@ape-egg/vibe-compiler 3.0.0 → 3.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ape-egg/vibe-compiler",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "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.1"
 dependencies = [
  "clap",
  "colored",

package/src/Cargo.toml

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

package/src/compiler/compile.rs

@@ -1516,6 +1516,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();
@@ -2831,6 +2841,111 @@ 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);
+    }
+
     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);