feat(ext/web): queueMicrotask

feat(ext/web): queueMicrotask

Author: load1n9

.github/workflows/release.yml

@@ -54,6 +54,9 @@ jobs:
           if [ "${{ matrix.os }}" = "windows-latest" ]; then
             mv andromeda.exe ${{ matrix.asset-name }}
           else
+            mv andromeda ${{ matrix.asset-name }}
+          fi
+
       - name: Upload Binary to Release
         if: github.ref == 'refs/heads/main'
         uses: svenstaro/upload-release-action@v2

cli/src/repl.rs

@@ -5,7 +5,7 @@
 use crate::error::{AndromedaError, Result, print_error};
 use crate::styles::format_js_value;
 use andromeda_core::{HostData, RuntimeHostHooks};
-use andromeda_runtime::{recommended_builtins, recommended_extensions};
+use andromeda_runtime::{RuntimeMacroTask, recommended_builtins, recommended_extensions};
 use console::Style;
 use nova_vm::{
     ecmascript::{
@@ -585,7 +585,7 @@ pub fn run_repl(expose_internals: bool, print_internals: bool, disable_gc: bool)
     let host_data = HostData::new(_macro_task_tx);
 
     let host_hooks = RuntimeHostHooks::new(host_data);
-    let host_hooks: &RuntimeHostHooks<()> = &*Box::leak(Box::new(host_hooks));
+    let host_hooks: &RuntimeHostHooks<RuntimeMacroTask> = &*Box::leak(Box::new(host_hooks));
 
     let mut agent = GcAgent::new(
         Options {

examples/queue_microtask.ts

@@ -0,0 +1,24 @@
+console.log("Testing queueMicrotask error reporting behavior...");
+
+// This should execute successfully
+queueMicrotask(() => {
+  console.log("✓ First microtask executed successfully");
+});
+
+// This should throw an error but not crash the program
+queueMicrotask(() => {
+  console.log("About to throw an error in microtask...");
+  throw new Error("This is a test error in a microtask callback");
+});
+
+// This should still execute despite the previous error
+queueMicrotask(() => {
+  console.log("✓ Third microtask executed successfully after error");
+});
+
+console.log("All microtasks queued. They will execute asynchronously...");
+
+// Wait a bit to see the results
+setTimeout(() => {
+  console.log("✓ Test completed - error reporting working correctly!");
+}, 50);

runtime/src/event_loop.rs

@@ -3,6 +3,7 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
 use crate::ext::{interval::IntervalId, timeout::TimeoutId};
+use nova_vm::{ecmascript::types::Value, engine::Global};
 
 pub enum RuntimeMacroTask {
     /// Run an interval.
@@ -13,4 +14,6 @@ pub enum RuntimeMacroTask {
     RunAndClearTimeout(TimeoutId),
     /// Stop a timeout from running no further.
     ClearTimeout(TimeoutId),
+    /// Run a microtask callback
+    RunMicrotaskCallback(Global<Value<'static>>),
 }

runtime/src/ext/web/mod.rs

@@ -2,7 +2,10 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
+use crate::RuntimeMacroTask;
 use andromeda_core::{Extension, ExtensionOp};
+use andromeda_core::{HostData, MacroTask};
+use nova_vm::engine::Global;
 use nova_vm::{
     ecmascript::{
         builtins::ArgumentsList,
@@ -11,6 +14,7 @@ use nova_vm::{
     },
     engine::context::{Bindable, GcScope, NoGcScope},
 };
+
 use std::time::{Instant, SystemTime, UNIX_EPOCH};
 
 // TODO: Get the time origin from when the runtime starts
@@ -45,6 +49,7 @@ impl WebExt {
                     Self::internal_performance_time_origin,
                     0,
                 ),
+                ExtensionOp::new("queueMicrotask", Self::queue_microtask, 1),
             ],
             storage: None,
             files: vec![
@@ -420,4 +425,50 @@ impl WebExt {
 
         Ok(Value::from_f64(agent, origin_ms, gc).unbind())
     }
+
+    /// Implementation of queueMicrotask as per HTML specification:
+    /// https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-queuemicrotask
+    pub fn queue_microtask<'gc>(
+        agent: &mut Agent,
+        _this: Value,
+        args: ArgumentsList,
+        gc: GcScope<'gc, '_>,
+    ) -> JsResult<'gc, Value<'gc>> {
+        let callback = args.get(0);
+        let _: nova_vm::ecmascript::types::Function = match callback.try_into() {
+            Ok(function) => function,
+            Err(_) => {
+                return Err(agent
+                    .throw_exception(
+                        ExceptionType::TypeError,
+                        "The callback provided as an argument to queueMicrotask must be a function.".to_string(),
+                        gc.nogc(),
+                    )
+                    .unbind());
+            }
+        };
+
+        // TODO: Implement proper microtask queueing when Nova APIs become available
+
+        // Store the callback globally so it can be called later
+        let root_callback = Global::new(agent, callback.unbind());
+
+        // Get host data to access the macro task system
+        let host_data = agent.get_host_data();
+        let host_data: &HostData<RuntimeMacroTask> = host_data.downcast_ref().unwrap();
+        let macro_task_tx = host_data.macro_task_tx();
+
+        // Schedule an immediate task to call the callback
+        // Using spawn_macro_task with an immediately resolving future
+        host_data.spawn_macro_task(async move {
+            // Send a macro task to call the callback
+            macro_task_tx
+                .send(MacroTask::User(RuntimeMacroTask::RunMicrotaskCallback(
+                    root_callback,
+                )))
+                .unwrap();
+        });
+
+        Ok(Value::Undefined)
+    }
 }

runtime/src/recommended.rs

@@ -2,8 +2,11 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-use andromeda_core::{Extension, HostData};
-use nova_vm::ecmascript::execution::agent::{GcAgent, RealmRoot};
+use andromeda_core::{AndromedaError, ErrorReporter, Extension, HostData};
+use nova_vm::{
+    ecmascript::execution::agent::{GcAgent, RealmRoot},
+    ecmascript::types::{Function, Value},
+};
 
 use crate::{ConsoleExt, FsExt, HeadersExt, ProcessExt, RuntimeMacroTask, TimeExt, URLExt, WebExt};
 
@@ -44,5 +47,32 @@ pub fn recommended_eventloop_handler(
         RuntimeMacroTask::ClearTimeout(timeout_id) => {
             timeout_id.clear_and_abort(host_data);
         }
+        RuntimeMacroTask::RunMicrotaskCallback(root_callback) => {
+            // Execute the microtask callback - this is for queueMicrotask implementation
+            agent.run_in_realm(realm_root, |agent, gc| {
+                let callback = root_callback.get(agent, gc.nogc());
+                if let Ok(callback_function) = Function::try_from(callback) {
+                    // Call the callback with no arguments as per HTML spec
+                    // If the callback throws an error, it should be reported but not stop execution
+                    if let Err(error) = callback_function.call(agent, Value::Undefined, &mut [], gc)
+                    {
+                        // Report the error as per Web IDL "invoke a callback function" with "report" error handling
+                        // This is the proper implementation of error reporting for queueMicrotask
+                        report_microtask_error(error);
+                    }
+                }
+            });
+        }
     }
 }
+
+/// Report a microtask error
+/// This is called when a queueMicrotask callback throws an exception.
+fn report_microtask_error<E>(error: E)
+where
+    E: std::fmt::Debug,
+{
+    let error_message = format!("Uncaught error in microtask callback: {:?}", error);
+    let andromeda_error = AndromedaError::runtime_error(error_message);
+    ErrorReporter::print_error(&andromeda_error);
+}