Apply the Octoscript rename to l0-photo-weight and merge main

.gitignore

@@ -5,3 +5,6 @@ Cargo.lock
 
 # Visual-QA screenshots (regenerate with tools/visual-qa.sh)
 tools/qa-shots/
+
+# makepad studio state
+.makepad/

Cargo.toml

@@ -22,7 +22,7 @@ members = [
 makepad-widgets = { git = "https://github.com/OctoSense-org/makepad.git", rev = "8c23d5779f643228004fd27e651ae19be9b14ab4" }
 makepad-script = { git = "https://github.com/OctoSense-org/makepad.git", rev = "8c23d5779f643228004fd27e651ae19be9b14ab4" }
 # The VM-independent Octoscript node model, from the Octoscript repo itself.
-octoscript-ui-l0 = { git = "https://github.com/OctoSense-org/Octoscript.git", branch = "main" }
+octoscript-ui-l0 = { git = "https://github.com/OctoSense-org/Octoscript.git", branch = "rename/fix-language-review-20260904" }
 
 [profile.release]
 opt-level = 3

README.md

@@ -81,20 +81,34 @@ Building + running the `kit-host` against upstream surfaced exactly **one** thin
 
 ## Relationship to makepad
 
-Makepad ships everything this needs — the `makepad-script` VM (`platform/script`) and the `Splash` runtime-mount widget. The whole workspace takes them from **one pinned revision** of [`guofoo/makepad`](https://github.com/guofoo/makepad) (a fork of upstream `dev`), declared once in the root `Cargo.toml` under `[workspace.dependencies]`:
-
-- The **core crates** depend on `makepad-script` from that pin.
-- **`octoscript-widgets`** and the kit apps depend on `makepad-widgets` from the same pin, so `makepad-script` stays aligned with `octoscript-render`'s.
-- The pin is the revision [OctoSense-org/octosense](https://github.com/OctoSense-org/octosense) builds against; bump both together so an app never carries two makepad lineages.
-- `octoscript-ui-l0` (the VM-independent node model) comes by git from [OctoSense-org/Octoscript](https://github.com/OctoSense-org/Octoscript), branch `main`.
+The workspace uses the checked-out sibling `../makepad`: `octoscript-render` takes
+`platform/script`, and the native widget crates and apps take `widgets`. Keep that checkout
+at the parent repository's pinned revision; the bounded evaluator also uses its
+`ScriptVm::eval_checked` API. The L0 integration tests use sibling `../octoscript`.
 
 ## Build
 
+### L0 design-kit validation
+
+The lab's `octoscript-beauty-host` Studio runnable mounts L0 cards through
+`l0::prepare` and `to_makepad_l0_ui`. This preserves the L0 kit's resolved
+Card/Chip presentation; `to_makepad_ui` remains the Material semantic entry
+point. The preview uses a standalone native window so Studio's pane size
+cannot change the design frame. HTTP image resources and host fixture data
+are exercised by the pipeline, alongside checked native widget construction.
+
+See [the Taskplan runbook](../lab/sketch/TASKPLAN-VALIDATION.md) for commands,
+capture hashes, fill/vision judgments and known fidelity limits. The new
+runnable is independent of the older Material catalog shell.
+
+With the `makepad`, `octoscript` and `octoscript-makepad` checkouts present:
+
 ```sh
-cargo test            # builds + tests the portable core (octoscript-render, octoscript-makepad)
+cargo test --release -p octoscript-render -p octoscript-makepad
 ```
 
-`octoscript-widgets` is excluded from the default workspace build (it needs the full upstream-makepad build); wire it into an app's makepad workspace to use it — call `octoscript_widgets::widgets_mod(vm)` in place of `makepad_widgets::widgets_mod(vm)`.
+This tests the portable renderer and translator without building the native applications.
+The native applications are workspace members and have separate platform build requirements.
 
 ## Status
 

apps/flutter-samples/src/lib.rs

@@ -161,8 +161,55 @@ pub struct App {
     /// Seconds since startup, fed to the kit as `st.t`.
     #[rust]
     clock: f64,
+    /// SELF-DRIVE: commands loaded from /data/local/tmp/fs_cmd.txt — the phone
+    /// taps and captures ITSELF; no adb input, no adb screencap. `tap X Y`
+    /// (physical px), `shot <path.png>`, `wait <ticks>`.
+    #[rust]
+    drive_cmds: Vec<String>,
+    #[rust]
+    drive_at: usize,
+    #[rust]
+    drive_delay: u32,
+    /// A Stop touch waiting to follow its Start.
+    #[rust]
+    drive_stop: Option<(f64, f64, u64)>,
+    #[rust]
+    drive_uid: u64,
+    #[rust]
+    drive_last_file: String,
+    /// Frames remaining on an active capture (env var set).
+    #[rust]
+    drive_shot: u32,
 }
 
+/// One synthetic touch through the REAL input pipeline: the same channel and
+/// coalescing the JNI layer uses, physical coords, converted by the same
+/// handler. The phone touching its own screen.
+#[cfg(target_os = "android")]
+fn self_tap(x: f64, y: f64, uid: u64, down: bool) {
+    use makepad_widgets::makepad_platform::os::linux::android::android_jni;
+    use makepad_widgets::makepad_platform::event::{TouchPoint, TouchState};
+    use makepad_widgets::makepad_platform::Area;
+    let t = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map(|d| d.as_secs_f64())
+        .unwrap_or(0.0);
+    let touch = TouchPoint {
+        state: if down { TouchState::Start } else { TouchState::Stop },
+        abs: makepad_widgets::makepad_platform::math_f64::dvec2(x, y),
+        time: t,
+        uid,
+        rotation_angle: 0.0,
+        force: 1.0,
+        radius: makepad_widgets::makepad_platform::math_f64::dvec2(1.0, 1.0),
+        handled: std::cell::Cell::new(Area::Empty),
+        sweep_lock: std::cell::Cell::new(Area::Empty),
+    };
+    android_jni::send_from_java_message(android_jni::FromJavaMessage::Touch(vec![touch]));
+}
+#[cfg(not(target_os = "android"))]
+fn self_tap(_x: f64, _y: f64, _uid: u64, _down: bool) {}
+
 impl App {
     fn current_source() -> String {
         std::fs::read_to_string(DEVICE_PATH).unwrap_or_else(|_| BAKED.to_string())
@@ -201,14 +248,65 @@ impl App {
         if let Some(node) = built {
             let ui = octoscript_makepad::to_makepad_ui(&node);
             diag.push_str(&format!(" nodes={} ui_len={}", node.count(), ui.len()));
-            self.ui.widget(cx, ids!(host)).set_text(cx, &ui);
+            // On the APP VM, with THIS crate as the module identity — not as
+            // text into the `Splash` isolate. Two reasons, both found blank on
+            // a real 6T and both already documented in kit-host's mount:
+            //   · `crate_resource("self:…")` resolves against the module that
+            //     evaluated the body. On the isolate that is makepad_widgets,
+            //     which ships no Roboto — so every text node silently dropped
+            //     while the chips and sliders drew fine.
+            //   · the emitted `on_click` calls the `NAV` global, which only
+            //     the app VM registers — on the isolate every tap was dead.
+            let code = format!("use mod.prelude.widgets.*\nView{{height:Fit, {ui}");
+            let script_mod = ScriptMod {
+                cargo_manifest_path: env!("CARGO_MANIFEST_DIR").to_string(),
+                module_path: module_path!().to_string(),
+                file: file!().to_string(),
+                line: 1,
+                column: 0,
+                code: String::new(),
+                values: Vec::new(),
+            };
+            let built_view = cx.with_vm(|vm| {
+                let value = vm.eval_with_append_source(script_mod, &code, octoscript_render::makepad_script::ScriptValue::NIL.into());
+                (!value.is_err() && !value.is_nil()).then(|| View::script_from_value(vm, value))
+            });
+            if let Some(view) = built_view {
+                if let Some(mut host) = self.ui.widget(cx, ids!(host)).borrow_mut::<Splash>() {
+                    host.view = view;
+                }
+            }
         }
         // `log!`, not a file write: the OHOS app sandbox blocks /data/local/tmp,
         // so the earlier file-based diagnostic produced nothing.
         log!("MOUNT {}", diag);
     }
 }
 
+/// Taps land here. The emitted body's `on_click` calls `NAV(t: "…")` — the
+/// same channel kit-host uses, because the body now evaluates on the APP VM
+/// (see `mount`), where `ui.nav_signal` does not exist.
+static TAPS: std::sync::Mutex<Vec<String>> = std::sync::Mutex::new(Vec::new());
+
+fn take_tap() -> Option<String> {
+    TAPS.lock().ok().and_then(|mut q| if q.is_empty() { None } else { Some(q.remove(0)) })
+}
+
+fn register_nav(vm: &mut ScriptVm) {
+    let f_nav = octoscript_render::add_global_fn(
+        vm,
+        &[(live_id!(t), octoscript_render::makepad_script::ScriptValue::NIL)],
+        |vm, a| {
+            let t = octoscript_render::string_prop(vm, a, live_id!(t)).unwrap_or_default();
+            if let Ok(mut q) = TAPS.lock() {
+                q.push(t);
+            }
+            octoscript_render::makepad_script::ScriptValue::NIL
+        },
+    );
+    vm.set_injected_global(live_id!(NAV), f_nav);
+}
+
 impl MatchEvent for App {}
 
 impl AppMain for App {
@@ -219,6 +317,10 @@ impl AppMain for App {
         });
         // Fork-free themed widgets, against upstream makepad.
         octoscript_widgets::widgets_mod(vm);
+        // The body mounts on THIS VM now (see `mount`), so its tap handlers
+        // need `NAV` here — unregistered, every tap raises "variable NAV not
+        // found" and dies silently.
+        register_nav(vm);
         self::script_mod(vm)
     }
 
@@ -256,10 +358,48 @@ impl AppMain for App {
         }
         if self.next_frame.is_event(event).is_some() {
             self.tick = self.tick.wrapping_add(1);
-            let nav_raw = self.ui.widget(cx, ids!(nav_signal)).text();
+            // SELF-DRIVE executor: one command at a time, frame-paced.
+            if let Some((x, y, uid)) = self.drive_stop.take() {
+                self_tap(x, y, uid, false);
+            } else if self.drive_shot > 0 {
+                self.drive_shot -= 1;
+                if self.drive_shot == 0 {
+                    std::env::remove_var("MAKEPAD_WRITE_FRAMEBUFFER_PNG");
+                }
+            } else if self.drive_delay > 0 {
+                self.drive_delay -= 1;
+            } else if self.drive_at < self.drive_cmds.len() {
+                let cmd = self.drive_cmds[self.drive_at].clone();
+                self.drive_at += 1;
+                let parts: Vec<&str> = cmd.split_whitespace().collect();
+                match parts.as_slice() {
+                    ["tap", x, y] => {
+                        if let (Ok(x), Ok(y)) = (x.parse::<f64>(), y.parse::<f64>()) {
+                            self.drive_uid += 1;
+                            self_tap(x, y, self.drive_uid, true);
+                            self.drive_stop = Some((x, y, self.drive_uid));
+                            self.drive_delay = 30;
+                        }
+                    }
+                    ["shot", path] => {
+                        std::env::set_var("MAKEPAD_WRITE_FRAMEBUFFER_PNG", path);
+                        self.drive_shot = 3;
+                        self.drive_delay = 6;
+                    }
+                    ["wait", n] => self.drive_delay = n.parse().unwrap_or(30),
+                    _ => {}
+                }
+                let done = self.drive_at >= self.drive_cmds.len();
+                let _ = std::fs::write(
+                    "/storage/emulated/0/Android/data/dev.makepad.flutter_samples/files/fs_cmd_done.txt",
+                    format!("{} {}/{}{}\n", cmd, self.drive_at, self.drive_cmds.len(),
+                            if done { " DONE" } else { "" }),
+                );
+                if done { log!("SELFDRIVE done"); }
+            }
+            let nav_raw = take_tap().unwrap_or_default();
             let nav = nav_raw.trim();
             if !nav.is_empty() {
-                self.ui.widget(cx, ids!(nav_signal)).set_text(cx, "");
                 if nav == "theme:toggle" {
                     self.dark = !self.dark;
                 } else if octoscript_render::state::apply(nav) {
@@ -278,6 +418,19 @@ impl AppMain for App {
                 }
                 self.mount(cx);
             } else if self.tick % 10 == 0 {
+                // SELF-DRIVE: load a new command file (mtime-independent — the
+                // file's CONTENT is the identity; clear it to re-arm).
+                if let Ok(txt) = std::fs::read_to_string("/data/local/tmp/fs_cmd.txt") {
+                    if !txt.trim().is_empty() && txt != self.drive_last_file {
+                        self.drive_last_file = txt.clone();
+                        self.drive_cmds =
+                            txt.lines().map(|l| l.trim().to_string()).filter(|l| !l.is_empty()).collect();
+                        self.drive_at = 0;
+                        self.drive_delay = 0;
+                        let _ = std::fs::write("/storage/emulated/0/Android/data/dev.makepad.flutter_samples/files/fs_cmd_done.txt", "LOADED\n");
+                        log!("SELFDRIVE loaded {} cmds", self.drive_cmds.len());
+                    }
+                }
                 // A route written to ROUTE_PATH wins over whatever was tapped,
                 // so the QA sweep can drive every screen from adb. Checked
                 // independently of the source, so pushing an edited kit still

apps/kit-host/Cargo.toml

@@ -9,7 +9,9 @@ description = "Generic app shell rendering a Octoscript component kit as native
 # on serde_json alone — it carries no makepad lineage, which is what makes it
 # safe here and is why it was extracted from octoscript-core.
 octoscript-ui-l0 = { workspace = true }
-serde_json = "1"
+serde_json = { version = "1", features = ["float_roundtrip"] }
+sha2 = "0.10"
+makepad-plot = { path = "../../crates/makepad-plot" }
 
 makepad-widgets = { workspace = true }
 octoscript-widgets = { path = "../../crates/octoscript-widgets" }
@@ -19,3 +21,7 @@ octoscript-makepad = { path = "../../crates/octoscript-makepad" }
 [[bin]]
 name = "kit-host"
 path = "src/main.rs"
+
+[[bin]]
+name = "beauty-host"
+path = "src/beauty.rs"

apps/kit-host/resources/atro/OFL.txt

@@ -0,0 +1,93 @@
+Copyright 2024 The Montserrat.Git Project Authors (https://github.com/JulietaUla/Montserrat.git)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+https://openfontlicense.org
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.