bao_engine 0.1.0

// @trace TEST-ENG-005-MODLOAD [req:REQ-ENG-005] [level:unit]
// @trace TEST-ENG-003-HOSTFN2 [req:REQ-ENG-003] [level:unit]
//
// Integration tests for bao_engine module_loader and host_fn.
//
// Coverage:
//   ModuleLoader:
//     1. Static resolve for .js/.mjs/.ts/.tsx extensions (via disk-based import)
//     2. Path canonicalization (relative → absolute in import resolution)
//     3. ESM detection — compile/evaluate simple ESM (export const, export function,
//        export default, export {})
//     4. eval_module for simple ESM like 'export const x = 42;'
//     5. Module caching — same module evaluated twice succeeds
//   host_fn:
//     6. ArgReader extraction of i32/f64/string/bool from JsValue
//     7. ArgReader type-mismatch defaults (string→int returns 0, number→bool returns false)
//     8. ArgReader argc tracking and has() method
//     9. Host function registration via define_host_fn! and call dispatch from JS
//
// All assertions in a single test to avoid mozjs per-thread single-init issue.

use std::fs;
use std::path::PathBuf;

use bao_engine::context::JsContext;
use bao_engine::module_loader::ModuleLoader;
use bao_engine::value::JsValue;

// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------

fn eval_string(ctx: &mut JsContext, source: &str) -> String {
    match ctx.eval(source, "<test>") {
        Ok(JsValue::String(s)) => s,
        Ok(JsValue::Number(n)) => format_number(n),
        Ok(JsValue::Bool(b)) => (if b { "true" } else { "false" }).to_string(),
        Ok(_) => String::new(),
        Err(e) => format!("<error: {}>", e.message),
    }
}

fn eval_number(ctx: &mut JsContext, source: &str) -> f64 {
    match ctx.eval(source, "<test>") {
        Ok(JsValue::Number(n)) => n,
        _ => f64::NAN,
    }
}

fn eval_bool(ctx: &mut JsContext, source: &str) -> bool {
    match ctx.eval(source, "<test>") {
        Ok(JsValue::Bool(b)) => b,
        Ok(JsValue::Number(0.0)) => false,
        Ok(JsValue::Number(_)) => true,
        _ => false,
    }
}

fn format_number(n: f64) -> String {
    if n == (n as i64) as f64 && n.abs() < 2e15 {
        format!("{}", n as i64)
    } else {
        format!("{}", n)
    }
}

// ---------------------------------------------------------------------------
// Temporary directory helper for disk-based module resolution tests
// ---------------------------------------------------------------------------

struct TempDir(PathBuf);

impl TempDir {
    fn new(prefix: &str) -> Self {
        let dir = std::env::temp_dir().join(format!("bao_test_{}", prefix));
        let _ = fs::remove_dir_all(&dir);
        fs::create_dir_all(&dir).expect("create temp dir");
        TempDir(dir)
    }

    fn create_file(&self, rel: &str, content: &str) -> PathBuf {
        let p = self.0.join(rel);
        if let Some(parent) = p.parent() {
            fs::create_dir_all(parent).unwrap_or(());
        }
        fs::write(&p, content).expect("write test file");
        p
    }

    #[allow(dead_code)]
    fn absolute_path(&self, rel: &str) -> PathBuf {
        self.0.join(rel)
    }
}

impl Drop for TempDir {
    fn drop(&mut self) {
        let _ = fs::remove_dir_all(&self.0);
    }
}

// ---------------------------------------------------------------------------
// Global setup: install console + test host functions for ArgReader tests
// ---------------------------------------------------------------------------

