@ape-egg/vibe 2.1.22 → 3.0.0

package/compiler/src/compiler/watcher.rs

@@ -1,1147 +0,0 @@
-use std::collections::{HashMap, HashSet};
-use std::path::{Path, PathBuf};
-use std::sync::mpsc::channel;
-use std::time::Duration;
-use colored::Colorize;
-use notify_debouncer_full::{new_debouncer, notify::{RecursiveMode, Watcher}};
-use regex::Regex;
-
-use super::{Compiler, compile::should_skip_path};
-use crate::config::Config;
-
-/// Tracks which pages and components depend on which components
-pub struct DependencyGraph {
-    /// component path -> set of page paths that use it
-    component_to_pages: HashMap<PathBuf, HashSet<PathBuf>>,
-    /// component path -> set of component paths that use it (for transitive dependencies)
-    component_to_components: HashMap<PathBuf, HashSet<PathBuf>>,
-    /// page path -> set of component paths it uses
-    page_to_components: HashMap<PathBuf, HashSet<PathBuf>>,
-    /// component path -> set of component paths it uses (forward edges, so a
-    /// component's own deps can be cleared on refresh — the mirror of
-    /// component_to_components)
-    component_to_used_components: HashMap<PathBuf, HashSet<PathBuf>>,
-}
-
-impl DependencyGraph {
-    pub fn new() -> Self {
-        Self {
-            component_to_pages: HashMap::new(),
-            component_to_components: HashMap::new(),
-            page_to_components: HashMap::new(),
-            component_to_used_components: HashMap::new(),
-        }
-    }
-
-    /// Add a dependency: file (page or component) uses component
-    pub fn add_dependency(&mut self, file: PathBuf, component: PathBuf, file_is_component: bool) {
-        if file_is_component {
-            // Component uses another component
-            self.component_to_components
-                .entry(component.clone())
-                .or_insert_with(HashSet::new)
-                .insert(file.clone());
-
-            self.component_to_used_components
-                .entry(file)
-                .or_insert_with(HashSet::new)
-                .insert(component);
-        } else {
-            // Page uses component
-            self.component_to_pages
-                .entry(component.clone())
-                .or_insert_with(HashSet::new)
-                .insert(file.clone());
-
-            self.page_to_components
-                .entry(file)
-                .or_insert_with(HashSet::new)
-                .insert(component);
-        }
-    }
-
-    /// Replace `file`'s outgoing dependency edges with `deps`. Works for both
-    /// pages and components, so a newly-added `<component src>` reference (or a
-    /// removed one) is learned the moment the referrer is saved. This is what lets
-    /// the watcher pick up files created mid-session: referencing a new component
-    /// always means editing a referrer, and that edit refreshes the graph here.
-    pub fn refresh_file(&mut self, file: &Path, deps: HashSet<PathBuf>, file_is_component: bool) {
-        // Clear the file's old outgoing edges (and their reverse entries) so a
-        // dependency it no longer uses stops mapping back to it.
-        let forward = if file_is_component {
-            &mut self.component_to_used_components
-        } else {
-            &mut self.page_to_components
-        };
-
-        if let Some(old_deps) = forward.remove(file) {
-            let reverse = if file_is_component {
-                &mut self.component_to_components
-            } else {
-                &mut self.component_to_pages
-            };
-            for dep in old_deps {
-                if let Some(users) = reverse.get_mut(&dep) {
-                    users.remove(file);
-                }
-            }
-        }
-
-        // Add the current edges.
-        for dep in deps {
-            self.add_dependency(file.to_path_buf(), dep, file_is_component);
-        }
-    }
-
-    /// Get all pages that transitively depend on a component (includes component -> component -> page chains)
-    pub fn get_all_dependent_pages(&self, component: &Path) -> HashSet<PathBuf> {
-        let mut all_pages = HashSet::new();
-        let mut visited_components = HashSet::new();
-        self.collect_dependent_pages(component, &mut all_pages, &mut visited_components);
-        all_pages
-    }
-
-    fn collect_dependent_pages(
-        &self,
-        component: &Path,
-        all_pages: &mut HashSet<PathBuf>,
-        visited: &mut HashSet<PathBuf>,
-    ) {
-        // Avoid infinite loops in circular dependencies
-        if !visited.insert(component.to_path_buf()) {
-            return;
-        }
-
-        // Add pages that directly use this component
-        if let Some(pages) = self.component_to_pages.get(component) {
-            all_pages.extend(pages.iter().cloned());
-        }
-
-        // Recursively add pages that use components that use this component
-        if let Some(dependent_components) = self.component_to_components.get(component) {
-            for dep_component in dependent_components {
-                self.collect_dependent_pages(dep_component, all_pages, visited);
-            }
-        }
-    }
-
-    /// Get the edited component itself plus every component that transitively
-    /// inlines it. These are exactly the component caches that go stale on an
-    /// edit: a parent's cached content is the *fully inlined* child, so when the
-    /// child changes the parent's cache is stale too. Unrelated components keep
-    /// their cache. The returned set always includes `component` itself.
-    pub fn get_all_dependent_components(&self, component: &Path) -> HashSet<PathBuf> {
-        let mut all = HashSet::new();
-        self.collect_dependent_components(component, &mut all);
-        all
-    }
-
-    fn collect_dependent_components(&self, component: &Path, all: &mut HashSet<PathBuf>) {
-        // insert() == false → already seen: doubles as the cycle guard.
-        if !all.insert(component.to_path_buf()) {
-            return;
-        }
-
-        if let Some(users) = self.component_to_components.get(component) {
-            for user in users {
-                self.collect_dependent_components(user, all);
-            }
-        }
-    }
-}
-
-/// Extract component references from HTML content
-pub fn extract_component_dependencies(html: &str, components_dir: &Path) -> HashSet<PathBuf> {
-    let mut deps = HashSet::new();
-
-    // 1. <component src="/components/card.html"> - works in both compiled and runtime modes
-    let component_tag_re = Regex::new(r#"<component\s+[^>]*src=["']([^"']+)["']"#).unwrap();
-    for cap in component_tag_re.captures_iter(html) {
-        if let Some(src) = cap.get(1) {
-            let src_path = src.as_str().trim_start_matches('/');
-            deps.insert(PathBuf::from(src_path));
-        }
-    }
-
-    // 2. Custom elements: <UserCard> -> /components/user-card.html
-    let custom_element_re = Regex::new(r"<([A-Z][a-zA-Z0-9]*)[\s>]").unwrap();
-    for cap in custom_element_re.captures_iter(html) {
-        if let Some(tag) = cap.get(1) {
-            let kebab = to_kebab_case(tag.as_str());
-            let component_path = components_dir.join(format!("{}.html", kebab));
-            // Store relative to source root
-            if let Ok(rel_path) = component_path.strip_prefix("/") {
-                deps.insert(rel_path.to_path_buf());
-            } else {
-                deps.insert(component_path);
-            }
-        }
-    }
-
-    deps
-}
-
-/// Convert PascalCase to kebab-case
-fn to_kebab_case(s: &str) -> String {
-    let mut result = String::new();
-    for (i, ch) in s.chars().enumerate() {
-        if ch.is_uppercase() && i > 0 {
-            result.push('-');
-        }
-        result.push(ch.to_ascii_lowercase());
-    }
-    result
-}
-
-/// Map a component's source path to the normalized key under which its inlined
-/// content is cached (e.g. `/components/Sidebar.html`). The cache key is the
-/// component's path relative to the source root, with a leading slash — the same
-/// form `<component src>` resolves to. Returns None for paths outside the source
-/// root (e.g. external URL components, which never go stale on a local edit).
-fn component_cache_key(component: &Path, canonical_source: &Path) -> Option<String> {
-    component
-        .strip_prefix(canonical_source)
-        .ok()
-        .and_then(|rel| rel.to_str())
-        .map(|rel| format!("/{}", rel.replace('\\', "/")))
-}
-
-/// Cross-process guard: exactly one `vibe compile --watch` per output
-/// directory. Two concurrent watchers double-compile every save and race each
-/// other's output writes — the loser reads a torn file back and emits a
-/// valid-but-empty manifest, so the page hydrates blank with no errors. The
-/// lock lives in the OS temp dir keyed by the output path, holds the owner's
-/// pid, and a lock whose process is gone is stolen (a killed watcher never
-/// unwinds, so Drop alone can't be trusted to clean up).
-#[derive(Debug)]
-pub struct WatchLock {
-    path: PathBuf,
-}
-
-impl WatchLock {
-    /// Deterministic lock path for an output dir, stable whether or not the
-    /// output exists yet: canonicalize the output itself when possible, else
-    /// its (existing) parent — so a watcher that locked before the first
-    /// compile created the output still collides with one that locked after.
-    fn lock_path_for(output: &Path) -> PathBuf {
-        use std::collections::hash_map::DefaultHasher;
-        use std::hash::{Hash, Hasher};
-
-        let canonical = output.canonicalize().unwrap_or_else(|_| {
-            let parent = output.parent().filter(|p| !p.as_os_str().is_empty()).unwrap_or(Path::new("."));
-            let name = output.file_name().map(PathBuf::from).unwrap_or_default();
-            parent
-                .canonicalize()
-                .unwrap_or_else(|_| parent.to_path_buf())
-                .join(name)
-        });
-
-        let mut hasher = DefaultHasher::new();
-        canonical.hash(&mut hasher);
-        std::env::temp_dir().join(format!("vibe-watch-{:016x}.lock", hasher.finish()))
-    }
-
-    pub fn acquire(output: &Path) -> Result<Self, String> {
-        let path = Self::lock_path_for(output);
-
-        // Two attempts: the second runs only after a stale lock was removed.
-        for _ in 0..2 {
-            match std::fs::OpenOptions::new().write(true).create_new(true).open(&path) {
-                Ok(mut file) => {
-                    use std::io::Write;
-                    let _ = write!(file, "{}", std::process::id());
-                    return Ok(Self { path });
-                }
-                Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => {
-                    let holder = std::fs::read_to_string(&path)
-                        .ok()
-                        .and_then(|s| s.trim().parse::<u32>().ok());
-                    match holder {
-                        Some(pid) if process_alive(pid) => {
-                            return Err(format!(
-                                "another `vibe compile --watch` (pid {}) is already watching this output directory. \
-                                 Concurrent watchers race each other's writes and corrupt manifests — stop the other one first. \
-                                 (lock: {})",
-                                pid,
-                                path.display()
-                            ));
-                        }
-                        // Dead owner or unreadable lock: stale, steal it.
-                        _ => {
-                            let _ = std::fs::remove_file(&path);
-                        }
-                    }
-                }
-                Err(e) => {
-                    return Err(format!(
-                        "failed to create watch lock {}: {}",
-                        path.display(),
-                        e
-                    ));
-                }
-            }
-        }
-
-        Err(format!(
-            "could not acquire watch lock {} — still held after stale-lock cleanup",
-            path.display()
-        ))
-    }
-}
-
-impl Drop for WatchLock {
-    fn drop(&mut self) {
-        let _ = std::fs::remove_file(&self.path);
-    }
-}
-
-#[cfg(unix)]
-fn process_alive(pid: u32) -> bool {
-    std::process::Command::new("kill")
-        .arg("-0")
-        .arg(pid.to_string())
-        .stdout(std::process::Stdio::null())
-        .stderr(std::process::Stdio::null())
-        .status()
-        .map(|s| s.success())
-        .unwrap_or(false)
-}
-
-/// Without a portable liveness probe, treat an existing lock as live — failing
-/// loudly (with the lock path in the message) beats silently racing.
-#[cfg(not(unix))]
-fn process_alive(_pid: u32) -> bool {
-    true
-}
-
-/// Check if a path should be blacklisted based on SKIP_FILES patterns
-/// This checks both the filename and all path components relative to source root
-fn is_path_blacklisted(path: &Path, source_root: &Path, skip_files: &[String]) -> bool {
-    let file_name = path.file_name().and_then(|n| n.to_str()).unwrap_or("");
-
-    // Check filename against blacklist
-    if should_skip_path(path, file_name, skip_files) {
-        return true;
-    }
-
-    // Check if any path component (relative to source) matches blacklist
-    if let Ok(relative) = path.strip_prefix(source_root) {
-        for component in relative.components() {
-            if let Some(component_str) = component.as_os_str().to_str() {
-                if should_skip_path(path, component_str, skip_files) {
-                    return true;
-                }
-            }
-        }
-    }
-
-    false
-}
-
-/// Build dependency graph by scanning all HTML files
-pub fn build_dependency_graph(config: &Config) -> std::result::Result<DependencyGraph, std::io::Error> {
-    let mut graph = DependencyGraph::new();
-
-    // Canonicalize output path for reliable comparison
-    let canonical_output = config.output.canonicalize()
-        .unwrap_or_else(|_| config.output.clone());
-
-    // Scan all HTML files in source directory
-    scan_directory(&config.source, &config.source, &config.components, &canonical_output, &config.skip_files, &mut graph)?;
-
-    Ok(graph)
-}
-
-fn scan_directory(
-    dir: &Path,
-    source_root: &Path,
-    components_dir: &str,
-    output_dir: &Path,
-    skip_files: &[String],
-    graph: &mut DependencyGraph,
-) -> std::result::Result<(), std::io::Error> {
-    if !dir.is_dir() {
-        return Ok(());
-    }
-
-    let components_path = source_root.join(components_dir);
-
-    for entry in std::fs::read_dir(dir)? {
-        let entry = entry?;
-        let path = entry.path();
-        let file_name = path.file_name().and_then(|n| n.to_str()).unwrap_or("");
-
-        if path.is_dir() {
-            // Skip output directory (dynamically check, not hardcoded "compiled")
-            let canonical_path = path.canonicalize().unwrap_or_else(|_| path.clone());
-            if canonical_path.starts_with(output_dir) {
-                continue;
-            }
-
-            // Skip directories using shared skip logic
-            if should_skip_path(&path, file_name, skip_files) {
-                continue;
-            }
-
-            scan_directory(&path, source_root, components_dir, output_dir, skip_files, graph)?;
-        } else if let Some(ext) = path.extension() {
-            if ext == "html" {
-                let html = std::fs::read_to_string(&path)?;
-                let deps = extract_component_dependencies(&html, &components_path);
-
-                // Check if this file is itself a component
-                let file_is_component = path.starts_with(&components_path);
-
-                for dep in deps {
-                    let dep_absolute = source_root.join(&dep);
-                    // Canonicalize to handle case-insensitive filesystems (macOS)
-                    let dep_canonical = dep_absolute.canonicalize().unwrap_or(dep_absolute);
-                    graph.add_dependency(path.clone(), dep_canonical, file_is_component);
-                }
-            }
-        }
-    }
-
-    Ok(())
-}
-
-/// A watcher whose spawning wrapper dies without unwinding (SIGKILL, crashed
-/// dev server) is orphaned: it keeps watching and its lock blocks every future
-/// `--watch` on the same output. Reparenting is the orphan signal — when the
-/// parent pid changes (to init or a reaper), the owner is gone, so release the
-/// lock and exit. `std::process::exit` skips Drop, hence the explicit remove.
-#[cfg(unix)]
-fn exit_when_orphaned(lock_path: PathBuf) {
-    let parent = std::os::unix::process::parent_id();
-    std::thread::spawn(move || loop {
-        std::thread::sleep(Duration::from_secs(2));
-        if std::os::unix::process::parent_id() != parent {
-            eprintln!("parent process exited — shutting down watcher");
-            let _ = std::fs::remove_file(&lock_path);
-            std::process::exit(0);
-        }
-    });
-}
-
-#[cfg(not(unix))]
-fn exit_when_orphaned(_lock_path: PathBuf) {}
-
-/// Start watching for file changes
-pub fn watch(config: Config, verbose: bool) -> std::result::Result<(), Box<dyn std::error::Error>> {
-    // Held for the watcher's whole lifetime; a second watcher on the same
-    // output exits loudly instead of silently racing this one.
-    let _watch_lock = WatchLock::acquire(&config.output)?;
-    exit_when_orphaned(_watch_lock.path.clone());
-
-    println!("{}", "Building dependency graph...".cyan());
-    let mut graph = build_dependency_graph(&config)?;
-
-    println!("{}", "Running initial compilation...".cyan());
-    let mut compiler = Compiler::new(config.clone(), verbose);
-
-    match compiler.compile() {
-        Ok(stats) => {
-            // Generate manifests BEFORE showing success (unless runtime-as-is is enabled)
-            let mut manifest_time_ms = 0.0;
-            let mut manifest_stats_result = None;
-            if !config.runtime_as_is {
-                match compiler.generate_manifests() {
-                    Ok(manifest_stats) => {
-                        manifest_time_ms = manifest_stats.total_time_ms;
-                        manifest_stats_result = Some(manifest_stats);
-                    }
-                    Err(e) => {
-                        eprintln!("\n{}: Manifest generation failed: {}", "Warning".yellow(), e);
-                        eprintln!("Compilation succeeded but manifests were not generated.");
-                    }
-                }
-            }
-
-            // Show success headline
-            println!("\n{}", "Initial compilation complete!".green().bold());
-            println!();
-
-            // Show individual phase timings (same as main.rs output)
-
-            // Show validation time if it happened
-            if let Some(validation_time) = stats.validation_time_ms {
-                println!("* Validated components in {:.0}ms", validation_time);
-            }
-
-            let total_components_unique = stats.internal_components_unique + stats.external_components_unique;
-
-            // Always show components line
-            if stats.components_as_is {
-                println!("* Compiled components (0 internal, 0 external) - \"components-as-is\": true");
-            } else if total_components_unique > 0 {
-                println!("* Compiled components ({} internal, {} external) in {:.0}ms",
-                    stats.internal_components_unique,
-                    stats.external_components_unique,
-                    stats.components_time_ms
-                );
-            }
-
-            if stats.files_compiled > 0 {
-                println!("* Compiled HTML ({} file{}) in {:.0}ms",
-                    stats.files_compiled,
-                    if stats.files_compiled == 1 { "" } else { "s" },
-                    stats.compile_time_ms
-                );
-            }
-
-            // Show manifest stats between HTML and Copied files
-            if let Some(manifest_stats) = manifest_stats_result {
-                println!("* Generated manifests ({} file{}, {} skipped) in {:.0}ms",
-                    manifest_stats.pages_processed,
-                    if manifest_stats.pages_processed == 1 { "" } else { "s" },
-                    manifest_stats.pages_skipped,
-                    manifest_stats.total_time_ms
-                );
-            }
-
-            if stats.files_copied > 0 {
-                println!("* Copied files ({} file{}) in {:.0}ms",
-                    stats.files_copied,
-                    if stats.files_copied == 1 { "" } else { "s" },
-                    stats.copy_time_ms
-                );
-            }
-
-            // Show node_modules handling
-            if let Some(nm_time) = stats.node_modules_time_ms {
-                if stats.node_modules_copied_as_is {
-                    println!("* copied node_modules in {:.0}ms", nm_time);
-                } else if let Some(ref pkg_manager) = stats.package_manager {
-                    println!("* {} install in {:.0}ms", pkg_manager, nm_time);
-                }
-            }
-
-            // Calculate total duration as sum of all individual operations
-            let total_duration_ms = stats.validation_time_ms.unwrap_or(0.0)
-                + stats.components_time_ms
-                + stats.compile_time_ms
-                + stats.copy_time_ms
-                + stats.node_modules_time_ms.unwrap_or(0.0)
-                + manifest_time_ms;
-
-            println!("\n{} in {:.0}ms", "Compiled".green(), total_duration_ms);
-            println!();
-        }
-        Err(e) => {
-            eprintln!("{}: {}", "Error".red(), e);
-            eprintln!("Fix the errors and save to retry.");
-            println!();
-        }
-    }
-
-    println!("{}", "Watching for changes... (Ctrl+C to stop)".cyan());
-    println!();
-
-    // Canonicalize output path for reliable comparison
-    let canonical_output = config.output.canonicalize()
-        .unwrap_or_else(|_| config.output.clone());
-    // Canonical source root: dependency-graph paths are canonical, so map them to
-    // cache keys against the same base.
-    let canonical_source = config.source.canonicalize()
-        .unwrap_or_else(|_| config.source.clone());
-
-    // Keep compiler and parser alive to reuse component cache across incremental compilations
-    let mut watch_compiler = Compiler::new(config.clone(), false);
-    // Carry the initial compile's warm component cache into the watcher so the
-    // first edit is already incremental (only the edited subtree re-expands).
-    watch_compiler.adopt_component_cache(&mut compiler);
-    let mut parser = {
-        use crate::parser::HtmlParser;
-        let mut p = HtmlParser::new(config.components_path());
-        if let Err(e) = p.load_elements() {
-            eprintln!("{}: Failed to load parser: {}", "Error".red(), e);
-            return Err(Box::new(e));
-        }
-        p
-    };
-
-    let (tx, rx) = channel();
-    let mut debouncer = new_debouncer(Duration::from_millis(100), None, tx)?;
-
-    debouncer.watcher().watch(&config.source, RecursiveMode::Recursive)?;
-
-    loop {
-        match rx.recv() {
-            Ok(result) => {
-                match result {
-                    Ok(events) => {
-                        // Collect unique paths from events
-                        let mut changed_paths: HashSet<PathBuf> = HashSet::new();
-
-                        for event in events {
-                            for path in &event.paths {
-                                // Skip blacklisted files/directories (check entire path, not just filename)
-                                if is_path_blacklisted(path, &config.source, &config.skip_files) {
-                                    continue;
-                                }
-
-                                if let Some(ext) = path.extension() {
-                                    if ext == "html" || ext == "css" || ext == "js" {
-                                        changed_paths.insert(path.clone());
-                                    }
-                                }
-                            }
-                        }
-
-                        if changed_paths.is_empty() {
-                            continue;
-                        }
-
-                        // Determine what needs recompiling
-                        let mut pages_to_recompile: HashSet<PathBuf> = HashSet::new();
-                        // Component caches that go stale this batch: each edited
-                        // component plus the ancestors that inline it. Everything
-                        // else stays cached and is reused.
-                        let mut stale_component_keys: HashSet<String> = HashSet::new();
-                        // Changed component files to re-mirror into the output —
-                        // runtime-fetched components are served from that mirror,
-                        // so it must track every edit/deletion even when no page
-                        // inlines the component (zero graph dependents).
-                        let mut components_to_mirror: Vec<PathBuf> = Vec::new();
-
-                        for path in &changed_paths {
-                            // Skip files in output directory (avoid infinite loop)
-                            let canonical_path = path.canonicalize().unwrap_or_else(|_| path.clone());
-                            if canonical_path.starts_with(&canonical_output) {
-                                continue;
-                            }
-
-                            // Skip blacklisted files/directories
-                            if is_path_blacklisted(path, &config.source, &config.skip_files) {
-                                continue;
-                            }
-
-                            let relative_path = path.strip_prefix(&config.source)
-                                .unwrap_or(path);
-
-                            // Check if it's a component
-                            if path.starts_with(&config.source.join(&config.components)) {
-                                // Component changed - recompile all transitively dependent pages
-                                // Canonicalize to match how dependencies were stored (handles case sensitivity)
-                                let path_canonical = path.canonicalize().unwrap_or_else(|_| path.clone());
-
-                                // The output's components mirror tracks every change,
-                                // dependents or not: a component nothing inlines is
-                                // still fetched from the mirror at runtime
-                                // (`<component src="@[page.src]">`, iter-prop roots).
-                                if path.exists() {
-                                    println!("{} {} changed", "[watch]".cyan(), relative_path.display());
-                                } else {
-                                    println!("{} {} deleted", "[watch]".yellow(), relative_path.display());
-                                }
-                                components_to_mirror.push(path.clone());
-
-                                // Refresh this component's own dependency edges so a
-                                // newly-added <component src> (e.g. a child file created
-                                // mid-session) is learned. Without this the new child maps
-                                // to zero dependent pages and editing it is a silent no-op.
-                                if path.exists() {
-                                    if let Ok(html) = std::fs::read_to_string(path) {
-                                        let components_path = config.source.join(&config.components);
-                                        let deps: HashSet<PathBuf> =
-                                            extract_component_dependencies(&html, &components_path)
-                                                .into_iter()
-                                                .map(|dep| {
-                                                    let dep_absolute = config.source.join(&dep);
-                                                    dep_absolute.canonicalize().unwrap_or(dep_absolute)
-                                                })
-                                                .collect();
-                                        graph.refresh_file(path, deps, true);
-                                    }
-                                }
-
-                                let dependent_pages = graph.get_all_dependent_pages(&path_canonical);
-                                if !dependent_pages.is_empty() {
-                                    // Invalidate only the edited component and the
-                                    // components whose cached inlined content embeds it
-                                    // (its ancestors). Every other component stays cached,
-                                    // so each affected page re-expands just the changed
-                                    // subtree instead of its whole component tree.
-                                    for stale in graph.get_all_dependent_components(&path_canonical) {
-                                        if let Some(key) = component_cache_key(&stale, &canonical_source) {
-                                            stale_component_keys.insert(key);
-                                        }
-                                    }
-
-                                    // Reload the changed component in the parser's element cache
-                                    // (used for custom element syntax like <Layout>)
-                                    if path.exists() {
-                                        let _ = parser.reload_element(path);
-                                    }
-
-                                    pages_to_recompile.extend(dependent_pages);
-                                }
-                            } else if let Some(ext) = path.extension() {
-                                if ext == "html" {
-                                    // Check if file still exists (handle deletions)
-                                    if !path.exists() {
-                                        // File was deleted - clean up dependency graph
-                                        println!("{} {} deleted", "[watch]".yellow(), relative_path.display());
-
-                                        if let Some(old_deps) = graph.page_to_components.remove(path) {
-                                            for dep in old_deps {
-                                                if let Some(pages) = graph.component_to_pages.get_mut(&dep) {
-                                                    pages.remove(path);
-                                                }
-                                            }
-                                        }
-
-                                        // Delete corresponding compiled output
-                                        let output_path = canonical_output.join(relative_path);
-                                        if output_path.exists() {
-                                            if let Err(e) = std::fs::remove_file(&output_path) {
-                                                eprintln!("{}: Failed to delete {}: {}", "Warning".yellow(), output_path.display(), e);
-                                            }
-                                        }
-
-                                        // Delete corresponding manifest
-                                        let manifest_path = canonical_output.join("vibe-hyperspeed").join(format!("{}.manifest.js", relative_path.display()));
-                                        if manifest_path.exists() {
-                                            if let Err(e) = std::fs::remove_file(&manifest_path) {
-                                                eprintln!("{}: Failed to delete manifest {}: {}", "Warning".yellow(), manifest_path.display(), e);
-                                            }
-                                        }
-
-                                        continue;
-                                    }
-
-                                    // Page changed - recompile just this page
-                                    println!("{} {} changed", "[watch]".cyan(), relative_path.display());
-                                    pages_to_recompile.insert(path.clone());
-
-                                    // Rebuild dependencies for this page (shared with the
-                                    // component path via refresh_file).
-                                    if let Ok(html) = std::fs::read_to_string(path) {
-                                        let components_path = config.source.join(&config.components);
-                                        let deps: HashSet<PathBuf> =
-                                            extract_component_dependencies(&html, &components_path)
-                                                .into_iter()
-                                                .map(|dep| {
-                                                    let dep_absolute = config.source.join(&dep);
-                                                    dep_absolute.canonicalize().unwrap_or(dep_absolute)
-                                                })
-                                                .collect();
-                                        graph.refresh_file(path, deps, false);
-                                    }
-                                }
-                            }
-                        }
-
-                        // Separate HTML files (from dependency graph) and CSS/JS assets (from changed_paths)
-                        // Filter out deleted files
-                        let html_files: Vec<PathBuf> = pages_to_recompile.into_iter()
-                            .filter(|p| p.exists())
-                            .collect();
-
-                        let mut asset_files: Vec<PathBuf> = Vec::new();
-                        for path in &changed_paths {
-                            // Skip files in output directory
-                            let canonical_path = path.canonicalize().unwrap_or_else(|_| path.clone());
-                            if canonical_path.starts_with(&canonical_output) {
-                                continue;
-                            }
-
-                            // Skip blacklisted files/directories
-                            if is_path_blacklisted(path, &config.source, &config.skip_files) {
-                                continue;
-                            }
-
-                            // Handle deleted asset files
-                            if !path.exists() {
-                                if let Some(ext) = path.extension().and_then(|e| e.to_str()) {
-                                    if ext == "css" || ext == "js" {
-                                        let relative_path = path.strip_prefix(&config.source).unwrap_or(path);
-                                        let output_path = canonical_output.join(relative_path);
-                                        if output_path.exists() {
-                                            if let Err(e) = std::fs::remove_file(&output_path) {
-                                                eprintln!("{}: Failed to delete {}: {}", "Warning".yellow(), output_path.display(), e);
-                                            } else {
-                                                println!("{} {} deleted", "[watch]".yellow(), relative_path.display());
-                                            }
-                                        }
-                                    }
-                                }
-                                continue;
-                            }
-
-                            if let Some(ext) = path.extension().and_then(|e| e.to_str()) {
-                                if ext == "css" || ext == "js" {
-                                    asset_files.push(path.clone());
-                                }
-                            }
-                        }
-
-                        if html_files.is_empty() && asset_files.is_empty() && components_to_mirror.is_empty() {
-                            continue;
-                        }
-
-                        let start = std::time::Instant::now();
-
-                        // Use persistent compiler and parser (cache is preserved)
-                        let mut total_stats = super::CompileStats {
-                            files_compiled: 0,
-                            files_copied: 0,
-                            internal_components_unique: 0,
-                            external_components_unique: 0,
-                            internal_components_total: 0,
-                            external_components_total: 0,
-                            compile_time_ms: 0.0,
-                            copy_time_ms: 0.0,
-                            components_time_ms: 0.0,
-                            validation_time_ms: None,
-                            node_modules_time_ms: None,
-                            package_manager: None,
-                            node_modules_copied_as_is: false,
-                            components_as_is: config.components_as_is,
-                        };
-
-                        let mut manifest_stats_result = None;
-                        let mut had_errors = false;
-
-                        // Compile HTML files
-                        if !html_files.is_empty() {
-                                // Drop only the stale component caches (edited components +
-                                // their inlining ancestors); unchanged components are reused.
-                                // A page-only edit invalidates nothing here — its components
-                                // are still valid — so the whole cache is reused as-is.
-                                let invalidated = watch_compiler.invalidate_components(&stale_component_keys);
-                                if invalidated > 0 {
-                                    println!("{} {} component{} re-expanded, {} reused from cache",
-                                        "↻".cyan(),
-                                        invalidated,
-                                        if invalidated == 1 { "" } else { "s" },
-                                        watch_compiler.cached_component_count(),
-                                    );
-                                }
-
-                                match watch_compiler.compile_specific_html_files(&html_files, &parser) {
-                                    Ok(stats) => {
-                                        total_stats.files_compiled = stats.files_compiled;
-                                        total_stats.internal_components_total = stats.internal_components_total;
-                                        total_stats.external_components_total = stats.external_components_total;
-                                        total_stats.internal_components_unique = stats.internal_components_unique;
-                                        total_stats.external_components_unique = stats.external_components_unique;
-                                        total_stats.compile_time_ms = stats.compile_time_ms;
-
-                                        // Generate manifests for affected HTML files
-                                        if !config.runtime_as_is {
-                                            match watch_compiler.generate_manifests_for_files(&html_files) {
-                                                Ok(manifest_stats) => {
-                                                    manifest_stats_result = Some(manifest_stats);
-                                                }
-                                                Err(e) => {
-                                                    eprintln!("{}: Manifest generation failed: {}", "Warning".yellow(), e);
-                                                }
-                                            }
-                                        }
-                                    }
-                                    Err(e) => {
-                                        eprintln!("{}: {}", "Error".red(), e);
-                                        eprintln!("Fix the errors and save to retry.");
-                                        println!();
-                                        had_errors = true;
-                                    }
-                                }
-                        }
-
-                        // Copy asset files
-                        if !asset_files.is_empty() && !had_errors {
-                            match watch_compiler.copy_specific_asset_files(&asset_files) {
-                                Ok(stats) => {
-                                    total_stats.files_copied = stats.files_copied;
-                                    total_stats.copy_time_ms = stats.copy_time_ms;
-                                }
-                                Err(e) => {
-                                    eprintln!("{}: {}", "Error".red(), e);
-                                    eprintln!("Fix the errors and save to retry.");
-                                    println!();
-                                    had_errors = true;
-                                }
-                            }
-                        }
-
-                        // Keep the output's components mirror in sync — changed
-                        // components reach it even with zero dependent pages, and
-                        // deleted ones leave it (see mirror_component_files).
-                        if !components_to_mirror.is_empty() && !had_errors {
-                            match watch_compiler.mirror_component_files(&components_to_mirror) {
-                                Ok(copied) => {
-                                    total_stats.files_copied += copied;
-                                }
-                                Err(e) => {
-                                    eprintln!("{}: {}", "Error".red(), e);
-                                    eprintln!("Fix the errors and save to retry.");
-                                    println!();
-                                    had_errors = true;
-                                }
-                            }
-                        }
-
-                        if !had_errors {
-                            // Show what was updated
-                            if total_stats.files_compiled > 0 {
-                                println!("{} Compiled {} HTML file{}",
-                                    "✓".green(),
-                                    total_stats.files_compiled,
-                                    if total_stats.files_compiled == 1 { "" } else { "s" }
-                                );
-                            }
-
-                            if let Some(manifest_stats) = manifest_stats_result {
-                                if manifest_stats.pages_processed > 0 {
-                                    println!("{} Generated {} manifest{}",
-                                        "✓".green(),
-                                        manifest_stats.pages_processed,
-                                        if manifest_stats.pages_processed == 1 { "" } else { "s" }
-                                    );
-                                }
-                            }
-
-                            if total_stats.files_copied > 0 {
-                                println!("{} Copied {} asset file{}",
-                                    "✓".green(),
-                                    total_stats.files_copied,
-                                    if total_stats.files_copied == 1 { "" } else { "s" }
-                                );
-                            }
-
-                            let elapsed = start.elapsed().as_millis();
-                            println!("{} Updated in {}ms", "✓".green(), elapsed);
-                        }
-                        println!();
-                    }
-                    Err(errors) => {
-                        for error in errors {
-                            eprintln!("{}: {:?}", "Watch error".red(), error);
-                        }
-                    }
-                }
-            }
-            Err(e) => {
-                eprintln!("{}: {}", "Channel error".red(), e);
-                break;
-            }
-        }
-    }
-
-    Ok(())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    // leaf <- mid <- layout <- page, with `sibling` an unrelated component that
-    // layout also uses. Editing `leaf` invalidates the cached, fully-inlined
-    // content of leaf and every component whose cache embeds it (mid, layout) —
-    // but NOT `sibling` (its cache never contained leaf) and NOT pages (they are
-    // recompiled, not cache entries).
-    fn chain_graph() -> (DependencyGraph, [PathBuf; 5]) {
-        let leaf = PathBuf::from("/src/components/AccountProgression.html");
-        let mid = PathBuf::from("/src/components/Sidebar.html");
-        let layout = PathBuf::from("/src/components/Layout.html");
-        let sibling = PathBuf::from("/src/components/Topbar.html");
-        let page = PathBuf::from("/src/pages/index.html");
-
-        let mut graph = DependencyGraph::new();
-        graph.add_dependency(mid.clone(), leaf.clone(), true); // mid uses leaf
-        graph.add_dependency(layout.clone(), mid.clone(), true); // layout uses mid
-        graph.add_dependency(layout.clone(), sibling.clone(), true); // layout uses sibling
-        graph.add_dependency(page.clone(), layout.clone(), false); // page uses layout
-
-        (graph, [leaf, mid, layout, sibling, page])
-    }
-
-    #[test]
-    fn dependent_components_are_just_the_stale_ancestor_chain() {
-        let (graph, [leaf, mid, layout, sibling, page]) = chain_graph();
-
-        let stale = graph.get_all_dependent_components(&leaf);
-
-        // The edited component itself, plus every component that inlines it.
-        assert!(stale.contains(&leaf), "leaf itself must be invalidated");
-        assert!(stale.contains(&mid), "mid inlines leaf — stale");
-        assert!(stale.contains(&layout), "layout transitively inlines leaf — stale");
-        // A sibling that does not contain leaf keeps its cache.
-        assert!(!stale.contains(&sibling), "sibling never inlined leaf — must stay cached");
-        // Pages are recompiled, not component-cache entries.
-        assert!(!stale.contains(&page), "pages are not in the component set");
-        assert_eq!(stale.len(), 3, "exactly leaf + mid + layout go stale");
-    }
-
-    #[test]
-    fn editing_a_leaf_invalidates_far_fewer_than_the_dependent_pages() {
-        let (graph, [leaf, _mid, _layout, _sibling, _page]) = chain_graph();
-
-        // dependent-pages drives which output files recompile; dependent-
-        // components drives which caches to drop — the minimal stale set, which
-        // never includes unrelated siblings.
-        let stale_components = graph.get_all_dependent_components(&leaf);
-        let dependent_pages = graph.get_all_dependent_pages(&leaf);
-
-        assert_eq!(dependent_pages.len(), 1, "one page inlines leaf");
-        assert!(stale_components.iter().all(|c| c.starts_with("/src/components")));
-    }
-
-    // The new-file bug: a component created mid-session is referenced by editing
-    // an existing component (e.g. Layout adds <component src="SeasonDowntime">).
-    // The watcher must refresh the edited component's own deps so that edge is
-    // learned — otherwise editing the new component maps to zero pages and is a
-    // silent no-op.
-    #[test]
-    fn refreshing_a_component_learns_newly_added_child_references() {
-        let layout = PathBuf::from("/src/components/Layout.html");
-        let page = PathBuf::from("/src/pages/index.html");
-        let downtime = PathBuf::from("/src/components/SeasonDowntime.html");
-
-        let mut graph = DependencyGraph::new();
-        graph.add_dependency(page.clone(), layout.clone(), false); // page uses layout
-
-        // Brand-new component nobody references yet.
-        assert!(
-            graph.get_all_dependent_pages(&downtime).is_empty(),
-            "nothing uses the new component yet"
-        );
-
-        // Layout is edited to add <component src="SeasonDowntime">. The watcher
-        // refreshes layout's deps, which must learn the layout -> downtime edge.
-        let mut new_deps = HashSet::new();
-        new_deps.insert(downtime.clone());
-        graph.refresh_file(&layout, new_deps, true);
-
-        // Now editing the new component must map back to the page that inlines it.
-        assert!(
-            graph.get_all_dependent_pages(&downtime).contains(&page),
-            "after layout learns the new component, editing it must recompile the page"
-        );
-    }
-
-    // refresh_file replaces a file's edges, so a dependency it no longer uses is
-    // dropped (no phantom recompiles of files that reference the removed dep).
-    #[test]
-    fn refreshing_a_file_drops_stale_dependencies() {
-        let page = PathBuf::from("/src/pages/index.html");
-        let old = PathBuf::from("/src/components/Old.html");
-        let new = PathBuf::from("/src/components/New.html");
-
-        let mut graph = DependencyGraph::new();
-        graph.add_dependency(page.clone(), old.clone(), false);
-        assert!(graph.get_all_dependent_pages(&old).contains(&page));
-
-        // Page edited: now uses `new` instead of `old`.
-        let mut deps = HashSet::new();
-        deps.insert(new.clone());
-        graph.refresh_file(&page, deps, false);
-
-        assert!(
-            graph.get_all_dependent_pages(&new).contains(&page),
-            "new dependency is learned"
-        );
-        assert!(
-            !graph.get_all_dependent_pages(&old).contains(&page),
-            "stale dependency is dropped"
-        );
-    }
-
-    // Same as above but for a component's own deps (component -> component edges),
-    // which previously had no forward tracking to clear.
-    #[test]
-    fn refreshing_a_component_drops_stale_child_references() {
-        let page = PathBuf::from("/src/pages/index.html");
-        let parent = PathBuf::from("/src/components/Parent.html");
-        let old_child = PathBuf::from("/src/components/OldChild.html");
-        let new_child = PathBuf::from("/src/components/NewChild.html");
-
-        let mut graph = DependencyGraph::new();
-        graph.add_dependency(page.clone(), parent.clone(), false); // page uses parent
-        graph.add_dependency(parent.clone(), old_child.clone(), true); // parent uses old_child
-        assert!(graph.get_all_dependent_pages(&old_child).contains(&page));
-
-        // Parent edited: swaps old_child for new_child.
-        let mut deps = HashSet::new();
-        deps.insert(new_child.clone());
-        graph.refresh_file(&parent, deps, true);
-
-        assert!(
-            graph.get_all_dependent_pages(&new_child).contains(&page),
-            "new child reference is learned transitively"
-        );
-        assert!(
-            !graph.get_all_dependent_pages(&old_child).contains(&page),
-            "stale child reference is dropped"
-        );
-    }
-
-    fn lock_test_output(name: &str) -> PathBuf {
-        let out = std::env::temp_dir().join(format!("vibe_watch_lock_{}_out", name));
-        let _ = std::fs::remove_dir_all(&out);
-        std::fs::create_dir_all(&out).unwrap();
-        // A previous crashed test run may have left a lock behind.
-        let _ = std::fs::remove_file(WatchLock::lock_path_for(&out));
-        out
-    }
-
-    // Two concurrent watchers on one output dir double-compile every save and
-    // race each other's writes (torn manifest reads → blank pages). The second
-    // watcher must refuse to start while the first holds the lock.
-    #[test]
-    fn second_watch_lock_on_same_output_fails_while_held() {
-        let out = lock_test_output("same");
-
-        let first = WatchLock::acquire(&out).expect("first lock acquires");
-        let second = WatchLock::acquire(&out);
-        let msg = second.expect_err("second watcher on the same output must fail loudly");
-        assert!(
-            msg.contains("vibe compile --watch"),
-            "error should explain the conflict: {msg}"
-        );
-
-        drop(first);
-        WatchLock::acquire(&out).expect("released lock can be re-acquired");
-    }
-
-    // A watcher killed without unwinding (Ctrl+C, SIGTERM from dev tooling)
-    // leaves its lock file behind; the pid inside is dead, so the next watcher
-    // steals the lock instead of being locked out forever.
-    #[test]
-    fn stale_lock_from_dead_process_is_stolen() {
-        let out = lock_test_output("stale");
-
-        // No live process can have this pid (pid_max is 99998 on macOS,
-        // ≤ 4194304 on Linux).
-        std::fs::write(WatchLock::lock_path_for(&out), "4294967295").unwrap();
-
-        WatchLock::acquire(&out).expect("stale lock from a dead process must be stolen");
-    }
-
-    #[test]
-    fn locks_on_different_outputs_do_not_conflict() {
-        let out_a = lock_test_output("indep_a");
-        let out_b = lock_test_output("indep_b");
-
-        let _a = WatchLock::acquire(&out_a).expect("lock a");
-        WatchLock::acquire(&out_b).expect("an unrelated output dir must not be blocked");
-    }
-
-    #[test]
-    fn cache_key_is_source_relative_with_leading_slash() {
-        let source = PathBuf::from("/proj/src");
-        // Must match the key form fetch_component_recursive stores.
-        assert_eq!(
-            component_cache_key(&PathBuf::from("/proj/src/components/Sidebar.html"), &source)
-                .as_deref(),
-            Some("/components/Sidebar.html"),
-        );
-        // A path outside the source root (e.g. an external URL component's
-        // resolved path) yields no key, so it's never wrongly invalidated.
-        assert_eq!(
-            component_cache_key(&PathBuf::from("/elsewhere/x.html"), &source),
-            None,
-        );
-    }
-}