Migrate lune-std-fs to use async-fs instead of tokio

Cargo.lock

@@ -1768,11 +1768,12 @@ dependencies = [
 name = "lune-std-fs"
 version = "0.1.2"
 dependencies = [
+ "async-fs",
  "bstr",
+ "futures-lite",
  "lune-std-datetime",
  "lune-utils",
  "mlua",
- "tokio",
 ]
 
 [[package]]

crates/lune-std-fs/Cargo.toml

@@ -15,9 +15,9 @@ workspace = true
 [dependencies]
 mlua = { version = "0.10.3", features = ["luau"] }
 
+async-fs = "2.1"
 bstr = "1.9"
-
+futures-lite = "2.6"
-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-fs/src/copy.rs

@@ -2,8 +2,9 @@ use std::collections::VecDeque;
 use std::io::ErrorKind;
 use std::path::{Path, PathBuf};
 
+use async_fs as fs;
+use futures_lite::prelude::*;
 use mlua::prelude::*;
-use tokio::fs;
 
 use super::options::FsWriteOptions;
 
@@ -24,8 +25,8 @@ async fn get_contents_at(root: PathBuf, _: FsWriteOptions) -> LuaResult<CopyCont
     })?;
 
     // Push initial children of the root path into the queue
-    let mut entries = fs::read_dir(&normalized_root).await?;
+    let mut reader = fs::read_dir(&normalized_root).await?;
-    while let Some(entry) = entries.next_entry().await? {
+    while let Some(entry) = reader.try_next().await? {
         queue.push_back((1, entry.path()));
     }
 
@@ -42,7 +43,7 @@ async fn get_contents_at(root: PathBuf, _: FsWriteOptions) -> LuaResult<CopyCont
         } else if meta.is_dir() {
             // FUTURE: Add an option in FsWriteOptions for max depth and limit it here
             let mut entries = fs::read_dir(&current_path).await?;
-            while let Some(entry) = entries.next_entry().await? {
+            while let Some(entry) = entries.try_next().await? {
                 queue.push_back((current_depth + 1, entry.path()));
             }
             dirs.push((current_depth, current_path));

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

@@ -3,9 +3,10 @@
 use std::io::ErrorKind as IoErrorKind;
 use std::path::PathBuf;
 
+use async_fs as fs;
 use bstr::{BString, ByteSlice};
+use futures_lite::prelude::*;
 use mlua::prelude::*;
-use tokio::fs;
 
 use lune_utils::TableBuilder;
 
@@ -59,7 +60,7 @@ async fn fs_read_file(lua: Lua, path: String) -> LuaResult<LuaString> {
 async fn fs_read_dir(_: Lua, path: String) -> LuaResult<Vec<String>> {
     let mut dir_strings = Vec::new();
     let mut dir = fs::read_dir(&path).await.into_lua_err()?;
-    while let Some(dir_entry) = dir.next_entry().await.into_lua_err()? {
+    while let Some(dir_entry) = dir.try_next().await.into_lua_err()? {
         if let Some(dir_name_str) = dir_entry.file_name().to_str() {
             dir_strings.push(dir_name_str.to_owned());
         } else {