selfhost/runtime: Stage 0-1 runner + MIR JSON loader (summary) with trace; compiler: scopebox/loopform prepass wiring (flags, child args); libs: add P1 standard boxes (console/string/array/map) as thin wrappers; runner: pass --box-pref via env; ops_calls dispatcher skeleton; docs: selfhost executor roadmap + scopebox/loopform notes; smokes: selfhost runner + identity prepasses; CURRENT_TASK: update plan and box lib schedule

src/runner/plugins.rs

@@ -0,0 +1,75 @@
+/*!
+ * Runner plugin/registry initialization (extracted)
+ */
+
+use super::*;
+
+impl NyashRunner {
+    /// Initialize global runtime registry and load configured plugins.
+    ///
+    /// Behavior (no-op changes to defaults):
+    /// - Always initializes the unified type/box registry.
+    /// - Loads native BID plugins unless `NYASH_DISABLE_PLUGINS=1`.
+    /// - Ensures built‑ins override list includes ArrayBox/MapBox/FileBox/TOMLBox
+    ///   by merging `NYASH_PLUGIN_OVERRIDE_TYPES` with required entries.
+    /// - When `--load-ny-plugins` or `NYASH_LOAD_NY_PLUGINS=1` is set, best‑effort
+    ///   loads Nyash scripts listed under `nyash.toml`'s `ny_plugins`.
+    ///
+    /// Side effects:
+    /// - Sets `NYASH_USE_PLUGIN_BUILTINS=1` if unset, to allow interpreter side creation.
+    /// - Updates `NYASH_PLUGIN_OVERRIDE_TYPES` env var (merged values).
+    pub(crate) fn init_runtime_and_plugins(&self, groups: &crate::cli::CliGroups) {
+        // Unified registry
+        runtime::init_global_unified_registry();
+        // Plugins (guarded)
+        if std::env::var("NYASH_DISABLE_PLUGINS").ok().as_deref() != Some("1") {
+            runner_plugin_init::init_bid_plugins();
+            crate::runner::box_index::refresh_box_index();
+        }
+        // Allow interpreter to create plugin-backed boxes via unified registry
+        if std::env::var("NYASH_USE_PLUGIN_BUILTINS").ok().is_none() {
+            std::env::set_var("NYASH_USE_PLUGIN_BUILTINS", "1");
+        }
+        // Merge override types env (ensure FileBox/TOMLBox present)
+        let mut override_types: Vec<String> = 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(","));
+
+        // Optional Ny script plugins loader (best-effort)
+        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::<toml::Value>(&text) {
+                    if let Some(np) = doc.get("ny_plugins") {
+                        let mut list: Vec<String> = 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; }
+                                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),
+                                                }
+                                            }
+                                            Err(e) => println!("[ny_plugins] {}: FAIL (parse: {})", p, e),
+                                        }
+                                    }
+                                    Err(e) => println!("[ny_plugins] {}: FAIL (read: {})", p, e),
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}