Move Cache hooks into core runtime

Author: olwang

README.md

@@ -410,15 +410,13 @@ rss verify-rust [--json] <file.rss>
 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 the remaining cache fixtures that have not yet moved into `core/`. Those signatures are still `.rssi` sources, not a second Rust-side builtin table.
+`rss check` loads bundled core `.rssi` signatures by default. Use `--no-core` only when testing a file against user-supplied interfaces in isolation. Bundled signatures are ordinary `.rssi` files under `core/`, 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, 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.
+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`, `Cache`, `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/cache/cache.rssi

@@ -0,0 +1,12 @@
+pub fn Cache.new() -> fresh Cache
+
+pub fn Cache.insert(
+    cache: mut Cache,
+    key: read String,
+    value: read String,
+) -> Unit
+    effects(retains(value))
+
+pub fn Cache.lookup(cache: read Cache, key: read String) -> String
+
+pub fn Cache.get(cache: read Cache) -> Image

core/prototype/builtins.rssi

@@ -0,0 +1,13 @@
+fn main() -> Unit {
+    let cache = Cache.new()
+    Cache.insert(
+        cache: mut cache,
+        key: read "/users",
+        value: read "handled /users",
+    )
+
+    let body = Cache.lookup(cache: read cache, key: read "/users")
+    Assert.equal(left: read body, right: read "handled /users")
+    Log.write(message: read body)
+    return Unit
+}

examples/cache_lookup.rss

@@ -1,5 +1,5 @@
 use std::cell::{BorrowError, BorrowMutError, Ref, RefCell, RefMut};
-use std::collections::VecDeque;
+use std::collections::{HashMap, VecDeque};
 use std::fmt;
 use std::io::{Read, Write};
 use std::ops::{Deref, DerefMut};
