.gitattributes

@@ -1,5 +1,9 @@
 * text=auto
 
+# Temporarily highlight luau as normal lua files
+# until we get native linguist support for Luau
+*.luau linguist-language=Lua
+
 # Ensure all lua files use LF
 *.lua  eol=lf
 *.luau eol=lf

.github/workflows/ci.yaml

@@ -23,8 +23,11 @@ jobs:
         with:
           components: rustfmt
 
+      - name: Install Just
+        uses: extractions/setup-just@v1
+
       - name: Install Tooling
-        uses: CompeyDev/setup-rokit@v0.1.2
+        uses: ok-nick/setup-aftman@v0.4.2
 
       - name: Check Formatting
         run: just fmt-check
@@ -37,8 +40,11 @@ jobs:
       - name: Checkout repository
         uses: actions/checkout@v4
 
+      - name: Install Just
+        uses: extractions/setup-just@v1
+
       - name: Install Tooling
-        uses: CompeyDev/setup-rokit@v0.1.2
+        uses: ok-nick/setup-aftman@v0.4.2
 
       - name: Analyze
         run: just analyze
@@ -82,20 +88,17 @@ jobs:
       - name: Build
         run: |
           cargo build \
-          --workspace \
           --locked --all-features \
           --target ${{ matrix.cargo-target }}
 
       - name: Lint
         run: |
           cargo clippy \
-          --workspace \
           --locked --all-features \
           --target ${{ matrix.cargo-target }}
 
       - name: Test
         run: |
           cargo test \
-          --lib --workspace \
           --locked --all-features \
           --target ${{ matrix.cargo-target }}

.github/workflows/publish.yaml

@@ -0,0 +1,24 @@
+name: Publish
+
+on:
+  push:
+    branches:
+      - "main"
+  workflow_dispatch:
+
+jobs:
+  publish:
+    name: Publish
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Publish to crates.io
+        uses: katyo/publish-crates@v2
+        with:
+          registry-token: ${{ secrets.CARGO_REGISTRY_TOKEN }}
+          ignore-unpublished-changes: true

.github/workflows/release.yaml

@@ -21,32 +21,14 @@ jobs:
         uses: actions/checkout@v4
 
       - name: Get version from manifest
-        uses: SebRollen/toml-action@v1.2.0
+        uses: SebRollen/toml-action@9062fbef52816d61278d24ce53c8070440e1e8dd
         id: get_version
         with:
-          file: crates/lune/Cargo.toml
+          file: Cargo.toml
           field: package.version
 
-  # dry-run:
-  #   name: Dry-run
-  #   needs: ["init"]
-  #   runs-on: ubuntu-latest
-  #   steps:
-  #     - name: Checkout repository
-  #       uses: actions/checkout@v4
-
-  #     - name: Install Rust
-  #       uses: dtolnay/rust-toolchain@stable
-
-  #     - name: Publish (dry-run)
-  #       uses: katyo/publish-crates@v2
-  #       with:
-  #         dry-run: true
-  #         check-repo: true
-  #         registry-token: ${{ secrets.CARGO_REGISTRY_TOKEN }}
-
   build:
-    needs: ["init"] # , "dry-run"]
+    needs: ["init"]
     strategy:
       fail-fast: false
       matrix:
@@ -88,7 +70,7 @@ jobs:
           targets: ${{ matrix.cargo-target }}
 
       - name: Install Just
-        uses: extractions/setup-just@v2
+        uses: extractions/setup-just@v1
 
       - name: Install build tooling (aarch64-unknown-linux-gnu)
         if: matrix.cargo-target == 'aarch64-unknown-linux-gnu'
@@ -104,24 +86,24 @@ jobs:
         run: just zip-release ${{ matrix.cargo-target }}
 
       - name: Upload release artifact
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
           name: ${{ matrix.artifact-name }}
           path: release.zip
 
-  release-github:
-    name: Release (GitHub)
+  release:
+    name: Release
     runs-on: ubuntu-latest
-    needs: ["init", "build"] # , "dry-run", "build"]
+    needs: ["init", "build"]
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
 
       - name: Install Just
-        uses: extractions/setup-just@v2
+        uses: extractions/setup-just@v1
 
       - name: Download releases
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v3
         with:
           path: ./releases
 
@@ -129,7 +111,7 @@ jobs:
         run: just unpack-releases "./releases"
 
       - name: Create release
-        uses: softprops/action-gh-release@v2
+        uses: softprops/action-gh-release@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
@@ -138,21 +120,3 @@ jobs:
           fail_on_unmatched_files: true
           files: ./releases/*.zip
           draft: true
-
-  # release-crates:
-  #   name: Release (crates.io)
-  #   runs-on: ubuntu-latest
-  #   needs: ["init", "dry-run", "build"]
-  #   steps:
-  #     - name: Checkout repository
-  #       uses: actions/checkout@v4
-
-  #     - name: Install Rust
-  #       uses: dtolnay/rust-toolchain@stable
-
-  #     - name: Publish crates
-  #       uses: katyo/publish-crates@v2
-  #       with:
-  #         dry-run: false
-  #         check-repo: true
-  #         registry-token: ${{ secrets.CARGO_REGISTRY_TOKEN }}

.lune/hello_lune.luau

@@ -129,7 +129,7 @@ end
 ]]
 
 print("Sending 4 pings to google 🌏")
-local result = process.exec("ping", {
+local result = process.spawn("ping", {
 	"google.com",
 	"-c 4",
 })

.lune/websocket_client.luau

@@ -28,8 +28,8 @@ end)
 
 for _ = 1, 5 do
 	local start = os.clock()
-	socket:send(tostring(1))
-	local response = socket:next()
+	socket.send(tostring(1))
+	local response = socket.next()
 	local elapsed = os.clock() - start
 	print(`Got response '{response}' in {elapsed * 1_000} milliseconds`)
 	task.wait(1 - elapsed)
@@ -38,7 +38,7 @@ end
 -- Everything went well, and we are done with the socket, so we can close it
 
 print("Closing web socket...")
-socket:close()
+socket.close()
 
 task.cancel(forceExit)
 print("Done! 🌙")

.lune/websocket_server.luau

@@ -15,9 +15,9 @@ local handle = net.serve(PORT, {
 	handleWebSocket = function(socket)
 		print("Got new web socket connection!")
 		repeat
-			local message = socket:next()
+			local message = socket.next()
 			if message ~= nil then
-				socket:send("Echo - " .. message)
+				socket.send("Echo - " .. message)
 			end
 		until message == nil
 		print("Web socket disconnected.")

CHANGELOG.md

@@ -8,218 +8,6 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## `0.9.0`
-
-### Breaking changes
-
-- Added two new process spawning functions - `process.create` and `process.exec`, removing the previous `process.spawn` API completely. ([#211])
-
-  To migrate from `process.spawn`, use the new `process.exec` API which retains the same behavior as the old function.
-
-  The new `process.create` function is a non-blocking process creation API and can be used to interactively
-  read and write stdio of the process.
-
-  ```lua
-  local child = process.create("program", {
-    "cli-argument",
-    "other-cli-argument"
-  })
-
-  -- Writing to stdin
-  child.stdin:write("Hello from Lune!")
-
-  -- Reading from stdout
-  local data = child.stdout:read()
-  print(buffer.tostring(data))
-  ```
-
-- WebSocket methods in `net.socket` and `net.serve` now use standard Lua method calling convention and colon syntax.
-  This means `socket.send(...)` is now `socket:send(...)`, `socket.close(...)` is now `socket:close(...)`, and so on.
-
-- `Runtime::run` now returns a more useful value instead of an `ExitCode` ([#178])
-
-### Changed
-
-- Documentation comments for several standard library properties have been improved ([#248], [#250])
-- Error messages no longer contain redundant or duplicate stack trace information
-
-[#178]: https://github.com/lune-org/lune/pull/178
-[#211]: https://github.com/lune-org/lune/pull/211
-[#248]: https://github.com/lune-org/lune/pull/248
-[#250]: https://github.com/lune-org/lune/pull/250
-
-## `0.8.9` - October 7th, 2024
-
-### Changed
-
-- Updated to Luau version `0.640`
-
-## `0.8.8` - August 22nd, 2024
-
-### Fixed
-
-- Fixed errors when deserializing `Lighting.AttributesSerialize` by updating `rbx-dom` dependencies ([#245])
-
-[#245]: https://github.com/lune-org/lune/pull/245
-
-## `0.8.7` - August 10th, 2024
-
-### Added
-
-- Added a compression level option to `serde.compress` ([#224])
-- Added missing vector methods to the `roblox` library ([#228])
-
-### Changed
-
-- Updated to Luau version `0.635`
-- Updated to rbx-dom database version `0.634`
-
-### Fixed
-
-- Fixed `fs.readDir` with trailing forward-slash on Windows ([#220])
-- Fixed `__type` and `__tostring` metamethods not always being respected when formatting tables
-
-[#220]: https://github.com/lune-org/lune/pull/220
-[#224]: https://github.com/lune-org/lune/pull/224
-[#228]: https://github.com/lune-org/lune/pull/228
-
-## `0.8.6` - June 23rd, 2024
-
-### Added
-
-- Added a builtin API for hashing and calculating HMACs as part of the `serde` library ([#193])
-
-  Basic usage:
-
-  ```lua
-  local serde = require("@lune/serde")
-  local hash = serde.hash("sha256", "a message to hash")
-  local hmac = serde.hmac("sha256", "a message to hash", "a secret string")
-
-  print(hash)
-  print(hmac)
-  ```
-
-  The returned hashes are sequences of lowercase hexadecimal digits. The following algorithms are supported:
-  `md5`, `sha1`, `sha224`, `sha256`, `sha384`, `sha512`, `sha3-224`, `sha3-256`, `sha3-384`, `sha3-512`, `blake3`
-
-- Added two new options to `luau.load`:
-
-  - `codegenEnabled` - whether or not codegen should be enabled for the loaded chunk.
-  - `injectGlobals` - whether or not to inject globals into a passed `environment`.
-
-  By default, globals are injected and codegen is disabled.
-  Check the documentation for the `luau` standard library for more information.
-
-- Implemented support for floor division operator / `__idiv` for the `Vector2` and `Vector3` types in the `roblox` standard library ([#196])
-- Fixed the `_VERSION` global containing an incorrect Lune version string.
-
-### Changed
-
-- Sandboxing and codegen in the Luau VM is now fully enabled, resulting in up to 2x or faster code execution.
-  This should not result in any behavior differences in Lune, but if it does, please open an issue.
-- Improved formatting of custom error objects (such as when `fs.readFile` returns an error) when printed or formatted using `stdio.format`.
-
-### Fixed
-
-- Fixed `__type` and `__tostring` metamethods on userdatas and tables not being respected when printed or formatted using `stdio.format`.
-
-[#193]: https://github.com/lune-org/lune/pull/193
-[#196]: https://github.com/lune-org/lune/pull/196
-
-## `0.8.5` - June 1st, 2024
-
-### Changed
-
-- Improved table pretty formatting when using `print`, `warn`, and `stdio.format`:
-
-  - Keys are sorted numerically / alphabetically when possible.
-  - Keys of different types are put in distinct sections for mixed tables.
-  - Tables that are arrays no longer display their keys.
-  - Empty tables are no longer spread across lines.
-
-## Fixed
-
-- Fixed formatted values in tables not being separated by newlines.
-- Fixed panicking (crashing) when using `process.spawn` with a program that does not exist.
-- Fixed `instance:SetAttribute("name", nil)` throwing an error and not removing the attribute.
-
-## `0.8.4` - May 12th, 2024
-
-### Added
-
-- Added a builtin API for regular expressions.
-
-  Example basic usage:
-
-  ```lua
-  local Regex = require("@lune/regex")
-
-  local re = Regex.new("hello")
-
-  if re:isMatch("hello, world!") then
-  	print("Matched!")
-  end
-
-  local caps = re:captures("hello, world! hello, again!")
-
-  print(#caps) -- 2
-  print(caps:get(1)) -- "hello"
-  print(caps:get(2)) -- "hello"
-  print(caps:get(3)) -- nil
-  ```
-
-  Check out the documentation for more details.
-
-- Added support for buffers as arguments in builtin APIs ([#148])
-
-  This includes APIs such as `fs.writeFile`, `serde.encode`, and more.
-
-- Added support for cross-compilation of standalone binaries ([#162])
-
-  You can now compile standalone binaries for other platforms by passing
-  an additional `target` argument to the `build` subcommand:
-
-  ```sh
-  lune build my-file.luau --output my-bin --target windows-x86_64
-  ```
-
-  Currently supported targets are the same as the ones included with each
-  release of Lune on GitHub. Check releases for a full list of targets.
-
-- Added `stdio.readToEnd()` for reading the entire stdin passed to Lune
-
-### Changed
-
-- Split the repository into modular crates instead of a monolith. ([#188])
-
-  If you previously depended on Lune as a crate, nothing about it has changed for version `0.8.4`, but now each individual sub-crate has also been published and is available for use:
-
-  - `lune` (old)
-  - `lune-utils`
-  - `lune-roblox`
-  - `lune-std-*` for every builtin library
-
-  When depending on the main `lune` crate, each builtin library also has a feature flag that can be toggled in the format `std-*`.
-
-  In general, this should mean that it is now much easier to make your own Lune builtin, publish your own flavor of a Lune CLI, or take advantage of all the work that has been done for Lune as a runtime when making your own Rust programs.
-
-- Changed the `User-Agent` header in `net.request` to be more descriptive ([#186])
-- Updated to Luau version `0.622`.
-
-### Fixed
-
-- Fixed not being able to decompress `lz4` format in high compression mode
-- Fixed stack overflow for tables with circular keys ([#183])
-- Fixed `net.serve` no longer accepting ipv6 addresses
-- Fixed headers in `net.serve` being raw bytes instead of strings
-
-[#148]: https://github.com/lune-org/lune/pull/148
-[#162]: https://github.com/lune-org/lune/pull/162
-[#183]: https://github.com/lune-org/lune/pull/183
-[#186]: https://github.com/lune-org/lune/pull/186
-[#188]: https://github.com/lune-org/lune/pull/188
-
 ## `0.8.3` - April 15th, 2024
 
 ### Fixed

Cargo.toml

@@ -1,22 +1,41 @@
-[workspace]
-resolver = "2"
-default-members = ["crates/lune"]
-members = [
-    "crates/lune",
-    "crates/lune-roblox",
-    "crates/lune-std",
-    "crates/lune-std-datetime",
-    "crates/lune-std-fs",
-    "crates/lune-std-luau",
-    "crates/lune-std-net",
-    "crates/lune-std-process",
-    "crates/lune-std-regex",
-    "crates/lune-std-roblox",
-    "crates/lune-std-serde",
-    "crates/lune-std-stdio",
-    "crates/lune-std-task",
-    "crates/lune-utils",
-    "crates/mlua-luau-scheduler",
+[package]
+name = "lune"
+version = "0.8.3"
+edition = "2021"
+license = "MPL-2.0"
+repository = "https://github.com/lune-org/lune"
+description = "A standalone Luau runtime"
+readme = "README.md"
+keywords = ["cli", "lua", "luau", "runtime"]
+categories = ["command-line-interface"]
+
+[[bin]]
+name = "lune"
+path = "src/main.rs"
+
+[lib]
+name = "lune"
+path = "src/lib.rs"
+
+[features]
+default = ["cli", "roblox"]
+cli = [
+    "dep:anyhow",
+    "dep:env_logger",
+    "dep:clap",
+    "dep:include_dir",
+    "dep:regex",
+    "dep:rustyline",
+]
+roblox = [
+    "dep:glam",
+    "dep:rand",
+    "dep:rbx_cookie",
+    "dep:rbx_binary",
+    "dep:rbx_dom_weak",
+    "dep:rbx_reflection",
+    "dep:rbx_reflection_database",
+    "dep:rbx_xml",
 ]
 
 # Profile for building the release binary, with the following options set:
@@ -34,31 +53,99 @@ opt-level = "z"
 strip = true
 lto = true
 
-# Lints for all crates in the workspace
+# All of the dependencies for Lune.
 #
-# 1. Error on all lints by default, then make cargo + clippy pedantic lints just warn
-# 2. Selectively allow some lints that are _too_ pedantic, such as:
-#    - Casts between number types
-#    - Module naming conventions
-#    - Imports and multiple dependency versions
-[workspace.lints.clippy]
-all = { level = "deny", priority = -3 }
-cargo = { level = "warn", priority = -2 }
-pedantic = { level = "warn", priority = -1 }
+# Dependencies are categorized as following:
+#
+# 1. General dependencies with no specific features set
+# 2. Large / core dependencies that have many different crates and / or features set
+# 3. Dependencies for specific features of Lune, eg. the CLI or massive Roblox builtin library
+#
+[dependencies]
+console = "0.15"
+directories = "5.0"
+futures-util = "0.3"
+once_cell = "1.17"
+thiserror = "1.0"
+async-trait = "0.1"
+dialoguer = "0.11"
+dunce = "1.0"
+lz4_flex = "0.11"
+path-clean = "1.0"
+pathdiff = "0.2"
+pin-project = "1.0"
+urlencoding = "2.1"
 
-cast_lossless = { level = "allow", priority = 1 }
-cast_possible_truncation = { level = "allow", priority = 1 }
-cast_possible_wrap = { level = "allow", priority = 1 }
-cast_precision_loss = { level = "allow", priority = 1 }
-cast_sign_loss = { level = "allow", priority = 1 }
+### RUNTIME
 
-similar_names = { level = "allow", priority = 1 }
-unnecessary_wraps = { level = "allow", priority = 1 }
-unnested_or_patterns = { level = "allow", priority = 1 }
-unreadable_literal = { level = "allow", priority = 1 }
+blocking = "1.5"
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+tokio = { version = "1.24", features = ["full", "tracing"] }
+os_str_bytes = { version = "7.0", features = ["conversions"] }
 
-multiple_crate_versions = { level = "allow", priority = 1 }
-module_inception = { level = "allow", priority = 1 }
-module_name_repetitions = { level = "allow", priority = 1 }
-needless_pass_by_value = { level = "allow", priority = 1 }
-wildcard_imports = { level = "allow", priority = 1 }
+mlua-luau-scheduler = { version = "0.0.2" }
+mlua = { version = "0.9.6", features = [
+    "luau",
+    "luau-jit",
+    "async",
+    "serialize",
+] }
+
+### SERDE
+
+async-compression = { version = "0.4", features = [
+    "tokio",
+    "brotli",
+    "deflate",
+    "gzip",
+    "zlib",
+] }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = { version = "1.0", features = ["preserve_order"] }
+serde_yaml = "0.9"
+toml = { version = "0.8", features = ["preserve_order"] }
+
+### NET
+
+hyper = { version = "1.1", features = ["full"] }
+hyper-util = { version = "0.1", features = ["full"] }
+http = "1.0"
+http-body-util = { version = "0.1" }
+hyper-tungstenite = { version = "0.13" }
+
+reqwest = { version = "0.11", default-features = false, features = [
+    "rustls-tls",
+] }
+
+tokio-tungstenite = { version = "0.21", features = ["rustls-tls-webpki-roots"] }
+
+### DATETIME
+chrono = "=0.4.34" # NOTE: 0.4.35 does not compile with chrono_lc
+chrono_lc = "0.1"
+
+### CLI
+
+anyhow = { optional = true, version = "1.0" }
+env_logger = { optional = true, version = "0.11" }
+itertools = "0.12"
+clap = { optional = true, version = "4.1", features = ["derive"] }
+include_dir = { optional = true, version = "0.7", features = ["glob"] }
+regex = { optional = true, version = "1.7", default-features = false, features = [
+    "std",
+    "unicode-perl",
+] }
+rustyline = { optional = true, version = "14.0" }
+
+### ROBLOX
+
+glam = { optional = true, version = "0.27" }
+rand = { optional = true, version = "0.8" }
+
+rbx_cookie = { optional = true, version = "0.1.4", default-features = false }
+
+rbx_binary = { optional = true, version = "0.7.3" }
+rbx_dom_weak = { optional = true, version = "2.6.0" }
+rbx_reflection = { optional = true, version = "4.4.0" }
+rbx_reflection_database = { optional = true, version = "0.2.9" }
+rbx_xml = { optional = true, version = "0.13.2" }

README.md

@@ -33,7 +33,7 @@ Lune provides fully asynchronous APIs wherever possible, and is built in Rust
 ## Features
 
 - 🌙 Strictly minimal but powerful interface that is easy to read and remember, just like Luau itself
-- 🧰 Fully featured APIs for the filesystem, networking, stdio, all included in the small (~5mb zipped) executable
+- 🧰 Fully featured APIs for the filesystem, networking, stdio, all included in the small (~5mb) executable
 - 📚 World-class documentation, on the web _or_ directly in your editor, no network connection necessary
 - 🏡 Familiar runtime environment for Roblox developers, with an included 1-to-1 task scheduler port
 - ✏️ Optional built-in library for manipulating Roblox place & model files, and their instances

aftman.toml

@@ -0,0 +1,4 @@
+[tools]
+luau-lsp = "JohnnyMorganz/luau-lsp@1.27.0"
+selene = "Kampfkarren/selene@0.26.1"
+stylua = "JohnnyMorganz/StyLua@0.19.1"

crates/lune-roblox/Cargo.toml

@@ -1,29 +0,0 @@
-[package]
-name = "lune-roblox"
-version = "0.1.4"
-edition = "2021"
-license = "MPL-2.0"
-repository = "https://github.com/lune-org/lune"
-description = "Roblox library for Lune"
-
-[lib]
-path = "src/lib.rs"
-
-[lints]
-workspace = true
-
-[dependencies]
-mlua = { version = "0.9.9", features = ["luau"] }
-
-glam = "0.27"
-rand = "0.8"
-thiserror = "1.0"
-once_cell = "1.17"
-
-rbx_binary = "1.0.0"
-rbx_dom_weak = "3.0.0"
-rbx_reflection = "5.0.0"
-rbx_reflection_database = "1.0.0"
-rbx_xml = "1.0.0"
-
-lune-utils = { version = "0.1.3", path = "../lune-utils" }

crates/lune-roblox/src/datatypes/types/content.rs

@@ -1,120 +0,0 @@
-use core::fmt;
-
-use mlua::prelude::*;
-use rbx_dom_weak::types::{Content as DomContent, ContentType};
-
-use lune_utils::TableBuilder;
-
-use crate::{exports::LuaExportsTable, instance::Instance};
-
-use super::{super::*, EnumItem};
-
-/**
-    An implementation of the [Content](https://create.roblox.com/docs/reference/engine/datatypes/Content) Roblox datatype.
-
-    This implements all documented properties, methods & constructors of the Content type as of April 2025.
-*/
-#[derive(Debug, Clone, PartialEq)]
-pub struct Content(ContentType);
-
-impl LuaExportsTable<'_> for Content {
-    const EXPORT_NAME: &'static str = "Content";
-
-    fn create_exports_table(lua: &'_ Lua) -> LuaResult<LuaTable<'_>> {
-        let from_uri = |_, uri: String| Ok(Self(ContentType::Uri(uri)));
-
-        let from_object = |_, obj: LuaUserDataRef<Instance>| {
-            let database = rbx_reflection_database::get();
-            let instance_descriptor = database
-                .classes
-                .get("Instance")
-                .expect("the reflection database should always have Instance in it");
-            let param_descriptor = database.classes.get(obj.get_class_name()).expect(
-                "you should not be able to construct an Instance that is not known to Lune",
-            );
-            if database.has_superclass(param_descriptor, instance_descriptor) {
-                Err(LuaError::runtime("the provided object is a descendant class of 'Instance', expected one that was only an 'Object'"))
-            } else {
-                Ok(Content(ContentType::Object(obj.dom_ref)))
-            }
-        };
-
-        TableBuilder::new(lua)?
-            .with_value("none", Content(ContentType::None))?
-            .with_function("fromUri", from_uri)?
-            .with_function("fromObject", from_object)?
-            .build_readonly()
-    }
-}
-
-impl LuaUserData for Content {
-    fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) {
-        fields.add_field_method_get("SourceType", |_, this| {
-            let variant_name = match &this.0 {
-                ContentType::None => "None",
-                ContentType::Uri(_) => "Uri",
-                ContentType::Object(_) => "Object",
-                other => {
-                    return Err(LuaError::runtime(format!(
-                        "cannot get SourceType: unknown ContentType variant '{other:?}'"
-                    )))
-                }
-            };
-            Ok(EnumItem::from_enum_name_and_name(
-                "ContentSourceType",
-                variant_name,
-            ))
-        });
-        fields.add_field_method_get("Uri", |_, this| {
-            if let ContentType::Uri(uri) = &this.0 {
-                Ok(Some(uri.to_owned()))
-            } else {
-                Ok(None)
-            }
-        });
-        fields.add_field_method_get("Object", |_, this| {
-            if let ContentType::Object(referent) = &this.0 {
-                Ok(Instance::new_opt(*referent))
-            } else {
-                Ok(None)
-            }
-        });
-    }
-
-    fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) {
-        methods.add_meta_method(LuaMetaMethod::Eq, userdata_impl_eq);
-        methods.add_meta_method(LuaMetaMethod::ToString, userdata_impl_to_string);
-    }
-}
-
-impl fmt::Display for Content {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        // Regardless of the actual content of the Content, Roblox just emits
-        // `Content` when casting it to a string. We do not do that.
-        write!(f, "Content(")?;
-        match &self.0 {
-            ContentType::None => write!(f, "None")?,
-            ContentType::Uri(uri) => write!(f, "Uri={uri}")?,
-            ContentType::Object(_) => write!(f, "Object")?,
-            other => write!(f, "UnknownType({other:?})")?,
-        }
-        write!(f, ")")
-    }
-}
-
-impl From<DomContent> for Content {
-    fn from(value: DomContent) -> Self {
-        Self(value.value().clone())
-    }
-}
-
-impl From<Content> for DomContent {
-    fn from(value: Content) -> Self {
-        match value.0 {
-            ContentType::None => Self::none(),
-            ContentType::Uri(uri) => Self::from_uri(uri),
-            ContentType::Object(referent) => Self::from_referent(referent),
-            other => unimplemented!("unknown variant of ContentType: {other:?}"),
-        }
-    }
-}

crates/lune-std-datetime/Cargo.toml

@@ -1,22 +0,0 @@
-[package]
-name = "lune-std-datetime"
-version = "0.1.3"
-edition = "2021"
-license = "MPL-2.0"
-repository = "https://github.com/lune-org/lune"
-description = "Lune standard library - DateTime"
-
-[lib]
-path = "src/lib.rs"
-
-[lints]
-workspace = true
-
-[dependencies]
-mlua = { version = "0.9.9", features = ["luau"] }
-
-thiserror = "1.0"
-chrono = "0.4.38"
-chrono_lc = "0.1.6"
-
-lune-utils = { version = "0.1.3", path = "../lune-utils" }

crates/lune-std-datetime/src/lib.rs

@@ -1,36 +0,0 @@
-#![allow(clippy::cargo_common_metadata)]
-
-use mlua::prelude::*;
-
-use lune_utils::TableBuilder;
-
-mod date_time;
-mod result;
-mod values;
-
-pub use self::date_time::DateTime;
-
-/**
-    Creates the `datetime` standard library module.
-
-    # Errors
-
-    Errors when out of memory.
-*/
-pub fn module(lua: &Lua) -> LuaResult<LuaTable> {
-    TableBuilder::new(lua)?
-        .with_function("fromIsoDate", |_, iso_date: String| {
-            Ok(DateTime::from_iso_date(iso_date)?)
-        })?
-        .with_function("fromLocalTime", |_, values| {
-            Ok(DateTime::from_local_time(&values)?)
-        })?
-        .with_function("fromUniversalTime", |_, values| {
-            Ok(DateTime::from_universal_time(&values)?)
-        })?
-        .with_function("fromUnixTimestamp", |_, timestamp| {
-            Ok(DateTime::from_unix_timestamp_float(timestamp)?)
-        })?
-        .with_function("now", |_, ()| Ok(DateTime::now()))?
-        .build_readonly()
-}

crates/lune-std-fs/Cargo.toml

@@ -1,23 +0,0 @@
-[package]
-name = "lune-std-fs"
-version = "0.1.2"
-edition = "2021"
-license = "MPL-2.0"
-repository = "https://github.com/lune-org/lune"
-description = "Lune standard library - FS"
-
-[lib]
-path = "src/lib.rs"
-
-[lints]
-workspace = true
-
-[dependencies]
-mlua = { version = "0.9.9", features = ["luau"] }
-
-bstr = "1.9"
-
-tokio = { version = "1", default-features = false, features = ["fs"] }
-
-lune-utils = { version = "0.1.3", path = "../lune-utils" }
-lune-std-datetime = { version = "0.1.2", path = "../lune-std-datetime" }

crates/lune-std-luau/Cargo.toml

@@ -1,18 +0,0 @@
-[package]
-name = "lune-std-luau"
-version = "0.1.2"
-edition = "2021"
-license = "MPL-2.0"
-repository = "https://github.com/lune-org/lune"
-description = "Lune standard library - Luau"
-
-[lib]
-path = "src/lib.rs"
-
-[lints]
-workspace = true
-
-[dependencies]
-mlua = { version = "0.9.9", features = ["luau", "luau-jit"] }
-
-lune-utils = { version = "0.1.3", path = "../lune-utils" }

crates/lune-std-luau/src/lib.rs

