Add runnable rules config reload hooks

Author: olwang

README.md

@@ -412,13 +412,13 @@ rss verify-rust [--json] <file.rss> --out-dir <directory>
 
 `rss check` loads bundled core `.rssi` signatures by default. Use `--no-core` only when testing a file against user-supplied interfaces in isolation.
 
-The checker prototype also keeps a small `core/prototype` interface bundle for real-scenario fixtures that have not yet moved into `core/`. Those signatures are still `.rssi` sources, not a second Rust-side builtin table.
+The checker prototype also keeps a small `core/prototype` interface bundle for the remaining cache fixtures that have not yet moved into `core/`. Those signatures are still `.rssi` sources, not a second Rust-side builtin table.
 
 If a lowered package contains `fn main() -> Unit` or `fn main() -> Result<Unit, E>`, `rss lower --rust --out-dir` also emits a Rust `src/main.rs` harness. `rss run <file.rss>` uses the same lowering path, writes a temporary Rust package, and delegates execution to `cargo run`. Use `rss run <file.rss> --out-dir <directory>` to keep the generated Rust package for inspection.
 
 `rss verify-rust <file.rss> --out-dir <directory>` keeps the generated package used for backend checking, including `rsscript-source-map.json`, so unmappable rustc diagnostics can be inspected against the generated Rust.
 
-The first observable runtime boundaries are `Log.write(message: read String)`, `Assert.equal(left: read String, right: read String)`, `OS.close(fd: Fd)`, `List.consume(list: take List<T>)`, `Buffer.consume(buffer: take Buffer)`, and the core `File`, `Json`, `Csv`, `Image`, `ImageCache`, HTTP handler, DB resource-pool, config reload, interpreter object-cycle, and `Counter` APIs, which lower to explicit runtime hooks. `ImageCache` is the first small retained managed-container hook: it stores managed image handles and enforces a capacity limit. The interpreter hooks model `Environment` and `FunctionObject` as managed handles, including an environment/function closure cycle. Simple core operations such as `String.concat(left: read String, right: read String)` keep RSScript `.rssi` signatures for checking and review, but lower directly to Rust standard-library expressions. Built-in boolean literals, numeric operators, comparison operators, `Option<T>` constructors, and core surface types such as `Bytes`, `Buffer`, `Path`, `List<T>`, `Map<K,V>`, and `Set<T>` lower to the corresponding Rust literals, operators, enum constructors, and standard-library types; user-defined operator overloading remains forbidden.
+The first observable runtime boundaries are `Log.write(message: read String)`, `Assert.equal(left: read String, right: read String)`, `OS.close(fd: Fd)`, `List.consume(list: take List<T>)`, `Buffer.consume(buffer: take Buffer)`, and the core `File`, `Json`, `Csv`, `Image`, `ImageCache`, HTTP handler, DB resource-pool, config reload, rules config reload, interpreter object-cycle, and `Counter` APIs, which lower to explicit runtime hooks. `ImageCache` is the first small retained managed-container hook: it stores managed image handles and enforces a capacity limit. The interpreter hooks model `Environment` and `FunctionObject` as managed handles, including an environment/function closure cycle. Simple core operations such as `String.concat(left: read String, right: read String)` keep RSScript `.rssi` signatures for checking and review, but lower directly to Rust standard-library expressions. Built-in boolean literals, numeric operators, comparison operators, `Option<T>` constructors, and core surface types such as `Bytes`, `Buffer`, `Path`, `List<T>`, `Map<K,V>`, and `Set<T>` lower to the corresponding Rust literals, operators, enum constructors, and standard-library types; user-defined operator overloading remains forbidden.
 
 Smallest runnable example:
 

core/config/rules.rssi

@@ -0,0 +1,22 @@
+struct Rule
+
+struct Config
+
+struct GlobalConfig
+
+pub fn RuleLoader.load_rules(path: read Path) -> Result<fresh List<Rule>, ConfigError>
+
+pub fn Config.new(name: read String, rules: read List<Rule>) -> fresh Config
+
+pub fn Config.rule_count(config: read Config) -> Int
+
+pub fn GlobalConfig.new(value: read Config) -> fresh GlobalConfig
+    effects(retains(value))
+
+pub fn GlobalConfig.replace(
+    global: mut GlobalConfig,
+    value: read Config,
+) -> Unit
+    effects(retains(value))
+
+pub fn GlobalConfig.rule_count(global: read GlobalConfig) -> Int

