use async locks for later i guess?

Cargo.lock

···
 ]
 
 [[package]]
+name = "async-lock"
+version = "3.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5fd03604047cee9b6ce9de9f70c6cd540a0520c813cbd49bae61f33ab80ed1dc"
+dependencies = [
+ "event-listener",
+ "event-listener-strategy",
+ "pin-project-lite",
+]
+
+[[package]]
 name = "atoi_simd"
 version = "0.16.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "0.4.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "75984efb6ed102a0d42db99afb6c1948f0380d1d91808d5529916e6c08b49d8d"
+
+[[package]]
+name = "concurrent-queue"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973"
+dependencies = [
+ "crossbeam-utils",
+]
 
 [[package]]
 name = "console"
···
 ]
 
 [[package]]
+name = "event-listener"
+version = "5.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e13b66accf52311f30a0db42147dadea9850cb48cd070028831ae5f5d4b856ab"
+dependencies = [
+ "concurrent-queue",
+ "parking",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "event-listener-strategy"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93"
+dependencies = [
+ "event-listener",
+ "pin-project-lite",
+]
+
+[[package]]
 name = "fancy-regex"
 version = "0.16.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 dependencies = [
  "ansi_term",
  "anyhow",
+ "async-lock",
  "console_error_panic_hook",
  "futures",
  "getrandom 0.3.4",

Cargo.toml

···
 
 scc = "3"
 rapidhash = { version = "4", features = ["unsafe"] }
+async-lock = "3.4.1"
 
 [patch.crates-io]
 vfs = { git = "https://github.com/landaire/rust-vfs", branch = "fix/wasm" }

src/completion.rs

···
+use futures::FutureExt;
+use js_sys::Promise;
+use wasm_bindgen_futures::future_to_promise;
+
 use super::*;
 
 #[derive(Debug, Serialize)]
···
 }
 
 #[wasm_bindgen]
-pub fn completion(input: &str, js_cursor_pos: usize) -> String {
-    let engine_guard = ENGINE_STATE
-        .get()
-        .unwrap()
-        .lock()
-        .expect("engine state initialized");
+pub fn completion(input: String, js_cursor_pos: usize) -> Promise {
+    future_to_promise(completion_impl(input, js_cursor_pos).map(|s| Ok(JsValue::from_str(&s))))
+}
+
+pub async fn completion_impl(input: String, js_cursor_pos: usize) -> String {
+    let engine_guard = read_engine_state().await;
     let root = get_pwd();
 
     // Map UTF-16 cursor position (from JS) to Byte index (for Rust)
···
         .nth(js_cursor_pos)
         .unwrap_or(input.len());
 
-    // 1. Parse & Flatten
-    let mut working_set = StateWorkingSet::new(&engine_guard);
-    // CRITICAL: Capture the start offset so we can normalize spans later
-    let global_offset = working_set.next_span_start();
-    let block = parse(&mut working_set, None, input.as_bytes(), false);
-    let shapes = flatten_block(&working_set, &block);
+    let (working_set, shapes, global_offset) = {
+        let mut working_set = StateWorkingSet::new(&engine_guard);
+        let global_offset = working_set.next_span_start();
+        let block = parse(&mut working_set, None, input.as_bytes(), false);
+        let shapes = flatten_block(&working_set, &block);
+        (working_set, shapes, global_offset)
+    };
 
     // 2. Identify context
     let mut is_command_pos = false;
···
         }
     }
 
+    let cmds =
+        working_set.find_commands_by_predicate(|value| value.starts_with(prefix.as_bytes()), true);
+    drop(working_set);
+    drop(engine_guard);
+
     // Fallback to Lexer if in whitespace
     if !found_shape {
         let (tokens, _err) = lex(input.as_bytes(), 0, &[], &[], true);
···
         });
     };
 
