refactor(watch): rename TaskStart/TaskEnd to BundleStart/BundleEnd (#8463)

hyf0 · hyf0 · commit 061a9b32c884 · 2026-02-26T04:16:02.000Z
diff --git a/crates/rolldown_watcher/src/event.rs b/crates/rolldown_watcher/src/event.rs
@@ -10,10 +10,10 @@ use tokio::sync::Mutex;
 pub enum WatchEvent {
   /// Watch run is starting (all tasks)
   Start,
-  /// A single task is starting its build
-  TaskStart(WatchStartEventData),
-  /// A single task has finished its build
-  TaskEnd(WatchEndEventData),
+  /// A single bundle is starting its build
+  BundleStart(BundleStartEventData),
+  /// A single bundle has finished its build
+  BundleEnd(BundleEndEventData),
   /// All tasks have finished
   End,
   /// An error occurred during bundling
@@ -24,8 +24,8 @@ impl WatchEvent {
   pub fn as_str(&self) -> &str {
     match self {
       WatchEvent::Start => "START",
-      WatchEvent::TaskStart(_) => "BUNDLE_START",
-      WatchEvent::TaskEnd(_) => "BUNDLE_END",
+      WatchEvent::BundleStart(_) => "BUNDLE_START",
+      WatchEvent::BundleEnd(_) => "BUNDLE_END",
       WatchEvent::End => "END",
       WatchEvent::Error(_) => "ERROR",
     }
@@ -38,24 +38,24 @@ impl Display for WatchEvent {
   }
 }
 
-/// Data for task start event
+/// Data for bundle start event
 #[derive(Debug, Clone)]
-pub struct WatchStartEventData {
+pub struct BundleStartEventData {
   pub task_index: WatchTaskIdx,
 }
 
-/// Data for task end event
+/// Data for bundle end event
 #[derive(Clone)]
-pub struct WatchEndEventData {
+pub struct BundleEndEventData {
   pub task_index: WatchTaskIdx,
   pub output: String,
   pub duration: u32,
   pub bundler: Arc<Mutex<Bundler>>,
 }
 
-impl Debug for WatchEndEventData {
+impl Debug for BundleEndEventData {
   fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-    f.debug_struct("WatchEndEventData")
+    f.debug_struct("BundleEndEventData")
       .field("task_index", &self.task_index)
       .field("output", &self.output)
       .field("duration", &self.duration)
diff --git a/crates/rolldown_watcher/src/lib.rs b/crates/rolldown_watcher/src/lib.rs
@@ -6,7 +6,7 @@ mod watch_coordinator;
 mod watch_task;
 mod watcher;
 
-pub use event::{WatchEndEventData, WatchErrorEventData, WatchEvent, WatchStartEventData};
+pub use event::{BundleEndEventData, BundleStartEventData, WatchErrorEventData, WatchEvent};
 pub use handler::WatcherEventHandler;
 pub use state::ChangeEntry;
 pub use watch_task::WatchTaskIdx;
diff --git a/crates/rolldown_watcher/src/watch_coordinator.rs b/crates/rolldown_watcher/src/watch_coordinator.rs
@@ -95,12 +95,12 @@ impl<H: WatcherEventHandler> WatchCoordinator<H> {
 
     for task_index in self.tasks.indices() {
       let task = &self.tasks[task_index];
-      self.handler.on_event(WatchEvent::TaskStart(task.start_event_data(task_index))).await;
+      self.handler.on_event(WatchEvent::BundleStart(task.start_event_data(task_index))).await;
 
       let task = &mut self.tasks[task_index];
       match task.build(task_index).await {
         Ok(BuildOutcome::Success(data)) => {
-          self.handler.on_event(WatchEvent::TaskEnd(data)).await;
+          self.handler.on_event(WatchEvent::BundleEnd(data)).await;
         }
         Ok(BuildOutcome::Error(data)) => {
           self.handler.on_event(WatchEvent::Error(data)).await;
@@ -121,7 +121,7 @@ impl<H: WatcherEventHandler> WatchCoordinator<H> {
   /// 2. For each task and each changed file: task.call_watch_change
   /// 3. handler.on_restart
   /// 4. handler.on_event(Start)
-  /// 5. For each task needing rebuild: TaskStart → build → TaskEnd/Error
+  /// 5. For each task needing rebuild: BundleStart → build → BundleEnd/Error
   /// 6. handler.on_event(End)
   /// 7. drain_buffered_events
   async fn run_build_sequence(&mut self, changes: Vec<ChangeEntry>) {
@@ -149,12 +149,12 @@ impl<H: WatcherEventHandler> WatchCoordinator<H> {
       }
 
       let task = &self.tasks[task_index];
-      self.handler.on_event(WatchEvent::TaskStart(task.start_event_data(task_index))).await;
+      self.handler.on_event(WatchEvent::BundleStart(task.start_event_data(task_index))).await;
 
       let task = &mut self.tasks[task_index];
       match task.build(task_index).await {
         Ok(BuildOutcome::Success(data)) => {
-          self.handler.on_event(WatchEvent::TaskEnd(data)).await;
+          self.handler.on_event(WatchEvent::BundleEnd(data)).await;
         }
         Ok(BuildOutcome::Error(data)) => {
           self.handler.on_event(WatchEvent::Error(data)).await;
diff --git a/crates/rolldown_watcher/src/watch_task.rs b/crates/rolldown_watcher/src/watch_task.rs
@@ -9,7 +9,7 @@ use std::sync::Arc;
 use std::time::Instant;
 use tokio::sync::Mutex as TokioMutex;
 
-use crate::event::{WatchEndEventData, WatchErrorEventData, WatchStartEventData};
+use crate::event::{BundleEndEventData, BundleStartEventData, WatchErrorEventData};
 
 oxc_index::define_index_type! {
   pub struct WatchTaskIdx = u32;
@@ -87,7 +87,7 @@ impl WatchTask {
     self.needs_rebuild = false;
 
     match result {
-      Ok(_output) => Ok(BuildOutcome::Success(WatchEndEventData {
+      Ok(_output) => Ok(BuildOutcome::Success(BundleEndEventData {
         task_index,
         output: self.options.cwd.join(&self.options.out_dir).to_string_lossy().into_owned(),
         duration,
@@ -106,8 +106,8 @@ impl WatchTask {
   }
 
   /// Start event data for this task
-  pub(crate) fn start_event_data(&self, task_index: WatchTaskIdx) -> WatchStartEventData {
-    WatchStartEventData { task_index }
+  pub(crate) fn start_event_data(&self, task_index: WatchTaskIdx) -> BundleStartEventData {
+    BundleStartEventData { task_index }
   }
 
   /// Update watched files by adding new ones to the fs watcher.
@@ -209,7 +209,7 @@ pub enum BuildOutcome {
   /// Build was skipped (no rebuild needed)
   Skipped,
   /// Build succeeded
-  Success(WatchEndEventData),
+  Success(BundleEndEventData),
   /// Build had errors (but didn't fail fatally)
   Error(WatchErrorEventData),
 }
diff --git a/meta/design/watch-mode.md b/meta/design/watch-mode.md
@@ -8,6 +8,7 @@ Watch mode monitors source files and automatically rebuilds when changes are det
 
 - **JS API aligns with Rollup** — The TypeScript surface (events, options, plugin hooks, lifecycle ordering) should match Rollup's behavior unless there's a technical reason not to. Divergences are documented explicitly.
 - **Rust code follows Rust idioms** — The Rust core should feel native: ownership-driven, enum state machines, trait-based extensibility, no unnecessary `Arc`/`Mutex` beyond what the architecture requires.
+- **Consistent naming across the stack** — Rollup defines the canonical event/concept names (e.g. `BUNDLE_START`/`BUNDLE_END`). The Rust side should use the same terminology so there's a clean 1:1 mapping and no mental translation at the NAPI boundary.
 
 ## API Contract
 
@@ -127,7 +128,7 @@ rolldown_watcher/
 ├── watch_coordinator.rs  // WatchCoordinator (actor + event loop)
 ├── watch_task.rs         // WatchTask (bundler + fs watcher) + WatchTaskIdx + BuildOutcome
 ├── handler.rs            // WatcherEventHandler async trait
-├── event.rs              // WatchEvent, WatchStartEventData, WatchEndEventData, WatchErrorEventData
+├── event.rs              // WatchEvent, BundleStartEventData, BundleEndEventData, WatchErrorEventData
 ├── state.rs              // WatcherState enum + transitions + ChangeEntry
 └── msg.rs                // WatcherMsg enum (FsEvent, Close)
 ```
