@ape-egg/vibe-compiler 3.0.0 → 3.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ape-egg/vibe-compiler",
-  "version": "3.0.0",
+  "version": "3.0.2",
   "type": "module",
   "description": "Optional Rust compiler for Vibe — pre-renders, inlines components, and optimizes iterations. The runtime never needs it.",
   "homepage": "https://vibe.korte.kim",

package/src/Cargo.lock

@@ -1599,7 +1599,7 @@ checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
 [[package]]
 name = "vibe-compiler"
-version = "2.2.0"
+version = "3.0.2"
 dependencies = [
  "clap",
  "colored",

package/src/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "vibe-compiler"
-version = "2.2.0"
+version = "3.0.2"
 edition = "2021"
 description = "Vibe framework compiler - compiles Vibe source files into optimized output"
 authors = ["Kim Korte"]

package/src/compiler/compile.rs

@@ -550,6 +550,20 @@ impl VerboseLogger {
     }
 }
 
+/// How a compiled page's HTML gets value-stamped after its manifest is built.
+#[derive(Clone, Copy, PartialEq)]
+pub(crate) enum StampMode {
+    /// Stamp everything resolvable and strip unresolved attribute markers —
+    /// regular compiled pages (the manifest restores what was stripped).
+    Full,
+    /// Stamp only what resolves statically; unresolved bindings, attributes
+    /// and conditionals stay byte-for-byte raw — the SPA shell, whose page
+    /// state is location-dependent and runtime-owned.
+    Selective,
+    /// Manifest only, HTML untouched.
+    Skip,
+}
+
 pub struct Compiler {
     config: Config,
     verbose: bool,
@@ -966,7 +980,7 @@ impl Compiler {
                     &source_root,
                     manifest_root.as_deref(),
                     &global_constants,
-                    !(spa && relative_path == "index.html"),
+                    if spa && relative_path == "index.html" { StampMode::Selective } else { StampMode::Full },
                 ) {
                     Ok(()) => true,
                     Err(e) => {
@@ -1003,7 +1017,7 @@ impl Compiler {
         source_root: &Path,
         manifest_root: Option<&str>,
         global_constants: &Map<String, Value>,
-        stamp: bool,
+        stamp: StampMode,
     ) -> Result<(), String> {
         use crate::compiler::manifest_builder::ManifestBuilder;
         use crate::compiler::component_tagger::ComponentTagger;
@@ -1060,15 +1074,18 @@ impl Compiler {
         // The manifest (written above) preserves BOTH branches so the runtime can
         // restore them and switch between branches reactively.
         //
-        // The SPA shell opts out (stamp: false): its state is location-dependent
-        // — unstampable by design — and it is served at EVERY route path while
-        // its manifest only resolves at /. Stamping would strip the raw
-        // `@[page.src]` outlet binding and leave deep links with nothing to
-        // hydrate from; unstamped, the runtime processes the raw binding at any
-        // URL (vibe-fouc covers the flash).
-        if stamp {
+        // The SPA shell stamps SELECTIVELY: its page state is location-dependent
+        // and it is served at EVERY route path, so anything unresolvable — the
+        // `@[page.src]` outlet, page.* conditionals, unresolved attribute
+        // markers — stays raw for the runtime to process at any URL. Whatever
+        // DOES resolve statically stamps like any compiled page, which drops
+        // iteration template rows from the painted DOM (they are live elements
+        // otherwise: their CSS animations run and their inline handlers fire
+        // before the vibe-module chain defines the handler functions).
+        if stamp != StampMode::Skip {
             let stamper = ValueStamper::with_constants(&state, components_as_is, global_constants)
-                .map_err(|e| format!("Failed to create value stamper: {}", e))?;
+                .map_err(|e| format!("Failed to create value stamper: {}", e))?
+                .selective(stamp == StampMode::Selective);
             let stamped = stamper.stamp_html(html.to_string())
                 .map_err(|e| format!("Failed to stamp HTML: {}", e))?;
 
@@ -1186,7 +1203,7 @@ impl Compiler {
 
                 // Try to generate manifest for this file (skip on error).
                 // The SPA shell keeps its raw bindings (manifest yes, stamp no).
-                let stamp = !(spa && relative_path == "index.html");
+                let stamp = if spa && relative_path == "index.html" { StampMode::Selective } else { StampMode::Full };
                 match Self::generate_file_manifest(html, html_path, &output_dir, relative_path, verbose, iterations_as_is, components_as_is, &source_root, manifest_root.as_deref(), &global_constants, stamp) {
                     Ok(()) => (true, None),
                     Err(e) => {
@@ -1516,6 +1533,16 @@ impl Compiler {
             )));
         }
 
+        // The component cache may be partially invalidated (watch mode drops
+        // an edited component plus its inlining ancestors before this pass).
+        // Re-fetch everything these pages reference — a cache miss during
+        // inlining is silent and would degrade the shell and fragments to raw
+        // runtime references. Warm entries return immediately, so a full
+        // build pays nothing.
+        if !self.config.components_as_is {
+            self.fetch_components_for_files(&page_files, parser)?;
+        }
+
         // Raw pre-pass: read every page and detect the shared-layout shape
         // BEFORE component inlining consumes the <component src> root.
         let mut raw_pages = Vec::new();
@@ -1726,7 +1753,7 @@ impl Compiler {
     /// Regenerate the shell's manifest after a watch-mode recompose (the full
     /// build gets it via generate_manifests; incremental recompiles target
     /// only changed files, and the shell has no source counterpart to list).
-    /// Manifest yes, stamp no — same rule as the full pipeline.
+    /// Manifest plus the selective stamp — same rule as the full pipeline.
     pub(crate) fn generate_shell_manifest(&self) -> Result<(), CompileError> {
         let shell_path = self.config.output.join("index.html");
         let disk_html;
@@ -1751,7 +1778,7 @@ impl Compiler {
             &self.config.source,
             self.config.root.as_deref(),
             &self.compute_global_constants(),
-            false,
+            StampMode::Selective,
         )
         .map_err(CompileError::SpaError)
     }
@@ -2831,6 +2858,210 @@ mod tests {
         let _ = fs::remove_dir_all(&dir);
     }
 
+    // Watch mode invalidates an edited component plus its inlining ancestors,
+    // then re-runs compile_spa through the same cache. The pass must re-fetch
+    // what it needs: a partially invalidated cache silently degrades inlining
+    // to raw runtime references (lean outlet-only shell, un-inlined
+    // fragments), so incremental output must be byte-identical to a cold full
+    // compile of the same source.
+    #[test]
+    fn spa_recompile_after_component_invalidation_matches_full_compile() {
+        let dir = std::env::temp_dir().join("vibe-spa-invalidation-test");
+        let _ = fs::remove_dir_all(&dir);
+        let source = dir.join("src");
+        fs::create_dir_all(source.join("pages")).unwrap();
+        fs::create_dir_all(source.join("components")).unwrap();
+        let page = |title: &str, content: &str| {
+            format!(
+                "<!DOCTYPE html>\n<html><head><title>{}</title></head>\n<body vibe-fouc>\
+                 <component src=\"/components/Layout.html\">{}</component></body></html>\n",
+                title, content
+            )
+        };
+        fs::write(
+            source.join("components/Layout.html"),
+            "<nav-chrome><component src=\"/components/Menu.html\"></component></nav-chrome>\n<slot></slot>\n",
+        )
+        .unwrap();
+        fs::write(source.join("components/Menu.html"), "<menu-box>menu-v1</menu-box>\n").unwrap();
+        fs::write(source.join("components/Widget.html"), "<widget-box>widget-v1</widget-box>\n").unwrap();
+        fs::write(
+            source.join("pages/index.html"),
+            page("Home", "<h1>home</h1><component src=\"/components/Widget.html\"></component>"),
+        )
+        .unwrap();
+        fs::write(source.join("pages/about.html"), page("About", "<h1>about</h1>")).unwrap();
+
+        let config = Config {
+            source: source.clone(),
+            output: dir.join("out"),
+            _source_str: String::new(),
+            _output_str: String::new(),
+            components: "components".to_string(),
+            pages: "pages".to_string(),
+            _assets: String::new(),
+            root: None,
+            minify: false,
+            elements_as_is: true,
+            source_maps: false,
+            reserved_elements: Vec::new(),
+            skip_files: Vec::new(),
+            node_modules_as_is: false,
+            components_as_is: false,
+            runtime_as_is: false,
+            iterations_as_is: false,
+            no_clean: false,
+            fouc_as_is: false,
+            spa: true,
+            working_dir: dir.clone(),
+        };
+
+        let mut compiler = Compiler::new(config.clone(), false);
+        let mut parser = HtmlParser::new(config.components_path());
+        parser.load_elements().unwrap();
+        compiler.compile().unwrap();
+        compiler.generate_manifests().unwrap();
+
+        let shell_path = config.output.join("index.html");
+        let manifest_path = config.output.join("vibe-hyperspeed/index.html.manifest.js");
+        let fragment_path = config.output.join("components/vibe-spa/index.html");
+        assert!(fs::read_to_string(&shell_path).unwrap().contains("menu-v1"));
+        assert!(fs::read_to_string(&fragment_path).unwrap().contains("widget-v1"));
+
+        // Edit both a layout-subtree component and a page-content component,
+        // then mirror the watcher: invalidate the edited components + their
+        // inlining ancestors, re-run the SPA pass, refresh the shell manifest.
+        fs::write(source.join("components/Menu.html"), "<menu-box>menu-v2</menu-box>\n").unwrap();
+        fs::write(source.join("components/Widget.html"), "<widget-box>widget-v2</widget-box>\n").unwrap();
+        let stale: std::collections::HashSet<String> = [
+            "/components/Menu.html",
+            "/components/Layout.html",
+            "/components/Widget.html",
+        ]
+        .into_iter()
+        .map(String::from)
+        .collect();
+        compiler.invalidate_components(&stale);
+        compiler.compile_spa(&parser).unwrap();
+        compiler.generate_shell_manifest().unwrap();
+
+        let incremental_shell = fs::read_to_string(&shell_path).unwrap();
+        let incremental_manifest = fs::read_to_string(&manifest_path).unwrap();
+        let incremental_fragment = fs::read_to_string(&fragment_path).unwrap();
+
+        // Cold full compile of the identical source is the reference output.
+        let mut full_compiler = Compiler::new(config.clone(), false);
+        let mut full_parser = HtmlParser::new(config.components_path());
+        full_parser.load_elements().unwrap();
+        full_compiler.compile().unwrap();
+        full_compiler.generate_manifests().unwrap();
+
+        assert_eq!(incremental_shell, fs::read_to_string(&shell_path).unwrap());
+        assert_eq!(incremental_manifest, fs::read_to_string(&manifest_path).unwrap());
+        assert_eq!(incremental_fragment, fs::read_to_string(&fragment_path).unwrap());
+
+        let _ = fs::remove_dir_all(&dir);
+    }
+
+    // The SPA shell can't be value-stamped wholesale — its page state is
+    // location-dependent — but skipping the stamp entirely ships raw iteration
+    // template rows as live DOM: they animate and their inline handlers fire
+    // before the module chain defines the handler functions (the production
+    // "onNotifyAnimEnd is not defined" crash). The shell stamps SELECTIVELY:
+    // whatever resolves statically stamps exactly like a compiled page (which
+    // drops iteration template rows — the manifest restores them at runtime),
+    // while anything unresolvable — the outlet, page.* conditionals, raw
+    // attribute markers, unknown globals — stays byte-for-byte raw for the
+    // runtime, matching the unstamped shell's behavior.
+    #[test]
+    fn spa_shell_stamps_selectively() {
+        let dir = std::env::temp_dir().join("vibe-spa-selective-stamp-test");
+        let _ = fs::remove_dir_all(&dir);
+        let source = dir.join("src");
+        fs::create_dir_all(source.join("pages")).unwrap();
+        fs::create_dir_all(source.join("components")).unwrap();
+        fs::write(
+            source.join("components/Layout.html"),
+            "<notify-area>\n\
+             <!-- each notifications as n (n.id) -->\n\
+             <notify-card onanimationend=\"onEnd(n)\" kind=\"@[n.kind]\">@[n.title]</notify-card>\n\
+             <!-- /each -->\n\
+             </notify-area>\n\
+             <static-branch><!-- if 1 === 1 -->stamped-true-branch<!-- else -->stamped-false-branch<!-- /if --></static-branch>\n\
+             <route-branch><!-- if page.name === 'about' -->route-true-branch<!-- else -->route-false-branch<!-- /if --></route-branch>\n\
+             <sum-stamp>@[2 + 3]</sum-stamp>\n\
+             <raw-bind data-thing=\"@[page.name]\">@[season]</raw-bind>\n\
+             <slot></slot>\n",
+        )
+        .unwrap();
+        let page = |title: &str, content: &str| {
+            format!(
+                "<!DOCTYPE html>\n<html><head><title>{}</title></head>\n<body vibe-fouc>\
+                 <component src=\"/components/Layout.html\">{}</component></body></html>\n",
+                title, content
+            )
+        };
+        fs::write(source.join("pages/index.html"), page("Home", "<h1>home</h1>")).unwrap();
+        fs::write(source.join("pages/about.html"), page("About", "<h1>about</h1>")).unwrap();
+
+        let config = Config {
+            source: source.clone(),
+            output: dir.join("out"),
+            _source_str: String::new(),
+            _output_str: String::new(),
+            components: "components".to_string(),
+            pages: "pages".to_string(),
+            _assets: String::new(),
+            root: None,
+            minify: false,
+            elements_as_is: true,
+            source_maps: false,
+            reserved_elements: Vec::new(),
+            skip_files: Vec::new(),
+            node_modules_as_is: false,
+            components_as_is: false,
+            runtime_as_is: false,
+            iterations_as_is: false,
+            no_clean: false,
+            fouc_as_is: false,
+            spa: true,
+            working_dir: dir.clone(),
+        };
+
+        let mut compiler = Compiler::new(config.clone(), false);
+        let mut parser = HtmlParser::new(config.components_path());
+        parser.load_elements().unwrap();
+        compiler.compile().unwrap();
+        compiler.generate_manifests().unwrap();
+
+        let shell = fs::read_to_string(config.output.join("index.html")).unwrap();
+
+        // The ghost template row is gone — nothing to animate, no handler to
+        // fire — while the iteration site marker survives for the runtime.
+        assert!(!shell.contains("notify-card"), "template row should be dropped: {shell}");
+        assert!(!shell.contains("onEnd"), "template handler should be dropped");
+        assert!(shell.contains("<!-- each notifications as n (n.id) -->"), "iteration marker should stay");
+
+        // Statically resolvable content stamps like any compiled page.
+        assert!(shell.contains("stamped-true-branch"), "resolvable conditional should stamp");
+        assert!(!shell.contains("stamped-false-branch"), "untaken branch should be emptied");
+        assert!(shell.contains("<sum-stamp>5</sum-stamp>"), "resolvable binding should stamp");
+
+        // Location-dependent state stays raw: the outlet keeps its bindings,
+        // page.* conditionals keep BOTH branches, unresolved attribute markers
+        // and unknown-global text bindings are untouched.
+        assert!(shell.contains(r#"src="@[page.src]""#), "outlet src must stay raw");
+        assert!(shell.contains(r#"key="@[page.path]""#), "outlet key must stay raw");
+        assert!(
+            shell.contains("route-true-branch") && shell.contains("route-false-branch"),
+            "page-dependent conditional must keep both branches raw"
+        );
+        assert!(shell.contains(r#"data-thing="@[page.name]""#), "unresolved attribute must not be stripped");
+        assert!(shell.contains("@[season]"), "unknown-global binding must stay raw");
+
+        let _ = fs::remove_dir_all(&dir);
+    }
+
     fn manifest_test_project(name: &str) -> (Config, PathBuf, PathBuf, PathBuf) {
         let dir = std::env::temp_dir().join(format!("vibe_{}_test", name));
         let _ = fs::remove_dir_all(&dir);

package/src/compiler/js_analyzer.rs

@@ -372,10 +372,14 @@ impl StateExtractor {
             // String literal: "hello"
             Expr::Lit(Lit::Str(s)) => Some(Value::String(s.value.to_string())),
 
-            // Number literal: 42
+            // Number literal: 42 — swc carries every numeric as f64; integral
+            // values must resolve to JSON integers or stamping paints "0.0".
             Expr::Lit(Lit::Num(n)) => {
-                serde_json::Number::from_f64(n.value)
-                    .map(Value::Number)
+                if n.value.fract() == 0.0 && n.value.abs() <= i64::MAX as f64 {
+                    Some(Value::Number(serde_json::Number::from(n.value as i64)))
+                } else {
+                    serde_json::Number::from_f64(n.value).map(Value::Number)
+                }
             }
 
             // Boolean literal: true/false
@@ -447,8 +451,10 @@ impl StateExtractor {
             }
         }
 
-        // Return partial object even if some properties couldn't be resolved
-        if result.is_empty() {
+        // Return partial object even if some properties couldn't be resolved.
+        // An authored-empty literal ({}) IS the resolved value — only a
+        // non-empty literal where nothing resolved counts as unresolvable.
+        if result.is_empty() && !obj.props.is_empty() {
             None
         } else {
             Some(Value::Object(result))
@@ -481,8 +487,10 @@ impl StateExtractor {
             }
         }
 
-        // Return partial array even if some elements couldn't be resolved
-        if result.is_empty() {
+        // Return partial array even if some elements couldn't be resolved.
+        // An authored-empty literal ([]) IS the resolved value — only a
+        // non-empty literal where nothing resolved counts as unresolvable.
+        if result.is_empty() && !arr.elems.is_empty() {
             None
         } else {
             Some(Value::Array(result))
@@ -603,7 +611,12 @@ mod tests {
 
     #[test]
     fn test_import_resolution() {
-        let mut analyzer = JsAnalyzer::new(PathBuf::from("/tmp"));
+        let dir = std::env::temp_dir().join("vibe_import_resolution_test");
+        let _ = fs::remove_dir_all(&dir);
+        fs::create_dir_all(&dir).unwrap();
+        fs::write(dir.join("test-import.js"), "export const data = { a: 1, b: 2 };\n").unwrap();
+
+        let mut analyzer = JsAnalyzer::new(dir.clone());
         let script = r#"
             import { data } from './test-import.js';
             vibe({ ...data, c: 3 });
@@ -613,6 +626,8 @@ mod tests {
         assert_eq!(state["a"].as_f64().unwrap(), 1.0);
         assert_eq!(state["b"].as_f64().unwrap(), 2.0);
         assert_eq!(state["c"].as_f64().unwrap(), 3.0);
+
+        let _ = fs::remove_dir_all(&dir);
     }
 
     #[test]
@@ -674,7 +689,16 @@ mod tests {
 
     #[test]
     fn test_absolute_path_import() {
-        let mut analyzer = JsAnalyzer::new(PathBuf::from("/tmp"));
+        let dir = std::env::temp_dir().join("vibe_absolute_import_test");
+        let _ = fs::remove_dir_all(&dir);
+        fs::create_dir_all(&dir).unwrap();
+        fs::write(
+            dir.join("test-data.js"),
+            "export const menuState = { menuSections: [], other: \"value\" };\n",
+        )
+        .unwrap();
+
+        let mut analyzer = JsAnalyzer::new(dir.clone());
         let script = r#"
             import { menuState } from '/test-data.js';
             vibe({ ...menuState, extra: "value" });
@@ -686,6 +710,8 @@ mod tests {
         assert!(state["menuSections"].is_array(), "menuSections should be an array");
         assert_eq!(state["other"].as_str().unwrap(), "value");
         assert_eq!(state["extra"].as_str().unwrap(), "value");
+
+        let _ = fs::remove_dir_all(&dir);
     }
 
     #[test]

package/src/compiler/value_stamper.rs

@@ -71,6 +71,11 @@ pub struct ValueStamper<'a> {
     /// one of these keys is stamped from here — never a compound expression — so
     /// there is no risk of a dynamic operand leaking into the value.
     constant_texts: HashMap<String, String>,
+    /// Selective mode (the SPA shell): unresolvable state is runtime-owned, so
+    /// unresolved attribute markers are kept instead of stripped and a
+    /// conditional whose expression reads an unknown root stays raw (both
+    /// branches) instead of stamping to its else branch.
+    selective: bool,
 }
 
 impl<'a> ValueStamper<'a> {
@@ -114,9 +119,15 @@ impl<'a> ValueStamper<'a> {
             context,
             components_as_is,
             constant_texts,
+            selective: false,
         })
     }
 
+    pub fn selective(mut self, selective: bool) -> Self {
+        self.selective = selective;
+        self
+    }
+
     pub fn stamp_html(&self, html: String) -> Result<String, String> {
         // Extract vibe-dehydrate content to protect it from processing
         // This prevents @[...] markers and iterations/conditionals from being processed
@@ -215,8 +226,12 @@ impl<'a> ValueStamper<'a> {
         // Add remaining text
         result.push_str(&html[last_pos..]);
 
-        // Clean up attributes that still contain unresolved markers
-        result = self.cleanup_unresolved_attributes(result);
+        // Clean up attributes that still contain unresolved markers. Selective
+        // mode keeps them: an unresolved marker there is runtime-owned state
+        // (the outlet's `src="@[page.src]"`), not an absent iteration property.
+        if !self.selective {
+            result = self.cleanup_unresolved_attributes(result);
+        }
 
         // Restore vibe-dehydrate content from placeholders
         for (i, content) in dehydrate_placeholders.iter().enumerate() {
@@ -312,7 +327,8 @@ impl<'a> ValueStamper<'a> {
 
                     // Create temp stamper with merged state for this iteration
                     let temp_stamper = ValueStamper::new(&merged_state, false)
-                        .map_err(|e| format!("Failed to create stamper for iteration: {}", e))?;
+                        .map_err(|e| format!("Failed to create stamper for iteration: {}", e))?
+                        .selective(self.selective);
 
                     // Render nested iterations first
                     let mut item_html = temp_stamper.render_iterations_recursive(template.clone())?;
@@ -651,6 +667,47 @@ impl<'a> ValueStamper<'a> {
     }
 
     fn try_eval_condition(&self, condition: &str) -> Option<bool> {
+        // Selective mode: a condition that reads a root the stamp state does
+        // not know (page.*, runtime-merged globals) must stay raw — stamping
+        // it to the else branch would pre-paint the wrong branch for state the
+        // runtime owns. Evaluate inside a `with` over a proxy that throws a
+        // marker on unknown roots; the marker means "keep raw" (None), while
+        // known-state conditions keep the exact semantics of the plain path.
+        if self.selective {
+            return self.context.with(|ctx| -> Option<bool> {
+                let probe = format!(
+                    "if (!globalThis.__vibeStrictScope) {{
+                        globalThis.__vibeStrictScope = new Proxy({{}}, {{
+                            has: function() {{ return true; }},
+                            get: function(t, k) {{
+                                if (typeof k !== 'string') return undefined;
+                                if (k in $) return $[k];
+                                if (k in globalThis) return globalThis[k];
+                                throw new Error('__VIBE_UNRESOLVED__');
+                            }},
+                        }});
+                    }}
+                    (function() {{
+                        try {{
+                            // `with` is illegal in strict-mode eval; a Function
+                            // constructor body is sloppy by spec, so the scope
+                            // proxy works there.
+                            return new Function('__scope', 'with (__scope) {{ return !!({}); }}')(globalThis.__vibeStrictScope);
+                        }} catch (e) {{
+                            return e && e.message === '__VIBE_UNRESOLVED__' ? '__VIBE_UNRESOLVED__' : false;
+                        }}
+                    }})()",
+                    condition.replace('\\', "\\\\").replace('\'', "\\'")
+                );
+                let result: rquickjs::Value = ctx.eval(probe.as_str()).ok()?;
+                if result.is_bool() {
+                    return result.as_bool();
+                }
+                // The marker string: an unknown root — keep the block raw.
+                None
+            });
+        }
+
         self.context.with(|ctx| -> Option<bool> {
             // Try to evaluate condition
             let result: rquickjs::Value = match ctx.eval(condition) {
@@ -746,6 +803,10 @@ impl<'a> ValueStamper<'a> {
             } else if attr_value.is_empty() {
                 // Convert boolean attributes with empty values to short form: `demo=""` -> `demo`
                 format!(" {}", &caps[1])
+            } else if *attr_value == *"true" {
+                // Normalize to HTML5 boolean attribute syntax: `disabled="true"` -> `disabled=""`
+                // (matches the runtime, where a truthy pure binding sets the attribute, not the string)
+                format!(" {}=\"\"", &caps[1])
             } else {
                 // Keep the attribute as-is
                 caps[0].to_string()
@@ -950,6 +1011,35 @@ mod tests {
         assert_eq!(result, r#"<input readonly="">"#);
     }
 
+    // Selective mode (the SPA shell): unresolved attribute markers are
+    // runtime-owned bindings, not absent iteration properties — kept raw.
+    #[test]
+    fn selective_keeps_unresolved_attribute_markers() {
+        let state = json!({ "known": "yes" });
+        let stamper = ValueStamper::new(&state, false).unwrap().selective(true);
+        let html = String::from(r#"<component src="@[page.src]" key="@[page.path]" title="@[known]"></component>"#);
+        let result = stamper.stamp_html(html).unwrap();
+        assert!(result.contains(r#"src="@[page.src]""#), "got: {result}");
+        assert!(result.contains(r#"key="@[page.path]""#), "got: {result}");
+        assert!(result.contains(r#"title="yes""#), "got: {result}");
+    }
+
+    // Selective mode: a conditional reading an unknown root stays raw (both
+    // branches, all markers) — the runtime owns that state. Known-root and
+    // static conditionals stamp exactly like the plain path.
+    #[test]
+    fn selective_conditionals_stamp_only_known_roots() {
+        let state = json!({ "flag": true });
+        let stamper = ValueStamper::new(&state, false).unwrap().selective(true);
+        let html = String::from(
+            "<a><!-- if page.name === 'about' -->route-yes<!-- else -->route-no<!-- /if --></a>\
+             <b><!-- if flag -->flag-yes<!-- else -->flag-no<!-- /if --></b>",
+        );
+        let result = stamper.stamp_html(html).unwrap();
+        assert!(result.contains("route-yes") && result.contains("route-no"), "got: {result}");
+        assert!(result.contains("flag-yes") && !result.contains("flag-no"), "got: {result}");
+    }
+
     fn constants(pairs: &[(&str, Value)]) -> Map<String, Value> {
         pairs.iter().map(|(k, v)| (k.to_string(), v.clone())).collect()
     }
@@ -986,3 +1076,4 @@ mod tests {
         assert!(!result.contains("0.1.5"), "constant leaked into compound: {result}");
     }
 }
+