simplify settings again

Author: lukesandberg

crates/next-api/src/project.rs

@@ -625,21 +625,17 @@ impl ProjectContainer {
                     .start_watching_with_invalidation_reason(watch.poll_interval)
                     .await?;
             } else {
-                project_fs
-                    .invalidate_with_reason(|path| invalidation::Initialize {
-                        // this path is just used for display purposes
-                        path: RcStr::from(path.to_string_lossy()),
-                    })
-                    .await?;
+                project_fs.invalidate_with_reason(|path| invalidation::Initialize {
+                    // this path is just used for display purposes
+                    path: RcStr::from(path.to_string_lossy()),
+                });
             }
             let output_fs = output_fs_operation(project)
                 .read_strongly_consistent()
                 .await?;
-            output_fs
-                .invalidate_with_reason(|path| invalidation::Initialize {
-                    path: RcStr::from(path.to_string_lossy()),
-                })
-                .await?;
+            output_fs.invalidate_with_reason(|path| invalidation::Initialize {
+                path: RcStr::from(path.to_string_lossy()),
+            });
             Ok(())
         }
         .instrument(span_clone)
@@ -774,20 +770,16 @@ impl ProjectContainer {
                         .start_watching_with_invalidation_reason(watch.poll_interval)
                         .await?;
                 } else {
-                    project_fs
-                        .invalidate_with_reason(|path| invalidation::Initialize {
-                            // this path is just used for display purposes
-                            path: RcStr::from(path.to_string_lossy()),
-                        })
-                        .await?;
+                    project_fs.invalidate_with_reason(|path| invalidation::Initialize {
+                        // this path is just used for display purposes
+                        path: RcStr::from(path.to_string_lossy()),
+                    });
                 }
             }
             if !ReadRef::ptr_eq(&prev_output_fs, &output_fs) {
-                prev_output_fs
-                    .invalidate_with_reason(|path| invalidation::Initialize {
-                        path: RcStr::from(path.to_string_lossy()),
-                    })
-                    .await?;
+                prev_output_fs.invalidate_with_reason(|path| invalidation::Initialize {
+                    path: RcStr::from(path.to_string_lossy()),
+                });
             }
 
             Ok(())

crates/next-napi-bindings/src/next_api/project.rs