@@ -1,90 +0,0 @@
-#![allow(clippy::cargo_common_metadata)]
-
-use mlua::prelude::*;
-
-use lune_utils::{jit::JitStatus, TableBuilder};
-
-mod options;
-
-use self::options::{LuauCompileOptions, LuauLoadOptions};
-
-const BYTECODE_ERROR_BYTE: u8 = 0;
-
-/**
-    Creates the `luau` standard library module.
-
-    # Errors
-
-    Errors when out of memory.
-*/
-pub fn module(lua: &Lua) -> LuaResult<LuaTable> {
-    TableBuilder::new(lua)?
-        .with_function("compile", compile_source)?
-        .with_function("load", load_source)?
-        .build_readonly()
-}
-
-fn compile_source<'lua>(
-    lua: &'lua Lua,
-    (source, options): (LuaString<'lua>, LuauCompileOptions),
-) -> LuaResult<LuaString<'lua>> {
-    let bytecode = options.into_compiler().compile(source);
-
-    match bytecode.first() {
-        Some(&BYTECODE_ERROR_BYTE) => Err(LuaError::RuntimeError(
-            String::from_utf8_lossy(&bytecode).into_owned(),
-        )),
-        Some(_) => lua.create_string(bytecode),
-        None => panic!("Compiling resulted in empty bytecode"),
-    }
-}
-
-fn load_source<'lua>(
-    lua: &'lua Lua,
-    (source, options): (LuaString<'lua>, LuauLoadOptions),
-) -> LuaResult<LuaFunction<'lua>> {
-    let mut chunk = lua.load(source.as_bytes()).set_name(options.debug_name);
-    let env_changed = options.environment.is_some();
-
-    if let Some(custom_environment) = options.environment {
-        let environment = lua.create_table()?;
-
-        // Inject all globals into the environment
-        if options.inject_globals {
-            for pair in lua.globals().pairs() {
-                let (key, value): (LuaValue, LuaValue) = pair?;
-                environment.set(key, value)?;
-            }
-
-            if let Some(global_metatable) = lua.globals().get_metatable() {
-                environment.set_metatable(Some(global_metatable));
-            }
-        } else if let Some(custom_metatable) = custom_environment.get_metatable() {
-            // Since we don't need to set the global metatable,
-            // we can just set a custom metatable if it exists
-            environment.set_metatable(Some(custom_metatable));
-        }
-
-        // Inject the custom environment
-        for pair in custom_environment.pairs() {
-            let (key, value): (LuaValue, LuaValue) = pair?;
-            environment.set(key, value)?;
-        }
-
-        chunk = chunk.set_environment(environment);
-    }
-
-    // Enable JIT if codegen is enabled and the environment hasn't
-    // changed, otherwise disable JIT since it'll fall back anyways
-    lua.enable_jit(options.codegen_enabled && !env_changed);
-    let function = chunk.into_function()?;
-    lua.enable_jit(
-        lua.app_data_ref::<JitStatus>()
-            .ok_or(LuaError::runtime(
-                "Failed to get current JitStatus ref from AppData",
-            ))?
-            .enabled(),
-    );
-
-    Ok(function)
-}

crates/lune-std-net/Cargo.toml

@@ -1,39 +0,0 @@
-[package]
-name = "lune-std-net"
-version = "0.1.2"
-edition = "2021"
-license = "MPL-2.0"
-repository = "https://github.com/lune-org/lune"
-description = "Lune standard library - Net"
-
-[lib]
-path = "src/lib.rs"
-
-[lints]
-workspace = true
-
-[dependencies]
-mlua = { version = "0.9.9", features = ["luau"] }
-mlua-luau-scheduler = { version = "0.0.2", path = "../mlua-luau-scheduler" }
-
-bstr = "1.9"
-futures-util = "0.3"
-hyper = { version = "1.1", features = ["full"] }
-hyper-util = { version = "0.1", features = ["full"] }
-http = "1.0"
-http-body-util = { version = "0.1" }
-hyper-tungstenite = { version = "0.13" }
-reqwest = { version = "0.11", default-features = false, features = [
-    "rustls-tls",
-] }
-tokio-tungstenite = { version = "0.21", features = ["rustls-tls-webpki-roots"] }
-urlencoding = "2.1"
-
-tokio = { version = "1", default-features = false, features = [
-    "sync",
-    "net",
-    "macros",
-] }
-
-lune-utils = { version = "0.1.3", path = "../lune-utils" }
-lune-std-serde = { version = "0.1.2", path = "../lune-std-serde" }

crates/lune-std-process/Cargo.toml

@@ -1,34 +0,0 @@
-[package]
-name = "lune-std-process"
-version = "0.1.3"
-edition = "2021"
-license = "MPL-2.0"
-repository = "https://github.com/lune-org/lune"
-description = "Lune standard library - Process"
-
-[lib]
-path = "src/lib.rs"
-
-[lints]
-workspace = true
-
-[dependencies]
-mlua = { version = "0.9.9", features = ["luau"] }
-mlua-luau-scheduler = { version = "0.0.2", path = "../mlua-luau-scheduler" }
-
-directories = "5.0"
-pin-project = "1.0"
-os_str_bytes = { version = "7.0", features = ["conversions"] }
-
-bstr = "1.9"
-bytes = "1.6.0"
-
-tokio = { version = "1", default-features = false, features = [
-    "io-std",
-    "io-util",
-    "process",
-    "rt",
-    "sync",
-] }
-
-lune-utils = { version = "0.1.3", path = "../lune-utils" }

crates/lune-std-process/src/lib.rs

@@ -1,289 +0,0 @@
-#![allow(clippy::cargo_common_metadata)]
-
-use std::{
-    cell::RefCell,
-    env::{
-        self,
-        consts::{ARCH, OS},
-    },
-    path::MAIN_SEPARATOR,
-    process::Stdio,
-    rc::Rc,
-    sync::Arc,
-};
-
-use mlua::prelude::*;
-
-use lune_utils::TableBuilder;
-use mlua_luau_scheduler::{Functions, LuaSpawnExt};
-use options::ProcessSpawnOptionsStdio;
-use os_str_bytes::RawOsString;
-use stream::{ChildProcessReader, ChildProcessWriter};
-use tokio::{io::AsyncWriteExt, process::Child, sync::RwLock};
-
-mod options;
-mod stream;
-mod tee_writer;
-mod wait_for_child;
-
-use self::options::ProcessSpawnOptions;
-use self::wait_for_child::wait_for_child;
-
-use lune_utils::path::get_current_dir;
-
-/**
-    Creates the `process` standard library module.
-
-    # Errors
-
-    Errors when out of memory.
-*/
-#[allow(clippy::missing_panics_doc)]
-pub fn module(lua: &Lua) -> LuaResult<LuaTable> {
-    let mut cwd_str = get_current_dir()
-        .to_str()
-        .expect("cwd should be valid UTF-8")
-        .to_string();
-    if !cwd_str.ends_with(MAIN_SEPARATOR) {
-        cwd_str.push(MAIN_SEPARATOR);
-    }
-    // Create constants for OS & processor architecture
-    let os = lua.create_string(OS.to_lowercase())?;
-    let arch = lua.create_string(ARCH.to_lowercase())?;
-    let endianness = lua.create_string(if cfg!(target_endian = "big") {
-        "big"
-    } else {
-        "little"
-    })?;
-    // Create readonly args array
-    let args_vec = lua
-        .app_data_ref::<Vec<String>>()
-        .ok_or_else(|| LuaError::runtime("Missing args vec in Lua app data"))?
-        .clone();
-    let args_tab = TableBuilder::new(lua)?
-        .with_sequential_values(args_vec)?
-        .build_readonly()?;
-    // Create proxied table for env that gets & sets real env vars
-    let env_tab = TableBuilder::new(lua)?
-        .with_metatable(
-            TableBuilder::new(lua)?
-                .with_function(LuaMetaMethod::Index.name(), process_env_get)?
-                .with_function(LuaMetaMethod::NewIndex.name(), process_env_set)?
-                .with_function(LuaMetaMethod::Iter.name(), process_env_iter)?
-                .build_readonly()?,
-        )?
-        .build_readonly()?;
-    // Create our process exit function, the scheduler crate provides this
-    let fns = Functions::new(lua)?;
-    let process_exit = fns.exit;
-    // Create the full process table
-    TableBuilder::new(lua)?
-        .with_value("os", os)?
-        .with_value("arch", arch)?
-        .with_value("endianness", endianness)?
-        .with_value("args", args_tab)?
-        .with_value("cwd", cwd_str)?
-        .with_value("env", env_tab)?
-        .with_value("exit", process_exit)?
-        .with_async_function("exec", process_exec)?
-        .with_function("create", process_create)?
-        .build_readonly()
-}
-
-fn process_env_get<'lua>(
-    lua: &'lua Lua,
-    (_, key): (LuaValue<'lua>, String),
-) -> LuaResult<LuaValue<'lua>> {
-    match env::var_os(key) {
-        Some(value) => {
-            let raw_value = RawOsString::new(value);
-            Ok(LuaValue::String(
-                lua.create_string(raw_value.to_raw_bytes())?,
-            ))
-        }
-        None => Ok(LuaValue::Nil),
-    }
-}
-
-fn process_env_set<'lua>(
-    _: &'lua Lua,
-    (_, key, value): (LuaValue<'lua>, String, Option<String>),
-) -> LuaResult<()> {
-    // Make sure key is valid, otherwise set_var will panic
-    if key.is_empty() {
-        Err(LuaError::RuntimeError("Key must not be empty".to_string()))
-    } else if key.contains('=') {
-        Err(LuaError::RuntimeError(
-            "Key must not contain the equals character '='".to_string(),
-        ))
-    } else if key.contains('\0') {
-        Err(LuaError::RuntimeError(
-            "Key must not contain the NUL character".to_string(),
-        ))
-    } else if let Some(value) = value {
-        // Make sure value is valid, otherwise set_var will panic
-        if value.contains('\0') {
-            Err(LuaError::RuntimeError(
-                "Value must not contain the NUL character".to_string(),
-            ))
-        } else {
-            env::set_var(&key, &value);
-            Ok(())
-        }
-    } else {
-        env::remove_var(&key);
-        Ok(())
-    }
-}
-
-fn process_env_iter<'lua>(
-    lua: &'lua Lua,
-    (_, ()): (LuaValue<'lua>, ()),
-) -> LuaResult<LuaFunction<'lua>> {
-    let mut vars = env::vars_os().collect::<Vec<_>>().into_iter();
-    lua.create_function_mut(move |lua, (): ()| match vars.next() {
-        Some((key, value)) => {
-            let raw_key = RawOsString::new(key);
-            let raw_value = RawOsString::new(value);
-            Ok((
-                LuaValue::String(lua.create_string(raw_key.to_raw_bytes())?),
-                LuaValue::String(lua.create_string(raw_value.to_raw_bytes())?),
-            ))
-        }
-        None => Ok((LuaValue::Nil, LuaValue::Nil)),
-    })
-}
-
-async fn process_exec(
-    lua: &Lua,
-    (program, args, options): (String, Option<Vec<String>>, ProcessSpawnOptions),
-) -> LuaResult<LuaTable> {
-    let res = lua
-        .spawn(async move {
-            let cmd = spawn_command_with_stdin(program, args, options.clone()).await?;
-            wait_for_child(cmd, options.stdio.stdout, options.stdio.stderr).await
-        })
-        .await?;
-
-    /*
-        NOTE: If an exit code was not given by the child process,
-        we default to 1 if it yielded any error output, otherwise 0
-
-        An exit code may be missing if the process was terminated by
-        some external signal, which is the only time we use this default
-    */
-    let code = res
-        .status
-        .code()
-        .unwrap_or(i32::from(!res.stderr.is_empty()));
-
-    // Construct and return a readonly lua table with results
-    TableBuilder::new(lua)?
-        .with_value("ok", code == 0)?
-        .with_value("code", code)?
-        .with_value("stdout", lua.create_string(&res.stdout)?)?
-        .with_value("stderr", lua.create_string(&res.stderr)?)?
-        .build_readonly()
-}
-
-#[allow(clippy::await_holding_refcell_ref)]
-fn process_create(
-    lua: &Lua,
-    (program, args, options): (String, Option<Vec<String>>, ProcessSpawnOptions),
-) -> LuaResult<LuaTable> {
-    // We do not want the user to provide stdio options for process.create,
-    // so we reset the options, regardless of what the user provides us
-    let mut spawn_options = options.clone();
-    spawn_options.stdio = ProcessSpawnOptionsStdio::default();
-
-    let (code_tx, code_rx) = tokio::sync::broadcast::channel(4);
-    let code_rx_rc = Rc::new(RefCell::new(code_rx));
-
-    let child = spawn_command(program, args, spawn_options)?;
-
-    let child_arc = Arc::new(RwLock::new(child));
-
-    let child_arc_clone = Arc::clone(&child_arc);
-    let mut child_lock = tokio::task::block_in_place(|| child_arc_clone.blocking_write());
-
-    let stdin = child_lock.stdin.take().unwrap();
-    let stdout = child_lock.stdout.take().unwrap();
-    let stderr = child_lock.stderr.take().unwrap();
-
-    let child_arc_inner = Arc::clone(&child_arc);
-
-    // Spawn a background task to wait for the child to exit and send the exit code
-    let status_handle = tokio::spawn(async move {
-        let res = child_arc_inner.write().await.wait().await;
-
-        if let Ok(output) = res {
-            let code = output.code().unwrap_or_default();
-
-            code_tx
-                .send(code)
-                .expect("ExitCode receiver was unexpectedly dropped");
-        }
-    });
-
-    TableBuilder::new(lua)?
-        .with_value("stdout", ChildProcessReader(stdout))?
-        .with_value("stderr", ChildProcessReader(stderr))?
-        .with_value("stdin", ChildProcessWriter(stdin))?
-        .with_async_function("kill", move |_, ()| {
-            // First, stop the status task so the RwLock is dropped
-            status_handle.abort();
-            let child_arc_clone = Arc::clone(&child_arc);
-
-            // Then get another RwLock to write to the child process and kill it
-            async move { Ok(child_arc_clone.write().await.kill().await?) }
-        })?
-        .with_async_function("status", move |lua, ()| {
-            let code_rx_rc_clone = Rc::clone(&code_rx_rc);
-            async move {
-                // Exit code of 9 corresponds to SIGKILL, which should be the only case where
-                // the receiver gets suddenly dropped
-                let code = code_rx_rc_clone.borrow_mut().recv().await.unwrap_or(9);
-
-                TableBuilder::new(lua)?
-                    .with_value("code", code)?
-                    .with_value("ok", code == 0)?
-                    .build_readonly()
-            }
-        })?
-        .build_readonly()
-}
-
-async fn spawn_command_with_stdin(
-    program: String,
-    args: Option<Vec<String>>,
-    mut options: ProcessSpawnOptions,
-) -> LuaResult<Child> {
-    let stdin = options.stdio.stdin.take();
-
-    let mut child = spawn_command(program, args, options)?;
-
-    if let Some(stdin) = stdin {
-        let mut child_stdin = child.stdin.take().unwrap();
-        child_stdin.write_all(&stdin).await.into_lua_err()?;
-    }
-
-    Ok(child)
-}
-
-fn spawn_command(
-    program: String,
-    args: Option<Vec<String>>,
-    options: ProcessSpawnOptions,
-) -> LuaResult<Child> {
-    let stdout = options.stdio.stdout;
-    let stderr = options.stdio.stderr;
-
-    let child = options
-        .into_command(program, args)
-        .stdin(Stdio::piped())
-        .stdout(stdout.as_stdio())
-        .stderr(stderr.as_stdio())
-        .spawn()?;
-
-    Ok(child)
-}

crates/lune-std-process/src/stream.rs

@@ -1,58 +0,0 @@
-use bstr::BString;
-use bytes::BytesMut;
-use mlua::prelude::*;
-use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
-
-const CHUNK_SIZE: usize = 8;
-
-#[derive(Debug, Clone)]
-pub struct ChildProcessReader<R: AsyncRead>(pub R);
-#[derive(Debug, Clone)]
-pub struct ChildProcessWriter<W: AsyncWrite>(pub W);
-
-impl<R: AsyncRead + Unpin> ChildProcessReader<R> {
-    pub async fn read(&mut self, chunk_size: Option<usize>) -> LuaResult<Vec<u8>> {
-        let mut buf = BytesMut::with_capacity(chunk_size.unwrap_or(CHUNK_SIZE));
-        self.0.read_buf(&mut buf).await?;
-
-        Ok(buf.to_vec())
-    }
-
-    pub async fn read_to_end(&mut self) -> LuaResult<Vec<u8>> {
-        let mut buf = vec![];
-        self.0.read_to_end(&mut buf).await?;
-
-        Ok(buf)
-    }
-}
-
-impl<R: AsyncRead + Unpin + 'static> LuaUserData for ChildProcessReader<R> {
-    fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) {
-        methods.add_async_method_mut("read", |lua, this, chunk_size: Option<usize>| async move {
-            let buf = this.read(chunk_size).await?;
-
-            if buf.is_empty() {
-                return Ok(LuaValue::Nil);
-            }
-
-            Ok(LuaValue::String(lua.create_string(buf)?))
-        });
-
-        methods.add_async_method_mut("readToEnd", |lua, this, ()| async {
-            Ok(lua.create_string(this.read_to_end().await?))
-        });
-    }
-}
-
-impl<W: AsyncWrite + Unpin> ChildProcessWriter<W> {
-    pub async fn write(&mut self, data: BString) -> LuaResult<()> {
-        self.0.write_all(data.as_ref()).await?;
-        Ok(())
-    }
-}
-
-impl<W: AsyncWrite + Unpin + 'static> LuaUserData for ChildProcessWriter<W> {
-    fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) {
-        methods.add_async_method_mut("write", |_, this, data| async { this.write(data).await });
-    }
-}

crates/lune-std-regex/Cargo.toml

@@ -1,21 +0,0 @@
-[package]
-name = "lune-std-regex"
-version = "0.1.2"
-edition = "2021"
-license = "MPL-2.0"
-repository = "https://github.com/lune-org/lune"
-description = "Lune standard library - RegEx"
-
-[lib]
-path = "src/lib.rs"
-
-[lints]
-workspace = true
-
-[dependencies]
-mlua = { version = "0.9.9", features = ["luau"] }
-
-regex = "1.10"
-self_cell = "1.0"
-
-lune-utils = { version = "0.1.3", path = "../lune-utils" }

crates/lune-std-regex/src/captures.rs

@@ -1,91 +0,0 @@
-use std::sync::Arc;
-
-use mlua::prelude::*;
-use regex::{Captures, Regex};
-use self_cell::self_cell;
-
-use super::matches::LuaMatch;
-
-type OptionalCaptures<'a> = Option<Captures<'a>>;
-
-self_cell! {
-    struct LuaCapturesInner {
-        owner: Arc<String>,
-        #[covariant]
-        dependent: OptionalCaptures,
-    }
-}
-
-/**
-    A wrapper over the `regex::Captures` struct that can be used from Lua.
-*/
-pub struct LuaCaptures {
-    inner: LuaCapturesInner,
-}
-
-impl LuaCaptures {
-    /**
-        Create a new `LuaCaptures` instance from a `Regex` pattern and a `String` text.
-
-        Returns `Some(_)` if captures were found, `None` if no captures were found.
-    */
-    pub fn new(pattern: &Regex, text: String) -> Option<Self> {
-        let inner =
-            LuaCapturesInner::new(Arc::from(text), |owned| pattern.captures(owned.as_str()));
-        if inner.borrow_dependent().is_some() {
-            Some(Self { inner })
-        } else {
-            None
-        }
-    }
-
-    fn captures(&self) -> &Captures {
-        self.inner
-            .borrow_dependent()
-            .as_ref()
-            .expect("None captures should not be used")
-    }
-
-    fn num_captures(&self) -> usize {
-        // NOTE: Here we exclude the match for the entire regex
-        // pattern, only counting the named and numbered captures
-        self.captures().len() - 1
-    }
-
-    fn text(&self) -> Arc<String> {
-        Arc::clone(self.inner.borrow_owner())
-    }
-}
-
-impl LuaUserData for LuaCaptures {
-    fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) {
-        methods.add_method("get", |_, this, index: usize| {
-            Ok(this
-                .captures()
-                .get(index)
-                .map(|m| LuaMatch::new(this.text(), m)))
-        });
-
-        methods.add_method("group", |_, this, group: String| {
-            Ok(this
-                .captures()
-                .name(&group)
-                .map(|m| LuaMatch::new(this.text(), m)))
-        });
-
-        methods.add_method("format", |_, this, format: String| {
-            let mut new = String::new();
-            this.captures().expand(&format, &mut new);
-            Ok(new)
-        });
-
-        methods.add_meta_method(LuaMetaMethod::Len, |_, this, ()| Ok(this.num_captures()));
-        methods.add_meta_method(LuaMetaMethod::ToString, |_, this, ()| {
-            Ok(format!("{}", this.num_captures()))
-        });
-    }
-
-    fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) {
-        fields.add_meta_field(LuaMetaMethod::Type, "RegexCaptures");
-    }
-}

crates/lune-std-regex/src/lib.rs

@@ -1,28 +0,0 @@
-#![allow(clippy::cargo_common_metadata)]
-
-use mlua::prelude::*;
-
-use lune_utils::TableBuilder;
-
-mod captures;
-mod matches;
-mod regex;
-
-use self::regex::LuaRegex;
-
-/**
-    Creates the `regex` standard library module.
-
-    # Errors
-
-    Errors when out of memory.
-*/
-pub fn module(lua: &Lua) -> LuaResult<LuaTable> {
-    TableBuilder::new(lua)?
-        .with_function("new", new_regex)?
-        .build_readonly()
-}
-
-fn new_regex(_: &Lua, pattern: String) -> LuaResult<LuaRegex> {
-    LuaRegex::new(pattern)
-}

crates/lune-std-regex/src/matches.rs

@@ -1,53 +0,0 @@
-use std::{ops::Range, sync::Arc};
-
-use mlua::prelude::*;
-use regex::Match;
-
-/**
-    A wrapper over the `regex::Match` struct that can be used from Lua.
-*/
-pub struct LuaMatch {
-    text: Arc<String>,
-    start: usize,
-    end: usize,
-}
-
-impl LuaMatch {
-    /**
-        Create a new `LuaMatch` instance from a `String` text and a `regex::Match`.
-    */
-    pub fn new(text: Arc<String>, matched: Match) -> Self {
-        Self {
-            text,
-            start: matched.start(),
-            end: matched.end(),
-        }
-    }
-
-    fn range(&self) -> Range<usize> {
-        self.start..self.end
-    }
-
-    fn slice(&self) -> &str {
-        &self.text[self.range()]
-    }
-}
-
-impl LuaUserData for LuaMatch {
-    fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) {
-        // NOTE: Strings are 0 based in Rust but 1 based in Luau, and end of range in Rust is exclusive
-        fields.add_field_method_get("start", |_, this| Ok(this.start.saturating_add(1)));
-        fields.add_field_method_get("finish", |_, this| Ok(this.end));
-        fields.add_field_method_get("len", |_, this| Ok(this.range().len()));
-        fields.add_field_method_get("text", |_, this| Ok(this.slice().to_string()));
-
-        fields.add_meta_field(LuaMetaMethod::Type, "RegexMatch");
-    }
-
-    fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) {
-        methods.add_meta_method(LuaMetaMethod::Len, |_, this, ()| Ok(this.range().len()));
-        methods.add_meta_method(LuaMetaMethod::ToString, |_, this, ()| {
-            Ok(this.slice().to_string())
-        });
-    }
-}

crates/lune-std-regex/src/regex.rs

@@ -1,76 +0,0 @@
-use std::sync::Arc;
-
-use mlua::prelude::*;
-use regex::Regex;
-
-use super::{captures::LuaCaptures, matches::LuaMatch};
-
-/**
-    A wrapper over the `regex::Regex` struct that can be used from Lua.
-*/
-#[derive(Debug, Clone)]
-pub struct LuaRegex {
-    inner: Regex,
-}
-
-impl LuaRegex {
-    /**
-        Create a new `LuaRegex` instance from a `String` pattern.
-    */
-    pub fn new(pattern: String) -> LuaResult<Self> {
-        Regex::new(&pattern)
-            .map(|inner| Self { inner })
-            .map_err(LuaError::external)
-    }
-}
-
-impl LuaUserData for LuaRegex {
-    fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) {
-        methods.add_method("isMatch", |_, this, text: String| {
-            Ok(this.inner.is_match(&text))
-        });
-
-        methods.add_method("find", |_, this, text: String| {
-            let arc = Arc::new(text);
-            Ok(this
-                .inner
-                .find(&arc)
-                .map(|m| LuaMatch::new(Arc::clone(&arc), m)))
-        });
-
-        methods.add_method("captures", |_, this, text: String| {
-            Ok(LuaCaptures::new(&this.inner, text))
-        });
-
-        methods.add_method("split", |_, this, text: String| {
-            Ok(this
-                .inner
-                .split(&text)
-                .map(ToString::to_string)
-                .collect::<Vec<_>>())
-        });
-
-        // TODO: Determine whether it's desirable and / or feasible to support
-        // using a function or table for `replace` like in the lua string library
-        methods.add_method(
-            "replace",
-            |_, this, (haystack, replacer): (String, String)| {
-                Ok(this.inner.replace(&haystack, replacer).to_string())
-            },
-        );
-        methods.add_method(
-            "replaceAll",
-            |_, this, (haystack, replacer): (String, String)| {
-                Ok(this.inner.replace_all(&haystack, replacer).to_string())
-            },
-        );
-
-        methods.add_meta_method(LuaMetaMethod::ToString, |_, this, ()| {
-            Ok(this.inner.as_str().to_string())
-        });
-    }
-
-    fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) {
-        fields.add_meta_field(LuaMetaMethod::Type, "Regex");
-    }
-}

crates/lune-std-roblox/Cargo.toml

@@ -1,24 +0,0 @@
-[package]
-name = "lune-std-roblox"
-version = "0.1.4"
-edition = "2021"
-license = "MPL-2.0"
-repository = "https://github.com/lune-org/lune"
-description = "Lune standard library - Roblox"
-
-[lib]
-path = "src/lib.rs"
-
-[lints]
-workspace = true
-
-[dependencies]
-mlua = { version = "0.9.9", features = ["luau"] }
-mlua-luau-scheduler = { version = "0.0.2", path = "../mlua-luau-scheduler" }
-
-once_cell = "1.17"
-rbx_cookie = { version = "0.1.4", default-features = false }
-roblox_install = "1.0.0"
-
-lune-utils = { version = "0.1.3", path = "../lune-utils" }
-lune-roblox = { version = "0.1.4", path = "../lune-roblox" }

crates/lune-std-serde/Cargo.toml

@@ -1,47 +0,0 @@
-[package]
-name = "lune-std-serde"
-version = "0.1.2"
-edition = "2021"
-license = "MPL-2.0"
-repository = "https://github.com/lune-org/lune"
-description = "Lune standard library - Serde"
-
-[lib]
-path = "src/lib.rs"
-
-[lints]
-workspace = true
-
-[dependencies]
-mlua = { version = "0.9.9", features = ["luau", "serialize"] }
-
-async-compression = { version = "0.4", features = [
-    "tokio",
-    "brotli",
-    "deflate",
-    "gzip",
-    "zlib",
-] }
-bstr = "1.9"
-lz4 = "1.26"
-serde = { version = "1.0", features = ["derive"] }
-serde_json = { version = "1.0", features = ["preserve_order"] }
-serde_yaml = "0.9"
-toml = { version = "0.8", features = ["preserve_order"] }
-
-digest = "0.10.7"
-hmac = "0.12.1"
-md-5 = "0.10.6"
-sha1 = "0.10.6"
-sha2 = "0.10.8"
-sha3 = "0.10.8"
-# This feature MIGHT break due to the unstable nature of the digest crate.
-# Check before updating it.
-blake3 = { version = "=1.5.0", features = ["traits-preview"] }
-
-tokio = { version = "1", default-features = false, features = [
-    "rt",
-    "io-util",
-] }
-
-lune-utils = { version = "0.1.3", path = "../lune-utils" }

crates/lune-std-serde/src/encode_decode.rs