-    let working_set = StateWorkingSet::new(&engine_guard);
-
     if is_command_pos {
-        for (_, name, desc, _) in working_set
-            .find_commands_by_predicate(|value| value.starts_with(prefix.as_bytes()), true)
-        {
+        for (_, name, desc, _) in cmds {
             add_cmd_suggestion(name, desc);
         }
     } else {

src/highlight.rs

···
+use futures::FutureExt;
+use js_sys::Promise;
+use wasm_bindgen_futures::future_to_promise;
+
 use super::*;
 
 #[wasm_bindgen]
-pub fn highlight(input: &str) -> String {
-    let engine_guard = ENGINE_STATE
-        .get()
-        .unwrap()
-        .lock()
-        .expect("engine state initialized");
-    let mut working_set = StateWorkingSet::new(&engine_guard);
-
-    // Capture the global offset before parsing, as parse will generate spans relative to this
-    let global_offset = working_set.next_span_start();
-
-    // Parse the input block using Nushell's full parser
-    let block = parse(&mut working_set, None, input.as_bytes(), false);
+pub fn highlight(input: String) -> Promise {
+    future_to_promise(highlight_impl(input).map(|s| Ok(JsValue::from_str(&s))))
+}
 
-    // Flatten the block to get shapes (semantic tokens)
-    let shapes = flatten_block(&working_set, &block);
+pub async fn highlight_impl(input: String) -> String {
+    let (global_offset, shapes) = {
+        let engine_guard = read_engine_state().await;
+        let mut working_set = StateWorkingSet::new(&engine_guard);
+        let offset = working_set.next_span_start();
+        let block = parse(&mut working_set, None, input.as_bytes(), false);
+        (offset, flatten_block(&working_set, &block))
+    };
 
     let mut output = String::new();
     let mut last_end = 0;

src/lib.rs

···
+use async_lock::{RwLock, RwLockReadGuard, RwLockUpgradableReadGuard, RwLockWriteGuard};
+use futures::FutureExt;
 use jacquard::chrono;
+use js_sys::Promise;
 use miette::Report;
 use nu_cmd_base::hook::eval_hook;
 use nu_cmd_extra::add_extra_command_context;
···
 use nu_parser::{FlatShape, TokenContents, flatten_block, lex, parse};
 use nu_protocol::{
     Config, ListStream, PipelineData, Signals, Span,
-    engine::{Call, EngineState, Stack, StateWorkingSet},
+    engine::{EngineState, Stack, StateWorkingSet},
 };
 use serde::Serialize;
 use std::{
     io::Cursor,
-    path::PathBuf,
-    sync::{Arc, Mutex, OnceLock},
+    sync::{Arc, OnceLock},
     time::UNIX_EPOCH,
 };
 use vfs::VfsError;
 use wasm_bindgen::prelude::*;
+use wasm_bindgen_futures::future_to_promise;
 
 pub mod cmd;
 pub mod completion;
···
     let _ = print_to_console(&msg, false);
 }
 
-static ENGINE_STATE: OnceLock<Mutex<EngineState>> = OnceLock::new();
-static STACK: OnceLock<Mutex<Stack>> = OnceLock::new();
+static ENGINE_STATE: OnceLock<RwLock<EngineState>> = OnceLock::new();
+#[inline]
+async fn read_engine_state() -> RwLockReadGuard<'static, EngineState> {
+    ENGINE_STATE.get().unwrap().read().await
+}
+#[inline]
+async fn write_engine_state() -> RwLockWriteGuard<'static, EngineState> {
+    ENGINE_STATE.get().unwrap().write().await
+}
+
+static STACK: OnceLock<RwLock<Stack>> = OnceLock::new();
+#[inline]
+async fn read_stack() -> RwLockReadGuard<'static, Stack> {
+    STACK.get().unwrap().read().await
+}
+#[inline]
+async fn write_stack() -> RwLockWriteGuard<'static, Stack> {
+    STACK.get().unwrap().write().await
+}
 
 fn init_engine_internal() -> Result<(), Report> {
     let mut engine_state = create_default_context();
···
     engine_state.set_signals(Signals::new(Arc::new(InterruptBool)));
 
     ENGINE_STATE
-        .set(Mutex::new(engine_state))
+        .set(RwLock::new(engine_state))
         .map_err(|_| miette::miette!("ENGINE_STATE was already set!?"))?;
     STACK
-        .set(Mutex::new(Stack::new()))
+        .set(RwLock::new(Stack::new()))
         .map_err(|_| miette::miette!("STACK was already set!?"))?;
 
     // web_sys::console::log_1(&"Hello, World!".into());
···
     init_engine_internal().map_or_else(|err| format!("error: {err}"), |_| String::new())
 }
 
-fn run_command_internal(
-    engine_state: &mut EngineState,
-    stack: &mut Stack,
-    input: &str,
-) -> Result<(), CommandError> {
-    // apply any pending deltas from previous commands (like `source`)
-    apply_pending_deltas(engine_state).map_err(|e| CommandError {
-        error: Report::new(e),
-        start_offset: 0,
-    })?;
-    let pwd = get_pwd_string().into_value(Span::unknown());
-    engine_state.add_env_var("PWD".to_string(), pwd.clone());
+async fn run_command_internal(input: &str) -> Result<(), CommandError> {
+    let mut engine_state = ENGINE_STATE.get().unwrap().upgradable_read().await;
+    let (mut working_set, signals, config) = {
+        let mut write_engine_state = RwLockUpgradableReadGuard::upgrade(engine_state).await;
+        apply_pending_deltas(&mut write_engine_state).map_err(|e| CommandError {
+            error: Report::new(e),
+            start_offset: 0,
+        })?;
+        write_engine_state.add_env_var(
+            "PWD".to_string(),
+            get_pwd_string().into_value(Span::unknown()),
+        );
+        engine_state = RwLockWriteGuard::downgrade_to_upgradable(write_engine_state);
 
-    let mut working_set = StateWorkingSet::new(engine_state);
+        (
+            StateWorkingSet::new(&engine_state),
+            engine_state.signals().clone(),
+            engine_state.config.clone(),
+        )
+    };
     let start_offset = working_set.next_span_start();
     let block = parse(&mut working_set, Some("entry"), input.as_bytes(), false);
 
···
             start_offset,
         });
     }
+    let delta = working_set.delta;
 
