@ape-egg/vibe-compiler 4.3.9 → 4.3.10

package/package.json

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

package/src/Cargo.lock

@@ -1599,12 +1599,13 @@ checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
 [[package]]
 name = "vibe-compiler"
-version = "4.3.9"
+version = "4.3.10"
 dependencies = [
  "clap",
  "colored",
  "glob",
  "html5ever",
+ "libc",
  "markup5ever",
  "markup5ever_rcdom",
  "notify",

package/src/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "vibe-compiler"
-version = "4.3.9"
+version = "4.3.10"
 edition = "2021"
 description = "Vibe framework compiler - compiles Vibe source files into optimized output"
 authors = ["Kim Korte"]
@@ -30,6 +30,7 @@ swc_ecma_visit = "=0.107.0"
 notify = "6.1"
 notify-debouncer-full = "0.3"
 rayon = "1.10"
+libc = "0.2"
 
 [profile.release]
 opt-level = 3

package/src/compiler/mod.rs

@@ -9,6 +9,7 @@ mod component_tagger;
 mod binding_case;
 mod name_binding_protect;
 mod reassignment_analyzer;
+mod shutdown;
 pub mod watcher;
 
 pub use compile::Compiler;

package/src/compiler/shutdown.rs

@@ -0,0 +1,85 @@
+use std::path::PathBuf;
+
+#[cfg(unix)]
+const SIGNALS: [libc::c_int; 3] = [libc::SIGINT, libc::SIGTERM, libc::SIGHUP];
+
+#[cfg(unix)]
+fn signal_set() -> libc::sigset_t {
+    unsafe {
+        let mut set = std::mem::zeroed();
+        libc::sigemptyset(&mut set);
+        SIGNALS.iter().for_each(|&sig| {
+            libc::sigaddset(&mut set, sig);
+        });
+        set
+    }
+}
+
+#[cfg(unix)]
+fn release(lock: &PathBuf, reason: &str, code: i32) -> ! {
+    let _ = std::fs::remove_file(lock);
+    eprintln!("{} — shutting down watcher", reason);
+    std::process::exit(code)
+}
+
+#[cfg(unix)]
+pub fn block() -> u32 {
+    unsafe { libc::pthread_sigmask(libc::SIG_BLOCK, &signal_set(), std::ptr::null_mut()) };
+    std::os::unix::process::parent_id()
+}
+
+#[cfg(target_os = "macos")]
+pub fn release_on_exit(parent: u32, lock: PathBuf) {
+    let event = |ident: usize, filter: i16, fflags: u32| libc::kevent {
+        ident,
+        filter,
+        flags: libc::EV_ADD,
+        fflags,
+        data: 0,
+        udata: std::ptr::null_mut(),
+    };
+    let watched: Vec<libc::kevent> = SIGNALS
+        .iter()
+        .map(|&sig| event(sig as usize, libc::EVFILT_SIGNAL, 0))
+        .chain([event(parent as usize, libc::EVFILT_PROC, libc::NOTE_EXIT)])
+        .collect();
+    let queue = unsafe { libc::kqueue() };
+    let registered = unsafe {
+        libc::kevent(queue, watched.as_ptr(), watched.len() as i32, std::ptr::null_mut(), 0, std::ptr::null())
+    };
+    if registered == -1 || std::os::unix::process::parent_id() != parent {
+        release(&lock, "parent process exited", 0);
+    }
+    std::thread::spawn(move || {
+        let mut fired = event(0, 0, 0);
+        unsafe { libc::kevent(queue, std::ptr::null(), 0, &mut fired, 1, std::ptr::null()) };
+        match fired.filter {
+            libc::EVFILT_SIGNAL => release(&lock, "received shutdown signal", 128 + fired.ident as i32),
+            _ => release(&lock, "parent process exited", 0),
+        }
+    });
+}
+
+#[cfg(all(unix, not(target_os = "macos")))]
+pub fn release_on_exit(parent: u32, lock: PathBuf) {
+    #[cfg(target_os = "linux")]
+    unsafe {
+        libc::prctl(libc::PR_SET_PDEATHSIG, libc::SIGHUP)
+    };
+    if std::os::unix::process::parent_id() != parent {
+        release(&lock, "parent process exited", 0);
+    }
+    std::thread::spawn(move || {
+        let mut sig = 0;
+        unsafe { libc::sigwait(&signal_set(), &mut sig) };
+        release(&lock, "received shutdown signal", 128 + sig)
+    });
+}
+
+#[cfg(not(unix))]
+pub fn block() -> u32 {
+    0
+}
+
+#[cfg(not(unix))]
+pub fn release_on_exit(_parent: u32, _lock: PathBuf) {}

package/src/compiler/watcher.rs

@@ -6,7 +6,7 @@ use colored::Colorize;
 use notify_debouncer_full::{new_debouncer, notify::{RecursiveMode, Watcher}};
 use regex::Regex;
 
-use super::{Compiler, compile::should_skip_path};
+use super::{Compiler, compile::should_skip_path, shutdown};
 use crate::config::Config;
 use crate::constants::{HYPERSPEED_DIR, MANIFEST_SUFFIX};
 
@@ -406,27 +406,6 @@ fn scan_directory(
     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) {}
-
 /// A config change invalidates every piece of watcher state — dependency
 /// graph, compiler, parser, watch roots, output lock. The cleanest
 /// expression is a fresh start: release the lock and exec the same binary
@@ -464,8 +443,9 @@ fn restart_with_fresh_config(lock: WatchLock) -> ! {
 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 parent = shutdown::block();
     let _watch_lock = WatchLock::acquire(&config.output)?;
-    exit_when_orphaned(_watch_lock.path.clone());
+    shutdown::release_on_exit(parent, _watch_lock.path.clone());
 
     println!("{}", "Building dependency graph...".cyan());
     let mut graph = build_dependency_graph(&config)?;