@@ -1,158 +0,0 @@
-use mlua::prelude::*;
-
-use serde_json::Value as JsonValue;
-use serde_yaml::Value as YamlValue;
-use toml::Value as TomlValue;
-
-// NOTE: These are options for going from other format -> lua ("serializing" lua values)
-const LUA_SERIALIZE_OPTIONS: LuaSerializeOptions = LuaSerializeOptions::new()
-    .set_array_metatable(false)
-    .serialize_none_to_null(false)
-    .serialize_unit_to_null(false);
-
-// NOTE: These are options for going from lua -> other format ("deserializing" lua values)
-const LUA_DESERIALIZE_OPTIONS: LuaDeserializeOptions = LuaDeserializeOptions::new()
-    .sort_keys(true)
-    .deny_recursive_tables(false)
-    .deny_unsupported_types(true);
-
-/**
-    An encoding and decoding format supported by Lune.
-
-    Encode / decode in this case is synonymous with serialize / deserialize.
-*/
-#[derive(Debug, Clone, Copy)]
-pub enum EncodeDecodeFormat {
-    Json,
-    Yaml,
-    Toml,
-}
-
-impl<'lua> FromLua<'lua> for EncodeDecodeFormat {
-    fn from_lua(value: LuaValue<'lua>, _: &'lua Lua) -> LuaResult<Self> {
-        if let LuaValue::String(s) = &value {
-            match s.to_string_lossy().to_ascii_lowercase().trim() {
-                "json" => Ok(Self::Json),
-                "yaml" => Ok(Self::Yaml),
-                "toml" => Ok(Self::Toml),
-                kind => Err(LuaError::FromLuaConversionError {
-                    from: value.type_name(),
-                    to: "EncodeDecodeFormat",
-                    message: Some(format!(
-                        "Invalid format '{kind}', valid formats are:  json, yaml, toml"
-                    )),
-                }),
-            }
-        } else {
-            Err(LuaError::FromLuaConversionError {
-                from: value.type_name(),
-                to: "EncodeDecodeFormat",
-                message: None,
-            })
-        }
-    }
-}
-
-/**
-    Configuration for encoding and decoding values.
-
-    Encoding / decoding in this case is synonymous with serialize / deserialize.
-*/
-#[derive(Debug, Clone, Copy)]
-pub struct EncodeDecodeConfig {
-    pub format: EncodeDecodeFormat,
-    pub pretty: bool,
-}
-
-impl From<EncodeDecodeFormat> for EncodeDecodeConfig {
-    fn from(format: EncodeDecodeFormat) -> Self {
-        Self {
-            format,
-            pretty: false,
-        }
-    }
-}
-
-impl From<(EncodeDecodeFormat, bool)> for EncodeDecodeConfig {
-    fn from(value: (EncodeDecodeFormat, bool)) -> Self {
-        Self {
-            format: value.0,
-            pretty: value.1,
-        }
-    }
-}
-
-/**
-    Encodes / serializes the given value into a string, using the specified configuration.
-
-    # Errors
-
-    Errors when the encoding fails.
-*/
-pub fn encode<'lua>(
-    value: LuaValue<'lua>,
-    lua: &'lua Lua,
-    config: EncodeDecodeConfig,
-) -> LuaResult<LuaString<'lua>> {
-    let bytes = match config.format {
-        EncodeDecodeFormat::Json => {
-            let serialized: JsonValue = lua.from_value_with(value, LUA_DESERIALIZE_OPTIONS)?;
-            if config.pretty {
-                serde_json::to_vec_pretty(&serialized).into_lua_err()?
-            } else {
-                serde_json::to_vec(&serialized).into_lua_err()?
-            }
-        }
-        EncodeDecodeFormat::Yaml => {
-            let serialized: YamlValue = lua.from_value_with(value, LUA_DESERIALIZE_OPTIONS)?;
-            let mut writer = Vec::with_capacity(128);
-            serde_yaml::to_writer(&mut writer, &serialized).into_lua_err()?;
-            writer
-        }
-        EncodeDecodeFormat::Toml => {
-            let serialized: TomlValue = lua.from_value_with(value, LUA_DESERIALIZE_OPTIONS)?;
-            let s = if config.pretty {
-                toml::to_string_pretty(&serialized).into_lua_err()?
-            } else {
-                toml::to_string(&serialized).into_lua_err()?
-            };
-            s.as_bytes().to_vec()
-        }
-    };
-    lua.create_string(bytes)
-}
-
-/**
-    Decodes / deserializes the given string into a value, using the specified configuration.
-
-    # Errors
-
-    Errors when the decoding fails.
-*/
-pub fn decode(
-    bytes: impl AsRef<[u8]>,
-    lua: &Lua,
-    config: EncodeDecodeConfig,
-) -> LuaResult<LuaValue> {
-    let bytes = bytes.as_ref();
-    match config.format {
-        EncodeDecodeFormat::Json => {
-            let value: JsonValue = serde_json::from_slice(bytes).into_lua_err()?;
-            lua.to_value_with(&value, LUA_SERIALIZE_OPTIONS)
-        }
-        EncodeDecodeFormat::Yaml => {
-            let value: YamlValue = serde_yaml::from_slice(bytes).into_lua_err()?;
-            lua.to_value_with(&value, LUA_SERIALIZE_OPTIONS)
-        }
-        EncodeDecodeFormat::Toml => {
-            if let Ok(s) = String::from_utf8(bytes.to_vec()) {
-                let value: TomlValue = toml::from_str(&s).into_lua_err()?;
-                lua.to_value_with(&value, LUA_SERIALIZE_OPTIONS)
-            } else {
-                Err(LuaError::RuntimeError(
-                    "TOML must be valid utf-8".to_string(),
-                ))
-            }
-        }
-    }
-}

crates/lune-std-serde/src/hash.rs

@@ -1,260 +0,0 @@
-use std::fmt::Write;
-
-use bstr::BString;
-use md5::Md5;
-use mlua::prelude::*;
-
-use blake3::Hasher as Blake3;
-use sha1::Sha1;
-use sha2::{Sha224, Sha256, Sha384, Sha512};
-use sha3::{Sha3_224, Sha3_256, Sha3_384, Sha3_512};
-
-pub struct HashOptions {
-    algorithm: HashAlgorithm,
-    message: BString,
-    secret: Option<BString>,
-    // seed: Option<BString>,
-}
-
-#[derive(Debug, Clone, Copy)]
-enum HashAlgorithm {
-    Md5,
-    Sha1,
-    // SHA-2 variants
-    Sha2_224,
-    Sha2_256,
-    Sha2_384,
-    Sha2_512,
-    // SHA-3 variants
-    Sha3_224,
-    Sha3_256,
-    Sha3_384,
-    Sha3_512,
-    // Blake3
-    Blake3,
-}
-
-impl HashAlgorithm {
-    pub const ALL: [Self; 11] = [
-        Self::Md5,
-        Self::Sha1,
-        Self::Sha2_224,
-        Self::Sha2_256,
-        Self::Sha2_384,
-        Self::Sha2_512,
-        Self::Sha3_224,
-        Self::Sha3_256,
-        Self::Sha3_384,
-        Self::Sha3_512,
-        Self::Blake3,
-    ];
-
-    pub const fn name(self) -> &'static str {
-        match self {
-            Self::Md5 => "md5",
-            Self::Sha1 => "sha1",
-            Self::Sha2_224 => "sha224",
-            Self::Sha2_256 => "sha256",
-            Self::Sha2_384 => "sha384",
-            Self::Sha2_512 => "sha512",
-            Self::Sha3_224 => "sha3-224",
-            Self::Sha3_256 => "sha3-256",
-            Self::Sha3_384 => "sha3-384",
-            Self::Sha3_512 => "sha3-512",
-            Self::Blake3 => "blake3",
-        }
-    }
-}
-
-impl HashOptions {
-    /**
-        Computes the hash for the `message` using whatever `algorithm` is
-        contained within this struct and returns it as a string of hex digits.
-    */
-    #[inline]
-    #[must_use = "hashing a message is useless without using the resulting hash"]
-    pub fn hash(self) -> String {
-        use digest::Digest;
-
-        let message = self.message;
-        let bytes = match self.algorithm {
-            HashAlgorithm::Md5 => Md5::digest(message).to_vec(),
-            HashAlgorithm::Sha1 => Sha1::digest(message).to_vec(),
-            HashAlgorithm::Sha2_224 => Sha224::digest(message).to_vec(),
-            HashAlgorithm::Sha2_256 => Sha256::digest(message).to_vec(),
-            HashAlgorithm::Sha2_384 => Sha384::digest(message).to_vec(),
-            HashAlgorithm::Sha2_512 => Sha512::digest(message).to_vec(),
-
-            HashAlgorithm::Sha3_224 => Sha3_224::digest(message).to_vec(),
-            HashAlgorithm::Sha3_256 => Sha3_256::digest(message).to_vec(),
-            HashAlgorithm::Sha3_384 => Sha3_384::digest(message).to_vec(),
-            HashAlgorithm::Sha3_512 => Sha3_512::digest(message).to_vec(),
-
-            HashAlgorithm::Blake3 => Blake3::digest(message).to_vec(),
-        };
-
-        // We don't want to return raw binary data generally, since that's not
-        // what most people want a hash for. So we have to make a hex string.
-        bytes
-            .iter()
-            .fold(String::with_capacity(bytes.len() * 2), |mut output, b| {
-                let _ = write!(output, "{b:02x}");
-                output
-            })
-    }
-
-    /**
-        Computes the HMAC for the `message` using whatever `algorithm` and
-        `secret` are contained within this struct. The computed value is
-        returned as a string of hex digits.
-
-        # Errors
-
-        If the `secret` is not provided or is otherwise invalid.
-    */
-    #[inline]
-    pub fn hmac(self) -> LuaResult<String> {
-        use hmac::{Hmac, Mac, SimpleHmac};
-
-        let secret = self
-            .secret
-            .ok_or_else(|| LuaError::FromLuaConversionError {
-                from: "nil",
-                to: "string or buffer",
-                message: Some("Argument #3 missing or nil".to_string()),
-            })?;
-
-        /*
-            These macros exist to remove what would ultimately be dozens of
-            repeating lines. Essentially, there's several step to processing
-            HMacs, which expands into the 3 lines you see below. However,
-            the Hmac struct is specialized towards eager block-based processes.
-            In order to support anything else, like blake3, there's a second
-            type named `SimpleHmac`. This results in duplicate macros like
-            there are below.
-        */
-        macro_rules! hmac {
-            ($Type:ty) => {{
-                let mut mac: Hmac<$Type> = Hmac::new_from_slice(&secret).into_lua_err()?;
-                mac.update(&self.message);
-                mac.finalize().into_bytes().to_vec()
-            }};
-        }
-        macro_rules! hmac_no_blocks {
-            ($Type:ty) => {{
-                let mut mac: SimpleHmac<$Type> =
-                    SimpleHmac::new_from_slice(&secret).into_lua_err()?;
-                mac.update(&self.message);
-                mac.finalize().into_bytes().to_vec()
-            }};
-        }
-
-        let bytes = match self.algorithm {
-            HashAlgorithm::Md5 => hmac!(Md5),
-            HashAlgorithm::Sha1 => hmac!(Sha1),
-
-            HashAlgorithm::Sha2_224 => hmac!(Sha224),
-            HashAlgorithm::Sha2_256 => hmac!(Sha256),
-            HashAlgorithm::Sha2_384 => hmac!(Sha384),
-            HashAlgorithm::Sha2_512 => hmac!(Sha512),
-
-            HashAlgorithm::Sha3_224 => hmac!(Sha3_224),
-            HashAlgorithm::Sha3_256 => hmac!(Sha3_256),
-            HashAlgorithm::Sha3_384 => hmac!(Sha3_384),
-            HashAlgorithm::Sha3_512 => hmac!(Sha3_512),
-
-            HashAlgorithm::Blake3 => hmac_no_blocks!(Blake3),
-        };
-        Ok(bytes
-            .iter()
-            .fold(String::with_capacity(bytes.len() * 2), |mut output, b| {
-                let _ = write!(output, "{b:02x}");
-                output
-            }))
-    }
-}
-
-impl<'lua> FromLua<'lua> for HashAlgorithm {
-    fn from_lua(value: LuaValue<'lua>, _lua: &'lua Lua) -> LuaResult<Self> {
-        if let LuaValue::String(str) = value {
-            /*
-                Casing tends to vary for algorithms, so rather than force
-                people to remember it we'll just accept any casing.
-            */
-            let str = str.to_str()?.to_ascii_lowercase();
-            match str.as_str() {
-                "md5" => Ok(Self::Md5),
-                "sha1" => Ok(Self::Sha1),
-
-                "sha2-224" | "sha2_224" | "sha224" => Ok(Self::Sha2_224),
-                "sha2-256" | "sha2_256" | "sha256" => Ok(Self::Sha2_256),
-                "sha2-384" | "sha2_384" | "sha384" => Ok(Self::Sha2_384),
-                "sha2-512" | "sha2_512" | "sha512" => Ok(Self::Sha2_512),
-
-                "sha3-224" | "sha3_224" => Ok(Self::Sha3_224),
-                "sha3-256" | "sha3_256" => Ok(Self::Sha3_256),
-                "sha3-384" | "sha3_384" => Ok(Self::Sha3_384),
-                "sha3-512" | "sha3_512" => Ok(Self::Sha3_512),
-
-                "blake3" => Ok(Self::Blake3),
-
-                _ => Err(LuaError::FromLuaConversionError {
-                    from: "string",
-                    to: "HashAlgorithm",
-                    message: Some(format!(
-                        "Invalid hashing algorithm '{str}', valid kinds are:\n{}",
-                        HashAlgorithm::ALL
-                            .into_iter()
-                            .map(HashAlgorithm::name)
-                            .collect::<Vec<_>>()
-                            .join(", ")
-                    )),
-                }),
-            }
-        } else {
-            Err(LuaError::FromLuaConversionError {
-                from: value.type_name(),
-                to: "HashAlgorithm",
-                message: None,
-            })
-        }
-    }
-}
-
-impl<'lua> FromLuaMulti<'lua> for HashOptions {
-    fn from_lua_multi(mut values: LuaMultiValue<'lua>, lua: &'lua Lua) -> LuaResult<Self> {
-        let algorithm = values
-            .pop_front()
-            .map(|value| HashAlgorithm::from_lua(value, lua))
-            .transpose()?
-            .ok_or_else(|| LuaError::FromLuaConversionError {
-                from: "nil",
-                to: "HashAlgorithm",
-                message: Some("Argument #1 missing or nil".to_string()),
-            })?;
-        let message = values
-            .pop_front()
-            .map(|value| BString::from_lua(value, lua))
-            .transpose()?
-            .ok_or_else(|| LuaError::FromLuaConversionError {
-                from: "nil",
-                to: "string or buffer",
-                message: Some("Argument #2 missing or nil".to_string()),
-            })?;
-        let secret = values
-            .pop_front()
-            .map(|value| BString::from_lua(value, lua))
-            .transpose()?;
-        // let seed = values
-        //     .pop_front()
-        //     .map(|value| BString::from_lua(value, lua))
-        //     .transpose()?;
-
-        Ok(HashOptions {
-            algorithm,
-            message,
-            secret,
-            // seed,
-        })
-    }
-}

crates/lune-std-serde/src/lib.rs

@@ -1,69 +0,0 @@
-#![allow(clippy::cargo_common_metadata)]
-
-use bstr::BString;
-use mlua::prelude::*;
-
-use lune_utils::TableBuilder;
-
-mod compress_decompress;
-mod encode_decode;
-mod hash;
-
-pub use self::compress_decompress::{compress, decompress, CompressDecompressFormat};
-pub use self::encode_decode::{decode, encode, EncodeDecodeConfig, EncodeDecodeFormat};
-pub use self::hash::HashOptions;
-
-/**
-    Creates the `serde` standard library module.
-
-    # Errors
-
-    Errors when out of memory.
-*/
-pub fn module(lua: &Lua) -> LuaResult<LuaTable> {
-    TableBuilder::new(lua)?
-        .with_function("encode", serde_encode)?
-        .with_function("decode", serde_decode)?
-        .with_async_function("compress", serde_compress)?
-        .with_async_function("decompress", serde_decompress)?
-        .with_function("hash", hash_message)?
-        .with_function("hmac", hmac_message)?
-        .build_readonly()
-}
-
-fn serde_encode<'lua>(
-    lua: &'lua Lua,
-    (format, value, pretty): (EncodeDecodeFormat, LuaValue<'lua>, Option<bool>),
-) -> LuaResult<LuaString<'lua>> {
-    let config = EncodeDecodeConfig::from((format, pretty.unwrap_or_default()));
-    encode(value, lua, config)
-}
-
-fn serde_decode(lua: &Lua, (format, bs): (EncodeDecodeFormat, BString)) -> LuaResult<LuaValue> {
-    let config = EncodeDecodeConfig::from(format);
-    decode(bs, lua, config)
-}
-
-async fn serde_compress(
-    lua: &Lua,
-    (format, bs, level): (CompressDecompressFormat, BString, Option<i32>),
-) -> LuaResult<LuaString> {
-    let bytes = compress(bs, format, level).await?;
-    lua.create_string(bytes)
-}
-
-async fn serde_decompress(
-    lua: &Lua,
-    (format, bs): (CompressDecompressFormat, BString),
-) -> LuaResult<LuaString> {
-    let bytes = decompress(bs, format).await?;
-    lua.create_string(bytes)
-}
-
-fn hash_message(lua: &Lua, options: HashOptions) -> LuaResult<LuaString> {
-    lua.create_string(options.hash())
-}
-
-fn hmac_message(lua: &Lua, options: HashOptions) -> LuaResult<LuaString> {
-    lua.create_string(options.hmac()?)
-}

crates/lune-std-stdio/Cargo.toml

@@ -1,25 +0,0 @@
-[package]
-name = "lune-std-stdio"
-version = "0.1.2"
-edition = "2021"
-license = "MPL-2.0"
-repository = "https://github.com/lune-org/lune"
-description = "Lune standard library - Stdio"
-
-[lib]
-path = "src/lib.rs"
-
-[lints]
-workspace = true
-
-[dependencies]
-dialoguer = "0.11"
-mlua = { version = "0.9.9", features = ["luau"] }
-mlua-luau-scheduler = { version = "0.0.2", path = "../mlua-luau-scheduler" }
-
-tokio = { version = "1", default-features = false, features = [
-    "io-std",
-    "io-util",
-] }
-
-lune-utils = { version = "0.1.3", path = "../lune-utils" }

crates/lune-std-stdio/src/lib.rs

@@ -1,85 +0,0 @@
-#![allow(clippy::cargo_common_metadata)]
-
-use lune_utils::fmt::{pretty_format_multi_value, ValueFormatConfig};
-use mlua::prelude::*;
-use mlua_luau_scheduler::LuaSpawnExt;
-
-use tokio::io::{stderr, stdin, stdout, AsyncReadExt, AsyncWriteExt};
-
-use lune_utils::TableBuilder;
-
-mod prompt;
-mod style_and_color;
-
-use self::prompt::{prompt, PromptOptions, PromptResult};
-use self::style_and_color::{ColorKind, StyleKind};
-
-const FORMAT_CONFIG: ValueFormatConfig = ValueFormatConfig::new()
-    .with_max_depth(4)
-    .with_colors_enabled(false);
-
-/**
-    Creates the `stdio` standard library module.
-
-    # Errors
-
-    Errors when out of memory.
-*/
-pub fn module(lua: &Lua) -> LuaResult<LuaTable> {
-    TableBuilder::new(lua)?
-        .with_function("color", stdio_color)?
-        .with_function("style", stdio_style)?
-        .with_function("format", stdio_format)?
-        .with_async_function("write", stdio_write)?
-        .with_async_function("ewrite", stdio_ewrite)?
-        .with_async_function("readToEnd", stdio_read_to_end)?
-        .with_async_function("prompt", stdio_prompt)?
-        .build_readonly()
-}
-
-fn stdio_color(lua: &Lua, color: ColorKind) -> LuaResult<LuaValue> {
-    color.ansi_escape_sequence().into_lua(lua)
-}
-
-fn stdio_style(lua: &Lua, style: StyleKind) -> LuaResult<LuaValue> {
-    style.ansi_escape_sequence().into_lua(lua)
-}
-
-fn stdio_format(_: &Lua, args: LuaMultiValue) -> LuaResult<String> {
-    Ok(pretty_format_multi_value(&args, &FORMAT_CONFIG))
-}
-
-async fn stdio_write(_: &Lua, s: LuaString<'_>) -> LuaResult<()> {
-    let mut stdout = stdout();
-    stdout.write_all(s.as_bytes()).await?;
-    stdout.flush().await?;
-    Ok(())
-}
-
-async fn stdio_ewrite(_: &Lua, s: LuaString<'_>) -> LuaResult<()> {
-    let mut stderr = stderr();
-    stderr.write_all(s.as_bytes()).await?;
-    stderr.flush().await?;
-    Ok(())
-}
-
-/*
-    FUTURE: Figure out how to expose some kind of "readLine" function using a buffered reader.
-
-    This is a bit tricky since we would want to be able to use **both** readLine and readToEnd
-    in the same script, doing something like readLine, readLine, readToEnd from lua, and
-    having that capture the first two lines and then read the rest of the input.
-*/
-
-async fn stdio_read_to_end(lua: &Lua, (): ()) -> LuaResult<LuaString> {
-    let mut input = Vec::new();
-    let mut stdin = stdin();
-    stdin.read_to_end(&mut input).await?;
-    lua.create_string(&input)
-}
-
-async fn stdio_prompt(lua: &Lua, options: PromptOptions) -> LuaResult<PromptResult> {
-    lua.spawn_blocking(move || prompt(options))
-        .await
-        .into_lua_err()
-}

crates/lune-std-stdio/src/style_and_color.rs

@@ -1,195 +0,0 @@
-use std::str::FromStr;
-
-use mlua::prelude::*;
-
-const ESCAPE_SEQ_RESET: &str = "\x1b[0m";
-
-/**
-    A color kind supported by the `stdio` standard library.
-*/
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum ColorKind {
-    Reset,
-    Black,
-    Red,
-    Green,
-    Yellow,
-    Blue,
-    Magenta,
-    Cyan,
-    White,
-}
-
-impl ColorKind {
-    pub const ALL: [Self; 9] = [
-        Self::Reset,
-        Self::Black,
-        Self::Red,
-        Self::Green,
-        Self::Yellow,
-        Self::Blue,
-        Self::Magenta,
-        Self::Cyan,
-        Self::White,
-    ];
-
-    /**
-        Returns the human-friendly name of this color kind.
-    */
-    pub fn name(self) -> &'static str {
-        match self {
-            Self::Reset => "reset",
-            Self::Black => "black",
-            Self::Red => "red",
-            Self::Green => "green",
-            Self::Yellow => "yellow",
-            Self::Blue => "blue",
-            Self::Magenta => "magenta",
-            Self::Cyan => "cyan",
-            Self::White => "white",
-        }
-    }
-
-    /**
-        Returns the ANSI escape sequence for the color kind.
-    */
-    pub fn ansi_escape_sequence(self) -> &'static str {
-        match self {
-            Self::Reset => ESCAPE_SEQ_RESET,
-            Self::Black => "\x1b[30m",
-            Self::Red => "\x1b[31m",
-            Self::Green => "\x1b[32m",
-            Self::Yellow => "\x1b[33m",
-            Self::Blue => "\x1b[34m",
-            Self::Magenta => "\x1b[35m",
-            Self::Cyan => "\x1b[36m",
-            Self::White => "\x1b[37m",
-        }
-    }
-}
-
-impl FromStr for ColorKind {
-    type Err = ();
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Ok(match s.trim().to_ascii_lowercase().as_str() {
-            "reset" => Self::Reset,
-            "black" => Self::Black,
-            "red" => Self::Red,
-            "green" => Self::Green,
-            "yellow" => Self::Yellow,
-            "blue" => Self::Blue,
-            // NOTE: Previous versions of Lune had this color as "purple" instead
-            // of "magenta", so we keep this here for backwards compatibility.
-            "magenta" | "purple" => Self::Magenta,
-            "cyan" => Self::Cyan,
-            "white" => Self::White,
-            _ => return Err(()),
-        })
-    }
-}
-
-impl FromLua<'_> for ColorKind {
-    fn from_lua(value: LuaValue, _: &Lua) -> LuaResult<Self> {
-        if let LuaValue::String(s) = value {
-            let s = s.to_str()?;
-            match s.parse() {
-                Ok(color) => Ok(color),
-                Err(()) => Err(LuaError::FromLuaConversionError {
-                    from: "string",
-                    to: "ColorKind",
-                    message: Some(format!(
-                        "Invalid color kind '{s}'\nValid kinds are: {}",
-                        Self::ALL
-                            .iter()
-                            .map(|kind| kind.name())
-                            .collect::<Vec<_>>()
-                            .join(", ")
-                    )),
-                }),
-            }
-        } else {
-            Err(LuaError::FromLuaConversionError {
-                from: value.type_name(),
-                to: "ColorKind",
-                message: None,
-            })
-        }
-    }
-}
-
-/**
-    A style kind supported by the `stdio` standard library.
-*/
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum StyleKind {
-    Reset,
-    Bold,
-    Dim,
-}
-
-impl StyleKind {
-    pub const ALL: [Self; 3] = [Self::Reset, Self::Bold, Self::Dim];
-
-    /**
-        Returns the human-friendly name for this style kind.
-    */
-    pub fn name(self) -> &'static str {
-        match self {
-            Self::Reset => "reset",
-            Self::Bold => "bold",
-            Self::Dim => "dim",
-        }
-    }
-
-    /**
-        Returns the ANSI escape sequence for this style kind.
-    */
-    pub fn ansi_escape_sequence(self) -> &'static str {
-        match self {
-            Self::Reset => ESCAPE_SEQ_RESET,
-            Self::Bold => "\x1b[1m",
-            Self::Dim => "\x1b[2m",
-        }
-    }
-}
-
-impl FromStr for StyleKind {
-    type Err = ();
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Ok(match s.trim().to_ascii_lowercase().as_str() {
-            "reset" => Self::Reset,
-            "bold" => Self::Bold,
-            "dim" => Self::Dim,
-            _ => return Err(()),
-        })
-    }
-}
-
-impl FromLua<'_> for StyleKind {
-    fn from_lua(value: LuaValue, _: &Lua) -> LuaResult<Self> {
-        if let LuaValue::String(s) = value {
-            let s = s.to_str()?;
-            match s.parse() {
-                Ok(style) => Ok(style),
-                Err(()) => Err(LuaError::FromLuaConversionError {
-                    from: "string",
-                    to: "StyleKind",
-                    message: Some(format!(
-                        "Invalid style kind '{s}'\nValid kinds are: {}",
-                        Self::ALL
-                            .iter()
-                            .map(|kind| kind.name())
-                            .collect::<Vec<_>>()
-                            .join(", ")
-                    )),
-                }),
-            }
-        } else {
-            Err(LuaError::FromLuaConversionError {
-                from: value.type_name(),
-                to: "StyleKind",
-                message: None,
-            })
-        }
-    }
-}

crates/lune-std-task/Cargo.toml

@@ -1,21 +0,0 @@
-[package]
-name = "lune-std-task"
-version = "0.1.2"
-edition = "2021"
-license = "MPL-2.0"
-repository = "https://github.com/lune-org/lune"
-description = "Lune standard library - Task"
-
-[lib]
-path = "src/lib.rs"
-
-[lints]
-workspace = true
-
-[dependencies]
-mlua = { version = "0.9.9", features = ["luau"] }
-mlua-luau-scheduler = { version = "0.0.2", path = "../mlua-luau-scheduler" }
-
-tokio = { version = "1", default-features = false, features = ["time"] }
-
-lune-utils = { version = "0.1.3", path = "../lune-utils" }

crates/lune-std/Cargo.toml

@@ -1,59 +0,0 @@
-[package]
-name = "lune-std"
-version = "0.1.5"
-edition = "2021"
-license = "MPL-2.0"
-repository = "https://github.com/lune-org/lune"
-description = "Lune standard library"
-
-[lib]
-path = "src/lib.rs"
-
-[lints]
-workspace = true
-
-[features]
-default = [
-    "datetime",
-    "fs",
-    "luau",
-    "net",
-    "process",
-    "regex",
-    "roblox",
-    "serde",
-    "stdio",
-    "task",
-]
-
-datetime = ["dep:lune-std-datetime"]
-fs = ["dep:lune-std-fs"]
-luau = ["dep:lune-std-luau"]
-net = ["dep:lune-std-net"]
-process = ["dep:lune-std-process"]
-regex = ["dep:lune-std-regex"]
-roblox = ["dep:lune-std-roblox"]
-serde = ["dep:lune-std-serde"]
-stdio = ["dep:lune-std-stdio"]
-task = ["dep:lune-std-task"]
-
-[dependencies]
-mlua = { version = "0.9.9", features = ["luau"] }
-mlua-luau-scheduler = { version = "0.0.2", path = "../mlua-luau-scheduler" }
-
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
-tokio = { version = "1", default-features = false, features = ["fs", "sync"] }
-
-lune-utils = { version = "0.1.3", path = "../lune-utils" }
-
-lune-std-datetime = { optional = true, version = "0.1.3", path = "../lune-std-datetime" }
-lune-std-fs = { optional = true, version = "0.1.2", path = "../lune-std-fs" }
-lune-std-luau = { optional = true, version = "0.1.2", path = "../lune-std-luau" }
-lune-std-net = { optional = true, version = "0.1.2", path = "../lune-std-net" }
-lune-std-process = { optional = true, version = "0.1.3", path = "../lune-std-process" }
-lune-std-regex = { optional = true, version = "0.1.2", path = "../lune-std-regex" }
-lune-std-roblox = { optional = true, version = "0.1.4", path = "../lune-std-roblox" }
-lune-std-serde = { optional = true, version = "0.1.2", path = "../lune-std-serde" }
-lune-std-stdio = { optional = true, version = "0.1.2", path = "../lune-std-stdio" }
-lune-std-task = { optional = true, version = "0.1.2", path = "../lune-std-task" }

crates/lune-std/src/global.rs

@@ -1,92 +0,0 @@
-use std::str::FromStr;
-
-use mlua::prelude::*;
-
-/**
-    A standard global provided by Lune.
-*/
-#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
-pub enum LuneStandardGlobal {
-    GTable,
-    Print,
-    Require,
-    Version,
-    Warn,
-}
-
-impl LuneStandardGlobal {
-    /**
-        All available standard globals.
-    */
-    pub const ALL: &'static [Self] = &[
-        Self::GTable,
-        Self::Print,
-        Self::Require,
-        Self::Version,
-        Self::Warn,
-    ];
-
-    /**
-        Gets the name of the global, such as `_G` or `require`.
-    */
-    #[must_use]
-    pub fn name(&self) -> &'static str {
-        match self {
-            Self::GTable => "_G",
-            Self::Print => "print",
-            Self::Require => "require",
-            Self::Version => "_VERSION",
-            Self::Warn => "warn",
-        }
-    }
-
-    /**
-        Creates the Lua value for the global.
-
-        # Errors
-
-        If the global could not be created.
-    */
-    #[rustfmt::skip]
-    #[allow(unreachable_patterns)]
-    pub fn create<'lua>(&self, lua: &'lua Lua) -> LuaResult<LuaValue<'lua>> {
-        let res = match self {
-            Self::GTable => crate::globals::g_table::create(lua),
-            Self::Print => crate::globals::print::create(lua),
-            Self::Require => crate::globals::require::create(lua),
-            Self::Version => crate::globals::version::create(lua),
-            Self::Warn => crate::globals::warn::create(lua),
-        };
-        match res {
-            Ok(v) => Ok(v),
-            Err(e) => Err(e.context(format!(
-                "Failed to create standard global '{}'",
-                self.name()
-            ))),
-        }
-    }
-}
-
-impl FromStr for LuneStandardGlobal {
-    type Err = String;
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let low = s.trim().to_ascii_lowercase();
-        Ok(match low.as_str() {
-            "_g" => Self::GTable,
-            "print" => Self::Print,
-            "require" => Self::Require,
-            "_version" => Self::Version,
-            "warn" => Self::Warn,
-            _ => {
-                return Err(format!(
-                    "Unknown standard global '{low}'\nValid globals are: {}",
-                    Self::ALL
-                        .iter()
-                        .map(Self::name)
-                        .collect::<Vec<_>>()
-                        .join(", ")
-                ))
-            }
-        })
-    }
-}