-    engine_state
-        .merge_delta(working_set.delta)
-        .map_err(cmd_err)?;
-    let result = eval_block::<nu_protocol::debugger::WithoutDebug>(
-        engine_state,
-        stack,
-        &block,
-        PipelineData::Empty,
-    );
+    let result = {
+        let mut write_engine_state = RwLockUpgradableReadGuard::upgrade(engine_state).await;
+        let mut stack = write_stack().await;
+        write_engine_state.merge_delta(delta).map_err(cmd_err)?;
+        let res = eval_block::<nu_protocol::debugger::WithoutDebug>(
+            &mut write_engine_state,
+            &mut stack,
+            &block,
+            PipelineData::Empty,
+        );
+        engine_state = RwLockWriteGuard::downgrade_to_upgradable(write_engine_state);
+        res
+    };
 
     let pipeline_data = result.map_err(cmd_err)?.body;
-    let signals = engine_state.signals().clone();
 
     // this is annoying but we have to collect here so we can uncover errors
     // before passing the data off to Table, because otherwise Table
···
         x => x,
     };
 
-    let conf = stack.get_config(engine_state);
-    let hook = conf.hooks.display_output.as_ref();
-    let res = eval_hook(
-        engine_state,
-        stack,
-        Some(pipeline_data),
-        vec![],
-        hook.unwrap(),
-        "display_output",
-    )
-    .map_err(cmd_err)?;
+    let res = {
+        let mut write_engine_state = RwLockUpgradableReadGuard::upgrade(engine_state).await;
+        let mut stack = write_stack().await;
+        eval_hook(
+            &mut write_engine_state,
+            &mut stack,
+            Some(pipeline_data),
+            vec![],
+            config.hooks.display_output.as_ref().unwrap(),
+            "display_output",
+        )
+        .map_err(cmd_err)?
+    };
 
     match res {
         PipelineData::Empty => {}
         PipelineData::Value(v, _) => {
-            print_to_console(&v.to_expanded_string("\n", &engine_state.config), true)
-                .map_err(cmd_err)?;
+            print_to_console(&v.to_expanded_string("\n", &config), true).map_err(cmd_err)?;
         }
         PipelineData::ByteStream(s, _) => {
             for line in s.lines().into_iter().flatten() {
···
                 let out = item
                     .unwrap_error()
                     .map_err(cmd_err)?
-                    .to_expanded_string("\n", &engine_state.config);
+                    .to_expanded_string("\n", &config);
                 print_to_console(&out, true).map_err(cmd_err)?;
             }
         }
···
 }
 
 #[wasm_bindgen]
-pub fn run_command(input: &str) -> Option<String> {
-    let (mut engine_guard, mut stack_guard) = (
-        ENGINE_STATE
-            .get()
-            .unwrap()
-            .lock()
-            .expect("engine state initialized"),
-        STACK.get().unwrap().lock().expect("stack initialized"),
-    );
+pub fn run_command(input: String) -> Promise {
+    set_interrupt(false);
 
-    set_interrupt(false);
-    match run_command_internal(&mut engine_guard, &mut stack_guard, input) {
-        Ok(_) => None,
-        Err(cmd_err) => Some(format_error(
-            cmd_err.error,
-            input.to_owned(),
-            cmd_err.start_offset,
-        )),
-    }
+    future_to_promise(async move {
+        run_command_internal(&input)
+            .map(|res| {
+                res.map_or_else(
+                    |cmd_err| {
+                        Some(format_error(
+                            cmd_err.error,
+                            input.to_owned(),
+                            cmd_err.start_offset,
+                        ))
+                    },
+                    |_| None,
+                )
+            })
+            .map(|res| {
+                Ok(res
+                    .map(|s| JsValue::from_str(&s))
+                    .unwrap_or_else(JsValue::null))
+            })
+            .await
+    })
 }
 
 #[wasm_bindgen]
···
     }
     pwd.as_str().to_string()
 }
-
-pub fn get_pwd_buf() -> PathBuf {
-    // web_sys::console::log_1(&"before pwd".into());
-    let pwd = get_pwd();
-    // web_sys::console::log_1(&"after pwd".into());
-    if pwd.is_root() {
-        return PathBuf::new().join("/");
-    }
-    pwd.as_str().into()
-}

www/src/main.ts

···
         output += currentLine;
       }
     } catch (e) {
+      console.error(`cant highlight: ${e}`);
       output += currentLine;
     }
 

www/src/worker.ts

···
 });
 
 // Handle messages from Main Thread
-self.onmessage = (e) => {
+self.onmessage = async (e) => {
   const { id, type, payload } = e.data;
 
   // console.log("Received message:", id, type, payload);
···
         set_interrupt_buffer(payload);
         break;
       case "run":
-        result = run_command(payload);
+        result = await run_command(payload);
         break;
       case "completion":
-        result = completion(payload.line, payload.cursor);
+        result = await completion(payload.line, payload.cursor);
         break;
       case "highlight":
-        result = highlight(payload);
+        result = await highlight(payload);
         break;
       case "get_pwd":
         result = get_pwd_string();