feat(turbopack): add support for polling file watcher

crates/napi/src/next_api/project.rs

@@ -10,7 +10,7 @@
     entrypoints::Entrypoints,
     project::{
         DefineEnv, DraftModeOptions, Instrumentation, Middleware, PartialProjectOptions, Project,
-        ProjectContainer, ProjectOptions,
+        ProjectContainer, ProjectOptions, WatchOptions,
     },
     route::{Endpoint, Route},
 };
@@ -78,6 +78,16 @@
     }
 }
 
+#[napi(object)]
+pub struct NapiWatchOptions {
+    /// Whether to watch the filesystem for file changes.
+    pub enable: bool,
+
+    /// Enable polling at a certain interval if the native file watching doesn't work (e.g.
+    /// docker).
+    pub poll_interval_ms: Option<f64>,
+}
+
 #[napi(object)]
 pub struct NapiProjectOptions {
     /// A root path from which all files must be nested under. Trying to access
@@ -91,8 +101,8 @@
     /// deserializing next.config, so passing it as separate option.
     pub dist_dir: Option<String>,
 
-    /// Whether to watch he filesystem for file changes.
-    pub watch: bool,
+    /// Filesystem watcher options.
+    pub watch: NapiWatchOptions,
 
     /// The contents of next.config.js, serialized to JSON.
     pub next_config: String,
@@ -137,8 +147,8 @@
     /// deserializing next.config, so passing it as separate option.
     pub dist_dir: Option<Option<String>>,
 
-    /// Whether to watch he filesystem for file changes.
-    pub watch: Option<bool>,
+    /// Filesystem watcher options.
+    pub watch: Option<NapiWatchOptions>,
 
     /// The contents of next.config.js, serialized to JSON.
     pub next_config: Option<String>,
@@ -183,12 +193,24 @@
     pub memory_limit: Option<f64>,
 }
 