crates/lune-std/src/globals/g_table.rs

@@ -1,5 +0,0 @@
-use mlua::prelude::*;
-
-pub fn create(lua: &Lua) -> LuaResult<LuaValue> {
-    lua.create_table()?.into_lua(lua)
-}

crates/lune-std/src/globals/mod.rs

@@ -1,5 +0,0 @@
-pub mod g_table;
-pub mod print;
-pub mod require;
-pub mod version;
-pub mod warn;

crates/lune-std/src/globals/print.rs

@@ -1,19 +0,0 @@
-use std::io::Write;
-
-use lune_utils::fmt::{pretty_format_multi_value, ValueFormatConfig};
-use mlua::prelude::*;
-
-const FORMAT_CONFIG: ValueFormatConfig = ValueFormatConfig::new()
-    .with_max_depth(4)
-    .with_colors_enabled(true);
-
-pub fn create(lua: &Lua) -> LuaResult<LuaValue> {
-    let f = lua.create_function(|_, args: LuaMultiValue| {
-        let formatted = format!("{}\n", pretty_format_multi_value(&args, &FORMAT_CONFIG));
-        let mut stdout = std::io::stdout();
-        stdout.write_all(formatted.as_bytes())?;
-        stdout.flush()?;
-        Ok(())
-    })?;
-    f.into_lua(lua)
-}

crates/lune-std/src/globals/version.rs

@@ -1,35 +0,0 @@
-use mlua::prelude::*;
-
-use lune_utils::get_version_string;
-
-struct Version(String);
-
-impl LuaUserData for Version {}
-
-pub fn create(lua: &Lua) -> LuaResult<LuaValue> {
-    let v = match lua.app_data_ref::<Version>() {
-        Some(v) => v.0.to_string(),
-        None => env!("CARGO_PKG_VERSION").to_string(),
-    };
-    let s = get_version_string(v);
-    lua.create_string(s)?.into_lua(lua)
-}
-
-/**
-    Overrides the version string to be used by the `_VERSION` global.
-
-    The global will be a string in the format `Lune x.y.z+luau`,
-    where `x.y.z` is the string passed to this function.
-
-    The version string passed should be the version of the Lune runtime,
-    obtained from `env!("CARGO_PKG_VERSION")` or a similar mechanism.
-
-    # Panics
-
-    Panics if the version string is empty or contains invalid characters.
-*/
-pub fn set_global_version(lua: &Lua, version: impl Into<String>) {
-    let v = version.into();
-    let _ = get_version_string(&v); // Validate version string
-    lua.set_app_data(Version(v));
-}

crates/lune-std/src/globals/warn.rs

@@ -1,23 +0,0 @@
-use std::io::Write;
-
-use lune_utils::fmt::{pretty_format_multi_value, Label, ValueFormatConfig};
-use mlua::prelude::*;
-
-const FORMAT_CONFIG: ValueFormatConfig = ValueFormatConfig::new()
-    .with_max_depth(4)
-    .with_colors_enabled(true);
-
-pub fn create(lua: &Lua) -> LuaResult<LuaValue> {
-    let f = lua.create_function(|_, args: LuaMultiValue| {
-        let formatted = format!(
-            "{}\n{}\n",
-            Label::Warn,
-            pretty_format_multi_value(&args, &FORMAT_CONFIG)
-        );
-        let mut stdout = std::io::stdout();
-        stdout.write_all(formatted.as_bytes())?;
-        stdout.flush()?;
-        Ok(())
-    })?;
-    f.into_lua(lua)
-}

crates/lune-std/src/lib.rs

@@ -1,29 +0,0 @@
-#![allow(clippy::cargo_common_metadata)]
-
-use mlua::prelude::*;
-
-mod global;
-mod globals;
-mod library;
-mod luaurc;
-
-pub use self::global::LuneStandardGlobal;
-pub use self::globals::version::set_global_version;
-pub use self::library::LuneStandardLibrary;
-
-/**
-    Injects all standard globals into the given Lua state / VM.
-
-    This includes all enabled standard libraries, which can
-    be used from Lua with `require("@lune/library-name")`.
-
-    # Errors
-
-    Errors when out of memory, or if *default* Lua globals are missing.
-*/
-pub fn inject_globals(lua: &Lua) -> LuaResult<()> {
-    for global in LuneStandardGlobal::ALL {
-        lua.globals().set(global.name(), global.create(lua)?)?;
-    }
-    Ok(())
-}

crates/lune-std/src/library.rs

@@ -1,127 +0,0 @@
-use std::str::FromStr;
-
-use mlua::prelude::*;
-
-/**
-    A standard library provided by Lune.
-*/
-#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
-#[rustfmt::skip]
-pub enum LuneStandardLibrary {
-    #[cfg(feature = "datetime")] DateTime,
-    #[cfg(feature = "fs")]       Fs,
-    #[cfg(feature = "luau")]     Luau,
-    #[cfg(feature = "net")]      Net,
-    #[cfg(feature = "task")]     Task,
-    #[cfg(feature = "process")]  Process,
-    #[cfg(feature = "regex")]    Regex,
-    #[cfg(feature = "serde")]    Serde,
-    #[cfg(feature = "stdio")]    Stdio,
-    #[cfg(feature = "roblox")]   Roblox,
-}
-
-impl LuneStandardLibrary {
-    /**
-        All available standard libraries.
-    */
-    #[rustfmt::skip]
-    pub const ALL: &'static [Self] = &[
-        #[cfg(feature = "datetime")] Self::DateTime,
-        #[cfg(feature = "fs")]       Self::Fs,
-        #[cfg(feature = "luau")]     Self::Luau,
-        #[cfg(feature = "net")]      Self::Net,
-        #[cfg(feature = "task")]     Self::Task,
-        #[cfg(feature = "process")]  Self::Process,
-        #[cfg(feature = "regex")]    Self::Regex,
-        #[cfg(feature = "serde")]    Self::Serde,
-        #[cfg(feature = "stdio")]    Self::Stdio,
-        #[cfg(feature = "roblox")]   Self::Roblox,
-    ];
-
-    /**
-        Gets the name of the library, such as `datetime` or `fs`.
-    */
-    #[must_use]
-    #[rustfmt::skip]
-    #[allow(unreachable_patterns)]
-    pub fn name(&self) -> &'static str {
-        match self {
-            #[cfg(feature = "datetime")] Self::DateTime => "datetime",
-            #[cfg(feature = "fs")]       Self::Fs       => "fs",
-            #[cfg(feature = "luau")]     Self::Luau     => "luau",
-            #[cfg(feature = "net")]      Self::Net      => "net",
-            #[cfg(feature = "task")]     Self::Task     => "task",
-            #[cfg(feature = "process")]  Self::Process  => "process",
-            #[cfg(feature = "regex")]    Self::Regex    => "regex",
-            #[cfg(feature = "serde")]    Self::Serde    => "serde",
-            #[cfg(feature = "stdio")]    Self::Stdio    => "stdio",
-            #[cfg(feature = "roblox")]   Self::Roblox   => "roblox",
-
-            _ => unreachable!("no standard library enabled"),
-        }
-    }
-
-    /**
-        Creates the Lua module for the library.
-
-        # Errors
-
-        If the library could not be created.
-    */
-    #[rustfmt::skip]
-    #[allow(unreachable_patterns)]
-    pub fn module<'lua>(&self, lua: &'lua Lua) -> LuaResult<LuaMultiValue<'lua>> {
-        let res: LuaResult<LuaTable> = match self {
-            #[cfg(feature = "datetime")] Self::DateTime => lune_std_datetime::module(lua),
-            #[cfg(feature = "fs")]       Self::Fs       => lune_std_fs::module(lua),
-            #[cfg(feature = "luau")]     Self::Luau     => lune_std_luau::module(lua),
-            #[cfg(feature = "net")]      Self::Net      => lune_std_net::module(lua),
-            #[cfg(feature = "task")]     Self::Task     => lune_std_task::module(lua),
-            #[cfg(feature = "process")]  Self::Process  => lune_std_process::module(lua),
-            #[cfg(feature = "regex")]    Self::Regex    => lune_std_regex::module(lua),
-            #[cfg(feature = "serde")]    Self::Serde    => lune_std_serde::module(lua),
-            #[cfg(feature = "stdio")]    Self::Stdio    => lune_std_stdio::module(lua),
-            #[cfg(feature = "roblox")]   Self::Roblox   => lune_std_roblox::module(lua),
-
-            _ => unreachable!("no standard library enabled"),
-        };
-        match res {
-            Ok(v) => v.into_lua_multi(lua),
-            Err(e) => Err(e.context(format!(
-                "Failed to create standard library '{}'",
-                self.name()
-            ))),
-        }
-    }
-}
-
-impl FromStr for LuneStandardLibrary {
-    type Err = String;
-    #[rustfmt::skip]
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let low = s.trim().to_ascii_lowercase();
-        Ok(match low.as_str() {
-            #[cfg(feature = "datetime")] "datetime" => Self::DateTime,
-            #[cfg(feature = "fs")]       "fs"       => Self::Fs,
-            #[cfg(feature = "luau")]     "luau"     => Self::Luau,
-            #[cfg(feature = "net")]      "net"      => Self::Net,
-            #[cfg(feature = "task")]     "task"     => Self::Task,
-            #[cfg(feature = "process")]  "process"  => Self::Process,
-            #[cfg(feature = "regex")]    "regex"    => Self::Regex,
-            #[cfg(feature = "serde")]    "serde"    => Self::Serde,
-            #[cfg(feature = "stdio")]    "stdio"    => Self::Stdio,
-            #[cfg(feature = "roblox")]   "roblox"   => Self::Roblox,
-
-            _ => {
-                return Err(format!(
-                    "Unknown standard library '{low}'\nValid libraries are: {}",
-                    Self::ALL
-                        .iter()
-                        .map(Self::name)
-                        .collect::<Vec<_>>()
-                        .join(", ")
-                ))
-            }
-        })
-    }
-}

crates/lune-utils/Cargo.toml

@@ -1,26 +0,0 @@
-[package]
-name = "lune-utils"
-version = "0.1.3"
-edition = "2021"
-license = "MPL-2.0"
-repository = "https://github.com/lune-org/lune"
-description = "Utilities library for Lune"
-
-[lib]
-path = "src/lib.rs"
-
-[lints]
-workspace = true
-
-[dependencies]
-mlua = { version = "0.9.9", features = ["luau", "async"] }
-
-tokio = { version = "1", default-features = false, features = ["fs"] }
-
-console = "0.15"
-dunce = "1.0"
-once_cell = "1.17"
-path-clean = "1.0"
-pathdiff = "0.2"
-parking_lot = "0.12.3"
-semver = "1.0"

crates/lune-utils/src/fmt/error/components.rs

@@ -1,196 +0,0 @@
-use std::fmt;
-use std::str::FromStr;
-use std::sync::Arc;
-
-use console::style;
-use mlua::prelude::*;
-use once_cell::sync::Lazy;
-
-use super::StackTrace;
-
-static STYLED_STACK_BEGIN: Lazy<String> = Lazy::new(|| {
-    format!(
-        "{}{}{}",
-        style("[").dim(),
-        style("Stack Begin").blue(),
-        style("]").dim()
-    )
-});
-
-static STYLED_STACK_END: Lazy<String> = Lazy::new(|| {
-    format!(
-        "{}{}{}",
-        style("[").dim(),
-        style("Stack End").blue(),
-        style("]").dim()
-    )
-});
-
-// NOTE: We indent using 4 spaces instead of tabs since
-// these errors are most likely to be displayed in a terminal
-// or some kind of live output - and tabs don't work well there
-const STACK_TRACE_INDENT: &str = "    ";
-
-/**
-    Error components parsed from a [`LuaError`].
-
-    Can be used to display a human-friendly error message
-    and stack trace, in the following Roblox-inspired format:
-
-    ```plaintext
-    Error message
-    [Stack Begin]
-        Stack trace line
-        Stack trace line
-        Stack trace line
-    [Stack End]
-    ```
-*/
-#[derive(Debug, Default, Clone)]
-pub struct ErrorComponents {
-    messages: Vec<String>,
-    trace: Option<StackTrace>,
-}
-
-impl ErrorComponents {
-    /**
-        Returns the error messages.
-    */
-    #[must_use]
-    pub fn messages(&self) -> &[String] {
-        &self.messages
-    }
-
-    /**
-        Returns the stack trace, if it exists.
-    */
-    #[must_use]
-    pub fn trace(&self) -> Option<&StackTrace> {
-        self.trace.as_ref()
-    }
-
-    /**
-        Returns `true` if the error has a non-empty stack trace.
-
-        Note that a trace may still *exist*, but it may be empty.
-    */
-    #[must_use]
-    pub fn has_trace(&self) -> bool {
-        self.trace
-            .as_ref()
-            .is_some_and(|trace| !trace.lines().is_empty())
-    }
-}
-
-impl fmt::Display for ErrorComponents {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        for message in self.messages() {
-            writeln!(f, "{message}")?;
-        }
-        if self.has_trace() {
-            let trace = self.trace.as_ref().unwrap();
-            writeln!(f, "{}", *STYLED_STACK_BEGIN)?;
-            for line in trace.lines() {
-                writeln!(f, "{STACK_TRACE_INDENT}{line}")?;
-            }
-            writeln!(f, "{}", *STYLED_STACK_END)?;
-        }
-        Ok(())
-    }
-}
-
-impl From<LuaError> for ErrorComponents {
-    fn from(error: LuaError) -> Self {
-        fn lua_error_message(e: &LuaError) -> String {
-            if let LuaError::RuntimeError(s) = e {
-                s.to_string()
-            } else {
-                e.to_string()
-            }
-        }
-
-        fn lua_stack_trace(source: &str) -> Option<StackTrace> {
-            // FUTURE: Preserve a parsing error here somehow?
-            // Maybe we can emit parsing errors using tracing?
-            StackTrace::from_str(source).ok()
-        }
-
-        // Extract any additional "context" messages before the actual error(s)
-        // The Arc is necessary here because mlua wraps all inner errors in an Arc
-        let mut error = Arc::new(error);
-        let mut messages = Vec::new();
-        while let LuaError::WithContext {
-            ref context,
-            ref cause,
-        } = *error
-        {
-            messages.push(context.to_string());
-            error = cause.clone();
-        }
-
-        // We will then try to extract any stack trace
-        let mut trace = if let LuaError::CallbackError {
-            ref traceback,
-            ref cause,
-        } = *error
-        {
-            messages.push(lua_error_message(cause));
-            lua_stack_trace(traceback)
-        } else if let LuaError::RuntimeError(ref s) = *error {
-            // NOTE: Runtime errors may include tracebacks, but they're
-            // joined with error messages, so we need to split them out
-            if let Some(pos) = s.find("stack traceback:") {
-                let (message, traceback) = s.split_at(pos);
-                messages.push(message.trim().to_string());
-                lua_stack_trace(traceback)
-            } else {
-                messages.push(s.to_string());
-                None
-            }
-        } else {
-            messages.push(lua_error_message(&error));
-            None
-        };
-
-        // Sometimes, we can get duplicate stack trace lines that only
-        // mention "[C]", without a function name or path, and these can
-        // be safely ignored / removed if the following line has more info
-        if let Some(trace) = &mut trace {
-            let lines = trace.lines_mut();
-            loop {
-                let first_is_c_and_empty = lines
-                    .first()
-                    .is_some_and(|line| line.source().is_c() && line.is_empty());
-                let second_is_c_and_nonempty = lines
-                    .get(1)
-                    .is_some_and(|line| line.source().is_c() && !line.is_empty());
-                if first_is_c_and_empty && second_is_c_and_nonempty {
-                    lines.remove(0);
-                } else {
-                    break;
-                }
-            }
-        }
-
-        // Finally, we do some light postprocessing to remove duplicate
-        // information, such as the location prefix in the error message
-        if let Some(message) = messages.last_mut() {
-            if let Some(line) = trace
-                .iter()
-                .flat_map(StackTrace::lines)
-                .find(|line| line.source().is_lua())
-            {
-                let location_prefix = format!(
-                    "[string \"{}\"]:{}:",
-                    line.path().unwrap(),
-                    line.line_number().unwrap()
-                );
-                if message.starts_with(&location_prefix) {
-                    *message = message[location_prefix.len()..].trim().to_string();
-                }
-            }
-        }
-
-        ErrorComponents { messages, trace }
-    }
-}

crates/lune-utils/src/fmt/error/mod.rs

@@ -1,8 +0,0 @@
-mod components;
-mod stack_trace;
-
-#[cfg(test)]
-mod tests;
-
-pub use self::components::ErrorComponents;
-pub use self::stack_trace::{StackTrace, StackTraceLine, StackTraceSource};

crates/lune-utils/src/fmt/error/stack_trace.rs

@@ -1,210 +0,0 @@
-use std::fmt;
-use std::str::FromStr;
-
-fn parse_path(s: &str) -> Option<(&str, &str)> {
-    let path = s.strip_prefix("[string \"")?;
-    let (path, after) = path.split_once("\"]:")?;
-
-    // Remove line number after any found colon, this may
-    // exist if the source path is from a rust source file
-    let path = match path.split_once(':') {
-        Some((before, _)) => before,
-        None => path,
-    };
-
-    Some((path, after))
-}
-
-fn parse_function_name(s: &str) -> Option<&str> {
-    s.strip_prefix("in function '")
-        .and_then(|s| s.strip_suffix('\''))
-}
-
-fn parse_line_number(s: &str) -> (Option<usize>, &str) {
-    match s.split_once(':') {
-        Some((before, after)) => (before.parse::<usize>().ok(), after),
-        None => (None, s),
-    }
-}
-
-/**
-    Source of a stack trace line parsed from a [`LuaError`].
-*/
-#[derive(Debug, Default, Clone, Copy)]
-pub enum StackTraceSource {
-    /// Error originated from a C / Rust function.
-    C,
-    /// Error originated from a Lua (user) function.
-    #[default]
-    Lua,
-}
-
-impl StackTraceSource {
-    /**
-        Returns `true` if the error originated from a C / Rust function, `false` otherwise.
-    */
-    #[must_use]
-    pub const fn is_c(self) -> bool {
-        matches!(self, Self::C)
-    }
-
-    /**
-        Returns `true` if the error originated from a Lua (user) function, `false` otherwise.
-    */
-    #[must_use]
-    pub const fn is_lua(self) -> bool {
-        matches!(self, Self::Lua)
-    }
-}
-
-/**
-    Stack trace line parsed from a [`LuaError`].
-*/
-#[derive(Debug, Default, Clone)]
-pub struct StackTraceLine {
-    source: StackTraceSource,
-    path: Option<String>,
-    line_number: Option<usize>,
-    function_name: Option<String>,
-}
-
-impl StackTraceLine {
-    /**
-        Returns the source of the stack trace line.
-    */
-    #[must_use]
-    pub fn source(&self) -> StackTraceSource {
-        self.source
-    }
-
-    /**
-        Returns the path, if it exists.
-    */
-    #[must_use]
-    pub fn path(&self) -> Option<&str> {
-        self.path.as_deref()
-    }
-
-    /**
-        Returns the line number, if it exists.
-    */
-    #[must_use]
-    pub fn line_number(&self) -> Option<usize> {
-        self.line_number
-    }
-
-    /**
-        Returns the function name, if it exists.
-    */
-    #[must_use]
-    pub fn function_name(&self) -> Option<&str> {
-        self.function_name.as_deref()
-    }
-
-    /**
-        Returns `true` if the stack trace line contains no "useful" information, `false` otherwise.
-
-        Useful information is determined as one of:
-
-        - A path
-        - A line number
-        - A function name
-    */
-    #[must_use]
-    pub const fn is_empty(&self) -> bool {
-        self.path.is_none() && self.line_number.is_none() && self.function_name.is_none()
-    }
-}
-
-impl FromStr for StackTraceLine {
-    type Err = String;
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        if let Some(after) = s.strip_prefix("[C]: ") {
-            let function_name = parse_function_name(after).map(ToString::to_string);
-
-            Ok(Self {
-                source: StackTraceSource::C,
-                path: None,
-                line_number: None,
-                function_name,
-            })
-        } else if let Some((path, after)) = parse_path(s) {
-            let (line_number, after) = parse_line_number(after);
-            let function_name = parse_function_name(after).map(ToString::to_string);
-
-            Ok(Self {
-                source: StackTraceSource::Lua,
-                path: Some(path.to_string()),
-                line_number,
-                function_name,
-            })
-        } else {
-            Err(String::from("unknown format"))
-        }
-    }
-}
-
-impl fmt::Display for StackTraceLine {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        if matches!(self.source, StackTraceSource::C) {
-            write!(f, "Script '[C]'")?;
-        } else {
-            write!(f, "Script '{}'", self.path.as_deref().unwrap_or("[?]"))?;
-            if let Some(line_number) = self.line_number {
-                write!(f, ", Line {line_number}")?;
-            }
-        }
-        if let Some(function_name) = self.function_name.as_deref() {
-            write!(f, " - function '{function_name}'")?;
-        }
-        Ok(())
-    }
-}
-
-/**
-    Stack trace parsed from a [`LuaError`].
-*/
-#[derive(Debug, Default, Clone)]
-pub struct StackTrace {
-    lines: Vec<StackTraceLine>,
-}
-
-impl StackTrace {
-    /**
-        Returns the individual stack trace lines.
-    */
-    #[must_use]
-    pub fn lines(&self) -> &[StackTraceLine] {
-        &self.lines
-    }
-
-    /**
-        Returns the individual stack trace lines, mutably.
-    */
-    #[must_use]
-    pub fn lines_mut(&mut self) -> &mut Vec<StackTraceLine> {
-        &mut self.lines
-    }
-}
-
-impl FromStr for StackTrace {
-    type Err = String;
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let (_, after) = s
-            .split_once("stack traceback:")
-            .ok_or_else(|| String::from("missing 'stack traceback:' prefix"))?;
-        let lines = after
-            .trim()
-            .lines()
-            .filter_map(|line| {
-                let line = line.trim();
-                if line.is_empty() {
-                    None
-                } else {
-                    Some(line.parse())
-                }
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-        Ok(StackTrace { lines })
-    }
-}

crates/lune-utils/src/fmt/error/tests.rs

@@ -1,150 +0,0 @@
-use mlua::prelude::*;
-
-use crate::fmt::ErrorComponents;
-
-fn new_lua_runtime_error() -> LuaResult<()> {
-    let lua = Lua::new();
-
-    lua.globals()
-        .set(
-            "f",
-            LuaFunction::wrap(|_, (): ()| {
-                Err::<(), _>(LuaError::runtime("oh no, a runtime error"))
-            }),
-        )
-        .unwrap();
-
-    lua.load("f()").set_name("chunk_name").eval()
-}
-
-fn new_lua_script_error() -> LuaResult<()> {
-    let lua = Lua::new();
-
-    lua.load(
-        "local function inner()\
-        \n    error(\"oh no, a script error\")\
-        \nend\
-        \n\
-        \nlocal function outer()\
-        \n    inner()\
-        \nend\
-        \n\
-        \nouter()\
-        ",
-    )
-    .set_name("chunk_name")
-    .eval()
-}
-
-// Tests for error context stack
-mod context {
-    use super::*;
-
-    #[test]
-    fn preserves_original() {
-        let lua_error = new_lua_runtime_error()
-            .context("additional context")
-            .unwrap_err();
-        let components = ErrorComponents::from(lua_error);
-
-        assert_eq!(components.messages()[0], "additional context");
-        assert_eq!(components.messages()[1], "oh no, a runtime error");
-    }
-
-    #[test]
-    fn preserves_levels() {
-        // NOTE: The behavior in mlua is to preserve a single level of context
-        // and not all levels (context gets replaced on each call to `context`)
-        let lua_error = new_lua_runtime_error()
-            .context("level 1")
-            .context("level 2")
-            .context("level 3")
-            .unwrap_err();
-        let components = ErrorComponents::from(lua_error);
-
-        assert_eq!(
-            components.messages(),
-            &["level 3", "oh no, a runtime error"]
-        );
-    }
-}
-
-// Tests for error components struct: separated messages + stack trace
-mod error_components {
-    use super::*;
-
-    #[test]
-    fn message() {
-        let lua_error = new_lua_runtime_error().unwrap_err();
-        let components = ErrorComponents::from(lua_error);
-
-        assert_eq!(components.messages()[0], "oh no, a runtime error");
-    }
-
-    #[test]
-    fn stack_begin_end() {
-        let lua_error = new_lua_runtime_error().unwrap_err();
-        let formatted = format!("{}", ErrorComponents::from(lua_error));
-
-        assert!(formatted.contains("Stack Begin"));
-        assert!(formatted.contains("Stack End"));
-    }
-
-    #[test]
-    fn stack_lines() {
-        let lua_error = new_lua_runtime_error().unwrap_err();
-        let components = ErrorComponents::from(lua_error);
-
-        let mut lines = components.trace().unwrap().lines().iter();
-        let line_1 = lines.next().unwrap().to_string();
-        let line_2 = lines.next().unwrap().to_string();
-        assert!(lines.next().is_none());
-
-        assert_eq!(line_1, "Script '[C]' - function 'f'");
-        assert_eq!(line_2, "Script 'chunk_name', Line 1");
-    }
-}
-
-// Tests for general formatting
-mod general {
-    use super::*;
-
-    #[test]
-    fn message_does_not_contain_location() {
-        let lua_error = new_lua_script_error().unwrap_err();
-
-        let components = ErrorComponents::from(lua_error);
-        let trace = components.trace().unwrap();
-
-        let first_message = components.messages().first().unwrap();
-        let first_lua_stack_line = trace
-            .lines()
-            .iter()
-            .find(|line| line.source().is_lua())
-            .unwrap();
-
-        let location_prefix = format!(
-            "[string \"{}\"]:{}:",
-            first_lua_stack_line.path().unwrap(),
-            first_lua_stack_line.line_number().unwrap()
-        );
-
-        assert!(!first_message.starts_with(&location_prefix));
-    }
-
-    #[test]
-    fn no_redundant_c_mentions() {
-        let lua_error = new_lua_script_error().unwrap_err();
-
-        let components = ErrorComponents::from(lua_error);
-        let trace = components.trace().unwrap();
-
-        let c_stack_lines = trace
-            .lines()
-            .iter()
-            .filter(|line| line.source().is_c())
-            .collect::<Vec<_>>();
-
-        assert_eq!(c_stack_lines.len(), 1); // Just the "error" call
-    }
-}

crates/lune-utils/src/fmt/label.rs

@@ -1,66 +0,0 @@
-use std::fmt;
-
-use console::{style, Color};
-
-/**
-    Label enum used for consistent output formatting throughout Lune.
-
-    # Example usage
-
-    ```rs
-    use lune_utils::fmt::Label;
-
-    println!("{} This is an info message", Label::Info);
-    // [INFO] This is an info message
-
-    println!("{} This is a warning message", Label::Warn);
-    // [WARN] This is a warning message
-
-    println!("{} This is an error message", Label::Error);
-    // [ERROR] This is an error message
-    ```
-*/
-#[derive(Debug, Clone, Copy)]
-pub enum Label {
-    Info,
-    Warn,
-    Error,
-}
-
-impl Label {
-    /**
-        Returns the name of the label in all uppercase.
-    */
-    #[must_use]
-    pub fn name(&self) -> &str {
-        match self {
-            Self::Info => "INFO",
-            Self::Warn => "WARN",
-            Self::Error => "ERROR",
-        }
-    }
-
-    /**
-        Returns the color of the label.
-    */
-    #[must_use]
-    pub fn color(&self) -> Color {
-        match self {
-            Self::Info => Color::Blue,
-            Self::Warn => Color::Yellow,
-            Self::Error => Color::Red,
-        }
-    }
-}
-
-impl fmt::Display for Label {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "{}{}{}",
-            style("[").dim(),
-            style(self.name()).fg(self.color()),
-            style("]").dim()
-        )
-    }
-}

crates/lune-utils/src/fmt/mod.rs

@@ -1,7 +0,0 @@
-mod error;
-mod label;
-mod value;
-
-pub use self::error::{ErrorComponents, StackTrace, StackTraceLine, StackTraceSource};
-pub use self::label::Label;
-pub use self::value::{pretty_format_multi_value, pretty_format_value, ValueFormatConfig};

crates/lune-utils/src/fmt/value/basic.rs