core/prototype/builtins.rssi

@@ -1,11 +1,3 @@
-pub fn RuleLoader.load_rules(path: read Path) -> Result<fresh List<Rule>, ConfigError>
-
-pub fn GlobalConfig.replace(
-    global: mut GlobalConfig,
-    value: read Config,
-) -> Unit
-    effects(retains(value))
-
 pub fn Cache.lookup(cache: read Cache, key: read String)
 
 pub fn Cache.get(cache: read Cache)

examples/rules_config_reload.rss

@@ -0,0 +1,33 @@
+fn load_rules_config(path: read String) -> Result<fresh Config, ConfigError> {
+    let rules = RuleLoader.load_rules(path: read path)?
+    return Ok(Config.new(name: read "rules", rules: read rules))
+}
+
+fn reload_rules_config(path: read String, global: mut GlobalConfig) -> Result<Unit, ConfigError> {
+    let next = load_rules_config(path: read path)?
+    GlobalConfig.replace(global: mut global, value: read next)
+    return Ok(Unit)
+}
+
+fn main() -> Result<Unit, ConfigError> {
+    let first = "rsscript-rules-first.txt"
+    let second = "rsscript-rules-second.txt"
+
+    with File.open_write(path: read first) as file {
+        File.write(file: mut file, data: read "alpha\nbeta\n")?
+    }
+    with File.open_write(path: read second) as file {
+        File.write(file: mut file, data: read "gamma\n")?
+    }
+
+    let initial = load_rules_config(path: read first)?
+    let global = GlobalConfig.new(value: read initial)
+    reload_rules_config(path: read second, global: mut global)?
+
+    let count = GlobalConfig.rule_count(global: read global)
+    if count == 1 {
+        Log.write(message: read "rules config reloaded")
+    }
+
+    return Ok(Unit)
+}

runtime/src/lib.rs

