fix(wasm): keep cli storage helpers out of browser build

Author: fireairforce

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

@@ -1,16 +1,19 @@
+use std::{borrow::Borrow, path::PathBuf, sync::Arc};
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 use std::{
-    borrow::Borrow,
     env,
-    path::PathBuf,
-    sync::{Arc, LazyLock, Mutex, PoisonError, Weak},
+    sync::{LazyLock, Mutex, PoisonError, Weak},
 };
 
-use anyhow::{Context, Result};
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
+use anyhow::Context;
+use anyhow::Result;
 use smallvec::SmallVec;
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 use turbo_bincode::{new_turbo_bincode_decoder, turbo_bincode_decode, turbo_bincode_encode};
+use turbo_tasks::{DynTaskInputs, RawVc, TaskId, macro_helpers::NativeFunction};
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 use turbo_tasks::{
-    DynTaskInputs, RawVc, TaskId,
-    macro_helpers::NativeFunction,
     panic_hooks::{PanicHookGuard, register_panic_hook},
     parallel,
 };
@@ -19,10 +22,13 @@ use crate::{
     GitVersionInfo,
     backend::{AnyOperation, SpecificTaskDataCategory, storage_schema::TaskStorage},
     backing_storage::{SnapshotItem, SnapshotMeta, compute_task_type_hash_from_components},
+    database::{db_invalidation::StartupCacheState, key_value_database::KeySpace},
+};
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
+use crate::{
     database::{
-        db_invalidation::{StartupCacheState, check_db_invalidation_and_cleanup, invalidate_db},
+        db_invalidation::{check_db_invalidation_and_cleanup, invalidate_db},
         db_versioning::handle_db_versioning,
-        key_value_database::KeySpace,
         turbo::{TurboKeyValueDatabase, TurboWriteBatch},
         write_batch::WriteBuffer,
     },
@@ -32,20 +38,24 @@ use crate::{
 const META_KEY_OPERATIONS: u32 = 0;
 const META_KEY_NEXT_FREE_TASK_ID: u32 = 1;
 
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 struct IntKey([u8; 4]);
 
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 impl IntKey {
     fn new(value: u32) -> Self {
         Self(value.to_le_bytes())
     }
 }
 
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 impl AsRef<[u8]> for IntKey {
     fn as_ref(&self) -> &[u8] {
         &self.0
     }
 }
 
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 fn as_u32(bytes: impl Borrow<[u8]>) -> Result<u32> {
     let n = u32::from_le_bytes(bytes.borrow().try_into()?);
     Ok(n)
@@ -59,6 +69,7 @@ fn as_u32(bytes: impl Borrow<[u8]>) -> Result<u32> {
 //
 // These overrides let us avoid the cache invalidation / error suppression within Vercel so that we
 // feel these pain points and fix the root causes of bugs.
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 fn should_invalidate_on_panic() -> bool {
     fn env_is_falsy(key: &str) -> bool {
         env::var_os(key)
@@ -70,6 +81,7 @@ fn should_invalidate_on_panic() -> bool {
     *SHOULD_INVALIDATE
 }
 
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 struct TurboBackingStorageInner {
     database: TurboKeyValueDatabase,
     /// Used when calling [`TurboBackingStorage::invalidate`]. Can be `None` in the
@@ -89,11 +101,16 @@ struct TurboBackingStorageInner {
 /// backend needs (snapshots, task-candidate lookups, etc.).
 ///
 /// [`TurboTasksBackend::new`]: crate::TurboTasksBackend::new
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 pub struct TurboBackingStorage {
     // wrapped so that `register_panic_hook` can hold a weak reference to `inner`.
     inner: Arc<TurboBackingStorageInner>,
 }
 
+#[cfg(all(target_family = "wasm", target_os = "unknown"))]
+pub struct TurboBackingStorage;
+
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 impl TurboBackingStorage {
     pub(crate) fn new_in_memory(database: TurboKeyValueDatabase) -> Self {
         Self {
@@ -157,6 +174,7 @@ impl TurboBackingStorage {
     }
 }
 
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 impl TurboBackingStorageInner {
     fn invalidate(&self, reason_code: &str) -> Result<()> {
         // `base_path` is `None` for in-memory backing storage (see `noop_backing_storage`).
@@ -190,6 +208,7 @@ impl TurboBackingStorageInner {
     }
 }
 
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 impl TurboBackingStorage {
     /// Called when the database should be invalidated upon re-initialization.
     ///
@@ -408,6 +427,75 @@ impl TurboBackingStorage {
     }
 }
 
+#[cfg(all(target_family = "wasm", target_os = "unknown"))]
+impl TurboBackingStorage {
+    pub(crate) fn new_in_memory() -> Self {
+        Self
+    }
+
+    pub(crate) fn invalidate(&self, _reason_code: &str) -> Result<()> {
+        Ok(())
+    }
+
+    pub(crate) fn next_free_task_id(&self) -> Result<TaskId> {
+        Ok(TaskId::MIN)
+    }
+
+    pub(crate) fn uncompleted_operations(&self) -> Result<Vec<AnyOperation>> {
+        Ok(Vec::new())
+    }
+
+    pub(crate) fn save_snapshot<I>(
+        &self,
+        _operations: Vec<Arc<AnyOperation>>,
+        _snapshots: Vec<I>,
+    ) -> Result<SnapshotMeta>
+    where
+        I: IntoIterator<Item = SnapshotItem> + Send + Sync,
+    {
+        Ok(SnapshotMeta::default())
+    }
+
+    pub(crate) fn lookup_task_candidates(
+        &self,
+        _native_fn: &'static NativeFunction,
+        _this: Option<RawVc>,
+        _arg: &dyn DynTaskInputs,
+    ) -> Result<SmallVec<[TaskId; 1]>> {
+        Ok(SmallVec::new())
+    }
+
+    pub(crate) fn lookup_data(
+        &self,
+        _task_id: TaskId,
+        _category: SpecificTaskDataCategory,
+        _storage: &mut TaskStorage,
+    ) -> Result<()> {
+        Ok(())
+    }
+
+    pub(crate) fn batch_lookup_data(
+        &self,
+        task_ids: &[TaskId],
+        _category: SpecificTaskDataCategory,
+    ) -> Result<Vec<TaskStorage>> {
+        Ok(task_ids.iter().map(|_| TaskStorage::new()).collect())
+    }
+
+    pub(crate) fn compact(&self) -> Result<bool> {
+        Ok(false)
+    }
+
+    pub(crate) fn shutdown(&self) -> Result<()> {
+        Ok(())
+    }
+
+    pub(crate) fn has_unrecoverable_write_error(&self) -> bool {
+        false
+    }
+}
+
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 fn get_next_free_task_id(batch: &TurboWriteBatch<'_>) -> Result<u32, anyhow::Error> {
     Ok(
         match batch.get(
@@ -420,6 +508,7 @@ fn get_next_free_task_id(batch: &TurboWriteBatch<'_>) -> Result<u32, anyhow::Err
     )
 }
 
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 fn save_infra(
     batch: &TurboWriteBatch<'_>,
     next_task_id: u32,

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

@@ -51,10 +51,20 @@ pub fn turbo_backing_storage(
 /// Creates an in-memory `BackingStorage` to be passed to [`TurboTasksBackend::new`]. Backed by
 /// an empty, read-only [`TurboPersistence`] — reads return `None`, writes are not expected
 /// (callers should set [`BackendOptions::storage_mode`] to `None`).
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 pub fn noop_backing_storage() -> TurboBackingStorage {
     TurboBackingStorage::new_in_memory(TurboKeyValueDatabase::empty_in_memory())
 }
 
+/// Creates a no-op `BackingStorage` for browser wasm builds.
+///
+/// Browser wasm has no on-disk persistence; callers should set
+/// [`BackendOptions::storage_mode`] to `None`.
+#[cfg(all(target_family = "wasm", target_os = "unknown"))]
+pub fn noop_backing_storage() -> TurboBackingStorage {
+    TurboBackingStorage::new_in_memory()
+}
+
 /// Opens a Turbopack persistent cache database at the given base path and performs a full
 /// compaction. This is intended for use by the `next internal post-build` CLI command to optimize
 /// the database after a build, without requiring the full turbo-tasks runtime.

turbopack/crates/turbopack-cli-utils/Cargo.toml

@@ -17,7 +17,6 @@ workspace = true
 [dependencies]
 anyhow = { workspace = true }
 async-trait = { workspace = true }
-crossterm = "0.29.0"
 clap = { workspace = true, features = ["derive"] }
 owo-colors = { workspace = true }
 rustc-hash = { workspace = true }
@@ -27,3 +26,6 @@ turbo-tasks = { workspace = true }
 turbo-tasks-fs = { workspace = true }
 turbopack-core = { workspace = true }
 turbopack-resolve = { workspace = true }
+
+[target.'cfg(not(all(target_family = "wasm", target_os = "unknown")))'.dependencies]
+crossterm = "0.29.0"

turbopack/crates/turbopack-cli-utils/src/lib.rs

@@ -2,6 +2,7 @@
 #![feature(arbitrary_self_types)]
 #![feature(arbitrary_self_types_pointers)]
 
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 pub mod issue;
 pub mod runtime_entry;
 pub mod source_context;

turbopack/crates/turbopack-ecmascript/src/analyzer/well_known/mod.rs

@@ -593,19 +593,35 @@ fn require_context_require_resolve<'a>(
 fn path_to_file_url<'a>(arena: &'a Bump, args: BumpVec<'a, JsValue<'a>>) -> JsValue<'a> {
     if args.len() == 1 {
         if let Some(path) = args[0].as_str() {
-            Url::from_file_path(path)
-                .map(|url| JsValue::Url(String::from(url).into(), JsValueUrlKind::Absolute))
-                .unwrap_or_else(|_| {
-                    JsValue::unknown(
-                        JsValue::call_from_parts(
-                            arena,
-                            JsValue::WellKnownFunction(WellKnownFunctionKind::PathToFileUrl),
-                            args,
-                        ),
-                        true,
-                        rcstr!("url not parseable: path is relative or has an invalid prefix"),
-                    )
-                })
+            #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
+            {
+                Url::from_file_path(path)
+                    .map(|url| JsValue::Url(String::from(url).into(), JsValueUrlKind::Absolute))
+                    .unwrap_or_else(|_| {
+                        JsValue::unknown(
+                            JsValue::call_from_parts(
+                                arena,
+                                JsValue::WellKnownFunction(WellKnownFunctionKind::PathToFileUrl),
+                                args,
+                            ),
+                            true,
+                            rcstr!("url not parseable: path is relative or has an invalid prefix"),
+                        )
+                    })
+            }
+            #[cfg(all(target_family = "wasm", target_os = "unknown"))]
+            {
+                let _ = path;
+                JsValue::unknown(
+                    JsValue::call_from_parts(
+                        arena,
+                        JsValue::WellKnownFunction(WellKnownFunctionKind::PathToFileUrl),
+                        args,
+                    ),
+                    true,
+                    rcstr!("pathToFileURL constant evaluation is not supported in browser wasm"),
+                )
+            }
         } else {
             JsValue::unknown(
                 JsValue::call_from_parts(