+impl From<NapiWatchOptions> for WatchOptions {
+    fn from(val: NapiWatchOptions) -> Self {
+        WatchOptions {
+            enable: val.enable,
+            poll_interval: val
+                .poll_interval_ms
+                .filter(|interval| !interval.is_nan() && interval.is_finite() && *interval > 0.0)
+                .map(|interval| Duration::from_secs_f64(interval / 1000.0)),
+        }
+    }
+}
+
 impl From<NapiProjectOptions> for ProjectOptions {
     fn from(val: NapiProjectOptions) -> Self {
         ProjectOptions {
             root_path: val.root_path.into(),
             project_path: val.project_path.into(),
-            watch: val.watch,
+            watch: val.watch.into(),
             next_config: val.next_config.into(),
             js_config: val.js_config.into(),
             env: val
@@ -211,7 +233,7 @@
         PartialProjectOptions {
             root_path: val.root_path.map(From::from),
             project_path: val.project_path.map(From::from),
-            watch: val.watch,
+            watch: val.watch.map(From::from),
             next_config: val.next_config.map(From::from),
             js_config: val.js_config.map(From::from),
             env: val.env.map(|env| {
@@ -909,7 +931,7 @@
     }
 }
 
 /// Subscribes to lifecycle events of the compilation.
 /// Emits an [UpdateMessage::Start] event when any computation starts.
 /// Emits an [UpdateMessage::End] event when there was no computation for the
 /// specified time (`aggregation_ms`). The [UpdateMessage::End] event contains

crates/next-api/src/project.rs

@@ -1,4 +1,4 @@
-use std::path::MAIN_SEPARATOR;
+use std::{path::MAIN_SEPARATOR, time::Duration};
 
 use anyhow::{bail, Context, Result};
 use indexmap::{indexmap, map::Entry, IndexMap};
@@ -78,6 +78,19 @@ pub struct DraftModeOptions {
     pub preview_mode_signing_key: RcStr,
 }
 
+#[derive(
+    Debug, Default, Serialize, Deserialize, Copy, Clone, TaskInput, PartialEq, Eq, Hash, TraceRawVcs,
+)]
+#[serde(rename_all = "camelCase")]
+pub struct WatchOptions {
+    /// Whether to watch the filesystem for file changes.
+    pub enable: bool,
+
+    /// Enable polling at a certain interval if the native file watching doesn't work (e.g.
+    /// docker).
+    pub poll_interval: Option<Duration>,
+}
+
 #[derive(Debug, Serialize, Deserialize, Clone, TaskInput, PartialEq, Eq, Hash, TraceRawVcs)]
 #[serde(rename_all = "camelCase")]
 pub struct ProjectOptions {
@@ -101,8 +114,8 @@ pub struct ProjectOptions {
     /// time.
     pub define_env: DefineEnv,
 
-    /// Whether to watch the filesystem for file changes.
-    pub watch: bool,
+    /// Filesystem watcher options.
+    pub watch: WatchOptions,
 
     /// The mode in which Next.js is running.
     pub dev: bool,
@@ -143,8 +156,8 @@ pub struct PartialProjectOptions {
     /// time.
     pub define_env: Option<DefineEnv>,
 
-    /// Whether to watch the filesystem for file changes.
-    pub watch: Option<bool>,
+    /// Filesystem watcher options.
+    pub watch: Option<WatchOptions>,
 
     /// The mode in which Next.js is running.
     pub dev: Option<bool>,
@@ -203,13 +216,16 @@ impl ProjectContainer {
 impl ProjectContainer {
     #[tracing::instrument(level = "info", name = "initialize project", skip_all)]
     pub async fn initialize(self: Vc<Self>, options: ProjectOptions) -> Result<()> {
+        let poll_interval = options.watch.poll_interval;
+
         self.await?.options_state.set(Some(options));
+
         let project = self.project();
         project
             .project_fs()
             .strongly_consistent()
             .await?
-            .start_watching_with_invalidation_reason()?;
+            .start_watching_with_invalidation_reason(poll_interval)?;
         project
             .output_fs()
             .strongly_consistent()
@@ -282,13 +298,15 @@ impl ProjectContainer {
         let prev_project_fs = project.project_fs().strongly_consistent().await?;
         let prev_output_fs = project.output_fs().strongly_consistent().await?;
 
+        let poll_interval = new_options.watch.poll_interval;
+
         this.options_state.set(Some(new_options));
         let project_fs = project.project_fs().strongly_consistent().await?;
         let output_fs = project.output_fs().strongly_consistent().await?;
 
         if !ReadRef::ptr_eq(&prev_project_fs, &project_fs) {
             // TODO stop watching: prev_project_fs.stop_watching()?;
-            project_fs.start_watching_with_invalidation_reason()?;
+            project_fs.start_watching_with_invalidation_reason(poll_interval)?;
         }
         if !ReadRef::ptr_eq(&prev_output_fs, &output_fs) {
             prev_output_fs.invalidate_with_reason();
@@ -407,8 +425,8 @@ pub struct Project {
     /// A path inside the root_path which contains the app/pages directories.
     pub project_path: RcStr,
 
-    /// Whether to watch the filesystem for file changes.
-    watch: bool,
+    /// Filesystem watcher options.
+    watch: WatchOptions,
 
     /// Next config.
     next_config: Vc<NextConfig>,
@@ -521,8 +539,10 @@ impl Project {
             self.root_path.clone(),
             vec![],
         );
-        if self.watch {
-            disk_fs.await?.start_watching_with_invalidation_reason()?;
+        if self.watch.enable {
+            disk_fs
+                .await?
+                .start_watching_with_invalidation_reason(self.watch.poll_interval)?;
         }
         Ok(disk_fs)
     }

crates/next-build-test/src/lib.rs

@@ -31,10 +31,10 @@ pub async fn main_inner(
 
     if matches!(strat, Strategy::Development { .. }) {
         options.dev = true;
-        options.watch = true;
+        options.watch.enable = true;
     } else {
         options.dev = false;
-        options.watch = false;
+        options.watch.enable = false;
     }
 
     let project = tt

crates/next-build-test/src/main.rs

@@ -153,7 +153,7 @@ fn main() {
                 },
                 project_path: canonical_path.to_string_lossy().into(),
                 root_path: "/".into(),
-                watch: false,
+                watch: Default::default(),
                 browserslist_query: "last 1 Chrome versions, last 1 Firefox versions, last 1 \
                                      Safari versions, last 1 Edge versions"
                     .into(),

packages/next/src/build/index.ts

@@ -1370,7 +1370,9 @@ export default async function build(
               dir,
             nextConfig: config,
             jsConfig: await getTurbopackJsConfig(dir, config),
-            watch: false,
+            watch: {
+              enable: false,
+            },
             dev,
             env: process.env as Record<string, string>,
             defineEnv: createDefineEnv({

packages/next/src/build/swc/generated-native.d.ts

@@ -82,6 +82,15 @@ export interface NapiDraftModeOptions {
   previewModeEncryptionKey: string
   previewModeSigningKey: string
 }
+export interface NapiWatchOptions {
+  /** Whether to watch the filesystem for file changes. */
+  enable: boolean
+  /**
+   * Enable polling at a certain interval if the native file watching doesn't work (e.g.
+   * docker).
+   */
+  pollIntervalMs?: number
+}
 export interface NapiProjectOptions {
   /**
    * A root path from which all files must be nested under. Trying to access
@@ -95,8 +104,8 @@ export interface NapiProjectOptions {
    * deserializing next.config, so passing it as separate option.
    */
   distDir?: string
-  /** Whether to watch he filesystem for file changes. */
-  watch: boolean
+  /** Filesystem watcher options. */
+  watch: NapiWatchOptions
   /** The contents of next.config.js, serialized to JSON. */
   nextConfig: string
   /** The contents of ts/config read by load-jsconfig, serialized to JSON. */
@@ -133,8 +142,8 @@ export interface NapiPartialProjectOptions {
    * deserializing next.config, so passing it as separate option.
    */
   distDir?: string | undefined | null
-  /** Whether to watch he filesystem for file changes. */
-  watch?: boolean
+  /** Filesystem watcher options. */
+  watch?: NapiWatchOptions
   /** The contents of next.config.js, serialized to JSON. */
   nextConfig?: string
   /** The contents of ts/config read by load-jsconfig, serialized to JSON. */

packages/next/src/build/swc/types.ts

@@ -346,7 +346,10 @@ export interface ProjectOptions {
   /**
    * Whether to watch the filesystem for file changes.
    */
-  watch: boolean
+  watch: {
+    enable: boolean
+    pollIntervalMs?: number
+  }
 
   /**
    * The mode in which Next.js is running.

packages/next/src/build/webpack-config.ts

@@ -137,7 +137,7 @@ const nodePathList = (process.env.NODE_PATH || '')
   .split(process.platform === 'win32' ? ';' : ':')
   .filter((p) => !!p)
 
-const watchOptions = Object.freeze({
+const baseWatchOptions: webpack.Configuration['watchOptions'] = Object.freeze({
   aggregateTimeout: 5,
   ignored:
     // Matches **/node_modules/**, **/.git/** and **/.next/**
@@ -1105,7 +1105,10 @@ export default async function getBaseWebpackConfig(
         ...entrypoints,
       }
     },
-    watchOptions,
+    watchOptions: Object.freeze({
+      ...baseWatchOptions,
+      poll: config.watchOptions?.pollIntervalMs,
+    }),
     output: {
       // we must set publicPath to an empty value to override the default of
       // auto which doesn't work in IE11

packages/next/src/server/config-schema.ts

@@ -627,5 +627,10 @@ export const configSchema: zod.ZodType<NextConfig> = z.lazy(() =>
     useFileSystemPublicRoutes: z.boolean().optional(),
     // The webpack config type is unknown, use z.any() here
     webpack: z.any().nullable().optional(),
+    watchOptions: z
+      .strictObject({
+        pollIntervalMs: z.number().positive().finite().optional(),
+      })
+      .optional(),
   })
 )

packages/next/src/server/config-shared.ts

@@ -944,6 +944,10 @@ export interface NextConfig extends Record<string, any> {
    * were not detected on a per-page basis.
    */
   outputFileTracingIncludes?: Record<string, string[]>
+
+  watchOptions?: {
+    pollIntervalMs?: number
+  }
 }
 
 export const defaultConfig: NextConfig = {

packages/next/src/server/dev/hot-reloader-turbopack.ts

@@ -152,7 +152,10 @@ export async function createHotReloaderTurbopack(
         dir,
       nextConfig: opts.nextConfig,
       jsConfig: await getTurbopackJsConfig(dir, nextConfig),
-      watch: dev,
+      watch: {
+        enable: dev,
+        pollIntervalMs: nextConfig.watchOptions?.pollIntervalMs,
+      },
       dev,
       env: process.env as Record<string, string>,
       defineEnv: createDefineEnv({

test/development/basic/next-rs-api.test.ts

@@ -200,7 +200,9 @@ describe('next.rs api', () => {
       rootPath: process.env.NEXT_SKIP_ISOLATE
         ? path.resolve(__dirname, '../../..')
         : next.testDir,
-      watch: true,
+      watch: {
+        enable: true,
+      },
       dev: true,
       defineEnv: createDefineEnv({
         isTurbopack: true,

turbopack/crates/node-file-trace/src/lib.rs

@@ -190,7 +190,7 @@ impl Args {
 async fn create_fs(name: &str, root: &str, watch: bool) -> Result<Vc<Box<dyn FileSystem>>> {
     let fs = DiskFileSystem::new(name.into(), root.into(), vec![]);
     if watch {
-        fs.await?.start_watching()?;
+        fs.await?.start_watching(None)?;
     } else {
         fs.await?.invalidate_with_reason();
     }

turbopack/crates/turbo-tasks-fs/examples/hash_directory.rs

@@ -31,7 +31,7 @@ async fn main() -> Result<()> {
         Box::pin(async {
             let root = current_dir().unwrap().to_str().unwrap().into();
             let disk_fs = DiskFileSystem::new("project".into(), root, vec![]);
-            disk_fs.await?.start_watching()?;
+            disk_fs.await?.start_watching(None)?;
 
             // Smart Pointer cast
             let fs: Vc<Box<dyn FileSystem>> = Vc::upcast(disk_fs);

turbopack/crates/turbo-tasks-fs/examples/hash_glob.rs

@@ -28,7 +28,7 @@ async fn main() -> Result<()> {
         Box::pin(async {
             let root = current_dir().unwrap().to_str().unwrap().into();
             let disk_fs = DiskFileSystem::new("project".into(), root, vec![]);
-            disk_fs.await?.start_watching()?;
+            disk_fs.await?.start_watching(None)?;
 
             // Smart Pointer cast
             let fs: Vc<Box<dyn FileSystem>> = Vc::upcast(disk_fs);

turbopack/crates/turbo-tasks-fs/src/embed/dir.rs

@@ -12,7 +12,7 @@ pub async fn directory_from_relative_path(
     path: RcStr,
 ) -> Result<Vc<Box<dyn FileSystem>>> {
     let disk_fs = DiskFileSystem::new(name, path, vec![]);
-    disk_fs.await?.start_watching()?;
+    disk_fs.await?.start_watching(None)?;
 
     Ok(Vc::upcast(disk_fs))
 }

turbopack/crates/turbo-tasks-fs/src/embed/file.rs

@@ -23,7 +23,7 @@ pub async fn content_from_relative_path(
         root_path.to_string_lossy().into(),
         vec![],
     );
-    disk_fs.await?.start_watching()?;
+    disk_fs.await?.start_watching(None)?;
 
     let fs_path = disk_fs.root().join(path.into());
     Ok(fs_path.read())