@@ -1,99 +0,0 @@
-use mlua::prelude::*;
-
-use crate::fmt::ErrorComponents;
-
-use super::{
-    metamethods::{
-        call_table_tostring_metamethod, call_userdata_tostring_metamethod,
-        get_table_type_metavalue, get_userdata_type_metavalue,
-    },
-    style::{COLOR_CYAN, COLOR_GREEN, COLOR_MAGENTA, COLOR_YELLOW},
-};
-
-const STRING_REPLACEMENTS: &[(&str, &str)] =
-    &[("\"", r#"\""#), ("\t", r"\t"), ("\r", r"\r"), ("\n", r"\n")];
-
-/**
-    Tries to return the given value as a plain string key.
-
-    A plain string key must:
-
-    - Start with an alphabetic character.
-    - Only contain alphanumeric characters and underscores.
-*/
-pub(crate) fn lua_value_as_plain_string_key(value: &LuaValue) -> Option<String> {
-    if let LuaValue::String(s) = value {
-        if let Ok(s) = s.to_str() {
-            let first_valid = s.chars().next().is_some_and(|c| c.is_ascii_alphabetic());
-            let all_valid = s.chars().all(|c| c.is_ascii_alphanumeric() || c == '_');
-            if first_valid && all_valid {
-                return Some(s.to_string());
-            }
-        }
-    }
-    None
-}
-
-/**
-    Formats a Lua value into a pretty string.
-
-    This does not recursively format tables.
-*/
-pub(crate) fn format_value_styled(value: &LuaValue, prefer_plain: bool) -> String {
-    match value {
-        LuaValue::Nil => COLOR_YELLOW.apply_to("nil").to_string(),
-        LuaValue::Boolean(true) => COLOR_YELLOW.apply_to("true").to_string(),
-        LuaValue::Boolean(false) => COLOR_YELLOW.apply_to("false").to_string(),
-        LuaValue::Number(n) => COLOR_CYAN.apply_to(n).to_string(),
-        LuaValue::Integer(i) => COLOR_CYAN.apply_to(i).to_string(),
-        LuaValue::String(s) if prefer_plain => s.to_string_lossy().to_string(),
-        LuaValue::String(s) => COLOR_GREEN
-            .apply_to({
-                let mut s = s.to_string_lossy().to_string();
-                for (from, to) in STRING_REPLACEMENTS {
-                    s = s.replace(from, to);
-                }
-                format!(r#""{s}""#)
-            })
-            .to_string(),
-        LuaValue::Vector(_) => COLOR_MAGENTA.apply_to("<vector>").to_string(),
-        LuaValue::Thread(_) => COLOR_MAGENTA.apply_to("<thread>").to_string(),
-        LuaValue::Function(_) => COLOR_MAGENTA.apply_to("<function>").to_string(),
-        LuaValue::LightUserData(_) => COLOR_MAGENTA.apply_to("<pointer>").to_string(),
-        LuaValue::UserData(u) => {
-            let formatted = format_typename_and_tostringed(
-                "userdata",
-                get_userdata_type_metavalue(u),
-                call_userdata_tostring_metamethod(u),
-            );
-            COLOR_MAGENTA.apply_to(formatted).to_string()
-        }
-        LuaValue::Table(t) => {
-            let formatted = format_typename_and_tostringed(
-                "table",
-                get_table_type_metavalue(t),
-                call_table_tostring_metamethod(t),
-            );
-            COLOR_MAGENTA.apply_to(formatted).to_string()
-        }
-        LuaValue::Error(e) => COLOR_MAGENTA
-            .apply_to(format!(
-                "<LuaError(\n{})>",
-                ErrorComponents::from(e.clone())
-            ))
-            .to_string(),
-    }
-}
-
-fn format_typename_and_tostringed(
-    fallback: &'static str,
-    typename: Option<String>,
-    tostringed: Option<String>,
-) -> String {
-    match (typename, tostringed) {
-        (Some(typename), Some(tostringed)) => format!("<{typename}({tostringed})>"),
-        (Some(typename), None) => format!("<{typename}>"),
-        (None, Some(tostringed)) => format!("<{tostringed}>"),
-        (None, None) => format!("<{fallback}>"),
-    }
-}

crates/lune-utils/src/fmt/value/config.rs

@@ -1,48 +0,0 @@
-/**
-    Configuration for formatting values.
-*/
-#[derive(Debug, Clone, Copy)]
-pub struct ValueFormatConfig {
-    pub(super) max_depth: usize,
-    pub(super) colors_enabled: bool,
-}
-
-impl ValueFormatConfig {
-    /**
-        Creates a new config with default values.
-    */
-    #[must_use]
-    pub const fn new() -> Self {
-        Self {
-            max_depth: 3,
-            colors_enabled: false,
-        }
-    }
-
-    /**
-        Sets the maximum depth to which tables will be formatted.
-    */
-    #[must_use]
-    pub const fn with_max_depth(self, max_depth: usize) -> Self {
-        Self { max_depth, ..self }
-    }
-
-    /**
-        Sets whether colors should be enabled.
-
-        Colors are disabled by default.
-    */
-    #[must_use]
-    pub const fn with_colors_enabled(self, colors_enabled: bool) -> Self {
-        Self {
-            colors_enabled,
-            ..self
-        }
-    }
-}
-
-impl Default for ValueFormatConfig {
-    fn default() -> Self {
-        Self::new()
-    }
-}

crates/lune-utils/src/fmt/value/metamethods.rs

@@ -1,37 +0,0 @@
-use mlua::prelude::*;
-
-pub fn get_table_type_metavalue<'a>(tab: &'a LuaTable<'a>) -> Option<String> {
-    let s = tab
-        .get_metatable()?
-        .get::<_, LuaString>(LuaMetaMethod::Type.name())
-        .ok()?;
-    let s = s.to_str().ok()?;
-    Some(s.to_string())
-}
-
-pub fn get_userdata_type_metavalue<'a>(tab: &'a LuaAnyUserData<'a>) -> Option<String> {
-    let s = tab
-        .get_metatable()
-        .ok()?
-        .get::<LuaString>(LuaMetaMethod::Type.name())
-        .ok()?;
-    let s = s.to_str().ok()?;
-    Some(s.to_string())
-}
-
-pub fn call_table_tostring_metamethod<'a>(tab: &'a LuaTable<'a>) -> Option<String> {
-    tab.get_metatable()?
-        .get::<_, LuaFunction>(LuaMetaMethod::ToString.name())
-        .ok()?
-        .call(tab)
-        .ok()
-}
-
-pub fn call_userdata_tostring_metamethod<'a>(tab: &'a LuaAnyUserData<'a>) -> Option<String> {
-    tab.get_metatable()
-        .ok()?
-        .get::<LuaFunction>(LuaMetaMethod::ToString.name())
-        .ok()?
-        .call(tab)
-        .ok()
-}

crates/lune-utils/src/fmt/value/mod.rs

@@ -1,63 +0,0 @@
-use std::{collections::HashSet, sync::Arc};
-
-use console::{colors_enabled as get_colors_enabled, set_colors_enabled};
-use mlua::prelude::*;
-use once_cell::sync::Lazy;
-use parking_lot::ReentrantMutex;
-
-mod basic;
-mod config;
-mod metamethods;
-mod recursive;
-mod style;
-
-use self::recursive::format_value_recursive;
-
-pub use self::config::ValueFormatConfig;
-
-// NOTE: Since the setting for colors being enabled is global,
-// and these functions may be called in parallel, we use this global
-// lock to make sure that we don't mess up the colors for other threads.
-static COLORS_LOCK: Lazy<Arc<ReentrantMutex<()>>> = Lazy::new(|| Arc::new(ReentrantMutex::new(())));
-
-/**
-    Formats a Lua value into a pretty string using the given config.
-*/
-#[must_use]
-#[allow(clippy::missing_panics_doc)]
-pub fn pretty_format_value(value: &LuaValue, config: &ValueFormatConfig) -> String {
-    let _guard = COLORS_LOCK.lock();
-
-    let were_colors_enabled = get_colors_enabled();
-    set_colors_enabled(were_colors_enabled && config.colors_enabled);
-
-    let mut visited = HashSet::new();
-    let res = format_value_recursive(value, config, &mut visited, 0);
-
-    set_colors_enabled(were_colors_enabled);
-    res.expect("using fmt for writing into strings should never fail")
-}
-
-/**
-    Formats a Lua multi-value into a pretty string using the given config.
-
-    Each value will be separated by a space.
-*/
-#[must_use]
-#[allow(clippy::missing_panics_doc)]
-pub fn pretty_format_multi_value(values: &LuaMultiValue, config: &ValueFormatConfig) -> String {
-    let _guard = COLORS_LOCK.lock();
-
-    let were_colors_enabled = get_colors_enabled();
-    set_colors_enabled(were_colors_enabled && config.colors_enabled);
-
-    let mut visited = HashSet::new();
-    let res = values
-        .into_iter()
-        .map(|value| format_value_recursive(value, config, &mut visited, 0))
-        .collect::<Result<Vec<_>, _>>();
-
-    set_colors_enabled(were_colors_enabled);
-    res.expect("using fmt for writing into strings should never fail")
-        .join(" ")
-}

crates/lune-utils/src/fmt/value/recursive.rs

@@ -1,184 +0,0 @@
-use std::cmp::Ordering;
-use std::collections::HashSet;
-use std::fmt::{self, Write as _};
-
-use mlua::prelude::*;
-
-use super::metamethods::{call_table_tostring_metamethod, get_table_type_metavalue};
-use super::{
-    basic::{format_value_styled, lua_value_as_plain_string_key},
-    config::ValueFormatConfig,
-    style::STYLE_DIM,
-};
-
-const INDENT: &str = "    ";
-
-/**
-    Representation of a pointer in memory to a Lua value.
-*/
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub(crate) struct LuaValueId(usize);
-
-impl From<&LuaValue<'_>> for LuaValueId {
-    fn from(value: &LuaValue<'_>) -> Self {
-        Self(value.to_pointer() as usize)
-    }
-}
-
-impl From<&LuaTable<'_>> for LuaValueId {
-    fn from(table: &LuaTable) -> Self {
-        Self(table.to_pointer() as usize)
-    }
-}
-
-/**
-    Formats the given value, recursively formatting tables
-    up to the maximum depth specified in the config.
-
-    NOTE: We return a result here but it's really just to make handling
-    of the `write!` calls easier. Writing into a string should never fail.
-*/
-pub(crate) fn format_value_recursive(
-    value: &LuaValue,
-    config: &ValueFormatConfig,
-    visited: &mut HashSet<LuaValueId>,
-    depth: usize,
-) -> Result<String, fmt::Error> {
-    let mut buffer = String::new();
-
-    if let LuaValue::Table(ref t) = value {
-        if let Some(formatted) = format_typename_and_tostringed(
-            get_table_type_metavalue(t),
-            call_table_tostring_metamethod(t),
-        ) {
-            write!(buffer, "{formatted}")?;
-        } else if depth >= config.max_depth {
-            write!(buffer, "{}", STYLE_DIM.apply_to("{ ... }"))?;
-        } else if !visited.insert(LuaValueId::from(t)) {
-            write!(buffer, "{}", STYLE_DIM.apply_to("{ recursive }"))?;
-        } else {
-            write!(buffer, "{}", STYLE_DIM.apply_to("{"))?;
-
-            let mut values = t
-                .clone()
-                .pairs::<LuaValue, LuaValue>()
-                .map(|res| res.expect("conversion to LuaValue should never fail"))
-                .collect::<Vec<_>>();
-            sort_for_formatting(&mut values);
-
-            let is_empty = values.is_empty();
-            let is_array = values
-                .iter()
-                .enumerate()
-                .all(|(i, (key, _))| key.as_integer().is_some_and(|x| x == (i as i32) + 1));
-
-            let formatted_values = if is_array {
-                format_array(values, config, visited, depth)?
-            } else {
-                format_table(values, config, visited, depth)?
-            };
-
-            visited.remove(&LuaValueId::from(t));
-
-            if is_empty {
-                write!(buffer, " {}", STYLE_DIM.apply_to("}"))?;
-            } else {
-                write!(
-                    buffer,
-                    "\n{}\n{}{}",
-                    formatted_values.join("\n"),
-                    INDENT.repeat(depth),
-                    STYLE_DIM.apply_to("}")
-                )?;
-            }
-        }
-    } else {
-        let prefer_plain = depth == 0;
-        write!(buffer, "{}", format_value_styled(value, prefer_plain))?;
-    }
-
-    Ok(buffer)
-}
-
-fn sort_for_formatting(values: &mut [(LuaValue, LuaValue)]) {
-    values.sort_by(|(a, _), (b, _)| {
-        if a.type_name() == b.type_name() {
-            // If we have the same type, sort either numerically or alphabetically
-            match (a, b) {
-                (LuaValue::Integer(a), LuaValue::Integer(b)) => a.cmp(b),
-                (LuaValue::Number(a), LuaValue::Number(b)) => a.partial_cmp(b).unwrap(),
-                (LuaValue::String(a), LuaValue::String(b)) => a.to_str().ok().cmp(&b.to_str().ok()),
-                _ => Ordering::Equal,
-            }
-        } else {
-            // If we have different types, sort numbers first, then strings, then others
-            a.is_number()
-                .cmp(&b.is_number())
-                .then_with(|| a.is_string().cmp(&b.is_string()))
-        }
-    });
-}
-
-fn format_array(
-    values: Vec<(LuaValue, LuaValue)>,
-    config: &ValueFormatConfig,
-    visited: &mut HashSet<LuaValueId>,
-    depth: usize,
-) -> Result<Vec<String>, fmt::Error> {
-    values
-        .into_iter()
-        .map(|(_, value)| {
-            Ok(format!(
-                "{}{}{}",
-                INDENT.repeat(1 + depth),
-                format_value_recursive(&value, config, visited, depth + 1)?,
-                STYLE_DIM.apply_to(","),
-            ))
-        })
-        .collect()
-}
-
-fn format_table(
-    values: Vec<(LuaValue, LuaValue)>,
-    config: &ValueFormatConfig,
-    visited: &mut HashSet<LuaValueId>,
-    depth: usize,
-) -> Result<Vec<String>, fmt::Error> {
-    values
-        .into_iter()
-        .map(|(key, value)| {
-            if let Some(plain_key) = lua_value_as_plain_string_key(&key) {
-                Ok(format!(
-                    "{}{plain_key} {} {}{}",
-                    INDENT.repeat(1 + depth),
-                    STYLE_DIM.apply_to("="),
-                    format_value_recursive(&value, config, visited, depth + 1)?,
-                    STYLE_DIM.apply_to(","),
-                ))
-            } else {
-                Ok(format!(
-                    "{}{}{}{} {} {}{}",
-                    INDENT.repeat(1 + depth),
-                    STYLE_DIM.apply_to("["),
-                    format_value_recursive(&key, config, visited, depth + 1)?,
-                    STYLE_DIM.apply_to("]"),
-                    STYLE_DIM.apply_to("="),
-                    format_value_recursive(&value, config, visited, depth + 1)?,
-                    STYLE_DIM.apply_to(","),
-                ))
-            }
-        })
-        .collect()
-}
-
-fn format_typename_and_tostringed(
-    typename: Option<String>,
-    tostringed: Option<String>,
-) -> Option<String> {
-    match (typename, tostringed) {
-        (Some(typename), Some(tostringed)) => Some(format!("<{typename}({tostringed})>")),
-        (Some(typename), None) => Some(format!("<{typename}>")),
-        (None, Some(tostringed)) => Some(tostringed),
-        (None, None) => None,
-    }
-}

crates/lune-utils/src/fmt/value/style.rs

@@ -1,9 +0,0 @@
-use console::Style;
-use once_cell::sync::Lazy;
-
-pub static COLOR_GREEN: Lazy<Style> = Lazy::new(|| Style::new().green());
-pub static COLOR_YELLOW: Lazy<Style> = Lazy::new(|| Style::new().yellow());
-pub static COLOR_MAGENTA: Lazy<Style> = Lazy::new(|| Style::new().magenta());
-pub static COLOR_CYAN: Lazy<Style> = Lazy::new(|| Style::new().cyan());
-
-pub static STYLE_DIM: Lazy<Style> = Lazy::new(|| Style::new().dim());

crates/lune-utils/src/jit.rs

@@ -1,30 +0,0 @@
-#[derive(Debug, Clone, Copy, Default)]
-pub struct JitStatus(bool);
-
-impl JitStatus {
-    #[must_use]
-    pub fn new(enabled: bool) -> Self {
-        Self(enabled)
-    }
-
-    pub fn set_status(&mut self, enabled: bool) {
-        self.0 = enabled;
-    }
-
-    #[must_use]
-    pub fn enabled(self) -> bool {
-        self.0
-    }
-}
-
-impl From<JitStatus> for bool {
-    fn from(val: JitStatus) -> Self {
-        val.enabled()
-    }
-}
-
-impl From<bool> for JitStatus {
-    fn from(val: bool) -> Self {
-        Self::new(val)
-    }
-}

crates/lune-utils/src/lib.rs

@@ -1,11 +0,0 @@
-#![allow(clippy::cargo_common_metadata)]
-
-mod table_builder;
-mod version_string;
-
-pub mod fmt;
-pub mod jit;
-pub mod path;
-
-pub use self::table_builder::TableBuilder;
-pub use self::version_string::get_version_string;

crates/lune-utils/src/path.rs

@@ -1,101 +0,0 @@
-use std::{
-    env::{current_dir, current_exe},
-    path::{Path, PathBuf, MAIN_SEPARATOR},
-    sync::Arc,
-};
-
-use once_cell::sync::Lazy;
-use path_clean::PathClean;
-
-static CWD: Lazy<Arc<Path>> = Lazy::new(create_cwd);
-static EXE: Lazy<Arc<Path>> = Lazy::new(create_exe);
-
-fn create_cwd() -> Arc<Path> {
-    let mut cwd = current_dir()
-        .expect("failed to find current working directory")
-        .to_str()
-        .expect("current working directory is not valid UTF-8")
-        .to_string();
-    if !cwd.ends_with(MAIN_SEPARATOR) {
-        cwd.push(MAIN_SEPARATOR);
-    }
-    dunce::canonicalize(cwd)
-        .expect("failed to canonicalize current working directory")
-        .into()
-}
-
-fn create_exe() -> Arc<Path> {
-    let exe = current_exe()
-        .expect("failed to find current executable")
-        .to_str()
-        .expect("current executable is not valid UTF-8")
-        .to_string();
-    dunce::canonicalize(exe)
-        .expect("failed to canonicalize current executable")
-        .into()
-}
-
-/**
-    Gets the current working directory as an absolute path.
-
-    This absolute path is canonicalized and does not contain any `.` or `..`
-    components, and it is also in a friendly (non-UNC) format.
-
-    This path is also guaranteed to:
-
-    - Be valid UTF-8.
-    - End with the platform's main path separator.
-*/
-#[must_use]
-pub fn get_current_dir() -> Arc<Path> {
-    Arc::clone(&CWD)
-}
-
-/**
-    Gets the path to the current executable as an absolute path.
-
-    This absolute path is canonicalized and does not contain any `.` or `..`
-    components, and it is also in a friendly (non-UNC) format.
-
-    This path is also guaranteed to:
-
-    - Be valid UTF-8.
-*/
-#[must_use]
-pub fn get_current_exe() -> Arc<Path> {
-    Arc::clone(&EXE)
-}
-
-/**
-    Diffs two paths against each other.
-
-    See the [`pathdiff`] crate for more information on what diffing paths does.
-*/
-pub fn diff_path(path: impl AsRef<Path>, base: impl AsRef<Path>) -> Option<PathBuf> {
-    pathdiff::diff_paths(path, base)
-}
-
-/**
-    Cleans a path.
-
-    See the [`path_clean`] crate for more information on what cleaning a path does.
-*/
-pub fn clean_path(path: impl AsRef<Path>) -> PathBuf {
-    path.as_ref().clean()
-}
-
-/**
-    Makes a path absolute and then cleans it.
-
-    Relative paths are resolved against the current working directory.
-
-    See the [`path_clean`] crate for more information on what cleaning a path does.
-*/
-pub fn clean_path_and_make_absolute(path: impl AsRef<Path>) -> PathBuf {
-    let path = path.as_ref();
-    if path.is_relative() {
-        CWD.join(path).clean()
-    } else {
-        path.clean()
-    }
-}

crates/lune-utils/src/version_string.rs

@@ -1,74 +0,0 @@
-use std::sync::Arc;
-
-use mlua::prelude::*;
-use once_cell::sync::Lazy;
-use semver::Version;
-
-static LUAU_VERSION: Lazy<Arc<String>> = Lazy::new(create_luau_version_string);
-
-/**
-    Returns a Lune version string, in the format `Lune x.y.z+luau`.
-
-    The version string passed should be the version of the Lune runtime,
-    obtained from `env!("CARGO_PKG_VERSION")` or a similar mechanism.
-
-    # Panics
-
-    Panics if the version string is empty or contains invalid characters.
-*/
-#[must_use]
-pub fn get_version_string(lune_version: impl AsRef<str>) -> String {
-    let lune_version = lune_version.as_ref();
-
-    assert!(!lune_version.is_empty(), "Lune version string is empty");
-    match Version::parse(lune_version) {
-        Ok(semver) => format!("Lune {semver}+{}", *LUAU_VERSION),
-        Err(e) => panic!("Lune version string is not valid semver: {e}"),
-    }
-}
-
-fn create_luau_version_string() -> Arc<String> {
-    // Extract the current Luau version from a fresh Lua state / VM that can't be accessed externally.
-    let luau_version_full = {
-        let temp_lua = Lua::new();
-
-        let luau_version_full = temp_lua
-            .globals()
-            .get::<_, LuaString>("_VERSION")
-            .expect("Missing _VERSION global");
-
-        luau_version_full
-            .to_str()
-            .context("Invalid utf8 found in _VERSION global")
-            .expect("Expected _VERSION global to be a string")
-            .to_string()
-    };
-
-    // Luau version is expected to be in the format "Luau 0.x" and sometimes "Luau 0.x.y"
-    assert!(
-        luau_version_full.starts_with("Luau 0."),
-        "_VERSION global is formatted incorrectly\
-        \nFound string '{luau_version_full}'"
-    );
-    let luau_version_noprefix = luau_version_full.strip_prefix("Luau 0.").unwrap().trim();
-
-    // We make some guarantees about the format of the _VERSION global,
-    // so make sure that the luau version also follows those rules.
-    if luau_version_noprefix.is_empty() {
-        panic!(
-            "_VERSION global is missing version number\
-            \nFound string '{luau_version_full}'"
-        )
-    } else if !luau_version_noprefix.chars().all(is_valid_version_char) {
-        panic!(
-            "_VERSION global contains invalid characters\
-            \nFound string '{luau_version_full}'"
-        )
-    }
-
-    luau_version_noprefix.to_string().into()
-}
-
-fn is_valid_version_char(c: char) -> bool {
-    matches!(c, '0'..='9' | '.')
-}

crates/lune/Cargo.toml

@@ -1,83 +0,0 @@
-[package]
-name = "lune"
-version = "0.8.9"
-edition = "2021"
-license = "MPL-2.0"
-repository = "https://github.com/lune-org/lune"
-description = "A standalone Luau runtime"
-readme = "../../README.md"
-keywords = ["cli", "lua", "luau", "runtime"]
-categories = ["command-line-interface"]
-
-[[bin]]
-name = "lune"
-path = "src/main.rs"
-
-[lib]
-name = "lune"
-path = "src/lib.rs"
-
-[features]
-default = ["std", "cli"]
-
-std-datetime = ["dep:lune-std", "lune-std/datetime"]
-std-fs = ["dep:lune-std", "lune-std/fs"]
-std-luau = ["dep:lune-std", "lune-std/luau"]
-std-net = ["dep:lune-std", "lune-std/net"]
-std-process = ["dep:lune-std", "lune-std/process"]
-std-regex = ["dep:lune-std", "lune-std/regex"]
-std-roblox = ["dep:lune-std", "lune-std/roblox", "dep:lune-roblox"]
-std-serde = ["dep:lune-std", "lune-std/serde"]
-std-stdio = ["dep:lune-std", "lune-std/stdio"]
-std-task = ["dep:lune-std", "lune-std/task"]
-
-std = [
-    "std-datetime",
-    "std-fs",
-    "std-luau",
-    "std-net",
-    "std-process",
-    "std-regex",
-    "std-roblox",
-    "std-serde",
-    "std-stdio",
-    "std-task",
-]
-
-cli = ["dep:clap", "dep:include_dir", "dep:rustyline", "dep:zip_next"]
-
-[lints]
-workspace = true
-
-[dependencies]
-mlua = { version = "0.9.9", features = ["luau"] }
-mlua-luau-scheduler = { version = "0.0.2", path = "../mlua-luau-scheduler" }
-
-anyhow = "1.0"
-console = "0.15"
-dialoguer = "0.11"
-directories = "5.0"
-futures-util = "0.3"
-once_cell = "1.17"
-self_cell = "1.0"
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
-thiserror = "1.0"
-
-tracing = "0.1"
-tracing-subscriber = { version = "0.3", features = ["env-filter"] }
-tokio = { version = "1", features = ["full"] }
-reqwest = { version = "0.11", default-features = false, features = [
-    "rustls-tls",
-] }
-
-lune-std = { optional = true, version = "0.1.5", path = "../lune-std" }
-lune-roblox = { optional = true, version = "0.1.4", path = "../lune-roblox" }
-lune-utils = { version = "0.1.3", path = "../lune-utils" }
-
-### CLI
-
-clap = { optional = true, version = "4.1", features = ["derive"] }
-include_dir = { optional = true, version = "0.7", features = ["glob"] }
-rustyline = { optional = true, version = "14.0" }
-zip_next = { optional = true, version = "1.1" }

crates/lune/src/cli/build/base_exe.rs

@@ -1,86 +0,0 @@
-use std::{
-    io::{Cursor, Read},
-    path::PathBuf,
-};
-
-use tokio::{fs, task};
-
-use crate::standalone::metadata::CURRENT_EXE;
-
-use super::{
-    files::write_executable_file_to,
-    result::{BuildError, BuildResult},
-    target::{BuildTarget, CACHE_DIR},
-};
-
-/**
-    Discovers the path to the base executable to use for cross-compilation.
-
-    If the target is the same as the current system, the current executable is used.
-
-    If no binary exists at the target path, it will attempt to download it from the internet.
-*/
-pub async fn get_or_download_base_executable(target: BuildTarget) -> BuildResult<PathBuf> {
-    if target.is_current_system() {
-        return Ok(CURRENT_EXE.to_path_buf());
-    }
-    if target.cache_path().exists() {
-        return Ok(target.cache_path());
-    }
-
-    // The target is not cached, we must download it
-    println!("Requested target '{target}' does not exist in cache");
-    let version = env!("CARGO_PKG_VERSION");
-    let target_triple = format!("lune-{version}-{target}");
-
-    let release_url = format!(
-        "{base_url}/v{version}/{target_triple}.zip",
-        base_url = "https://github.com/lune-org/lune/releases/download",
-    );
-
-    // NOTE: This is not entirely accurate, but it is clearer for a user
-    println!("Downloading {target_triple}{}...", target.exe_suffix());
-
-    // Try to request to download the zip file from the target url,
-    // making sure transient errors are handled gracefully and
-    // with a different error message than "not found"
-    let response = reqwest::get(release_url).await?;
-    if !response.status().is_success() {
-        if response.status().as_u16() == 404 {
-            return Err(BuildError::ReleaseTargetNotFound(target));
-        }
-        return Err(BuildError::Download(
-            response.error_for_status().unwrap_err(),
-        ));
-    }
-
-    // Receive the full zip file
-    let zip_bytes = response.bytes().await?.to_vec();
-    let zip_file = Cursor::new(zip_bytes);
-
-    // Look for and extract the binary file from the zip file
-    // NOTE: We use spawn_blocking here since reading a zip
-    // archive is a somewhat slow / blocking operation
-    let binary_file_name = format!("lune{}", target.exe_suffix());
-    let binary_file_handle = task::spawn_blocking(move || {
-        let mut archive = zip_next::ZipArchive::new(zip_file)?;
-
-        let mut binary = Vec::new();
-        archive
-            .by_name(&binary_file_name)
-            .or(Err(BuildError::ZippedBinaryNotFound(binary_file_name)))?
-            .read_to_end(&mut binary)?;
-
-        Ok::<_, BuildError>(binary)
-    });
-    let binary_file_contents = binary_file_handle.await??;
-
-    // Finally, write the extracted binary to the cache
-    if !CACHE_DIR.exists() {
-        fs::create_dir_all(CACHE_DIR.as_path()).await?;
-    }
-    write_executable_file_to(target.cache_path(), binary_file_contents).await?;
-    println!("Downloaded successfully and added to cache");
-
-    Ok(target.cache_path())
-}

crates/lune/src/cli/build/files.rs

@@ -1,42 +0,0 @@
-use std::path::{Path, PathBuf};
-
-use anyhow::Result;
-use tokio::{fs, io::AsyncWriteExt};
-
-/**
-    Removes the source file extension from the given path, if it has one.
-
-    A source file extension is an extension such as `.lua` or `.luau`.
-*/
-pub fn remove_source_file_ext(path: &Path) -> PathBuf {
-    if path
-        .extension()
-        .is_some_and(|ext| matches!(ext.to_str(), Some("lua" | "luau")))
-    {
-        path.with_extension("")
-    } else {
-        path.to_path_buf()
-    }
-}
-
-/**
-    Writes the given bytes to a file at the specified path,
-    and makes sure it has permissions to be executed.
-*/
-pub async fn write_executable_file_to(
-    path: impl AsRef<Path>,
-    bytes: impl AsRef<[u8]>,
-) -> Result<(), std::io::Error> {
-    let mut options = fs::OpenOptions::new();
-    options.write(true).create(true).truncate(true);
-
-    #[cfg(unix)]
-    {
-        options.mode(0o755); // Read & execute for all, write for owner
-    }
-
-    let mut file = options.open(path).await?;
-    file.write_all(bytes.as_ref()).await?;
-
-    Ok(())
-}

crates/lune/src/cli/build/mod.rs