@@ -40,6 +40,22 @@ pub struct ConfigStore {
     current: ConfigValue,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Rule {
+    name: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Config {
+    name: String,
+    rules: Vec<Rule>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct GlobalConfig {
+    current: Config,
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Counter {
     value: i64,
@@ -421,6 +437,44 @@ pub fn config_store_name(store: &ConfigStore) -> String {
     store.current.name.clone()
 }
 
+pub fn rule_loader_load_rules<P: RuntimePath + ?Sized>(path: &P) -> Result<Vec<Rule>, ConfigError> {
+    let text = std::fs::read_to_string(path.as_path())?;
+    let rules = text
+        .lines()
+        .map(str::trim)
+        .filter(|line| !line.is_empty())
+        .map(|name| Rule {
+            name: name.to_string(),
+        })
+        .collect();
+    Ok(rules)
+}
+
+pub fn config_new(name: &str, rules: &[Rule]) -> Config {
+    Config {
+        name: name.to_string(),
+        rules: rules.to_owned(),
+    }
+}
+
+pub fn config_rule_count(config: &Config) -> i64 {
+    config.rules.len() as i64
+}
+
+pub fn global_config_new(value: &Config) -> GlobalConfig {
+    GlobalConfig {
+        current: value.clone(),
+    }
+}
+
+pub fn global_config_replace(global: &mut GlobalConfig, value: &Config) {
+    global.current = value.clone();
+}
+
+pub fn global_config_rule_count(global: &GlobalConfig) -> i64 {
+    global.current.rules.len() as i64
+}
+
 pub fn counter_new(value: i64) -> Counter {
     Counter { value }
 }
@@ -1175,4 +1229,31 @@ mod tests {
         let _ = std::fs::remove_file(first);
         let _ = std::fs::remove_file(second);
     }
+
+    #[test]
+    fn rules_config_runtime_hooks_load_and_replace_global() {
+        let first = std::env::temp_dir().join(format!(
+            "rsscript-runtime-rules-first-{}.txt",
+            std::process::id()
+        ));
+        let second = std::env::temp_dir().join(format!(
+            "rsscript-runtime-rules-second-{}.txt",
+            std::process::id()
+        ));
+        std::fs::write(&first, "alpha\nbeta\n").expect("first rules should write");
+        std::fs::write(&second, "gamma\n").expect("second rules should write");
+
+        let first_rules = super::rule_loader_load_rules(&first).expect("first rules should load");
+        let initial = super::config_new("initial", &first_rules);
+        let mut global = super::global_config_new(&initial);
+        let second_rules =
+            super::rule_loader_load_rules(&second).expect("second rules should load");
+        let next = super::config_new("next", &second_rules);
+        super::global_config_replace(&mut global, &next);
+
+        assert_eq!(super::global_config_rule_count(&global), 1);
+
+        let _ = std::fs::remove_file(first);
+        let _ = std::fs::remove_file(second);
+    }
 }

src/hir.rs

@@ -1336,28 +1336,35 @@ fn split_top_level_type_args(args: &str) -> Vec<&str> {
 fn classify_return_expr(hir: &Hir, expr: &Expr) -> HirReturnProof {
     match expr {
         Expr::Ident(name, _) => HirReturnProof::Ident { name: name.clone() },
-        Expr::Call { callee, .. } => match hir.resolve_call(callee) {
-            CallResolution::Resolved {
-                signature,
-                kind:
-                    ResolvedCalleeKind::Constructor {
-                        type_kind: HirTypeKind::Struct,
-                    },
-            } if signature.returns_fresh => HirReturnProof::StructConstructor,
-            CallResolution::Resolved { signature, .. } if signature.returns_fresh => {
-                HirReturnProof::FreshCall
+        Expr::Call { callee, args, .. } => {
+            if matches!(callee_name(callee), "Ok" | "Some")
+                && let Some(arg) = args.first()
+            {
+                return classify_return_expr(hir, &arg.value);
             }
-            CallResolution::Resolved {
-                kind:
-                    ResolvedCalleeKind::Constructor {
-                        type_kind: HirTypeKind::Struct,
-                    },
-                ..
-            } => HirReturnProof::StructConstructor,
-            CallResolution::Resolved { .. }
-            | CallResolution::EnumVariant
-            | CallResolution::Unknown => HirReturnProof::Unknown,
-        },
+            match hir.resolve_call(callee) {
+                CallResolution::Resolved {
+                    signature,
+                    kind:
+                        ResolvedCalleeKind::Constructor {
+                            type_kind: HirTypeKind::Struct,
+                        },
+                } if signature.returns_fresh => HirReturnProof::StructConstructor,
+                CallResolution::Resolved { signature, .. } if signature.returns_fresh => {
+                    HirReturnProof::FreshCall
+                }
+                CallResolution::Resolved {
+                    kind:
+                        ResolvedCalleeKind::Constructor {
+                            type_kind: HirTypeKind::Struct,
+                        },
+                    ..
+                } => HirReturnProof::StructConstructor,
+                CallResolution::Resolved { .. }
+                | CallResolution::EnumVariant
+                | CallResolution::Unknown => HirReturnProof::Unknown,
+            }
+        }
         Expr::Effect { value, .. } | Expr::Manage { value, .. } | Expr::Try { value, .. } => {
             classify_return_expr(hir, value)
         }

src/interfaces.rs

@@ -19,6 +19,10 @@ pub(crate) const CORE_INTERFACES: &[(&str, &str)] = &[
         "core/config/config.rssi",
         include_str!("../core/config/config.rssi"),
     ),
+    (
+        "core/config/rules.rssi",
+        include_str!("../core/config/rules.rssi"),
+    ),
     (
         "core/counter/counter.rssi",
         include_str!("../core/counter/counter.rssi"),

src/rust_lower.rs

@@ -811,6 +811,13 @@ impl<'a> RustLowerer<'a> {
             "Fd" => "i64".to_string(),
             "Bytes" | "Buffer" => "Vec<u8>".to_string(),
             "Path" => "std::path::PathBuf".to_string(),
+            "Rule" if !self.type_kinds.contains_key("Rule") => "rsscript_runtime::Rule".to_string(),
+            "Config" if !self.type_kinds.contains_key("Config") => {
+                "rsscript_runtime::Config".to_string()
+            }
+            "GlobalConfig" if !self.type_kinds.contains_key("GlobalConfig") => {
+                "rsscript_runtime::GlobalConfig".to_string()
+            }
             "Environment" => "rsscript_runtime::Environment".to_string(),
             "FunctionObject" => "rsscript_runtime::FunctionObject".to_string(),
             "Counter" => "rsscript_runtime::Counter".to_string(),
@@ -1217,6 +1224,22 @@ fn lower_callee(callee: &Callee) -> String {
         callee if is_config_store_name_callee(callee) => {
             "rsscript_runtime::config_store_name".to_string()
         }
+        callee if is_rule_loader_load_rules_callee(callee) => {
+            "rsscript_runtime::rule_loader_load_rules".to_string()
+        }
+        callee if is_rules_config_new_callee(callee) => "rsscript_runtime::config_new".to_string(),
+        callee if is_rules_config_rule_count_callee(callee) => {
+            "rsscript_runtime::config_rule_count".to_string()
+        }
+        callee if is_global_config_new_callee(callee) => {
+            "rsscript_runtime::global_config_new".to_string()
+        }
+        callee if is_global_config_replace_callee(callee) => {
+            "rsscript_runtime::global_config_replace".to_string()
+        }
+        callee if is_global_config_rule_count_callee(callee) => {
+            "rsscript_runtime::global_config_rule_count".to_string()
+        }
         callee if is_counter_new_callee(callee) => "rsscript_runtime::counter_new".to_string(),
         callee if is_counter_add_callee(callee) => "rsscript_runtime::counter_add".to_string(),
         callee if is_counter_value_callee(callee) => "rsscript_runtime::counter_value".to_string(),
@@ -1372,6 +1395,30 @@ fn is_config_store_name_callee(callee: &Callee) -> bool {
     matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "ConfigStore" && name == "name")
 }
 
+fn is_rule_loader_load_rules_callee(callee: &Callee) -> bool {
+    matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "RuleLoader" && name == "load_rules")
+}
+
+fn is_rules_config_new_callee(callee: &Callee) -> bool {
+    matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "Config" && name == "new")
+}
+
+fn is_rules_config_rule_count_callee(callee: &Callee) -> bool {
+    matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "Config" && name == "rule_count")
+}
+
+fn is_global_config_new_callee(callee: &Callee) -> bool {
+    matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "GlobalConfig" && name == "new")
+}
+
+fn is_global_config_replace_callee(callee: &Callee) -> bool {
+    matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "GlobalConfig" && name == "replace")
+}
+
+fn is_global_config_rule_count_callee(callee: &Callee) -> bool {
+    matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "GlobalConfig" && name == "rule_count")
+}
+
 fn is_counter_new_callee(callee: &Callee) -> bool {
     matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "Counter" && name == "new")
 }

tests/checker.rs

@@ -112,6 +112,11 @@ fn bundled_core_interfaces_are_available_to_checker() {
             .iter()
             .any(|(path, _)| *path == "core/counter/counter.rssi")
     );
+    assert!(
+        core_interfaces()
+            .iter()
+            .any(|(path, _)| *path == "core/config/rules.rssi")
+    );
     assert!(
         core_interfaces()
             .iter()
@@ -565,6 +570,31 @@ fn reload_config(path: read String, store: mut ConfigStore) -> Result<Unit, Conf
     assert!(rust.contains("rsscript_runtime::config_store_replace(store, &next);"));
 }
 
+#[test]
+fn rust_lowering_maps_rules_config_reload_to_runtime_hooks() {
+    let source = r#"
+fn load_rules_config(path: read String) -> Result<fresh Config, ConfigError> {
+    let rules = RuleLoader.load_rules(path: read path)?
+    return Ok(Config.new(name: read "rules", rules: read rules))
+}
+
+fn reload_rules_config(path: read String, global: mut GlobalConfig) -> Result<Unit, ConfigError> {
+    let next = load_rules_config(path: read path)?
+    GlobalConfig.replace(global: mut global, value: read next)
+    return Ok(Unit)
+}
+"#;
+    let rust = lower_source_to_rust("rules-config.rss", source).expect("source should lower");
+
+    assert!(rust.contains("-> Result<rsscript_runtime::Config, rsscript_runtime::ConfigError>"));
+    assert!(rust.contains("let rules = rsscript_runtime::rule_loader_load_rules(&path)?;"));
+    assert!(
+        rust.contains("return Ok(rsscript_runtime::config_new(&\"rules\".to_string(), &rules));")
+    );
+    assert!(rust.contains("global: &mut rsscript_runtime::GlobalConfig"));
+    assert!(rust.contains("rsscript_runtime::global_config_replace(global, &next);"));
+}
+
 #[test]
 fn rust_lowering_maps_counter_core_calls_to_runtime_hooks() {
     let source = r#"