@@ -1246,19 +1246,15 @@ async fn invalidate_deferred_entry_source_dirs_after_callback(
 
     if paths_to_invalidate.is_empty() {
         // Fallback to full invalidation when app dir paths are unavailable.
-        project_fs
-            .invalidate_with_reason(|path| invalidation::Initialize {
-                path: RcStr::from(path.to_string_lossy()),
-            })
-            .await?;
+        project_fs.invalidate_with_reason(|path| invalidation::Initialize {
+            path: RcStr::from(path.to_string_lossy()),
+        });
     } else {
-        project_fs
-            .invalidate_path_and_children_with_reason(paths_to_invalidate, |path| {
-                invalidation::Initialize {
-                    path: RcStr::from(path.to_string_lossy()),
-                }
-            })
-            .await?;
+        project_fs.invalidate_path_and_children_with_reason(paths_to_invalidate, |path| {
+            invalidation::Initialize {
+                path: RcStr::from(path.to_string_lossy()),
+            }
+        });
     }
 
     Ok(())

turbopack/crates/turbo-tasks-backend/src/backend/cell_data.rs

@@ -32,7 +32,9 @@ use turbo_bincode::{
     TurboBincodeDecode, TurboBincodeDecoder, TurboBincodeEncode, TurboBincodeEncoder,
     impl_decode_for_turbo_bincode_decode, impl_encode_for_turbo_bincode_encode,
 };
-use turbo_tasks::{CellId, SharedReference, ShrinkToFit, ValueTypePersistence, registry};
+use turbo_tasks::{
+    CellId, Evictability, SharedReference, ShrinkToFit, ValueTypePersistence, registry,
+};
 
 use crate::backend::storage_schema::{DropPartial, DropPartialOutcome};
 
@@ -50,37 +52,23 @@ impl CellData {
 }
 
 impl DropPartial for CellData {
-    /// Drop cells that can be cheaply reconstructed on next access, retain
-    /// those that cannot. Called by the macro-generated `TaskStorage::drop_partial`
+    /// Drop cells whose value type is freely evictable, retain those that
+    /// are not. Called by the macro-generated `TaskStorage::drop_partial`
     /// on the data-eviction path.
     ///
-    /// Dropped:
-    /// - `Persistable` — restored from disk.
-    /// - `SkipPersist { expensive: false, .. }` — cheap to re-derive by re-running the task.
+    /// Dropped (`Evictability::Always`): persistable cells (restored from
+    /// disk on next access), skip cells (re-derived by re-running the task),
+    /// and hash-only cells (re-derived; hash gates spurious invalidation).
     ///
     /// Retained:
-    /// - `SkipPersist { expensive: true, .. }` — expensive to re-derive.
-    /// - `SessionStateful` — would lose accumulated state if dropped.
+    /// - `Evictability::Expensive` — re-derivation is non-trivial, prefer keeping in memory.
+    /// - `Evictability::Never` — value type holds session-scoped state that must not leave memory
+    ///   (`State<>` cells, file watchers, worker pools).
     fn drop_partial(&mut self) -> DropPartialOutcome {
         self.0.retain(
-            |cell_id, _| match registry::get_value_type(cell_id.type_id).persistence {
-                ValueTypePersistence::Persistable(_, _)
-                | ValueTypePersistence::SkipPersist {
-                    expensive: false,
-                    hash_only: _,
-                } => {
-                    // these are either persisted or determined to not be worth persisting because
-                    // they are cheap to re-derive
-                    false
-                }
-                ValueTypePersistence::SkipPersist {
-                    expensive: true,
-                    hash_only: _,
-                }
-                | ValueTypePersistence::SessionStateful => {
-                    // These are either impossible to derive or expensive so we retain.
-                    true
-                }
+            |cell_id, _| match registry::get_value_type(cell_id.type_id).evictability {
+                Evictability::Always => false,
+                Evictability::Expensive | Evictability::Never => true,
             },
         );
         if self.0.is_empty() {
@@ -122,9 +110,9 @@ impl ShrinkToFit for CellData {
 
 impl TurboBincodeEncode for CellData {
     /// Writes `count-of-persistable-entries` followed by each persistable
-    /// `(CellId, encoded-value)`. Entries whose value type is `SkipPersist`
-    /// or `SessionStateful` (no bincode) are skipped; they will be
-    /// reconstructed on the next task execution after restore.
+    /// `(CellId, encoded-value)`. Entries whose value type is `Skip` or
+    /// `HashOnly` (no bincode codec) are skipped; they will be reconstructed
+    /// on the next task execution after restore.
     fn encode(&self, encoder: &mut TurboBincodeEncoder) -> Result<(), EncodeError> {
         // First pass: count persistable entries. One extra O(N) iteration over
         // the registry — cold path (snapshot time only) and the registry is a
@@ -185,16 +173,20 @@ impl_decode_for_turbo_bincode_decode!(CellData);
 
 #[cfg(test)]
 mod tests {
-    //! `drop_partial` must partition cells by their `ValueTypePersistence` —
-    //! keep the non-recoverable ones, drop the rest. Tests below declare one
-    //! value type per persistence variant and exercise every partition.
+    //! `drop_partial` must partition cells by their `Evictability` — keep
+    //! the non-evictable ones, drop the rest. Tests below cover every
+    //! `(persistence, evictability)` combination the macro currently emits,
+    //! including the `Persistable + Never` combo (e.g. `DiskFileSystem`).
     use turbo_tasks::{self as turbo_tasks, VcValueType};
 
     use super::*;
 
     #[turbo_tasks::value]
     struct PersistableV(#[allow(dead_code)] u32);
 
+    #[turbo_tasks::value(evict = "never")]
+    struct PersistableNeverV(#[allow(dead_code)] u32);
+
     #[turbo_tasks::value(serialization = "skip")]
     struct SkipCheapV(
         #[turbo_tasks(trace_ignore)]
@@ -229,16 +221,18 @@ mod tests {
     }
 
     #[test]
-    fn drop_partial_partitions_by_persistence() {
+    fn drop_partial_partitions_by_evictability() {
         let mut data = CellData::new();
         data.insert(cell_of::<PersistableV>(0), dummy_ref());
+        data.insert(cell_of::<PersistableNeverV>(0), dummy_ref());
         data.insert(cell_of::<SkipCheapV>(0), dummy_ref());
         data.insert(cell_of::<SkipExpensiveV>(0), dummy_ref());
         data.insert(cell_of::<SessionStatefulV>(0), dummy_ref());
         data.insert(cell_of::<HashOnlyV>(0), dummy_ref());
 
         assert_eq!(data.drop_partial(), DropPartialOutcome::HasResidue);
-        assert_eq!(data.len(), 2);
+        assert_eq!(data.len(), 3);
+        assert!(data.contains_key(&cell_of::<PersistableNeverV>(0)));
         assert!(data.contains_key(&cell_of::<SkipExpensiveV>(0)));
         assert!(data.contains_key(&cell_of::<SessionStatefulV>(0)));
         assert!(!data.contains_key(&cell_of::<PersistableV>(0)));
@@ -247,7 +241,7 @@ mod tests {
     }
 
     #[test]
-    fn drop_partial_fully_empties_when_all_recoverable() {
+    fn drop_partial_fully_empties_when_all_evictable() {
         let mut data = CellData::new();
         data.insert(cell_of::<PersistableV>(0), dummy_ref());
         data.insert(cell_of::<SkipCheapV>(0), dummy_ref());
@@ -258,13 +252,14 @@ mod tests {
     }
 
     #[test]
-    fn drop_partial_keeps_everything_when_all_non_recoverable() {
+    fn drop_partial_keeps_everything_when_all_non_evictable() {
         let mut data = CellData::new();
+        data.insert(cell_of::<PersistableNeverV>(0), dummy_ref());
         data.insert(cell_of::<SkipExpensiveV>(0), dummy_ref());
         data.insert(cell_of::<SessionStatefulV>(0), dummy_ref());
 
         assert_eq!(data.drop_partial(), DropPartialOutcome::HasResidue);
-        assert_eq!(data.len(), 2);
+        assert_eq!(data.len(), 3);
     }
 
     #[test]

turbopack/crates/turbo-tasks-backend/src/backend/mod.rs

@@ -14,7 +14,7 @@ use std::{
     pin::Pin,
     sync::{
         Arc, LazyLock,
-        atomic::{AtomicBool, AtomicU64, Ordering},
+        atomic::{AtomicBool, Ordering},
     },
     time::SystemTime,
 };

turbopack/crates/turbo-tasks-backend/src/backend/operation/update_cell.rs

@@ -65,13 +65,7 @@ impl UpdateCellOperation {
         // cleared.)
         debug_assert!(
             content_hash.is_none()
-                || matches!(
-                    value_type.persistence,
-                    ValueTypePersistence::SkipPersist {
-                        expensive: _,
-                        hash_only: true
-                    }
-                ),
+                || matches!(value_type.persistence, ValueTypePersistence::HashOnly),
             "content_hash must only be supplied for HashOnly cells"
         );
 
@@ -118,23 +112,18 @@ impl UpdateCellOperation {
 
             // For HashOnly cells without available content, use hash-based comparison to
             // detect whether the value actually changed—avoiding unnecessary invalidation.
-            let skip_invalidation = matches!(
-                value_type.persistence,
-                ValueTypePersistence::SkipPersist {
-                    expensive: _,
-                    hash_only: true
-                }
-            ) && {
-                let has_old_content = task.cell_data_contains(&cell);
-                if !has_old_content {
-                    match (content_hash, task.get_cell_data_hash(&cell)) {
-                        (Some(new_hash), Some(old_hash)) => new_hash == *old_hash,
-                        _ => false,
+            let skip_invalidation =
+                matches!(value_type.persistence, ValueTypePersistence::HashOnly) && {
+                    let has_old_content = task.cell_data_contains(&cell);
+                    if !has_old_content {
+                        match (content_hash, task.get_cell_data_hash(&cell)) {
+                            (Some(new_hash), Some(old_hash)) => new_hash == *old_hash,
+                            _ => false,
+                        }
+                    } else {
+                        false
                     }
-                } else {
-                    false
-                }
-            };
+                };
 
             #[cfg(feature = "trace_task_dirty")]
             let has_updated_key_hashes = updated_key_hashes.is_some();
@@ -181,13 +170,7 @@ impl UpdateCellOperation {
                 let old_content = task.remove_cell_data(&cell);
 
                 // Update cell_data_hash before dropping the task lock
-                if matches!(
-                    value_type.persistence,
-                    ValueTypePersistence::SkipPersist {
-                        expensive: _,
-                        hash_only: true
-                    }
-                ) {
+                if matches!(value_type.persistence, ValueTypePersistence::HashOnly) {
                     update_cell_data_hash(&mut task, &cell, content_hash);
                 }
 
@@ -226,14 +209,8 @@ impl UpdateCellOperation {
             task.remove_cell_data(&cell)
         };
 
-        // Update cell_data_hash for non-hashonly cells.
-        if matches!(
-            value_type.persistence,
-            ValueTypePersistence::SkipPersist {
-                expensive: _,
-                hash_only: true
-            }
-        ) {
+        // Update cell_data_hash for hash-only cells.
+        if matches!(value_type.persistence, ValueTypePersistence::HashOnly) {
             update_cell_data_hash(&mut task, &cell, content_hash);
         }
 

turbopack/crates/turbo-tasks-backend/src/backend/storage_schema.rs

@@ -287,13 +287,15 @@ struct TaskStorageSchema {
     // =========================================================================
     /// Cell data for all cells, regardless of serialization mode.
     ///
-    /// `CellData` is a newtype over `AutoMap<CellId, SharedReference>` whose
-    /// bincode impl filters out entries whose value type is not
-    /// `ValueTypePersistence::Persistable` at encode time (i.e. `SkipPersist`
-    /// or `SessionStateful`). Those entries stay in memory but are not
-    /// persisted — on restore the next read triggers the "cell index in range
-    /// but data missing" recompute path. `SessionStateful` value types are
-    /// identified on `ValueType::persistence` for future eviction handling.
+    /// `CellData` is a newtype over `AutoMap<CellId, SharedReference>` with
+    /// two policies driven by the value type registry:
+    ///
+    /// - **Persistence** (encode time): only entries whose value type has
+    ///   `ValueTypePersistence::Persistable` are written to disk. `Skip` and `HashOnly` entries
+    ///   stay in memory only — on restore the next read triggers the "cell index in range but data
+    ///   missing" recompute path.
+    /// - **Eviction** (`drop_partial`): entries are dropped iff their value type's `Evictability`
+    ///   is `Always`. `Expensive` and `Never` cells stay in memory across the eviction sweep.
     #[field(
         storage = "auto_map",
         category = "data",