@@ -1,83 +0,0 @@
-use std::{path::PathBuf, process::ExitCode};
-
-use anyhow::{bail, Context, Result};
-use clap::Parser;
-use console::style;
-use tokio::fs;
-
-use crate::standalone::metadata::Metadata;
-
-mod base_exe;
-mod files;
-mod result;
-mod target;
-
-use self::base_exe::get_or_download_base_executable;
-use self::files::{remove_source_file_ext, write_executable_file_to};
-use self::target::BuildTarget;
-
-/// Build a standalone executable
-#[derive(Debug, Clone, Parser)]
-pub struct BuildCommand {
-    /// The path to the input file
-    pub input: PathBuf,
-
-    /// The path to the output file - defaults to the
-    /// input file path with an executable extension
-    #[clap(short, long)]
-    pub output: Option<PathBuf>,
-
-    /// The target to compile for in the format `os-arch` -
-    /// defaults to the os and arch of the current system
-    #[clap(short, long)]
-    pub target: Option<BuildTarget>,
-}
-
-impl BuildCommand {
-    pub async fn run(self) -> Result<ExitCode> {
-        // Derive target spec to use, or default to the current host system
-        let target = self.target.unwrap_or_else(BuildTarget::current_system);
-
-        // Derive paths to use, and make sure the output path is
-        // not the same as the input, so that we don't overwrite it
-        let output_path = self
-            .output
-            .clone()
-            .unwrap_or_else(|| remove_source_file_ext(&self.input));
-        let output_path = output_path.with_extension(target.exe_extension());
-        if output_path == self.input {
-            if self.output.is_some() {
-                bail!("output path cannot be the same as input path");
-            }
-            bail!("output path cannot be the same as input path, please specify a different output path");
-        }
-
-        // Try to read the given input file
-        // FUTURE: We should try and resolve a full require file graph using the input
-        // path here instead, see the notes in the `standalone` module for more details
-        let source_code = fs::read(&self.input)
-            .await
-            .context("failed to read input file")?;
-
-        // Derive the base executable path based on the arguments provided
-        let base_exe_path = get_or_download_base_executable(target).await?;
-
-        // Read the contents of the lune interpreter as our starting point
-        println!(
-            "Compiling standalone binary from {}",
-            style(self.input.display()).green()
-        );
-        let patched_bin = Metadata::create_env_patched_bin(base_exe_path, source_code)
-            .await
-            .context("failed to create patched binary")?;
-
-        // And finally write the patched binary to the output file
-        println!(
-            "Writing standalone binary to {}",
-            style(output_path.display()).blue()
-        );
-        write_executable_file_to(output_path, patched_bin).await?; // Read & execute for all, write for owner
-
-        Ok(ExitCode::SUCCESS)
-    }
-}

crates/lune/src/cli/build/result.rs

@@ -1,24 +0,0 @@
-use thiserror::Error;
-
-use super::target::BuildTarget;
-
-/**
-    Errors that may occur when building a standalone binary
-*/
-#[derive(Debug, Error)]
-pub enum BuildError {
-    #[error("failed to find lune target '{0}' in GitHub release")]
-    ReleaseTargetNotFound(BuildTarget),
-    #[error("failed to find lune binary '{0}' in downloaded zip file")]
-    ZippedBinaryNotFound(String),
-    #[error("failed to download lune binary: {0}")]
-    Download(#[from] reqwest::Error),
-    #[error("failed to unzip lune binary: {0}")]
-    Unzip(#[from] zip_next::result::ZipError),
-    #[error("panicked while unzipping lune binary: {0}")]
-    UnzipJoin(#[from] tokio::task::JoinError),
-    #[error("io error: {0}")]
-    IoError(#[from] std::io::Error),
-}
-
-pub type BuildResult<T, E = BuildError> = std::result::Result<T, E>;

crates/lune/src/cli/build/target.rs

@@ -1,177 +0,0 @@
-use std::{env::consts::ARCH, fmt, path::PathBuf, str::FromStr};
-
-use directories::BaseDirs;
-use once_cell::sync::Lazy;
-
-static HOME_DIR: Lazy<PathBuf> = Lazy::new(|| {
-    BaseDirs::new()
-        .expect("could not find home directory")
-        .home_dir()
-        .to_path_buf()
-});
-
-pub static CACHE_DIR: Lazy<PathBuf> = Lazy::new(|| HOME_DIR.join(".lune").join("target"));
-
-/**
-    A target operating system supported by Lune
-*/
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum BuildTargetOS {
-    Windows,
-    Linux,
-    MacOS,
-}
-
-impl BuildTargetOS {
-    fn current_system() -> Self {
-        match std::env::consts::OS {
-            "windows" => Self::Windows,
-            "linux" => Self::Linux,
-            "macos" => Self::MacOS,
-            _ => panic!("unsupported target OS"),
-        }
-    }
-
-    fn exe_extension(self) -> &'static str {
-        // NOTE: We can't use the constants from std since
-        // they are only accessible for the current target
-        match self {
-            Self::Windows => "exe",
-            _ => "",
-        }
-    }
-
-    fn exe_suffix(self) -> &'static str {
-        match self {
-            Self::Windows => ".exe",
-            _ => "",
-        }
-    }
-}
-
-impl fmt::Display for BuildTargetOS {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Windows => write!(f, "windows"),
-            Self::Linux => write!(f, "linux"),
-            Self::MacOS => write!(f, "macos"),
-        }
-    }
-}
-
-impl FromStr for BuildTargetOS {
-    type Err = &'static str;
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s.trim().to_ascii_lowercase().as_str() {
-            "win" | "windows" => Ok(Self::Windows),
-            "linux" => Ok(Self::Linux),
-            "mac" | "macos" | "darwin" => Ok(Self::MacOS),
-            _ => Err("invalid target OS"),
-        }
-    }
-}
-
-/**
-    A target architecture supported by Lune
-*/
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum BuildTargetArch {
-    X86_64,
-    Aarch64,
-}
-
-impl BuildTargetArch {
-    fn current_system() -> Self {
-        match ARCH {
-            "x86_64" => Self::X86_64,
-            "aarch64" => Self::Aarch64,
-            _ => panic!("unsupported target architecture"),
-        }
-    }
-}
-
-impl fmt::Display for BuildTargetArch {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::X86_64 => write!(f, "x86_64"),
-            Self::Aarch64 => write!(f, "aarch64"),
-        }
-    }
-}
-
-impl FromStr for BuildTargetArch {
-    type Err = &'static str;
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s.trim().to_ascii_lowercase().as_str() {
-            "x86_64" | "x64" => Ok(Self::X86_64),
-            "aarch64" | "arm64" => Ok(Self::Aarch64),
-            _ => Err("invalid target architecture"),
-        }
-    }
-}
-
-/**
-    A full target description that Lune supports (OS + Arch)
-
-    This is used to determine the target to build for standalone binaries,
-    and to download the correct base executable for cross-compilation.
-
-    The target may be parsed from and displayed in the form `os-arch`.
-    Examples of valid targets are:
-
-    - `linux-aarch64`
-    - `linux-x86_64`
-    - `macos-aarch64`
-    - `macos-x86_64`
-    - `windows-x86_64`
-*/
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct BuildTarget {
-    pub os: BuildTargetOS,
-    pub arch: BuildTargetArch,
-}
-
-impl BuildTarget {
-    pub fn current_system() -> Self {
-        Self {
-            os: BuildTargetOS::current_system(),
-            arch: BuildTargetArch::current_system(),
-        }
-    }
-
-    pub fn is_current_system(&self) -> bool {
-        self.os == BuildTargetOS::current_system() && self.arch == BuildTargetArch::current_system()
-    }
-
-    pub fn exe_extension(&self) -> &'static str {
-        self.os.exe_extension()
-    }
-
-    pub fn exe_suffix(&self) -> &'static str {
-        self.os.exe_suffix()
-    }
-
-    pub fn cache_path(&self) -> PathBuf {
-        CACHE_DIR.join(format!("{self}{}", self.os.exe_extension()))
-    }
-}
-
-impl fmt::Display for BuildTarget {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}-{}", self.os, self.arch)
-    }
-}
-
-impl FromStr for BuildTarget {
-    type Err = &'static str;
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let (left, right) = s
-            .split_once('-')
-            .ok_or("target must be in the form `os-arch`")?;
-
-        let os = left.parse()?;
-        let arch = right.parse()?;
-
-        Ok(Self { os, arch })
-    }
-}

crates/lune/src/lib.rs

@@ -1,12 +0,0 @@
-#![allow(clippy::cargo_common_metadata)]
-
-mod rt;
-
-// TODO: Remove this in 0.9.0 since it is now available as a separate crate!
-#[cfg(feature = "std-roblox")]
-pub use lune_roblox as roblox;
-
-#[cfg(test)]
-mod tests;
-
-pub use crate::rt::{Runtime, RuntimeError, RuntimeResult};

crates/lune/src/main.rs

@@ -1,42 +0,0 @@
-#![allow(clippy::cargo_common_metadata)]
-
-use std::process::ExitCode;
-
-#[cfg(feature = "cli")]
-pub(crate) mod cli;
-
-pub(crate) mod standalone;
-
-use lune_utils::fmt::Label;
-
-#[tokio::main(flavor = "multi_thread")]
-async fn main() -> ExitCode {
-    tracing_subscriber::fmt()
-        .compact()
-        .with_env_filter(tracing_subscriber::filter::EnvFilter::from_default_env())
-        .with_target(true)
-        .with_timer(tracing_subscriber::fmt::time::uptime())
-        .with_level(true)
-        .init();
-
-    if let Some(bin) = standalone::check().await {
-        return standalone::run(bin).await.unwrap();
-    }
-
-    #[cfg(feature = "cli")]
-    {
-        match cli::Cli::new().run().await {
-            Ok(code) => code,
-            Err(err) => {
-                eprintln!("{}\n{err:?}", Label::Error);
-                ExitCode::FAILURE
-            }
-        }
-    }
-
-    #[cfg(not(feature = "cli"))]
-    {
-        eprintln!("{}\nCLI feature is disabled", Label::Error);
-        ExitCode::FAILURE
-    }
-}

crates/lune/src/rt/mod.rs

@@ -1,5 +0,0 @@
-mod result;
-mod runtime;
-
-pub use self::result::{RuntimeError, RuntimeResult};
-pub use self::runtime::Runtime;

crates/lune/src/rt/runtime.rs

@@ -1,195 +0,0 @@
-#![allow(clippy::missing_panics_doc)]
-
-use std::{
-    rc::Rc,
-    sync::{
-        atomic::{AtomicBool, Ordering},
-        Arc,
-    },
-};
-
-use lune_utils::jit::JitStatus;
-use mlua::prelude::*;
-use mlua_luau_scheduler::{Functions, Scheduler};
-use self_cell::self_cell;
-
-use super::{RuntimeError, RuntimeResult};
-
-// NOTE: We need to use self_cell to create a self-referential
-// struct storing both the Lua VM and the scheduler. The scheduler
-// needs to be created at the same time so that we can also create
-// and inject the scheduler functions which will be used across runs.
-self_cell! {
-    struct RuntimeInner {
-        owner: Rc<Lua>,
-        #[covariant]
-        dependent: Scheduler,
-    }
-}
-
-impl RuntimeInner {
-    fn create() -> LuaResult<Self> {
-        let lua = Rc::new(Lua::new());
-
-        lua.set_app_data(Rc::downgrade(&lua));
-        lua.set_app_data(Vec::<String>::new());
-
-        Self::try_new(lua, |lua| {
-            let sched = Scheduler::new(lua);
-            let fns = Functions::new(lua)?;
-
-            // Overwrite some globals that are not compatible with our scheduler
-            let co = lua.globals().get::<_, LuaTable>("coroutine")?;
-            co.set("resume", fns.resume.clone())?;
-            co.set("wrap", fns.wrap.clone())?;
-
-            // Inject all the globals that are enabled
-            #[cfg(any(
-                feature = "std-datetime",
-                feature = "std-fs",
-                feature = "std-luau",
-                feature = "std-net",
-                feature = "std-process",
-                feature = "std-regex",
-                feature = "std-roblox",
-                feature = "std-serde",
-                feature = "std-stdio",
-                feature = "std-task",
-            ))]
-            {
-                lune_std::set_global_version(lua, env!("CARGO_PKG_VERSION"));
-                lune_std::inject_globals(lua)?;
-            }
-
-            // Sandbox the Luau VM and make it go zooooooooom
-            lua.sandbox(true)?;
-
-            // _G table needs to be injected again after sandboxing,
-            // otherwise it will be read-only and completely unusable
-            #[cfg(any(
-                feature = "std-datetime",
-                feature = "std-fs",
-                feature = "std-luau",
-                feature = "std-net",
-                feature = "std-process",
-                feature = "std-regex",
-                feature = "std-roblox",
-                feature = "std-serde",
-                feature = "std-stdio",
-                feature = "std-task",
-            ))]
-            {
-                let g_table = lune_std::LuneStandardGlobal::GTable;
-                lua.globals().set(g_table.name(), g_table.create(lua)?)?;
-            }
-
-            Ok(sched)
-        })
-    }
-
-    fn lua(&self) -> &Lua {
-        self.borrow_owner()
-    }
-
-    fn scheduler(&self) -> &Scheduler {
-        self.borrow_dependent()
-    }
-}
-
-/**
-    A Lune runtime.
-*/
-pub struct Runtime {
-    inner: RuntimeInner,
-    jit_status: JitStatus,
-}
-
-impl Runtime {
-    /**
-        Creates a new Lune runtime, with a new Luau VM.
-
-        Injects standard globals and libraries if any of the `std` features are enabled.
-    */
-    #[must_use]
-    #[allow(clippy::new_without_default)]
-    pub fn new() -> Self {
-        Self {
-            inner: RuntimeInner::create().expect("Failed to create runtime"),
-            jit_status: JitStatus::default(),
-        }
-    }
-
-    /**
-        Sets arguments to give in `process.args` for Lune scripts.
-    */
-    #[must_use]
-    pub fn with_args<A, S>(self, args: A) -> Self
-    where
-        A: IntoIterator<Item = S>,
-        S: Into<String>,
-    {
-        let args = args.into_iter().map(Into::into).collect::<Vec<_>>();
-        self.inner.lua().set_app_data(args);
-        self
-    }
-
-    /**
-        Enables or disables JIT compilation.
-    */
-    #[must_use]
-    pub fn with_jit(mut self, jit_status: impl Into<JitStatus>) -> Self {
-        self.jit_status = jit_status.into();
-        self
-    }
-
-    /**
-        Runs a Lune script inside of the current runtime.
-
-        This will preserve any modifications to global values / context.
-
-        # Errors
-
-        This function will return an error if the script fails to run.
-    */
-    pub async fn run(
-        &mut self,
-        script_name: impl AsRef<str>,
-        script_contents: impl AsRef<[u8]>,
-    ) -> RuntimeResult<(u8, Vec<LuaValue>)> {
-        let lua = self.inner.lua();
-        let sched = self.inner.scheduler();
-
-        // Add error callback to format errors nicely + store status
-        let got_any_error = Arc::new(AtomicBool::new(false));
-        let got_any_inner = Arc::clone(&got_any_error);
-        self.inner.scheduler().set_error_callback(move |e| {
-            got_any_inner.store(true, Ordering::SeqCst);
-            eprintln!("{}", RuntimeError::from(e));
-        });
-
-        // Enable / disable the JIT as requested and store the current status as AppData
-        lua.set_app_data(self.jit_status);
-        lua.enable_jit(self.jit_status.enabled());
-
-        // Load our "main" thread
-        let main = lua
-            .load(script_contents.as_ref())
-            .set_name(script_name.as_ref());
-
-        // Run it on our scheduler until it and any other spawned threads complete
-        let main_thread_id = sched.push_thread_back(main, ())?;
-        sched.run().await;
-
-        let main_thread_res = match sched.get_thread_result(main_thread_id) {
-            Some(res) => res,
-            None => LuaValue::Nil.into_lua_multi(lua),
-        }?;
-
-        Ok((
-            sched
-                .get_exit_code()
-                .unwrap_or(u8::from(got_any_error.load(Ordering::SeqCst))),
-            main_thread_res.into_vec(),
-        ))
-    }
-}

crates/mlua-luau-scheduler/Cargo.toml

@@ -1,67 +0,0 @@
-[package]
-name = "mlua-luau-scheduler"
-version = "0.0.2"
-edition = "2021"
-license = "MPL-2.0"
-repository = "https://github.com/lune-org/lune"
-description = "Luau-based async scheduler, using mlua and async-executor"
-readme = "README.md"
-keywords = ["async", "luau", "scheduler"]
-categories = ["async"]
-
-[lib]
-path = "src/lib.rs"
-
-[lints]
-workspace = true
-
-[dependencies]
-async-executor = "1.8"
-blocking = "1.5"
-concurrent-queue = "2.4"
-derive_more = "0.99"
-event-listener = "4.0"
-futures-lite = "2.2"
-rustc-hash = "1.1"
-tracing = "0.1"
-
-mlua = { version = "0.9.9", features = [
-    "luau",
-    "luau-jit",
-    "async",
-    "serialize",
-] }
-
-[dev-dependencies]
-async-fs = "2.1"
-async-io = "2.3"
-tracing-subscriber = { version = "0.3", features = ["env-filter"] }
-tracing-tracy = "0.11"
-
-[[example]]
-name = "basic_sleep"
-test = true
-
-[[example]]
-name = "basic_spawn"
-test = true
-
-[[example]]
-name = "callbacks"
-test = true
-
-[[example]]
-name = "exit_code"
-test = true
-
-[[example]]
-name = "lots_of_threads"
-test = true
-
-[[example]]
-name = "scheduler_ordering"
-test = true
-
-[[example]]
-name = "tracy"
-test = false

crates/mlua-luau-scheduler/README.md

@@ -1,78 +0,0 @@
-<!-- markdownlint-disable MD033 -->
-<!-- markdownlint-disable MD041 -->
-
-# `mlua-luau-scheduler`
-
-An async scheduler for Luau, using [`mlua`][mlua] and built on top of [`async-executor`][async-executor].
-
-This crate is runtime-agnostic and is compatible with any async runtime, including [Tokio][tokio], [smol][smol], [async-std][async-std], and others. </br>
-However, since many dependencies are shared with [smol][smol], depending on it over other runtimes may be preferred.
-
-[async-executor]: https://crates.io/crates/async-executor
-[async-std]: https://async.rs
-[mlua]: https://crates.io/crates/mlua
-[smol]: https://github.com/smol-rs/smol
-[tokio]: https://tokio.rs
-
-## Example Usage
-
-### 1. Import dependencies
-
-```rs
-use std::time::{Duration, Instant};
-use std::io::ErrorKind;
-
-use async_io::{block_on, Timer};
-use async_fs::read_to_string;
-
-use mlua::prelude::*;
-use mlua_luau_scheduler::*;
-```
-
-### 2. Set up Lua environment
-
-```rs
-let lua = Lua::new();
-
-lua.globals().set(
-    "sleep",
-    lua.create_async_function(|_, duration: f64| async move {
-        let before = Instant::now();
-        let after = Timer::after(Duration::from_secs_f64(duration)).await;
-        Ok((after - before).as_secs_f64())
-    })?,
-)?;
-
-lua.globals().set(
-    "readFile",
-    lua.create_async_function(|lua, path: String| async move {
-        // Spawn background task that does not take up resources on the lua thread
-        // Normally, futures in mlua can not be shared across threads, but this can
-        let task = lua.spawn(async move {
-            match read_to_string(path).await {
-                Ok(s) => Ok(Some(s)),
-                Err(e) if e.kind() == ErrorKind::NotFound => Ok(None),
-                Err(e) => Err(e),
-            }
-        });
-        task.await.into_lua_err()
-    })?,
-)?;
-```
-
-### 3. Set up scheduler, run threads
-
-```rs
-let sched = Scheduler::new(&lua)?;
-
-// We can create multiple lua threads ...
-let sleepThread = lua.load("sleep(0.1)");
-let fileThread = lua.load("readFile(\"Cargo.toml\")");
-
-// ... spawn them both onto the scheduler ...
-sched.push_thread_front(sleepThread, ());
-sched.push_thread_front(fileThread, ());
-
-// ... and run until they finish
-block_on(sched.run());
-```

crates/mlua-luau-scheduler/examples/basic_sleep.rs

@@ -1,45 +0,0 @@
-#![allow(clippy::missing_errors_doc)]
-#![allow(clippy::cargo_common_metadata)]
-
-use std::time::{Duration, Instant};
-
-use async_io::{block_on, Timer};
-
-use mlua::prelude::*;
-use mlua_luau_scheduler::Scheduler;
-
-const MAIN_SCRIPT: &str = include_str!("./lua/basic_sleep.luau");
-
-pub fn main() -> LuaResult<()> {
-    tracing_subscriber::fmt()
-        .with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
-        .with_target(false)
-        .without_time()
-        .init();
-
-    // Set up persistent Lua environment
-    let lua = Lua::new();
-    lua.globals().set(
-        "sleep",
-        lua.create_async_function(|_, duration: f64| async move {
-            let before = Instant::now();
-            let after = Timer::after(Duration::from_secs_f64(duration)).await;
-            Ok((after - before).as_secs_f64())
-        })?,
-    )?;
-
-    // Load the main script into a scheduler
-    let sched = Scheduler::new(&lua);
-    let main = lua.load(MAIN_SCRIPT);
-    sched.push_thread_front(main, ())?;
-
-    // Run until completion
-    block_on(sched.run());
-
-    Ok(())
-}
-
-#[test]
-fn test_basic_sleep() -> LuaResult<()> {
-    main()
-}

crates/mlua-luau-scheduler/examples/basic_spawn.rs

@@ -1,64 +0,0 @@
-#![allow(clippy::missing_errors_doc)]
-#![allow(clippy::cargo_common_metadata)]
-
-use std::io::ErrorKind;
-
-use async_fs::read_to_string;
-use async_io::block_on;
-
-use mlua::prelude::*;
-use mlua_luau_scheduler::{LuaSpawnExt, Scheduler};
-
-const MAIN_SCRIPT: &str = include_str!("./lua/basic_spawn.luau");
-
-pub fn main() -> LuaResult<()> {
-    tracing_subscriber::fmt()
-        .with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
-        .with_target(false)
-        .without_time()
-        .init();
-
-    // Set up persistent Lua environment
-    let lua = Lua::new();
-    lua.globals().set(
-        "readFile",
-        lua.create_async_function(|lua, path: String| async move {
-            // Spawn background task that does not take up resources on the Lua thread
-            let task = lua.spawn(async move {
-                match read_to_string(path).await {
-                    Ok(s) => Ok(Some(s)),
-                    Err(e) if e.kind() == ErrorKind::NotFound => Ok(None),
-                    Err(e) => Err(e),
-                }
-            });
-
-            // Wait for it to complete
-            let result = task.await.into_lua_err();
-
-            // We can also spawn local tasks that do take up resources
-            // on the Lua thread, but that do not have the Send bound
-            if result.is_ok() {
-                lua.spawn_local(async move {
-                    println!("File read successfully!");
-                });
-            }
-
-            result
-        })?,
-    )?;
-
-    // Load the main script into a scheduler
-    let sched = Scheduler::new(&lua);
-    let main = lua.load(MAIN_SCRIPT);
-    sched.push_thread_front(main, ())?;
-
-    // Run until completion
-    block_on(sched.run());
-
-    Ok(())
-}
-
-#[test]
-fn test_basic_spawn() -> LuaResult<()> {
-    main()
-}

crates/mlua-luau-scheduler/examples/callbacks.rs

@@ -1,48 +0,0 @@
-#![allow(clippy::missing_errors_doc)]
-#![allow(clippy::missing_panics_doc)]
-#![allow(clippy::cargo_common_metadata)]
-
-use mlua::prelude::*;
-use mlua_luau_scheduler::Scheduler;
-
-use async_io::block_on;
-
-const MAIN_SCRIPT: &str = include_str!("./lua/callbacks.luau");
-
-pub fn main() -> LuaResult<()> {
-    tracing_subscriber::fmt()
-        .with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
-        .with_target(false)
-        .without_time()
-        .init();
-
-    // Set up persistent Lua environment
-    let lua = Lua::new();
-
-    // Create a new scheduler with custom callbacks
-    let sched = Scheduler::new(&lua);
-    sched.set_error_callback(|e| {
-        println!(
-            "Captured error from Lua!\n{}\n{e}\n{}",
-            "-".repeat(15),
-            "-".repeat(15)
-        );
-    });
-
-    // Load the main script into the scheduler, and keep track of the thread we spawn
-    let main = lua.load(MAIN_SCRIPT);
-    let id = sched.push_thread_front(main, ())?;
-
-    // Run until completion
-    block_on(sched.run());
-
-    // We should have gotten the error back from our script
-    assert!(sched.get_thread_result(id).unwrap().is_err());
-
-    Ok(())
-}
-
-#[test]
-fn test_callbacks() -> LuaResult<()> {
-    main()
-}

crates/mlua-luau-scheduler/examples/exit_code.rs

@@ -1,43 +0,0 @@
-#![allow(clippy::missing_errors_doc)]
-#![allow(clippy::missing_panics_doc)]
-#![allow(clippy::cargo_common_metadata)]
-
-use async_io::block_on;
-
-use mlua::prelude::*;
-use mlua_luau_scheduler::{Functions, Scheduler};
-
-const MAIN_SCRIPT: &str = include_str!("./lua/exit_code.luau");
-
-pub fn main() -> LuaResult<()> {
-    tracing_subscriber::fmt()
-        .with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
-        .with_target(false)
-        .without_time()
-        .init();
-
-    // Set up persistent Lua environment
-    let lua = Lua::new();
-    let sched = Scheduler::new(&lua);
-    let fns = Functions::new(&lua)?;
-
-    lua.globals().set("exit", fns.exit)?;
-
-    // Load the main script into the scheduler
-    let main = lua.load(MAIN_SCRIPT);
-    sched.push_thread_front(main, ())?;
-
-    // Run until completion
-    block_on(sched.run());
-
-    // Verify that we got a correct exit code
-    let code = sched.get_exit_code().unwrap_or_default();
-    assert_eq!(code, 1);
-
-    Ok(())
-}
-
-#[test]
-fn test_exit_code() -> LuaResult<()> {
-    main()
-}

crates/mlua-luau-scheduler/examples/lots_of_threads.rs

@@ -1,51 +0,0 @@
-#![allow(clippy::missing_errors_doc)]
-#![allow(clippy::cargo_common_metadata)]
-
-use std::time::Duration;
-
-use async_io::{block_on, Timer};
-
-use mlua::prelude::*;
-use mlua_luau_scheduler::{Functions, Scheduler};
-
-const MAIN_SCRIPT: &str = include_str!("./lua/lots_of_threads.luau");
-
-const ONE_NANOSECOND: Duration = Duration::from_nanos(1);
-
-pub fn main() -> LuaResult<()> {
-    tracing_subscriber::fmt()
-        .with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
-        .with_target(false)
-        .without_time()
-        .init();
-
-    // Set up persistent Lua environment
-    let lua = Lua::new();
-    let sched = Scheduler::new(&lua);
-    let fns = Functions::new(&lua)?;
-
-    lua.globals().set("spawn", fns.spawn)?;
-    lua.globals().set(
-        "sleep",
-        lua.create_async_function(|_, ()| async move {
-            // Obviously we can't sleep for a single nanosecond since
-            // this uses OS scheduling under the hood, but we can try
-            Timer::after(ONE_NANOSECOND).await;
-            Ok(())
-        })?,
-    )?;
-
-    // Load the main script into the scheduler
-    let main = lua.load(MAIN_SCRIPT);
-    sched.push_thread_front(main, ())?;
-
-    // Run until completion
-    block_on(sched.run());
-
-    Ok(())
-}
-
-#[test]
-fn test_lots_of_threads() -> LuaResult<()> {
-    main()
-}

crates/mlua-luau-scheduler/examples/lua/basic_sleep.luau

@@ -1,13 +0,0 @@
---!nocheck
---!nolint UnknownGlobal
-
-print("Sleeping for 3 seconds...")
-
-sleep(1)
-print("1 second passed")
-
-sleep(1)
-print("2 seconds passed")
-
-sleep(1)
-print("3 seconds passed")

crates/mlua-luau-scheduler/examples/lua/basic_spawn.luau

@@ -1,17 +0,0 @@
---!nocheck
---!nolint UnknownGlobal
-
-local _, err = pcall(function()
-	local file = readFile("Cargo.toml")
-	if file ~= nil then
-		print("Cargo.toml found!")
-		print("Contents:")
-		print(file)
-	else
-		print("Cargo.toml not found!")
-	end
-end)
-
-if err ~= nil then
-	print("Error while reading file: " .. err)
-end

crates/mlua-luau-scheduler/examples/lua/callbacks.luau

@@ -1,4 +0,0 @@
---!nocheck
---!nolint UnknownGlobal
-
-error("Oh no! Something went very very wrong!")

crates/mlua-luau-scheduler/examples/lua/exit_code.luau

@@ -1,8 +0,0 @@
---!nocheck
---!nolint UnknownGlobal
-
-print("Setting exit code manually")
-
-exit(1)
-
-error("unreachable")

crates/mlua-luau-scheduler/examples/lua/lots_of_threads.luau

@@ -1,29 +0,0 @@
---!nocheck
---!nolint UnknownGlobal
-
-local NUM_BATCHES = 10
-local NUM_THREADS = 100_000
-
-print(`Spawning {NUM_BATCHES * NUM_THREADS} threads split into {NUM_BATCHES} batches\n`)
-
-local before = os.clock()
-for i = 1, NUM_BATCHES do
-	print(`Batch {i} of {NUM_BATCHES}`)
-	local thread = coroutine.running()
-
-	local counter = 0
-	for j = 1, NUM_THREADS do
-		spawn(function()
-			sleep(0.1)
-			counter += 1
-			if counter == NUM_THREADS then
-				spawn(thread)
-			end
-		end)
-	end
-
-	coroutine.yield()
-end
-local after = os.clock()
-
-print(`\nSpawned {NUM_BATCHES * NUM_THREADS} sleeping threads in {after - before}s`)