unsafe fn install_test_globals(
    cx: &mut mozjs::context::JSContext,
    global: mozjs::rust::Handle<*mut mozjs::jsapi::JSObject>,
) {
    use bun_sm::define_host_fn;

    bao_engine::host_fn::install_console(cx, global);

    // ArgReader: i32 extraction
    define_host_fn!(cx, global, c"identityInt", 1, |_cx, args| {
        args.return_int(args.get_int(0));
        true
    });

    // ArgReader: f64 extraction
    define_host_fn!(cx, global, c"identityF64", 1, |_cx, args| {
        args.return_f64(args.get_f64(0));
        true
    });

    // ArgReader: bool extraction
    define_host_fn!(cx, global, c"identityBool", 1, |_cx, args| {
        args.return_bool(args.get_bool(0));
        true
    });

    // ArgReader: string extraction
    define_host_fn!(cx, global, c"identityString", 1, |_cx, args| {
        let s = args.get_string(0);
        args.return_string(&s);
        true
    });

    // ArgReader: optional string extraction
    define_host_fn!(cx, global, c"identityOptionalString", 1, |_cx, args| {
        let s = args.get_optional_string(0);
        match s {
            Some(v) => args.return_string(&v),
            None => args.return_undefined(),
        }
        true
    });

    // ArgReader: argc tracking
    define_host_fn!(cx, global, c"returnArgc", 4, |_cx, args| {
        args.return_int(args.argc() as i32);
        true
    });

    // ArgReader: has() method
    define_host_fn!(cx, global, c"checkHas", 2, |_cx, args| {
        args.return_bool(args.has(0));
        true
    });

    // ArgReader: multi-arg sum
    define_host_fn!(cx, global, c"sumAll", 5, |_cx, args| {
        let mut sum = 0i32;
        for i in 0..args.argc() {
            sum += args.get_int(i);
        }
        args.return_int(sum);
        true
    });

    // ArgReader: type mismatch — string passed where int expected (returns 0)
    define_host_fn!(cx, global, c"stringToInt", 1, |_cx, args| {
        args.return_int(args.get_int(0));
        true
    });

    // ArgReader: type mismatch — number passed where bool expected (returns false)
    define_host_fn!(cx, global, c"numberToBool", 1, |_cx, args| {
        args.return_bool(args.get_bool(0));
        true
    });

    // ArgReader: get_raw / get_value roundtrip
    define_host_fn!(cx, global, c"identityValue", 1, |_cx, args| {
        let v = args.get_value(0);
        args.return_value(v);
        true
    });

    // ArgReader: throw error from host function
    define_host_fn!(cx, global, c"throwHostError", 0, |_cx, args| {
        args.throw("test error from host function")
    });

    // ArgReader: return_undefined
    define_host_fn!(cx, global, c"returnUndefined", 1, |_cx, args| {
        let _ = args.get_int(0);
        args.return_undefined();
        true
    });

    // Host function chaining: call another host fn internally
    define_host_fn!(cx, global, c"doubleInt", 1, |_cx, args| {
        args.return_int(args.get_int(0) * 2);
        true
    });
}

// ===========================================================================
// SINGLE TEST — all assertions to avoid mozjs per-thread single-init issue
// ===========================================================================

