@ape-egg/vibe 2.1.22 → 3.0.0

package/compiler/src/compiler/mod.rs

@@ -1,15 +0,0 @@
-pub mod compile;
-mod state_extractor;
-mod manifest_builder;
-mod value_stamper;
-mod iteration_optimizer;
-mod js_analyzer;
-mod component_tagger;
-mod binding_case;
-mod name_binding_protect;
-mod reassignment_analyzer;
-pub mod watcher;
-
-pub use compile::Compiler;
-#[allow(unused_imports)]
-pub use compile::{CompileStats, ManifestStats};

package/compiler/src/compiler/name_binding_protect.rs

@@ -1,207 +0,0 @@
-use regex::Regex;
-use std::sync::OnceLock;
-
-/// The attribute a relocated name-binding is parked in. Mirrors the runtime
-/// constant of the same name (runtime/constants.js) — the manifest builder reads
-/// the binding back out of it, and the runtime consumes + strips it on hydrate.
-pub const NAME_BIND_ATTR: &str = "data-vibe-namebind";
-
-/// A name-binding lives in attribute-NAME position: `<icon @[expr]>`. HTML parsers
-/// split an attribute token on whitespace, so once a prop is inlined into one and the
-/// expression gains spaces — `<icon @[element]>` becoming `@[EQUIPMENT(item, true).element]`
-/// — html5ever (and the browser) tear it into broken attributes and the binding is lost.
-///
-/// We relocate every whitespace-bearing name-binding into a single verbatim
-/// value-attribute `data-vibe-namebind="@[expr]@[expr2]…"`. Value attributes are kept
-/// byte-for-byte through parsing, so the manifest builder recovers the exact expression
-/// and the runtime evaluates it through the same path it uses in non-compiled mode —
-/// identical behaviour, no expression rewriting. Whitespace-free name-bindings already
-/// survive as-is and are left untouched.
-pub fn protect(html: &str) -> String {
-    // <script>/<style> bodies are raw text — a `<` inside them must not be read as a
-    // tag. Park them behind comment placeholders for the tag scan, restore after.
-    let (masked, raw_blocks) = mask_raw_text(html);
-
-    let out = tag_open_regex()
-        .replace_all(&masked, |caps: &regex::Captures| {
-            let name = &caps[1];
-            let attrs = &caps[2];
-            let (kept, relocated) = relocate_unsafe(attrs);
-            if relocated.is_empty() {
-                return caps[0].to_string();
-            }
-            // Preserve a self-closing slash as the final token.
-            let kept_end_trimmed = kept.trim_end();
-            let (body, self_close) = match kept_end_trimmed.strip_suffix('/') {
-                Some(b) => (b.trim_end(), " /"),
-                None => (kept_end_trimmed, ""),
-            };
-            format!(
-                "<{}{} {}=\"{}\"{}>",
-                name, body, NAME_BIND_ATTR, relocated, self_close
-            )
-        })
-        .to_string();
-
-    restore_raw_text(&out, &raw_blocks)
-}
-
-/// Matches an opening tag and captures (name, attribute-section). Quoted values may
-/// hold anything but their own quote; bare attribute chars are anything but `<>"'`.
-fn tag_open_regex() -> &'static Regex {
-    static RE: OnceLock<Regex> = OnceLock::new();
-    RE.get_or_init(|| {
-        Regex::new(r#"<([a-zA-Z][a-zA-Z0-9-]*)((?:"[^"]*"|'[^']*'|[^<>"'])*)>"#).unwrap()
-    })
-}
-
-/// Walk a tag's attribute section, moving each whitespace-bearing name-binding out of
-/// the kept attributes and into the concatenated `relocated` string. Quoted attribute
-/// values (and string literals inside an expression) are skipped so value-bindings and
-/// `@[fn('a b')]`-style literals are never mistaken for a name-binding.
-fn relocate_unsafe(attrs: &str) -> (String, String) {
-    let bytes = attrs.as_bytes();
-    let n = bytes.len();
-    let mut kept = String::with_capacity(n);
-    let mut relocated = String::new();
-    let mut i = 0;
-    let mut seg = 0;
-
-    while i < n {
-        let b = bytes[i];
-
-        // Skip a quoted attribute value verbatim (it may legally contain `@[…]`).
-        if b == b'"' || b == b'\'' {
-            i += 1;
-            while i < n && bytes[i] != b {
-                i += 1;
-            }
-            if i < n {
-                i += 1; // consume closing quote
-            }
-            continue;
-        }
-
-        // A bare name-binding in attribute-name position.
-        if b == b'@' && i + 1 < n && bytes[i + 1] == b'[' {
-            kept.push_str(&attrs[seg..i]);
-            let start = i;
-            i += 2;
-            let mut depth = 1;
-            while i < n && depth > 0 {
-                let c = bytes[i];
-                if c == b'\'' || c == b'"' {
-                    i += 1;
-                    while i < n && bytes[i] != c {
-                        i += 1;
-                    }
-                    if i < n {
-                        i += 1;
-                    }
-                    continue;
-                }
-                match c {
-                    b'[' => depth += 1,
-                    b']' => depth -= 1,
-                    _ => {}
-                }
-                i += 1;
-            }
-            let binding = &attrs[start..i];
-            let inner = &binding[2..binding.len() - 1];
-            if inner.bytes().any(|x| x.is_ascii_whitespace()) {
-                relocated.push_str(binding);
-            } else {
-                kept.push_str(binding);
-            }
-            seg = i;
-            continue;
-        }
-
-        i += 1;
-    }
-    kept.push_str(&attrs[seg..]);
-    (kept, relocated)
-}
-
-fn raw_text_regex() -> &'static Regex {
-    static RE: OnceLock<Regex> = OnceLock::new();
-    RE.get_or_init(|| Regex::new(r"(?is)<(script|style)\b[^>]*>.*?</(?:script|style)>").unwrap())
-}
-
-fn mask_raw_text(html: &str) -> (String, Vec<String>) {
-    let mut blocks = Vec::new();
-    let mut out = String::with_capacity(html.len());
-    let mut last = 0;
-    for mat in raw_text_regex().find_iter(html) {
-        out.push_str(&html[last..mat.start()]);
-        out.push_str(&format!("<!--VIBE_RAWTEXT_{}-->", blocks.len()));
-        blocks.push(html[mat.start()..mat.end()].to_string());
-        last = mat.end();
-    }
-    out.push_str(&html[last..]);
-    (out, blocks)
-}
-
-fn restore_raw_text(html: &str, blocks: &[String]) -> String {
-    let mut out = html.to_string();
-    for (i, block) in blocks.iter().enumerate() {
-        out = out.replace(&format!("<!--VIBE_RAWTEXT_{}-->", i), block);
-    }
-    out
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn relocates_whitespace_name_binding() {
-        let html = r#"<icon @[EQUIPMENT(item, true).element]></icon>"#;
-        let out = protect(html);
-        assert!(
-            out.contains(r#"data-vibe-namebind="@[EQUIPMENT(item, true).element]""#),
-            "got: {}",
-            out
-        );
-        // The raw whitespace binding must no longer sit in attribute-name position.
-        assert!(!out.contains("@[EQUIPMENT(item, true).element]>"));
-    }
-
-    #[test]
-    fn leaves_whitespace_free_name_binding_untouched() {
-        let html = r#"<icon @[(selectedEquipProps(uuid)).element]></icon>"#;
-        assert_eq!(protect(html), html);
-    }
-
-    #[test]
-    fn leaves_value_binding_untouched() {
-        let html = r#"<card tinted="@[fn(a, b).element]"></card>"#;
-        assert_eq!(protect(html), html);
-    }
-
-    #[test]
-    fn leaves_text_binding_untouched() {
-        let html = r#"<label>@[fn(a, b)]</label>"#;
-        assert_eq!(protect(html), html);
-    }
-
-    #[test]
-    fn ignores_at_bracket_inside_script() {
-        let html = r#"<script>const x = "@[fn(a, b)]";</script><icon @[fn(a, b)]></icon>"#;
-        let out = protect(html);
-        assert!(out.contains(r#"const x = "@[fn(a, b)]";"#), "script mangled: {}", out);
-        assert!(out.contains(r#"data-vibe-namebind="@[fn(a, b)]""#), "got: {}", out);
-    }
-
-    #[test]
-    fn relocates_multiple_on_one_element() {
-        let html = r#"<el @[fn(a, b)] @[gn(c, d)]></el>"#;
-        let out = protect(html);
-        assert!(
-            out.contains(r#"data-vibe-namebind="@[fn(a, b)]@[gn(c, d)]""#),
-            "got: {}",
-            out
-        );
-    }
-}

package/compiler/src/compiler/reassignment_analyzer.rs

@@ -1,456 +0,0 @@
-//! Reassignment analysis: decide which global `$` state keys are compile-time
-//! constants (safe to value-stamp into pre-rendered HTML) versus runtime-dynamic
-//! (must be left as live `@[...]` bindings for the runtime to fill).
-//!
-//! Soundness rule: a wrong "constant" bakes stale content into production HTML
-//! (a correctness bug), while a wrong "dynamic" merely forgoes the optimization
-//! (a brief FOUC, same as today). So every uncertain case resolves to **dynamic**.
-//!
-//! A key is reported constant only when ALL of these hold:
-//!   1. Its initial value is a primitive (string / number / bool / null). Objects
-//!      and arrays are never constant — their contents can be mutated through a
-//!      value alias (`const a = $.items; a.push(x)`) that a `$.key` scan cannot
-//!      see, so they are conservatively excluded.
-//!   2. No write to `$.key` anywhere across the scanned sources — assignment,
-//!      compound assignment, `++`/`--`, `delete`, or a nested `$.key.x = …`.
-//!
-//! Any of these "escape" signals discards the whole optimization (every key is
-//! treated dynamic), because they could write a key we cannot pin down:
-//!   - aliasing `$` itself (`const x = $` / `x = $`),
-//!   - reflective writes (`Object.assign($, …)` / `Object.defineProperty($, …)`),
-//!   - a source that fails to parse (we cannot prove it is write-free).
-//!
-//! The `$` access split mirrors Vibe's own convention: `$.key` and `$['key']`
-//! (string literal) address GLOBAL state, while `$[expr]` with a non-literal key
-//! is the component-state-by-id pattern (`const id = component(s); $[id].x = …`)
-//! whose key is a generated component id, never a global key — so a non-literal
-//! computed write is ignored, not a bail.
-//!
-//! Passing `$` as a plain argument (`derive($, …)`) is treated as a read, not an
-//! escape — the vibe convention is to write state through direct `$.key = …`
-//! member assignments, and bailing on every `f($)` would disable the optimization
-//! for any real app.
-
-use swc_common::{sync::Lrc, FileName, SourceMap};
-use swc_ecma_ast::*;
-use swc_ecma_parser::{EsSyntax, Parser, StringInput, Syntax};
-use swc_ecma_visit::{Visit, VisitWith};
-
-use serde_json::{Map, Value};
-use std::collections::HashSet;
-
-/// Classify which `initial_state` keys are safe to treat as compile-time
-/// constants, given every JS source in the app (module files, inline `<script>`
-/// bodies, and HTML `on*` handler bodies). See module docs for the rules.
-pub fn classify_constant_keys(
-    initial_state: &Map<String, Value>,
-    sources: &[String],
-) -> HashSet<String> {
-    let mut written: HashSet<String> = HashSet::new();
-
-    for src in sources {
-        let module = match parse(src) {
-            Some(m) => m,
-            // Cannot prove a source is write-free → forfeit the whole optimization.
-            None => return HashSet::new(),
-        };
-        let mut visitor = WriteVisitor::default();
-        module.visit_with(&mut visitor);
-        if visitor.bail {
-            return HashSet::new();
-        }
-        written.extend(visitor.written);
-    }
-
-    initial_state
-        .iter()
-        .filter(|(key, value)| is_primitive(value) && !written.contains(key.as_str()))
-        .map(|(key, _)| key.clone())
-        .collect()
-}
-
-/// True if `src` parses as JavaScript. Used to drop heuristically-extracted
-/// HTML attribute values that aren't actually event-handler code, so that genuine
-/// unparseable JS sources can still trigger the conservative bail.
-pub fn parses_as_js(src: &str) -> bool {
-    parse(src).is_some()
-}
-
-fn is_primitive(value: &Value) -> bool {
-    matches!(
-        value,
-        Value::String(_) | Value::Number(_) | Value::Bool(_) | Value::Null
-    )
-}
-
-/// Parse a source as a module. Handler bodies can contain top-level `return`
-/// (`onclick="if (x) return; f()"`), which is illegal at module top level, so a
-/// failed parse is retried wrapped in a function before giving up — writes are
-/// still found inside the wrapper, while genuinely broken sources fall through.
-fn parse(src: &str) -> Option<Module> {
-    parse_module(src).or_else(|| parse_module(&format!("function __vibe_wrap__(){{\n{}\n}}", src)))
-}
-
-fn parse_module(code: &str) -> Option<Module> {
-    let cm: Lrc<SourceMap> = Default::default();
-    let fm = cm.new_source_file(Lrc::new(FileName::Anon), code.to_string());
-    let syntax = Syntax::Es(EsSyntax {
-        jsx: false,
-        decorators: true,
-        ..Default::default()
-    });
-    let input = StringInput::new(&fm.src, fm.start_pos, fm.end_pos);
-    let mut parser = Parser::new(syntax, input, None);
-    parser.parse_module().ok()
-}
-
-fn is_dollar(expr: &Expr) -> bool {
-    matches!(expr, Expr::Ident(id) if id.sym.to_string() == "$")
-}
-
-/// What a write target rooted at `$` resolves to.
-enum DollarTarget {
-    /// `$.key`, `$.key.x…`, or `$['key']` — the top-level GLOBAL state key touched.
-    Key(String),
-    /// `$[expr]` with a non-literal key — Vibe's component-state-by-id access,
-    /// never a global key, so irrelevant to global-constant analysis.
-    ComponentState,
-    /// Not rooted at `$`.
-    None,
-}
-
-/// Walk a member chain to its base. If the base is the `$` identifier, return
-/// the FIRST property after it (the top-level state key). `$.a.b.c` → `a`.
-fn dollar_target(member: &MemberExpr) -> DollarTarget {
-    match &*member.obj {
-        Expr::Ident(id) if id.sym.to_string() == "$" => match &member.prop {
-            MemberProp::Ident(name) => DollarTarget::Key(name.sym.to_string()),
-            MemberProp::Computed(c) => match &*c.expr {
-                Expr::Lit(Lit::Str(s)) => DollarTarget::Key(s.value.to_string()),
-                _ => DollarTarget::ComponentState,
-            },
-            MemberProp::PrivateName(_) => DollarTarget::None,
-        },
-        Expr::Member(inner) => dollar_target(inner),
-        Expr::Paren(p) => match &*p.expr {
-            Expr::Member(inner) => dollar_target(inner),
-            _ => DollarTarget::None,
-        },
-        _ => DollarTarget::None,
-    }
-}
-
-#[derive(Default)]
-struct WriteVisitor {
-    written: HashSet<String>,
-    bail: bool,
-}
-
-impl WriteVisitor {
-    /// Record a write whose target is (or descends from) `$`.
-    fn record_member_write(&mut self, member: &MemberExpr) {
-        match dollar_target(member) {
-            DollarTarget::Key(k) => {
-                self.written.insert(k);
-            }
-            // Component-state-by-id write — irrelevant to global keys.
-            DollarTarget::ComponentState => {}
-            DollarTarget::None => {}
-        }
-    }
-}
-
-/// Detects any use of the bare `$` identifier within a subtree.
-#[derive(Default)]
-struct DollarUseFinder {
-    found: bool,
-}
-impl Visit for DollarUseFinder {
-    fn visit_ident(&mut self, id: &Ident) {
-        if id.sym.to_string() == "$" {
-            self.found = true;
-        }
-    }
-}
-
-impl Visit for WriteVisitor {
-    fn visit_assign_expr(&mut self, n: &AssignExpr) {
-        match &n.left {
-            AssignTarget::Simple(SimpleAssignTarget::Member(m)) => self.record_member_write(m),
-            // `($.k) = …`
-            AssignTarget::Simple(SimpleAssignTarget::Paren(p)) => {
-                if let Expr::Member(m) = &*p.expr {
-                    self.record_member_write(m);
-                }
-            }
-            // Reassigning `$` itself (`$ = …`) replaces the whole state object.
-            AssignTarget::Simple(SimpleAssignTarget::Ident(id)) => {
-                if id.id.sym.to_string() == "$" {
-                    self.bail = true;
-                }
-            }
-            // Destructuring assignment that writes through `$` (`[$.k] = …`).
-            AssignTarget::Pat(pat) => {
-                let mut finder = DollarUseFinder::default();
-                pat.visit_with(&mut finder);
-                if finder.found {
-                    self.bail = true;
-                }
-            }
-            _ => {}
-        }
-        // Aliasing: `x = $` lets later `x.key = …` writes escape our scan.
-        if is_dollar(&n.right) {
-            self.bail = true;
-        }
-        n.visit_children_with(self);
-    }
-
-    fn visit_var_declarator(&mut self, n: &VarDeclarator) {
-        // `const x = $` — same aliasing escape as `x = $`.
-        if let Some(init) = &n.init {
-            if is_dollar(init) {
-                self.bail = true;
-            }
-        }
-        n.visit_children_with(self);
-    }
-
-    fn visit_update_expr(&mut self, n: &UpdateExpr) {
-        // `$.key++`, `--$.key`
-        if let Expr::Member(m) = &*n.arg {
-            self.record_member_write(m);
-        }
-        n.visit_children_with(self);
-    }
-
-    fn visit_unary_expr(&mut self, n: &UnaryExpr) {
-        // `delete $.key`
-        if matches!(n.op, UnaryOp::Delete) {
-            if let Expr::Member(m) = &*n.arg {
-                self.record_member_write(m);
-            }
-        }
-        n.visit_children_with(self);
-    }
-
-    fn visit_call_expr(&mut self, n: &CallExpr) {
-        // Reflective writes: Object.assign($, …) / Object.defineProperty($, …) /
-        // Reflect.set($, …) and friends could write any key.
-        if let Callee::Expr(callee) = &n.callee {
-            if let Expr::Member(m) = &**callee {
-                if let Expr::Ident(obj) = &*m.obj {
-                    let obj = obj.sym.to_string();
-                    if let MemberProp::Ident(method) = &m.prop {
-                        let method = method.sym.to_string();
-                        let reflective_write = matches!(
-                            (obj.as_str(), method.as_str()),
-                            ("Object", "assign")
-                                | ("Object", "defineProperty")
-                                | ("Object", "defineProperties")
-                                | ("Object", "setPrototypeOf")
-                                | ("Reflect", "set")
-                                | ("Reflect", "defineProperty")
-                                | ("Reflect", "deleteProperty")
-                                | ("Reflect", "setPrototypeOf")
-                        );
-                        if reflective_write {
-                            if let Some(first) = n.args.first() {
-                                if is_dollar(&first.expr) {
-                                    self.bail = true;
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        n.visit_children_with(self);
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use serde_json::json;
-
-    fn state(pairs: &[(&str, Value)]) -> Map<String, Value> {
-        pairs.iter().map(|(k, v)| (k.to_string(), v.clone())).collect()
-    }
-
-    #[test]
-    fn primitive_never_written_is_constant() {
-        let s = state(&[("version", json!("0.1.5"))]);
-        let got = classify_constant_keys(&s, &["console.log($.version);".to_string()]);
-        assert!(got.contains("version"));
-    }
-
-    #[test]
-    fn direct_reassignment_is_dynamic() {
-        let s = state(&[("coins", json!(400)), ("version", json!("0.1.5"))]);
-        let got = classify_constant_keys(&s, &["$.coins = 500;".to_string()]);
-        assert!(!got.contains("coins"));
-        assert!(got.contains("version"));
-    }
-
-    #[test]
-    fn compound_and_update_are_dynamic() {
-        let s = state(&[("a", json!(1)), ("b", json!(1)), ("c", json!(1))]);
-        let got = classify_constant_keys(&s, &["$.a += 1; $.b++; --$.c;".to_string()]);
-        assert!(got.is_empty());
-    }
-
-    #[test]
-    fn computed_string_literal_write_is_dynamic() {
-        let s = state(&[("coins", json!(400)), ("version", json!("v"))]);
-        let got = classify_constant_keys(&s, &["$['coins'] = 1;".to_string()]);
-        assert!(!got.contains("coins"));
-        assert!(got.contains("version"));
-    }
-
-    #[test]
-    fn delete_is_dynamic() {
-        let s = state(&[("x", json!(1))]);
-        let got = classify_constant_keys(&s, &["delete $.x;".to_string()]);
-        assert!(!got.contains("x"));
-    }
-
-    #[test]
-    fn nested_property_write_marks_top_key_dynamic() {
-        let s = state(&[("settings", json!({ "a": 1 })), ("version", json!("v"))]);
-        let got = classify_constant_keys(&s, &["$.settings.theme = 'dark';".to_string()]);
-        assert!(!got.contains("settings"));
-        assert!(got.contains("version"));
-    }
-
-    #[test]
-    fn objects_and_arrays_are_never_constant() {
-        let s = state(&[
-            ("characters", json!([])),
-            ("clock", json!({ "now": 0 })),
-            ("version", json!("v")),
-        ]);
-        let got = classify_constant_keys(&s, &["// no writes".to_string()]);
-        assert!(!got.contains("characters"));
-        assert!(!got.contains("clock"));
-        assert!(got.contains("version"));
-    }
-
-    #[test]
-    fn aliasing_dollar_bails_everything() {
-        let s = state(&[("version", json!("v")), ("coins", json!(1))]);
-        let got = classify_constant_keys(&s, &["const x = $; x.coins = 5;".to_string()]);
-        assert!(got.is_empty());
-    }
-
-    #[test]
-    fn reassigning_dollar_bails_everything() {
-        let s = state(&[("version", json!("v"))]);
-        let got = classify_constant_keys(&s, &["let y; y = $;".to_string()]);
-        assert!(got.is_empty());
-    }
-
-    #[test]
-    fn computed_component_state_write_is_ignored() {
-        // `$[id]` / `$[id].x = …` is Vibe's component-state-by-id pattern (id is a
-        // generated component id, never a global key), so it must not bail.
-        let s = state(&[("version", json!("v"))]);
-        let got = classify_constant_keys(
-            &s,
-            &["const id = component({ open: false }); $[id].open = true;".to_string()],
-        );
-        assert!(got.contains("version"));
-    }
-
-    #[test]
-    fn computed_string_literal_global_write_is_dynamic() {
-        // A *literal* computed key IS a global-key write and must mark it dynamic.
-        let s = state(&[("coins", json!(1)), ("version", json!("v"))]);
-        let got = classify_constant_keys(&s, &["$['coins'] = 5;".to_string()]);
-        assert!(!got.contains("coins"));
-        assert!(got.contains("version"));
-    }
-
-    #[test]
-    fn object_assign_on_dollar_bails_everything() {
-        let s = state(&[("version", json!("v"))]);
-        let got = classify_constant_keys(&s, &["Object.assign($, { coins: 5 });".to_string()]);
-        assert!(got.is_empty());
-    }
-
-    #[test]
-    fn write_in_nested_scope_is_detected() {
-        let s = state(&[("token", json!(null)), ("version", json!("v"))]);
-        let src = "function f(){ if (true) { $.token = undefined; } } const g = () => $.version;";
-        let got = classify_constant_keys(&s, &[src.to_string()]);
-        assert!(!got.contains("token"));
-        assert!(got.contains("version"));
-    }
-
-    #[test]
-    fn write_across_multiple_sources() {
-        let s = state(&[("a", json!(1)), ("b", json!(2))]);
-        let srcs = ["$.a = 1;".to_string(), "console.log($.b);".to_string()];
-        let got = classify_constant_keys(&s, &srcs);
-        assert!(!got.contains("a"));
-        assert!(got.contains("b"));
-    }
-
-    #[test]
-    fn reads_do_not_mark_dynamic() {
-        let s = state(&[("version", json!("v"))]);
-        let src = "const x = $.version; if ($.version === 'v') foo($.version);";
-        let got = classify_constant_keys(&s, &[src.to_string()]);
-        assert!(got.contains("version"));
-    }
-
-    #[test]
-    fn passing_dollar_as_argument_does_not_bail() {
-        let s = state(&[("version", json!("v"))]);
-        let src = "dataInspectorState($, paths); render($);";
-        let got = classify_constant_keys(&s, &[src.to_string()]);
-        assert!(got.contains("version"));
-    }
-
-    #[test]
-    fn unparseable_source_bails_everything() {
-        let s = state(&[("version", json!("v"))]);
-        let got = classify_constant_keys(&s, &["this is (((not valid @@@".to_string()]);
-        assert!(got.is_empty());
-    }
-
-    #[test]
-    fn handler_body_write_is_detected() {
-        let s = state(&[("overlay", json!({})), ("version", json!("v"))]);
-        let got = classify_constant_keys(
-            &s,
-            &["event.preventDefault(); $.overlay = { name: 'x' };".to_string()],
-        );
-        assert!(got.contains("version"));
-        assert!(!got.contains("overlay"));
-    }
-
-    #[test]
-    fn realistic_app_state_subset() {
-        // Mirrors the battle-brawlers global state: only `version` survives.
-        let s = state(&[
-            ("version", json!("0.1.5")),
-            ("coins", json!(400)),
-            ("characters", json!([])),
-            ("token", json!(null)),
-            ("settings", json!({ "darkMode": false })),
-        ]);
-        let srcs = [
-            "if (email) $.email = email; $.canTest = false;".to_string(),
-            "if (gameState.characters) $.characters = gameState.characters;".to_string(),
-            "if (gameState.coins !== undefined) $.coins = gameState.coins;".to_string(),
-            "$.token = undefined; const v = $.version;".to_string(),
-        ];
-        let got = classify_constant_keys(&s, &srcs);
-        assert!(got.contains("version"));
-        assert!(!got.contains("coins"));
-        assert!(!got.contains("characters"));
-        assert!(!got.contains("token"));
-        assert!(!got.contains("settings"));
-    }
-}