@@ -40,6 +40,11 @@ pub struct ConfigStore {
     current: ConfigValue,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Cache {
+    entries: HashMap<String, String>,
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Rule {
     name: String,
@@ -383,6 +388,35 @@ pub fn buffer_consume(buffer: Vec<u8>) {
     drop(buffer);
 }
 
+pub fn cache_new() -> Cache {
+    Cache {
+        entries: HashMap::new(),
+    }
+}
+
+pub fn cache_insert(cache: &mut Cache, key: &str, value: &str) {
+    cache.entries.insert(key.to_string(), value.to_string());
+}
+
+pub fn cache_lookup(cache: &Cache, key: &str) -> String {
+    cache.entries.get(key).cloned().unwrap_or_default()
+}
+
+pub fn cache_get(cache: &Cache) -> Image {
+    let bytes = cache
+        .entries
+        .values()
+        .next()
+        .map(|value| value.as_bytes().to_vec())
+        .unwrap_or_default();
+    Image {
+        bytes,
+        width: None,
+        height: None,
+        operations: vec!["cache-get"],
+    }
+}
+
 pub fn request_new(path: &str) -> Request {
     Request {
         path: path.to_string(),
@@ -1122,6 +1156,16 @@ mod tests {
         super::os_close(0);
     }
 
+    #[test]
+    fn cache_runtime_hooks_insert_and_lookup_values() {
+        let mut cache = super::cache_new();
+
+        super::cache_insert(&mut cache, "/users", "handled /users");
+
+        assert_eq!(super::cache_lookup(&cache, "/users"), "handled /users");
+        assert_eq!(super::cache_get(&cache).bytes, b"handled /users");
+    }
+
     #[test]
     fn interpreter_runtime_hooks_link_environment_function_cycle() {
         let root = super::manage(super::environment_root());

runtime/src/lib.rs

@@ -1,4 +1,8 @@
 pub(crate) const CORE_INTERFACES: &[(&str, &str)] = &[
+    (
+        "core/cache/cache.rssi",
+        include_str!("../core/cache/cache.rssi"),
+    ),
     (
         "core/cache/image_cache.rssi",
         include_str!("../core/cache/image_cache.rssi"),
@@ -62,14 +66,6 @@ pub(crate) const CORE_INTERFACES: &[(&str, &str)] = &[
     ),
 ];
 
-pub(crate) const PROTOTYPE_INTERFACES: &[(&str, &str)] = &[(
-    "core/prototype/builtins.rssi",
-    include_str!("../core/prototype/builtins.rssi"),
-)];
-
 pub(crate) fn builtin_interfaces() -> impl Iterator<Item = (&'static str, &'static str)> {
-    CORE_INTERFACES
-        .iter()
-        .chain(PROTOTYPE_INTERFACES.iter())
-        .copied()
+    CORE_INTERFACES.iter().copied()
 }

src/interfaces.rs

@@ -811,6 +811,9 @@ impl<'a> RustLowerer<'a> {
             "Fd" => "i64".to_string(),
             "Bytes" | "Buffer" => "Vec<u8>".to_string(),
             "Path" => "std::path::PathBuf".to_string(),
+            "Cache" if !self.type_kinds.contains_key("Cache") => {
+                "rsscript_runtime::Cache".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()
@@ -1197,6 +1200,10 @@ fn lower_callee(callee: &Callee) -> String {
         callee if is_buffer_consume_callee(callee) => {
             "rsscript_runtime::buffer_consume".to_string()
         }
+        callee if is_cache_new_callee(callee) => "rsscript_runtime::cache_new".to_string(),
+        callee if is_cache_insert_callee(callee) => "rsscript_runtime::cache_insert".to_string(),
+        callee if is_cache_lookup_callee(callee) => "rsscript_runtime::cache_lookup".to_string(),
+        callee if is_cache_get_callee(callee) => "rsscript_runtime::cache_get".to_string(),
         callee if is_file_open_callee(callee) => "rsscript_runtime::file_open".to_string(),
         callee if is_file_open_read_callee(callee) => {
             "rsscript_runtime::file_open_read".to_string()
@@ -1331,6 +1338,22 @@ fn is_buffer_consume_callee(callee: &Callee) -> bool {
     matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "Buffer" && name == "consume")
 }
 
+fn is_cache_new_callee(callee: &Callee) -> bool {
+    matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "Cache" && name == "new")
+}
+
+fn is_cache_insert_callee(callee: &Callee) -> bool {
+    matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "Cache" && name == "insert")
+}
+
+fn is_cache_lookup_callee(callee: &Callee) -> bool {
+    matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "Cache" && name == "lookup")
+}
+
+fn is_cache_get_callee(callee: &Callee) -> bool {
+    matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "Cache" && name == "get")
+}
+
 fn is_string_concat_callee(callee: &Callee) -> bool {
     matches!(callee, Callee::Qualified { namespace, name } if type_root_name(namespace) == "String" && name == "concat")
 }

src/rust_lower.rs

@@ -87,6 +87,11 @@ fn bundled_core_interfaces_are_available_to_checker() {
             .iter()
             .any(|(path, _)| *path == "core/log/log.rssi")
     );
+    assert!(
+        core_interfaces()
+            .iter()
+            .any(|(path, _)| *path == "core/cache/cache.rssi")
+    );
     assert!(
         core_interfaces()
             .iter()
@@ -372,6 +377,30 @@ fn consume_buffer(buffer: take Buffer) -> Unit {
     assert!(rust.contains("rsscript_runtime::buffer_consume(buffer);"));
 }
 
+#[test]
+fn rust_lowering_maps_cache_core_calls_to_runtime_hooks() {
+    let source = r#"
+fn main() -> Unit {
+    let cache = Cache.new()
+    Cache.insert(cache: mut cache, key: read "/users", value: read "handled /users")
+    let body = Cache.lookup(cache: read cache, key: read "/users")
+    Log.write(message: read body)
+    return Unit
+}
+"#;
+    let rust = lower_source_to_rust("cache.rss", source).expect("source should lower");
+
+    assert!(rust.contains("let mut cache = rsscript_runtime::cache_new();"));
+    assert!(rust.contains(
+        "rsscript_runtime::cache_insert(&mut cache, &\"/users\".to_string(), &\"handled /users\".to_string());"
+    ));
+    assert!(
+        rust.contains(
+            "let body = rsscript_runtime::cache_lookup(&cache, &\"/users\".to_string());"
+        )
+    );
+}
+
 #[test]
 fn rust_lowering_maps_file_core_calls_to_runtime_hooks() {
     let source = r#"