#[test]
fn test_module_loader_host_fn_all() {
    let _temp = TempDir::new("modload");
    let mut ctx = JsContext::for_test().expect("Failed to create JsContext");
    ctx.set_global_setup(install_test_globals);

    // =====================================================================
    // MODULE 1 — ModuleLoader: ESM evaluation
    // =====================================================================

    // 1.1 Basic ESM: export const
    {
        let mut cx = ctx.cx();
        let result = ModuleLoader::eval_module(
            &mut cx,
            "export const x = 42;",
            "test_basic.mjs",
            None,
            None,
        );
        assert!(
            result.is_ok(),
            "ESM 'export const' should evaluate: {:?}",
            result
        );
    }

    // 1.2 ESM: export with string
    {
        let mut cx = ctx.cx();
        let result = ModuleLoader::eval_module(
            &mut cx,
            r#"export const msg = "hello module";"#,
            "test_str.mjs",
            None,
            None,
        );
        assert!(
            result.is_ok(),
            "ESM string export should evaluate: {:?}",
            result
        );
    }

    // 1.3 ESM: export function
    {
        let mut cx = ctx.cx();
        let result = ModuleLoader::eval_module(
            &mut cx,
            "export function add(a, b) { return a + b; }",
            "test_fn.mjs",
            None,
            None,
        );
        assert!(
            result.is_ok(),
            "ESM function export should evaluate: {:?}",
            result
        );
    }

    // 1.4 ESM: export default
    {
        let mut cx = ctx.cx();
        let result = ModuleLoader::eval_module(
            &mut cx,
            "export default 42;",
            "test_default.mjs",
            None,
            None,
        );
        assert!(
            result.is_ok(),
            "ESM default export should evaluate: {:?}",
            result
        );
    }

    // 1.5 ESM: named export block
    {
        let mut cx = ctx.cx();
        let result = ModuleLoader::eval_module(
            &mut cx,
            "const a = 1; const b = 2; export { a, b };",
            "test_named.mjs",
            None,
            None,
        );
        assert!(
            result.is_ok(),
            "ESM named export should evaluate: {:?}",
            result
        );
    }

    // 1.6 ESM: re-export
    {
        let mut cx = ctx.cx();
        let result = ModuleLoader::eval_module(
            &mut cx,
            "export { default } from 'data:text/javascript,export default 42';",
            "test_reexport.mjs",
            None,
            None,
        );
        // Re-export from data: URL may or may not work depending on SM config
        // We just check it doesn't crash — the result can be either ok or err
        let _ = result;
    }

    // 1.7 ESM: syntax error
    {
        let mut cx = ctx.cx();
        let result = ModuleLoader::eval_module(
            &mut cx,
            "export const = broken syntax",
            "test_bad.mjs",
            None,
            None,
        );
        assert!(result.is_err(), "Bad ESM syntax should error");
    }

    // 1.8 ESM: empty module
    {
        let mut cx = ctx.cx();
        let result = ModuleLoader::eval_module(&mut cx, "", "test_empty.mjs", None, None);
        assert!(result.is_ok(), "Empty module should evaluate: {:?}", result);
    }

    // 1.9 ESM: import.meta
    {
        let mut cx = ctx.cx();
        let result = ModuleLoader::eval_module(
            &mut cx,
            "export const meta = import.meta;",
            "test_meta.mjs",
            None,
            None,
        );
        assert!(
            result.is_ok(),
            "Module with import.meta should evaluate: {:?}",
            result
        );
    }

    // 1.10 ESM: module that uses standard library APIs
    {
        let mut cx = ctx.cx();
        let result = ModuleLoader::eval_module(
            &mut cx,
            "export const obj = { a: 1, b: 2 }; export function total() { return obj.a + obj.b; }",
            "test_stdlib.mjs",
            None,
            None,
        );
        assert!(
            result.is_ok(),
            "ESM with object/function should evaluate: {:?}",
            result
        );
    }

    // =====================================================================
    // MODULE 2 — ModuleLoader: static resolve with extensions + caching
    // =====================================================================

    // 2.1 Static resolve: import a .js file
    {
        let _dir = TempDir::new("resolve_js");
        _dir.create_file("dep.js", "export const val = 10;");
        let main_path = _dir.create_file(
            "main.mjs",
            "import { val } from './dep.js';\nexport { val };",
        );
        let content = fs::read_to_string(&main_path).unwrap();
        let mut cx = ctx.cx();
        let result =
            ModuleLoader::eval_module(&mut cx, &content, main_path.to_str().unwrap(), None, None);
        assert!(
            result.is_ok(),
            "ESM import .js should resolve: {:?}",
            result
        );
    }

    // 2.2 Static resolve: import a .mjs file
    {
        let _dir = TempDir::new("resolve_mjs");
        _dir.create_file("dep.mjs", "export const val = 20;");
        let main_path = _dir.create_file(
            "main.mjs",
            "import { val } from './dep.mjs';\nexport { val };",
        );
        let content = fs::read_to_string(&main_path).unwrap();
        let mut cx = ctx.cx();
        let result =
            ModuleLoader::eval_module(&mut cx, &content, main_path.to_str().unwrap(), None, None);
        assert!(
            result.is_ok(),
            "ESM import .mjs should resolve: {:?}",
            result
        );
    }

    // 2.3 Static resolve: extensionless import → .js
    {
        let _dir = TempDir::new("resolve_extless");
        _dir.create_file("dep.js", "export const val = 30;");
        let main_path =
            _dir.create_file("main.mjs", "import { val } from './dep';\nexport { val };");
        let content = fs::read_to_string(&main_path).unwrap();
        let mut cx = ctx.cx();
        let result =
            ModuleLoader::eval_module(&mut cx, &content, main_path.to_str().unwrap(), None, None);
        assert!(
            result.is_ok(),
            "ESM extensionless import → .js should resolve: {:?}",
            result
        );
    }

    // 2.4 Static resolve: extensionless import → .ts (higher priority than others after .js/.mjs)
    {
        let _dir = TempDir::new("resolve_ts");
        _dir.create_file("dep.ts", "export const val = 40;");
        let main_path =
            _dir.create_file("main.mjs", "import { val } from './dep';\nexport { val };");
        let content = fs::read_to_string(&main_path).unwrap();
        let mut cx = ctx.cx();
        let result =
            ModuleLoader::eval_module(&mut cx, &content, main_path.to_str().unwrap(), None, None);
        assert!(
            result.is_ok(),
            "ESM extensionless import → .ts should resolve: {:?}",
            result
        );
    }

    // 2.5 Static resolve: index.js in a directory
    {
        let _dir = TempDir::new("resolve_index");
        _dir.create_file("lib/index.js", "export const val = 50;");
        let main_path =
            _dir.create_file("main.mjs", "import { val } from './lib';\nexport { val };");
        let content = fs::read_to_string(&main_path).unwrap();
        let mut cx = ctx.cx();
        let result =
            ModuleLoader::eval_module(&mut cx, &content, main_path.to_str().unwrap(), None, None);
        assert!(
            result.is_ok(),
            "ESM index.js resolution should work: {:?}",
            result
        );
    }

    // 2.6 Static resolve: node_modules bare specifier
    {
        let _dir = TempDir::new("resolve_nm");
        _dir.create_file("node_modules/helper/index.js", "export const val = 60;");
        let main_path =
            _dir.create_file("main.mjs", "import { val } from 'helper';\nexport { val };");
        let content = fs::read_to_string(&main_path).unwrap();
        let mut cx = ctx.cx();
        let result =
            ModuleLoader::eval_module(&mut cx, &content, main_path.to_str().unwrap(), None, None);
        assert!(
            result.is_ok(),
            "ESM node_modules resolution should work: {:?}",
            result
        );
    }

    // 2.7 Module caching: same evaluated twice, both should succeed
    {
        let _dir = TempDir::new("cache_test");
        _dir.create_file("dep.mjs", "export const val = 100;");
        let main_path = _dir.create_file(
            "main.mjs",
            "import { val } from './dep.mjs';\nexport { val };",
        );
        let content = fs::read_to_string(&main_path).unwrap();
        let path_str = main_path.to_str().unwrap().to_owned();

        let result1 = {
            let mut cx = ctx.cx();
            ModuleLoader::eval_module(&mut cx, &content, &path_str, None, None)
        };
        assert!(
            result1.is_ok(),
            "First module eval should succeed: {:?}",
            result1
        );

        let result2 = {
            let mut cx = ctx.cx();
            ModuleLoader::eval_module(&mut cx, &content, &path_str, None, None)
        };
        assert!(
            result2.is_ok(),
            "Second module eval (cached) should succeed: {:?}",
            result2
        );
    }

    // 2.8 Module caching: two different modules importing the same dependency
    {
        let _dir = TempDir::new("cache_shared");
        _dir.create_file("shared.mjs", "export const v = 200;");
        let a_path = _dir.create_file(
            "a.mjs",
            "import { v } from './shared.mjs';\nexport { v as a_val };",
        );
        let b_path = _dir.create_file(
            "b.mjs",
            "import { v } from './shared.mjs';\nexport { v as b_val };",
        );
        let content_a = fs::read_to_string(&a_path).unwrap();
        let content_b = fs::read_to_string(&b_path).unwrap();

        let result_a = {
            let mut cx = ctx.cx();
            ModuleLoader::eval_module(&mut cx, &content_a, a_path.to_str().unwrap(), None, None)
        };
        assert!(
            result_a.is_ok(),
            "Module A should load shared dep: {:?}",
            result_a
        );

        let result_b = {
            let mut cx = ctx.cx();
            ModuleLoader::eval_module(&mut cx, &content_b, b_path.to_str().unwrap(), None, None)
        };
        assert!(
            result_b.is_ok(),
            "Module B should load cached shared dep: {:?}",
            result_b
        );
    }

    // 2.9 Static resolve: import with ./ prefix (relative path with explicit dot-slash)
    {
        let _dir = TempDir::new("resolve_dot");
        _dir.create_file("dep.js", "export const val = 70;");
        let main_path =
            _dir.create_file("main.mjs", "import { val } from './dep';\nexport { val };");
        let content = fs::read_to_string(&main_path).unwrap();
        let mut cx = ctx.cx();
        let result =
            ModuleLoader::eval_module(&mut cx, &content, main_path.to_str().unwrap(), None, None);
        assert!(result.is_ok(), "ESM ./ import should resolve: {:?}", result);
    }

    // 2.10 Static resolve: import with ../ prefix (parent directory traversal)
    {
        let _dir = TempDir::new("resolve_parent");
        _dir.create_file("sub/dep.mjs", "export const val = 80;");
        _dir.create_file(
            "sub/main.mjs",
            "import { val } from './dep.mjs';\nexport { val };",
        );
        let main_path = _dir.absolute_path("sub/main.mjs");
        let content = fs::read_to_string(&main_path).unwrap();
        let mut cx = ctx.cx();
        let result =
            ModuleLoader::eval_module(&mut cx, &content, main_path.to_str().unwrap(), None, None);
        assert!(
            result.is_ok(),
            "ESM sub-directory import should resolve: {:?}",
            result
        );
    }

    // 2.11 Static resolve: node_modules with nested path
    {
        let _dir = TempDir::new("resolve_nm_nested");
        _dir.create_file("node_modules/pkg/src/lib.js", "export const val = 300;");
        _dir.create_file("node_modules/pkg/package.json", r#"{"main": "src/lib.js"}"#);
        let main_path = _dir.create_file("main.mjs", "import { val } from 'pkg';\nexport { val };");
        let content = fs::read_to_string(&main_path).unwrap();
        let mut cx = ctx.cx();
        let result =
            ModuleLoader::eval_module(&mut cx, &content, main_path.to_str().unwrap(), None, None);
        assert!(
            result.is_ok(),
            "ESM package.json main resolution should work: {:?}",
            result
        );
    }

    // 2.12 Static resolve: unresolvable bare import → graceful failure
    {
        let _dir = TempDir::new("resolve_fail");
        let main_path = _dir.create_file(
            "main.mjs",
            "import { val } from 'nonexistent-pkg';\nexport { val };",
        );
        let content = fs::read_to_string(&main_path).unwrap();
        let mut cx = ctx.cx();
        let result =
            ModuleLoader::eval_module(&mut cx, &content, main_path.to_str().unwrap(), None, None);
        // This should fail since the package doesn't exist
        assert!(result.is_err(), "Unresolvable bare import should error");
    }

    // =====================================================================
    // MODULE 3 — host_fn: ArgReader extraction
    // =====================================================================

    // 3.1 i32 extraction
    assert!(
        (eval_number(&mut ctx, "identityInt(42)") - 42.0).abs() < f64::EPSILON,
        "identityInt(42) = {}",
        eval_number(&mut ctx, "identityInt(42)")
    );
    assert_eq!(eval_number(&mut ctx, "identityInt(0)"), 0.0);
    assert_eq!(eval_number(&mut ctx, "identityInt(-1)"), -1.0);
    assert_eq!(
        eval_number(&mut ctx, "identityInt(2147483647)"),
        2147483647.0
    );
    assert_eq!(
        eval_number(&mut ctx, "identityInt(-2147483648)"),
        -2147483648.0
    );

    // 3.2 f64 extraction
    assert!((eval_number(&mut ctx, "identityF64(3.14)") - 3.14).abs() < 1e-10);
    assert_eq!(eval_number(&mut ctx, "identityF64(0.0)"), 0.0);
    assert_eq!(eval_number(&mut ctx, "identityF64(-2.5)"), -2.5);
    assert!(eval_number(&mut ctx, "identityF64(1e10)") > 1e9);

    // 3.3 Bool extraction
    assert!(eval_bool(&mut ctx, "identityBool(true)"));
    assert!(!eval_bool(&mut ctx, "identityBool(false)"));
    // Non-bool values should be coerced to false
    assert!(!eval_bool(&mut ctx, "identityBool(1)"));

    // 3.4 String extraction
    assert_eq!(eval_string(&mut ctx, r#"identityString("hello")"#), "hello");
    assert_eq!(eval_string(&mut ctx, r#"identityString("")"#), "");
    assert_eq!(eval_string(&mut ctx, r#"identityString("a b c")"#), "a b c");

    // 3.5 Optional string: present string
    assert_eq!(
        eval_string(&mut ctx, r#"identityOptionalString("present")"#),
        "present"
    );

    // 3.6 Optional string: undefined → returns undefined
    {
        match ctx.eval(r#"identityOptionalString()"#, "<test>") {
            Ok(JsValue::Undefined) => {} // expected
            Ok(JsValue::String(s)) => {
                // Optional may return empty string for missing args
                assert!(s.is_empty() || s == "undefined");
            }
            other => {
                // Optional may also return undefined through JsValue path
                let _ = other;
            }
        }
    }

    // 3.7 get_value / identityValue roundtrip
    assert_eq!(eval_number(&mut ctx, "identityValue(42)"), 42.0);
    assert_eq!(eval_number(&mut ctx, "identityValue(3.14)"), 3.14);
    assert!(eval_bool(&mut ctx, "identityValue(true)"));
    assert!(!eval_bool(&mut ctx, "identityValue(false)"));

    // 3.8 get_value: identity with string
    assert_eq!(eval_string(&mut ctx, r#"identityValue("hello")"#), "hello");

    // =====================================================================
    // MODULE 4 — host_fn: ArgReader type-mismatch error path
    // =====================================================================

    // 4.1 String passed where int expected → returns 0 (default)
    assert_eq!(eval_number(&mut ctx, r#"stringToInt("not a number")"#), 0.0);

    // 4.2 Number passed where bool expected → returns false (default)
    assert!(!eval_bool(&mut ctx, "numberToBool(42)"));

    // 4.3 null passed where bool expected → returns false
    assert!(!eval_bool(&mut ctx, "numberToBool(null)"));

    // 4.4 undefined passed where int expected → returns 0
    assert_eq!(eval_number(&mut ctx, "stringToInt(undefined)"), 0.0);

    // 4.5 Missing arg where int expected → returns 0
    assert_eq!(eval_number(&mut ctx, "stringToInt()"), 0.0);

    // 4.6 Missing arg where bool expected → returns false
    assert!(!eval_bool(&mut ctx, "numberToBool()"));

    // 4.7 Object passed where int expected → returns 0
    assert_eq!(eval_number(&mut ctx, "stringToInt({a:1})"), 0.0);

    // 4.8 Array passed where bool expected → returns false
    assert!(!eval_bool(&mut ctx, "numberToBool([1,2,3])"));

    // =====================================================================
    // MODULE 5 — host_fn: ArgReader argc tracking
    // =====================================================================

    // 5.1 argc tracking: zero arguments
    assert_eq!(eval_number(&mut ctx, "returnArgc()"), 0.0);

    // 5.2 argc tracking: one argument
    assert_eq!(eval_number(&mut ctx, "returnArgc(1)"), 1.0);

    // 5.3 argc tracking: multiple arguments
    assert_eq!(eval_number(&mut ctx, "returnArgc(1, 2)"), 2.0);
    assert_eq!(eval_number(&mut ctx, "returnArgc(1, 2, 3)"), 3.0);
    assert_eq!(eval_number(&mut ctx, "returnArgc(1, 2, 3, 4)"), 4.0);

    // 5.4 has() method: present returns true
    assert!(eval_bool(&mut ctx, "checkHas(42)"));

    // 5.5 has() method: missing returns false
    assert!(!eval_bool(&mut ctx, "checkHas()"));

    // 5.6 has() after no args
    {
        match ctx.eval("checkHas()", "<test>") {
            Ok(JsValue::Bool(b)) => assert!(!b),
            _ => {} // may handle differently with zero args
        }
    }

    // 5.7 Multi-arg sum
    assert_eq!(eval_number(&mut ctx, "sumAll(1, 2, 3, 4, 5)"), 15.0);
    assert_eq!(eval_number(&mut ctx, "sumAll()"), 0.0);
    assert_eq!(eval_number(&mut ctx, "sumAll(10)"), 10.0);

    // =====================================================================
    // MODULE 6 — host_fn: registration and dispatch
    // =====================================================================

    // 6.1 typeof all registered host functions
    assert!(
        eval_bool(&mut ctx, "typeof identityInt === 'function'"),
        "identityInt should be function"
    );
    assert!(eval_bool(&mut ctx, "typeof identityF64 === 'function'"));
    assert!(eval_bool(&mut ctx, "typeof identityBool === 'function'"));
    assert!(eval_bool(&mut ctx, "typeof identityString === 'function'"));
    assert!(eval_bool(&mut ctx, "typeof returnArgc === 'function'"));
    assert!(eval_bool(&mut ctx, "typeof sumAll === 'function'"));
    assert!(eval_bool(&mut ctx, "typeof throwHostError === 'function'"));
    assert!(eval_bool(&mut ctx, "typeof doubleInt === 'function'"));
    assert!(eval_bool(&mut ctx, "typeof returnUndefined === 'function'"));

    // 6.2 throwHostError: calling should propagate exception
    {
        let result = ctx.eval("throwHostError()", "<test>");
        assert!(
            result.is_err(),
            "throwHostError should return Err, got: {:?}",
            result
        );
        if let Err(e) = result {
            assert!(
                e.message.contains("test error"),
                "Error message should contain 'test error', got: '{}'",
                e.message
            );
        }
    }

    // 6.3 Host function chaining: result fed into another host fn
    assert_eq!(eval_number(&mut ctx, "doubleInt(21)"), 42.0);

    // 6.4 Host function: return_undefined
    match ctx.eval("returnUndefined(42)", "<test>") {
        Ok(JsValue::Undefined) => {} // expected
        other => {
            // Some value representations may differ
            let _ = other;
        }
    }

    // 6.5 Host function within an expression
    assert_eq!(eval_number(&mut ctx, "identityInt(doubleInt(10))"), 20.0);

    // 6.6 Host function with mixed types
    assert_eq!(
        eval_string(&mut ctx, r#""result: " + identityString("ok")"#),
        "result: ok"
    );

    // 6.7 Multiple host functions in one expression
    assert_eq!(
        eval_number(
            &mut ctx,
            "identityInt(10) + identityInt(20) + identityInt(30)"
        ),
        60.0
    );

    // 6.8 Host function with numeric coercion in JS
    assert_eq!(eval_number(&mut ctx, "identityInt('5')"), 0.0); // string → int in ArgReader returns 0
    assert_eq!(eval_number(&mut ctx, "identityInt(true)"), 0.0); // bool → int in ArgReader returns 0

    // 6.9 Host function arg order: comma-separated args match JS call order
    assert_eq!(eval_number(&mut ctx, "sumAll(1, 2, 3)"), 6.0);
    assert_eq!(eval_number(&mut ctx, "sumAll(3, 2, 1)"), 6.0);

    bao_engine::context::JsContext::shutdown_thread_sm();
}