UI Profile Level 0: a canonical profile for LLM-authored UI

Cargo.toml

@@ -1,6 +1,7 @@
 [workspace]
 members = [
     "crates/splash-core",
+    "crates/splash-ui-l0",
     "crates/splash-linux-seccomp",
     "crates/splash-linux-project-quota",
     "crates/splash-capabilities",

crates/splash-core/Cargo.toml

@@ -10,5 +10,6 @@ description = "Bounded, host-neutral Splash VM runtime"
 workspace = true
 
 [dependencies]
+splash-ui-l0 = { path = "../splash-ui-l0" }
 makepad-script = { path = "../../vendor/makepad/platform/script" }
 serde_json = "1.0.150"

crates/splash-core/src/lib.rs

@@ -8,6 +8,14 @@
 //! Rust code.
 
 mod profile;
+/// The UI profile, re-exported so existing paths keep working.
+///
+/// It lives in `splash-ui-l0` now: it depends on `serde_json` alone, and an
+/// application carrying a different makepad lineage cannot depend on THIS crate
+/// at all — Cargo refuses the lockfile, since both ship `makepad-error-log
+/// v1.0.0` at different paths. L0 never needed the vendored VM; it inherited it
+/// by living here.
+pub use splash_ui_l0 as ui_l0;
 
 use std::any::Any;
 use std::cell::Cell;

crates/splash-ui-l0/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "splash-ui-l0"
+version = "0.1.0"
+edition = "2021"
+description = "UI Profile Level 0: check, realize and dispatch LLM-authored Splash cards"
+license = "MIT OR Apache-2.0"
+
+# serde_json and nothing else — deliberately.
+#
+# L0 has no expression form, so there is nothing to evaluate and no VM in the
+# path. Keeping the dependency list at one crate is what makes that claim
+# checkable rather than asserted, and what lets a host adopt L0 without adopting
+# a runtime: `splash-core` depends on a vendored makepad-script, and any app
+# already carrying a different makepad lineage cannot depend on it at all —
+# Cargo rejects the lockfile, because both ship `makepad-error-log v1.0.0` at
+# different paths. That collision is the reason this crate exists.
+[dependencies]
+serde_json = "1"
+
+[dev-dependencies]
+serde_json = "1"

crates/splash-ui-l0/examples/dirty_set.rs

@@ -0,0 +1,38 @@
+//! How much of a card a state write actually touches.
+//!
+//! Usage: dirty_set <card> <path>…
+
+use splash_ui_l0::{dirty_records, patch_points, record_dependencies};
+
+fn main() {
+    let mut a = std::env::args().skip(1);
+    let path = a.next().expect("usage: dirty_set <card> <path>…");
+    let changed: Vec<String> = a.collect();
+    let card = std::fs::read_to_string(&path).expect("card");
+
+    let all = record_dependencies(&card);
+    println!("{} records", all.len());
+    for d in &all {
+        println!("  {:<14} reads {}", d.record, d.reads.join(", "));
+    }
+    for c in &changed {
+        let dirty = dirty_records(&card, &[c.as_str()]);
+        println!(
+            "\nwriting {c:?} dirties {}/{} records: {}",
+            dirty.len(),
+            all.len(),
+            dirty.join(", ")
+        );
+        let minimal = patch_points(&card, &[c.as_str()]);
+        println!(
+            "  minimal patch points: {}/{} -> {}",
+            minimal.len(),
+            all.len(),
+            if minimal.is_empty() {
+                "(none)".into()
+            } else {
+                minimal.join(", ")
+            }
+        );
+    }
+}

crates/splash-ui-l0/examples/lower_l0.rs

@@ -0,0 +1,34 @@
+//! Realize an L0 card against a data snapshot and print the Makepad DSL.
+//!
+//! Usage: cargo run -p splash-core --example lower_l0 -- <card> <data.json>
+//!
+//! The data stands in for what the runtime would have fetched. Realization is a
+//! tree walk, so this never evaluates anything and reaches nothing.
+
+use splash_ui_l0::{makepad, realize, RealizeLimits};
+
+fn main() {
+    let mut args = std::env::args().skip(1);
+    let card_path = args.next().expect("usage: lower_l0 <card> <data.json>");
+    let data_path = args.next().expect("usage: lower_l0 <card> <data.json>");
+
+    let card = std::fs::read_to_string(&card_path).expect("card");
+    let data: serde_json::Value =
+        serde_json::from_str(&std::fs::read_to_string(&data_path).expect("data")).expect("json");
+
+    let report = realize(&card, &data, RealizeLimits::default());
+    for d in &report.diagnostics {
+        eprintln!("{}:{}:{}: {}", card_path, d.line, d.column, d.message);
+    }
+    match report.root {
+        Some(root) => {
+            eprintln!(
+                "realized {} nodes{}",
+                report.nodes,
+                if report.truncated { " (truncated)" } else { "" }
+            );
+            print!("{}", makepad::lower(&root));
+        }
+        None => std::process::exit(1),
+    }
+}

crates/splash-ui-l0/examples/source_plan.rs

@@ -0,0 +1,61 @@
+//! Print a card's source plan as JSON, for a host to fulfil.
+//!
+//! Usage: source_plan <card>
+//!
+//! splash-core says WHAT to fetch and in what order; it never fetches. Only a
+//! host knows what answers `sys.weather`.
+
+use splash_ui_l0::{source_plan, SourceArg};
+
+fn arg_json(a: &SourceArg) -> String {
+    match a {
+        SourceArg::Path(p) => format!(r#"{{"kind":"path","value":{p:?}}}"#),
+        SourceArg::Text(t) => format!(r#"{{"kind":"text","value":{t:?}}}"#),
+        SourceArg::Number(n) => format!(r#"{{"kind":"number","value":{n}}}"#),
+        SourceArg::List(items) => format!(
+            r#"{{"kind":"list","value":[{}]}}"#,
+            items
+                .iter()
+                .map(|i| format!("{i:?}"))
+                .collect::<Vec<_>>()
+                .join(",")
+        ),
+    }
+}
+
+fn main() {
+    let path = std::env::args().nth(1).expect("usage: source_plan <card>");
+    let plan = source_plan(&std::fs::read_to_string(&path).expect("card"));
+
+    let requests: Vec<String> = plan
+        .requests
+        .iter()
+        .map(|r| {
+            let args: Vec<String> = r
+                .args
+                .iter()
+                .map(|(n, a)| format!("[{n:?},{}]", arg_json(a)))
+                .collect();
+            let deps: Vec<String> = r.depends_on.iter().map(|d| format!("{d:?}")).collect();
+            format!(
+                r#"{{"name":{:?},"helper":{:?},"args":[{}],"depends_on":[{}]}}"#,
+                r.name,
+                r.helper,
+                args.join(","),
+                deps.join(",")
+            )
+        })
+        .collect();
+
+    let diags: Vec<String> = plan
+        .diagnostics
+        .iter()
+        .map(|d| format!(r#"{{"line":{},"message":{:?}}}"#, d.line, d.message))
+        .collect();
+
+    println!(
+        r#"{{"requests":[{}],"diagnostics":[{}]}}"#,
+        requests.join(","),
+        diags.join(",")
+    );
+}

crates/splash-ui-l0/examples/tap_l0.rs

@@ -0,0 +1,33 @@
+//! Realize a card, dispatch one event, realize again — the interaction loop.
+//!
+//! Usage: tap_l0 <card> <data.json> <event> [payload]
+//!
+//! Proves the loop end to end without a UI: state lives in the store, the event
+//! is a declared name, and the second realization reflects the write.
+
+use splash_ui_l0::{dispatch_with, makepad, realize_with_state, InstanceStore, RealizeLimits};
+
+fn main() {
+    let a: Vec<String> = std::env::args().skip(1).collect();
+    let (card_path, data_path, event) = (&a[0], &a[1], &a[2]);
+    let payload = a.get(3).map(|v| serde_json::Value::String(v.clone()));
+
+    let card = std::fs::read_to_string(card_path).expect("card");
+    let data: serde_json::Value =
+        serde_json::from_str(&std::fs::read_to_string(data_path).expect("data")).expect("json");
+    let mut store = InstanceStore::default();
+
+    let before = realize_with_state(&card, &data, &store, RealizeLimits::default());
+    eprintln!("before: {} nodes", before.nodes);
+
+    let applied = dispatch_with(&card, &mut store, "root", event, payload.as_ref());
+    eprintln!("dispatch {event:?} -> {applied}");
+
+    let after = realize_with_state(&card, &data, &store, RealizeLimits::default());
+    eprintln!("after:  {} nodes", after.nodes);
+    // Forget instances that went away, so the store tracks the live tree.
+    store.prune(&after.live_keys);
+    eprintln!("store:  {} live cells", store.len());
+
+    print!("{}", makepad::lower(&after.root.expect("root")));
+}