feat(ie-js): integrate Boa JS engine with console API #80

JsRuntime wrapping boa_engine::Context:
- execute(source) — run JS, log errors via tracing
- eval(source) — run JS, return string result
- console.log/warn/error/info mapped to tracing targets

console.rs:
- register_console: creates console global with 4 methods
- NativeFunction::from_copy_closure for each method
- format_args_to_string: converts JsValue args to display strings

execute_scripts helper: runs Vec<String> of script contents,
collects errors without crashing.

7 tests: runtime creation, eval arithmetic, console methods,
JS error handling, string operations, multi-script execution.

Author: thomasnemer

crates/ie-js/src/console.rs

@@ -0,0 +1,54 @@
+use boa_engine::{
+    Context, JsValue, NativeFunction, js_string, object::ObjectInitializer, property::Attribute,
+};
+
+/// Register the `console` global object with log/warn/error/info methods.
+pub fn register_console(context: &mut Context) {
+    let log = NativeFunction::from_copy_closure(|_this, args, _ctx| {
+        let msg = format_args_to_string(args);
+        tracing::info!(target: "ie_js::console", "{msg}");
+        Ok(JsValue::undefined())
+    });
+
+    let warn = NativeFunction::from_copy_closure(|_this, args, _ctx| {
+        let msg = format_args_to_string(args);
+        tracing::warn!(target: "ie_js::console", "{msg}");
+        Ok(JsValue::undefined())
+    });
+
+    let error = NativeFunction::from_copy_closure(|_this, args, _ctx| {
+        let msg = format_args_to_string(args);
+        tracing::error!(target: "ie_js::console", "{msg}");
+        Ok(JsValue::undefined())
+    });
+
+    let info = NativeFunction::from_copy_closure(|_this, args, _ctx| {
+        let msg = format_args_to_string(args);
+        tracing::info!(target: "ie_js::console", "{msg}");
+        Ok(JsValue::undefined())
+    });
+
+    let console = ObjectInitializer::new(context)
+        .function(log, js_string!("log"), 0)
+        .function(warn, js_string!("warn"), 0)
+        .function(error, js_string!("error"), 0)
+        .function(info, js_string!("info"), 0)
+        .build();
+
+    let _ = context.register_global_property(js_string!("console"), console, Attribute::all());
+}
+
+fn format_args_to_string(args: &[JsValue]) -> String {
+    args.iter()
+        .map(|v| match v {
+            JsValue::String(s) => s.to_std_string_escaped(),
+            JsValue::Integer(n) => n.to_string(),
+            JsValue::Rational(n) => n.to_string(),
+            JsValue::Boolean(b) => b.to_string(),
+            JsValue::Null => "null".to_string(),
+            JsValue::Undefined => "undefined".to_string(),
+            _ => format!("{v:?}"),
+        })
+        .collect::<Vec<_>>()
+        .join(" ")
+}

crates/ie-js/src/lib.rs

@@ -3,21 +3,119 @@
 //! JavaScript engine integration using Boa.
 //! Provides DOM bindings and Web API surface.
 
+mod console;
+
 use anyhow::Result;
-use boa_engine::Context;
+use boa_engine::{Context, Source};
 
 pub struct JsRuntime {
-    #[expect(dead_code)]
     context: Context,
 }
 
 impl JsRuntime {
     pub fn new() -> Result<Self> {
-        let context = Context::default();
+        let mut context = Context::default();
+        console::register_console(&mut context);
         Ok(Self { context })
     }
 
-    pub fn eval(&mut self, _source: &str) -> Result<()> {
-        todo!("JS evaluation with DOM bindings")
+    /// Execute a JavaScript source string. Returns Ok on success, Err on JS error.
+    pub fn execute(&mut self, source: &str) -> Result<()> {
+        match self.context.eval(Source::from_bytes(source)) {
+            Ok(_) => Ok(()),
+            Err(e) => {
+                let msg = e.to_string();
+                tracing::warn!("JS error: {msg}");
+                Err(anyhow::anyhow!("JS error: {msg}"))
+            }
+        }
+    }
+
+    /// Execute and return the string representation of the result.
+    pub fn eval(&mut self, source: &str) -> Result<String> {
+        match self.context.eval(Source::from_bytes(source)) {
+            Ok(val) => {
+                let result = val
+                    .to_string(&mut self.context)
+                    .map(|s| s.to_std_string_escaped())
+                    .unwrap_or_else(|_| "undefined".to_string());
+                Ok(result)
+            }
+            Err(e) => {
+                let msg = e.to_string();
+                tracing::warn!("JS error: {msg}");
+                Err(anyhow::anyhow!("JS error: {msg}"))
+            }
+        }
+    }
+}
+
+/// Execute all script contents from a parsed HTML page.
+pub fn execute_scripts(scripts: &[String]) -> Vec<String> {
+    let mut errors = Vec::new();
+    let Ok(mut runtime) = JsRuntime::new() else {
+        errors.push("failed to create JS runtime".to_string());
+        return errors;
+    };
+    for script in scripts {
+        if let Err(e) = runtime.execute(script) {
+            errors.push(e.to_string());
+        }
+    }
+    errors
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn runtime_creates() {
+        JsRuntime::new().unwrap();
+    }
+
+    #[test]
+    fn simple_eval() {
+        let mut rt = JsRuntime::new().unwrap();
+        let result = rt.eval("1 + 2").unwrap();
+        assert_eq!(result, "3");
+    }
+
+    #[test]
+    fn console_log_does_not_crash() {
+        let mut rt = JsRuntime::new().unwrap();
+        rt.execute("console.log('hello from JS')").unwrap();
+    }
+
+    #[test]
+    fn console_warn_error_info() {
+        let mut rt = JsRuntime::new().unwrap();
+        rt.execute("console.warn('warning'); console.error('error'); console.info('info')")
+            .unwrap();
+    }
+
+    #[test]
+    fn js_error_does_not_panic() {
+        let mut rt = JsRuntime::new().unwrap();
+        let result = rt.execute("undefined_function()");
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn string_operations() {
+        let mut rt = JsRuntime::new().unwrap();
+        let result = rt.eval("'hello' + ' ' + 'world'").unwrap();
+        assert_eq!(result, "hello world");
+    }
+
+    #[test]
+    fn execute_scripts_helper() {
+        let scripts = vec![
+            "console.log('script 1')".to_string(),
+            "var x = 42".to_string(),
+            "bad syntax {{{{".to_string(),
+        ];
+        let errors = execute_scripts(&scripts);
+        assert_eq!(errors.len(), 1); // only the bad syntax one
     }
 }