/*! * Execution Runner Module - Nyash File and Mode Execution Coordinator * * This module handles all execution logic, backend selection, and mode coordination, * separated from CLI parsing and the main entry point. */ use nyash_rust::cli::CliConfig; // prune heavy unused imports here; modules import what they need locally // pruned unused runtime imports in this module #[cfg(feature = "wasm-backend")] use nyash_rust::backend::{aot::AotBackend, wasm::WasmBackend}; #[cfg(feature = "llvm-inkwell-legacy")] use nyash_rust::backend::llvm_compile_and_execute; use std::{fs, process}; mod box_index; mod build; mod cli_directives; mod demos; mod dispatch; mod json_v0_bridge; mod mir_json_emit; pub mod modes; mod pipe_io; mod pipeline; mod jit_direct; mod selfhost; mod tasks; mod trace; // v2 plugin system imports use nyash_rust::runner_plugin_init; use nyash_rust::runtime; // use std::path::PathBuf; // not used in current runner /// Resolve a using target according to priority: modules > relative > using-paths /// Returns Ok(resolved_path_or_token). On strict mode, ambiguous matches cause error. use pipeline::resolve_using_target; /// Main execution coordinator pub struct NyashRunner { config: CliConfig, } /// Minimal task runner: read nyash.toml [env] and [tasks], run the named task via shell use tasks::run_named_task; impl NyashRunner { /// Create a new runner with the given configuration pub fn new(config: CliConfig) -> Self { Self { config } } /// Run Nyash based on the configuration pub fn run(&self) { // Macro sandbox child mode: --macro-expand-child if let Some(ref macro_file) = self.config.macro_expand_child { crate::runner::modes::macro_child::run_macro_child(macro_file); return; } // Build system (MVP): nyash --build let groups = self.config.as_groups(); if let Some(cfg_path) = groups.build.path.clone() { if let Err(e) = self.run_build_mvp(&cfg_path) { eprintln!("❌ build error: {}", e); std::process::exit(1); } return; } // Using/module overrides pre-processing let mut using_ctx = self.init_using_context(); let mut pending_using: Vec<(String, Option)> = Vec::new(); // CLI --using SPEC entries (SPEC: 'ns', 'ns as Alias', '"path" as Alias') for spec in &groups.input.cli_usings { let s = spec.trim(); if s.is_empty() { continue; } let (target, alias) = if let Some(pos) = s.find(" as ") { ( s[..pos].trim().to_string(), Some(s[pos + 4..].trim().to_string()), ) } else { (s.to_string(), None) }; // Normalize quotes for path let is_path = target.starts_with('"') || target.starts_with("./") || target.starts_with('/') || target.ends_with(".nyash"); if is_path { let path = target.trim_matches('"').to_string(); let name = alias.clone().unwrap_or_else(|| { std::path::Path::new(&path) .file_stem() .and_then(|s| s.to_str()) .unwrap_or("module") .to_string() }); pending_using.push((name, Some(path))); } else { pending_using.push((target, alias)); } } for (ns, path) in using_ctx.pending_modules.iter() { let sb = crate::box_trait::StringBox::new(path.clone()); crate::runtime::modules_registry::set(ns.clone(), Box::new(sb)); } // Stage-1: Optional dependency tree bridge (log-only) if let Ok(dep_path) = std::env::var("NYASH_DEPS_JSON") { match std::fs::read_to_string(&dep_path) { Ok(s) => { let bytes = s.as_bytes().len(); // Try to extract quick hints without failing let mut root_info = String::new(); if let Ok(v) = serde_json::from_str::(&s) { if let Some(r) = v.get("root_path").and_then(|x| x.as_str()) { root_info = format!(" root='{}'", r); } } crate::cli_v!( "[deps] loaded {} bytes from{} {}", bytes, if root_info.is_empty() { "" } else { ":" }, root_info ); } Err(e) => { crate::cli_v!("[deps] read error: {}", e); } } } // Phase-15: JSON IR v0 bridge (stdin/file) if self.try_run_json_v0_pipe() { return; } // Run named task from nyash.toml (MVP) if let Some(task) = groups.run_task.clone() { if let Err(e) = run_named_task(&task) { eprintln!("❌ Task error: {}", e); process::exit(1); } return; } // Verbose CLI flag maps to env for downstream helpers/scripts if groups.debug.cli_verbose { std::env::set_var("NYASH_CLI_VERBOSE", "1"); } // GC mode forwarding: map CLI --gc to NYASH_GC_MODE for downstream runtimes if let Some(ref m) = groups.gc_mode { if !m.trim().is_empty() { std::env::set_var("NYASH_GC_MODE", m); } } // Script-level env directives (special comments) — parse early // Supported: // // @env KEY=VALUE // // @jit-debug (preset: exec, threshold=1, events+trace) // // @plugin-builtins (NYASH_USE_PLUGIN_BUILTINS=1) if let Some(ref filename) = groups.input.file { if let Ok(code) = fs::read_to_string(filename) { // Apply script-level directives and lint let strict_fields = std::env::var("NYASH_FIELDS_TOP_STRICT").ok().as_deref() == Some("1"); if let Err(e) = cli_directives::apply_cli_directives_from_source( &code, strict_fields, groups.debug.cli_verbose, ) { eprintln!("❌ Lint/Directive error: {}", e); std::process::exit(1); } // Env overrides for using rules // Merge late env overrides (if any) if let Ok(paths) = std::env::var("NYASH_USING_PATH") { for p in paths.split(':') { let p = p.trim(); if !p.is_empty() { using_ctx.using_paths.push(p.to_string()); } } } if let Ok(mods) = std::env::var("NYASH_MODULES") { for ent in mods.split(',') { if let Some((k, v)) = ent.split_once('=') { let k = k.trim(); let v = v.trim(); if !k.is_empty() && !v.is_empty() { using_ctx .pending_modules .push((k.to_string(), v.to_string())); } } } } // Apply pending modules to registry as StringBox (path or ns token) for (ns, path) in using_ctx.pending_modules.iter() { let sb = nyash_rust::box_trait::StringBox::new(path.clone()); nyash_rust::runtime::modules_registry::set(ns.clone(), Box::new(sb)); } // Resolve pending using with clear precedence and ambiguity handling let strict = std::env::var("NYASH_USING_STRICT").ok().as_deref() == Some("1"); let verbose = crate::config::env::cli_verbose(); let ctx = std::path::Path::new(filename).parent(); for (ns, alias) in pending_using.iter() { let value = match resolve_using_target( ns, false, &using_ctx.pending_modules, &using_ctx.using_paths, &using_ctx.aliases, ctx, strict, verbose, ) { Ok(v) => v, Err(e) => { eprintln!("❌ using: {}", e); std::process::exit(1); } }; let sb = nyash_rust::box_trait::StringBox::new(value.clone()); nyash_rust::runtime::modules_registry::set(ns.clone(), Box::new(sb)); if let Some(a) = alias { let sb2 = nyash_rust::box_trait::StringBox::new(value); nyash_rust::runtime::modules_registry::set(a.clone(), Box::new(sb2)); } } } } // If strict mode requested via env, ensure handle-only shim behavior is enabled if std::env::var("NYASH_JIT_STRICT").ok().as_deref() == Some("1") { if std::env::var("NYASH_JIT_ARGS_HANDLE_ONLY").ok().is_none() { std::env::set_var("NYASH_JIT_ARGS_HANDLE_ONLY", "1"); } // Enforce JIT-only by default in strict mode unless explicitly overridden if std::env::var("NYASH_JIT_ONLY").ok().is_none() { std::env::set_var("NYASH_JIT_ONLY", "1"); } } // 🏭 Phase 9.78b: Initialize unified registry runtime::init_global_unified_registry(); // Try to initialize BID plugins from nyash.toml (best-effort) // Allow disabling during snapshot/CI via NYASH_DISABLE_PLUGINS=1 if std::env::var("NYASH_DISABLE_PLUGINS").ok().as_deref() != Some("1") { runner_plugin_init::init_bid_plugins(); // Build BoxIndex after plugin host is initialized crate::runner::box_index::refresh_box_index(); } // Allow interpreter to create plugin-backed boxes via unified registry // Opt-in by default for FileBox/TOMLBox which are required by ny-config and similar tools. if std::env::var("NYASH_USE_PLUGIN_BUILTINS").ok().is_none() { std::env::set_var("NYASH_USE_PLUGIN_BUILTINS", "1"); } // Merge FileBox,TOMLBox with defaults if present let mut override_types: Vec = if let Ok(list) = std::env::var("NYASH_PLUGIN_OVERRIDE_TYPES") { list.split(',') .map(|s| s.trim().to_string()) .filter(|s| !s.is_empty()) .collect() } else { vec!["ArrayBox".into(), "MapBox".into()] }; for t in ["FileBox", "TOMLBox"] { if !override_types.iter().any(|x| x == t) { override_types.push(t.into()); } } std::env::set_var("NYASH_PLUGIN_OVERRIDE_TYPES", override_types.join(",")); // Opt-in: load Ny script plugins listed in nyash.toml [ny_plugins] if groups.load_ny_plugins || std::env::var("NYASH_LOAD_NY_PLUGINS").ok().as_deref() == Some("1") { if let Ok(text) = std::fs::read_to_string("nyash.toml") { if let Ok(doc) = toml::from_str::(&text) { if let Some(np) = doc.get("ny_plugins") { let mut list: Vec = Vec::new(); if let Some(arr) = np.as_array() { for v in arr { if let Some(s) = v.as_str() { list.push(s.to_string()); } } } else if let Some(tbl) = np.as_table() { for (_k, v) in tbl { if let Some(s) = v.as_str() { list.push(s.to_string()); } else if let Some(arr) = v.as_array() { for e in arr { if let Some(s) = e.as_str() { list.push(s.to_string()); } } } } } if !list.is_empty() { let list_only = std::env::var("NYASH_NY_PLUGINS_LIST_ONLY").ok().as_deref() == Some("1"); println!("🧩 Ny script plugins ({}):", list.len()); for p in list { if list_only { println!(" • {}", p); continue; } // Execute each script best-effort via interpreter match std::fs::read_to_string(&p) { Ok(code) => { match nyash_rust::parser::NyashParser::parse_from_string( &code, ) { Ok(ast) => { let mut interpreter = nyash_rust::interpreter::NyashInterpreter::new( ); match interpreter.execute(ast) { Ok(_) => println!("[ny_plugins] {}: OK", p), Err(e) => { println!( "[ny_plugins] {}: FAIL ({})", p, e ); // continue to next } } } Err(e) => { println!("[ny_plugins] {}: FAIL (parse: {})", p, e); } } } Err(e) => { println!("[ny_plugins] {}: FAIL (read: {})", p, e); } } } } } } } } // Optional: enable VM stats via CLI flags if groups.backend.vm_stats { std::env::set_var("NYASH_VM_STATS", "1"); } if groups.backend.vm_stats_json { // Prefer explicit JSON flag over any default std::env::set_var("NYASH_VM_STATS_JSON", "1"); } // Optional: JIT controls via CLI flags (centralized) { // CLI opt-in for JSONL events if groups.backend.jit.events { std::env::set_var("NYASH_JIT_EVENTS", "1"); } if groups.backend.jit.events_compile { std::env::set_var("NYASH_JIT_EVENTS_COMPILE", "1"); } if groups.backend.jit.events_runtime { std::env::set_var("NYASH_JIT_EVENTS_RUNTIME", "1"); } if let Some(ref p) = groups.backend.jit.events_path { std::env::set_var("NYASH_JIT_EVENTS_PATH", p); } let mut jc = nyash_rust::jit::config::JitConfig::from_env(); jc.exec |= groups.backend.jit.exec; jc.stats |= groups.backend.jit.stats; jc.stats_json |= groups.backend.jit.stats_json; jc.dump |= groups.backend.jit.dump; if groups.backend.jit.threshold.is_some() { jc.threshold = groups.backend.jit.threshold; } jc.phi_min |= groups.backend.jit.phi_min; jc.hostcall |= groups.backend.jit.hostcall; jc.handle_debug |= groups.backend.jit.handle_debug; jc.native_f64 |= groups.backend.jit.native_f64; jc.native_bool |= groups.backend.jit.native_bool; // If observability is enabled and no threshold is provided, force threshold=1 so lowering runs and emits events let events_on = std::env::var("NYASH_JIT_EVENTS").ok().as_deref() == Some("1") || std::env::var("NYASH_JIT_EVENTS_COMPILE").ok().as_deref() == Some("1") || std::env::var("NYASH_JIT_EVENTS_RUNTIME").ok().as_deref() == Some("1"); if events_on && jc.threshold.is_none() { jc.threshold = Some(1); } if groups.backend.jit.only { std::env::set_var("NYASH_JIT_ONLY", "1"); } // Apply runtime capability probe (e.g., disable b1 ABI if unsupported) let caps = nyash_rust::jit::config::probe_capabilities(); jc = nyash_rust::jit::config::apply_runtime_caps(jc, caps); // Optional DOT emit via CLI (ensures dump is on when path specified) if let Some(path) = &groups.emit.emit_cfg { std::env::set_var("NYASH_JIT_DOT", path); jc.dump = true; } // Persist to env (CLI parity) and set as current jc.apply_env(); nyash_rust::jit::config::set_current(jc.clone()); } // Architectural pivot: JIT is compiler-only (EXE/AOT). Ensure VM runtime does not dispatch to JIT // unless explicitly requested via independent JIT mode, or when emitting AOT objects. if !groups.compile_native && !groups.backend.jit.direct { // When AOT object emission is requested, allow JIT to run for object generation let aot_obj = std::env::var("NYASH_AOT_OBJECT_OUT").ok(); if aot_obj.is_none() || aot_obj.as_deref() == Some("") { // Force-disable runtime JIT execution path for VM/Interpreter flows std::env::set_var("NYASH_JIT_EXEC", "0"); } } // Benchmark mode - can run without a file if groups.benchmark { println!("📊 Nyash Performance Benchmark Suite"); println!("===================================="); println!("Running {} iterations per test...", groups.iterations); println!(); #[cfg(feature = "vm-legacy")] { self.execute_benchmark_mode(); return; } #[cfg(not(feature = "vm-legacy"))] { eprintln!( "❌ Benchmark mode requires VM backend. Rebuild with --features vm-legacy." ); std::process::exit(1); } } if let Some(ref filename) = groups.input.file { // Independent JIT direct mode (no VM execute path) if groups.backend.jit.direct { self.run_file_jit_direct(filename); return; } // Delegate file-mode execution to modes::common dispatcher self.run_file(filename); } else { demos::run_all_demos(); } } // init_bid_plugins moved to runner_plugin_init.rs /// Execute file-based mode with backend selection pub(crate) fn run_file(&self, filename: &str) { dispatch::execute_file_with_backend(self, filename); } /// Minimal AOT build pipeline driven by nyash.toml (mvp) fn run_build_mvp(&self, cfg_path: &str) -> Result<(), String> { build::run_build_mvp_impl(self, cfg_path) } } impl NyashRunner { /// Run a file through independent JIT engine (no VM execute loop) fn run_file_jit_direct(&self, filename: &str) { use nyash_rust::{mir::MirCompiler, parser::NyashParser}; use std::fs; // Small helper for unified error output (text or JSON) let emit_err = |phase: &str, code: &str, msg: &str| { if std::env::var("NYASH_JIT_STATS_JSON").ok().as_deref() == Some("1") || std::env::var("NYASH_JIT_ERROR_JSON").ok().as_deref() == Some("1") { let payload = serde_json::json!({ "kind": "jit_direct_error", "phase": phase, "code": code, "message": msg, "file": filename, }); println!("{}", payload.to_string()); } else { eprintln!("[JIT-direct][{}][{}] {}", phase, code, msg); } }; // Require cranelift feature at runtime by attempting compile; if unavailable compile_function returns None let code = match fs::read_to_string(filename) { Ok(s) => s, Err(e) => { emit_err("read_file", "IO", &format!("{}", e)); std::process::exit(1); } }; let ast = match NyashParser::parse_from_string(&code) { Ok(a) => a, Err(e) => { emit_err("parse", "SYNTAX", &format!("{}", e)); std::process::exit(1); } }; let mut mc = MirCompiler::new(); let cr = match mc.compile(ast) { Ok(m) => m, Err(e) => { emit_err("mir", "MIR_COMPILE", &format!("{}", e)); std::process::exit(1); } }; let func = match cr.module.functions.get("main") { Some(f) => f, None => { emit_err("mir", "NO_MAIN", "No main function found"); std::process::exit(1); } }; // Guard: refuse write-effects in jit-direct when policy.read_only { use nyash_rust::mir::effect::Effect; let policy = nyash_rust::jit::policy::current(); let mut writes = 0usize; for (_bbid, bb) in func.blocks.iter() { for inst in bb.instructions.iter() { let mask = inst.effects(); if mask.contains(Effect::WriteHeap) { writes += 1; } } if let Some(term) = &bb.terminator { if term.effects().contains(Effect::WriteHeap) { writes += 1; } } } if policy.read_only && writes > 0 { emit_err( "policy", "WRITE_EFFECTS", &format!( "write-effects detected ({} ops). jit-direct is read-only at this stage.", writes ), ); std::process::exit(1); } } // jit-direct 安定化: 分岐合流(PHI)は明示ブロック引数で配線 { let mut cfg = nyash_rust::jit::config::current(); cfg.phi_min = true; // enable multi-PHI arg passing/join nyash_rust::jit::config::set_current(cfg); } // Prepare minimal runtime hooks so JIT externs (checkpoint/await) can reach GC/scheduler { let rt = nyash_rust::runtime::NyashRuntime::new(); nyash_rust::runtime::global_hooks::set_from_runtime(&rt); } let mut engine = nyash_rust::jit::engine::JitEngine::new(); match engine.compile_function("main", func) { Some(h) => { // Optional event: compile nyash_rust::jit::events::emit( "compile", &func.signature.name, Some(h), None, serde_json::json!({}), ); // Parse JIT args from env: NYASH_JIT_ARGS (comma-separated), with optional type prefixes // Formats per arg: i:123, f:3.14, b:true/false, h:42 (handle), or bare numbers (int), true/false (bool) let mut jit_args: Vec = Vec::new(); if let Ok(s) = std::env::var("NYASH_JIT_ARGS") { for raw in s.split(',') { let t = raw.trim(); if t.is_empty() { continue; } let v = if let Some(rest) = t.strip_prefix("i:") { rest.parse::() .ok() .map(nyash_rust::jit::abi::JitValue::I64) } else if let Some(rest) = t.strip_prefix("f:") { rest.parse::() .ok() .map(nyash_rust::jit::abi::JitValue::F64) } else if let Some(rest) = t.strip_prefix("b:") { let b = matches!(rest, "1" | "true" | "True" | "TRUE"); Some(nyash_rust::jit::abi::JitValue::Bool(b)) } else if let Some(rest) = t.strip_prefix("h:") { rest.parse::() .ok() .map(nyash_rust::jit::abi::JitValue::Handle) } else if t.eq_ignore_ascii_case("true") || t == "1" { Some(nyash_rust::jit::abi::JitValue::Bool(true)) } else if t.eq_ignore_ascii_case("false") || t == "0" { Some(nyash_rust::jit::abi::JitValue::Bool(false)) } else if let Ok(iv) = t.parse::() { Some(nyash_rust::jit::abi::JitValue::I64(iv)) } else if let Ok(fv) = t.parse::() { Some(nyash_rust::jit::abi::JitValue::F64(fv)) } else { None }; if let Some(jv) = v { jit_args.push(jv); } } } // Coerce args to expected MIR types use nyash_rust::mir::MirType; let expected = &func.signature.params; if expected.len() != jit_args.len() { emit_err( "args", "COUNT_MISMATCH", &format!("expected={}, passed={}", expected.len(), jit_args.len()), ); eprintln!("Hint: set NYASH_JIT_ARGS as comma-separated values, e.g., i:42,f:3.14,b:true"); std::process::exit(1); } let mut coerced: Vec = Vec::with_capacity(jit_args.len()); for (i, (exp, got)) in expected.iter().zip(jit_args.iter()).enumerate() { let cv = match exp { MirType::Integer => match got { nyash_rust::jit::abi::JitValue::I64(v) => { nyash_rust::jit::abi::JitValue::I64(*v) } nyash_rust::jit::abi::JitValue::F64(f) => { nyash_rust::jit::abi::JitValue::I64(*f as i64) } nyash_rust::jit::abi::JitValue::Bool(b) => { nyash_rust::jit::abi::JitValue::I64(if *b { 1 } else { 0 }) } _ => { emit_err( "args", "TYPE_MISMATCH", &format!("param#{} expects Integer", i), ); std::process::exit(1); } }, MirType::Float => match got { nyash_rust::jit::abi::JitValue::F64(f) => { nyash_rust::jit::abi::JitValue::F64(*f) } nyash_rust::jit::abi::JitValue::I64(v) => { nyash_rust::jit::abi::JitValue::F64(*v as f64) } nyash_rust::jit::abi::JitValue::Bool(b) => { nyash_rust::jit::abi::JitValue::F64(if *b { 1.0 } else { 0.0 }) } _ => { emit_err( "args", "TYPE_MISMATCH", &format!("param#{} expects Float", i), ); std::process::exit(1); } }, MirType::Bool => match got { nyash_rust::jit::abi::JitValue::Bool(b) => { nyash_rust::jit::abi::JitValue::Bool(*b) } nyash_rust::jit::abi::JitValue::I64(v) => { nyash_rust::jit::abi::JitValue::Bool(*v != 0) } nyash_rust::jit::abi::JitValue::F64(f) => { nyash_rust::jit::abi::JitValue::Bool(*f != 0.0) } _ => { emit_err( "args", "TYPE_MISMATCH", &format!("param#{} expects Bool", i), ); std::process::exit(1); } }, MirType::String | MirType::Box(_) | MirType::Array(_) | MirType::Future(_) => match got { nyash_rust::jit::abi::JitValue::Handle(h) => { nyash_rust::jit::abi::JitValue::Handle(*h) } _ => { emit_err( "args", "TYPE_MISMATCH", &format!("param#{} expects handle (h:)", i), ); std::process::exit(1); } }, MirType::Void | MirType::Unknown => { // Keep as-is *got } }; coerced.push(cv); } nyash_rust::jit::rt::set_current_jit_args(&coerced); let t0 = std::time::Instant::now(); let out = engine.execute_handle(h, &coerced); match out { Some(v) => { let ms = t0.elapsed().as_millis(); nyash_rust::jit::events::emit( "execute", &func.signature.name, Some(h), Some(ms), serde_json::json!({}), ); // Normalize result according to MIR return type for friendly output use nyash_rust::mir::MirType; let ret_ty = &func.signature.return_type; let vmv = match (ret_ty, v) { (MirType::Bool, nyash_rust::jit::abi::JitValue::I64(i)) => { nyash_rust::backend::vm::VMValue::Bool(i != 0) } (MirType::Bool, nyash_rust::jit::abi::JitValue::Bool(b)) => { nyash_rust::backend::vm::VMValue::Bool(b) } (MirType::Float, nyash_rust::jit::abi::JitValue::F64(f)) => { nyash_rust::backend::vm::VMValue::Float(f) } (MirType::Float, nyash_rust::jit::abi::JitValue::I64(i)) => { nyash_rust::backend::vm::VMValue::Float(i as f64) } // Default adapter for other combos _ => nyash_rust::jit::abi::adapter::from_jit_value(v), }; println!("✅ JIT-direct execution completed successfully!"); // Pretty print with expected type tag let (ety, sval) = match (ret_ty, &vmv) { (MirType::Bool, nyash_rust::backend::vm::VMValue::Bool(b)) => { ("Bool", b.to_string()) } (MirType::Float, nyash_rust::backend::vm::VMValue::Float(f)) => { ("Float", format!("{}", f)) } (MirType::Integer, nyash_rust::backend::vm::VMValue::Integer(i)) => { ("Integer", i.to_string()) } // Fallbacks (_, nyash_rust::backend::vm::VMValue::Integer(i)) => { ("Integer", i.to_string()) } (_, nyash_rust::backend::vm::VMValue::Float(f)) => { ("Float", format!("{}", f)) } (_, nyash_rust::backend::vm::VMValue::Bool(b)) => { ("Bool", b.to_string()) } (_, nyash_rust::backend::vm::VMValue::String(s)) => { ("String", s.clone()) } (_, nyash_rust::backend::vm::VMValue::BoxRef(arc)) => { ("BoxRef", arc.type_name().to_string()) } (_, nyash_rust::backend::vm::VMValue::Future(_)) => { ("Future", "".to_string()) } (_, nyash_rust::backend::vm::VMValue::Void) => { ("Void", "void".to_string()) } }; println!("ResultType(MIR): {}", ety); println!("Result: {}", sval); // Optional JSON stats if std::env::var("NYASH_JIT_STATS_JSON").ok().as_deref() == Some("1") { let cfg = nyash_rust::jit::config::current(); let caps = nyash_rust::jit::config::probe_capabilities(); let (phi_t, phi_b1, ret_b) = engine.last_lower_stats(); let abi_mode = if cfg.native_bool_abi && caps.supports_b1_sig { "b1_bool" } else { "i64_bool" }; let payload = serde_json::json!({ "version": 1, "function": func.signature.name, "abi_mode": abi_mode, "abi_b1_enabled": cfg.native_bool_abi, "abi_b1_supported": caps.supports_b1_sig, "b1_norm_count": nyash_rust::jit::rt::b1_norm_get(), "ret_bool_hint_count": nyash_rust::jit::rt::ret_bool_hint_get(), "phi_total_slots": phi_t, "phi_b1_slots": phi_b1, "ret_bool_hint_used": ret_b, }); println!("{}", payload.to_string()); } } None => { nyash_rust::jit::events::emit( "fallback", &func.signature.name, Some(h), None, serde_json::json!({"reason":"trap_or_missing"}), ); emit_err( "execute", "TRAP_OR_MISSING", "execution failed (trap or missing handle)", ); std::process::exit(1); } } } None => { emit_err( "compile", "UNAVAILABLE", "Build with --features cranelift-jit", ); std::process::exit(1); } } } } // Demo functions (moved from main.rs) // moved to demos.rs // moved to demos.rs // moved to demos.rs // moved to demos.rs // moved to demos.rs // moved to demos.rs