crates/mlua-luau-scheduler/examples/lua/scheduler_ordering.luau

@@ -1,34 +0,0 @@
---!nocheck
---!nolint UnknownGlobal
-
-local nums = {}
-local function insert(n: number)
-	table.insert(nums, n)
-	print(n)
-end
-
-insert(1)
-
--- Defer will run at the end of the resumption cycle, but without yielding
-defer(function()
-	insert(5)
-end)
-
--- Spawn will instantly run up until the first yield, and must then be resumed manually ...
-spawn(function()
-	insert(2)
-	coroutine.yield()
-	error("unreachable code")
-end)
-
--- ... unless calling functions created using `lua.create_async_function(...)`,
--- which will resume their calling thread with their result automatically
-spawn(function()
-	insert(3)
-	sleep(1)
-	insert(6)
-end)
-
-insert(4)
-
-return nums

crates/mlua-luau-scheduler/examples/scheduler_ordering.rs

@@ -1,56 +0,0 @@
-#![allow(clippy::missing_errors_doc)]
-#![allow(clippy::missing_panics_doc)]
-#![allow(clippy::cargo_common_metadata)]
-
-use std::time::{Duration, Instant};
-
-use async_io::{block_on, Timer};
-
-use mlua::prelude::*;
-use mlua_luau_scheduler::{Functions, Scheduler};
-
-const MAIN_SCRIPT: &str = include_str!("./lua/scheduler_ordering.luau");
-
-pub fn main() -> LuaResult<()> {
-    tracing_subscriber::fmt()
-        .with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
-        .with_target(false)
-        .without_time()
-        .init();
-
-    // Set up persistent Lua environment
-    let lua = Lua::new();
-    let sched = Scheduler::new(&lua);
-    let fns = Functions::new(&lua)?;
-
-    lua.globals().set("spawn", fns.spawn)?;
-    lua.globals().set("defer", fns.defer)?;
-    lua.globals().set(
-        "sleep",
-        lua.create_async_function(|_, duration: Option<f64>| async move {
-            let duration = duration.unwrap_or_default().max(1.0 / 250.0);
-            let before = Instant::now();
-            let after = Timer::after(Duration::from_secs_f64(duration)).await;
-            Ok((after - before).as_secs_f64())
-        })?,
-    )?;
-
-    // Load the main script into the scheduler, and keep track of the thread we spawn
-    let main = lua.load(MAIN_SCRIPT);
-    let id = sched.push_thread_front(main, ())?;
-
-    // Run until completion
-    block_on(sched.run());
-
-    // We should have gotten proper values back from our script
-    let res = sched.get_thread_result(id).unwrap().unwrap();
-    let nums = Vec::<usize>::from_lua_multi(res, &lua)?;
-    assert_eq!(nums, vec![1, 2, 3, 4, 5, 6]);
-
-    Ok(())
-}
-
-#[test]
-fn test_scheduler_ordering() -> LuaResult<()> {
-    main()
-}

crates/mlua-luau-scheduler/examples/tracy.rs

@@ -1,61 +0,0 @@
-/*
-    NOTE: This example is the same as "lots_of_threads", but with tracy set up for performance profiling.
-
-    How to run:
-
-    1. Install tracy
-       - Follow the instructions at https://github.com/wolfpld/tracy
-       - Or install via something like homebrew: `brew install tracy`
-    2. Run the server (`tracy`) in a terminal
-    3. Run the example in another terminal
-       - `export RUST_LOG=trace`
-       - `cargo run --example tracy`
-*/
-
-#![allow(clippy::missing_errors_doc)]
-#![allow(clippy::cargo_common_metadata)]
-
-use std::time::Duration;
-
-use async_io::{block_on, Timer};
-use tracing_subscriber::layer::SubscriberExt;
-use tracing_tracy::{client::Client as TracyClient, TracyLayer};
-
-use mlua::prelude::*;
-use mlua_luau_scheduler::{Functions, Scheduler};
-
-const MAIN_SCRIPT: &str = include_str!("./lua/lots_of_threads.luau");
-
-const ONE_NANOSECOND: Duration = Duration::from_nanos(1);
-
-pub fn main() -> LuaResult<()> {
-    let _client = TracyClient::start();
-    let _ = tracing::subscriber::set_global_default(
-        tracing_subscriber::registry().with(TracyLayer::default()),
-    );
-
-    // Set up persistent Lua environment
-    let lua = Lua::new();
-    let sched = Scheduler::new(&lua);
-    let fns = Functions::new(&lua)?;
-
-    lua.globals().set("spawn", fns.spawn)?;
-    lua.globals().set(
-        "sleep",
-        lua.create_async_function(|_, ()| async move {
-            // Obviously we can't sleep for a single nanosecond since
-            // this uses OS scheduling under the hood, but we can try
-            Timer::after(ONE_NANOSECOND).await;
-            Ok(())
-        })?,
-    )?;
-
-    // Load the main script into the scheduler
-    let main = lua.load(MAIN_SCRIPT);
-    sched.push_thread_front(main, ())?;
-
-    // Run until completion
-    block_on(sched.run());
-
-    Ok(())
-}

crates/mlua-luau-scheduler/src/error_callback.rs

@@ -1,45 +0,0 @@
-use std::{cell::RefCell, rc::Rc};
-
-use mlua::prelude::*;
-
-type ErrorCallback = Box<dyn Fn(LuaError) + Send + 'static>;
-
-#[derive(Clone)]
-pub(crate) struct ThreadErrorCallback {
-    inner: Rc<RefCell<Option<ErrorCallback>>>,
-}
-
-impl ThreadErrorCallback {
-    pub fn new() -> Self {
-        Self {
-            inner: Rc::new(RefCell::new(None)),
-        }
-    }
-
-    pub fn replace(&self, callback: impl Fn(LuaError) + Send + 'static) {
-        self.inner.borrow_mut().replace(Box::new(callback));
-    }
-
-    pub fn clear(&self) {
-        self.inner.borrow_mut().take();
-    }
-
-    pub fn call(&self, error: &LuaError) {
-        if let Some(cb) = &*self.inner.borrow() {
-            cb(error.clone());
-        }
-    }
-}
-
-#[allow(clippy::needless_pass_by_value)]
-fn default_error_callback(e: LuaError) {
-    eprintln!("{e}");
-}
-
-impl Default for ThreadErrorCallback {
-    fn default() -> Self {
-        let this = Self::new();
-        this.replace(default_error_callback);
-        this
-    }
-}

crates/mlua-luau-scheduler/src/exit.rs

@@ -1,31 +0,0 @@
-use std::{cell::Cell, rc::Rc};
-
-use event_listener::Event;
-
-#[derive(Debug, Clone)]
-pub(crate) struct Exit {
-    code: Rc<Cell<Option<u8>>>,
-    event: Rc<Event>,
-}
-
-impl Exit {
-    pub fn new() -> Self {
-        Self {
-            code: Rc::new(Cell::new(None)),
-            event: Rc::new(Event::new()),
-        }
-    }
-
-    pub fn set(&self, code: u8) {
-        self.code.set(Some(code));
-        self.event.notify(usize::MAX);
-    }
-
-    pub fn get(&self) -> Option<u8> {
-        self.code.get()
-    }
-
-    pub async fn listen(&self) {
-        self.event.listen().await;
-    }
-}

crates/mlua-luau-scheduler/src/functions.rs

@@ -1,279 +0,0 @@
-#![allow(clippy::too_many_lines)]
-
-use mlua::prelude::*;
-
-use crate::{
-    error_callback::ThreadErrorCallback,
-    queue::{DeferredThreadQueue, SpawnedThreadQueue},
-    result_map::ThreadResultMap,
-    thread_id::ThreadId,
-    traits::LuaSchedulerExt,
-    util::{is_poll_pending, LuaThreadOrFunction, ThreadResult},
-};
-
-const ERR_METADATA_NOT_ATTACHED: &str = "\
-Lua state does not have scheduler metadata attached!\
-\nThis is most likely caused by creating functions outside of a scheduler.\
-\nScheduler functions must always be created from within an active scheduler.\
-";
-
-const EXIT_IMPL_LUA: &str = r"
-exit(...)
-yield()
-";
-
-const WRAP_IMPL_LUA: &str = r"
-local t = create(...)
-return function(...)
-    local r = { resume(t, ...) }
-    if r[1] then
-        return select(2, unpack(r))
-    else
-        error(r[2], 2)
-    end
-end
-";
-
-/**
-    A collection of lua functions that may be called to interact with a [`Scheduler`].
-
-    Note that these may all be implemented using [`LuaSchedulerExt`], however, this struct
-    is implemented using internal (non-public) APIs, and generally has better performance.
-*/
-pub struct Functions<'lua> {
-    /**
-        Implementation of `coroutine.resume` that handles async polling properly.
-
-        Defers onto the scheduler queue if the thread calls an async function.
-    */
-    pub resume: LuaFunction<'lua>,
-    /**
-        Implementation of `coroutine.wrap` that handles async polling properly.
-
-        Defers onto the scheduler queue if the thread calls an async function.
-    */
-    pub wrap: LuaFunction<'lua>,
-    /**
-        Resumes a function / thread once instantly, and runs until first yield.
-
-        Spawns onto the scheduler queue if not completed.
-    */
-    pub spawn: LuaFunction<'lua>,
-    /**
-        Defers a function / thread onto the scheduler queue.
-
-        Does not resume instantly, only adds to the queue.
-    */
-    pub defer: LuaFunction<'lua>,
-    /**
-        Cancels a function / thread, removing it from the queue.
-    */
-    pub cancel: LuaFunction<'lua>,
-    /**
-        Exits the scheduler, stopping all other threads and closing the scheduler.
-
-        Yields the calling thread to ensure that it does not continue.
-    */
-    pub exit: LuaFunction<'lua>,
-}
-
-impl<'lua> Functions<'lua> {
-    /**
-        Creates a new collection of Lua functions that may be called to interact with a [`Scheduler`].
-
-        # Errors
-
-        Errors when out of memory, or if default Lua globals are missing.
-
-        # Panics
-
-        Panics when the given [`Lua`] instance does not have an attached [`Scheduler`].
-    */
-    pub fn new(lua: &'lua Lua) -> LuaResult<Self> {
-        let spawn_queue = lua
-            .app_data_ref::<SpawnedThreadQueue>()
-            .expect(ERR_METADATA_NOT_ATTACHED)
-            .clone();
-        let defer_queue = lua
-            .app_data_ref::<DeferredThreadQueue>()
-            .expect(ERR_METADATA_NOT_ATTACHED)
-            .clone();
-        let error_callback = lua
-            .app_data_ref::<ThreadErrorCallback>()
-            .expect(ERR_METADATA_NOT_ATTACHED)
-            .clone();
-        let result_map = lua
-            .app_data_ref::<ThreadResultMap>()
-            .expect(ERR_METADATA_NOT_ATTACHED)
-            .clone();
-
-        let resume_queue = defer_queue.clone();
-        let resume_map = result_map.clone();
-        let resume =
-            lua.create_function(move |lua, (thread, args): (LuaThread, LuaMultiValue)| {
-                let _span = tracing::trace_span!("Scheduler::fn_resume").entered();
-                match thread.resume::<_, LuaMultiValue>(args.clone()) {
-                    Ok(v) => {
-                        if v.get(0).is_some_and(is_poll_pending) {
-                            // Pending, defer to scheduler and return nil
-                            resume_queue.push_item(lua, &thread, args)?;
-                            (true, LuaValue::Nil).into_lua_multi(lua)
-                        } else {
-                            // Not pending, store the value if thread is done
-                            if thread.status() != LuaThreadStatus::Resumable {
-                                let id = ThreadId::from(&thread);
-                                if resume_map.is_tracked(id) {
-                                    let res = ThreadResult::new(Ok(v.clone()), lua);
-                                    resume_map.insert(id, res);
-                                }
-                            }
-                            (true, v).into_lua_multi(lua)
-                        }
-                    }
-                    Err(e) => {
-                        // Not pending, store the error
-                        let id = ThreadId::from(&thread);
-                        if resume_map.is_tracked(id) {
-                            let res = ThreadResult::new(Err(e.clone()), lua);
-                            resume_map.insert(id, res);
-                        }
-                        (false, e.to_string()).into_lua_multi(lua)
-                    }
-                }
-            })?;
-
-        let wrap_env = lua.create_table_from(vec![
-            ("resume", resume.clone()),
-            ("error", lua.globals().get::<_, LuaFunction>("error")?),
-            ("select", lua.globals().get::<_, LuaFunction>("select")?),
-            ("unpack", lua.globals().get::<_, LuaFunction>("unpack")?),
-            (
-                "create",
-                lua.globals()
-                    .get::<_, LuaTable>("coroutine")?
-                    .get::<_, LuaFunction>("create")?,
-            ),
-        ])?;
-        let wrap = lua
-            .load(WRAP_IMPL_LUA)
-            .set_name("=__scheduler_wrap")
-            .set_environment(wrap_env)
-            .into_function()?;
-
-        let spawn_map = result_map.clone();
-        let spawn = lua.create_function(
-            move |lua, (tof, args): (LuaThreadOrFunction, LuaMultiValue)| {
-                let _span = tracing::trace_span!("Scheduler::fn_spawn").entered();
-                let thread = tof.into_thread(lua)?;
-                if thread.status() == LuaThreadStatus::Resumable {
-                    // NOTE: We need to resume the thread once instantly for correct behavior,
-                    // and only if we get the pending value back we can spawn to async executor
-                    match thread.resume::<_, LuaMultiValue>(args.clone()) {
-                        Ok(v) => {
-                            if v.get(0).is_some_and(is_poll_pending) {
-                                spawn_queue.push_item(lua, &thread, args)?;
-                            } else {
-                                // Not pending, store the value if thread is done
-                                if thread.status() != LuaThreadStatus::Resumable {
-                                    let id = ThreadId::from(&thread);
-                                    if spawn_map.is_tracked(id) {
-                                        let res = ThreadResult::new(Ok(v), lua);
-                                        spawn_map.insert(id, res);
-                                    }
-                                }
-                            }
-                        }
-                        Err(e) => {
-                            error_callback.call(&e);
-                            // Not pending, store the error
-                            let id = ThreadId::from(&thread);
-                            if spawn_map.is_tracked(id) {
-                                let res = ThreadResult::new(Err(e), lua);
-                                spawn_map.insert(id, res);
-                            }
-                        }
-                    };
-                }
-                Ok(thread)
-            },
-        )?;
-
-        let defer = lua.create_function(
-            move |lua, (tof, args): (LuaThreadOrFunction, LuaMultiValue)| {
-                let _span = tracing::trace_span!("Scheduler::fn_defer").entered();
-                let thread = tof.into_thread(lua)?;
-                if thread.status() == LuaThreadStatus::Resumable {
-                    defer_queue.push_item(lua, &thread, args)?;
-                }
-                Ok(thread)
-            },
-        )?;
-
-        let close = lua
-            .globals()
-            .get::<_, LuaTable>("coroutine")?
-            .get::<_, LuaFunction>("close")?;
-        let close_key = lua.create_registry_value(close)?;
-        let cancel = lua.create_function(move |lua, thread: LuaThread| {
-            let _span = tracing::trace_span!("Scheduler::fn_cancel").entered();
-            let close: LuaFunction = lua.registry_value(&close_key)?;
-            match close.call(thread) {
-                Err(LuaError::CoroutineInactive) | Ok(()) => Ok(()),
-                Err(e) => Err(e),
-            }
-        })?;
-
-        let exit_env = lua.create_table_from(vec![
-            (
-                "exit",
-                lua.create_function(|lua, code: Option<u8>| {
-                    let _span = tracing::trace_span!("Scheduler::fn_exit").entered();
-                    let code = code.unwrap_or_default();
-                    lua.set_exit_code(code);
-                    Ok(())
-                })?,
-            ),
-            (
-                "yield",
-                lua.globals()
-                    .get::<_, LuaTable>("coroutine")?
-                    .get::<_, LuaFunction>("yield")?,
-            ),
-        ])?;
-        let exit = lua
-            .load(EXIT_IMPL_LUA)
-            .set_name("=__scheduler_exit")
-            .set_environment(exit_env)
-            .into_function()?;
-
-        Ok(Self {
-            resume,
-            wrap,
-            spawn,
-            defer,
-            cancel,
-            exit,
-        })
-    }
-}
-
-impl Functions<'_> {
-    /**
-        Injects [`Scheduler`]-compatible functions into the given [`Lua`] instance.
-
-        This will overwrite the following functions:
-
-        - `coroutine.resume`
-        - `coroutine.wrap`
-
-        # Errors
-
-        Errors when out of memory, or if default Lua globals are missing.
-    */
-    pub fn inject_compat(&self, lua: &Lua) -> LuaResult<()> {
-        let co: LuaTable = lua.globals().get("coroutine")?;
-        co.set("resume", self.resume.clone())?;
-        co.set("wrap", self.wrap.clone())?;
-        Ok(())
-    }
-}

crates/mlua-luau-scheduler/src/lib.rs

@@ -1,18 +0,0 @@
-#![allow(clippy::cargo_common_metadata)]
-
-mod error_callback;
-mod exit;
-mod functions;
-mod queue;
-mod result_map;
-mod scheduler;
-mod status;
-mod thread_id;
-mod traits;
-mod util;
-
-pub use functions::Functions;
-pub use scheduler::Scheduler;
-pub use status::Status;
-pub use thread_id::ThreadId;
-pub use traits::{IntoLuaThread, LuaSchedulerExt, LuaSpawnExt};

crates/mlua-luau-scheduler/src/queue.rs

@@ -1,139 +0,0 @@
-use std::{pin::Pin, rc::Rc};
-
-use concurrent_queue::ConcurrentQueue;
-use derive_more::{Deref, DerefMut};
-use event_listener::Event;
-use futures_lite::{Future, FutureExt};
-use mlua::prelude::*;
-
-use crate::{traits::IntoLuaThread, util::ThreadWithArgs, ThreadId};
-
-/**
-    Queue for storing [`LuaThread`]s with associated arguments.
-
-    Provides methods for pushing and draining the queue, as
-    well as listening for new items being pushed to the queue.
-*/
-#[derive(Debug, Clone)]
-pub(crate) struct ThreadQueue {
-    queue: Rc<ConcurrentQueue<ThreadWithArgs>>,
-    event: Rc<Event>,
-}
-
-impl ThreadQueue {
-    pub fn new() -> Self {
-        let queue = Rc::new(ConcurrentQueue::unbounded());
-        let event = Rc::new(Event::new());
-        Self { queue, event }
-    }
-
-    pub fn push_item<'lua>(
-        &self,
-        lua: &'lua Lua,
-        thread: impl IntoLuaThread<'lua>,
-        args: impl IntoLuaMulti<'lua>,
-    ) -> LuaResult<ThreadId> {
-        let thread = thread.into_lua_thread(lua)?;
-        let args = args.into_lua_multi(lua)?;
-
-        tracing::trace!("pushing item to queue with {} args", args.len());
-        let id = ThreadId::from(&thread);
-        let stored = ThreadWithArgs::new(lua, thread, args)?;
-
-        self.queue.push(stored).into_lua_err()?;
-        self.event.notify(usize::MAX);
-
-        Ok(id)
-    }
-
-    #[inline]
-    pub fn drain_items<'outer, 'lua>(
-        &'outer self,
-        lua: &'lua Lua,
-    ) -> impl Iterator<Item = (LuaThread<'lua>, LuaMultiValue<'lua>)> + 'outer
-    where
-        'lua: 'outer,
-    {
-        self.queue.try_iter().map(|stored| stored.into_inner(lua))
-    }
-
-    #[inline]
-    pub async fn wait_for_item(&self) {
-        if self.queue.is_empty() {
-            let listener = self.event.listen();
-            // NOTE: Need to check again, we could have gotten
-            // new queued items while creating our listener
-            if self.queue.is_empty() {
-                listener.await;
-            }
-        }
-    }
-
-    #[inline]
-    pub fn is_empty(&self) -> bool {
-        self.queue.is_empty()
-    }
-}
-
-/**
-    Alias for [`ThreadQueue`], providing a newtype to store in Lua app data.
-*/
-#[derive(Debug, Clone, Deref, DerefMut)]
-pub(crate) struct SpawnedThreadQueue(ThreadQueue);
-
-impl SpawnedThreadQueue {
-    pub fn new() -> Self {
-        Self(ThreadQueue::new())
-    }
-}
-
-/**
-    Alias for [`ThreadQueue`], providing a newtype to store in Lua app data.
-*/
-#[derive(Debug, Clone, Deref, DerefMut)]
-pub(crate) struct DeferredThreadQueue(ThreadQueue);
-
-impl DeferredThreadQueue {
-    pub fn new() -> Self {
-        Self(ThreadQueue::new())
-    }
-}
-
-pub type LocalBoxFuture<'fut> = Pin<Box<dyn Future<Output = ()> + 'fut>>;
-
-/**
-    Queue for storing local futures.
-
-    Provides methods for pushing and draining the queue, as
-    well as listening for new items being pushed to the queue.
-*/
-#[derive(Debug, Clone)]
-pub(crate) struct FuturesQueue<'fut> {
-    queue: Rc<ConcurrentQueue<LocalBoxFuture<'fut>>>,
-    event: Rc<Event>,
-}
-
-impl<'fut> FuturesQueue<'fut> {
-    pub fn new() -> Self {
-        let queue = Rc::new(ConcurrentQueue::unbounded());
-        let event = Rc::new(Event::new());
-        Self { queue, event }
-    }
-
-    pub fn push_item(&self, fut: impl Future<Output = ()> + 'fut) {
-        let _ = self.queue.push(fut.boxed_local());
-        self.event.notify(usize::MAX);
-    }
-
-    pub fn drain_items<'outer>(
-        &'outer self,
-    ) -> impl Iterator<Item = LocalBoxFuture<'fut>> + 'outer {
-        self.queue.try_iter()
-    }
-
-    pub async fn wait_for_item(&self) {
-        if self.queue.is_empty() {
-            self.event.listen().await;
-        }
-    }
-}

crates/mlua-luau-scheduler/src/result_map.rs

@@ -1,64 +0,0 @@
-#![allow(clippy::inline_always)]
-
-use std::{cell::RefCell, rc::Rc};
-
-use event_listener::Event;
-// NOTE: This is the hash algorithm that mlua also uses, so we
-// are not adding any additional dependencies / bloat by using it.
-use rustc_hash::{FxHashMap, FxHashSet};
-
-use crate::{thread_id::ThreadId, util::ThreadResult};
-
-#[derive(Clone)]
-pub(crate) struct ThreadResultMap {
-    tracked: Rc<RefCell<FxHashSet<ThreadId>>>,
-    results: Rc<RefCell<FxHashMap<ThreadId, ThreadResult>>>,
-    events: Rc<RefCell<FxHashMap<ThreadId, Rc<Event>>>>,
-}
-
-impl ThreadResultMap {
-    pub fn new() -> Self {
-        Self {
-            tracked: Rc::new(RefCell::new(FxHashSet::default())),
-            results: Rc::new(RefCell::new(FxHashMap::default())),
-            events: Rc::new(RefCell::new(FxHashMap::default())),
-        }
-    }
-
-    #[inline(always)]
-    pub fn track(&self, id: ThreadId) {
-        self.tracked.borrow_mut().insert(id);
-    }
-
-    #[inline(always)]
-    pub fn is_tracked(&self, id: ThreadId) -> bool {
-        self.tracked.borrow().contains(&id)
-    }
-
-    pub fn insert(&self, id: ThreadId, result: ThreadResult) {
-        debug_assert!(self.is_tracked(id), "Thread must be tracked");
-        self.results.borrow_mut().insert(id, result);
-        if let Some(event) = self.events.borrow_mut().remove(&id) {
-            event.notify(usize::MAX);
-        }
-    }
-
-    pub async fn listen(&self, id: ThreadId) {
-        debug_assert!(self.is_tracked(id), "Thread must be tracked");
-        if !self.results.borrow().contains_key(&id) {
-            let listener = {
-                let mut events = self.events.borrow_mut();
-                let event = events.entry(id).or_insert_with(|| Rc::new(Event::new()));
-                event.listen()
-            };
-            listener.await;
-        }
-    }
-
-    pub fn remove(&self, id: ThreadId) -> Option<ThreadResult> {
-        let res = self.results.borrow_mut().remove(&id)?;
-        self.tracked.borrow_mut().remove(&id);
-        self.events.borrow_mut().remove(&id);
-        Some(res)
-    }
-}

crates/mlua-luau-scheduler/src/scheduler.rs

