diff --git a/.cargo/config.toml b/.cargo/config.toml
index a20e20d2971e..95a1cb5189af 100644
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -73,4 +73,4 @@ rustflags = [
 linker = "arm-linux-gnueabihf-gcc"
 
 [target.wasm32-unknown-unknown]
-rustflags = ["-Zshare-generics=y", "--cfg", 'getrandom_backend="wasm_js"']
+rustflags = ["-Zshare-generics=y", "-Aunused", "--cfg", 'getrandom_backend="wasm_js"']
diff --git a/Cargo.lock b/Cargo.lock
index a06447a33961..9e85e1f0bea0 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1318,7 +1318,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "117725a109d387c937a1533ce01b450cbde6b88abceea8473c4d7a85853cda3c"
 dependencies = [
  "lazy_static",
- "windows-sys 0.59.0",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
@@ -1469,6 +1469,15 @@ dependencies = [
  "unicode-segmentation",
 ]
 
+[[package]]
+name = "convert_case"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb402b8d4c85569410425650ce3eddc7d698ed96d39a73f941b08fb63082f1e7"
+dependencies = [
+ "unicode-segmentation",
+]
+
 [[package]]
 name = "cooked-waker"
 version = "5.0.0"
@@ -1713,15 +1722,17 @@ dependencies = [
 
 [[package]]
 name = "crossterm"
-version = "0.26.1"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a84cda67535339806297f1b331d6dd6320470d2a0fe65381e79ee9e156dd3d13"
+checksum = "d8b9f2e4c67f833b660cdb0a3523065869fb35570177239812ed4c905aeff87b"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags 2.9.1",
  "crossterm_winapi",
- "libc",
- "mio 0.8.11",
+ "derive_more 2.0.1",
+ "document-features",
+ "mio 1.0.3",
  "parking_lot",
+ "rustix 1.0.7",
  "signal-hook",
  "signal-hook-mio",
  "winapi",
@@ -2077,6 +2088,7 @@ version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bda628edc44c4bb645fbe0f758797143e4e07926f7ebf4e9bdfbd3d2ce621df3"
 dependencies = [
+ "convert_case 0.7.1",
  "proc-macro2",
  "quote",
  "syn 2.0.104",
@@ -2134,9 +2146,9 @@ dependencies = [
 
 [[package]]
 name = "document-features"
-version = "0.2.10"
+version = "0.2.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb6969eaabd2421f8a2775cfd2471a2b634372b4a25d41e3bd647b79912850a0"
+checksum = "d4b8a88685455ed29a21542a33abd9cb6510b6b129abadabdcef0f4c55bc8f61"
 dependencies = [
  "litrs",
 ]
@@ -3480,6 +3492,17 @@ dependencies = [
  "rustversion",
 ]
 
+[[package]]
+name = "io-uring"
+version = "0.7.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fdd7bddefd0a8833b88a4b68f90dae22c7450d11b354198baee3874fd811b344"
+dependencies = [
+ "bitflags 2.9.1",
+ "cfg-if",
+ "libc",
+]
+
 [[package]]
 name = "ipnet"
 version = "2.10.1"
@@ -3636,9 +3659,9 @@ dependencies = [
 
 [[package]]
 name = "js-sys"
-version = "0.3.77"
+version = "0.3.85"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1cfaf33c695fc6e08064efbc1f72ec937429614f25eef83af942d0e227c3a28f"
+checksum = "8c942ebf8e95485ca0d52d97da7c5a2c387d0e7f0ba4c35e93bfcaee045955b3"
 dependencies = [
  "once_cell",
  "wasm-bindgen",
@@ -3868,7 +3891,7 @@ version = "1.0.0-alpha.43"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "84c12744d1279367caed41739ef094c325d53fb0ffcd4f9b84a368796f870252"
 dependencies = [
- "convert_case",
+ "convert_case 0.6.0",
  "proc-macro2",
  "quote",
  "syn 1.0.109",
@@ -3932,9 +3955,9 @@ checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77"
 
 [[package]]
 name = "litrs"
-version = "0.4.1"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4ce301924b7887e9d637144fdade93f9dfff9b60981d4ac161db09720d39aa5"
+checksum = "11d3d7f243d5c5a8b9bb5d6dd2b1602c0cb0b9db1621bafc7ed66e35ff9fe092"
 
 [[package]]
 name = "lmdb-rkv"
@@ -4289,7 +4312,7 @@ version = "0.110.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "733b723f4e2a9c561b611aed657e6c3938941124fa1cb83b6a3b8e61511ff3c4"
 dependencies = [
- "convert_case",
+ "convert_case 0.6.0",
  "handlebars",
  "once_cell",
  "regex",
@@ -4367,7 +4390,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7cbe2585d8ac223f7d34f13701434b9d5f4eb9c332cccce8dee57ea18ab8ab0c"
 dependencies = [
  "cfg-if",
- "convert_case",
+ "convert_case 0.6.0",
  "napi-derive-backend",
  "proc-macro2",
  "quote",
@@ -4380,7 +4403,7 @@ version = "1.0.75"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1639aaa9eeb76e91c6ae66da8ce3e89e921cd3885e99ec85f4abacae72fc91bf"
 dependencies = [
- "convert_case",
+ "convert_case 0.6.0",
  "once_cell",
  "proc-macro2",
  "quote",
@@ -5318,9 +5341,9 @@ dependencies = [
 
 [[package]]
 name = "pin-project-lite"
-version = "0.2.13"
+version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8afb450f006bf6385ca15ef45d71d2288452bc3683ce2e2cacc0d18e4be60b58"
+checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
 
 [[package]]
 name = "pin-utils"
@@ -6927,12 +6950,13 @@ dependencies = [
 
 [[package]]
 name = "signal-hook-mio"
-version = "0.2.3"
+version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29ad2e15f37ec9a6cc544097b78a1ec90001e9f71b81338ca39f430adaca99af"
+checksum = "b75a19a7a740b25bc7944bdee6172368f988763b744e3d4dfe753f6b4ece40cc"
 dependencies = [
  "libc",
  "mio 0.8.11",
+ "mio 1.0.3",
  "signal-hook",
 ]
 
@@ -7055,6 +7079,16 @@ dependencies = [
  "windows-sys 0.52.0",
 ]
 
+[[package]]
+name = "socket2"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "17129e116933cf371d018bb80ae557e889637989d8638274fb25622827b03881"
+dependencies = [
+ "libc",
+ "windows-sys 0.60.2",
+]
+
 [[package]]
 name = "spin"
 version = "0.9.8"
@@ -8918,28 +8952,50 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "tokio"
-version = "1.43.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d61fa4ffa3de412bfea335c6ecff681de2b609ba3c77ef3e00e521813a9ed9e"
+version = "1.47.1"
+source = "git+https://github.com/utooland/tokio.git#0b9f7720e2b65634e0fb7d7d8be9073fc21d96a1"
 dependencies = [
  "backtrace",
  "bytes",
+ "io-uring",
  "libc",
  "mio 1.0.3",
  "parking_lot",
  "pin-project-lite",
  "signal-hook-registry",
- "socket2 0.5.10",
+ "slab",
+ "socket2 0.6.1",
  "tokio-macros",
  "tracing",
- "windows-sys 0.52.0",
+ "wasm_thread",
+ "wasmtimer",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "tokio-fs-ext"
+version = "0.7.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db902ff0804cc7965a81fec91151b9c27ed3a489c217a5dc7a885064fb0c1571"
+dependencies = [
+ "bitflags 2.9.1",
+ "cfg-if",
+ "futures",
+ "js-sys",
+ "notify-types",
+ "pin-project-lite",
+ "rustc-hash 2.1.1",
+ "tokio",
+ "tokio-stream",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
 ]
 
 [[package]]
 name = "tokio-macros"
 version = "2.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e06d43f1345a3bcd39f6a56dbb7dcab2ba47e68e8ac134855e7e2bdbaf8cab8"
+source = "git+https://github.com/utooland/tokio.git#0b9f7720e2b65634e0fb7d7d8be9073fc21d96a1"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -8992,15 +9048,13 @@ dependencies = [
 
 [[package]]
 name = "tokio-util"
-version = "0.7.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7fcaa8d55a2bdd6b83ace262b016eca0d79ee02818c5c1bcdf0305114081078"
+version = "0.7.16"
+source = "git+https://github.com/utooland/tokio.git#0b9f7720e2b65634e0fb7d7d8be9073fc21d96a1"
 dependencies = [
  "bytes",
  "futures-core",
  "futures-sink",
  "futures-util",
- "hashbrown 0.14.5",
  "pin-project-lite",
  "tokio",
 ]
@@ -9686,6 +9740,7 @@ dependencies = [
  "jsonc-parser",
  "mime",
  "notify",
+ "notify-types",
  "parking_lot",
  "rand 0.10.0",
  "regex",
@@ -9698,6 +9753,7 @@ dependencies = [
  "tempfile",
  "thiserror 1.0.69",
  "tokio",
+ "tokio-fs-ext",
  "tracing",
  "triomphe 0.1.12",
  "turbo-bincode",
@@ -9731,6 +9787,7 @@ version = "0.1.0"
 dependencies = [
  "bincode 2.0.1",
  "data-encoding",
+ "getrandom 0.3.3",
  "sha2",
  "turbo-tasks-macros",
  "twox-hash 2.1.2",
@@ -9804,7 +9861,6 @@ dependencies = [
  "serde",
  "serde_json",
  "smallvec",
- "tokio",
  "tracing",
  "turbo-esregex",
  "turbo-rcstr",
@@ -9877,6 +9933,8 @@ dependencies = [
  "bincode 2.0.1",
  "either",
  "indoc",
+ "qstring",
+ "regex",
  "serde",
  "serde_json",
  "serde_qs",
@@ -9887,6 +9945,7 @@ dependencies = [
  "turbo-tasks-fs",
  "turbo-tasks-hash",
  "turbopack-core",
+ "turbopack-css",
  "turbopack-ecmascript",
  "turbopack-ecmascript-runtime",
  "turbopack-resolve",
@@ -9942,7 +10001,8 @@ name = "turbopack-cli-utils"
 version = "0.1.0"
 dependencies = [
  "anyhow",
- "crossterm 0.26.1",
+ "clap",
+ "crossterm 0.29.0",
  "owo-colors",
  "rustc-hash 2.1.1",
  "serde",
@@ -10260,12 +10320,14 @@ dependencies = [
  "async-trait",
  "base64 0.21.4",
  "bincode 2.0.1",
+ "bytes",
  "const_format",
  "dashmap 6.1.0",
  "either",
  "futures",
  "futures-retry",
  "indoc",
+ "js-sys",
  "napi",
  "napi-derive",
  "once_cell",
@@ -10290,6 +10352,8 @@ dependencies = [
  "turbopack-core",
  "turbopack-ecmascript",
  "turbopack-resolve",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
 ]
 
 [[package]]
@@ -11020,37 +11084,26 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.100"
+version = "0.2.108"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1edc8929d7499fc4e8f0be2262a241556cfc54a0bea223790e71446f2aab1ef5"
+checksum = "64024a30ec1e37399cf85a7ffefebdb72205ca1c972291c51512360d90bd8566"
 dependencies = [
  "cfg-if",
  "once_cell",
  "rustversion",
  "wasm-bindgen-macro",
-]
-
-[[package]]
-name = "wasm-bindgen-backend"
-version = "0.2.100"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f0a0651a5c2bc21487bde11ee802ccaf4c51935d0d3d42a6101f98161700bc6"
-dependencies = [
- "bumpalo",
- "log",
- "proc-macro2",
- "quote",
- "syn 2.0.104",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.50"
+version = "0.4.58"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "555d470ec0bc3bb57890405e5d4322cc9ea83cebb085523ced7be4144dac1e61"
+checksum = "70a6e77fd0ae8029c9ea0063f87c46fde723e7d887703d74ad2616d792e51e6f"
 dependencies = [
  "cfg-if",
+ "futures-core",
+ "futures-util",
  "js-sys",
  "once_cell",
  "wasm-bindgen",
@@ -11059,9 +11112,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.100"
+version = "0.2.108"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fe63fc6d09ed3792bd0897b314f53de8e16568c2b3f7982f468c0bf9bd0b407"
+checksum = "008b239d9c740232e71bd39e8ef6429d27097518b6b30bdf9086833bd5b6d608"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -11069,22 +11122,22 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.100"
+version = "0.2.108"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de"
+checksum = "5256bae2d58f54820e6490f9839c49780dff84c65aeab9e772f15d5f0e913a55"
 dependencies = [
+ "bumpalo",
  "proc-macro2",
  "quote",
  "syn 2.0.104",
- "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.100"
+version = "0.2.108"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a05d73b933a847d6cccdda8f838a22ff101ad9bf93e33684f39c1f5f0eece3d"
+checksum = "1f01b580c9ac74c8d8f0c0e4afb04eeef2acf145458e52c03845ee9cd23e3d12"
 dependencies = [
  "unicode-ident",
 ]
@@ -11121,6 +11174,17 @@ dependencies = [
  "wasmparser 0.244.0",
 ]
 
+[[package]]
+name = "wasm_thread"
+version = "0.3.3"
+source = "git+https://github.com/utooland/wasm_thread.git#fd53c2f5a20e9f899d9216dee045472f50d97219"
+dependencies = [
+ "futures",
+ "js-sys",
+ "wasm-bindgen",
+ "web-sys",
+]
+
 [[package]]
 name = "wasmer"
 version = "6.1.0-rc.3"
@@ -11480,6 +11544,20 @@ dependencies = [
  "semver",
 ]
 
+[[package]]
+name = "wasmtimer"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c598d6b99ea013e35844697fc4670d08339d5cda15588f193c6beedd12f644b"
+dependencies = [
+ "futures",
+ "js-sys",
+ "parking_lot",
+ "pin-utils",
+ "slab",
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "wast"
 version = "235.0.0"
@@ -11504,9 +11582,9 @@ dependencies = [
 
 [[package]]
 name = "web-sys"
-version = "0.3.77"
+version = "0.3.85"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33b6dd2ef9186f1f2072e409e99cd22a975331a6b3591b12c764e0e55c60d5d2"
+checksum = "312e32e551d92129218ea9a2452120f4aabc03529ef03e4d0d82fb2780608598"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
diff --git a/Cargo.toml b/Cargo.toml
index 526990132a26..13237f81a953 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -428,6 +428,7 @@ napi-derive = "2"
 napi-build = "2"
 nohash-hasher = "0.2.0"
 notify = "8.1.0"
+notify-types = "2.0.0"
 once_cell = "1.21.3"
 owo-colors = "4.2.2"
 parcel_selectors = "0.28.2"
@@ -441,6 +442,7 @@ qstring = "0.7.2"
 quick_cache = { version = "0.6.14" }
 quote = "1.0.23"
 rand = "0.10.0"
+getrandom = "0.3"
 rayon = "1.10.0"
 regex = "1.10.6"
 regress = "0.10.4"
@@ -470,8 +472,8 @@ syn = "2.0.100"
 tempfile = "3.20.0"
 thiserror = "1.0.48"
 thread_local = "1.1.8"
-tokio = "1.43.0"
-tokio-util = { version = "0.7.13", features = ["io", "rt"] }
+tokio = "1.47.1"
+tokio-util = { version = "0.7.16", features = ["io", "rt"] }
 tracing = "0.1.37"
 tracing-subscriber = "0.3.16"
 triomphe = { git = "https://github.com/sokra/triomphe", branch = "sokra/unstable" }
@@ -492,3 +494,5 @@ virtue = { git = "https://github.com/bgw/virtue.git", branch = "bgw/fix-generic-
 mdxjs = { git = "https://github.com/vercel-labs/mdxjs-rs-turbopack.git", branch = "turbopack" }
 # Doesn't compile on recent nightly versions because of https://github.com/Michael-F-Bryan/include_dir/pull/117
 include_dir = { git = "https://github.com/vercel-labs/include_dir", branch = "turbopack" }
+tokio = { git = "https://github.com/utooland/tokio.git", package = "tokio" }
+tokio-util = { git = "https://github.com/utooland/tokio.git", package = "tokio-util" }
diff --git a/crates/next-core/src/transform_options.rs b/crates/next-core/src/transform_options.rs
index 22468bdd74d9..b4a1fffa3902 100644
--- a/crates/next-core/src/transform_options.rs
+++ b/crates/next-core/src/transform_options.rs
@@ -54,7 +54,7 @@ pub async fn get_typescript_transform_options(
 ) -> Result<Vc<TypescriptTransformOptions>> {
     let tsconfig = get_typescript_options(project_path, tsconfig_path).await?;
 
-    let use_define_for_class_fields = if let Some(tsconfig) = tsconfig {
+    let use_define_for_class_fields = if let Some(ref tsconfig) = tsconfig {
         read_from_tsconfigs(&tsconfig, |json, _| {
             json["compilerOptions"]["useDefineForClassFields"].as_bool()
         })
@@ -63,9 +63,19 @@ pub async fn get_typescript_transform_options(
     } else {
         false
     };
+    let verbatim_module_syntax = if let Some(ref tsconfig) = tsconfig {
+        read_from_tsconfigs(tsconfig, |json, _| {
+            json["compilerOptions"]["verbatimModuleSyntax"].as_bool()
+        })
+        .await?
+        .unwrap_or(false)
+    } else {
+        false
+    };
 
     let ts_transform_options = TypescriptTransformOptions {
         use_define_for_class_fields,
+        verbatim_module_syntax,
     };
 
     Ok(ts_transform_options.cell())
diff --git a/packages/next/src/build/swc/index.ts b/packages/next/src/build/swc/index.ts
index ba7900daf8f0..e5e996f9e039 100644
--- a/packages/next/src/build/swc/index.ts
+++ b/packages/next/src/build/swc/index.ts
@@ -41,6 +41,7 @@ import type {
 } from './types'
 import { runLoaderWorkerPool } from './loaderWorkerPool'
 import { throwTurbopackInternalError } from '../../shared/lib/turbopack/internal-error'
+import { runLoaderWorkerPool } from './loaderWorkerPool'
 
 export enum HmrTarget {
   Client = 'client',
diff --git a/turbopack/crates/turbo-tasks-backend/Cargo.toml b/turbopack/crates/turbo-tasks-backend/Cargo.toml
index aa5f4d177f46..363bd4df57a7 100644
--- a/turbopack/crates/turbo-tasks-backend/Cargo.toml
+++ b/turbopack/crates/turbo-tasks-backend/Cargo.toml
@@ -39,7 +39,7 @@ arc-swap = { version = "1.8.2" }
 auto-hash-map = { workspace = true }
 bitfield = { workspace = true }
 byteorder = { workspace = true }
-dashmap = { workspace = true, features = ["raw-api"]}
+dashmap = { workspace = true, features = ["raw-api"] }
 either = { workspace = true }
 hashbrown = { workspace = true, features = ["raw"] }
 indexmap = { workspace = true }
@@ -58,11 +58,13 @@ tokio = { workspace = true }
 tracing = { workspace = true }
 thread_local = { workspace = true }
 turbo-bincode = { workspace = true }
-turbo-persistence = { workspace = true }
 turbo-rcstr = { workspace = true }
 turbo-tasks = { workspace = true }
 turbo-tasks-hash = { workspace = true }
 
+[target.'cfg(not(all(target_family = "wasm", target_os = "unknown")))'.dependencies]
+turbo-persistence = { workspace = true }
+
 [dev-dependencies]
 criterion = { workspace = true, features = ["async_tokio"] }
 futures = { workspace = true }
diff --git a/turbopack/crates/turbo-tasks-backend/src/backend/operation/aggregation_update.rs b/turbopack/crates/turbo-tasks-backend/src/backend/operation/aggregation_update.rs
index b47c453ef0c4..b6d38a3d2971 100644
--- a/turbopack/crates/turbo-tasks-backend/src/backend/operation/aggregation_update.rs
+++ b/turbopack/crates/turbo-tasks-backend/src/backend/operation/aggregation_update.rs
@@ -7,7 +7,7 @@ use std::{
     ops::{ControlFlow, Deref},
     sync::Arc,
     thread::yield_now,
-    time::{Duration, Instant},
+    time::Duration,
 };
 
 use anyhow::Result;
@@ -16,6 +16,7 @@ use indexmap::map::Entry;
 use ringmap::RingSet;
 use rustc_hash::{FxBuildHasher, FxHashMap};
 use smallvec::{SmallVec, smallvec};
+use tokio::time::Instant;
 #[cfg(feature = "trace_aggregation_update_queue")]
 use tracing::span::Span;
 #[cfg(any(
diff --git a/turbopack/crates/turbo-tasks-backend/src/backend/operation/mod.rs b/turbopack/crates/turbo-tasks-backend/src/backend/operation/mod.rs
index 851a7029a837..d2e0eb9871a9 100644
--- a/turbopack/crates/turbo-tasks-backend/src/backend/operation/mod.rs
+++ b/turbopack/crates/turbo-tasks-backend/src/backend/operation/mod.rs
@@ -233,6 +233,26 @@ where
             StorageWriteGuard<'e>,
         ),
     ) {
+        // Fast path: no backing storage (e.g. WASM/NoopKvDb) — process inline,
+        // skip the Vec allocation needed for batch DB restoration.
+        #[cfg(all(target_family = "wasm", target_os = "unknown"))]
+        if !self.backend.should_restore() {
+            for (id, category) in task_ids {
+                let mut task = self.backend.storage.access_mut(id);
+                if !task.flags.is_restored(category) {
+                    task.flags.set_restored(category);
+                }
+                if id.is_transient() {
+                    if call_prepared_task_callback_for_transient_tasks {
+                        prepared_task_callback(self, id, category, task);
+                    }
+                } else {
+                    prepared_task_callback(self, id, category, task);
+                }
+            }
+            return;
+        }
+
         let mut data_count = 0;
         let mut meta_count = 0;
         let mut all_count = 0;
diff --git a/turbopack/crates/turbo-tasks-backend/src/database/key_value_database.rs b/turbopack/crates/turbo-tasks-backend/src/database/key_value_database.rs
index ab0200cf6801..b203a303c433 100644
--- a/turbopack/crates/turbo-tasks-backend/src/database/key_value_database.rs
+++ b/turbopack/crates/turbo-tasks-backend/src/database/key_value_database.rs
@@ -1,5 +1,6 @@
 use anyhow::Result;
 use smallvec::SmallVec;
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 use turbo_persistence::{FamilyConfig, FamilyKind};
 
 use crate::database::write_batch::{
@@ -13,6 +14,8 @@ pub enum KeySpace {
     TaskData = 2,
     TaskCache = 3,
 }
+
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 impl KeySpace {
     /// Returns the persistence configuration for this keyspace.
     pub const fn family_config(&self) -> FamilyConfig {
diff --git a/turbopack/crates/turbo-tasks-backend/src/database/mod.rs b/turbopack/crates/turbo-tasks-backend/src/database/mod.rs
index 5b8ec3c7c295..012a48a0c089 100644
--- a/turbopack/crates/turbo-tasks-backend/src/database/mod.rs
+++ b/turbopack/crates/turbo-tasks-backend/src/database/mod.rs
@@ -12,5 +12,6 @@ pub mod noop_kv;
 pub mod read_transaction_cache;
 #[cfg(feature = "lmdb")]
 pub mod startup_cache;
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 pub mod turbo;
 pub mod write_batch;
diff --git a/turbopack/crates/turbo-tasks-backend/src/lib.rs b/turbopack/crates/turbo-tasks-backend/src/lib.rs
index 974c91da16b9..3250f7e054e0 100644
--- a/turbopack/crates/turbo-tasks-backend/src/lib.rs
+++ b/turbopack/crates/turbo-tasks-backend/src/lib.rs
@@ -15,7 +15,9 @@ use std::path::Path;
 
 use anyhow::Result;
 
-use crate::database::{noop_kv::NoopKvDb, turbo::TurboKeyValueDatabase};
+use crate::database::noop_kv::NoopKvDb;
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
+use crate::database::turbo::TurboKeyValueDatabase;
 pub use crate::{
     backend::{BackendOptions, StorageMode, TurboTasksBackend},
     backing_storage::BackingStorage,
@@ -71,6 +73,7 @@ pub fn lmdb_backing_storage(
     )
 }
 
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 pub type TurboBackingStorage = KeyValueDatabaseBackingStorage<TurboKeyValueDatabase>;
 
 /// Creates a `BackingStorage` to be passed to [`TurboTasksBackend::new`].
@@ -79,6 +82,7 @@ pub type TurboBackingStorage = KeyValueDatabaseBackingStorage<TurboKeyValueDatab
 ///
 /// This is the fastest most-tested implementation of `BackingStorage`, and is normally returned by
 /// [`default_backing_storage`].
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 pub fn turbo_backing_storage(
     base_path: &Path,
     version_info: &GitVersionInfo,
@@ -103,11 +107,13 @@ pub fn noop_backing_storage() -> NoopBackingStorage {
 #[cfg(feature = "lmdb")]
 pub type DefaultBackingStorage = LmdbBackingStorage;
 
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 #[cfg(not(feature = "lmdb"))]
 pub type DefaultBackingStorage = TurboBackingStorage;
 
 /// Calls [`turbo_backing_storage`] (recommended) or `lmdb_backing_storage`, depending on if the
 /// `lmdb` cargo feature is enabled.
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 pub fn default_backing_storage(
     path: &Path,
     version_info: &GitVersionInfo,
diff --git a/turbopack/crates/turbo-tasks-fs/Cargo.toml b/turbopack/crates/turbo-tasks-fs/Cargo.toml
index dc01622369f3..da69fa381718 100644
--- a/turbopack/crates/turbo-tasks-fs/Cargo.toml
+++ b/turbopack/crates/turbo-tasks-fs/Cargo.toml
@@ -36,7 +36,6 @@ include_dir = { version = "0.7.3", features = ["nightly"] }
 indexmap = { workspace = true }
 jsonc-parser = { version = "0.26.3", features = ["serde"] }
 mime = { workspace = true }
-notify = { workspace = true }
 parking_lot = { workspace = true }
 regex = { workspace = true }
 rustc-hash = { workspace = true }
@@ -53,6 +52,12 @@ turbo-tasks = { workspace = true }
 turbo-tasks-hash = { workspace = true }
 turbo-unix-path = { workspace = true }
 urlencoding = { workspace = true }
+notify-types = { workspace = true }
+
+notify = { workspace = true }
+
+[target.'cfg(all(target_family = "wasm", target_os = "unknown"))'.dependencies]
+tokio-fs-ext = { version = "0.7.8", features = ["opfs_offload", "opfs_watch"] }
 
 [dev-dependencies]
 criterion = { workspace = true, features = ["async_tokio"] }
@@ -62,4 +67,3 @@ sha2 = { workspace = true }
 tempfile = { workspace = true }
 turbo-tasks-testing = { workspace = true }
 turbo-tasks-backend = { workspace = true }
-
diff --git a/turbopack/crates/turbo-tasks-fs/src/embed/dir.rs b/turbopack/crates/turbo-tasks-fs/src/embed/dir.rs
index 726e6a3bec5d..71177ac8860b 100644
--- a/turbopack/crates/turbo-tasks-fs/src/embed/dir.rs
+++ b/turbopack/crates/turbo-tasks-fs/src/embed/dir.rs
@@ -13,6 +13,7 @@ pub async fn directory_from_relative_path(
     path: RcStr,
 ) -> Result<Vc<Box<dyn FileSystem>>> {
     let disk_fs = DiskFileSystem::new(name, path);
+    #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
     disk_fs.await?.start_watching(None).await?;
 
     Ok(Vc::upcast(disk_fs))
diff --git a/turbopack/crates/turbo-tasks-fs/src/embed/file.rs b/turbopack/crates/turbo-tasks-fs/src/embed/file.rs
index 6cbc30eaac16..b85e936c38f0 100644
--- a/turbopack/crates/turbo-tasks-fs/src/embed/file.rs
+++ b/turbopack/crates/turbo-tasks-fs/src/embed/file.rs
@@ -23,6 +23,7 @@ pub async fn content_from_relative_path(
         root_path.to_string_lossy().into(),
         root_path.to_string_lossy().into(),
     );
+    #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
     disk_fs.await?.start_watching(None).await?;
 
     let fs_path = disk_fs.root().await?.join(path)?;
diff --git a/turbopack/crates/turbo-tasks-fs/src/lib.rs b/turbopack/crates/turbo-tasks-fs/src/lib.rs
index ee602f8c1e25..53225d40badb 100644
--- a/turbopack/crates/turbo-tasks-fs/src/lib.rs
+++ b/turbopack/crates/turbo-tasks-fs/src/lib.rs
@@ -46,6 +46,9 @@ use std::{
     time::Duration,
 };
 
+#[cfg(all(target_family = "wasm", target_os = "unknown"))]
+pub mod wasm_fs_offload;
+
 use anyhow::{Context, Result, anyhow, bail};
 use auto_hash_map::{AutoMap, AutoSet};
 use bincode::{Decode, Encode};
@@ -537,14 +540,24 @@ impl DiskFileSystemInner {
         let root_path = self.root_path().to_path_buf();
 
         // create the directory for the filesystem on disk, if it doesn't exist
+        #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
         retry_blocking(|| std::fs::create_dir_all(&root_path))
             .instrument(tracing::info_span!("create root directory", name = ?root_path))
             .concurrency_limited(&self.write_semaphore)
             .await?;
 
+        #[cfg(all(target_family = "wasm", target_os = "unknown"))]
+        wasm_fs_offload::CLIENT.create_dir_all(root_path).await?;
+
+        #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
         self.watcher
             .start_watching(self.clone(), report_invalidation_reason, poll_interval)?;
 
+        #[cfg(all(target_family = "wasm", target_os = "unknown"))]
+        self.watcher
+            .start_watching(self.clone(), report_invalidation_reason, poll_interval)
+            .await?;
+
         Ok(())
     }
 
@@ -554,10 +567,15 @@ impl DiskFileSystemInner {
             |fs_context| fs_context.created_directories.contains(directory),
         );
         if !already_created {
+            #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
             retry_blocking(|| std::fs::create_dir_all(directory))
                 .instrument(tracing::info_span!("create directory", name = ?directory))
                 .concurrency_limited(&self.write_semaphore)
                 .await?;
+
+            #[cfg(all(target_family = "wasm", target_os = "unknown"))]
+            wasm_fs_offload::CLIENT.create_dir_all(directory).await?;
+
             ApplyEffectsContext::with(|fs_context: &mut DiskFileSystemApplyContext| {
                 fs_context
                     .created_directories
@@ -619,6 +637,7 @@ impl DiskFileSystem {
             .await
     }
 
+    #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
     pub fn stop_watching(&self) {
         self.inner.watcher.stop_watching();
     }
@@ -708,7 +727,7 @@ impl DiskFileSystem {
     /// * `root` - Path to the given filesystem's root. Should be
     ///   [canonicalized][std::fs::canonicalize].
     pub fn new(name: RcStr, root: RcStr) -> Vc<Self> {
-        Self::new_internal(name, root, Vec::new())
+        Self::new_internal(name, root, Vec::new(), Vec::new())
     }
 
     /// Create a new instance of `DiskFileSystem`.
@@ -727,14 +746,49 @@ impl DiskFileSystem {
                 "denied_path must be normalized: {denied_path:?}"
             );
         }
-        Self::new_internal(name, root, denied_paths)
+        Self::new_internal(name, root, denied_paths, Vec::new())
+    }
+
+    /// Create a new instance of `DiskFileSystem` with watch ignore patterns.
+    /// # Arguments
+    ///
+    /// * `name` - Name of the filesystem.
+    /// * `root` - Path to the given filesystem's root. Should be
+    ///   [canonicalized][std::fs::canonicalize].
+    /// * `denied_paths` - Paths within this filesystem that are not allowed to be accessed.
+    /// * `watched_ignored` - Paths that should be ignored when watching for file changes.
+    pub fn new_with_denied_paths_and_watched_ignored(
+        name: RcStr,
+        root: RcStr,
+        denied_paths: Vec<RcStr>,
+        watched_ignored: Vec<RcStr>,
+    ) -> Vc<Self> {
+        for denied_path in &denied_paths {
+            debug_assert!(!denied_path.is_empty(), "denied_path must not be empty");
+            debug_assert!(
+                normalize_path(denied_path).as_deref() == Some(&**denied_path),
+                "denied_path must be normalized: {denied_path:?}"
+            );
+        }
+        Self::new_internal(name, root, denied_paths, watched_ignored)
     }
 }
 
 #[turbo_tasks::value_impl]
 impl DiskFileSystem {
     #[turbo_tasks::function]
-    fn new_internal(name: RcStr, root: RcStr, denied_paths: Vec<RcStr>) -> Vc<Self> {
+    fn new_internal(
+        name: RcStr,
+        root: RcStr,
+        denied_paths: Vec<RcStr>,
+        watched_ignored: Vec<RcStr>,
+    ) -> Vc<Self> {
+        let watcher = if watched_ignored.is_empty() {
+            DiskWatcher::new()
+        } else {
+            DiskWatcher::new_with_ignored_paths(watched_ignored)
+        };
+
         let instance = DiskFileSystem {
             inner: Arc::new(DiskFileSystemInner {
                 name,
@@ -745,7 +799,7 @@ impl DiskFileSystem {
                 dir_invalidator_map: InvalidatorMap::new(),
                 read_semaphore: create_read_semaphore(),
                 write_semaphore: create_write_semaphore(),
-                watcher: DiskWatcher::new(),
+                watcher,
                 denied_paths,
                 turbo_tasks: turbo_tasks_weak(),
                 tokio_handle: Handle::current(),
@@ -777,6 +831,7 @@ impl FileSystem for DiskFileSystem {
         self.inner.register_read_invalidator(&full_path)?;
 
         let _lock = self.inner.lock_path(&full_path).await;
+        #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
         let content = match retry_blocking(|| File::from_path(&full_path))
             .instrument(tracing::info_span!("read file", name = ?full_path))
             .concurrency_limited(&self.inner.read_semaphore)
@@ -788,6 +843,15 @@ impl FileSystem for DiskFileSystem {
             }
             Err(e) => return Err(anyhow!(e).context(format!("reading file {full_path:?}"))),
         };
+
+        #[cfg(all(target_family = "wasm", target_os = "unknown"))]
+        let content = match wasm_fs_offload::CLIENT.read(&full_path).await {
+            Ok(buf) => Ok(FileContent::from(File::from_bytes(buf))),
+            Err(e) if e.kind() == ErrorKind::NotFound || e.kind() == ErrorKind::InvalidFilename => {
+                Ok(FileContent::NotFound)
+            }
+            Err(e) => Err(anyhow!(e).context(format!("reading file {}", full_path.display()))),
+        }?;
         Ok(content.cell())
     }
 
@@ -804,6 +868,7 @@ impl FileSystem for DiskFileSystem {
         self.inner.register_dir_invalidator(&full_path)?;
 
         // we use the sync std function here as it's a lot faster (600%) in node-file-trace
+        #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
         let read_dir = match retry_blocking(|| std::fs::read_dir(&full_path))
             .instrument(tracing::info_span!("read directory", name = ?full_path))
             .concurrency_limited(&self.inner.read_semaphore)
@@ -821,6 +886,21 @@ impl FileSystem for DiskFileSystem {
                 return Err(anyhow!(e).context(format!("reading dir {full_path:?}")));
             }
         };
+
+        #[cfg(all(target_family = "wasm", target_os = "unknown"))]
+        let read_dir = match wasm_fs_offload::CLIENT.read_dir(&full_path).await {
+            Ok(dir) => dir,
+            Err(e)
+                if e.kind() == ErrorKind::NotFound
+                    || e.kind() == ErrorKind::NotADirectory
+                    || e.kind() == ErrorKind::InvalidFilename =>
+            {
+                return Ok(RawDirectoryContent::not_found());
+            }
+            Err(e) => {
+                bail!(anyhow!(e).context(format!("reading dir {}", full_path.display())))
+            }
+        };
         let dir_path = fs_path.path.as_str();
         let denied_entries: FxHashSet<&str> = self
             .inner
@@ -893,6 +973,7 @@ impl FileSystem for DiskFileSystem {
         self.inner.register_read_invalidator(&full_path)?;
 
         let _lock = self.inner.lock_path(&full_path).await;
+        #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
         let link_path = match retry_blocking(|| std::fs::read_link(&full_path))
             .instrument(tracing::info_span!("read symlink", name = ?full_path))
             .concurrency_limited(&self.inner.read_semaphore)
@@ -901,6 +982,13 @@ impl FileSystem for DiskFileSystem {
             Ok(res) => res,
             Err(_) => return Ok(LinkContent::NotFound.cell()),
         };
+
+        #[cfg(all(target_family = "wasm", target_os = "unknown"))]
+        let link_path: PathBuf = {
+            // TODO: not supported now
+            todo!()
+        };
+
         let is_link_absolute = link_path.is_absolute();
 
         let mut file = link_path.clone();
@@ -1038,56 +1126,83 @@ impl FileSystem for DiskFileSystem {
                     }
 
                     let content = content.clone();
-                    retry_blocking(|| {
-                        let mut f = std::fs::File::create(&full_path)?;
-                        let FileContent::Content(file) = &*content else {
-                            unreachable!()
-                        };
-                        std::io::copy(&mut file.read(), &mut f)?;
-                        #[cfg(unix)]
-                        f.set_permissions(file.meta.permissions.into())?;
-                        f.flush()?;
-
-                        static WRITE_VERSION: LazyLock<bool> = LazyLock::new(|| {
-                            std::env::var_os("TURBO_ENGINE_WRITE_VERSION")
-                                .is_some_and(|v| v == "1" || v == "true")
-                        });
-                        if *WRITE_VERSION {
-                            let mut full_path = full_path.clone().into_owned();
-                            let hash = hash_xxh3_hash64(file);
-                            let ext = full_path.extension();
-                            let ext = if let Some(ext) = ext {
-                                format!("{:016x}.{}", hash, ext.to_string_lossy())
+                    {
+                        #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
+                        {
+                            retry_blocking(|| {
+                                let mut f = std::fs::File::create(&full_path)?;
+                                let FileContent::Content(file) = &*content else {
+                                    unreachable!()
+                                };
+                                std::io::copy(&mut file.read(), &mut f)?;
+                                #[cfg(unix)]
+                                f.set_permissions(file.meta.permissions.into())?;
+                                f.flush()?;
+
+                                static WRITE_VERSION: LazyLock<bool> = LazyLock::new(|| {
+                                    std::env::var_os("TURBO_ENGINE_WRITE_VERSION")
+                                        .is_some_and(|v| v == "1" || v == "true")
+                                });
+                                if *WRITE_VERSION {
+                                    let mut full_path = full_path.clone().into_owned();
+                                    let hash = hash_xxh3_hash64(file);
+                                    let ext = full_path.extension();
+                                    let ext = if let Some(ext) = ext {
+                                        format!("{:016x}.{}", hash, ext.to_string_lossy())
+                                    } else {
+                                        format!("{hash:016x}")
+                                    };
+                                    full_path.set_extension(ext);
+                                    let mut f = std::fs::File::create(&full_path)?;
+                                    std::io::copy(&mut file.read(), &mut f)?;
+                                    #[cfg(unix)]
+                                    f.set_permissions(file.meta.permissions.into())?;
+                                    f.flush()?;
+                                }
+                                Ok::<(), io::Error>(())
+                            })
+                            .instrument(tracing::info_span!("write file", name = ?full_path))
+                            .concurrency_limited(&inner.write_semaphore)
+                        }
+
+                        #[cfg(all(target_family = "wasm", target_os = "unknown"))]
+                        async {
+                            if let FileContent::Content(file) = &*content {
+                                let mut content_buf = vec![];
+                                std::io::copy(&mut file.read(), &mut content_buf)?;
+                                wasm_fs_offload::CLIENT
+                                    .write(&full_path, &content_buf)
+                                    .await
                             } else {
-                                format!("{hash:016x}")
-                            };
-                            full_path.set_extension(ext);
-                            let mut f = std::fs::File::create(&full_path)?;
-                            std::io::copy(&mut file.read(), &mut f)?;
-                            #[cfg(unix)]
-                            f.set_permissions(file.meta.permissions.into())?;
-                            f.flush()?;
+                                unreachable!()
+                            }
                         }
-                        Ok::<(), io::Error>(())
-                    })
-                    .instrument(tracing::info_span!("write file", name = ?full_path))
-                    .concurrency_limited(&inner.write_semaphore)
+                    }
                     .await
                     .with_context(|| format!("failed to write to {full_path:?}"))?;
                 }
                 FileContent::NotFound => {
-                    retry_blocking(|| std::fs::remove_file(&full_path))
-                        .instrument(tracing::info_span!("remove file", name = ?full_path))
-                        .concurrency_limited(&inner.write_semaphore)
-                        .await
-                        .or_else(|err| {
-                            if err.kind() == ErrorKind::NotFound {
-                                Ok(())
-                            } else {
-                                Err(err)
-                            }
-                        })
-                        .with_context(|| format!("removing {full_path:?} failed"))?;
+                    {
+                        #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
+                        {
+                            retry_blocking(|| std::fs::remove_file(full_path.clone()))
+                                .instrument(tracing::info_span!("remove file", name = ?full_path))
+                                .concurrency_limited(&inner.write_semaphore)
+                        }
+                        #[cfg(all(target_family = "wasm", target_os = "unknown"))]
+                        {
+                            wasm_fs_offload::CLIENT.remove_file(&full_path)
+                        }
+                    }
+                    .await
+                    .or_else(|err| {
+                        if err.kind() == ErrorKind::NotFound {
+                            Ok(())
+                        } else {
+                            Err(err)
+                        }
+                    })
+                    .with_context(|| anyhow!("removing {} failed", full_path.display()))?;
                 }
             }
 
@@ -1101,6 +1216,11 @@ impl FileSystem for DiskFileSystem {
 
     #[turbo_tasks::function(fs)]
     async fn write_link(&self, fs_path: FileSystemPath, target: Vc<LinkContent>) -> Result<()> {
+        #[cfg(all(target_family = "wasm", target_os = "unknown"))]
+        {
+            unreachable!()
+        }
+
         // You might be tempted to use `mark_session_dependent` here, but we purely declare a side
         // effect and does not need to be re-executed in the next session. All side effects are
         // re-executed in general.
@@ -1116,6 +1236,7 @@ impl FileSystem for DiskFileSystem {
         let inner = self.inner.clone();
         let invalidator = turbo_tasks::get_invalidator();
 
+        #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
         effect(async move {
             let full_path = validate_path_length(&full_path)?;
 
@@ -1177,6 +1298,7 @@ impl FileSystem for DiskFileSystem {
                 Ok(res) => Some((res.is_absolute(), res)),
                 Err(_) => None,
             };
+
             let is_equal = match (&os_specific_link_content, &old_content) {
                 (
                     OsSpecificLinkContent::Link { target, .. },
@@ -1323,12 +1445,18 @@ impl FileSystem for DiskFileSystem {
         self.inner.register_read_invalidator(&full_path)?;
 
         let _lock = self.inner.lock_path(&full_path).await;
+        #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
         let meta = retry_blocking(|| std::fs::metadata(&full_path))
             .instrument(tracing::info_span!("read metadata", name = ?full_path))
             .concurrency_limited(&self.inner.read_semaphore)
             .await
             .with_context(|| format!("reading metadata for {:?}", full_path))?;
 
+        #[cfg(all(target_family = "wasm", target_os = "unknown"))]
+        let meta = wasm_fs_offload::CLIENT
+            .metadata(&full_path)
+            .await
+            .with_context(|| format!("reading metadata for {}", full_path.display()))?;
         Ok(FileMeta::cell(meta.into()))
     }
 }
@@ -1509,7 +1637,7 @@ impl FileSystemPath {
     /// 1. The parent directory, if any;
     /// 2. The file stem;
     /// 3. The extension, if any.
-    fn split_file_stem_extension(&self) -> (Option<&str>, &str, Option<&str>) {
+    pub fn split_file_stem_extension(&self) -> (Option<&str>, &str, Option<&str>) {
         let (path_before_extension, extension) = self.split_extension();
 
         if let Some((parent, file_stem)) = path_before_extension.rsplit_once('/') {
@@ -1957,6 +2085,7 @@ enum FileComparison {
 impl FileContent {
     /// Performs a comparison of self's data against a disk file's streamed
     /// read.
+    #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
     async fn streaming_compare(&self, path: &Path) -> Result<FileComparison> {
         let old_file =
             extract_disk_access(retry_blocking(|| std::fs::File::open(path)).await, path)?;
@@ -2010,6 +2139,51 @@ impl FileContent {
             old_contents.consume(len);
         })
     }
+
+    #[cfg(all(target_family = "wasm", target_os = "unknown"))]
+    async fn streaming_compare(&self, path: &Path) -> Result<FileComparison> {
+        let old_meta = extract_disk_access(wasm_fs_offload::CLIENT.metadata(path).await, path)?;
+        let Some(old_meta) = old_meta else {
+            return Ok(FileComparison::Create);
+        };
+        let FileContent::Content(new_file) = self else {
+            return Ok(FileComparison::NotEqual);
+        };
+        if new_file.meta != old_meta.into() {
+            return Ok(FileComparison::NotEqual);
+        }
+        let mut new_contents = new_file.read();
+        let mut old_contents = if let Some(content) =
+            extract_disk_access(wasm_fs_offload::CLIENT.read(path).await, path)?
+        {
+            let cursor = std::io::Cursor::new(content);
+            BufReader::new(cursor)
+        } else {
+            return Ok(FileComparison::Create);
+        };
+        Ok(loop {
+            let new_chunk = new_contents.fill_buf()?;
+            let Ok(old_chunk) = old_contents.fill_buf() else {
+                break FileComparison::NotEqual;
+            };
+
+            let len = min(new_chunk.len(), old_chunk.len());
+            if len == 0 {
+                if new_chunk.len() == old_chunk.len() {
+                    break FileComparison::Equal;
+                } else {
+                    break FileComparison::NotEqual;
+                }
+            }
+
+            if new_chunk[0..len] != old_chunk[0..len] {
+                break FileComparison::NotEqual;
+            }
+
+            new_contents.consume(len);
+            old_contents.consume(len);
+        })
+    }
 }
 
 bitflags! {
@@ -2232,6 +2406,13 @@ impl DeterministicHash for FileMeta {
     }
 }
 
+#[cfg(all(target_family = "wasm", target_os = "unknown"))]
+impl From<tokio_fs_ext::Metadata> for FileMeta {
+    fn from(_meta: tokio_fs_ext::Metadata) -> Self {
+        FileMeta::default()
+    }
+}
+
 impl FileContent {
     pub fn new(file: File) -> Self {
         FileContent::Content(file)
diff --git a/turbopack/crates/turbo-tasks-fs/src/wasm_fs_offload.rs b/turbopack/crates/turbo-tasks-fs/src/wasm_fs_offload.rs
new file mode 100644
index 000000000000..a77aa2e282fb
--- /dev/null
+++ b/turbopack/crates/turbo-tasks-fs/src/wasm_fs_offload.rs
@@ -0,0 +1,20 @@
+use std::{
+    path::{Path, PathBuf},
+    sync::LazyLock,
+};
+
+use anyhow::{Context, Result};
+use parking_lot::Mutex;
+use tokio::sync::oneshot;
+use tokio_fs_ext::offload::{self, FsOffload};
+
+static WASM_FS_OFFLOAD: LazyLock<(Mutex<offload::Server>, offload::Client)> = LazyLock::new(|| {
+    let (server, client) = offload::split();
+    (Mutex::new(server), client)
+});
+
+pub static CLIENT: LazyLock<offload::Client> = LazyLock::new(|| WASM_FS_OFFLOAD.1.clone());
+
+pub async fn server(offload: impl FsOffload) {
+    WASM_FS_OFFLOAD.0.lock().serve(offload).await
+}
diff --git a/turbopack/crates/turbo-tasks-fs/src/watcher.rs b/turbopack/crates/turbo-tasks-fs/src/watcher.rs
index c82c7d3113f5..34cc7359aacf 100644
--- a/turbopack/crates/turbo-tasks-fs/src/watcher.rs
+++ b/turbopack/crates/turbo-tasks-fs/src/watcher.rs
@@ -3,7 +3,7 @@ use std::{
     collections::BTreeSet,
     env, fmt,
     mem::take,
-    path::{Path, PathBuf},
+    path::{Component, Path, PathBuf},
     sync::{
         Arc, LazyLock, RwLock, RwLockWriteGuard,
         mpsc::{Receiver, TryRecvError, channel},
@@ -13,16 +13,17 @@ use std::{
 
 use anyhow::{Context, Result};
 use bincode::{Decode, Encode};
-use notify::{
-    Config, EventKind, PollWatcher, RecommendedWatcher, RecursiveMode, Watcher,
-    event::{MetadataKind, ModifyKind, RenameMode},
-};
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
+use notify::{Config, PollWatcher, RecommendedWatcher, RecursiveMode, Watcher};
+use notify_types::event::{EventKind, MetadataKind, ModifyKind, RenameMode};
 use rustc_hash::FxHashSet;
 use tracing::instrument;
 use turbo_rcstr::RcStr;
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
+use turbo_tasks::spawn_thread;
 use turbo_tasks::{
     FxIndexSet, InvalidationReason, InvalidationReasonKind, Invalidator, TurboTasksApi, parallel,
-    spawn_thread, util::StaticOrArc,
+    util::StaticOrArc,
 };
 
 use crate::{
@@ -32,6 +33,7 @@ use crate::{
     path_map::OrderedPathMapExt,
 };
 
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 static WATCH_RECURSIVE_MODE: LazyLock<RecursiveMode> = LazyLock::new(|| {
     match env::var("TURBO_TASKS_FORCE_WATCH_MODE").as_deref() {
         Ok("recursive") => {
@@ -64,6 +66,9 @@ static WATCH_RECURSIVE_MODE: LazyLock<RecursiveMode> = LazyLock::new(|| {
 pub(crate) struct DiskWatcher {
     #[bincode(skip)]
     state: State,
+    /// Paths to ignore when watching for file changes
+    #[bincode(skip)]
+    ignored_paths: Arc<Vec<RcStr>>,
 }
 
 enum State {
@@ -86,12 +91,15 @@ enum StateWriteGuard<'a> {
 
 impl State {
     fn new_stopped() -> Self {
+        #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
         match *WATCH_RECURSIVE_MODE {
             RecursiveMode::Recursive => Self::Recursive(RwLock::new(RecursiveState::Stopped)),
             RecursiveMode::NonRecursive => {
                 Self::NonRecursive(RwLock::new(NonRecursiveState::Stopped))
             }
         }
+        #[cfg(all(target_family = "wasm", target_os = "unknown"))]
+        Self::Recursive(RwLock::new(RecursiveState::Stopped))
     }
 
     fn write(&self) -> StateWriteGuard<'_> {
@@ -110,6 +118,7 @@ enum RecursiveState {
     Stopped,
     Watching {
         /// Hold onto the watcher: When this is dropped, it will cause the channel to disconnect
+        #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
         _notify_watcher: NotifyWatcher,
     },
 }
@@ -124,6 +133,7 @@ enum NonRecursiveState {
 
 // split out from the `NonRecursiveState` enum because we want to pass this value around
 struct NonRecursiveWatchingState {
+    #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
     notify_watcher: NotifyWatcher,
     /// Keeps track of which directories are currently or were previously watched by
     /// [`Self::notify_watcher`].
@@ -136,11 +146,13 @@ struct NonRecursiveWatchingState {
 }
 
 /// A thin wrapper around [`RecommendedWatcher`] and [`PollWatcher`].
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 enum NotifyWatcher {
     Recommended(RecommendedWatcher),
     Polling(PollWatcher),
 }
 
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 impl NotifyWatcher {
     fn watch(&mut self, path: &Path, recursive_mode: RecursiveMode) -> notify::Result<()> {
         match self {
@@ -150,11 +162,13 @@ impl NotifyWatcher {
     }
 }
 
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 mod non_recursive_helpers {
     use super::*;
     use crate::path_map::OrderedPathSetExt;
 
     /// Called after a rescan in case a previously watched-but-deleted directory was recreated.
+    #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
     #[instrument(skip_all, level = "trace")]
     pub fn restore_all_watched_ignore_errors(state: &RwLock<NonRecursiveState>, root_path: &Path) {
         let mut guard = state.write().unwrap();
@@ -173,6 +187,7 @@ mod non_recursive_helpers {
 
     /// Called when a new directory is found in a parent directory we're watching. Restores the
     /// watcher if we were previously watching it.
+    #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
     #[instrument(skip_all, level = "trace")]
     pub fn restore_if_watched(
         state: &RwLock<NonRecursiveState>,
@@ -259,6 +274,7 @@ mod non_recursive_helpers {
     /// This does not watch any of the parent directories. For that, use
     /// [`start_watching_dir_and_parents`]. Use this method when iterating over previously-watched
     /// values in `self.watching`.
+    #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
     fn start_watching_dir(
         notify_watcher: &mut NotifyWatcher,
         dir_path: &Path,
@@ -287,6 +303,7 @@ mod non_recursive_helpers {
     /// Watches the given `dir_path` and every parent up to `root_path`. Parents must be recursively
     /// watched in case any of them change:
     /// https://docs.rs/notify/latest/notify/#parent-folder-deletion
+    #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
     fn start_watching_dir_and_parents(
         state: &mut NonRecursiveWatchingState,
         dir_path: &Path,
@@ -333,9 +350,32 @@ mod non_recursive_helpers {
 
 impl DiskWatcher {
     pub fn new() -> Self {
+        Self::new_with_ignored_paths(vec![])
+    }
+
+    pub fn new_with_ignored_paths(ignored_paths: Vec<RcStr>) -> Self {
         Self {
             state: State::new_stopped(),
+            ignored_paths: Arc::new(ignored_paths),
+        }
+    }
+
+    /// Check if a path should be ignored based on configured ignore patterns
+    fn should_ignore_path(&self, path: &Path) -> bool {
+        if self.ignored_paths.is_empty() {
+            return false;
         }
+        path.components().any(|component| {
+            if let Component::Normal(name) = component
+                && let Some(name_str) = name.to_str()
+            {
+                return self
+                    .ignored_paths
+                    .iter()
+                    .any(|ignored| ignored.as_str() == name_str);
+            }
+            false
+        })
     }
 
     /// Create a watcher and start watching by creating `debounced` watcher
@@ -353,6 +393,7 @@ impl DiskWatcher {
     /// - Emits only one Remove event when deleting a directory (inotify)
     /// - Doesn't emit duplicate create events
     /// - Doesn't emit Modify events after a Create event
+    #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
     pub fn start_watching(
         &self,
         fs_inner: Arc<DiskFileSystemInner>,
@@ -457,6 +498,157 @@ impl DiskWatcher {
         Ok(())
     }
 
+    #[cfg(all(target_family = "wasm", target_os = "unknown"))]
+    pub(crate) async fn start_watching(
+        &self,
+        fs_inner: Arc<DiskFileSystemInner>,
+        report_invalidation_reason: bool,
+        poll_interval: Option<Duration>,
+    ) -> Result<()> {
+        use crate::wasm_fs_offload;
+
+        let fs_inner_arc = fs_inner.clone();
+        let root_path = fs_inner_arc.root_path();
+        let ignored_paths = self.ignored_paths.clone();
+        let watch_dir = wasm_fs_offload::CLIENT
+            .watch_dir(root_path, true, move |event| {
+                let paths: Vec<PathBuf> = if ignored_paths.is_empty() {
+                    event.paths
+                } else {
+                    event
+                        .paths
+                        .into_iter()
+                        .filter(|path| {
+                            !path.components().any(|component| {
+                                if let Component::Normal(name) = component {
+                                    if let Some(name_str) = name.to_str() {
+                                        return ignored_paths
+                                            .iter()
+                                            .any(|ignored| ignored.as_str() == name_str);
+                                    }
+                                }
+                                false
+                            })
+                        })
+                        .collect()
+                };
+
+                if paths.is_empty() {
+                    return;
+                }
+
+                let mut batched_invalidate_path = FxHashSet::default();
+                let mut batched_invalidate_path_dir = FxHashSet::default();
+                let mut batched_invalidate_path_and_children = FxHashSet::default();
+                let mut batched_invalidate_path_and_children_dir = FxHashSet::default();
+
+                match event.kind {
+                    EventKind::Modify(
+                        ModifyKind::Data(_) | ModifyKind::Metadata(MetadataKind::Any),
+                    ) => {
+                        batched_invalidate_path.extend(paths);
+                    }
+                    EventKind::Create(_) => {
+                        batched_invalidate_path_and_children.extend(paths.clone());
+                        batched_invalidate_path_and_children_dir.extend(paths.clone());
+                        paths.iter().for_each(|path| {
+                            if let Some(parent) = path.parent() {
+                                batched_invalidate_path_dir.insert(PathBuf::from(parent));
+                            }
+                        });
+                    }
+                    EventKind::Remove(_) => {
+                        batched_invalidate_path_and_children.extend(paths.clone());
+                        batched_invalidate_path_and_children_dir.extend(paths.clone());
+                        paths.iter().for_each(|path| {
+                            if let Some(parent) = path.parent() {
+                                batched_invalidate_path_dir.insert(PathBuf::from(parent));
+                            }
+                        });
+                    }
+                    EventKind::Modify(ModifyKind::Name(RenameMode::Both)) => {
+                        if let [source, destination, ..] = &paths[..] {
+                            batched_invalidate_path_and_children.insert(source.clone());
+                            if let Some(parent) = source.parent() {
+                                batched_invalidate_path_dir.insert(PathBuf::from(parent));
+                            }
+                            batched_invalidate_path_and_children.insert(destination.clone());
+                            if let Some(parent) = destination.parent() {
+                                batched_invalidate_path_dir.insert(PathBuf::from(parent));
+                            }
+                        } else {
+                            panic!(
+                                "Rename event does not contain source and destination paths \
+                                 {paths:#?}"
+                            );
+                        }
+                    }
+                    EventKind::Any | EventKind::Modify(ModifyKind::Any | ModifyKind::Name(..)) => {
+                        batched_invalidate_path.extend(paths.clone());
+                        batched_invalidate_path_and_children.extend(paths.clone());
+                        batched_invalidate_path_and_children_dir.extend(paths.clone());
+                        for parent in paths.iter().filter_map(|path| path.parent()) {
+                            batched_invalidate_path_dir.insert(PathBuf::from(parent));
+                        }
+                    }
+                    EventKind::Modify(ModifyKind::Metadata(..) | ModifyKind::Other)
+                    | EventKind::Access(_)
+                    | EventKind::Other => {
+                        // ignored
+                    }
+                }
+
+                let Some(turbo_tasks) = fs_inner.turbo_tasks.upgrade() else {
+                    // TurboTasks was dropped, stop watching
+                    // wasm_fs_offload::CLIENT.stop_watching();
+                    return;
+                };
+                let _guard = fs_inner.tokio_handle.enter();
+                // FIXME: this will cause hanging on wasm now
+                // let _lock = fs_inner.invalidation_lock.blocking_write();
+                {
+                    let mut invalidator_map = fs_inner.invalidator_map.lock().unwrap();
+
+                    invalidate_path(
+                        &fs_inner,
+                        &*turbo_tasks,
+                        report_invalidation_reason,
+                        &mut invalidator_map,
+                        batched_invalidate_path.drain(),
+                    );
+
+                    invalidate_path_and_children_execute(
+                        &fs_inner,
+                        &*turbo_tasks,
+                        report_invalidation_reason,
+                        &mut invalidator_map,
+                        batched_invalidate_path_and_children.drain(),
+                    );
+                }
+                {
+                    let mut dir_invalidator_map = fs_inner.dir_invalidator_map.lock().unwrap();
+                    invalidate_path(
+                        &fs_inner,
+                        &*turbo_tasks,
+                        report_invalidation_reason,
+                        &mut dir_invalidator_map,
+                        batched_invalidate_path_dir.drain(),
+                    );
+
+                    invalidate_path_and_children_execute(
+                        &fs_inner,
+                        &*turbo_tasks,
+                        report_invalidation_reason,
+                        &mut dir_invalidator_map,
+                        batched_invalidate_path_and_children_dir.drain(),
+                    );
+                }
+            })
+            .await?;
+
+        Ok(())
+    }
+
     pub fn stop_watching(&self) {
         match &self.state {
             State::Recursive(state) => *state.write().unwrap() = RecursiveState::Stopped,
@@ -470,6 +662,7 @@ impl DiskWatcher {
     /// and invalidates the cache.
     ///
     /// Should only be called once from `start_watching`.
+    #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
     fn watch_thread(
         &self,
         rx: Receiver<notify::Result<notify::Event>>,
@@ -539,7 +732,11 @@ impl DiskWatcher {
                             break;
                         }
 
-                        let paths: Vec<PathBuf> = event.paths;
+                        let paths: Vec<PathBuf> = event
+                            .paths
+                            .into_iter()
+                            .filter(|path| !self.should_ignore_path(path))
+                            .collect();
                         if paths.is_empty() {
                             // this event isn't useful, but keep trying to process the batch
                             event_result = rx.try_recv();
@@ -737,6 +934,7 @@ impl DiskWatcher {
         // Watch the parent directory instead of the specified file, since directories also track
         // their immediate children (even in non-recursive mode), and we need to watch all the
         // parents anyways.
+        #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
         if let State::NonRecursive(non_recursive) = &self.state
             && let Some(dir_path) = path.parent()
         {
@@ -746,6 +944,7 @@ impl DiskWatcher {
     }
 
     pub fn ensure_watched_dir(&self, dir_path: &Path, root_path: &Path) -> Result<()> {
+        #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
         if let State::NonRecursive(non_recursive) = &self.state {
             non_recursive_helpers::ensure_watched(non_recursive, dir_path, root_path)?;
         }
diff --git a/turbopack/crates/turbo-tasks-hash/Cargo.toml b/turbopack/crates/turbo-tasks-hash/Cargo.toml
index 4be1293fb4e0..66aea2172322 100644
--- a/turbopack/crates/turbo-tasks-hash/Cargo.toml
+++ b/turbopack/crates/turbo-tasks-hash/Cargo.toml
@@ -18,3 +18,6 @@ data-encoding = { workspace = true }
 sha2 = { workspace = true }
 turbo-tasks-macros = { workspace = true }
 twox-hash = { workspace = true }
+
+[target.'cfg(all(target_family = "wasm", target_os = "unknown"))'.dependencies]
+getrandom = { version = "0.3", features = ["wasm_js"] }
diff --git a/turbopack/crates/turbo-tasks-malloc/Cargo.toml b/turbopack/crates/turbo-tasks-malloc/Cargo.toml
index 2933ebad133d..b84c0ae1e5c4 100644
--- a/turbopack/crates/turbo-tasks-malloc/Cargo.toml
+++ b/turbopack/crates/turbo-tasks-malloc/Cargo.toml
@@ -9,17 +9,14 @@ autobenches = false
 [lib]
 bench = false
 
-[dependencies]
-
-
-[target.'cfg(not(any(target_os = "linux", target_family = "wasm")))'.dependencies]
-mimalloc = { version = "0.1.48", features = [
+[target.'cfg(not(any(target_os = "linux",  target_env = "musl")))'.dependencies]
+mimalloc = {  version = "0.1.48", features = [
   "v3",
   "extended",
 ], optional = true }
 
-[target.'cfg(all(target_os = "linux", not(target_family = "wasm")))'.dependencies]
-mimalloc = { version = "0.1.48", features = [
+[target.'cfg(all(target_os = "linux", not(target_env = "musl")))'.dependencies]
+mimalloc = { version ="0.1.48", features = [
   "v3",
   "extended",
   "local_dynamic_tls",
diff --git a/turbopack/crates/turbo-tasks-malloc/src/lib.rs b/turbopack/crates/turbo-tasks-malloc/src/lib.rs
index 47410b0e11a1..4af96208c308 100644
--- a/turbopack/crates/turbo-tasks-malloc/src/lib.rs
+++ b/turbopack/crates/turbo-tasks-malloc/src/lib.rs
@@ -105,17 +105,17 @@ impl TurboMalloc {
 /// Get the allocator for this platform that we should wrap with TurboMalloc.
 #[inline]
 fn base_alloc() -> &'static impl GlobalAlloc {
-    #[cfg(all(feature = "custom_allocator", not(target_family = "wasm")))]
+    #[cfg(all(feature = "custom_allocator", not(target_env = "musl")))]
     return &mimalloc::MiMalloc;
-    #[cfg(not(all(feature = "custom_allocator", not(target_family = "wasm"))))]
+    #[cfg(any(not(feature = "custom_allocator"), target_env = "musl"))]
     return &std::alloc::System;
 }
 
 #[allow(unused_variables)]
 unsafe fn base_alloc_size(ptr: *const u8, layout: Layout) -> usize {
-    #[cfg(all(feature = "custom_allocator", not(target_family = "wasm")))]
+    #[cfg(all(feature = "custom_allocator", not(target_env = "musl")))]
     return unsafe { mimalloc::MiMalloc.usable_size(ptr) };
-    #[cfg(not(all(feature = "custom_allocator", not(target_family = "wasm"))))]
+    #[cfg(any(not(feature = "custom_allocator"), target_env = "musl"))]
     return layout.size();
 }
 
diff --git a/turbopack/crates/turbo-tasks/Cargo.toml b/turbopack/crates/turbo-tasks/Cargo.toml
index f0ea87d4ee10..957bd34bb50b 100644
--- a/turbopack/crates/turbo-tasks/Cargo.toml
+++ b/turbopack/crates/turbo-tasks/Cargo.toml
@@ -36,7 +36,7 @@ futures = { workspace = true }
 indexmap = { workspace = true, features = ["serde"] }
 inventory = { workspace = true }
 once_cell = { workspace = true }
-parking_lot = { workspace = true, features = ["serde"]}
+parking_lot = { workspace = true, features = ["serde"] }
 pin-project-lite = { workspace = true }
 rayon = { workspace = true }
 regex = { workspace = true }
@@ -45,7 +45,7 @@ serde = { workspace = true, features = ["rc", "derive"] }
 serde_json = { workspace = true }
 shrink-to-fit = { workspace = true, features = ["indexmap", "serde_json", "smallvec", "nightly"] }
 smallvec = { workspace = true }
-tokio = { workspace = true, features = ["full"] }
+tokio = { workspace = true, features = ["sync", "time", "macros", "rt-multi-thread"] }
 tokio-util = { workspace = true }
 tracing = { workspace = true }
 triomphe = { workspace = true, features = ["unsize", "unstable"] }
@@ -60,7 +60,5 @@ unsize = { workspace = true }
 
 [dev-dependencies]
 criterion = { workspace = true, features = ["async_tokio"] }
+tokio = { workspace = true }
 
-[[bench]]
-name = "mod"
-harness = false
diff --git a/turbopack/crates/turbo-tasks/src/duration_span.rs b/turbopack/crates/turbo-tasks/src/duration_span.rs
index 8fc73546f81c..313fa90f771f 100644
--- a/turbopack/crates/turbo-tasks/src/duration_span.rs
+++ b/turbopack/crates/turbo-tasks/src/duration_span.rs
@@ -1,4 +1,4 @@
-use std::time::Instant;
+use tokio::time::Instant;
 
 /// Guard that emits a tracing event when dropped with the duration of the
 /// lifetime of the guard.
diff --git a/turbopack/crates/turbo-tasks/src/manager.rs b/turbopack/crates/turbo-tasks/src/manager.rs
index cc2fd7070dcc..8e4441c3b9c9 100644
--- a/turbopack/crates/turbo-tasks/src/manager.rs
+++ b/turbopack/crates/turbo-tasks/src/manager.rs
@@ -9,7 +9,7 @@ use std::{
         Arc, Mutex, RwLock, Weak,
         atomic::{AtomicBool, AtomicUsize, Ordering},
     },
-    time::{Duration, Instant},
+    time::Duration,
 };
 
 use anyhow::{Result, anyhow};
@@ -20,7 +20,7 @@ use futures::stream::FuturesUnordered;
 use rustc_hash::{FxBuildHasher, FxHasher};
 use serde::{Deserialize, Serialize};
 use smallvec::SmallVec;
-use tokio::{select, sync::mpsc::Receiver, task_local};
+use tokio::{select, sync::mpsc::Receiver, task_local, time::Instant};
 use tracing::{Instrument, Span, instrument};
 
 use crate::{
diff --git a/turbopack/crates/turbo-tasks/src/priority_runner.rs b/turbopack/crates/turbo-tasks/src/priority_runner.rs
index 8d5e2ad70cf8..cd3cf195e5f7 100644
--- a/turbopack/crates/turbo-tasks/src/priority_runner.rs
+++ b/turbopack/crates/turbo-tasks/src/priority_runner.rs
@@ -9,12 +9,15 @@ use std::{
         atomic::{AtomicUsize, Ordering},
     },
     task::{Context, Poll},
-    time::{Duration, Instant},
+    time::Duration,
 };
 
 use parking_lot::Mutex;
 use pin_project_lite::pin_project;
-use tokio::sync::oneshot::{Receiver, Sender};
+use tokio::{
+    sync::oneshot::{Receiver, Sender},
+    time::Instant,
+};
 
 pub trait Executor<C, T, P>: Send + Sync {
     type Future: Future<Output = ()> + Send;
diff --git a/turbopack/crates/turbopack-browser/Cargo.toml b/turbopack/crates/turbopack-browser/Cargo.toml
index fd634233594b..cbf01d8c3c81 100644
--- a/turbopack/crates/turbopack-browser/Cargo.toml
+++ b/turbopack/crates/turbopack-browser/Cargo.toml
@@ -28,7 +28,8 @@ serde_json = { workspace = true }
 serde_qs = { workspace = true }
 tracing = { workspace = true }
 urlencoding = { workspace = true }
-
+regex = { workspace = true }
+qstring = { workspace = true }
 turbo-bincode = { workspace = true }
 turbo-rcstr = { workspace = true }
 turbo-tasks = { workspace = true }
@@ -37,5 +38,6 @@ turbo-tasks-hash = { workspace = true }
 turbopack-core = { workspace = true }
 turbopack-ecmascript = { workspace = true }
 turbopack-ecmascript-runtime = { workspace = true }
+turbopack-css = { workspace = true }
 turbopack-resolve = { workspace = true }
 
diff --git a/turbopack/crates/turbopack-browser/src/chunking_context.rs b/turbopack/crates/turbopack-browser/src/chunking_context.rs
index c1757fef87a9..ee486cfcf2f2 100644
--- a/turbopack/crates/turbopack-browser/src/chunking_context.rs
+++ b/turbopack/crates/turbopack-browser/src/chunking_context.rs
@@ -1,5 +1,9 @@
+use std::{cmp::min, sync::LazyLock};
+
 use anyhow::{Context, Result, bail};
 use bincode::{Decode, Encode};
+use qstring::QString;
+use regex::Regex;
 use tracing::Instrument;
 use turbo_rcstr::{RcStr, rcstr};
 use turbo_tasks::{
@@ -7,9 +11,9 @@ use turbo_tasks::{
     trace::TraceRawVcs,
 };
 use turbo_tasks_fs::FileSystemPath;
-use turbo_tasks_hash::{DeterministicHash, HashAlgorithm};
+use turbo_tasks_hash::{DeterministicHash, hash_xxh3_hash64};
 use turbopack_core::{
-    asset::Asset,
+    asset::{Asset, AssetContent},
     chunk::{
         AssetSuffix, Chunk, ChunkGroupResult, ChunkItem, ChunkType, ChunkableModule,
         ChunkingConfig, ChunkingConfigs, ChunkingContext, EntryChunkGroupResult, EvaluatableAsset,
@@ -29,6 +33,7 @@ use turbopack_core::{
     },
     output::{OutputAsset, OutputAssets},
 };
+use turbopack_css::chunk::{CssChunk, source_map::CssChunkSourceMapAsset};
 use turbopack_ecmascript::{
     async_chunk::module::AsyncLoaderModule,
     chunk::EcmascriptChunk,
@@ -53,6 +58,9 @@ pub enum CurrentChunkMethod {
 pub const CURRENT_CHUNK_METHOD_DOCUMENT_CURRENT_SCRIPT_EXPR: &str =
     "typeof document === \"object\" ? document.currentScript : undefined";
 
+pub const GLOBAL_THIS_FALLBACK_EXPR: &str =
+    "typeof globalThis !== \"undefined\" ? globalThis : (typeof self !== \"undefined\" ? self : (typeof window !== \"undefined\" ? window : (typeof global !== \"undefined\" ? global : {})))";
+
 #[derive(
     Debug,
     TaskInput,
@@ -98,6 +106,11 @@ impl BrowserChunkingContextBuilder {
         self
     }
 
+    pub fn entry_root_export(mut self, name: Option<RcStr>) -> Self {
+        self.chunking_context.entry_root_export = name;
+        self
+    }
+
     pub fn tracing(mut self, enable_tracing: bool) -> Self {
         self.chunking_context.enable_tracing = enable_tracing;
         self
@@ -238,6 +251,31 @@ impl BrowserChunkingContextBuilder {
         self
     }
 
+    pub fn filename(mut self, filename: RcStr) -> Self {
+        self.chunking_context.filename = Some(filename);
+        self
+    }
+
+    pub fn chunk_filename(mut self, chunk_filename: RcStr) -> Self {
+        self.chunking_context.chunk_filename = Some(chunk_filename);
+        self
+    }
+
+    pub fn css_filename(mut self, css_filename: RcStr) -> Self {
+        self.chunking_context.css_filename = Some(css_filename);
+        self
+    }
+
+    pub fn css_chunk_filename(mut self, css_chunk_filename: RcStr) -> Self {
+        self.chunking_context.css_chunk_filename = Some(css_chunk_filename);
+        self
+    }
+
+    pub fn asset_module_filename(mut self, asset_module_filename: RcStr) -> Self {
+        self.chunking_context.asset_module_filename = Some(asset_module_filename);
+        self
+    }
+
     pub fn chunk_loading_global(mut self, chunk_loading_global: RcStr) -> Self {
         self.chunking_context.chunk_loading_global = Some(chunk_loading_global);
         self
@@ -337,6 +375,21 @@ pub struct BrowserChunkingContext {
     /// The global variable name used for chunk loading.
     /// Default: "TURBOPACK"
     chunk_loading_global: Option<RcStr>,
+    /// Evaluate chunk filename template
+    filename: Option<RcStr>,
+    /// Non evaluate chunk filename template
+    chunk_filename: Option<RcStr>,
+    /// Initial css chunk filename template
+    css_filename: Option<RcStr>,
+    /// Non initial css chunk filename template
+    css_chunk_filename: Option<RcStr>,
+    /// Asset module filename template
+    asset_module_filename: Option<RcStr>,
+    /// Expose entry module exports to global scope with the specified name.
+    /// When set, all named exports from the entry module will be available on
+    /// `window`/`globalThis` under the specified name.
+    /// Default: None (no exposure)
+    entry_root_export: Option<RcStr>,
 }
 
 impl BrowserChunkingContext {
@@ -388,6 +441,12 @@ impl BrowserChunkingContext {
                 should_use_absolute_url_references: false,
                 worker_forwarded_globals: vec![],
                 chunk_loading_global: Default::default(),
+                filename: Default::default(),
+                chunk_filename: Default::default(),
+                css_filename: Default::default(),
+                css_chunk_filename: Default::default(),
+                asset_module_filename: Default::default(),
+                entry_root_export: None,
             },
         }
     }
@@ -490,6 +549,12 @@ impl BrowserChunkingContext {
         self.minify_type.cell()
     }
 
+    /// Returns the entry root export name to expose to global scope.
+    #[turbo_tasks::function]
+    pub fn entry_root_export(&self) -> Vc<Option<RcStr>> {
+        Vc::cell(self.entry_root_export.clone())
+    }
+
     /// Returns the chunk path information.
     #[turbo_tasks::function]
     fn chunk_path_info(&self) -> Vc<ChunkPathInfo> {
@@ -562,49 +627,101 @@ impl ChunkingContext for BrowserChunkingContext {
             "`extension` should include the leading '.', got '{extension}'"
         );
         let ChunkPathInfo {
-            chunk_root_path,
-            content_hashing,
             root_path,
+            chunk_root_path,
+            content_hashing: _,
         } = &*self.chunk_path_info().await?;
-        let name = match *content_hashing {
-            None => {
-                ident
-                    .output_name(root_path.clone(), prefix, extension)
-                    .owned()
-                    .await?
-            }
-            Some(ContentHashing::Direct { length }) => {
-                let Some(asset) = asset else {
-                    bail!("chunk_path requires an asset when content hashing is enabled");
+
+        let output_name = ident
+            .output_name(root_path.clone(), prefix, extension.clone())
+            .owned()
+            .await?;
+
+        let mut filename = match asset {
+            Some(asset) => {
+                let ident = ident.await?;
+
+                let mut evaluate = false;
+                let mut dev_chunk_list = false;
+                ident.modifiers.iter().for_each(|m| {
+                    if m.contains("evaluate") {
+                        evaluate = true;
+                    }
+                    if m.contains("dev chunk list") {
+                        dev_chunk_list = true;
+                    }
+                });
+                let query = QString::from(ident.query.as_str());
+                let name = if dev_chunk_list {
+                    output_name.as_str()
+                } else {
+                    query.get("name").unwrap_or(output_name.as_str())
                 };
-                let hash = asset
-                    .content()
-                    .content_hash(HashAlgorithm::Xxh3Hash128Hex)
-                    .await?;
-                let hash = hash.as_ref().context(
-                    "chunk_path requires an asset with file content when content hashing is \
-                     enabled",
-                )?;
-                let length = length as usize;
-                let hash = &hash[0..length];
-                if let Some(prefix) = prefix {
-                    format!("{prefix}-{hash}{extension}").into()
+
+                let this = self.await?;
+                let filename_template = if evaluate {
+                    this.filename.clone()
                 } else {
-                    format!("{hash}{extension}").into()
+                    let resolved_asset = asset.to_resolved().await?;
+                    if ResolvedVc::try_downcast_type::<CssChunk>(resolved_asset).is_some()
+                        || ResolvedVc::try_downcast_type::<CssChunkSourceMapAsset>(resolved_asset)
+                            .is_some()
+                    {
+                        // TODO: distinguash initial or non-initial css chunk, the non-initial css
+                        // chunk should use css_chunk_filename for template
+                        this.css_filename.clone()
+                    } else {
+                        this.chunk_filename.clone()
+                    }
+                };
+
+                match filename_template {
+                    Some(filename) => {
+                        let mut filename = filename.to_string();
+
+                        if match_name_placeholder(&filename) {
+                            filename = replace_name_placeholder(&filename, name);
+                        }
+
+                        if match_content_hash_placeholder(&filename) {
+                            let content = asset.content().await?;
+                            if let AssetContent::File(file) = &*content {
+                                let content_hash = hash_xxh3_hash64(&file.await?);
+                                filename = replace_content_hash_placeholder(
+                                    &filename,
+                                    &format!("{content_hash:016x}"),
+                                );
+                            } else {
+                                bail!(
+                                    "chunk_path requires an asset with file content when content \
+                                     hashing is enabled"
+                                );
+                            }
+                        };
+
+                        filename
+                    }
+                    None => name.to_string(),
                 }
             }
+            None => output_name.to_string(),
         };
-        Ok(chunk_root_path.join(&name)?.cell())
+
+        if !filename.ends_with(extension.as_str()) {
+            filename.push_str(&extension);
+        }
+
+        Ok(chunk_root_path.join(&filename)?.cell())
     }
 
     #[turbo_tasks::function]
     async fn asset_url(&self, ident: FileSystemPath, tag: Option<RcStr>) -> Result<Vc<RcStr>> {
         let asset_path = ident.to_string();
 
-        let client_root = tag
-            .as_ref()
-            .and_then(|tag| self.client_roots.get(tag))
-            .unwrap_or(&self.client_root);
+        // let client_root = tag
+        //     .as_ref()
+        //     .and_then(|tag| self.client_roots.get(tag))
+        //     .unwrap_or(&self.client_root);
 
         let asset_base_path = tag
             .as_ref()
@@ -612,8 +729,8 @@ impl ChunkingContext for BrowserChunkingContext {
             .or(self.asset_base_path.as_ref());
 
         let asset_path = asset_path
-            .strip_prefix(&format!("{}/", client_root.path))
-            .context("expected asset_path to contain client_root")?;
+            .strip_prefix(&format!("{}/", self.client_root.path))
+            .unwrap_or(&asset_path);
 
         Ok(Vc::cell(
             format!(
@@ -653,16 +770,40 @@ impl ChunkingContext for BrowserChunkingContext {
         let source_path = original_asset_ident.path().await?;
         let basename = source_path.file_name();
         let content_hash = content_hash.await?;
-        let asset_path = match source_path.extension_ref() {
-            Some(ext) => format!(
-                "{basename}.{content_hash}.{ext}",
-                basename = &basename[..basename.len() - ext.len() - 1],
-                content_hash = &content_hash[..8]
-            ),
-            None => format!(
-                "{basename}.{content_hash}",
-                content_hash = &content_hash[..8]
-            ),
+
+        let asset_path = match &self.asset_module_filename {
+            Some(filename_template) => {
+                let mut filename = filename_template.to_string();
+
+                let (_, name, ext) = source_path.split_file_stem_extension();
+
+                if match_name_placeholder(&filename) {
+                    filename = replace_name_placeholder(&filename, name);
+                }
+
+                if match_content_hash_placeholder(&filename) {
+                    filename = replace_content_hash_placeholder(&filename, &content_hash);
+                };
+
+                if let Some(ext) = ext
+                    && !filename.ends_with(ext)
+                {
+                    filename = format!("{filename}.{ext}");
+                }
+
+                filename
+            }
+            None => match source_path.extension_ref() {
+                Some(ext) => format!(
+                    "{basename}.{content_hash}.{ext}",
+                    basename = &basename[..basename.len() - ext.len() - 1],
+                    content_hash = &content_hash[..8]
+                ),
+                None => format!(
+                    "{basename}.{content_hash}",
+                    content_hash = &content_hash[..8]
+                ),
+            },
         };
 
         let asset_root_path = tag
@@ -978,3 +1119,50 @@ struct ChunkPathInfo {
     chunk_root_path: FileSystemPath,
     content_hashing: Option<ContentHashing>,
 }
+
+static NAME_PLACEHOLDER_REGEX: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"\[name\]").unwrap());
+
+pub fn match_name_placeholder(s: &str) -> bool {
+    NAME_PLACEHOLDER_REGEX.is_match(s)
+}
+
+pub fn replace_name_placeholder(s: &str, name: &str) -> String {
+    NAME_PLACEHOLDER_REGEX
+        .replace_all(s, |caps: &regex::Captures| {
+            let m = caps.get(0).unwrap();
+            let after = &s[m.end()..];
+            // If the name already ends with an extension (e.g. "foo.js") and the template
+            // text right after [name] starts with that same extension (e.g. ".js"), strip
+            // the extension from the name to avoid duplication like "foo.js.js".
+            if let Some(dot_pos) = name.rfind('.') {
+                let ext = &name[dot_pos..]; // e.g. ".js"
+                if after.starts_with(ext) {
+                    return name[..dot_pos].to_string();
+                }
+            }
+            name.to_string()
+        })
+        .to_string()
+}
+
+static CONTENT_HASH_PLACEHOLDER_REGEX: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"\[contenthash(?::(?P<len>\d+))?\]").unwrap());
+
+pub fn match_content_hash_placeholder(s: &str) -> bool {
+    CONTENT_HASH_PLACEHOLDER_REGEX.is_match(s)
+}
+
+pub fn replace_content_hash_placeholder(s: &str, hash: &str) -> String {
+    CONTENT_HASH_PLACEHOLDER_REGEX
+        .replace_all(s, |caps: &regex::Captures| {
+            let len = caps.name("len").map(|m| m.as_str()).unwrap_or("");
+            let len = if len.is_empty() {
+                hash.len()
+            } else {
+                len.parse().unwrap_or(hash.len())
+            };
+            let len = min(len, hash.len());
+            hash[..len].to_string()
+        })
+        .to_string()
+}
diff --git a/turbopack/crates/turbopack-browser/src/ecmascript/content.rs b/turbopack/crates/turbopack-browser/src/ecmascript/content.rs
index 43f4114ca815..9f43594e9f99 100644
--- a/turbopack/crates/turbopack-browser/src/ecmascript/content.rs
+++ b/turbopack/crates/turbopack-browser/src/ecmascript/content.rs
@@ -21,7 +21,10 @@ use super::{
 };
 use crate::{
     BrowserChunkingContext,
-    chunking_context::{CURRENT_CHUNK_METHOD_DOCUMENT_CURRENT_SCRIPT_EXPR, CurrentChunkMethod},
+    chunking_context::{
+        CURRENT_CHUNK_METHOD_DOCUMENT_CURRENT_SCRIPT_EXPR, GLOBAL_THIS_FALLBACK_EXPR,
+        CurrentChunkMethod,
+    },
 };
 
 #[turbo_tasks::value(serialization = "none")]
@@ -109,7 +112,8 @@ impl EcmascriptBrowserChunkContent {
             code,
             // `||=` would be better but we need to be es2020 compatible
             //`x || (x = default)` is better than `x = x || default` simply because we avoid _writing_ the property in the common case.
-            r#"(globalThis[{chunk_loading_global}] || (globalThis[{chunk_loading_global}] = [])).push([{script_or_path},"#,
+            r#"(({global_this})[{chunk_loading_global}] || (({global_this})[{chunk_loading_global}] = [])).push([{script_or_path},"#,
+            global_this = GLOBAL_THIS_FALLBACK_EXPR,
             chunk_loading_global = StringifyJs(&chunk_loading_global),
         )?;
 
diff --git a/turbopack/crates/turbopack-browser/src/ecmascript/evaluate/chunk.rs b/turbopack/crates/turbopack-browser/src/ecmascript/evaluate/chunk.rs
index 1fd20e7e4d25..aace6b200d37 100644
--- a/turbopack/crates/turbopack-browser/src/ecmascript/evaluate/chunk.rs
+++ b/turbopack/crates/turbopack-browser/src/ecmascript/evaluate/chunk.rs
@@ -29,7 +29,10 @@ use turbopack_ecmascript_runtime::RuntimeType;
 
 use crate::{
     BrowserChunkingContext,
-    chunking_context::{CURRENT_CHUNK_METHOD_DOCUMENT_CURRENT_SCRIPT_EXPR, CurrentChunkMethod},
+    chunking_context::{
+        CURRENT_CHUNK_METHOD_DOCUMENT_CURRENT_SCRIPT_EXPR, GLOBAL_THIS_FALLBACK_EXPR,
+        CurrentChunkMethod,
+    },
 };
 
 /// An Ecmascript chunk that:
@@ -38,7 +41,7 @@ use crate::{
 #[turbo_tasks::value(shared)]
 #[derive(ValueToString)]
 #[value_to_string("Ecmascript Browser Evaluate Chunk")]
-pub(crate) struct EcmascriptBrowserEvaluateChunk {
+pub struct EcmascriptBrowserEvaluateChunk {
     chunking_context: ResolvedVc<BrowserChunkingContext>,
     ident: ResolvedVc<AssetIdent>,
     other_chunks: ResolvedVc<OutputAssets>,
@@ -70,13 +73,33 @@ impl EcmascriptBrowserEvaluateChunk {
     }
 
     #[turbo_tasks::function]
-    async fn chunks_data(&self) -> Result<Vc<ChunksData>> {
+    pub async fn chunks_data(&self) -> Result<Vc<ChunksData>> {
         Ok(ChunkData::from_assets(
             self.chunking_context.output_root().owned().await?,
             *self.other_chunks,
         ))
     }
 
+    #[turbo_tasks::function]
+    pub fn ident(&self) -> Vc<AssetIdent> {
+        *self.ident
+    }
+
+    #[turbo_tasks::function]
+    pub fn evaluatable_assets(&self) -> Vc<EvaluatableAssets> {
+        *self.evaluatable_assets
+    }
+
+    #[turbo_tasks::function]
+    pub fn module_graph(&self) -> Vc<ModuleGraph> {
+        *self.module_graph
+    }
+
+    #[turbo_tasks::function]
+    pub fn chunking_context(&self) -> Vc<Box<dyn ChunkingContext>> {
+        Vc::upcast(*self.chunking_context)
+    }
+
     #[turbo_tasks::function]
     async fn code(self: Vc<Self>) -> Result<Vc<Code>> {
         let this = self.await?;
@@ -162,11 +185,12 @@ impl EcmascriptBrowserEvaluateChunk {
             // `||=` would be better but we need to be es2020 compatible
             //`x || (x = default)` is better than `x = x || default` simply because we avoid _writing_ the property in the common case.
             r#"
-                (globalThis[{chunk_loading_global}] || (globalThis[{chunk_loading_global}] = [])).push([
+                (({global_this})[{chunk_loading_global}] || (({global_this})[{chunk_loading_global}] = [])).push([
                     {script_or_path},
                     {params}
                 ]);
             "#,
+            global_this = GLOBAL_THIS_FALLBACK_EXPR,
             chunk_loading_global = StringifyJs(&chunk_loading_global),
             params = StringifyJs(&params),
         )?;
@@ -183,6 +207,7 @@ impl EcmascriptBrowserEvaluateChunk {
                     output_root_to_root_path,
                     source_maps,
                     this.chunking_context.chunk_loading_global(),
+                    this.chunking_context.entry_root_export(),
                 );
                 code.push_code(&*runtime_code.await?);
             }
diff --git a/turbopack/crates/turbopack-browser/src/ecmascript/list/asset.rs b/turbopack/crates/turbopack-browser/src/ecmascript/list/asset.rs
index 1e5489073638..303a58a578c4 100644
--- a/turbopack/crates/turbopack-browser/src/ecmascript/list/asset.rs
+++ b/turbopack/crates/turbopack-browser/src/ecmascript/list/asset.rs
@@ -29,7 +29,7 @@ use crate::BrowserChunkingContext;
 #[turbo_tasks::value(shared)]
 #[derive(ValueToString)]
 #[value_to_string("Ecmascript Dev Chunk List")]
-pub(crate) struct EcmascriptDevChunkList {
+pub struct EcmascriptDevChunkList {
     pub(super) chunking_context: ResolvedVc<BrowserChunkingContext>,
     pub(super) ident: ResolvedVc<AssetIdent>,
     pub(super) evaluatable_assets: ResolvedVc<EvaluatableAssets>,
diff --git a/turbopack/crates/turbopack-browser/src/ecmascript/list/content.rs b/turbopack/crates/turbopack-browser/src/ecmascript/list/content.rs
index 732fe122548e..a5c78820df21 100644
--- a/turbopack/crates/turbopack-browser/src/ecmascript/list/content.rs
+++ b/turbopack/crates/turbopack-browser/src/ecmascript/list/content.rs
@@ -27,7 +27,8 @@ use super::{
     version::EcmascriptDevChunkListVersion,
 };
 use crate::chunking_context::{
-    CURRENT_CHUNK_METHOD_DOCUMENT_CURRENT_SCRIPT_EXPR, CurrentChunkMethod,
+    CURRENT_CHUNK_METHOD_DOCUMENT_CURRENT_SCRIPT_EXPR, GLOBAL_THIS_FALLBACK_EXPR,
+    CurrentChunkMethod,
 };
 
 #[derive(
@@ -158,7 +159,7 @@ impl EcmascriptDevChunkListContent {
 
         let mut code = CodeBuilder::default();
 
-        // When loaded, JS chunks must register themselves with the `TURBOPACK` global
+        // When loaded, JS chunks must register themselves with the chunk loading global
         // variable. Similarly, we register the chunk list with the
         // `{chunk_loading_global}_CHUNK_LISTS` global variable.
         let chunk_lists_global = format!("{}_CHUNK_LISTS", this.chunk_loading_global);
@@ -167,12 +168,13 @@ impl EcmascriptDevChunkListContent {
             // `||=` would be better but we need to be es2020 compatible
             //`x || (x = default)` is better than `x = x || default` simply because we avoid _writing_ the property in the common case.
             r#"
-                (globalThis[{chunk_lists_global}] || (globalThis[{chunk_lists_global}] = [])).push({{
+                (({global_this})[{chunk_lists_global}] || (({global_this})[{chunk_lists_global}] = [])).push({{
                     script: {script_or_path},
                     chunks: {chunks},
                     source: {source}
                 }});
             "#,
+            global_this = GLOBAL_THIS_FALLBACK_EXPR,
             chunk_lists_global = StringifyJs(&chunk_lists_global),
             chunks = StringifyJs(&chunks),
             source = StringifyJs(&this.source),
diff --git a/turbopack/crates/turbopack-browser/src/ecmascript/mod.rs b/turbopack/crates/turbopack-browser/src/ecmascript/mod.rs
index d80b785e8ba6..3da0cc8b965f 100644
--- a/turbopack/crates/turbopack-browser/src/ecmascript/mod.rs
+++ b/turbopack/crates/turbopack-browser/src/ecmascript/mod.rs
@@ -10,4 +10,6 @@ pub(crate) mod worker;
 
 pub use chunk::EcmascriptBrowserChunk;
 pub use content::EcmascriptBrowserChunkContent;
+pub use evaluate::chunk::EcmascriptBrowserEvaluateChunk;
+pub use list::asset::EcmascriptDevChunkList;
 pub use worker::EcmascriptBrowserWorkerEntrypoint;
diff --git a/turbopack/crates/turbopack-browser/src/lib.rs b/turbopack/crates/turbopack-browser/src/lib.rs
index 0604839560af..e3f362cda84f 100644
--- a/turbopack/crates/turbopack-browser/src/lib.rs
+++ b/turbopack/crates/turbopack-browser/src/lib.rs
@@ -3,7 +3,7 @@
 #![feature(arbitrary_self_types)]
 #![feature(arbitrary_self_types_pointers)]
 
-pub(crate) mod chunking_context;
+pub mod chunking_context;
 pub mod ecmascript;
 pub mod react_refresh;
 
diff --git a/turbopack/crates/turbopack-cli-utils/Cargo.toml b/turbopack/crates/turbopack-cli-utils/Cargo.toml
index 2cae973901ef..5e61eea0e61d 100644
--- a/turbopack/crates/turbopack-cli-utils/Cargo.toml
+++ b/turbopack/crates/turbopack-cli-utils/Cargo.toml
@@ -16,7 +16,7 @@ workspace = true
 
 [dependencies]
 anyhow = { workspace = true }
-crossterm = "0.26.0"
+clap = { workspace = true, features = ["derive"] }
 owo-colors = { workspace = true }
 rustc-hash = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
@@ -26,3 +26,5 @@ 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"
diff --git a/turbopack/crates/turbopack-cli-utils/src/issue.rs b/turbopack/crates/turbopack-cli-utils/src/issue.rs
index 8614390ac3db..4d7c5cfcb1e4 100644
--- a/turbopack/crates/turbopack-cli-utils/src/issue.rs
+++ b/turbopack/crates/turbopack-cli-utils/src/issue.rs
@@ -8,6 +8,7 @@ use std::{
 };
 
 use anyhow::Result;
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 use crossterm::style::{StyledContent, Stylize};
 use owo_colors::{OwoColorize as _, Style};
 use rustc_hash::{FxHashMap, FxHashSet};
@@ -537,10 +538,18 @@ fn make_relative_to_cwd<'a>(path: &'a str, project_dir: &Path, cwd: &Path) -> Co
     }
 }
 
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 fn show_all_message(label: &str, size: usize) -> StyledContent<String> {
     show_all_message_with_shown_count(label, size, DEFAULT_SHOW_COUNT)
 }
 
+// FIXME:
+#[cfg(all(target_family = "wasm", target_os = "unknown"))]
+fn show_all_message(label: &str, size: usize) -> String {
+    format!("{label} {size}")
+}
+
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 fn show_all_message_with_shown_count(
     label: &str,
     size: usize,
@@ -563,6 +572,12 @@ fn show_all_message_with_shown_count(
     }
 }
 
+// FIXME:
+#[cfg(all(target_family = "wasm", target_os = "unknown"))]
+fn show_all_message_with_shown_count(label: &str, size: usize, shown: usize) -> String {
+    format!("{label} {size} {shown}")
+}
+
 fn render_styled_string_to_ansi(styled_string: &StyledString) -> String {
     match styled_string {
         StyledString::Line(parts) => {
diff --git a/turbopack/crates/turbopack-core/src/ident.rs b/turbopack/crates/turbopack-core/src/ident.rs
index a8e5e62eff79..aab60aee40af 100644
--- a/turbopack/crates/turbopack-core/src/ident.rs
+++ b/turbopack/crates/turbopack-core/src/ident.rs
@@ -268,6 +268,27 @@ impl AssetIdent {
             fragment.deterministic_hash(&mut hasher);
             has_hash = true;
         }
+        if !assets.is_empty() {
+            // Use XOR to combine asset hashes in an order-independent way
+            // This ensures chunks with the same modules but different order get the same hash
+            let mut asset_hashes = Vec::with_capacity(assets.len());
+            for (key, ident) in assets.iter() {
+                let mut asset_hasher = Xxh3Hash64Hasher::new();
+                key.deterministic_hash(&mut asset_hasher);
+                ident
+                    .to_string()
+                    .await?
+                    .deterministic_hash(&mut asset_hasher);
+                asset_hashes.push(asset_hasher.finish());
+            }
+            asset_hashes.sort_unstable();
+
+            2_u8.deterministic_hash(&mut hasher);
+            for h in asset_hashes {
+                h.deterministic_hash(&mut hasher);
+            }
+            has_hash = true;
+        }
         for (key, ident) in assets.iter() {
             2_u8.deterministic_hash(&mut hasher);
             key.deterministic_hash(&mut hasher);
@@ -364,10 +385,10 @@ impl AssetIdent {
         // We need to make sure that `.json` and `.json.js` doesn't end up with the same
         // name. So when we add an extra extension when want to mark that with a "._"
         // suffix.
-        if !removed_extension {
-            name += "._";
-        }
-        name += &expected_extension;
+        // if !removed_extension {
+        //     name += "._";
+        // }
+        // name += &expected_extension;
         Ok(Vc::cell(name.into()))
     }
 }
@@ -433,8 +454,8 @@ impl ValueToString for AssetIdent {
     }
 }
 
-fn escape_file_path(s: &str) -> String {
-    static SEPARATOR_REGEX: Lazy<Regex> = Lazy::new(|| Regex::new(r"[/#?:]").unwrap());
+pub fn escape_file_path(s: &str) -> String {
+    static SEPARATOR_REGEX: Lazy<Regex> = Lazy::new(|| Regex::new(r"[/#?:\[\]<>@\s()]").unwrap());
     SEPARATOR_REGEX.replace_all(s, "_").to_string()
 }
 
diff --git a/turbopack/crates/turbopack-core/src/resolve/mod.rs b/turbopack/crates/turbopack-core/src/resolve/mod.rs
index ab3602fe81d6..289dca63f8e5 100644
--- a/turbopack/crates/turbopack-core/src/resolve/mod.rs
+++ b/turbopack/crates/turbopack-core/src/resolve/mod.rs
@@ -20,7 +20,7 @@ use turbo_tasks::{
     FxIndexMap, FxIndexSet, NonLocalValue, ReadRef, ResolvedVc, TaskInput, TryFlatJoinIterExt,
     TryJoinIterExt, ValueToString, Vc, trace::TraceRawVcs,
 };
-use turbo_tasks_fs::{FileSystemEntryType, FileSystemPath};
+use turbo_tasks_fs::{DiskFileSystem, FileSystemEntryType, FileSystemPath};
 use turbo_unix_path::normalize_request;
 
 use crate::{
@@ -479,6 +479,7 @@ pub enum ExternalType {
     EcmaScriptModule,
     Global,
     Script,
+    Umd,
 }
 
 impl Display for ExternalType {
@@ -489,6 +490,7 @@ impl Display for ExternalType {
             ExternalType::Url => write!(f, "url"),
             ExternalType::Global => write!(f, "global"),
             ExternalType::Script => write!(f, "script"),
+            ExternalType::Umd => write!(f, "umd"),
         }
     }
 }
@@ -2061,18 +2063,78 @@ async fn resolve_internal_inline(
                 .await?
             }
             Request::Windows {
-                path: _,
-                query: _,
-                fragment: _,
+                path,
+                query,
+                fragment,
             } => {
+                if let Some(path_str) = path.as_constant_string() {
+                    let sys_path = std::path::Path::new(path_str.as_str());
+
+                    if let Some(disk_fs_vc) =
+                        ResolvedVc::try_downcast_type::<DiskFileSystem>(lookup_path.fs)
+                    {
+                        let disk_fs = disk_fs_vc.await?;
+                        let root_path = lookup_path.root().owned().await?;
+
+                        // Try to convert the Windows path to a FileSystemPath
+                        if let Some(fs_path) = disk_fs.try_from_sys_path(disk_fs_vc, sys_path, None)
+                        {
+                            // Successfully converted - resolve as a raw path
+                            let mut results = Vec::new();
+                            let unix_path = &fs_path.path;
+                            let pattern = Pattern::Constant(unix_path.clone());
+                            let matches = read_matches(
+                                root_path.clone(),
+                                rcstr!(""),
+                                false,
+                                Pattern::new(pattern).resolve().await?,
+                            )
+                            .await?;
+
+                            for m in matches.iter() {
+                                match m {
+                                    PatternMatch::File(matched_pattern, path) => {
+                                        results.push(
+                                            resolved(
+                                                RequestKey::new(matched_pattern.clone()),
+                                                path.clone(),
+                                                lookup_path.clone(),
+                                                request,
+                                                options_value,
+                                                options,
+                                                query.clone(),
+                                                fragment.clone(),
+                                            )
+                                            .await?
+                                            .into_cell(),
+                                        );
+                                    }
+                                    PatternMatch::Directory(matched_pattern, path) => {
+                                        results.push(
+                                            resolve_into_folder(path.clone(), options)
+                                                .with_request(matched_pattern.clone()),
+                                        );
+                                    }
+                                }
+                            }
+
+                            return Ok(merge_results(results));
+                        }
+                    }
+                }
+
                 if !has_alias {
                     ResolvingIssue {
                         severity: resolve_error_severity(options).await?,
-                        request_type: "windows import: not implemented yet".to_string(),
+                        request_type: "windows import".to_string(),
                         request: request.to_resolved().await?,
                         file_path: lookup_path.clone(),
                         resolve_options: options.to_resolved().await?,
-                        error_message: Some("windows imports are not implemented yet".to_string()),
+                        error_message: Some(
+                            "Windows absolute path imports can only be resolved if the path is \
+                             within the project root. Please use a relative path instead."
+                                .to_string(),
+                        ),
                         source: None,
                     }
                     .resolved_cell()
@@ -2970,6 +3032,12 @@ async fn resolve_import_map_result(
         ImportMapResult::Result(result) => Some(ResolveResultOrCell::Cell(**result)),
         ImportMapResult::Alias(request, alias_lookup_path) => {
             let request = **request;
+            // Preserve the query string from the original request (e.g., ?modules for CSS modules)
+            let request = if !query.is_empty() {
+                request.with_query(query.clone())
+            } else {
+                request
+            };
             let lookup_path = match alias_lookup_path {
                 Some(path) => path.clone(),
                 None => lookup_path,
@@ -3025,7 +3093,10 @@ async fn resolve_import_map_result(
                         ExternalType::EcmaScriptModule => {
                             node_esm_resolve_options(alias_lookup_path.root().owned().await?)
                         }
-                        ExternalType::Script | ExternalType::Url | ExternalType::Global => options,
+                        ExternalType::Script
+                        | ExternalType::Url
+                        | ExternalType::Global
+                        | ExternalType::Umd => options,
                     },
                 )
                 .await?
diff --git a/turbopack/crates/turbopack-core/src/resolve/parse.rs b/turbopack/crates/turbopack-core/src/resolve/parse.rs
index 15f58172c845..4230c9f49961 100644
--- a/turbopack/crates/turbopack-core/src/resolve/parse.rs
+++ b/turbopack/crates/turbopack-core/src/resolve/parse.rs
@@ -162,6 +162,20 @@ impl Request {
             return Request::Empty;
         }
 
+        // Handle webpack-style tilde prefix (~) for node_modules resolution
+        // This is commonly used in CSS preprocessors like less-loader and sass-loader
+        // Only strip ~ if it's followed by a module path (not a relative path like ~/home)
+        // for utoopack issue: https://github.com/utooland/utoo/issues/2309
+        let r = if let Some(remainder) = r
+            .strip_prefix('~')
+            .filter(|s| !s.is_empty() && !s.starts_with('/') && !s.starts_with('\\'))
+            .filter(|s| MODULE_PATH.is_match(s))
+        {
+            remainder.into()
+        } else {
+            r
+        };
+
         if let Some(remainder) = r.strip_prefix("//") {
             return Request::Uri {
                 protocol: rcstr!("//"),
diff --git a/turbopack/crates/turbopack-core/src/source_map/utils.rs b/turbopack/crates/turbopack-core/src/source_map/utils.rs
index 63df52bf29bd..8caa3e1ac27d 100644
--- a/turbopack/crates/turbopack-core/src/source_map/utils.rs
+++ b/turbopack/crates/turbopack-core/src/source_map/utils.rs
@@ -114,15 +114,24 @@ pub async fn resolve_source_map_sources(
 
             let fs_path = if let Ok(original_source_url_obj) = Url::parse(&maybe_file_url) {
                 // We have an absolute URL, try to parse it as a `file://` URL
-                if let Ok(sys_path) = original_source_url_obj.to_file_path() {
-                    if let Some((disk_fs_vc, disk_fs)) = disk_fs {
-                        disk_fs.try_from_sys_path(*disk_fs_vc, &sys_path, Some(origin))
+                #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
+                {
+                    if let Ok(sys_path) = original_source_url_obj.to_file_path() {
+                        if let Some((disk_fs_vc, disk_fs)) = disk_fs {
+                            disk_fs.try_from_sys_path(*disk_fs_vc, &sys_path, Some(origin))
+                        } else {
+                            None
+                        }
                     } else {
-                        None
+                        // this is an absolute URL with a non-`file://` scheme, just assume it's valid
+                        // and don't modify anything
+                        return Ok(());
                     }
-                } else {
-                    // this is an absolute URL with a non-`file://` scheme, just assume it's valid
-                    // and don't modify anything
+                }
+                #[cfg(all(target_family = "wasm", target_os = "unknown"))]
+                {
+                    // On WASM targets, to_file_path() is not available,
+                    // just assume it's a valid absolute URL and don't modify anything
                     return Ok(());
                 }
             } else {
diff --git a/turbopack/crates/turbopack-css/src/process.rs b/turbopack/crates/turbopack-css/src/process.rs
index d58750d7b298..047284822494 100644
--- a/turbopack/crates/turbopack-css/src/process.rs
+++ b/turbopack/crates/turbopack-css/src/process.rs
@@ -448,16 +448,20 @@ async fn process_content(
                     let mut validator = CssValidator { errors: Vec::new() };
                     ss.visit(&mut validator).unwrap();
 
-                    for err in validator.errors {
-                        err.report(source);
-                    }
+                    // TODO: remove pure selector
+                    // for err in validator.errors {
+                    //     err.report(source);
+                    // }
                 }
 
                 for err in warnings.read().unwrap().iter() {
-                    match err.kind {
+                    match &err.kind {
+                        // Ignore all SelectorError errors
+                        lightningcss::error::ParserError::SelectorError(..) => {
+                            continue;
+                        }
                         lightningcss::error::ParserError::UnexpectedToken(_)
                         | lightningcss::error::ParserError::UnexpectedImportRule
-                        | lightningcss::error::ParserError::SelectorError(..)
                         | lightningcss::error::ParserError::EndOfInput => {
                             let source = match &err.loc {
                                 Some(loc) => IssueSource::from_single_line_col(
@@ -482,7 +486,7 @@ async fn process_content(
                         }
 
                         _ => {
-                            // Ignore
+                            // Ignore other warnings
                         }
                     }
                 }
@@ -523,6 +527,11 @@ async fn process_content(
                 stylesheet_into_static(&ss, without_warnings(config.clone()))
             }
             Err(e) => {
+                // Ignore all SelectorError errors
+                if matches!(e.kind, lightningcss::error::ParserError::SelectorError(..)) {
+                    return Ok(ParseCssResult::Unparsable.cell());
+                }
+
                 let source = match &e.loc {
                     Some(loc) => IssueSource::from_single_line_col(
                         source,
@@ -580,6 +589,7 @@ enum CssError {
 }
 
 impl CssError {
+    #[allow(unused)]
     fn report(self, source: ResolvedVc<Box<dyn Source>>) {
         match self {
             CssError::CssSelectorInModuleNotPure { selector } => {
diff --git a/turbopack/crates/turbopack-css/src/references/url.rs b/turbopack/crates/turbopack-css/src/references/url.rs
index da2166521e11..c8f73d523b5e 100644
--- a/turbopack/crates/turbopack-css/src/references/url.rs
+++ b/turbopack/crates/turbopack-css/src/references/url.rs
@@ -82,7 +82,7 @@ impl ModuleReference for UrlAssetReference {
             *self.request,
             ReferenceType::Url(UrlReferenceSubType::CssUrl),
             Some(self.issue_source),
-            ResolveErrorMode::Error,
+            ResolveErrorMode::Warn,
         )
     }
 
diff --git a/turbopack/crates/turbopack-dev-server/Cargo.toml b/turbopack/crates/turbopack-dev-server/Cargo.toml
index bbe1b58a04c9..685f19446e15 100644
--- a/turbopack/crates/turbopack-dev-server/Cargo.toml
+++ b/turbopack/crates/turbopack-dev-server/Cargo.toml
@@ -21,8 +21,6 @@ auto-hash-map = { workspace = true }
 bincode = { workspace = true }
 flate2 = { workspace = true }
 futures = { workspace = true }
-hyper = { version = "0.14", features = ["full"] }
-hyper-tungstenite = "0.9.0"
 mime = { workspace = true }
 mime_guess = "2.0.4"
 parking_lot = { workspace = true }
@@ -31,10 +29,7 @@ rustc-hash = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 serde_qs = { workspace = true }
-socket2 = "0.4.9"
-tokio = { workspace = true }
-tokio-stream = "0.1.9"
-tokio-util = { workspace = true }
+
 tracing = { workspace = true }
 turbo-bincode = { workspace = true }
 turbo-rcstr = { workspace = true }
@@ -49,6 +44,14 @@ turbopack-ecmascript = { workspace = true }
 turbopack-ecmascript-hmr-protocol = { workspace = true }
 urlencoding = "2.1.2"
 
+[target.'cfg(not(all(target_family = "wasm", target_os = "unknown")))'.dependencies]
+hyper = { version = "0.14", features = ["full"] }
+hyper-tungstenite = "0.9.0"
+tokio = { workspace = true }
+tokio-stream = "0.1.9"
+tokio-util = { workspace = true }
+socket2 = "0.4.9"
+
 [dev-dependencies]
 turbo-tasks-backend = { workspace = true }
 
diff --git a/turbopack/crates/turbopack-dev-server/src/lib.rs b/turbopack/crates/turbopack-dev-server/src/lib.rs
index 4894eba6c967..2586c9286afe 100644
--- a/turbopack/crates/turbopack-dev-server/src/lib.rs
+++ b/turbopack/crates/turbopack-dev-server/src/lib.rs
@@ -6,12 +6,16 @@
 #![feature(arbitrary_self_types_pointers)]
 
 pub mod html;
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 mod http;
 pub mod introspect;
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 mod invalidation;
 pub mod source;
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 pub mod update;
 
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 use std::{
     collections::VecDeque,
     future::Future,
@@ -21,27 +25,38 @@ use std::{
     time::{Duration, Instant},
 };
 
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 use anyhow::{Context, Result};
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 use hyper::{
     Request, Response, Server,
     server::{Builder, conn::AddrIncoming},
     service::{make_service_fn, service_fn},
 };
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 use parking_lot::Mutex;
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 use socket2::{Domain, Protocol, Socket, Type};
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 use tokio::task::JoinHandle;
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 use tracing::{Instrument, Level, Span, event, info_span};
+use turbo_tasks::OperationVc;
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 use turbo_tasks::{
-    Effects, NonLocalValue, OperationVc, PrettyPrintError, TurboTasksApi, Vc, get_effects,
-    run_once_with_reason, trace::TraceRawVcs, util::FormatDuration,
+    Effects, NonLocalValue, PrettyPrintError, TurboTasksApi, Vc, get_effects, run_once_with_reason,
+    trace::TraceRawVcs, util::FormatDuration,
 };
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 use turbopack_core::issue::{IssueReporter, IssueSeverity, handle_issues};
 
-use self::{source::ContentSource, update::UpdateServer};
-use crate::{
-    invalidation::{ServerRequest, ServerRequestSideEffects},
-    source::ContentSourceSideEffect,
-};
+use self::source::ContentSource;
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
+use self::update::UpdateServer;
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
+use crate::invalidation::{ServerRequest, ServerRequestSideEffects};
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
+use crate::source::ContentSourceSideEffect;
 
 pub trait SourceProvider: Send + Clone + 'static {
     /// must call a turbo-tasks function internally
@@ -80,6 +95,7 @@ pub struct DevServerBuilder {
     server: Builder<AddrIncoming>,
 }
 
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 #[derive(TraceRawVcs, NonLocalValue)]
 pub struct DevServer {
     #[turbo_tasks(trace_ignore)]
@@ -88,6 +104,7 @@ pub struct DevServer {
     pub future: Pin<Box<dyn Future<Output = Result<()>> + Send + 'static>>,
 }
 
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 impl DevServer {
     pub fn listen(addr: SocketAddr) -> Result<DevServerBuilder, anyhow::Error> {
         // This is annoying. The hyper::Server doesn't allow us to know which port was
@@ -123,6 +140,7 @@ impl DevServer {
     }
 }
 
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 impl DevServerBuilder {
     pub fn serve(
         self,
diff --git a/turbopack/crates/turbopack-dev-server/src/source/mod.rs b/turbopack/crates/turbopack-dev-server/src/source/mod.rs
index 2d1bbf21a562..564135f8bd6a 100644
--- a/turbopack/crates/turbopack-dev-server/src/source/mod.rs
+++ b/turbopack/crates/turbopack-dev-server/src/source/mod.rs
@@ -5,7 +5,9 @@ pub mod headers;
 pub mod issue_context;
 pub mod lazy_instantiated;
 pub mod query;
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 pub mod request;
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 pub(crate) mod resolve;
 pub mod route_tree;
 pub mod router;
diff --git a/turbopack/crates/turbopack-ecmascript-runtime/js/src/browser/runtime/base/runtime-base.ts b/turbopack/crates/turbopack-ecmascript-runtime/js/src/browser/runtime/base/runtime-base.ts
index dc3fe78bdd75..3955a13cf8da 100644
--- a/turbopack/crates/turbopack-ecmascript-runtime/js/src/browser/runtime/base/runtime-base.ts
+++ b/turbopack/crates/turbopack-ecmascript-runtime/js/src/browser/runtime/base/runtime-base.ts
@@ -23,6 +23,14 @@ declare var CHUNK_BASE_PATH: string
 declare var ASSET_SUFFIX: string
 declare var WORKER_FORWARDED_GLOBALS: string[]
 
+// Support runtime public path from window.publicPath
+function getRuntimeChunkBasePath(): string {
+  if (CHUNK_BASE_PATH === '__RUNTIME_PUBLIC_PATH__') {
+    return contextPrototype.p()
+  }
+  return CHUNK_BASE_PATH
+}
+
 interface TurbopackBrowserBaseContext<M> extends TurbopackBaseContext<M> {
   R: ResolvePathFromModule
 }
@@ -198,6 +206,36 @@ function loadChunkByUrl(
 }
 browserContextPrototype.L = loadChunkByUrl
 
+const loadedScripts = new Map<string, Promise<void>>()
+
+/**
+ * Load an external script by creating a <script> tag.
+ * This is used for script externals that need to be loaded from CDN or other external sources.
+ */
+function loadScript(
+  this: TurbopackBrowserBaseContext<Module>,
+  scriptUrl: string
+): Promise<void> {
+  // Return cached promise if script is already loading or loaded
+  let promise = loadedScripts.get(scriptUrl)
+  if (promise) {
+    return promise
+  }
+
+  promise = new Promise<void>((resolve, reject) => {
+    const script = document.createElement('script')
+    script.src = scriptUrl
+    script.onload = () => resolve()
+    script.onerror = () =>
+      reject(new Error(`Failed to load script: ${scriptUrl}`))
+    document.head.appendChild(script)
+  })
+
+  loadedScripts.set(scriptUrl, promise)
+  return promise
+}
+browserContextPrototype.S = loadScript
+
 // Do not make this async. React relies on referential equality of the returned Promise.
 function loadChunkByUrlInternal(
   sourceType: SourceType,
@@ -348,7 +386,7 @@ function instantiateRuntimeModule(
  * Returns the URL relative to the origin where a chunk can be fetched from.
  */
 function getChunkRelativeUrl(chunkPath: ChunkPath | ChunkListPath): ChunkUrl {
-  return `${CHUNK_BASE_PATH}${chunkPath
+  return `${getRuntimeChunkBasePath()}${chunkPath
     .split('/')
     .map((p) => encodeURIComponent(p))
     .join('/')}${ASSET_SUFFIX}` as ChunkUrl
@@ -369,9 +407,13 @@ function getPathFromScript(
   }
   const chunkUrl = chunkScript.src!
   const src = decodeURIComponent(chunkUrl.replace(/[?#].*$/, ''))
-  const path = src.startsWith(CHUNK_BASE_PATH)
-    ? src.slice(CHUNK_BASE_PATH.length)
+  const runtimeBasePath = getRuntimeChunkBasePath()
+  let path = src.startsWith(runtimeBasePath)
+    ? src.slice(runtimeBasePath.length)
     : src
+  if (path.startsWith('/')) {
+    path = path.slice(1)
+  }
   return path as ChunkPath | ChunkListPath
 }
 
diff --git a/turbopack/crates/turbopack-ecmascript-runtime/js/src/browser/runtime/dom/runtime-backend-dom.ts b/turbopack/crates/turbopack-ecmascript-runtime/js/src/browser/runtime/dom/runtime-backend-dom.ts
index d514565edc8b..46e1b84ab604 100644
--- a/turbopack/crates/turbopack-ecmascript-runtime/js/src/browser/runtime/dom/runtime-backend-dom.ts
+++ b/turbopack/crates/turbopack-ecmascript-runtime/js/src/browser/runtime/dom/runtime-backend-dom.ts
@@ -39,7 +39,7 @@ const chunkResolvers: Map<ChunkUrl, ChunkResolver> = new Map()
   BACKEND = {
     async registerChunk(chunk, params) {
       let chunkPath = getPathFromScript(chunk)
-      let chunkUrl = getUrlFromScript(chunk)
+      let chunkUrl = getUrlFromScript(chunkPath)
 
       const resolver = getOrCreateResolver(chunkUrl)
       resolver.resolve()
diff --git a/turbopack/crates/turbopack-ecmascript-runtime/js/src/nodejs/runtime.web.ts b/turbopack/crates/turbopack-ecmascript-runtime/js/src/nodejs/runtime.web.ts
new file mode 100644
index 000000000000..67fb33eb04b7
--- /dev/null
+++ b/turbopack/crates/turbopack-ecmascript-runtime/js/src/nodejs/runtime.web.ts
@@ -0,0 +1,312 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+
+/// <reference path="../shared/runtime-utils.ts" />
+/// <reference path="../shared-node/base-externals-utils.ts" />
+/// <reference path="../shared-node/node-externals-utils.ts" />
+/// <reference path="../shared-node/node-wasm-utils.ts" />
+
+// @ts-ignore
+
+const path = require('path')
+
+// @ts-ignore
+
+const RUNTIME_ROOT = './'
+
+enum SourceType {
+  /**
+   * The module was instantiated because it was included in an evaluated chunk's
+   * runtime.
+   * SourceData is a ChunkPath.
+   */
+  Runtime = 0,
+  /**
+   * The module was instantiated because a parent module imported it.
+   * SourceData is a ModuleId.
+   */
+  Parent = 1,
+}
+
+type SourceData = ChunkPath | ModuleId
+
+process.env.TURBOPACK = '1'
+
+interface TurbopackNodeBuildContext extends TurbopackBaseContext<Module> {
+  R: ResolvePathFromModule
+  x: ExternalRequire
+  y: ExternalImport
+}
+
+const nodeContextPrototype = Context.prototype as TurbopackNodeBuildContext
+
+type ModuleFactory = (
+  this: Module['exports'],
+  context: TurbopackNodeBuildContext
+) => unknown
+
+const url = require('url') as typeof import('url')
+
+const moduleFactories: ModuleFactories = new Map()
+nodeContextPrototype.M = moduleFactories
+const moduleCache: ModuleCache<Module> = Object.create(null)
+nodeContextPrototype.c = moduleCache
+
+/**
+ * Returns an absolute path to the given module's id.
+ */
+function resolvePathFromModule(
+  this: TurbopackBaseContext<Module>,
+  moduleId: string
+): string {
+  const exported = this.r(moduleId)
+  const exportedPath = exported?.default ?? exported
+  if (typeof exportedPath !== 'string') {
+    return exported as any
+  }
+
+  const strippedAssetPrefix = exportedPath.slice(ASSET_PREFIX.length)
+  const resolved = path.resolve(RUNTIME_ROOT, strippedAssetPrefix)
+
+  return url.pathToFileURL(resolved).href
+}
+nodeContextPrototype.R = resolvePathFromModule
+
+function loadRuntimeChunk(sourcePath: ChunkPath, chunkData: ChunkData): void {
+  if (typeof chunkData === 'string') {
+    loadRuntimeChunkPath(sourcePath, chunkData)
+  } else {
+    loadRuntimeChunkPath(sourcePath, chunkData.path)
+  }
+}
+
+const loadedChunks = new Set<ChunkPath>()
+const unsupportedLoadChunk = Promise.resolve(undefined)
+const loadedChunk: Promise<void> = Promise.resolve(undefined)
+const chunkCache = new Map<ChunkPath, Promise<void>>()
+
+function clearChunkCache() {
+  chunkCache.clear()
+}
+
+function loadRuntimeChunkPath(
+  sourcePath: ChunkPath,
+  chunkPath: ChunkPath
+): void {
+  if (!isJs(chunkPath)) {
+    // We only support loading JS chunks in Node.js.
+    // This branch can be hit when trying to load a CSS chunk.
+    return
+  }
+
+  if (loadedChunks.has(chunkPath)) {
+    return
+  }
+
+  try {
+    const resolved = `${RUNTIME_ROOT}${chunkPath}`
+    const chunkModules: CompressedModuleFactories = require(resolved)
+    installCompressedModuleFactories(chunkModules, 0, moduleFactories)
+    loadedChunks.add(chunkPath)
+  } catch (e) {
+    let errorMessage = `Failed to load chunk ${chunkPath}`
+
+    if (sourcePath) {
+      errorMessage += ` from runtime for chunk ${sourcePath}`
+    }
+
+    throw new Error(errorMessage, {
+      cause: e,
+    })
+  }
+}
+
+function loadChunkAsync(
+  this: TurbopackBaseContext<Module>,
+  chunkData: ChunkData
+): Promise<void> {
+  const chunkPath = typeof chunkData === 'string' ? chunkData : chunkData.path
+  if (!isJs(chunkPath)) {
+    // We only support loading JS chunks in Node.js.
+    // This branch can be hit when trying to load a CSS chunk.
+    return unsupportedLoadChunk
+  }
+
+  let entry = chunkCache.get(chunkPath)
+  if (entry === undefined) {
+    try {
+      // resolve to an absolute path to simplify `require` handling
+      const resolved = path.resolve(RUNTIME_ROOT, chunkPath)
+      // TODO: consider switching to `import()` to enable concurrent chunk loading and async file io
+      // However this is incompatible with hot reloading (since `import` doesn't use the require cache)
+      const chunkModules: CompressedModuleFactories = require(resolved)
+      installCompressedModuleFactories(chunkModules, 0, moduleFactories)
+      entry = loadedChunk
+    } catch (e) {
+      const errorMessage = `Failed to load chunk ${chunkPath} from module ${this.m.id}`
+
+      // Cache the failure promise, future requests will also get this same rejection
+      entry = Promise.reject(
+        new Error(errorMessage, {
+          cause: e,
+        })
+      )
+    }
+    chunkCache.set(chunkPath, entry)
+  }
+  // TODO: Return an instrumented Promise that React can use instead of relying on referential equality.
+  return entry
+}
+contextPrototype.l = loadChunkAsync
+
+function loadChunkAsyncByUrl(
+  this: TurbopackBaseContext<Module>,
+  chunkUrl: string
+) {
+  const path = url.fileURLToPath(new URL(chunkUrl, RUNTIME_ROOT)) as ChunkPath
+  return loadChunkAsync.call(this, path)
+}
+contextPrototype.L = loadChunkAsyncByUrl
+
+function loadWebAssembly(
+  chunkPath: ChunkPath,
+  _edgeModule: () => WebAssembly.Module,
+  imports: WebAssembly.Imports
+) {
+  const resolved = path.resolve(RUNTIME_ROOT, chunkPath)
+
+  return instantiateWebAssemblyFromPath(resolved, imports)
+}
+contextPrototype.w = loadWebAssembly
+
+function loadWebAssemblyModule(
+  chunkPath: ChunkPath,
+  _edgeModule: () => WebAssembly.Module
+) {
+  const resolved = path.resolve(RUNTIME_ROOT, chunkPath)
+
+  return compileWebAssemblyFromPath(resolved)
+}
+contextPrototype.u = loadWebAssemblyModule
+
+function getWorkerBlobURL(_chunks: ChunkPath[]): string {
+  throw new Error('Worker blobs are not implemented yet for Node.js')
+}
+
+nodeContextPrototype.b = getWorkerBlobURL
+
+function instantiateModule(
+  id: ModuleId,
+  sourceType: SourceType,
+  sourceData: SourceData
+): Module {
+  const moduleFactory = moduleFactories.get(id)
+  if (typeof moduleFactory !== 'function') {
+    // This can happen if modules incorrectly handle HMR disposes/updates,
+    // e.g. when they keep a `setTimeout` around which still executes old code
+    // and contains e.g. a `require("something")` call.
+    let instantiationReason: string
+    switch (sourceType) {
+      case SourceType.Runtime:
+        instantiationReason = `as a runtime entry of chunk ${sourceData}`
+        break
+      case SourceType.Parent:
+        instantiationReason = `because it was required from module ${sourceData}`
+        break
+      default:
+        invariant(
+          sourceType,
+          (sourceType) => `Unknown source type: ${sourceType}`
+        )
+    }
+    throw new Error(
+      `Module ${id} was instantiated ${instantiationReason}, but the module factory is not available.`
+    )
+  }
+
+  const module: Module = createModuleObject(id)
+  const exports = module.exports
+  moduleCache[id] = module
+
+  const context = new (Context as any as ContextConstructor<Module>)(
+    module,
+    exports
+  )
+  // NOTE(alexkirsz) This can fail when the module encounters a runtime error.
+  try {
+    moduleFactory(context, module, exports)
+  } catch (error) {
+    module.error = error as any
+    throw error
+  }
+
+  module.loaded = true
+  if (module.namespaceObject && module.exports !== module.namespaceObject) {
+    // in case of a circular dependency: cjs1 -> esm2 -> cjs1
+    interopEsm(module.exports, module.namespaceObject)
+  }
+
+  return module
+}
+
+/**
+ * Retrieves a module from the cache, or instantiate it if it is not cached.
+ */
+// @ts-ignore
+function getOrInstantiateModuleFromParent(
+  id: ModuleId,
+  sourceModule: Module
+): Module {
+  const module = moduleCache[id]
+
+  if (module) {
+    if (module.error) {
+      throw module.error
+    }
+
+    return module
+  }
+
+  return instantiateModule(id, SourceType.Parent, sourceModule.id)
+}
+
+/**
+ * Instantiates a runtime module.
+ */
+function instantiateRuntimeModule(
+  chunkPath: ChunkPath,
+  moduleId: ModuleId
+): Module {
+  return instantiateModule(moduleId, SourceType.Runtime, chunkPath)
+}
+
+/**
+ * Retrieves a module from the cache, or instantiate it as a runtime module if it is not cached.
+ */
+// @ts-ignore TypeScript doesn't separate this module space from the browser runtime
+function getOrInstantiateRuntimeModule(
+  chunkPath: ChunkPath,
+  moduleId: ModuleId
+): Module {
+  const module = moduleCache[moduleId]
+  if (module) {
+    if (module.error) {
+      throw module.error
+    }
+    return module
+  }
+
+  return instantiateRuntimeModule(chunkPath, moduleId)
+}
+
+const regexJsUrl = /\.js(?:\?[^#]*)?(?:#.*)?$/
+/**
+ * Checks if a given path/URL ends with .js, optionally followed by ?query or #fragment.
+ */
+function isJs(chunkUrlOrPath: ChunkUrl | ChunkPath): boolean {
+  return regexJsUrl.test(chunkUrlOrPath)
+}
+
+module.exports = (sourcePath: ChunkPath) => ({
+  m: (id: ModuleId) => getOrInstantiateRuntimeModule(sourcePath, id),
+  c: (chunkData: ChunkData) => loadRuntimeChunk(sourcePath, chunkData),
+})
diff --git a/turbopack/crates/turbopack-ecmascript-runtime/js/src/shared/runtime/runtime-types.d.ts b/turbopack/crates/turbopack-ecmascript-runtime/js/src/shared/runtime/runtime-types.d.ts
index d3fc7fd41ff6..650339ef6d97 100644
--- a/turbopack/crates/turbopack-ecmascript-runtime/js/src/shared/runtime/runtime-types.d.ts
+++ b/turbopack/crates/turbopack-ecmascript-runtime/js/src/shared/runtime/runtime-types.d.ts
@@ -63,6 +63,7 @@ type DynamicExport = (
 
 type LoadChunk = (chunkPath: ChunkPath) => Promise<any> | undefined
 type LoadChunkByUrl = (chunkUrl: ChunkUrl) => Promise<any> | undefined
+type LoadScript = (scriptUrl: string) => Promise<void>
 type LoadWebAssembly = (
   wasmChunkPath: ChunkPath,
   edgeModule: () => WebAssembly.Module,
@@ -103,6 +104,8 @@ type GetWorkerURL = (
   shared: boolean
 ) => URL
 
+type GetPublicPath = () => string
+
 type ExternalRequire = (
   id: DependencySpecifier,
   thunk: () => any,
@@ -145,6 +148,7 @@ interface TurbopackBaseContext<M> {
   M: ModuleFactories
   l: LoadChunk
   L: LoadChunkByUrl
+  S: LoadScript
   w: LoadWebAssembly
   u: LoadWebAssemblyModule
   P: ResolveAbsolutePath
@@ -154,4 +158,5 @@ interface TurbopackBaseContext<M> {
   y: ExternalImport
   z: CommonJsRequire
   g: typeof globalThis
+  p: GetPublicPath
 }
diff --git a/turbopack/crates/turbopack-ecmascript-runtime/js/src/shared/runtime/runtime-utils.ts b/turbopack/crates/turbopack-ecmascript-runtime/js/src/shared/runtime/runtime-utils.ts
index 26f636db0fb2..8a1502cd4013 100644
--- a/turbopack/crates/turbopack-ecmascript-runtime/js/src/shared/runtime/runtime-utils.ts
+++ b/turbopack/crates/turbopack-ecmascript-runtime/js/src/shared/runtime/runtime-utils.ts
@@ -834,6 +834,22 @@ contextPrototype.z = requireStub
 // Make `globalThis` available to the module in a way that cannot be shadowed by a local variable.
 contextPrototype.g = globalThis
 
+/**
+ * Gets the public path for runtime assets.
+ * Checks globalThis.publicPath and falls back to empty string.
+ */
+function getPublicPath(): string {
+  if (
+    typeof globalThis !== 'undefined' &&
+    typeof (globalThis as any).publicPath === 'string'
+  ) {
+    const publicPath = (globalThis as any).publicPath as string
+    return publicPath.endsWith('/') ? publicPath : `${publicPath}/`
+  }
+  return ''
+}
+contextPrototype.p = getPublicPath
+
 type ContextConstructor<M> = {
   new (module: Module, exports: Exports): TurbopackBaseContext<M>
 }
diff --git a/turbopack/crates/turbopack-ecmascript-runtime/src/browser_runtime.rs b/turbopack/crates/turbopack-ecmascript-runtime/src/browser_runtime.rs
index 8ee69fee1ba7..975412cf3750 100644
--- a/turbopack/crates/turbopack-ecmascript-runtime/src/browser_runtime.rs
+++ b/turbopack/crates/turbopack-ecmascript-runtime/src/browser_runtime.rs
@@ -12,7 +12,14 @@ use turbopack_core::{
 };
 use turbopack_ecmascript::utils::StringifyJs;
 
-use crate::{RuntimeType, asset_context::get_runtime_asset_context, embed_js::embed_static_code};
+use crate::{
+    RuntimeType,
+    asset_context::get_runtime_asset_context,
+    embed_js::embed_static_code,
+};
+
+const GLOBAL_THIS_FALLBACK_EXPR: &str =
+    "typeof globalThis !== \"undefined\" ? globalThis : (typeof self !== \"undefined\" ? self : (typeof window !== \"undefined\" ? window : (typeof global !== \"undefined\" ? global : {})))";
 
 /// Returns the code for the ECMAScript runtime.
 #[turbo_tasks::function]
@@ -25,6 +32,7 @@ pub async fn get_browser_runtime_code(
     output_root_to_root_path: RcStr,
     generate_source_map: bool,
     chunk_loading_global: Vc<RcStr>,
+    entry_root_export: Vc<Option<RcStr>>,
 ) -> Result<Vc<Code>> {
     let asset_context = get_runtime_asset_context(*environment).resolve().await?;
 
@@ -87,31 +95,71 @@ pub async fn get_browser_runtime_code(
     let asset_suffix = asset_suffix.await?;
     let chunk_loading_global = chunk_loading_global.await?;
     let chunk_lists_global = format!("{}_CHUNK_LISTS", &*chunk_loading_global);
+    let entry_root_export = entry_root_export.await?;
 
-    writedoc!(
-        code,
-        r#"
-            (() => {{
-            if (!Array.isArray(globalThis[{}])) {{
-                return;
-            }}
-
-            const CHUNK_BASE_PATH = {};
-            const RELATIVE_ROOT_PATH = {};
-            const RUNTIME_PUBLIC_PATH = {};
-        "#,
-        StringifyJs(&chunk_loading_global),
-        StringifyJs(chunk_base_path),
-        StringifyJs(relative_root_path.as_str()),
-        StringifyJs(chunk_base_path),
-    )?;
+    // Start the IIFE
+    if let Some(ref export_name) = *entry_root_export {
+        writedoc!(
+            code,
+            r#"
+                (function(root, factory) {{
+                    if (typeof exports === 'object' && typeof module === 'object')
+                        module.exports = factory();
+                    else if (typeof exports === 'object')
+                        exports[{}] = factory();
+                    else
+                        root[{}] = factory();
+                }}(typeof self !== 'undefined' ? self : this, function() {{
+
+                var __chunk__ = (function() {{
+                var __turbopack_global__ = {global_this_fallback};
+                var globalThis = __turbopack_global__;
+                if (!Array.isArray(__turbopack_global__["{chunk_loading_global}"])) {{
+                    return;
+                }}
+
+                var __entryExports__ = undefined;
+
+                var CHUNK_BASE_PATH = {};
+                var RELATIVE_ROOT_PATH = {};
+                var RUNTIME_PUBLIC_PATH = {};
+            "#,
+            StringifyJs(export_name.as_str()),
+            StringifyJs(export_name.as_str()),
+            StringifyJs(chunk_base_path),
+            StringifyJs(relative_root_path.as_str()),
+            StringifyJs(chunk_base_path),
+            global_this_fallback = GLOBAL_THIS_FALLBACK_EXPR,
+        )?;
+    } else {
+        writedoc!(
+            code,
+            r#"
+                (() => {{
+                var __turbopack_global__ = {global_this_fallback};
+                var globalThis = __turbopack_global__;
+                if (!Array.isArray(__turbopack_global__[{}])) {{
+                    return;
+                }}
+
+                var CHUNK_BASE_PATH = {};
+                var RELATIVE_ROOT_PATH = {};
+                var RUNTIME_PUBLIC_PATH = {};
+            "#,
+            StringifyJs(&chunk_loading_global),
+            StringifyJs(chunk_base_path),
+            StringifyJs(relative_root_path.as_str()),
+            StringifyJs(chunk_base_path),
+            global_this_fallback = GLOBAL_THIS_FALLBACK_EXPR,
+        )?;
+    }
 
     match &*asset_suffix {
         AssetSuffix::None => {
             writedoc!(
                 code,
                 r#"
-                    const ASSET_SUFFIX = "";
+                    var ASSET_SUFFIX = "";
                 "#
             )?;
         }
@@ -119,7 +167,7 @@ pub async fn get_browser_runtime_code(
             writedoc!(
                 code,
                 r#"
-                    const ASSET_SUFFIX = {};
+                    var ASSET_SUFFIX = {};
                 "#,
                 StringifyJs(suffix.as_str())
             )?;
@@ -131,7 +179,7 @@ pub async fn get_browser_runtime_code(
             writedoc!(
                 code,
                 r#"
-                    const ASSET_SUFFIX = getAssetSuffixFromScriptSrc();
+                    var ASSET_SUFFIX = getAssetSuffixFromScriptSrc();
                 "#
             )?;
         }
@@ -139,7 +187,7 @@ pub async fn get_browser_runtime_code(
             writedoc!(
                 code,
                 r#"
-                    const ASSET_SUFFIX = globalThis[{}] || "";
+                    var ASSET_SUFFIX = __turbopack_global__[{}] || "";
                 "#,
                 StringifyJs(global_name)
             )?;
@@ -151,11 +199,10 @@ pub async fn get_browser_runtime_code(
     writedoc!(
         code,
         r#"
-            const WORKER_FORWARDED_GLOBALS = {};
+            var WORKER_FORWARDED_GLOBALS = {};
         "#,
         StringifyJs(&*worker_forwarded_globals)
     )?;
-
     code.push_code(&*shared_runtime_utils_code.await?);
     for runtime_code in runtime_base_code {
         code.push_code(
@@ -205,8 +252,8 @@ pub async fn get_browser_runtime_code(
     writedoc!(
         code,
         r#"
-            const chunksToRegister = globalThis[{chunk_loading_global}];
-            globalThis[{chunk_loading_global}] = {{ push: registerChunk }};
+            var chunksToRegister = __turbopack_global__[{chunk_loading_global}] || [];
+            __turbopack_global__[{chunk_loading_global}] = {{ push: registerChunk }};
             chunksToRegister.forEach(registerChunk);
         "#,
         chunk_loading_global = StringifyJs(&chunk_loading_global),
@@ -215,19 +262,67 @@ pub async fn get_browser_runtime_code(
         writedoc!(
             code,
             r#"
-            const chunkListsToRegister = globalThis[{chunk_lists_global}] || [];
-            globalThis[{chunk_lists_global}] = {{ push: registerChunkList }};
+            var chunkListsToRegister = __turbopack_global__[{chunk_lists_global}] || [];
+            __turbopack_global__[{chunk_lists_global}] = {{ push: registerChunkList }};
             chunkListsToRegister.forEach(registerChunkList);
         "#,
             chunk_lists_global = StringifyJs(&chunk_lists_global),
         )?;
     }
-    writedoc!(
-        code,
-        r#"
+
+    // Add expose entry exports code if enabled
+    if entry_root_export.is_some() {
+        writedoc!(
+            code,
+            r#"
+
+                try {{
+                for (var i = 0; i < chunksToRegister.length; i++) {{
+                    var registration = chunksToRegister[i];
+                    var runtimeParams = registration.length === 2 ? registration[1] : null;
+                    if (runtimeParams && runtimeParams.runtimeModuleIds && runtimeParams.runtimeModuleIds.length > 0) {{
+                        var entryModuleId = runtimeParams.runtimeModuleIds[runtimeParams.runtimeModuleIds.length - 1];
+                        var chunkPath = getPathFromScript(registration[0]);
+
+                        var entryModule = getOrInstantiateRuntimeModule(chunkPath, entryModuleId);
+
+                        if (entryModule && entryModule.exports) {{
+                            var moduleExports = entryModule.namespaceObject || entryModule.exports;
+
+                            // Save for return value (will be handled by UMD wrapper)
+                            __entryExports__ = moduleExports;
+                        }}
+                        break;
+                    }}
+                }}
+                }} catch (e) {{
+                    console.error('Failed to expose entry module exports:', e);
+                }}
+            "#
+        )?;
+    }
+
+    // Close the IIFE and return exports if enabled
+    if entry_root_export.is_some() {
+        writedoc!(
+            code,
+            r#"
+                return __entryExports__;
             }})();
-        "#
-    )?;
+
+            // Return the exports from the factory function
+            return __chunk__;
+            }}));
+            "#
+        )?;
+    } else {
+        writedoc!(
+            code,
+            r#"
+            }})();
+            "#
+        )?;
+    }
 
     Ok(Code::cell(code.build()))
 }
diff --git a/turbopack/crates/turbopack-ecmascript/Cargo.toml b/turbopack/crates/turbopack-ecmascript/Cargo.toml
index 48eea0823f42..cd82430210fb 100644
--- a/turbopack/crates/turbopack-ecmascript/Cargo.toml
+++ b/turbopack/crates/turbopack-ecmascript/Cargo.toml
@@ -45,7 +45,7 @@ serde_json = { workspace = true, features = ["raw_value"] }
 swc_sourcemap = { workspace = true }
 smallvec = { workspace = true }
 strsim = { workspace = true }
-tokio = { workspace = true }
+tokio = { workspace = true, features = ["io-util"] }
 tracing = { workspace = true }
 turbo-bincode = { workspace = true }
 turbo-esregex = { workspace = true }
@@ -91,3 +91,4 @@ turbo-tasks-backend = { workspace = true }
 turbo-tasks-malloc = { workspace = true }
 turbo-tasks-testing = { workspace = true }
 turbopack-test-utils = { workspace = true }
+tokio = { workspace = true }
diff --git a/turbopack/crates/turbopack-ecmascript/src/analyzer/well_known.rs b/turbopack/crates/turbopack-ecmascript/src/analyzer/well_known.rs
index e4143f580712..5b664d3622a0 100644
--- a/turbopack/crates/turbopack-ecmascript/src/analyzer/well_known.rs
+++ b/turbopack/crates/turbopack-ecmascript/src/analyzer/well_known.rs
@@ -4,8 +4,13 @@ use anyhow::Result;
 use turbo_rcstr::rcstr;
 use turbo_tasks::Vc;
 use turbopack_core::compile_time_info::CompileTimeInfo;
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 use url::Url;
 
+#[cfg_attr(
+    all(target_family = "wasm", target_os = "unknown"),
+    allow(unused_imports)
+)]
 use super::{
     ConstantValue, JsValue, JsValueUrlKind, ModuleValue, WellKnownFunctionKind,
     WellKnownObjectKind, imports::ImportAnnotations,
@@ -507,23 +512,34 @@ fn require_context_require_resolve(
     Ok(m.as_str().into())
 }
 
+#[cfg_attr(
+    all(target_family = "wasm", target_os = "unknown"),
+    allow(unused_variables)
+)]
 fn path_to_file_url(args: Vec<JsValue>) -> JsValue {
     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(
-                            Box::new(JsValue::WellKnownFunction(
-                                WellKnownFunctionKind::PathToFileUrl,
-                            )),
-                            args,
-                        ),
-                        true,
-                        "url not parseable: path is relative or has an invalid prefix",
-                    )
-                })
+            #[cfg(all(target_family = "wasm", target_os = "unknown"))]
+            {
+                unreachable!()
+            }
+            #[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(
+                                Box::new(JsValue::WellKnownFunction(
+                                    WellKnownFunctionKind::PathToFileUrl,
+                                )),
+                                args,
+                            ),
+                            true,
+                            "url not parseable: path is relative or has an invalid prefix",
+                        )
+                    })
+            }
         } else {
             JsValue::unknown(
                 JsValue::call(
diff --git a/turbopack/crates/turbopack-ecmascript/src/async_chunk/module.rs b/turbopack/crates/turbopack-ecmascript/src/async_chunk/module.rs
index c8658b92a2e6..da63b674f62d 100644
--- a/turbopack/crates/turbopack-ecmascript/src/async_chunk/module.rs
+++ b/turbopack/crates/turbopack-ecmascript/src/async_chunk/module.rs
@@ -164,8 +164,8 @@ impl EcmascriptChunkPlaceable for AsyncLoaderModule {
         if estimated {
             let code = formatdoc! {
                 r#"
-                    {TURBOPACK_EXPORT_VALUE}((parentImport) => {{
-                        return Promise.all([].map((chunk) => {TURBOPACK_LOAD}(chunk))).then(() => {{}});
+                    {TURBOPACK_EXPORT_VALUE}(function(parentImport) {{
+                        return Promise.all([].map(function(chunk) {{ return {TURBOPACK_LOAD}(chunk); }})).then(function() {{}});
                     }});
                 "#,
             };
@@ -198,8 +198,8 @@ impl EcmascriptChunkPlaceable for AsyncLoaderModule {
             (Some(id), true) => {
                 formatdoc! {
                     r#"
-                        {TURBOPACK_EXPORT_VALUE}((parentImport) => {{
-                            return Promise.resolve().then(() => {{
+                        {TURBOPACK_EXPORT_VALUE}(function(parentImport) {{
+                            return Promise.resolve().then(function() {{
                                 return parentImport({id});
                             }});
                         }});
@@ -210,8 +210,8 @@ impl EcmascriptChunkPlaceable for AsyncLoaderModule {
             (Some(id), false) => {
                 formatdoc! {
                     r#"
-                        {TURBOPACK_EXPORT_VALUE}((parentImport) => {{
-                            return Promise.all({chunks:#}.map((chunk) => {TURBOPACK_LOAD}(chunk))).then(() => {{
+                        {TURBOPACK_EXPORT_VALUE}(function(parentImport) {{
+                            return Promise.all({chunks:#}.map(function(chunk) {{ return {TURBOPACK_LOAD}(chunk); }})).then(function() {{
                                 return parentImport({id});
                             }});
                         }});
@@ -223,7 +223,7 @@ impl EcmascriptChunkPlaceable for AsyncLoaderModule {
             (None, true) => {
                 formatdoc! {
                     r#"
-                        {TURBOPACK_EXPORT_VALUE}((parentImport) => {{
+                        {TURBOPACK_EXPORT_VALUE}(function(parentImport) {{
                             return Promise.resolve();
                         }});
                     "#,
@@ -232,8 +232,8 @@ impl EcmascriptChunkPlaceable for AsyncLoaderModule {
             (None, false) => {
                 formatdoc! {
                     r#"
-                        {TURBOPACK_EXPORT_VALUE}((parentImport) => {{
-                            return Promise.all({chunks:#}.map((chunk) => {TURBOPACK_LOAD}(chunk))).then(() => {{}});
+                        {TURBOPACK_EXPORT_VALUE}(function(parentImport) {{
+                            return Promise.all({chunks:#}.map(function(chunk) {{ return {TURBOPACK_LOAD}(chunk); }})).then(function() {{}});
                         }});
                     "#,
                     chunks = StringifyJs(&chunks_data),
diff --git a/turbopack/crates/turbopack-ecmascript/src/chunk/chunk_type.rs b/turbopack/crates/turbopack-ecmascript/src/chunk/chunk_type.rs
index b8912b2285f0..79475993fd1b 100644
--- a/turbopack/crates/turbopack-ecmascript/src/chunk/chunk_type.rs
+++ b/turbopack/crates/turbopack-ecmascript/src/chunk/chunk_type.rs
@@ -1,8 +1,10 @@
 use anyhow::{Result, bail};
+use turbo_rcstr::RcStr;
 use turbo_tasks::{ResolvedVc, TryJoinIterExt, ValueDefault, ValueToString, Vc};
 use turbopack_core::chunk::{
-    AsyncModuleInfo, Chunk, ChunkItem, ChunkItemBatchGroup, ChunkItemOrBatchWithAsyncModuleInfo,
-    ChunkType, ChunkingContext, round_chunk_item_size,
+    AsyncModuleInfo, Chunk, ChunkItem, ChunkItemBatchGroup, ChunkItemExt,
+    ChunkItemOrBatchWithAsyncModuleInfo, ChunkType, ChunkingContext, ModuleId,
+    round_chunk_item_size,
 };
 
 use super::{EcmascriptChunk, EcmascriptChunkContent, EcmascriptChunkItem};
@@ -27,12 +29,42 @@ impl ChunkType for EcmascriptChunkType {
         chunk_items: Vec<ChunkItemOrBatchWithAsyncModuleInfo>,
         batch_groups: Vec<ResolvedVc<ChunkItemBatchGroup>>,
     ) -> Result<Vc<Box<dyn Chunk>>> {
+        // Convert chunk items first
+        let converted_chunk_items: Vec<_> = chunk_items
+            .iter()
+            .map(EcmascriptChunkItemOrBatchWithAsyncInfo::from_chunk_item_or_batch)
+            .try_join()
+            .await?;
+
+        // Sort chunk items by their module ID for deterministic content ordering
+        // This ensures chunks with the same modules produce identical content
+        let mut items_with_id: Vec<_> = converted_chunk_items
+            .into_iter()
+            .map(|item| async move {
+                let id: ModuleId = match &item {
+                    EcmascriptChunkItemOrBatchWithAsyncInfo::ChunkItem(item) => {
+                        item.chunk_item.id().await?
+                    }
+                    EcmascriptChunkItemOrBatchWithAsyncInfo::Batch(batch) => {
+                        let batch_ref = batch.await?;
+                        if let Some(first_item) = batch_ref.chunk_items.first() {
+                            first_item.chunk_item.id().await?
+                        } else {
+                            ModuleId::String(RcStr::default())
+                        }
+                    }
+                };
+                Ok((id, item))
+            })
+            .try_join()
+            .await?;
+
+        items_with_id.sort_by(|a, b| a.0.cmp(&b.0));
+
+        let sorted_items: Vec<_> = items_with_id.into_iter().map(|(_, item)| item).collect();
+
         let content = EcmascriptChunkContent {
-            chunk_items: chunk_items
-                .iter()
-                .map(EcmascriptChunkItemOrBatchWithAsyncInfo::from_chunk_item_or_batch)
-                .try_join()
-                .await?,
+            chunk_items: sorted_items,
             batch_groups: batch_groups
                 .into_iter()
                 .map(|batch_group| {
diff --git a/turbopack/crates/turbopack-ecmascript/src/chunk/item.rs b/turbopack/crates/turbopack-ecmascript/src/chunk/item.rs
index 4dec163fcf71..88598a040d45 100644
--- a/turbopack/crates/turbopack-ecmascript/src/chunk/item.rs
+++ b/turbopack/crates/turbopack-ecmascript/src/chunk/item.rs
@@ -131,9 +131,9 @@ impl EcmascriptChunkItemContent {
             writeln!(code, "{}, ", StringifyJs(&additional_id))?;
         }
         if self.options.module_and_exports {
-            code += "((__turbopack_context__, module, exports) => {\n";
+            code += "(function(__turbopack_context__, module, exports) {\n";
         } else {
-            code += "((__turbopack_context__) => {\n";
+            code += "(function(__turbopack_context__) {\n";
         }
         if self.options.strict {
             code += "\"use strict\";\n\n";
diff --git a/turbopack/crates/turbopack-ecmascript/src/lib.rs b/turbopack/crates/turbopack-ecmascript/src/lib.rs
index a3402b6b9490..ecc6122ce471 100644
--- a/turbopack/crates/turbopack-ecmascript/src/lib.rs
+++ b/turbopack/crates/turbopack-ecmascript/src/lib.rs
@@ -1135,8 +1135,14 @@ impl EcmascriptModuleContent {
                 .try_join()
                 .await?;
 
-            let (merged_ast, comments, source_maps, original_source_maps, lookup_table) =
-                merge_modules(contents, &entry_points, &globals_merged).await?;
+            let (
+                merged_ast,
+                comments,
+                source_maps,
+                original_source_maps,
+                lookup_table,
+                fallback_import_idents,
+            ) = merge_modules(contents, &entry_points, &globals_merged).await?;
 
             // Use the options from an arbitrary module, since they should all be the same with
             // regards to minify_type and chunking_context.
@@ -1165,22 +1171,35 @@ impl EcmascriptModuleContent {
             };
 
             let first_entry = entry_points.first().unwrap().0;
-            let additional_ids = modules
-                .keys()
-                // Additionally set this module factory for all modules that are exposed. The whole
-                // group might be imported via a different entry import in different chunks (we only
-                // ensure that the modules are in the same order, not that they form a subgraph that
-                // is always imported from the same root module).
-                //
-                // Also skip the first entry, which is the name of the chunk item.
-                .filter(|m| {
-                    **m != first_entry
-                        && *modules.get(*m).unwrap() == MergeableModuleExposure::External
+            let module_ids = modules
+                .iter()
+                .map(async |(module, exposure)| {
+                    Ok((
+                        *module,
+                        *exposure,
+                        module.chunk_item_id(*options.chunking_context).await?,
+                    ))
                 })
-                .map(|m| m.chunk_item_id(*options.chunking_context))
                 .try_join()
-                .await?
-                .into();
+                .await?;
+            let additional_ids = module_ids
+                .into_iter()
+                .filter_map(|(module, exposure, module_id)| {
+                    if module == first_entry {
+                        return None;
+                    }
+                    let fallback_ident: Atom =
+                        crate::magic_identifier::mangle(&format!("imported module {module_id}"))
+                            .into();
+                    if exposure == MergeableModuleExposure::External
+                        || fallback_import_idents.contains(&fallback_ident)
+                    {
+                        Some(module_id)
+                    } else {
+                        None
+                    }
+                })
+                .collect::<SmallVec<[ModuleId; 1]>>();
 
             emit_content(content, additional_ids)
                 .instrument(tracing::info_span!("emit code"))
@@ -1214,6 +1233,7 @@ async fn merge_modules(
     Vec<CodeGenResultSourceMap>,
     SmallVec<[ResolvedVc<Box<dyn GenerateSourceMap>>; 1]>,
     Arc<Mutex<Vec<ModulePosition>>>,
+    FxHashSet<Atom>,
 )> {
     struct SetSyntaxContextVisitor<'a> {
         modules_header_width: u32,
@@ -1513,10 +1533,12 @@ async fn merge_modules(
         merged_ast.visit_mut_with(&mut swc_core::ecma::transforms::base::hygiene::hygiene());
         drop(span);
 
-        Ok((merged_ast, inserted))
+        let fallback_import_idents = inserted_imports.keys().cloned().collect();
+
+        Ok((merged_ast, inserted, fallback_import_idents))
     });
 
-    let (merged_ast, inserted) = match result {
+    let (merged_ast, inserted, fallback_import_idents) = match result {
         Ok(v) => v,
         Err((content_idx, err)) => {
             return Err(
@@ -1563,6 +1585,7 @@ async fn merge_modules(
         source_maps,
         original_source_maps,
         Arc::new(Mutex::new(lookup_table)),
+        fallback_import_idents,
     ))
 }
 
diff --git a/turbopack/crates/turbopack-ecmascript/src/manifest/loader_module.rs b/turbopack/crates/turbopack-ecmascript/src/manifest/loader_module.rs
index a3b59102dc41..23bf003d104f 100644
--- a/turbopack/crates/turbopack-ecmascript/src/manifest/loader_module.rs
+++ b/turbopack/crates/turbopack-ecmascript/src/manifest/loader_module.rs
@@ -157,12 +157,12 @@ impl EcmascriptChunkPlaceable for ManifestLoaderModule {
         writedoc!(
             code,
             r#"
-                {TURBOPACK_EXPORT_VALUE}((parentImport) => {{
-                    return Promise.all({chunks_server_data}.map((chunk) => {TURBOPACK_LOAD}(chunk))).then(() => {{
+                {TURBOPACK_EXPORT_VALUE}(function(parentImport) {{
+                    return Promise.all({chunks_server_data}.map(function(chunk) {{ return {TURBOPACK_LOAD}(chunk); }})).then(function() {{
                         return {TURBOPACK_REQUIRE}({item_id});
-                    }}).then((chunks) => {{
-                        return Promise.all(chunks.map((chunk) => {TURBOPACK_LOAD}(chunk)));
-                    }}).then(() => {{
+                    }}).then(function(chunks) {{
+                        return Promise.all(chunks.map(function(chunk) {{ return {TURBOPACK_LOAD}(chunk); }}));
+                    }}).then(function() {{
                         return parentImport({dynamic_id});
                     }});
                 }});
diff --git a/turbopack/crates/turbopack-ecmascript/src/references/esm/base.rs b/turbopack/crates/turbopack-ecmascript/src/references/esm/base.rs
index 8652f005ed61..4399c5845607 100644
--- a/turbopack/crates/turbopack-ecmascript/src/references/esm/base.rs
+++ b/turbopack/crates/turbopack-ecmascript/src/references/esm/base.rs
@@ -794,7 +794,7 @@ pub struct InvalidExport {
 #[turbo_tasks::value_impl]
 impl Issue for InvalidExport {
     fn severity(&self) -> IssueSeverity {
-        IssueSeverity::Error
+        IssueSeverity::Warning
     }
 
     #[turbo_tasks::function]
diff --git a/turbopack/crates/turbopack-ecmascript/src/references/esm/module_item.rs b/turbopack/crates/turbopack-ecmascript/src/references/esm/module_item.rs
index 977eca1fa716..537701231750 100644
--- a/turbopack/crates/turbopack-ecmascript/src/references/esm/module_item.rs
+++ b/turbopack/crates/turbopack-ecmascript/src/references/esm/module_item.rs
@@ -46,7 +46,7 @@ impl EsmModuleItem {
                 if let ModuleItem::ModuleDecl(module_decl) = item {
                     match module_decl {
                         ModuleDecl::ExportDefaultExpr(ExportDefaultExpr { box expr, .. }) => {
-                            let stmt = quote!("const $name = $expr;" as Stmt,
+                            let stmt = quote!("var $name = $expr;" as Stmt,
                                 name = Ident::new(magic_identifier::mangle("default export").into(), DUMMY_SP, Default::default()),
                                 expr: Expr = expr
                             );
diff --git a/turbopack/crates/turbopack-ecmascript/src/references/external_module.rs b/turbopack/crates/turbopack-ecmascript/src/references/external_module.rs
index cc58c20e680f..0e66fc30a7eb 100644
--- a/turbopack/crates/turbopack-ecmascript/src/references/external_module.rs
+++ b/turbopack/crates/turbopack-ecmascript/src/references/external_module.rs
@@ -36,7 +36,7 @@ use crate::{
     references::async_module::{AsyncModule, OptionAsyncModule},
     runtime_functions::{
         TURBOPACK_EXPORT_NAMESPACE, TURBOPACK_EXPORT_VALUE, TURBOPACK_EXTERNAL_IMPORT,
-        TURBOPACK_EXTERNAL_REQUIRE, TURBOPACK_LOAD_BY_URL,
+        TURBOPACK_EXTERNAL_REQUIRE, TURBOPACK_LOAD_SCRIPT,
     },
     utils::StringifyJs,
 };
@@ -50,6 +50,7 @@ pub enum CachedExternalType {
     EcmaScriptViaImport,
     Global,
     Script,
+    Umd,
 }
 
 #[derive(
@@ -72,6 +73,7 @@ impl Display for CachedExternalType {
             CachedExternalType::EcmaScriptViaImport => write!(f, "esm_import"),
             CachedExternalType::Global => write!(f, "global"),
             CachedExternalType::Script => write!(f, "script"),
+            CachedExternalType::Umd => write!(f, "umd"),
         }
     }
 }
@@ -167,6 +169,16 @@ impl CachedExternalModule {
             CachedExternalType::Global => {
                 if self.request.is_empty() {
                     writeln!(code, "const mod = {{}};")?;
+                } else if self.request.contains(' ') {
+                    // Handle requests with '/' by splitting into nested global access
+                    let global_access = self
+                        .request
+                        .split(' ')
+                        .fold("globalThis".to_string(), |acc, part| {
+                            format!("{}[{}]", acc, StringifyJs(part))
+                        });
+
+                    writeln!(code, "const mod = {global_access};")?;
                 } else {
                     writeln!(
                         code,
@@ -175,6 +187,22 @@ impl CachedExternalModule {
                     )?;
                 }
             }
+            CachedExternalType::Umd => {
+                // request format is: "root React commonjs react"
+                let parts = self.request.split(' ').collect::<Vec<_>>();
+                let global_name = parts[1];
+                let module_name = parts[3];
+
+                writeln!(
+                    code,
+                    "let mod; if (typeof exports === 'object' && typeof module === 'object') {{ \
+                     mod = {TURBOPACK_EXTERNAL_REQUIRE}({}, () => require({})); }} else {{ mod = \
+                     globalThis[{}] }}",
+                    StringifyJs(module_name),
+                    StringifyJs(module_name),
+                    StringifyJs(global_name),
+                )?;
+            }
             CachedExternalType::Script => {
                 // Parse the request format: "variableName@url"
                 // e.g., "foo@https://test.test.com"
@@ -182,42 +210,54 @@ impl CachedExternalModule {
                     let variable_name = &self.request[..at_index];
                     let url = &self.request[at_index + 1..];
 
-                    // Wrap the loading and variable access in a try-catch block
-                    writeln!(code, "let mod;")?;
-                    writeln!(code, "try {{")?;
+                    // Similar to webpack's approach: wrap in a promise that checks variable before
+                    // and after loading
+                    writeln!(code, "const mod = await (async () => {{")?;
+
+                    // First check if variable already exists (avoid redundant loading)
+                    writeln!(
+                        code,
+                        "  if (typeof globalThis[{}] !== 'undefined') {{",
+                        StringifyJs(variable_name)
+                    )?;
+                    writeln!(
+                        code,
+                        "    return globalThis[{}];",
+                        StringifyJs(variable_name)
+                    )?;
+                    writeln!(code, "  }}")?;
 
-                    // First load the URL
+                    // Load the script if variable doesn't exist
                     writeln!(
                         code,
-                        "  await {TURBOPACK_LOAD_BY_URL}({});",
+                        "  await {TURBOPACK_LOAD_SCRIPT}({});",
                         StringifyJs(url)
                     )?;
 
-                    // Then get the variable from global with existence check
+                    // After loading, check again if the variable is available
                     writeln!(
                         code,
-                        "  if (typeof global[{}] === 'undefined') {{",
+                        "  if (typeof globalThis[{}] !== 'undefined') {{",
                         StringifyJs(variable_name)
                     )?;
                     writeln!(
                         code,
-                        "    throw new Error('Variable {} is not available on global object after \
-                         loading {}');",
-                        StringifyJs(variable_name),
-                        StringifyJs(url)
+                        "    return globalThis[{}];",
+                        StringifyJs(variable_name)
                     )?;
                     writeln!(code, "  }}")?;
-                    writeln!(code, "  mod = global[{}];", StringifyJs(variable_name))?;
 
-                    // Catch and re-throw errors with more context
-                    writeln!(code, "}} catch (error) {{")?;
+                    // Variable not found after loading - throw error
                     writeln!(
                         code,
-                        "  throw new Error('Failed to load external URL module {}: ' + \
-                         (error.message || error));",
-                        StringifyJs(&self.request)
+                        "  const error = new Error('Loading script failed.\\n(missing: {})');",
+                        StringifyJs(url)
                     )?;
-                    writeln!(code, "}}")?;
+                    writeln!(code, "  error.name = 'ScriptExternalLoadError';")?;
+                    writeln!(code, "  error.type = 'missing';")?;
+                    writeln!(code, "  error.request = {};", StringifyJs(url))?;
+                    writeln!(code, "  throw error;")?;
+                    writeln!(code, "}})();")?;
                 } else {
                     // Invalid format - throw error
                     writeln!(
@@ -264,7 +304,16 @@ fn externals_fs_root() -> Vc<FileSystemPath> {
 impl Module for CachedExternalModule {
     #[turbo_tasks::function]
     async fn ident(&self) -> Result<Vc<AssetIdent>> {
-        let mut ident = AssetIdent::from_path(externals_fs_root().await?.join(&self.request)?)
+        // For script externals, simplify the path by using variable name
+        // instead of the full url to avoid long filenames
+        let path_str = if self.external_type == CachedExternalType::Script
+            && let Some(at_index) = self.request.rfind('@').filter(|&i| i > 0)
+        {
+            self.request[..at_index].to_string()
+        } else {
+            self.request.to_string()
+        };
+        let mut ident = AssetIdent::from_path(externals_fs_root().await?.join(&path_str)?)
             .with_layer(Layer::new(rcstr!("external")))
             .with_modifier(self.request.clone())
             .with_modifier(self.external_type.to_string().into());
@@ -308,7 +357,9 @@ impl Module for CachedExternalModule {
                         )
                         .await?
                     }
-                    CachedExternalType::Global | CachedExternalType::Script => {
+                    CachedExternalType::Global
+                    | CachedExternalType::Script
+                    | CachedExternalType::Umd => {
                         origin
                             .resolve_asset(
                                 Request::parse_string(self.request.clone()),
diff --git a/turbopack/crates/turbopack-ecmascript/src/references/mod.rs b/turbopack/crates/turbopack-ecmascript/src/references/mod.rs
index c7fad2ed098e..c665f6317d21 100644
--- a/turbopack/crates/turbopack-ecmascript/src/references/mod.rs
+++ b/turbopack/crates/turbopack-ecmascript/src/references/mod.rs
@@ -1446,15 +1446,31 @@ async fn analyze_ecmascript_module_internal(
                     }
 
                     // FreeVar("require") might be turbopackIgnore-d
-                    if !analysis_state
+                    let linked_value = analysis_state
                         .link_value(
                             JsValue::FreeVar(var.clone()),
                             eval_context.imports.get_attributes(span),
                         )
-                        .await?
-                        .is_unknown()
-                    {
-                        // Call handle free var
+                        .await?;
+
+                    // Call handle_free_var if the value is not unknown, or if it might be in
+                    // free_var_references (e.g., when Object is too large and
+                    // gets converted to Unknown in link_value, but we still
+                    // need to add code generation via ConstantValueCodeGen)
+                    let might_be_in_free_var_references = {
+                        let free_var_js = JsValue::FreeVar(var.clone());
+                        if let Some((name, _)) = free_var_js.get_definable_name(None) {
+                            analysis_state
+                                .compile_time_info_ref
+                                .free_var_references
+                                .get(&name)
+                                .await?
+                                .is_some()
+                        } else {
+                            false
+                        }
+                    };
+                    if !linked_value.is_unknown() || might_be_in_free_var_references {
                         handle_free_var(
                             &ast_path,
                             JsValue::FreeVar(var),
diff --git a/turbopack/crates/turbopack-ecmascript/src/references/pattern_mapping.rs b/turbopack/crates/turbopack-ecmascript/src/references/pattern_mapping.rs
index 402fa77c018f..939f3c3a231a 100644
--- a/turbopack/crates/turbopack-ecmascript/src/references/pattern_mapping.rs
+++ b/turbopack/crates/turbopack-ecmascript/src/references/pattern_mapping.rs
@@ -28,6 +28,7 @@ use turbopack_core::{
 };
 
 use crate::{
+    chunk::EcmascriptChunkPlaceable,
     references::util::{
         request_to_string, throw_module_not_found_error_expr, throw_module_not_found_expr,
         throw_module_not_found_expr_async,
@@ -356,6 +357,13 @@ async fn to_single_pattern_mapping(
         }
     };
     if let Some(chunkable) = ResolvedVc::try_downcast::<Box<dyn ChunkableModule>>(module) {
+        // Check if it's an EcmascriptChunkPlaceable
+        // Non-JS modules should be ignored as their side effects
+        // are handled through their own chunk types
+        if ResolvedVc::try_downcast::<Box<dyn EcmascriptChunkPlaceable>>(module).is_none() {
+            return Ok(SinglePatternMapping::Ignored);
+        }
+
         match resolve_type {
             ResolveType::AsyncChunkLoader => {
                 let ident = chunking_context.async_loader_chunk_item_ident(*chunkable);
diff --git a/turbopack/crates/turbopack-ecmascript/src/runtime_functions.rs b/turbopack/crates/turbopack-ecmascript/src/runtime_functions.rs
index d152bdec7389..a4c565a4a2a4 100644
--- a/turbopack/crates/turbopack-ecmascript/src/runtime_functions.rs
+++ b/turbopack/crates/turbopack-ecmascript/src/runtime_functions.rs
@@ -78,6 +78,7 @@ pub const TURBOPACK_CACHE: &TurbopackRuntimeFunctionShortcut = make_shortcut!("c
 pub const TURBOPACK_MODULES: &TurbopackRuntimeFunctionShortcut = make_shortcut!("M");
 pub const TURBOPACK_LOAD: &TurbopackRuntimeFunctionShortcut = make_shortcut!("l");
 pub const TURBOPACK_LOAD_BY_URL: &TurbopackRuntimeFunctionShortcut = make_shortcut!("L");
+pub const TURBOPACK_LOAD_SCRIPT: &TurbopackRuntimeFunctionShortcut = make_shortcut!("S");
 pub const TURBOPACK_CLEAR_CHUNK_CACHE: &TurbopackRuntimeFunctionShortcut = make_shortcut!("C");
 pub const TURBOPACK_DYNAMIC: &TurbopackRuntimeFunctionShortcut = make_shortcut!("j");
 pub const TURBOPACK_RESOLVE_ABSOLUTE_PATH: &TurbopackRuntimeFunctionShortcut = make_shortcut!("P");
@@ -93,10 +94,11 @@ pub const TURBOPACK_REQUIRE_REAL: &TurbopackRuntimeFunctionShortcut = make_short
 pub const TURBOPACK_WASM: &TurbopackRuntimeFunctionShortcut = make_shortcut!("w");
 pub const TURBOPACK_WASM_MODULE: &TurbopackRuntimeFunctionShortcut = make_shortcut!("u");
 pub const TURBOPACK_GLOBAL: &TurbopackRuntimeFunctionShortcut = make_shortcut!("g");
+pub const TURBOPACK_PUBLIC_PATH: &TurbopackRuntimeFunctionShortcut = make_shortcut!("p");
 
 /// Adding an entry to this list will automatically ensure that `__turbopack_XXX__` can be called
 /// from user code (by inserting a replacement into free_var_references)
-pub const TURBOPACK_RUNTIME_FUNCTION_SHORTCUTS: [(&str, &TurbopackRuntimeFunctionShortcut); 23] = [
+pub const TURBOPACK_RUNTIME_FUNCTION_SHORTCUTS: [(&str, &TurbopackRuntimeFunctionShortcut); 25] = [
     ("__turbopack_require__", TURBOPACK_REQUIRE),
     ("__turbopack_module_context__", TURBOPACK_MODULE_CONTEXT),
     ("__turbopack_import__", TURBOPACK_IMPORT),
@@ -107,6 +109,7 @@ pub const TURBOPACK_RUNTIME_FUNCTION_SHORTCUTS: [(&str, &TurbopackRuntimeFunctio
     ("__turbopack_modules__", TURBOPACK_MODULES),
     ("__turbopack_load__", TURBOPACK_LOAD),
     ("__turbopack_load_by_url__", TURBOPACK_LOAD_BY_URL),
+    ("__turbopack_load_script__", TURBOPACK_LOAD_SCRIPT),
     ("__turbopack_dynamic__", TURBOPACK_DYNAMIC),
     (
         "__turbopack_resolve_absolute_path__",
@@ -129,4 +132,5 @@ pub const TURBOPACK_RUNTIME_FUNCTION_SHORTCUTS: [(&str, &TurbopackRuntimeFunctio
     ),
     ("__turbopack_wasm__", TURBOPACK_WASM),
     ("__turbopack_wasm_module__", TURBOPACK_WASM_MODULE),
+    ("__turbopack_public_path__", TURBOPACK_PUBLIC_PATH),
 ];
diff --git a/turbopack/crates/turbopack-ecmascript/src/transform/mod.rs b/turbopack/crates/turbopack-ecmascript/src/transform/mod.rs
index 0f47a89fd080..a2816686b0ca 100644
--- a/turbopack/crates/turbopack-ecmascript/src/transform/mod.rs
+++ b/turbopack/crates/turbopack-ecmascript/src/transform/mod.rs
@@ -7,7 +7,7 @@ use swc_core::{
     base::SwcComments,
     common::{Mark, SourceMap, comments::Comments},
     ecma::{
-        ast::{ExprStmt, ModuleItem, Pass, Program, Stmt},
+        ast::{ClassMember, ExprStmt, ModuleItem, Pass, Program, Stmt},
         preset_env::{self, Feature, FeatureOrModule, Targets},
         transforms::{
             base::{
@@ -17,6 +17,7 @@ use swc_core::{
             react::react,
         },
         utils::IsDirective,
+        visit::{VisitMut, VisitMutWith, noop_visit_mut_type},
     },
     quote,
 };
@@ -27,6 +28,28 @@ use turbopack_core::{environment::Environment, source::Source};
 
 use crate::runtime_functions::{TURBOPACK_MODULE, TURBOPACK_REFRESH};
 
+struct StripUninitializedClassFields;
+
+impl VisitMut for StripUninitializedClassFields {
+    noop_visit_mut_type!();
+
+    fn visit_mut_class_members(&mut self, members: &mut Vec<ClassMember>) {
+        members.retain(|member| {
+            match member {
+                // Remove class properties without initializers (type-only declarations)
+                ClassMember::ClassProp(prop) => prop.value.is_some(),
+                // Remove private properties without initializers
+                ClassMember::PrivateProp(prop) => prop.value.is_some(),
+                // Keep all other members
+                _ => true,
+            }
+        });
+
+        // Continue visiting children
+        members.visit_mut_children_with(self);
+    }
+}
+
 #[turbo_tasks::value]
 #[derive(Debug, Clone, Hash)]
 pub enum EcmascriptInputTransform {
@@ -44,6 +67,7 @@ pub enum EcmascriptInputTransform {
     // it doesn't derive `Copy` so repeating values in here
     TypeScript {
         use_define_for_class_fields: bool,
+        verbatim_module_syntax: bool,
     },
     Decorators {
         is_legacy: bool,
@@ -228,29 +252,40 @@ impl EcmascriptInputTransform {
                 )
             }
             EcmascriptInputTransform::TypeScript {
-                // TODO(WEB-1213)
-                use_define_for_class_fields: _use_define_for_class_fields,
+                use_define_for_class_fields,
+                verbatim_module_syntax,
             } => {
                 use swc_core::ecma::transforms::typescript::typescript;
-                let config = Default::default();
-                apply_transform(
+                let config = swc_core::ecma::transforms::typescript::Config {
+                    verbatim_module_syntax: *verbatim_module_syntax,
+                    ..Default::default()
+                };
+                let helpers = apply_transform(
                     program,
                     helpers,
                     typescript(config, unresolved_mark, top_level_mark),
-                )
+                );
+
+                // When useDefineForClassFields is false (TypeScript legacy behavior),
+                // class field declarations without initializers should be stripped
+                // as they are type-only declarations.
+                if !use_define_for_class_fields {
+                    program.visit_mut_with(&mut StripUninitializedClassFields);
+                }
+
+                helpers
             }
             EcmascriptInputTransform::Decorators {
                 is_legacy,
                 is_ecma: _,
                 emit_decorators_metadata,
-                // TODO(WEB-1213)
-                use_define_for_class_fields: _use_define_for_class_fields,
+                use_define_for_class_fields,
             } => {
                 use swc_core::ecma::transforms::proposal::decorators::{Config, decorators};
                 let config = Config {
                     legacy: *is_legacy,
                     emit_metadata: *emit_decorators_metadata,
-                    ..Default::default()
+                    use_define_for_class_fields: *use_define_for_class_fields,
                 };
 
                 apply_transform(program, helpers, decorators(config))
diff --git a/turbopack/crates/turbopack-ecmascript/src/tree_shake/graph.rs b/turbopack/crates/turbopack-ecmascript/src/tree_shake/graph.rs
index 8f586c466041..e737abfd4b24 100644
--- a/turbopack/crates/turbopack-ecmascript/src/tree_shake/graph.rs
+++ b/turbopack/crates/turbopack-ecmascript/src/tree_shake/graph.rs
@@ -1117,7 +1117,7 @@ impl DepGraph {
                                 content: ModuleItem::Stmt(Stmt::Decl(Decl::Var(Box::new(
                                     VarDecl {
                                         span: DUMMY_SP,
-                                        kind: VarDeclKind::Const,
+                                        kind: VarDeclKind::Var,
                                         decls: vec![VarDeclarator {
                                             span: DUMMY_SP,
                                             name: default_var.clone().into(),
diff --git a/turbopack/crates/turbopack-mdx/src/lib.rs b/turbopack/crates/turbopack-mdx/src/lib.rs
index 2e9a95d105ad..6f012054ec8b 100644
--- a/turbopack/crates/turbopack-mdx/src/lib.rs
+++ b/turbopack/crates/turbopack-mdx/src/lib.rs
@@ -3,6 +3,7 @@
 #![feature(arbitrary_self_types_pointers)]
 
 use anyhow::Result;
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 use mdxjs::{MdxParseOptions, Options, compile};
 use serde::Deserialize;
 use turbo_rcstr::{RcStr, rcstr};
@@ -127,104 +128,112 @@ impl Asset for MdxTransformedAsset {
 impl MdxTransformedAsset {
     #[turbo_tasks::function]
     async fn process(&self) -> Result<Vc<MdxTransformResult>> {
-        let content = self.source.content().await?;
-        let transform_options = self.options.await?;
-
-        let AssetContent::File(file) = &*content else {
-            anyhow::bail!("Unexpected mdx asset content");
-        };
+        #[cfg(all(target_family = "wasm", target_os = "unknown"))]
+        {
+            unreachable!()
+        }
 
-        let FileContent::Content(file) = &*file.await? else {
-            anyhow::bail!("Not able to read mdx file content");
-        };
+        #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
+        {
+            let content = self.source.content().await?;
+            let transform_options = self.options.await?;
 
-        let jsx_runtime = if let Some(runtime) = &transform_options.jsx_runtime {
-            match runtime.as_str() {
-                "automatic" => Some(mdxjs::JsxRuntime::Automatic),
-                "classic" => Some(mdxjs::JsxRuntime::Classic),
-                _ => None,
-            }
-        } else {
-            None
-        };
+            let AssetContent::File(file) = &*content else {
+                anyhow::bail!("Unexpected mdx asset content");
+            };
 
-        let parse_options = match transform_options.mdx_type {
-            Some(MdxParseConstructs::Gfm) => MdxParseOptions::gfm(),
-            _ => MdxParseOptions::default(),
-        };
+            let FileContent::Content(file) = &*file.await? else {
+                anyhow::bail!("Not able to read mdx file content");
+            };
 
-        let options = Options {
-            parse: parse_options,
-            development: transform_options.development.unwrap_or(false),
-            provider_import_source: transform_options
-                .provider_import_source
-                .clone()
-                .map(RcStr::into_owned),
-            jsx: transform_options.jsx.unwrap_or(false), // true means 'preserve' jsx syntax.
-            jsx_runtime,
-            jsx_import_source: transform_options
-                .jsx_import_source
-                .clone()
-                .map(RcStr::into_owned),
-            filepath: Some(self.source.ident().path().await?.to_string()),
-            ..Default::default()
-        };
+            let jsx_runtime = if let Some(runtime) = &transform_options.jsx_runtime {
+                match runtime.as_str() {
+                    "automatic" => Some(mdxjs::JsxRuntime::Automatic),
+                    "classic" => Some(mdxjs::JsxRuntime::Classic),
+                    _ => None,
+                }
+            } else {
+                None
+            };
 
-        let result = compile(&file.content().to_str()?, &options);
+            let parse_options = match transform_options.mdx_type {
+                Some(MdxParseConstructs::Gfm) => MdxParseOptions::gfm(),
+                _ => MdxParseOptions::default(),
+            };
 
-        match result {
-            Ok(mdx_jsx_component) => Ok(MdxTransformResult {
-                content: AssetContent::file(
-                    FileContent::Content(File::from(Rope::from(mdx_jsx_component))).cell(),
-                )
-                .to_resolved()
-                .await?,
-            }
-            .cell()),
-            Err(err) => {
-                let source = match err.place {
-                    Some(p) => {
-                        let (start, end) = match *p {
-                            // markdown's positions are 1-indexed, SourcePos is 0-indexed.
-                            // Both end positions point to the first character after the range
-                            markdown::message::Place::Position(p) => (
-                                SourcePos {
-                                    line: (p.start.line - 1) as u32,
-                                    column: (p.start.column - 1) as u32,
-                                },
-                                SourcePos {
-                                    line: (p.end.line - 1) as u32,
-                                    column: (p.end.column - 1) as u32,
-                                },
-                            ),
-                            markdown::message::Place::Point(p) => {
-                                let p = SourcePos {
-                                    line: (p.line - 1) as u32,
-                                    column: (p.column - 1) as u32,
-                                };
-                                (p, p)
-                            }
-                        };
+            let options = Options {
+                parse: parse_options,
+                development: transform_options.development.unwrap_or(false),
+                provider_import_source: transform_options
+                    .provider_import_source
+                    .clone()
+                    .map(RcStr::into_owned),
+                jsx: transform_options.jsx.unwrap_or(false), // true means 'preserve' jsx syntax.
+                jsx_runtime,
+                jsx_import_source: transform_options
+                    .jsx_import_source
+                    .clone()
+                    .map(RcStr::into_owned),
+                filepath: Some(self.source.ident().path().await?.to_string()),
+                ..Default::default()
+            };
 
-                        IssueSource::from_line_col(self.source, start, end)
-                    }
-                    None => IssueSource::from_source_only(self.source),
-                };
+            let result = compile(&file.content().to_str()?, &options);
 
-                MdxIssue {
-                    source,
-                    reason: RcStr::from(err.reason),
-                    mdx_rule_id: RcStr::from(*err.rule_id),
-                    mdx_source: RcStr::from(*err.source),
+            match result {
+                Ok(mdx_jsx_component) => Ok(MdxTransformResult {
+                    content: AssetContent::file(
+                        FileContent::Content(File::from(Rope::from(mdx_jsx_component))).cell(),
+                    )
+                    .to_resolved()
+                    .await?,
                 }
-                .resolved_cell()
-                .emit();
+                .cell()),
+                Err(err) => {
+                    let source = match err.place {
+                        Some(p) => {
+                            let (start, end) = match *p {
+                                // markdown's positions are 1-indexed, SourcePos is 0-indexed.
+                                // Both end positions point to the first character after the range
+                                markdown::message::Place::Position(p) => (
+                                    SourcePos {
+                                        line: (p.start.line - 1) as u32,
+                                        column: (p.start.column - 1) as u32,
+                                    },
+                                    SourcePos {
+                                        line: (p.end.line - 1) as u32,
+                                        column: (p.end.column - 1) as u32,
+                                    },
+                                ),
+                                markdown::message::Place::Point(p) => {
+                                    let p = SourcePos {
+                                        line: (p.line - 1) as u32,
+                                        column: (p.column - 1) as u32,
+                                    };
+                                    (p, p)
+                                }
+                            };
+
+                            IssueSource::from_line_col(self.source, start, end)
+                        }
+                        None => IssueSource::from_source_only(self.source),
+                    };
 
-                Ok(MdxTransformResult {
-                    content: AssetContent::File(FileContent::NotFound.resolved_cell())
-                        .resolved_cell(),
+                    MdxIssue {
+                        source,
+                        reason: RcStr::from(err.reason),
+                        mdx_rule_id: RcStr::from(*err.rule_id),
+                        mdx_source: RcStr::from(*err.source),
+                    }
+                    .resolved_cell()
+                    .emit();
+
+                    Ok(MdxTransformResult {
+                        content: AssetContent::File(FileContent::NotFound.resolved_cell())
+                            .resolved_cell(),
+                    }
+                    .cell())
                 }
-                .cell())
             }
         }
     }
diff --git a/turbopack/crates/turbopack-node/Cargo.toml b/turbopack/crates/turbopack-node/Cargo.toml
index f8ffb02e41ed..0ddaf0af3c90 100644
--- a/turbopack/crates/turbopack-node/Cargo.toml
+++ b/turbopack/crates/turbopack-node/Cargo.toml
@@ -14,7 +14,8 @@ default = ["process_pool"]
 # enable "HMR" for embedded assets
 dynamic_embed_contents = ["turbo-tasks-fs/dynamic_embed_contents"]
 process_pool = ["tokio/full"]
-worker_pool = ["tokio/sync", "napi", "napi-derive", "turbo-rcstr/napi"]
+worker_pool      = ["tokio/sync"]
+worker_pool_napi = ["worker_pool", "napi", "napi-derive", "turbo-rcstr/napi"]
 
 [lints]
 workspace = true
@@ -26,6 +27,7 @@ async-trait = { workspace = true }
 dashmap = { workspace = true }
 base64 = "0.21.0"
 bincode = { workspace = true }
+bytes = { workspace = true }
 const_format = { workspace = true }
 either = { workspace = true, features = ["serde"] }
 futures = { workspace = true }
@@ -58,3 +60,11 @@ napi-derive = { workspace = true, optional = true }
 rustc-hash = { workspace = true }
 turbo-tasks-backend = { workspace = true }
 turbo-tasks-testing = { workspace = true }
+[target.'cfg(not(all(target_family = "wasm", target_os = "unknown")))'.dependencies]
+turbo-rcstr = { workspace = true, features= ["napi"] }
+
+
+[target.'cfg(all(target_family = "wasm", target_os = "unknown"))'.dependencies]
+wasm-bindgen = { version = "0.2.104" }
+wasm-bindgen-futures = { version = "0.4.54" }
+js-sys = { version = "0.3.78" }
diff --git a/turbopack/crates/turbopack-node/js/src/transforms/postcss.ts b/turbopack/crates/turbopack-node/js/src/transforms/postcss.ts
index 6bfbbac60b55..9579bb7b6dc8 100644
--- a/turbopack/crates/turbopack-node/js/src/transforms/postcss.ts
+++ b/turbopack/crates/turbopack-node/js/src/transforms/postcss.ts
@@ -5,6 +5,7 @@ declare const __turbopack_external_require__: (
 ) => any
 
 import type { Processor } from 'postcss'
+import { workerData } from 'worker_threads'
 
 // @ts-ignore
 import postcss from '@vercel/turbopack/postcss'
@@ -46,7 +47,11 @@ export const init = async (ipc: TransformIpc) => {
       let pluginFactory = arg
 
       if (typeof pluginFactory === 'string') {
-        pluginFactory = require(/* turbopackIgnore: true */ pluginFactory)
+        // turbopackIgnore: true does not take effects, this may be a bug
+        // use module.require to workaround
+        pluginFactory = module.require(
+          /* turbopackIgnore: true */ pluginFactory
+        )
       }
 
       if (pluginFactory.default) {
@@ -128,3 +133,17 @@ export default async function transform(
     assets,
   }
 }
+
+if (workerData && workerData.binding) {
+  // @ts-ignore
+  const { run } = require('../web_worker/evaluate')
+  run(async () => {
+    return {
+      init: async () => {
+        // @ts-ignore
+        await init()
+      },
+      default: transform,
+    }
+  })
+}
diff --git a/turbopack/crates/turbopack-node/js/src/transforms/webpack-loaders.ts b/turbopack/crates/turbopack-node/js/src/transforms/webpack-loaders.ts
index 248ff5382e61..8814968bca4e 100644
--- a/turbopack/crates/turbopack-node/js/src/transforms/webpack-loaders.ts
+++ b/turbopack/crates/turbopack-node/js/src/transforms/webpack-loaders.ts
@@ -3,7 +3,7 @@ declare const __turbopack_external_require__: {
 } & ((id: string, thunk: () => any, esm?: boolean) => any)
 
 import type { Channel as Ipc } from '../types'
-import { dirname, resolve as pathResolve, relative } from 'path'
+import { resolve as pathResolve, relative } from 'path'
 import {
   StackFrame,
   parse as parseStackTrace,
@@ -17,6 +17,7 @@ import {
 } from './transforms'
 import fs from 'fs'
 import path from 'path'
+import { workerData } from 'worker_threads'
 
 export type IpcInfoMessage =
   | {
@@ -156,7 +157,6 @@ const transform = (
 ) => {
   return new Promise((resolve, reject) => {
     const resource = pathResolve(contextDir, name)
-    const resourceDir = dirname(resource)
 
     const loadersWithOptions = loaders.map((loader) =>
       typeof loader === 'string' ? { loader, options: {} } : loader
@@ -463,9 +463,7 @@ const transform = (
         },
 
         loaders: loadersWithOptions.map((loader) => ({
-          loader: __turbopack_external_require__.resolve(loader.loader, {
-            paths: [contextDir, resourceDir],
-          }),
+          loader: __turbopack_external_require__.resolve(loader.loader),
           options: loader.options,
         })),
         readResource: (_filename, callback) => {
@@ -512,6 +510,16 @@ const transform = (
 
 export { transform as default }
 
+if (workerData && workerData.binding) {
+  // @ts-ignore
+  const { run } = require('../web_worker/evaluate')
+  run(async () => {
+    return {
+      default: transform,
+    }
+  })
+}
+
 function makeErrorEmitter(
   severity: 'warning' | 'error',
   ipc: Ipc<IpcInfoMessage, IpcRequestMessage>
diff --git a/turbopack/crates/turbopack-node/js/src/web_worker/evaluate.ts b/turbopack/crates/turbopack-node/js/src/web_worker/evaluate.ts
new file mode 100644
index 000000000000..87a1dfbd884f
--- /dev/null
+++ b/turbopack/crates/turbopack-node/js/src/web_worker/evaluate.ts
@@ -0,0 +1,116 @@
+import {
+  Binding,
+  TaskChannel,
+  TEXT_DECODER,
+  TEXT_ENCODER,
+} from '../worker_thread/taskChannel'
+import { structuredError } from '../error'
+import type { Channel } from '../types'
+import { workerData, threadId as workerId } from 'worker_threads'
+
+export type Self = DedicatedWorkerGlobalScope
+
+export declare const self: Self
+
+let binding: Binding = workerData.binding
+
+binding.workerCreated(workerId)
+
+export const run = async (
+  moduleFactory: () => Promise<{
+    init?: () => Promise<void>
+    default: (channel: Channel<any, any>, ...deserializedArgs: any[]) => any
+  }>
+) => {
+  let getValue: (channel: Channel<any, any>, ...deserializedArgs: any[]) => any
+
+  let isRunning = false
+  const queue: Array<{ taskId: number; args: string[] }> = []
+
+  const run = async (taskId: number, args: string[]) => {
+    try {
+      if (typeof getValue !== 'function') {
+        const module = await moduleFactory()
+        if (typeof module.init === 'function') {
+          await module.init()
+        }
+        getValue = module.default
+      }
+      const value = await getValue(new TaskChannel(binding, taskId), ...args)
+      await binding.sendTaskMessage({
+        taskId,
+        data: TEXT_ENCODER.encode(
+          JSON.stringify({
+            type: 'end',
+            data: value === undefined ? undefined : JSON.stringify(value),
+            duration: 0,
+          })
+        ),
+      })
+    } catch (err) {
+      await binding.sendTaskMessage({
+        taskId,
+        data: TEXT_ENCODER.encode(
+          JSON.stringify({
+            type: 'error',
+            ...structuredError(err as Error),
+          })
+        ),
+      })
+    }
+    if (queue.length > 0) {
+      const next = queue.shift()!
+      run(next.taskId, next.args)
+    } else {
+      isRunning = false
+    }
+  }
+
+  while (true) {
+    const { taskId, data: msg_buf } =
+      await binding.recvTaskMessageInWorker(workerId)
+
+    const msg = JSON.parse(TEXT_DECODER.decode(msg_buf)) as
+      | {
+          type: 'evaluate'
+          args: string[]
+        }
+      | {
+          type: 'result'
+          id: number
+          error?: string
+          data?: any
+        }
+
+    switch (msg.type) {
+      case 'evaluate': {
+        if (!isRunning) {
+          isRunning = true
+          run(taskId, msg.args)
+        } else {
+          queue.push({ taskId, args: msg.args })
+        }
+        break
+      }
+      case 'result': {
+        const request = TaskChannel.requests.get(msg.id)
+        if (request) {
+          TaskChannel.requests.delete(msg.id)
+          if (msg.error) {
+            // Need to reject at next macro task queue, because some rejection callbacks is not registered when executing to here,
+            // that will cause the error be propergated to schedule thread, then causing panic.
+            // The situation always happen when using sass-loader, it will try to resolve many possible dependencies,
+            // some of then will got a failure.
+            setTimeout(() => request.reject(new Error(msg.error)), 0)
+          } else {
+            request.resolve(msg.data)
+          }
+        }
+        break
+      }
+      default: {
+        console.error('unexpected message type', (msg as any).type)
+      }
+    }
+  }
+}
diff --git a/turbopack/crates/turbopack-node/js/src/web_worker/globals.ts b/turbopack/crates/turbopack-node/js/src/web_worker/globals.ts
new file mode 100644
index 000000000000..4bafe7fae58c
--- /dev/null
+++ b/turbopack/crates/turbopack-node/js/src/web_worker/globals.ts
@@ -0,0 +1,9 @@
+// Web worker globals - no Node.js worker_threads available
+// @ts-ignore
+if (typeof globalThis.process === 'undefined') {
+  // @ts-ignore
+  globalThis.process = {} as any
+}
+
+// @ts-ignore
+process.turbopack = {}
diff --git a/turbopack/crates/turbopack-node/js/src/web_worker/transforms.ts b/turbopack/crates/turbopack-node/js/src/web_worker/transforms.ts
new file mode 100644
index 000000000000..bebdc423c259
--- /dev/null
+++ b/turbopack/crates/turbopack-node/js/src/web_worker/transforms.ts
@@ -0,0 +1 @@
+export * from '../transforms/transforms'
diff --git a/turbopack/crates/turbopack-node/js/tsconfig.json b/turbopack/crates/turbopack-node/js/tsconfig.json
index 4c88e2f5ef17..4f3a88d5d804 100644
--- a/turbopack/crates/turbopack-node/js/tsconfig.json
+++ b/turbopack/crates/turbopack-node/js/tsconfig.json
@@ -14,7 +14,7 @@
     "checkJs": false,
 
     // environment
-    "lib": ["ESNext"],
+    "lib": ["ESNext", "WebWorker"],
     "target": "esnext",
 
     // modules
diff --git a/turbopack/crates/turbopack-node/src/available_parallelism.rs b/turbopack/crates/turbopack-node/src/available_parallelism.rs
new file mode 100644
index 000000000000..2ca0b7e9231d
--- /dev/null
+++ b/turbopack/crates/turbopack-node/src/available_parallelism.rs
@@ -0,0 +1,19 @@
+#[cfg(all(target_family = "wasm", target_os = "unknown"))]
+pub fn available_parallelism() -> usize {
+    use wasm_bindgen::{JsCast, prelude::*};
+    let nav = js_sys::Reflect::get(&js_sys::global(), &JsValue::from_str("navigator"));
+    if let Ok(nav) = nav {
+        let hc = js_sys::Reflect::get(&nav, &JsValue::from_str("hardwareConcurrency"));
+        if let Ok(hc) = hc {
+            if let Some(n) = hc.as_f64() {
+                return n as usize;
+            }
+        }
+    }
+    1
+}
+
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
+pub fn available_parallelism() -> usize {
+    std::thread::available_parallelism().map_or(1, |v| v.get())
+}
diff --git a/turbopack/crates/turbopack-node/src/evaluate.rs b/turbopack/crates/turbopack-node/src/evaluate.rs
index b991e171f13f..ca1b62294862 100644
--- a/turbopack/crates/turbopack-node/src/evaluate.rs
+++ b/turbopack/crates/turbopack-node/src/evaluate.rs
@@ -5,6 +5,7 @@ use std::{
 
 use anyhow::{Result, bail};
 use bincode::{Decode, Encode};
+use bytes::Bytes;
 use futures_retry::{FutureRetry, RetryPolicy};
 use serde::{Deserialize, Serialize, de::DeserializeOwned};
 use serde_json::Value as JsonValue;
@@ -35,6 +36,10 @@ use turbopack_core::{
     virtual_source::VirtualSource,
 };
 
+#[cfg(all(feature = "process_pool", not(feature = "worker_pool")))]
+use crate::process_pool::ChildProcessPool;
+#[cfg(feature = "worker_pool")]
+use crate::worker_pool::WorkerThreadPool;
 use crate::{
     AssetsForSourceMapping,
     backend::{CreatePoolOptions, NodeBackend},
@@ -118,9 +123,9 @@ pub trait EvaluateOperation: Send + Sync {
 
 #[async_trait::async_trait]
 pub trait Operation: Send {
-    async fn recv(&mut self) -> Result<Vec<u8>>;
+    async fn recv(&mut self) -> Result<Bytes>;
 
-    async fn send(&mut self, data: Vec<u8>) -> Result<()>;
+    async fn send(&mut self, data: Bytes) -> Result<()>;
 
     async fn wait_or_kill(&mut self) -> Result<ExitStatus>;
 
@@ -371,11 +376,11 @@ pub async fn custom_evaluate(evaluate_context: impl EvaluateContext) -> Result<V
         || async {
             let mut operation = pool.operation().await?;
             operation
-                .send(serde_json::to_vec(
+                .send(Bytes::from(serde_json::to_vec(
                     &EvalJavaScriptOutgoingMessage::Evaluate {
                         args: args.iter().map(|v| &**v).collect(),
                     },
-                )?)
+                )?))
                 .await?;
             Ok(operation)
         },
@@ -564,24 +569,24 @@ async fn pull_operation<T: EvaluateContext>(
                 {
                     Ok(response) => {
                         operation
-                            .send(serde_json::to_vec(
+                            .send(Bytes::from(serde_json::to_vec(
                                 &EvalJavaScriptOutgoingMessage::Result {
                                     id,
                                     error: None,
                                     data: Some(serde_json::to_value(response)?),
                                 },
-                            )?)
+                            )?))
                             .await?;
                     }
                     Err(e) => {
                         operation
-                            .send(serde_json::to_vec(
+                            .send(Bytes::from(serde_json::to_vec(
                                 &EvalJavaScriptOutgoingMessage::Result {
                                     id,
                                     error: Some(PrettyPrintError(&e).to_string()),
                                     data: None,
                                 },
-                            )?)
+                            )?))
                             .await?;
                     }
                 }
@@ -721,3 +726,25 @@ impl Issue for EvaluationIssue {
         Vc::cell(Some(self.source))
     }
 }
+
+pub fn scale_down() {
+    #[cfg(all(feature = "process_pool", not(feature = "worker_pool")))]
+    {
+        ChildProcessPool::scale_down();
+    }
+    #[cfg(feature = "worker_pool")]
+    {
+        WorkerThreadPool::scale_down();
+    }
+}
+
+pub fn scale_zero() {
+    #[cfg(all(feature = "process_pool", not(feature = "worker_pool")))]
+    {
+        ChildProcessPool::scale_zero();
+    }
+    #[cfg(feature = "worker_pool")]
+    {
+        WorkerThreadPool::scale_zero();
+    }
+}
diff --git a/turbopack/crates/turbopack-node/src/process_pool/mod.rs b/turbopack/crates/turbopack-node/src/process_pool/mod.rs
index e3d584dffff7..af1d7d82ae04 100644
--- a/turbopack/crates/turbopack-node/src/process_pool/mod.rs
+++ b/turbopack/crates/turbopack-node/src/process_pool/mod.rs
@@ -8,6 +8,7 @@ use std::{
 };
 
 use anyhow::{Context, Result, bail};
+use bytes::Bytes;
 use futures::join;
 use once_cell::sync::Lazy;
 use owo_colors::OwoColorize;
@@ -416,7 +417,7 @@ impl NodeJsPoolProcess {
         Ok(process)
     }
 
-    async fn recv(&mut self) -> Result<Vec<u8>> {
+    async fn recv(&mut self) -> Result<Bytes> {
         let connection = &mut self.connection;
         async fn with_timeout<T, E: Into<anyhow::Error>>(
             debug: bool,
@@ -448,20 +449,19 @@ impl NodeJsPoolProcess {
             with_timeout(debug, true, connection.read_exact(&mut packet_data))
                 .await
                 .context("reading packet data")?;
-            Ok::<_, anyhow::Error>(packet_data)
+            Ok::<_, anyhow::Error>(packet_data.into())
         };
         let (result, stdout, stderr) = join!(
             recv_future,
             self.stdout_handler.handle_operation(),
             self.stderr_handler.handle_operation(),
         );
-        let result = result?;
+        let result: Bytes = result?;
         stdout.context("unable to handle stdout from the Node.js process in a structured way")?;
         stderr.context("unable to handle stderr from the Node.js process in a structured way")?;
         Ok(result)
     }
-
-    async fn send(&mut self, packet_data: Vec<u8>) -> Result<()> {
+    async fn send(&mut self, packet_data: Bytes) -> Result<()> {
         self.connection
             .write_u32(
                 packet_data
@@ -799,16 +799,16 @@ pub struct ChildProcessOperation {
 
 #[async_trait::async_trait]
 impl Operation for ChildProcessOperation {
-    async fn recv(&mut self) -> Result<Vec<u8>> {
-        let vec = self
+    async fn recv(&mut self) -> Result<Bytes> {
+        let bytes = self
             .with_process(|process| async move {
                 process.recv().await.context("failed to receive message")
             })
             .await?;
-        Ok(vec)
+        Ok(bytes)
     }
 
-    async fn send(&mut self, message: Vec<u8>) -> Result<()> {
+    async fn send(&mut self, message: Bytes) -> Result<()> {
         self.with_process(|process| async move {
             timeout(Duration::from_secs(30), process.send(message))
                 .await
diff --git a/turbopack/crates/turbopack-node/src/transforms/postcss.rs b/turbopack/crates/turbopack-node/src/transforms/postcss.rs
index d198d5d48b97..f166de35f3d3 100644
--- a/turbopack/crates/turbopack-node/src/transforms/postcss.rs
+++ b/turbopack/crates/turbopack-node/src/transforms/postcss.rs
@@ -365,6 +365,7 @@ pub(crate) async fn config_loader_source(
 
     // We don't want to bundle the config file, so we load it with `import()`.
     // Bundling would break the ability to use `require.resolve` in the config file.
+    #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
     let code = formatdoc! {
         r#"
             import {{ pathToFileURL }} from 'node:url';
@@ -382,6 +383,19 @@ pub(crate) async fn config_loader_source(
         config_path = serde_json::to_string(&config_path).expect("a string should be serializable"),
     };
 
+    #[cfg(all(target_family = "wasm", target_os = "unknown"))]
+    let code = formatdoc! {
+        r#"
+            import path from 'node:path';
+
+            const configPath = path.join(process.cwd(), {config_path});
+            const mod = module.require(configPath);
+
+            export default mod.default ?? mod;
+        "#,
+        config_path = serde_json::to_string(&config_path).expect("a string should be serializable"),
+    };
+
     Ok(Vc::upcast(VirtualSource::new(
         postcss_config_path.append("_.loader.mjs")?,
         AssetContent::file(FileContent::Content(File::from(code)).cell()),
@@ -403,12 +417,12 @@ async fn postcss_executor(
         .to_resolved()
         .await?;
 
+    let path = embed_file_path(rcstr!("transforms/postcss.ts"))
+        .owned()
+        .await?;
+
     Ok(asset_context.process(
-        Vc::upcast(FileSource::new(
-            embed_file_path(rcstr!("transforms/postcss.ts"))
-                .owned()
-                .await?,
-        )),
+        Vc::upcast(FileSource::new(path)),
         ReferenceType::Internal(ResolvedVc::cell(fxindexmap! {
             rcstr!("CONFIG") => config_asset
         })),
diff --git a/turbopack/crates/turbopack-node/src/worker_pool/mod.rs b/turbopack/crates/turbopack-node/src/worker_pool/mod.rs
index 717d89aa2bfd..62d2733d055a 100644
--- a/turbopack/crates/turbopack-node/src/worker_pool/mod.rs
+++ b/turbopack/crates/turbopack-node/src/worker_pool/mod.rs
@@ -17,21 +17,25 @@ use turbo_rcstr::{RcStr, rcstr};
 use turbo_tasks::{ResolvedVc, duration_span};
 use turbo_tasks_fs::FileSystemPath;
 
+#[cfg(all(target_family = "wasm", target_os = "unknown"))]
+use self::web_worker::create_worker;
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
+use self::worker_thread::create_worker;
 use crate::{
     AssetsForSourceMapping,
     backend::{CreatePoolFuture, CreatePoolOptions, NodeBackend},
     evaluate::{EvaluateOperation, EvaluatePool, Operation},
     pool_stats::{AcquiredPermits, PoolStatsSnapshot},
-    worker_pool::{
-        operation::{
-            PoolState, TaskChannels, WORKER_POOL_OPERATION, WorkerOperation, WorkerOptions,
-            get_pool_state,
-        },
-        worker_thread::create_worker,
+    worker_pool::operation::{
+        PoolState, TaskChannels, WORKER_POOL_OPERATION, WorkerOperation, WorkerOptions,
+        get_pool_state,
     },
 };
 
 mod operation;
+#[cfg(all(target_family = "wasm", target_os = "unknown"))]
+pub mod web_worker;
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 mod worker_thread;
 
 static OPERATION_TASK_ID: AtomicU32 = AtomicU32::new(1);
@@ -120,7 +124,11 @@ impl WorkerThreadPool {
 
         let bootup = async {
             let permit = self.bootup_semaphore.clone().acquire_owned().await;
+
             let wait_time = self.state.stats.lock().wait_time_before_bootup();
+
+            // FIXME: hanging when using wasmtimer::sleep
+            #[cfg(not(target_arch = "wasm32"))]
             sleep(wait_time).await;
             permit
         };
@@ -155,11 +163,25 @@ pub(crate) struct WorkerThreadsBackend;
 #[turbo_tasks::value_impl]
 impl NodeBackend for WorkerThreadsBackend {
     fn runtime_module_path(&self) -> RcStr {
-        rcstr!("worker_thread/evaluate.ts")
+        #[cfg(all(target_family = "wasm", target_os = "unknown"))]
+        {
+            rcstr!("web_worker/evaluate.ts")
+        }
+        #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
+        {
+            rcstr!("worker_thread/evaluate.ts")
+        }
     }
 
     fn globals_module_path(&self) -> RcStr {
-        rcstr!("worker_thread/globals.ts")
+        #[cfg(all(target_family = "wasm", target_os = "unknown"))]
+        {
+            rcstr!("web_worker/globals.ts")
+        }
+        #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
+        {
+            rcstr!("worker_thread/globals.ts")
+        }
     }
 
     fn create_pool(&self, options: CreatePoolOptions) -> CreatePoolFuture {
diff --git a/turbopack/crates/turbopack-node/src/worker_pool/operation.rs b/turbopack/crates/turbopack-node/src/worker_pool/operation.rs
index 1ff0d9bb57cf..580631cd009f 100644
--- a/turbopack/crates/turbopack-node/src/worker_pool/operation.rs
+++ b/turbopack/crates/turbopack-node/src/worker_pool/operation.rs
@@ -4,6 +4,7 @@ use std::{
 };
 
 use anyhow::{Context, Result};
+use bytes::Bytes;
 use parking_lot::Mutex;
 use rustc_hash::FxHashMap;
 use tokio::sync::{
@@ -13,10 +14,13 @@ use tokio::sync::{
 };
 use turbo_rcstr::RcStr;
 
+#[cfg(all(target_family = "wasm", target_os = "unknown"))]
+use crate::worker_pool::web_worker;
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
+use crate::worker_pool::worker_thread;
 use crate::{
     evaluate::Operation,
     pool_stats::{AcquiredPermits, NodeJsPoolStats},
-    worker_pool::worker_thread,
 };
 
 /// A bidirectional message channel using unbounded mpsc.
@@ -58,24 +62,24 @@ pub(crate) struct PoolState {
 
 #[turbo_tasks::value(cell = "new", serialization = "none", eq = "manual", shared)]
 #[derive(Clone, PartialEq, Eq, Hash)]
-pub(super) struct WorkerOptions {
-    pub(super) filename: RcStr,
-    pub(super) cwd: RcStr,
+pub struct WorkerOptions {
+    pub filename: RcStr,
+    pub cwd: RcStr,
 }
 
 // Allow dead_code for test builds where napi exports are not entry points
 #[allow(dead_code)]
 pub(super) struct TaskMessage {
     pub task_id: u32,
-    pub data: Vec<u8>,
+    pub data: Bytes,
 }
 
 #[derive(Default)]
 pub(crate) struct WorkerPoolOperation {
     #[allow(clippy::type_complexity)]
-    worker_routed_channel: Mutex<FxHashMap<u32, Arc<MessageChannel<(u32, Vec<u8>)>>>>,
+    worker_routed_channel: Mutex<FxHashMap<u32, Arc<MessageChannel<(u32, Bytes)>>>>,
     #[allow(clippy::type_complexity)]
-    task_routed_channel: Mutex<FxHashMap<u32, Arc<MessageChannel<Vec<u8>>>>>,
+    task_routed_channel: Mutex<FxHashMap<u32, Arc<MessageChannel<Bytes>>>>,
     pub(crate) pools: Mutex<FxHashMap<Arc<WorkerOptions>, Arc<PoolState>>>,
 }
 
@@ -143,7 +147,10 @@ impl WorkerPoolOperation {
         worker_id: u32,
     ) -> Result<()> {
         self.remove_worker_channel(worker_id);
+        #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
         worker_thread::terminate_worker(worker_options, worker_id);
+        #[cfg(all(target_family = "wasm", target_os = "unknown"))]
+        web_worker::terminate_worker(worker_options, worker_id);
         Ok(())
     }
 
@@ -151,10 +158,7 @@ impl WorkerPoolOperation {
         self.worker_routed_channel.lock().remove(&worker_id);
     }
 
-    pub(crate) async fn recv_task_message_in_worker(
-        &self,
-        worker_id: u32,
-    ) -> Result<(u32, Vec<u8>)> {
+    pub(crate) async fn recv_task_message_in_worker(&self, worker_id: u32) -> Result<(u32, Bytes)> {
         let channel = {
             let mut map = self.worker_routed_channel.lock();
             map.entry(worker_id)
@@ -196,9 +200,9 @@ pub(crate) async fn get_pool_state(worker_options: Arc<WorkerOptions>) -> Arc<Po
 /// Holds Arc references to avoid HashMap lookups during send/recv.
 pub(crate) struct TaskChannels {
     /// Channel for Rust -> Worker communication (task_id, data)
-    worker_channel: Arc<MessageChannel<(u32, Vec<u8>)>>,
+    worker_channel: Arc<MessageChannel<(u32, Bytes)>>,
     /// Channel for Worker -> Rust communication (data)
-    task_channel: Arc<MessageChannel<Vec<u8>>>,
+    task_channel: Arc<MessageChannel<Bytes>>,
     task_id: u32,
 }
 
@@ -228,7 +232,7 @@ impl TaskChannels {
     }
 
     /// Send message to worker (Rust -> JS Worker)
-    pub(crate) async fn send_to_worker(&self, message: Vec<u8>) -> Result<()> {
+    pub(crate) async fn send_to_worker(&self, message: Bytes) -> Result<()> {
         self.worker_channel
             .send((self.task_id, message))
             .await
@@ -236,7 +240,7 @@ impl TaskChannels {
     }
 
     /// Receive message from worker (JS Worker -> Rust)
-    pub(crate) async fn recv_from_worker(&self) -> Result<Vec<u8>> {
+    pub(crate) async fn recv_from_worker(&self) -> Result<Bytes> {
         self.task_channel
             .recv()
             .await
@@ -275,11 +279,11 @@ impl Drop for WorkerOperation {
 
 #[async_trait::async_trait]
 impl Operation for WorkerOperation {
-    async fn recv(&mut self) -> Result<Vec<u8>> {
+    async fn recv(&mut self) -> Result<Bytes> {
         self.channels.recv_from_worker().await
     }
 
-    async fn send(&mut self, message: Vec<u8>) -> Result<()> {
+    async fn send(&mut self, message: Bytes) -> Result<()> {
         self.channels.send_to_worker(message).await
     }
 
diff --git a/turbopack/crates/turbopack-node/src/worker_pool/web_worker.rs b/turbopack/crates/turbopack-node/src/worker_pool/web_worker.rs
new file mode 100644
index 000000000000..973fe947ec9e
--- /dev/null
+++ b/turbopack/crates/turbopack-node/src/worker_pool/web_worker.rs
@@ -0,0 +1,171 @@
+use std::sync::{Arc, LazyLock};
+
+use bytes::Bytes;
+use tokio::sync::{Mutex, mpsc, oneshot};
+use tracing::info;
+use wasm_bindgen::{JsCast, prelude::*};
+
+use crate::worker_pool::{
+    WorkerOptions,
+    operation::{TaskMessage, WORKER_POOL_OPERATION},
+};
+
+pub enum WorkerOperation {
+    Create(WebWorkerCreation, oneshot::Sender<u32>),
+    Terminate(WebWorkerTermination),
+}
+
+static WORKER_CHANNEL: LazyLock<(
+    mpsc::UnboundedSender<WorkerOperation>,
+    std::sync::Mutex<Option<mpsc::UnboundedReceiver<WorkerOperation>>>,
+)> = LazyLock::new(|| {
+    let (tx, rx) = mpsc::unbounded_channel();
+    (tx, std::sync::Mutex::new(Some(rx)))
+});
+
+static PENDING_CREATIONS: LazyLock<
+    std::sync::Mutex<std::collections::VecDeque<oneshot::Sender<u32>>>,
+> = LazyLock::new(|| std::sync::Mutex::new(std::collections::VecDeque::new()));
+
+pub fn worker_created(worker_id: u32) {
+    if let Some(tx) = PENDING_CREATIONS.lock().unwrap().pop_front() {
+        let _ = tx.send(worker_id);
+    }
+}
+
+pub async fn register_worker_scheduler(creator: js_sys::Function, terminator: js_sys::Function) {
+    let mut rx_opt = WORKER_CHANNEL.1.lock().unwrap();
+    let mut rx = if let Some(rx) = rx_opt.take() {
+        rx
+    } else {
+        return;
+    };
+
+    while let Some(op) = rx.recv().await {
+        match op {
+            WorkerOperation::Create(creation, tx) => {
+                PENDING_CREATIONS.lock().unwrap().push_back(tx);
+                let _ = creator.call1(&JsValue::NULL, &JsValue::from(creation));
+            }
+            WorkerOperation::Terminate(termination) => {
+                let _ = terminator.call1(&JsValue::NULL, &JsValue::from(termination));
+            }
+        }
+    }
+}
+
+#[wasm_bindgen]
+#[derive(Clone)]
+pub struct WebWorkerOptions {
+    #[wasm_bindgen(getter_with_clone)]
+    pub filename: String,
+    #[wasm_bindgen(getter_with_clone)]
+    pub cwd: String,
+}
+
+impl From<&WorkerOptions> for WebWorkerOptions {
+    fn from(options: &WorkerOptions) -> Self {
+        Self {
+            filename: options.filename.to_string(),
+            cwd: options.cwd.to_string(),
+        }
+    }
+}
+
+#[wasm_bindgen]
+pub struct WebWorkerCreation {
+    #[wasm_bindgen(getter_with_clone)]
+    pub options: WebWorkerOptions,
+}
+
+#[wasm_bindgen]
+pub struct WebWorkerTermination {
+    #[wasm_bindgen(getter_with_clone)]
+    pub options: WebWorkerOptions,
+    #[wasm_bindgen(js_name = "workerId")]
+    pub worker_id: u32,
+}
+
+pub async fn create_worker(options: Arc<WorkerOptions>) -> anyhow::Result<u32> {
+    let (tx, rx) = oneshot::channel();
+
+    let options_js = options.as_ref().into();
+
+    let creation = WebWorkerCreation {
+        options: options_js,
+    };
+
+    let sender = &WORKER_CHANNEL.0;
+
+    sender
+        .send(WorkerOperation::Create(creation, tx))
+        .map_err(|_| anyhow::anyhow!("Worker scheduler closed"))?;
+
+    let worker_id = rx.await?;
+
+    Ok(worker_id)
+}
+
+pub fn terminate_worker(options: Arc<WorkerOptions>, worker_id: u32) {
+    let options_js = options.as_ref().into();
+
+    let termination = WebWorkerTermination {
+        options: options_js,
+        worker_id,
+    };
+
+    let sender = &WORKER_CHANNEL.0;
+    let _ = sender.send(WorkerOperation::Terminate(termination));
+}
+
+#[wasm_bindgen]
+pub struct WasmTaskMessage {
+    #[wasm_bindgen(js_name = "taskId")]
+    pub task_id: u32,
+    data: js_sys::Uint8Array,
+}
+
+#[wasm_bindgen]
+impl WasmTaskMessage {
+    #[wasm_bindgen(getter)]
+    pub fn data(&self) -> js_sys::Uint8Array {
+        self.data.clone()
+    }
+}
+
+impl From<TaskMessage> for WasmTaskMessage {
+    fn from(msg: TaskMessage) -> Self {
+        Self {
+            task_id: msg.task_id,
+            data: js_sys::Uint8Array::from(&msg.data[..]),
+        }
+    }
+}
+
+#[wasm_bindgen(js_name = "recvTaskMessageInWorker")]
+pub async fn recv_task_message_in_worker(worker_id: u32) -> Result<WasmTaskMessage, JsError> {
+    let (task_id, data) = WORKER_POOL_OPERATION
+        .recv_task_message_in_worker(worker_id)
+        .await
+        .map_err(|e| JsError::new(&e.to_string()))?;
+    Ok(TaskMessage { task_id, data }.into())
+}
+
+#[wasm_bindgen(js_name = "sendTaskMessage")]
+pub async fn send_task_message(message: JsValue) -> Result<(), JsError> {
+    let task_id = js_sys::Reflect::get(&message, &"taskId".into())
+        .map_err(|_| JsError::new("Failed to get taskId"))?
+        .as_f64()
+        .ok_or_else(|| JsError::new("taskId must be a number"))? as u32;
+
+    let data_js = js_sys::Reflect::get(&message, &"data".into())
+        .map_err(|_| JsError::new("Failed to get data"))?;
+
+    let data = Bytes::from(js_sys::Uint8Array::new(&data_js).to_vec());
+
+    WORKER_POOL_OPERATION
+        .send_task_message(TaskMessage { task_id, data })
+        .await
+        .map_err(|e| JsError::new(&e.to_string()))?;
+    Ok(())
+}
diff --git a/turbopack/crates/turbopack-node/src/worker_pool/worker_thread.rs b/turbopack/crates/turbopack-node/src/worker_pool/worker_thread.rs
index 31b45a77e2f3..e51b76673618 100644
--- a/turbopack/crates/turbopack-node/src/worker_pool/worker_thread.rs
+++ b/turbopack/crates/turbopack-node/src/worker_pool/worker_thread.rs
@@ -1,5 +1,6 @@
 use std::{collections::VecDeque, sync::Arc};
 
+use bytes::Bytes;
 use napi::{
     Env,
     threadsafe_function::{ErrorStrategy, ThreadsafeFunction, ThreadsafeFunctionCallMode},
@@ -152,7 +153,7 @@ impl From<NapiTaskMessage> for TaskMessage {
         let NapiTaskMessage { task_id, data } = message;
         TaskMessage {
             task_id,
-            data: data.into(),
+            data: Bytes::from_owner(data),
         }
     }
 }
@@ -166,7 +167,7 @@ pub async fn recv_task_message_in_worker(worker_id: u32) -> napi::Result<NapiTas
         .await?;
     Ok(NapiTaskMessage {
         task_id,
-        data: message.into(),
+        data: Vec::from(message).into(),
     })
 }
 
diff --git a/turbopack/crates/turbopack-node/tests/pool.rs b/turbopack/crates/turbopack-node/tests/pool.rs
index b7f22dc6d958..d7c7d077806e 100644
--- a/turbopack/crates/turbopack-node/tests/pool.rs
+++ b/turbopack/crates/turbopack-node/tests/pool.rs
@@ -5,6 +5,7 @@
 use std::path::PathBuf;
 
 use anyhow::Result;
+use bytes::Bytes;
 use rustc_hash::FxHashMap;
 use serde::{Deserialize, Serialize};
 use turbo_rcstr::RcStr;
@@ -71,9 +72,10 @@ struct Echo {
     pid: u32,
 }
 
-/// Helper: send a message and return the echo response.
 async fn send_recv(op: &mut Box<dyn Operation>, msg: serde_json::Value) -> Echo {
-    op.send(serde_json::to_vec(&msg).unwrap()).await.unwrap();
+    op.send(Bytes::from(serde_json::to_vec(&msg).unwrap()))
+        .await
+        .unwrap();
     serde_json::from_slice(&op.recv().await.unwrap()).unwrap()
 }
 
diff --git a/turbopack/crates/turbopack-nodejs/src/chunking_context.rs b/turbopack/crates/turbopack-nodejs/src/chunking_context.rs
index 441bfadc323f..eab365db9042 100644
--- a/turbopack/crates/turbopack-nodejs/src/chunking_context.rs
+++ b/turbopack/crates/turbopack-nodejs/src/chunking_context.rs
@@ -416,10 +416,13 @@ impl ChunkingContext for NodeJsChunkingContext {
         extension: RcStr,
     ) -> Result<Vc<FileSystemPath>> {
         let root_path = self.chunk_root_path.clone();
-        let name = ident
-            .output_name(self.root_path.clone(), prefix, extension)
-            .owned()
-            .await?;
+        let mut name = ident
+            .output_name(self.root_path.clone(), prefix, extension.clone())
+            .await?
+            .to_string();
+        if !name.ends_with(extension.as_str()) {
+            name.push_str(&extension);
+        }
         Ok(root_path.join(&name)?.cell())
     }
 
diff --git a/turbopack/crates/turbopack-resolve/src/typescript.rs b/turbopack/crates/turbopack-resolve/src/typescript.rs
index d5879ba0c970..5c99f838258a 100644
--- a/turbopack/crates/turbopack-resolve/src/typescript.rs
+++ b/turbopack/crates/turbopack-resolve/src/typescript.rs
@@ -96,7 +96,7 @@ pub async fn read_tsconfigs(
                         continue;
                     } else {
                         TsConfigIssue {
-                            severity: IssueSeverity::Error,
+                            severity: IssueSeverity::Warning,
                             // TODO: this should point at the `extends` property
                             source: IssueSource::from_source_only(tsconfig),
                             message: format!("extends: \"{extends}\" doesn't resolve correctly")
diff --git a/turbopack/crates/turbopack-static/src/ecma.rs b/turbopack/crates/turbopack-static/src/ecma.rs
index d2f3bc3cc5a3..e7d0bae962ed 100644
--- a/turbopack/crates/turbopack-static/src/ecma.rs
+++ b/turbopack/crates/turbopack-static/src/ecma.rs
@@ -14,7 +14,7 @@ use turbopack_ecmascript::{
         EcmascriptChunkItemContent, EcmascriptChunkPlaceable, EcmascriptExports,
         ecmascript_chunk_item,
     },
-    runtime_functions::{TURBOPACK_EXPORT_URL, TURBOPACK_EXPORT_VALUE},
+    runtime_functions::{TURBOPACK_EXPORT_URL, TURBOPACK_EXPORT_VALUE, TURBOPACK_PUBLIC_PATH},
     utils::StringifyJs,
 };
 
@@ -101,6 +101,23 @@ impl EcmascriptChunkPlaceable for StaticUrlJsModule {
             .asset_url(static_asset.path().owned().await?, this.tag.clone())
             .await?;
 
+        /*
+         * TODO: @fireairefore
+         * remove this, switch to use AssetSuffix::FromGlobal
+         */
+        if let Some(asset_path) = url.strip_prefix("__RUNTIME_PUBLIC_PATH__") {
+            // For runtime publicPath, use the getPublicPath() runtime function
+            let code = format!(
+                "{TURBOPACK_EXPORT_VALUE}({TURBOPACK_PUBLIC_PATH}() + {path});",
+                path = StringifyJs(asset_path)
+            );
+            return Ok(EcmascriptChunkItemContent {
+                inner_code: code.into(),
+                ..Default::default()
+            }
+            .cell());
+        }
+
         let url_behavior = chunking_context.url_behavior(this.tag.clone()).await?;
 
         let inner_code = match &url_behavior.suffix {
diff --git a/turbopack/crates/turbopack-test-utils/src/snapshot.rs b/turbopack/crates/turbopack-test-utils/src/snapshot.rs
index eddb2d4dbf0a..5190b36d99e1 100644
--- a/turbopack/crates/turbopack-test-utils/src/snapshot.rs
+++ b/turbopack/crates/turbopack-test-utils/src/snapshot.rs
@@ -23,6 +23,11 @@ pub static UPDATE: Lazy<bool> = Lazy::new(|| env::var("UPDATE").unwrap_or_defaul
 
 static ANSI_REGEX: Lazy<Regex> = Lazy::new(|| Regex::new(r"\x1b\[\d+m").unwrap());
 
+// Matches characters that are not allowed or problematic in filenames
+static INVALID_FILENAME_CHARS: Lazy<Regex> = Lazy::new(|| Regex::new(r#"[/:*?"<>|'\\]+"#).unwrap());
+// Matches multiple spaces or dashes
+static MULTI_SPACE_DASH: Lazy<Regex> = Lazy::new(|| Regex::new(r"[\s-]+").unwrap());
+
 pub async fn snapshot_issues<I: IntoIterator<Item = ReadRef<PlainIssue>>>(
     captured_issues: I,
     issues_path: FileSystemPath,
@@ -31,17 +36,15 @@ pub async fn snapshot_issues<I: IntoIterator<Item = ReadRef<PlainIssue>>>(
     let expected_issues = expected(issues_path.clone()).await?;
     let mut seen = FxHashSet::default();
     for plain_issue in captured_issues.into_iter() {
-        let title = styled_string_to_file_safe_string(&plain_issue.title)
-            .replace('/', "__")
-            // We replace "*", "?", and '"' because they're not allowed in filenames on Windows.
-            .replace('*', "__star__")
-            .replace('"', "__quo__")
-            .replace('?', "__q__")
-            .replace(':', "__c__");
+        let title = styled_string_to_file_safe_string(&plain_issue.title);
+        // Replace invalid filename characters with space, then normalize spaces/dashes
+        let title = INVALID_FILENAME_CHARS.replace_all(&title, " ");
+        let title = MULTI_SPACE_DASH.replace_all(&title, "-");
+        let title = title.trim_matches('-');
         let title = if title.len() > 50 {
             &title[0..50]
         } else {
-            &title
+            title
         };
         let hash = encode_hex(plain_issue.internal_hash_ref(true));
 
@@ -212,27 +215,13 @@ async fn diff_paths(
 
 fn styled_string_to_file_safe_string(styled_string: &StyledString) -> String {
     match styled_string {
-        StyledString::Line(parts) => {
-            let mut string = String::new();
-            string += "__l_";
-            for part in parts {
-                string.push_str(&styled_string_to_file_safe_string(part));
-            }
-            string += "__";
-            string
-        }
-        StyledString::Stack(parts) => {
-            let mut string = String::new();
-            string += "__s_";
-            for part in parts {
-                string.push_str(&styled_string_to_file_safe_string(part));
-                string.push('_');
-            }
-            string += "__";
-            string
+        StyledString::Line(parts) | StyledString::Stack(parts) => parts
+            .iter()
+            .map(styled_string_to_file_safe_string)
+            .collect::<Vec<_>>()
+            .join(" "),
+        StyledString::Text(string) | StyledString::Code(string) | StyledString::Strong(string) => {
+            string.to_string()
         }
-        StyledString::Text(string) => string.to_string(),
-        StyledString::Code(string) => format!("__c_{string}__"),
-        StyledString::Strong(string) => format!("__{string}__"),
     }
 }
diff --git a/turbopack/crates/turbopack/Cargo.toml b/turbopack/crates/turbopack/Cargo.toml
index fc929dcda7e1..f8afed2bfc6d 100644
--- a/turbopack/crates/turbopack/Cargo.toml
+++ b/turbopack/crates/turbopack/Cargo.toml
@@ -21,7 +21,6 @@ rustc-hash = { workspace = true }
 smallvec = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
-tokio = { workspace = true }
 tracing = { workspace = true }
 
 turbo-rcstr = { workspace = true }
@@ -38,6 +37,8 @@ turbopack-mdx = { workspace = true }
 turbopack-node = { workspace = true, default-features = false }
 turbopack-resolve = { workspace = true }
 turbopack-static = { workspace = true }
+
+[target.'cfg(not(all(target_family = "wasm", target_os = "unknown")))'.dependencies]
 turbopack-wasm = { workspace = true }
 
 [dev-dependencies]
diff --git a/turbopack/crates/turbopack/src/evaluate_context.rs b/turbopack/crates/turbopack/src/evaluate_context.rs
index 1d1d2c58e32d..d5a353b37bf3 100644
--- a/turbopack/crates/turbopack/src/evaluate_context.rs
+++ b/turbopack/crates/turbopack/src/evaluate_context.rs
@@ -73,7 +73,7 @@ pub async fn node_evaluate_asset_context(
                 .await?,
         ),
         enable_node_externals: true,
-        enable_node_native_modules: true,
+        enable_node_native_modules: !cfg!(all(target_family = "wasm", target_os = "unknown")),
         custom_conditions: vec![node_env.clone(), rcstr!("node")],
         ..Default::default()
     };
diff --git a/turbopack/crates/turbopack/src/lib.rs b/turbopack/crates/turbopack/src/lib.rs
index 27e763670b56..d853ec439249 100644
--- a/turbopack/crates/turbopack/src/lib.rs
+++ b/turbopack/crates/turbopack/src/lib.rs
@@ -66,6 +66,7 @@ use turbopack_resolve::{
     typescript::type_resolve,
 };
 use turbopack_static::{css::StaticUrlCssModule, ecma::StaticUrlJsModule};
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 use turbopack_wasm::{module_asset::WebAssemblyModuleAsset, source::WebAssemblySource};
 
 use crate::{
@@ -268,6 +269,7 @@ async fn apply_module_type(
                 .to_resolved()
                 .await?,
         ),
+        #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
         ModuleType::WebAssembly { source_ty } => ResolvedVc::upcast(
             WebAssemblyModuleAsset::new(
                 WebAssemblySource::new(*source, *source_ty),
@@ -1238,6 +1240,7 @@ pub async fn replace_external(
         }
         ExternalType::Global => CachedExternalType::Global,
         ExternalType::Script => CachedExternalType::Script,
+        ExternalType::Umd => CachedExternalType::Umd,
         ExternalType::Url => {
             // we don't want to wrap url externals.
             return Ok(None);
diff --git a/turbopack/crates/turbopack/src/module_options/mod.rs b/turbopack/crates/turbopack/src/module_options/mod.rs
index cae949e3dae7..255784d42bab 100644
--- a/turbopack/crates/turbopack/src/module_options/mod.rs
+++ b/turbopack/crates/turbopack/src/module_options/mod.rs
@@ -36,6 +36,7 @@ use turbopack_node::{
     transforms::{postcss::PostCssTransform, webpack::WebpackLoaders},
 };
 use turbopack_resolve::resolve_options_context::ResolveOptionsContext;
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 use turbopack_wasm::source::WebAssemblySourceType;
 
 use crate::evaluate_context::{config_tracing_module_context, node_evaluate_asset_context};
@@ -653,6 +654,7 @@ impl ModuleOptions {
                 vec![ModuleRuleEffect::ModuleType(ModuleType::NodeAddon)],
             ),
             // WebAssembly
+            #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
             ModuleRule::new(
                 RuleCondition::any(vec![
                     RuleCondition::ResourcePathEndsWith(".wasm".to_string()),
@@ -662,6 +664,7 @@ impl ModuleOptions {
                     source_ty: WebAssemblySourceType::Binary,
                 })],
             ),
+            #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
             ModuleRule::new(
                 RuleCondition::any(vec![RuleCondition::ResourcePathEndsWith(
                     ".wat".to_string(),
@@ -705,12 +708,14 @@ impl ModuleOptions {
         ]);
 
         if let Some(options) = enable_typescript_transform {
+            let options = options.await?;
             let ts_preprocess = ResolvedVc::cell(
                 decorators_transform
                     .clone()
                     .into_iter()
                     .chain(std::iter::once(EcmascriptInputTransform::TypeScript {
-                        use_define_for_class_fields: options.await?.use_define_for_class_fields,
+                        use_define_for_class_fields: options.use_define_for_class_fields,
+                        verbatim_module_syntax: options.verbatim_module_syntax,
                     }))
                     .collect(),
             );
@@ -854,8 +859,8 @@ impl ModuleOptions {
                                     *execution_context,
                                     Some(import_map),
                                     None,
-                                    Layer::new(rcstr!("postcss")),
-                                    true,
+                                    Layer::new(rcstr!("webpack_loaders")),
+                                    cfg!(all(target_family = "wasm", target_os = "unknown")),
                                 ),
                                 config_tracing_module_context(*execution_context),
                                 *execution_context,
diff --git a/turbopack/crates/turbopack/src/module_options/module_options_context.rs b/turbopack/crates/turbopack/src/module_options/module_options_context.rs
index 3d4db9d93a58..b7915216040e 100644
--- a/turbopack/crates/turbopack/src/module_options/module_options_context.rs
+++ b/turbopack/crates/turbopack/src/module_options/module_options_context.rs
@@ -165,6 +165,7 @@ impl ValueDefault for DecoratorsOptions {
 #[derive(Default, Clone, Debug)]
 pub struct TypescriptTransformOptions {
     pub use_define_for_class_fields: bool,
+    pub verbatim_module_syntax: bool,
 }
 
 #[turbo_tasks::value_impl]
diff --git a/turbopack/crates/turbopack/src/module_options/module_rule.rs b/turbopack/crates/turbopack/src/module_options/module_rule.rs
index 7b3073419506..443f3bd77ad0 100644
--- a/turbopack/crates/turbopack/src/module_options/module_rule.rs
+++ b/turbopack/crates/turbopack/src/module_options/module_rule.rs
@@ -14,6 +14,7 @@ use turbopack_ecmascript::{
     EcmascriptInputTransforms, EcmascriptOptions, bytes_source_transform::BytesSourceTransform,
     json_source_transform::JsonSourceTransform,
 };
+#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 use turbopack_wasm::source::WebAssemblySourceType;
 
 use crate::module_options::{CustomModuleType, RuleCondition, match_mode::MatchMode};
@@ -151,6 +152,7 @@ pub enum ModuleType {
         /// The tag that is passed to ChunkingContext::asset_url
         tag: Option<RcStr>,
     },
+    #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
     WebAssembly {
         source_ty: WebAssemblySourceType,
     },
@@ -170,6 +172,7 @@ impl Display for ModuleType {
             ModuleType::Css { .. } => write!(f, "Css"),
             ModuleType::StaticUrlJs { .. } => write!(f, "StaticUrlJs"),
             ModuleType::StaticUrlCss { .. } => write!(f, "StaticUrlCss"),
+            #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
             ModuleType::WebAssembly { .. } => write!(f, "WebAssembly"),
             ModuleType::Custom(_) => write!(f, "Custom"),
         }
@@ -272,9 +275,17 @@ impl ConfiguredModuleType {
                     JsonSourceTransform::new_cjs().to_resolved().await?,
                 )]))
             }
+            #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
             ConfiguredModuleType::Wasm => ModuleRuleEffect::ModuleType(ModuleType::WebAssembly {
                 source_ty: WebAssemblySourceType::Binary,
             }),
+            #[cfg(all(target_family = "wasm", target_os = "unknown"))]
+            ConfiguredModuleType::Wasm => {
+                bail!(
+                    "WebAssembly module type is not supported when the bundler itself runs in a \
+                     WASM environment"
+                )
+            }
             ConfiguredModuleType::Raw => ModuleRuleEffect::ModuleType(ModuleType::Raw),
             ConfiguredModuleType::Node => ModuleRuleEffect::ModuleType(ModuleType::NodeAddon),
         })