@@ -1,483 +0,0 @@
-#![allow(clippy::module_name_repetitions)]
-
-use std::{
-    cell::Cell,
-    rc::{Rc, Weak as WeakRc},
-    sync::{Arc, Weak as WeakArc},
-    thread::panicking,
-};
-
-use futures_lite::prelude::*;
-use mlua::prelude::*;
-
-use async_executor::{Executor, LocalExecutor};
-use tracing::{debug, instrument, trace, trace_span, Instrument};
-
-use crate::{
-    error_callback::ThreadErrorCallback,
-    exit::Exit,
-    queue::{DeferredThreadQueue, FuturesQueue, SpawnedThreadQueue},
-    result_map::ThreadResultMap,
-    status::Status,
-    thread_id::ThreadId,
-    traits::IntoLuaThread,
-    util::{run_until_yield, ThreadResult},
-};
-
-const ERR_METADATA_ALREADY_ATTACHED: &str = "\
-Lua state already has scheduler metadata attached!\
-\nThis may be caused by running multiple schedulers on the same Lua state, or a call to Scheduler::run being cancelled.\
-\nOnly one scheduler can be used per Lua state at once, and schedulers must always run until completion.\
-";
-
-const ERR_METADATA_REMOVED: &str = "\
-Lua state scheduler metadata was unexpectedly removed!\
-\nThis should never happen, and is likely a bug in the scheduler.\
-";
-
-const ERR_SET_CALLBACK_WHEN_RUNNING: &str = "\
-Cannot set error callback when scheduler is running!\
-";
-
-/**
-    A scheduler for running Lua threads and async tasks.
-*/
-#[derive(Clone)]
-pub struct Scheduler<'lua> {
-    lua: &'lua Lua,
-    queue_spawn: SpawnedThreadQueue,
-    queue_defer: DeferredThreadQueue,
-    error_callback: ThreadErrorCallback,
-    result_map: ThreadResultMap,
-    status: Rc<Cell<Status>>,
-    exit: Exit,
-}
-
-impl<'lua> Scheduler<'lua> {
-    /**
-        Creates a new scheduler for the given Lua state.
-
-        This scheduler will have a default error callback that prints errors to stderr.
-
-        # Panics
-
-        Panics if the given Lua state already has a scheduler attached to it.
-    */
-    #[must_use]
-    pub fn new(lua: &'lua Lua) -> Scheduler<'lua> {
-        let queue_spawn = SpawnedThreadQueue::new();
-        let queue_defer = DeferredThreadQueue::new();
-        let error_callback = ThreadErrorCallback::default();
-        let result_map = ThreadResultMap::new();
-        let exit = Exit::new();
-
-        assert!(
-            lua.app_data_ref::<SpawnedThreadQueue>().is_none(),
-            "{ERR_METADATA_ALREADY_ATTACHED}"
-        );
-        assert!(
-            lua.app_data_ref::<DeferredThreadQueue>().is_none(),
-            "{ERR_METADATA_ALREADY_ATTACHED}"
-        );
-        assert!(
-            lua.app_data_ref::<ThreadErrorCallback>().is_none(),
-            "{ERR_METADATA_ALREADY_ATTACHED}"
-        );
-        assert!(
-            lua.app_data_ref::<ThreadResultMap>().is_none(),
-            "{ERR_METADATA_ALREADY_ATTACHED}"
-        );
-        assert!(
-            lua.app_data_ref::<Exit>().is_none(),
-            "{ERR_METADATA_ALREADY_ATTACHED}"
-        );
-
-        lua.set_app_data(queue_spawn.clone());
-        lua.set_app_data(queue_defer.clone());
-        lua.set_app_data(error_callback.clone());
-        lua.set_app_data(result_map.clone());
-        lua.set_app_data(exit.clone());
-
-        let status = Rc::new(Cell::new(Status::NotStarted));
-
-        Scheduler {
-            lua,
-            queue_spawn,
-            queue_defer,
-            error_callback,
-            result_map,
-            status,
-            exit,
-        }
-    }
-
-    /**
-        Sets the current status of this scheduler and emits relevant tracing events.
-    */
-    fn set_status(&self, status: Status) {
-        debug!(status = ?status, "status");
-        self.status.set(status);
-    }
-
-    /**
-        Returns the current status of this scheduler.
-    */
-    #[must_use]
-    pub fn status(&self) -> Status {
-        self.status.get()
-    }
-
-    /**
-        Sets the error callback for this scheduler.
-
-        This callback will be called whenever a Lua thread errors.
-
-        Overwrites any previous error callback.
-
-        # Panics
-
-        Panics if the scheduler is currently running.
-    */
-    pub fn set_error_callback(&self, callback: impl Fn(LuaError) + Send + 'static) {
-        assert!(
-            !self.status().is_running(),
-            "{ERR_SET_CALLBACK_WHEN_RUNNING}"
-        );
-        self.error_callback.replace(callback);
-    }
-
-    /**
-        Clears the error callback for this scheduler.
-
-        This will remove any current error callback, including default(s).
-
-        # Panics
-
-        Panics if the scheduler is currently running.
-    */
-    pub fn remove_error_callback(&self) {
-        assert!(
-            !self.status().is_running(),
-            "{ERR_SET_CALLBACK_WHEN_RUNNING}"
-        );
-        self.error_callback.clear();
-    }
-
-    /**
-        Gets the exit code for this scheduler, if one has been set.
-    */
-    #[must_use]
-    pub fn get_exit_code(&self) -> Option<u8> {
-        self.exit.get()
-    }
-
-    /**
-        Sets the exit code for this scheduler.
-
-        This will cause [`Scheduler::run`] to exit immediately.
-    */
-    pub fn set_exit_code(&self, code: u8) {
-        self.exit.set(code);
-    }
-
-    /**
-        Spawns a chunk / function / thread onto the scheduler queue.
-
-        Threads are guaranteed to be resumed in the order that they were pushed to the queue.
-
-        # Returns
-
-        Returns a [`ThreadId`] that can be used to retrieve the result of the thread.
-
-        Note that the result may not be available until [`Scheduler::run`] completes.
-
-        # Errors
-
-        Errors when out of memory.
-    */
-    pub fn push_thread_front(
-        &self,
-        thread: impl IntoLuaThread<'lua>,
-        args: impl IntoLuaMulti<'lua>,
-    ) -> LuaResult<ThreadId> {
-        let id = self.queue_spawn.push_item(self.lua, thread, args)?;
-        self.result_map.track(id);
-        Ok(id)
-    }
-
-    /**
-        Defers a chunk / function / thread onto the scheduler queue.
-
-        Deferred threads are guaranteed to run after all spawned threads either yield or complete.
-
-        Threads are guaranteed to be resumed in the order that they were pushed to the queue.
-
-        # Returns
-
-        Returns a [`ThreadId`] that can be used to retrieve the result of the thread.
-
-        Note that the result may not be available until [`Scheduler::run`] completes.
-
-        # Errors
-
-        Errors when out of memory.
-    */
-    pub fn push_thread_back(
-        &self,
-        thread: impl IntoLuaThread<'lua>,
-        args: impl IntoLuaMulti<'lua>,
-    ) -> LuaResult<ThreadId> {
-        let id = self.queue_defer.push_item(self.lua, thread, args)?;
-        self.result_map.track(id);
-        Ok(id)
-    }
-
-    /**
-        Gets the tracked result for the [`LuaThread`] with the given [`ThreadId`].
-
-        Depending on the current [`Scheduler::status`], this method will return:
-
-        - [`Status::NotStarted`]: returns `None`.
-        - [`Status::Running`]: may return `Some(Ok(v))` or `Some(Err(e))`, but it is not guaranteed.
-        - [`Status::Completed`]: returns `Some(Ok(v))` or `Some(Err(e))`.
-
-        Note that this method also takes the value out of the scheduler and
-        stops tracking the given thread, so it may only be called once.
-
-        Any subsequent calls after this method returns `Some` will return `None`.
-    */
-    #[must_use]
-    pub fn get_thread_result(&self, id: ThreadId) -> Option<LuaResult<LuaMultiValue<'lua>>> {
-        self.result_map.remove(id).map(|r| r.value(self.lua))
-    }
-
-    /**
-        Waits for the [`LuaThread`] with the given [`ThreadId`] to complete.
-
-        This will return instantly if the thread has already completed.
-    */
-    pub async fn wait_for_thread(&self, id: ThreadId) {
-        self.result_map.listen(id).await;
-    }
-
-    /**
-        Runs the scheduler until all Lua threads have completed.
-
-        Note that the given Lua state must be the same one that was
-        used to create this scheduler, otherwise this method will panic.
-
-        # Panics
-
-        Panics if the given Lua state already has a scheduler attached to it.
-    */
-    #[allow(clippy::too_many_lines)]
-    #[instrument(level = "debug", name = "Scheduler::run", skip(self))]
-    pub async fn run(&self) {
-        /*
-            Create new executors to use - note that we do not need create multiple executors
-            for work stealing, the user may do that themselves if they want to and it will work
-            just fine, as long as anything async is .await-ed from within a Lua async function.
-
-            The main purpose of the two executors here is just to have one with
-            the Send bound, and another (local) one without it, for Lua scheduling.
-
-            We also use the main executor to drive the main loop below forward,
-            saving a tiny bit of processing from going on the Lua executor itself.
-        */
-        let local_exec = LocalExecutor::new();
-        let main_exec = Arc::new(Executor::new());
-        let fut_queue = Rc::new(FuturesQueue::new());
-
-        /*
-            Store the main executor and queue in Lua, so that they may be used with LuaSchedulerExt.
-
-            Also ensure we do not already have an executor or queues - these are definite user errors
-            and may happen if the user tries to run multiple schedulers on the same Lua state at once.
-        */
-        assert!(
-            self.lua.app_data_ref::<WeakArc<Executor>>().is_none(),
-            "{ERR_METADATA_ALREADY_ATTACHED}"
-        );
-        assert!(
-            self.lua.app_data_ref::<WeakRc<FuturesQueue>>().is_none(),
-            "{ERR_METADATA_ALREADY_ATTACHED}"
-        );
-
-        self.lua.set_app_data(Arc::downgrade(&main_exec));
-        self.lua.set_app_data(Rc::downgrade(&fut_queue.clone()));
-
-        /*
-            Manually tick the Lua executor, while running under the main executor.
-            Each tick we wait for the next action to perform, in prioritized order:
-
-            1. The exit event is triggered by setting an exit code
-            2. A Lua thread is available to run on the spawned queue
-            3. A Lua thread is available to run on the deferred queue
-            4. A new thread-local future is available to run on the local executor
-            5. Task(s) scheduled on the Lua executor have made progress and should be polled again
-
-            This ordering is vital to ensure that we don't accidentally exit the main loop
-            when there are new Lua threads to enqueue and potentially more work to be done.
-        */
-        let fut = async {
-            let result_map = self.result_map.clone();
-            let process_thread = |thread: LuaThread<'lua>, args| {
-                // NOTE: Thread may have been cancelled from Lua
-                // before we got here, so we need to check it again
-                if thread.status() == LuaThreadStatus::Resumable {
-                    // Check if we should be tracking this thread
-                    let id = ThreadId::from(&thread);
-                    let id_tracked = result_map.is_tracked(id);
-                    let result_map_inner = if id_tracked {
-                        Some(result_map.clone())
-                    } else {
-                        None
-                    };
-                    // Create our future which will run the thread and store its final result
-                    let fut = async move {
-                        if id_tracked {
-                            // Run until yield and check if we got a final result
-                            if let Some(res) = run_until_yield(thread.clone(), args).await {
-                                if let Err(e) = res.as_ref() {
-                                    self.error_callback.call(e);
-                                }
-                                if thread.status() != LuaThreadStatus::Resumable {
-                                    let thread_res = ThreadResult::new(res, self.lua);
-                                    result_map_inner.unwrap().insert(id, thread_res);
-                                }
-                            }
-                        } else {
-                            // Just run until yield
-                            if let Some(res) = run_until_yield(thread, args).await {
-                                if let Err(e) = res.as_ref() {
-                                    self.error_callback.call(e);
-                                }
-                            }
-                        }
-                    };
-                    // Spawn it on the executor
-                    local_exec.spawn(fut).detach();
-                }
-            };
-
-            loop {
-                let fut_exit = self.exit.listen(); // 1
-                let fut_spawn = self.queue_spawn.wait_for_item(); // 2
-                let fut_defer = self.queue_defer.wait_for_item(); // 3
-                let fut_futs = fut_queue.wait_for_item(); // 4
-
-                // 5
-                let mut num_processed = 0;
-                let span_tick = trace_span!("Scheduler::tick");
-                let fut_tick = async {
-                    local_exec.tick().await;
-                    // NOTE: Try to do as much work as possible instead of just a single tick()
-                    num_processed += 1;
-                    while local_exec.try_tick() {
-                        num_processed += 1;
-                    }
-                };
-
-                // 1 + 2 + 3 + 4 + 5
-                fut_exit
-                    .or(fut_spawn)
-                    .or(fut_defer)
-                    .or(fut_futs)
-                    .or(fut_tick.instrument(span_tick.or_current()))
-                    .await;
-
-                // Check if we should exit
-                if self.exit.get().is_some() {
-                    debug!("exit signal received");
-                    break;
-                }
-
-                // Process spawned threads first, then deferred threads, then futures
-                let mut num_spawned = 0;
-                let mut num_deferred = 0;
-                let mut num_futures = 0;
-                {
-                    let _span = trace_span!("Scheduler::drain_spawned").entered();
-                    for (thread, args) in self.queue_spawn.drain_items(self.lua) {
-                        process_thread(thread, args);
-                        num_spawned += 1;
-                    }
-                }
-                {
-                    let _span = trace_span!("Scheduler::drain_deferred").entered();
-                    for (thread, args) in self.queue_defer.drain_items(self.lua) {
-                        process_thread(thread, args);
-                        num_deferred += 1;
-                    }
-                }
-                {
-                    let _span = trace_span!("Scheduler::drain_futures").entered();
-                    for fut in fut_queue.drain_items() {
-                        local_exec.spawn(fut).detach();
-                        num_futures += 1;
-                    }
-                }
-
-                // Empty executor = we didn't spawn any new Lua tasks
-                // above, and there are no remaining tasks to run later
-                let completed = local_exec.is_empty()
-                    && self.queue_spawn.is_empty()
-                    && self.queue_defer.is_empty();
-                trace!(
-                    futures_spawned = num_futures,
-                    futures_processed = num_processed,
-                    lua_threads_spawned = num_spawned,
-                    lua_threads_deferred = num_deferred,
-                    "loop"
-                );
-                if completed {
-                    break;
-                }
-            }
-        };
-
-        // Run the executor inside a span until all lua threads complete
-        self.set_status(Status::Running);
-        main_exec.run(fut).await;
-        self.set_status(Status::Completed);
-
-        // Clean up
-        self.lua
-            .remove_app_data::<WeakArc<Executor>>()
-            .expect(ERR_METADATA_REMOVED);
-        self.lua
-            .remove_app_data::<WeakRc<FuturesQueue>>()
-            .expect(ERR_METADATA_REMOVED);
-    }
-}
-
-impl Drop for Scheduler<'_> {
-    fn drop(&mut self) {
-        if panicking() {
-            // Do not cause further panics if already panicking, as
-            // this may abort the program instead of safely unwinding
-            self.lua.remove_app_data::<SpawnedThreadQueue>();
-            self.lua.remove_app_data::<DeferredThreadQueue>();
-            self.lua.remove_app_data::<ThreadErrorCallback>();
-            self.lua.remove_app_data::<ThreadResultMap>();
-            self.lua.remove_app_data::<Exit>();
-        } else {
-            // In any other case we panic if metadata was removed incorrectly
-            self.lua
-                .remove_app_data::<SpawnedThreadQueue>()
-                .expect(ERR_METADATA_REMOVED);
-            self.lua
-                .remove_app_data::<DeferredThreadQueue>()
-                .expect(ERR_METADATA_REMOVED);
-            self.lua
-                .remove_app_data::<ThreadErrorCallback>()
-                .expect(ERR_METADATA_REMOVED);
-            self.lua
-                .remove_app_data::<ThreadResultMap>()
-                .expect(ERR_METADATA_REMOVED);
-            self.lua
-                .remove_app_data::<Exit>()
-                .expect(ERR_METADATA_REMOVED);
-        }
-    }
-}

crates/mlua-luau-scheduler/src/status.rs

@@ -1,31 +0,0 @@
-#![allow(clippy::module_name_repetitions)]
-
-/**
-    The current status of a scheduler.
-*/
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum Status {
-    /// The scheduler has not yet started running.
-    NotStarted,
-    /// The scheduler is currently running.
-    Running,
-    /// The scheduler has completed.
-    Completed,
-}
-
-impl Status {
-    #[must_use]
-    pub const fn is_not_started(self) -> bool {
-        matches!(self, Self::NotStarted)
-    }
-
-    #[must_use]
-    pub const fn is_running(self) -> bool {
-        matches!(self, Self::Running)
-    }
-
-    #[must_use]
-    pub const fn is_completed(self) -> bool {
-        matches!(self, Self::Completed)
-    }
-}

crates/mlua-luau-scheduler/src/thread_id.rs

@@ -1,30 +0,0 @@
-use std::hash::{Hash, Hasher};
-
-use mlua::prelude::*;
-
-/**
-    Opaque and unique ID representing a [`LuaThread`].
-
-    Typically used for associating metadata with a thread in a structure such as a `HashMap<ThreadId, ...>`.
-
-    Note that holding a `ThreadId` does not prevent the thread from being garbage collected.
-    The actual thread may or may not still exist and be active at any given point in time.
-*/
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct ThreadId {
-    inner: usize,
-}
-
-impl From<&LuaThread<'_>> for ThreadId {
-    fn from(thread: &LuaThread) -> Self {
-        Self {
-            inner: thread.to_pointer() as usize,
-        }
-    }
-}
-
-impl Hash for ThreadId {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.inner.hash(state);
-    }
-}

crates/mlua-luau-scheduler/src/traits.rs

@@ -1,378 +0,0 @@
-#![allow(unused_imports)]
-#![allow(clippy::missing_errors_doc)]
-
-use std::{
-    cell::Cell, future::Future, process::ExitCode, rc::Weak as WeakRc, sync::Weak as WeakArc,
-};
-
-use async_executor::{Executor, Task};
-use mlua::prelude::*;
-use tracing::trace;
-
-use crate::{
-    exit::Exit,
-    queue::{DeferredThreadQueue, FuturesQueue, SpawnedThreadQueue},
-    result_map::ThreadResultMap,
-    scheduler::Scheduler,
-    thread_id::ThreadId,
-};
-
-/**
-    Trait for any struct that can be turned into an [`LuaThread`]
-    and passed to the scheduler, implemented for the following types:
-
-    - Lua threads ([`LuaThread`])
-    - Lua functions ([`LuaFunction`])
-    - Lua chunks ([`LuaChunk`])
-*/
-pub trait IntoLuaThread<'lua> {
-    /**
-        Converts the value into a Lua thread.
-
-        # Errors
-
-        Errors when out of memory.
-    */
-    fn into_lua_thread(self, lua: &'lua Lua) -> LuaResult<LuaThread<'lua>>;
-}
-
-impl<'lua> IntoLuaThread<'lua> for LuaThread<'lua> {
-    fn into_lua_thread(self, _: &'lua Lua) -> LuaResult<LuaThread<'lua>> {
-        Ok(self)
-    }
-}
-
-impl<'lua> IntoLuaThread<'lua> for LuaFunction<'lua> {
-    fn into_lua_thread(self, lua: &'lua Lua) -> LuaResult<LuaThread<'lua>> {
-        lua.create_thread(self)
-    }
-}
-
-impl<'lua> IntoLuaThread<'lua> for LuaChunk<'lua, '_> {
-    fn into_lua_thread(self, lua: &'lua Lua) -> LuaResult<LuaThread<'lua>> {
-        lua.create_thread(self.into_function()?)
-    }
-}
-
-impl<'lua, T> IntoLuaThread<'lua> for &T
-where
-    T: IntoLuaThread<'lua> + Clone,
-{
-    fn into_lua_thread(self, lua: &'lua Lua) -> LuaResult<LuaThread<'lua>> {
-        self.clone().into_lua_thread(lua)
-    }
-}
-
-/**
-    Trait for interacting with the current [`Scheduler`].
-
-    Provides extra methods on the [`Lua`] struct for:
-
-    - Setting the exit code and forcibly stopping the scheduler
-    - Pushing (spawning) and deferring (pushing to the back) lua threads
-    - Tracking and getting the result of lua threads
-*/
-pub trait LuaSchedulerExt<'lua> {
-    /**
-        Sets the exit code of the current scheduler.
-
-        See [`Scheduler::set_exit_code`] for more information.
-
-        # Panics
-
-        Panics if called outside of a running [`Scheduler`].
-    */
-    fn set_exit_code(&self, code: u8);
-
-    /**
-        Pushes (spawns) a lua thread to the **front** of the current scheduler.
-
-        See [`Scheduler::push_thread_front`] for more information.
-
-        # Panics
-
-        Panics if called outside of a running [`Scheduler`].
-    */
-    fn push_thread_front(
-        &'lua self,
-        thread: impl IntoLuaThread<'lua>,
-        args: impl IntoLuaMulti<'lua>,
-    ) -> LuaResult<ThreadId>;
-
-    /**
-        Pushes (defers) a lua thread to the **back** of the current scheduler.
-
-        See [`Scheduler::push_thread_back`] for more information.
-
-        # Panics
-
-        Panics if called outside of a running [`Scheduler`].
-    */
-    fn push_thread_back(
-        &'lua self,
-        thread: impl IntoLuaThread<'lua>,
-        args: impl IntoLuaMulti<'lua>,
-    ) -> LuaResult<ThreadId>;
-
-    /**
-        Registers the given thread to be tracked within the current scheduler.
-
-        Must be called before waiting for a thread to complete or getting its result.
-    */
-    fn track_thread(&'lua self, id: ThreadId);
-
-    /**
-        Gets the result of the given thread.
-
-        See [`Scheduler::get_thread_result`] for more information.
-
-        # Panics
-
-        Panics if called outside of a running [`Scheduler`].
-    */
-    fn get_thread_result(&'lua self, id: ThreadId) -> Option<LuaResult<LuaMultiValue<'lua>>>;
-
-    /**
-        Waits for the given thread to complete.
-
-        See [`Scheduler::wait_for_thread`] for more information.
-
-        # Panics
-
-        Panics if called outside of a running [`Scheduler`].
-    */
-    fn wait_for_thread(&'lua self, id: ThreadId) -> impl Future<Output = ()>;
-}
-
-/**
-    Trait for interacting with the [`Executor`] for the current [`Scheduler`].
-
-    Provides extra methods on the [`Lua`] struct for:
-
-    - Spawning thread-local (`!Send`) futures on the current executor
-    - Spawning background (`Send`) futures on the current executor
-    - Spawning blocking tasks on a separate thread pool
-*/
-pub trait LuaSpawnExt<'lua> {
-    /**
-        Spawns the given future on the current executor and returns its [`Task`].
-
-        # Panics
-
-        Panics if called outside of a running [`Scheduler`].
-
-        # Example usage
-
-        ```rust
-        use async_io::block_on;
-
-        use mlua::prelude::*;
-        use mlua_luau_scheduler::*;
-
-        fn main() -> LuaResult<()> {
-            let lua = Lua::new();
-
-            lua.globals().set(
-                "spawnBackgroundTask",
-                lua.create_async_function(|lua, ()| async move {
-                    lua.spawn(async move {
-                        println!("Hello from background task!");
-                    }).await;
-                    Ok(())
-                })?
-            )?;
-
-            let sched = Scheduler::new(&lua);
-            sched.push_thread_front(lua.load("spawnBackgroundTask()"), ());
-            block_on(sched.run());
-
-            Ok(())
-        }
-        ```
-    */
-    fn spawn<F, T>(&self, fut: F) -> Task<T>
-    where
-        F: Future<Output = T> + Send + 'static,
-        T: Send + 'static;
-
-    /**
-        Spawns the given thread-local future on the current executor.
-
-        Note that this future will run detached and always to completion,
-        preventing the [`Scheduler`] was spawned on from completing until done.
-
-        # Panics
-
-        Panics if called outside of a running [`Scheduler`].
-
-        # Example usage
-
-        ```rust
-        use async_io::block_on;
-
-        use mlua::prelude::*;
-        use mlua_luau_scheduler::*;
-
-        fn main() -> LuaResult<()> {
-            let lua = Lua::new();
-
-            lua.globals().set(
-                "spawnLocalTask",
-                lua.create_async_function(|lua, ()| async move {
-                    lua.spawn_local(async move {
-                        println!("Hello from local task!");
-                    });
-                    Ok(())
-                })?
-            )?;
-
-            let sched = Scheduler::new(&lua);
-            sched.push_thread_front(lua.load("spawnLocalTask()"), ());
-            block_on(sched.run());
-
-            Ok(())
-        }
-        ```
-    */
-    fn spawn_local<F>(&self, fut: F)
-    where
-        F: Future<Output = ()> + 'static;
-
-    /**
-        Spawns the given blocking function and returns its [`Task`].
-
-        This function will run on a separate thread pool and not block the current executor.
-
-        # Panics
-
-        Panics if called outside of a running [`Scheduler`].
-
-        # Example usage
-
-        ```rust
-        use async_io::block_on;
-
-        use mlua::prelude::*;
-        use mlua_luau_scheduler::*;
-
-        fn main() -> LuaResult<()> {
-            let lua = Lua::new();
-
-            lua.globals().set(
-                "spawnBlockingTask",
-                lua.create_async_function(|lua, ()| async move {
-                    lua.spawn_blocking(|| {
-                        println!("Hello from blocking task!");
-                    }).await;
-                    Ok(())
-                })?
-            )?;
-
-            let sched = Scheduler::new(&lua);
-            sched.push_thread_front(lua.load("spawnBlockingTask()"), ());
-            block_on(sched.run());
-
-            Ok(())
-        }
-        ```
-    */
-    fn spawn_blocking<F, T>(&self, f: F) -> Task<T>
-    where
-        F: FnOnce() -> T + Send + 'static,
-        T: Send + 'static;
-}
-
-impl<'lua> LuaSchedulerExt<'lua> for Lua {
-    fn set_exit_code(&self, code: u8) {
-        let exit = self
-            .app_data_ref::<Exit>()
-            .expect("exit code can only be set from within an active scheduler");
-        exit.set(code);
-    }
-
-    fn push_thread_front(
-        &'lua self,
-        thread: impl IntoLuaThread<'lua>,
-        args: impl IntoLuaMulti<'lua>,
-    ) -> LuaResult<ThreadId> {
-        let queue = self
-            .app_data_ref::<SpawnedThreadQueue>()
-            .expect("lua threads can only be pushed from within an active scheduler");
-        queue.push_item(self, thread, args)
-    }
-
-    fn push_thread_back(
-        &'lua self,
-        thread: impl IntoLuaThread<'lua>,
-        args: impl IntoLuaMulti<'lua>,
-    ) -> LuaResult<ThreadId> {
-        let queue = self
-            .app_data_ref::<DeferredThreadQueue>()
-            .expect("lua threads can only be pushed from within an active scheduler");
-        queue.push_item(self, thread, args)
-    }
-
-    fn track_thread(&'lua self, id: ThreadId) {
-        let map = self
-            .app_data_ref::<ThreadResultMap>()
-            .expect("lua threads can only be tracked from within an active scheduler");
-        map.track(id);
-    }
-
-    fn get_thread_result(&'lua self, id: ThreadId) -> Option<LuaResult<LuaMultiValue<'lua>>> {
-        let map = self
-            .app_data_ref::<ThreadResultMap>()
-            .expect("lua threads results can only be retrieved from within an active scheduler");
-        map.remove(id).map(|r| r.value(self))
-    }
-
-    fn wait_for_thread(&'lua self, id: ThreadId) -> impl Future<Output = ()> {
-        let map = self
-            .app_data_ref::<ThreadResultMap>()
-            .expect("lua threads results can only be retrieved from within an active scheduler");
-        async move { map.listen(id).await }
-    }
-}
-
-impl LuaSpawnExt<'_> for Lua {
-    fn spawn<F, T>(&self, fut: F) -> Task<T>
-    where
-        F: Future<Output = T> + Send + 'static,
-        T: Send + 'static,
-    {
-        let exec = self
-            .app_data_ref::<WeakArc<Executor>>()
-            .expect("tasks can only be spawned within an active scheduler")
-            .upgrade()
-            .expect("executor was dropped");
-        trace!("spawning future on executor");
-        exec.spawn(fut)
-    }
-
-    fn spawn_local<F>(&self, fut: F)
-    where
-        F: Future<Output = ()> + 'static,
-    {
-        let queue = self
-            .app_data_ref::<WeakRc<FuturesQueue>>()
-            .expect("tasks can only be spawned within an active scheduler")
-            .upgrade()
-            .expect("executor was dropped");
-        trace!("spawning local task on executor");
-        queue.push_item(fut);
-    }
-
-    fn spawn_blocking<F, T>(&self, f: F) -> Task<T>
-    where
-        F: FnOnce() -> T + Send + 'static,
-        T: Send + 'static,
-    {
-        let exec = self
-            .app_data_ref::<WeakArc<Executor>>()
-            .expect("tasks can only be spawned within an active scheduler")
-            .upgrade()
-            .expect("executor was dropped");
-        trace!("spawning blocking task on executor");
-        exec.spawn(blocking::unblock(f))
-    }
-}

crates/mlua-luau-scheduler/src/util.rs

@@ -1,147 +0,0 @@
-use futures_lite::StreamExt;
-use mlua::prelude::*;
-use tracing::instrument;
-
-/**
-    Runs a Lua thread until it manually yields (using coroutine.yield), errors, or completes.
-
-    May return `None` if the thread was cancelled.
-
-    Otherwise returns the values yielded by the thread, or the error that caused it to stop.
-*/
-#[instrument(level = "trace", name = "Scheduler::run_until_yield", skip_all)]
-pub(crate) async fn run_until_yield<'lua>(
-    thread: LuaThread<'lua>,
-    args: LuaMultiValue<'lua>,
-) -> Option<LuaResult<LuaMultiValue<'lua>>> {
-    let mut stream = thread.into_async(args);
-    /*
-        NOTE: It is very important that we drop the thread/stream as
-        soon as we are done, it takes up valuable Lua registry space
-        and detached tasks will not drop until the executor does
-
-        https://github.com/smol-rs/smol/issues/294
-
-        We also do not unwrap here since returning `None` is expected behavior for cancellation.
-
-        Even though we are converting into a stream, and then immediately running it,
-        the future may still be cancelled before it is polled, which gives us None.
-    */
-    stream.next().await
-}
-
-/**
-    Checks if the given [`LuaValue`] is the async `POLL_PENDING` constant.
-*/
-#[inline]
-pub(crate) fn is_poll_pending(value: &LuaValue) -> bool {
-    value
-        .as_light_userdata()
-        .is_some_and(|l| l == Lua::poll_pending())
-}
-
-/**
-    Representation of a [`LuaResult`] with an associated [`LuaMultiValue`] currently stored in the Lua registry.
-*/
-#[derive(Debug)]
-pub(crate) struct ThreadResult {
-    inner: LuaResult<LuaRegistryKey>,
-}
-
-impl ThreadResult {
-    pub fn new(result: LuaResult<LuaMultiValue>, lua: &Lua) -> Self {
-        Self {
-            inner: match result {
-                Ok(v) => Ok({
-                    let vec = v.into_vec();
-                    lua.create_registry_value(vec).expect("out of memory")
-                }),
-                Err(e) => Err(e),
-            },
-        }
-    }
-
-    pub fn value(self, lua: &Lua) -> LuaResult<LuaMultiValue> {
-        match self.inner {
-            Ok(key) => {
-                let vec = lua.registry_value(&key).unwrap();
-                lua.remove_registry_value(key).unwrap();
-                Ok(LuaMultiValue::from_vec(vec))
-            }
-            Err(e) => Err(e.clone()),
-        }
-    }
-}
-
-/**
-    Representation of a [`LuaThread`] with its associated arguments currently stored in the Lua registry.
-*/
-#[derive(Debug)]
-pub(crate) struct ThreadWithArgs {
-    key_thread: LuaRegistryKey,
-    key_args: LuaRegistryKey,
-}
-
-impl ThreadWithArgs {
-    pub fn new<'lua>(
-        lua: &'lua Lua,
-        thread: LuaThread<'lua>,
-        args: LuaMultiValue<'lua>,
-    ) -> LuaResult<Self> {
-        let argsv = args.into_vec();
-
-        let key_thread = lua.create_registry_value(thread)?;
-        let key_args = lua.create_registry_value(argsv)?;
-
-        Ok(Self {
-            key_thread,
-            key_args,
-        })
-    }
-
-    pub fn into_inner(self, lua: &Lua) -> (LuaThread<'_>, LuaMultiValue<'_>) {
-        let thread = lua.registry_value(&self.key_thread).unwrap();
-        let argsv = lua.registry_value(&self.key_args).unwrap();
-
-        let args = LuaMultiValue::from_vec(argsv);
-
-        lua.remove_registry_value(self.key_thread).unwrap();
-        lua.remove_registry_value(self.key_args).unwrap();
-
-        (thread, args)
-    }
-}
-
-/**
-    Wrapper struct to accept either a Lua thread or a Lua function as function argument.
-
-    [`LuaThreadOrFunction::into_thread`] may be used to convert the value into a Lua thread.
-*/
-#[derive(Clone)]
-pub(crate) enum LuaThreadOrFunction<'lua> {
-    Thread(LuaThread<'lua>),
-    Function(LuaFunction<'lua>),
-}
-
-impl<'lua> LuaThreadOrFunction<'lua> {
-    pub(super) fn into_thread(self, lua: &'lua Lua) -> LuaResult<LuaThread<'lua>> {
-        match self {
-            Self::Thread(t) => Ok(t),
-            Self::Function(f) => lua.create_thread(f),
-        }
-    }
-}
-
-impl<'lua> FromLua<'lua> for LuaThreadOrFunction<'lua> {
-    fn from_lua(value: LuaValue<'lua>, _: &'lua Lua) -> LuaResult<Self> {
-        match value {
-            LuaValue::Thread(t) => Ok(Self::Thread(t)),
-            LuaValue::Function(f) => Ok(Self::Function(f)),
-            value => Err(LuaError::FromLuaConversionError {
-                from: value.type_name(),
-                to: "LuaThreadOrFunction",
-                message: Some("Expected thread or function".to_string()),
-            }),
-        }
-    }
-}

rokit.toml

@@ -1,4 +0,0 @@
-[tools]
-luau-lsp = "JohnnyMorganz/luau-lsp@1.33.1"
-stylua = "JohnnyMorganz/StyLua@0.20.0"
-just = "casey/just@1.36.0"