diff --git a/.github/workflows/build_and_deploy.yml b/.github/workflows/build_and_deploy.yml
index b7d1d535158..9a0e68f0920 100644
--- a/.github/workflows/build_and_deploy.yml
+++ b/.github/workflows/build_and_deploy.yml
@@ -183,13 +183,10 @@ jobs:
             build_task: build-native-release
             os:
               mac:
+                host: "['macos-15']"
                 vendor: apple
                 sys: darwin
-                arch:
-                  x86_64:
-                    host: "['macos-15-intel']"
-                  aarch64:
-                    host: "['macos-15']"
+                arch: [x86_64, aarch64]
               windows:
                 host: "['windows-latest-8-core-oss']"
                 vendor: pc
@@ -226,7 +223,7 @@ jobs:
 
     name: stable - ${{ matrix.target }} - node@20
     runs-on: ${{ fromJSON(matrix.host) }}
-    timeout-minutes: ${{ matrix.os == 'mac' && 90 || 45 }}
+    timeout-minutes: 45
     env:
       # Disable all build caches for production/staging/force-preview deploys
       NEXT_SKIP_BUILD_CACHE: ${{ contains(fromJSON('["production","staging","force-preview"]'), needs.deploy-target.outputs.value) && '1' || '' }}
diff --git a/.github/workflows/build_and_test.yml b/.github/workflows/build_and_test.yml
index ef7a99dcbf1..2d9047e437d 100644
--- a/.github/workflows/build_and_test.yml
+++ b/.github/workflows/build_and_test.yml
@@ -238,6 +238,7 @@ jobs:
       needsRust: 'yes'
       needsNextest: 'yes'
       skipNativeBuild: 'yes'
+      skipInstallBuild: 'yes'
       afterBuild: pnpm dlx turbo@${TURBO_VERSION} run test-cargo-unit ${TURBO_ARGS}
       stepName: 'test-cargo-unit'
     secrets: inherit
diff --git a/.github/workflows/build_reusable.yml b/.github/workflows/build_reusable.yml
index bbd669af0d1..082150a3268 100644
--- a/.github/workflows/build_reusable.yml
+++ b/.github/workflows/build_reusable.yml
@@ -309,7 +309,7 @@ jobs:
         if: ${{ inputs.skipInstallBuild != 'yes' }}
 
       - run: pnpm install
-        if: ${{ inputs.skipInstallBuild != 'yes' }}
+        if: ${{ inputs.skipInstallBuild != 'yes' || inputs.needsNextest == 'yes' }}
 
       - name: Install node-file-trace test dependencies
         if: ${{ inputs.needsNextest == 'yes' }}
diff --git a/Cargo.lock b/Cargo.lock
index d125d53dbd5..47f06d42eaf 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2007,19 +2007,20 @@ dependencies = [
 
 [[package]]
 name = "ctor"
-version = "0.8.0"
+version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "352d39c2f7bef1d6ad73db6f5160efcaed66d94ef8c6c573a8410c00bf909a98"
+checksum = "83cf0d42651b16c6dfe68685716d18480d18a9c39c62d76e8cf3eb6ed5d8bcbf"
 dependencies = [
  "ctor-proc-macro",
  "dtor",
+ "link-section",
 ]
 
 [[package]]
 name = "ctor-proc-macro"
-version = "0.0.7"
+version = "0.0.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52560adf09603e58c9a7ee1fe1dcb95a16927b17c127f0ac02d6e768a0e25bc1"
+checksum = "7a949c44fcacbbbb7ada007dc7acb34603dd97cd47de5d054f2b6493ecebb483"
 
 [[package]]
 name = "ctrlc"
@@ -2398,18 +2399,18 @@ dependencies = [
 
 [[package]]
 name = "dtor"
-version = "0.3.0"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1057d6c64987086ff8ed0fd3fbf377a6b7d205cc7715868cd401705f715cbe4"
+checksum = "edf234dd1594d6dd434a8fb8cada51ddbbc593e40e4a01556a0b31c62da2775b"
 dependencies = [
  "dtor-proc-macro",
 ]
 
 [[package]]
 name = "dtor-proc-macro"
-version = "0.0.6"
+version = "0.0.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f678cf4a922c215c63e0de95eb1ff08a958a81d47e485cf9da1e27bf6305cfa5"
+checksum = "2647271c92754afcb174e758003cfd1cbf1e43e5a7853d7b1813e63e19e39a73"
 
 [[package]]
 name = "dunce"
@@ -3347,7 +3348,7 @@ dependencies = [
  "libc",
  "percent-encoding",
  "pin-project-lite",
- "socket2 0.6.2",
+ "socket2 0.5.10",
  "tokio",
  "tower-service",
  "tracing",
@@ -3781,17 +3782,6 @@ version = "2.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "06432fb54d3be7964ecd3649233cddf80db2832f47fec34c01f65b3d9d774983"
 
-[[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"
@@ -4102,9 +4092,9 @@ dependencies = [
 
 [[package]]
 name = "libc"
-version = "0.2.174"
+version = "0.2.186"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776"
+checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
 
 [[package]]
 name = "libfuzzer-sys"
@@ -4218,6 +4208,12 @@ dependencies = [
  "smallvec",
 ]
 
+[[package]]
+name = "link-section"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b685d66585d646efe09fec763d796c291049c8b6bf84e04954bffc8748341f0d"
+
 [[package]]
 name = "linked-hash-map"
 version = "0.5.6"
@@ -4569,14 +4565,14 @@ dependencies = [
 
 [[package]]
 name = "mio"
-version = "1.0.3"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2886843bf800fba2e3377cff24abf6379b4c4d5c6681eaf9ea5b0d15090450bd"
+checksum = "50b7e5b27aa02a74bac8c3f23f448f8d87ff11f92d3aac1a6ed369ee08cc56c1"
 dependencies = [
  "libc",
  "log",
  "wasi 0.11.0+wasi-snapshot-preview1",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -5078,7 +5074,7 @@ dependencies = [
  "kqueue",
  "libc",
  "log",
- "mio 1.0.3",
+ "mio 1.2.0",
  "notify-types",
  "walkdir",
  "windows-sys 0.60.2",
@@ -6089,7 +6085,7 @@ dependencies = [
  "quinn-udp",
  "rustc-hash 2.1.1",
  "rustls",
- "socket2 0.6.2",
+ "socket2 0.5.10",
  "thiserror 2.0.12",
  "tokio",
  "tracing",
@@ -6127,7 +6123,7 @@ dependencies = [
  "cfg_aliases",
  "libc",
  "once_cell",
- "socket2 0.6.2",
+ "socket2 0.5.10",
  "tracing",
  "windows-sys 0.60.2",
 ]
@@ -7417,12 +7413,12 @@ dependencies = [
 
 [[package]]
 name = "socket2"
-version = "0.6.2"
+version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86f4aa3ad99f2088c990dfa82d367e19cb29268ed67c574d10d0a4bfe71f07e0"
+checksum = "3a766e1110788c36f4fa1c2b71b387a7815aa65f88ce0229841826633d93723e"
 dependencies = [
  "libc",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -9304,30 +9300,27 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "tokio"
-version = "1.47.3"
+version = "1.52.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d89b5fb34fc88de6a0c0e32dcee5f4890c67b8afbbc4ba35afc0671c6eacda60"
+checksum = "b67dee974fe86fd92cc45b7a95fdd2f99a36a6d7b0d431a231178d3d670bbcc6"
 dependencies = [
- "backtrace",
  "bytes",
- "io-uring",
  "libc",
- "mio 1.0.3",
+ "mio 1.2.0",
  "parking_lot",
  "pin-project-lite",
  "signal-hook-registry",
- "slab",
- "socket2 0.6.2",
+ "socket2 0.6.3",
  "tokio-macros",
  "tracing",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "tokio-macros"
-version = "2.5.0"
+version = "2.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e06d43f1345a3bcd39f6a56dbb7dcab2ba47e68e8ac134855e7e2bdbaf8cab8"
+checksum = "385a6cb71ab9ab790c5fe8d67f1645e6c450a7ce006a33de03daa956cf70a496"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -9380,15 +9373,14 @@ dependencies = [
 
 [[package]]
 name = "tokio-util"
-version = "0.7.13"
+version = "0.7.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7fcaa8d55a2bdd6b83ace262b016eca0d79ee02818c5c1bcdf0305114081078"
+checksum = "9ae9cec805b01e8fc3fd2fe289f89149a9b66dd16786abd8b19cfa7b48cb0098"
 dependencies = [
  "bytes",
  "futures-core",
  "futures-sink",
  "futures-util",
- "hashbrown 0.14.5",
  "pin-project-lite",
  "tokio",
 ]
@@ -9898,6 +9890,7 @@ dependencies = [
  "bincode 2.0.1",
  "codspeed-criterion-compat",
  "concurrent-queue",
+ "ctor 0.10.1",
  "dashmap 6.1.0",
  "either",
  "erased-serde",
@@ -10120,7 +10113,7 @@ version = "0.1.0"
 dependencies = [
  "anyhow",
  "bincode 2.0.1",
- "ctor 0.8.0",
+ "ctor 0.10.1",
  "serde",
  "tokio",
  "trybuild",
@@ -10809,6 +10802,7 @@ dependencies = [
  "rustc-hash 2.1.1",
  "serde",
  "serde_json",
+ "smallvec",
  "tungstenite 0.21.0",
  "turbo-rcstr",
  "turbo-tasks-malloc",
diff --git a/Cargo.toml b/Cargo.toml
index c9879b8909b..e4c649c01e8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -258,7 +258,7 @@ console-subscriber = "0.4.1"
 const_format = "0.2.30"
 crc32fast = "1.5.0"
 criterion = { package = "codspeed-criterion-compat", version = "4.3.0" }
-ctor = "0.8"
+ctor = "0.10"
 crossbeam-channel = "0.5.8"
 crossbeam-utils = "0.8"
 dashmap = "6.1.0"
@@ -348,8 +348,8 @@ tempfile = "3.20.0"
 terminal_size = "0.3.0"
 thiserror = "1.0.48"
 thread_local = "1.1.8"
-tokio = "~1.47.3"
-tokio-util = { version = "0.7.13", features = ["io", "rt"] }
+tokio = "1.52.1"
+tokio-util = { version = "0.7.18", features = ["io", "rt"] }
 tracing = "0.1.44"
 tracing-subscriber = "0.3.16"
 triomphe = { git = "https://github.com/sokra/triomphe", branch = "sokra/unstable" }
diff --git a/crates/next-api/src/client_references.rs b/crates/next-api/src/client_references.rs
index bd2f137c3eb..5f77173b386 100644
--- a/crates/next-api/src/client_references.rs
+++ b/crates/next-api/src/client_references.rs
@@ -31,9 +31,9 @@ pub struct ClientReferenceData(FxHashMap<ResolvedVc<Box<dyn Module>>, ClientMani
 pub async fn map_client_references(
     graph: ResolvedVc<ModuleGraphLayer>,
 ) -> Result<Vc<ClientReferenceData>> {
-    let graph = graph.await?;
     let manifest = graph
-        .iter_nodes()
+        .await?
+        .iter_reachable_modules()?
         .map(|module| async move {
             if let Some(client_reference_module) =
                 ResolvedVc::try_downcast_type::<EcmascriptClientReferenceModule>(module)
diff --git a/crates/next-api/src/dynamic_imports.rs b/crates/next-api/src/dynamic_imports.rs
index 8a09e081622..3c0e4f92b85 100644
--- a/crates/next-api/src/dynamic_imports.rs
+++ b/crates/next-api/src/dynamic_imports.rs
@@ -123,7 +123,7 @@ pub async fn map_next_dynamic(
     let actions =
         graph
             .await?
-            .iter_nodes()
+            .iter_reachable_modules()?
             .map(|module| async move {
                 if let Some(dynamic_entry_module) =
                     ResolvedVc::try_downcast_type::<NextDynamicEntryModule>(module)
diff --git a/crates/next-api/src/project.rs b/crates/next-api/src/project.rs
index 63da4038135..611251d188c 100644
--- a/crates/next-api/src/project.rs
+++ b/crates/next-api/src/project.rs
@@ -2482,7 +2482,7 @@ async fn scale_down_node_pool(project: ResolvedVc<Project>) -> Result<()> {
 async fn whole_app_module_graph_operation(
     project: ResolvedVc<Project>,
 ) -> Result<Vc<BaseAndFullModuleGraph>> {
-    let span = tracing::info_span!("whole app module graph", modules = Empty);
+    let span = tracing::info_span!("whole app module graph", modules = Empty, edges = Empty);
     let span_clone = span.clone();
     async move {
         let next_mode = project.next_mode();
@@ -2529,15 +2529,24 @@ async fn whole_app_module_graph_operation(
                 .connect()
                 .module_count()
                 .untracked()
-                .owned()
                 .await?;
             let additional_module_count = additional_module_graph
                 .connect()
                 .module_count()
                 .untracked()
-                .owned()
                 .await?;
-            span.record("modules", base_module_count + additional_module_count);
+            span.record("modules", *base_module_count + *additional_module_count);
+            let base_edge_count = base_single_module_graph
+                .connect()
+                .edge_count()
+                .untracked()
+                .await?;
+            let additional_edge_count = additional_module_graph
+                .connect()
+                .edge_count()
+                .untracked()
+                .await?;
+            span.record("edges", *base_edge_count + *additional_edge_count);
         }
 
         let graphs = vec![base_single_module_graph, additional_module_graph];
diff --git a/crates/next-api/src/server_actions.rs b/crates/next-api/src/server_actions.rs
index d2cb359bdf1..5d85211344b 100644
--- a/crates/next-api/src/server_actions.rs
+++ b/crates/next-api/src/server_actions.rs
@@ -527,7 +527,7 @@ pub async fn map_server_actions(
 ) -> Result<Vc<AllModuleActions>> {
     let actions = graph
         .await?
-        .iter_nodes()
+        .iter_reachable_modules()?
         .map(async |module| {
             // TODO: compare module contexts instead?
             let layer = match module.ident().await?.layer.as_ref() {
diff --git a/lerna.json b/lerna.json
index f79f4e9a5a5..5fca0c04212 100644
--- a/lerna.json
+++ b/lerna.json
@@ -15,5 +15,5 @@
       "registry": "https://registry.npmjs.org/"
     }
   },
-  "version": "16.3.0-canary.4"
-}
+  "version": "16.3.0-canary.5"
+}
\ No newline at end of file
diff --git a/packages/create-next-app/package.json b/packages/create-next-app/package.json
index 056fbf21319..6cd531a9e91 100644
--- a/packages/create-next-app/package.json
+++ b/packages/create-next-app/package.json
@@ -1,6 +1,6 @@
 {
   "name": "create-next-app",
-  "version": "16.3.0-canary.4",
+  "version": "16.3.0-canary.5",
   "keywords": [
     "react",
     "next",
diff --git a/packages/eslint-config-next/package.json b/packages/eslint-config-next/package.json
index a0edb5d2f6e..8ef8aa77e03 100644
--- a/packages/eslint-config-next/package.json
+++ b/packages/eslint-config-next/package.json
@@ -1,6 +1,6 @@
 {
   "name": "eslint-config-next",
-  "version": "16.3.0-canary.4",
+  "version": "16.3.0-canary.5",
   "description": "ESLint configuration used by Next.js.",
   "license": "MIT",
   "repository": {
@@ -12,7 +12,7 @@
     "dist"
   ],
   "dependencies": {
-    "@next/eslint-plugin-next": "16.3.0-canary.4",
+    "@next/eslint-plugin-next": "16.3.0-canary.5",
     "eslint-import-resolver-node": "^0.3.6",
     "eslint-import-resolver-typescript": "^3.5.2",
     "eslint-plugin-import": "^2.32.0",
diff --git a/packages/eslint-plugin-internal/package.json b/packages/eslint-plugin-internal/package.json
index b7d5fa0093d..ab86c488edb 100644
--- a/packages/eslint-plugin-internal/package.json
+++ b/packages/eslint-plugin-internal/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@next/eslint-plugin-internal",
   "private": true,
-  "version": "16.3.0-canary.4",
+  "version": "16.3.0-canary.5",
   "description": "ESLint plugin for working on Next.js.",
   "exports": {
     ".": "./src/eslint-plugin-internal.js"
diff --git a/packages/eslint-plugin-next/package.json b/packages/eslint-plugin-next/package.json
index 261f15f2755..2bbe9c40314 100644
--- a/packages/eslint-plugin-next/package.json
+++ b/packages/eslint-plugin-next/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@next/eslint-plugin-next",
-  "version": "16.3.0-canary.4",
+  "version": "16.3.0-canary.5",
   "description": "ESLint plugin for Next.js.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
diff --git a/packages/font/package.json b/packages/font/package.json
index f11bd9ea7f2..15350993877 100644
--- a/packages/font/package.json
+++ b/packages/font/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@next/font",
   "private": true,
-  "version": "16.3.0-canary.4",
+  "version": "16.3.0-canary.5",
   "repository": {
     "url": "vercel/next.js",
     "directory": "packages/font"
diff --git a/packages/next-bundle-analyzer/package.json b/packages/next-bundle-analyzer/package.json
index 8032b770340..9e5a4acac92 100644
--- a/packages/next-bundle-analyzer/package.json
+++ b/packages/next-bundle-analyzer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@next/bundle-analyzer",
-  "version": "16.3.0-canary.4",
+  "version": "16.3.0-canary.5",
   "main": "index.js",
   "types": "index.d.ts",
   "license": "MIT",
diff --git a/packages/next-codemod/package.json b/packages/next-codemod/package.json
index 6f1bfbf0ff9..ac64619da63 100644
--- a/packages/next-codemod/package.json
+++ b/packages/next-codemod/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@next/codemod",
-  "version": "16.3.0-canary.4",
+  "version": "16.3.0-canary.5",
   "license": "MIT",
   "repository": {
     "type": "git",
diff --git a/packages/next-env/package.json b/packages/next-env/package.json
index 01a5a3b768b..dfdde13d08f 100644
--- a/packages/next-env/package.json
+++ b/packages/next-env/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@next/env",
-  "version": "16.3.0-canary.4",
+  "version": "16.3.0-canary.5",
   "keywords": [
     "react",
     "next",
diff --git a/packages/next-mdx/package.json b/packages/next-mdx/package.json
index bb027703f21..0fcc6ef2a61 100644
--- a/packages/next-mdx/package.json
+++ b/packages/next-mdx/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@next/mdx",
-  "version": "16.3.0-canary.4",
+  "version": "16.3.0-canary.5",
   "main": "index.js",
   "license": "MIT",
   "repository": {
diff --git a/packages/next-playwright/package.json b/packages/next-playwright/package.json
index a9888468903..2c60c2b450b 100644
--- a/packages/next-playwright/package.json
+++ b/packages/next-playwright/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@next/playwright",
-  "version": "16.3.0-canary.4",
+  "version": "16.3.0-canary.5",
   "repository": {
     "url": "vercel/next.js",
     "directory": "packages/next-playwright"
diff --git a/packages/next-plugin-storybook/package.json b/packages/next-plugin-storybook/package.json
index 19df21707a2..a22812457ec 100644
--- a/packages/next-plugin-storybook/package.json
+++ b/packages/next-plugin-storybook/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@next/plugin-storybook",
-  "version": "16.3.0-canary.4",
+  "version": "16.3.0-canary.5",
   "repository": {
     "url": "vercel/next.js",
     "directory": "packages/next-plugin-storybook"
diff --git a/packages/next-polyfill-module/package.json b/packages/next-polyfill-module/package.json
index c2962c4a815..ba7173ff216 100644
--- a/packages/next-polyfill-module/package.json
+++ b/packages/next-polyfill-module/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@next/polyfill-module",
-  "version": "16.3.0-canary.4",
+  "version": "16.3.0-canary.5",
   "description": "A standard library polyfill for ES Modules supporting browsers (Edge 16+, Firefox 60+, Chrome 61+, Safari 10.1+)",
   "main": "dist/polyfill-module.js",
   "license": "MIT",
diff --git a/packages/next-polyfill-nomodule/package.json b/packages/next-polyfill-nomodule/package.json
index 03987548d1d..7eb0847b8eb 100644
--- a/packages/next-polyfill-nomodule/package.json
+++ b/packages/next-polyfill-nomodule/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@next/polyfill-nomodule",
-  "version": "16.3.0-canary.4",
+  "version": "16.3.0-canary.5",
   "description": "A polyfill for non-dead, nomodule browsers.",
   "main": "dist/polyfill-nomodule.js",
   "license": "MIT",
diff --git a/packages/next-routing/package.json b/packages/next-routing/package.json
index 591cb0cace6..b7393b55130 100644
--- a/packages/next-routing/package.json
+++ b/packages/next-routing/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@next/routing",
-  "version": "16.3.0-canary.4",
+  "version": "16.3.0-canary.5",
   "keywords": [
     "react",
     "next",
diff --git a/packages/next-rspack/package.json b/packages/next-rspack/package.json
index a6a3b3128b8..c7d38f9e2e5 100644
--- a/packages/next-rspack/package.json
+++ b/packages/next-rspack/package.json
@@ -1,6 +1,6 @@
 {
   "name": "next-rspack",
-  "version": "16.3.0-canary.4",
+  "version": "16.3.0-canary.5",
   "repository": {
     "url": "vercel/next.js",
     "directory": "packages/next-rspack"
diff --git a/packages/next-swc/package.json b/packages/next-swc/package.json
index 5e1e60726a2..f185866668f 100644
--- a/packages/next-swc/package.json
+++ b/packages/next-swc/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@next/swc",
-  "version": "16.3.0-canary.4",
+  "version": "16.3.0-canary.5",
   "private": true,
   "files": [
     "native/"
diff --git a/packages/next-swc/turbo.jsonc b/packages/next-swc/turbo.jsonc
index 297ba751252..b20c048642b 100644
--- a/packages/next-swc/turbo.jsonc
+++ b/packages/next-swc/turbo.jsonc
@@ -84,7 +84,12 @@
     },
     "test-cargo-unit": {
       "dependsOn": ["rust-fingerprint"],
-      "inputs": ["../../target/.rust-fingerprint"],
+      "inputs": [
+        "../../target/.rust-fingerprint",
+        "../../crates/*/tests/**",
+        "../../turbopack/crates/*/tests/**",
+        "!../../turbopack/crates/turbopack-tests/tests/execution/**/output/*",
+      ],
     },
   },
 }
diff --git a/packages/next/package.json b/packages/next/package.json
index 7601c6fedc0..4eb3eb890d2 100644
--- a/packages/next/package.json
+++ b/packages/next/package.json
@@ -1,6 +1,6 @@
 {
   "name": "next",
-  "version": "16.3.0-canary.4",
+  "version": "16.3.0-canary.5",
   "description": "The React Framework",
   "main": "./dist/server/next.js",
   "license": "MIT",
@@ -101,7 +101,7 @@
     ]
   },
   "dependencies": {
-    "@next/env": "16.3.0-canary.4",
+    "@next/env": "16.3.0-canary.5",
     "@swc/helpers": "0.5.15",
     "baseline-browser-mapping": "^2.9.19",
     "caniuse-lite": "^1.0.30001579",
@@ -165,11 +165,11 @@
     "@modelcontextprotocol/sdk": "1.18.1",
     "@mswjs/interceptors": "0.23.0",
     "@napi-rs/triples": "1.2.0",
-    "@next/font": "16.3.0-canary.4",
-    "@next/polyfill-module": "16.3.0-canary.4",
-    "@next/polyfill-nomodule": "16.3.0-canary.4",
-    "@next/react-refresh-utils": "16.3.0-canary.4",
-    "@next/swc": "16.3.0-canary.4",
+    "@next/font": "16.3.0-canary.5",
+    "@next/polyfill-module": "16.3.0-canary.5",
+    "@next/polyfill-nomodule": "16.3.0-canary.5",
+    "@next/react-refresh-utils": "16.3.0-canary.5",
+    "@next/swc": "16.3.0-canary.5",
     "@opentelemetry/api": "1.6.0",
     "@playwright/test": "1.58.2",
     "@rspack/core": "1.6.7",
diff --git a/packages/next/src/next-devtools/dev-overlay/components/devtools-indicator/next-logo.tsx b/packages/next/src/next-devtools/dev-overlay/components/devtools-indicator/next-logo.tsx
index d12da9fb58e..11a9c1a55df 100644
--- a/packages/next/src/next-devtools/dev-overlay/components/devtools-indicator/next-logo.tsx
+++ b/packages/next/src/next-devtools/dev-overlay/components/devtools-indicator/next-logo.tsx
@@ -7,6 +7,7 @@ import { css } from '../../utils/css'
 import { useDevOverlayContext } from '../../../dev-overlay.browser'
 import { useRenderErrorContext } from '../../dev-overlay'
 import { useDelayedRender } from '../../hooks/use-delayed-render'
+import { useDebouncedValue } from '../../hooks/use-debounced-value'
 import {
   ACTION_ERROR_OVERLAY_CLOSE,
   ACTION_ERROR_OVERLAY_OPEN,
@@ -17,6 +18,12 @@ import { StatusIndicator, Status, getCurrentStatus } from './status-indicator'
 
 const SHORT_DURATION_MS = 150
 
+// Smooth out rapid status transitions driven by bursty HMR events (e.g.
+// Compiling→None→Compiling when consecutive compile episodes are <300ms apart,
+// or Compiling→Rendering→Compiling oscillation). The debounce bridges burst
+// gaps and active↔active flicker.
+const STATUS_DEBOUNCE_MS = 300
+
 export function NextLogo({
   onTriggerClick,
   ...buttonProps
@@ -42,12 +49,30 @@ export function NextLogo({
   )
 
   // Cache indicator state management
-  const isCacheFilling = state.cacheIndicator === 'filling'
   const isCacheBypassing = state.cacheIndicator === 'bypass'
 
+  // Get the current status from the state. Debounce active↔active transitions
+  // (e.g. Compiling→Rendering) so bursts of HMR events don't flicker the
+  // badge. Transitions to None are committed immediately so fast single builds
+  // cancel the enter timer before the pill becomes visible.
+  const currentStatus = useDebouncedValue(
+    getCurrentStatus(
+      state.buildingIndicator,
+      state.renderingIndicator,
+      state.cacheIndicator
+    ),
+    STATUS_DEBOUNCE_MS,
+    {
+      // Only None→active is immediate (no debounce on top of enterDelay).
+      // active→None is debounced so short inter-burst gaps don't prematurely
+      // collapse the pill. Fast single builds (completing in <enterDelay-debounce ms)
+      // still stay hidden because the debounced None commits before enterDelay fires.
+      leading: (prev: Status) => prev === Status.None,
+    }
+  )
+
   // Determine if we should show any status (excluding cache bypass, which renders like error badge)
-  const shouldShowStatus =
-    state.buildingIndicator || state.renderingIndicator || isCacheFilling
+  const shouldShowStatus = currentStatus !== Status.None
 
   // Delay showing for 400ms to catch fast operations,
   // and keep visible for minimum time (longer for warnings)
@@ -59,13 +84,6 @@ export function NextLogo({
   const ref = useRef<HTMLDivElement | null>(null)
   const measuredWidth = useMeasureWidth(ref)
 
-  // Get the current status from the state
-  const currentStatus = getCurrentStatus(
-    state.buildingIndicator,
-    state.renderingIndicator,
-    state.cacheIndicator
-  )
-
   const displayStatus = showStatusIndicator ? currentStatus : Status.None
 
   const isExpanded =
diff --git a/packages/next/src/next-devtools/dev-overlay/hooks/use-debounced-value.test.ts b/packages/next/src/next-devtools/dev-overlay/hooks/use-debounced-value.test.ts
new file mode 100644
index 00000000000..93e447494b3
--- /dev/null
+++ b/packages/next/src/next-devtools/dev-overlay/hooks/use-debounced-value.test.ts
@@ -0,0 +1,159 @@
+/**
+ * @jest-environment jsdom
+ */
+/* eslint-disable import/no-extraneous-dependencies -- Not a prod file */
+import { act, renderHook } from '@testing-library/react'
+import { useDebouncedValue } from './use-debounced-value'
+
+beforeEach(() => {
+  jest.useFakeTimers()
+})
+
+afterEach(() => {
+  jest.useRealTimers()
+})
+
+describe('useDebouncedValue', () => {
+  it('returns the initial value immediately', () => {
+    const { result } = renderHook(() => useDebouncedValue('a', 300))
+    expect(result.current).toBe('a')
+  })
+
+  it('does not update immediately when value changes', () => {
+    const { result, rerender } = renderHook(
+      ({ value }) => useDebouncedValue(value, 300),
+      { initialProps: { value: 'a' } }
+    )
+
+    rerender({ value: 'b' })
+    expect(result.current).toBe('a')
+  })
+
+  it('updates after the debounce delay', () => {
+    const { result, rerender } = renderHook(
+      ({ value }) => useDebouncedValue(value, 300),
+      { initialProps: { value: 'a' } }
+    )
+
+    rerender({ value: 'b' })
+    act(() => {
+      jest.advanceTimersByTime(300)
+    })
+    expect(result.current).toBe('b')
+  })
+
+  it('resets the timer when value changes again before delay elapses', () => {
+    const { result, rerender } = renderHook(
+      ({ value }) => useDebouncedValue(value, 300),
+      { initialProps: { value: 'a' } }
+    )
+
+    rerender({ value: 'b' })
+    act(() => {
+      jest.advanceTimersByTime(200)
+    })
+    // Still debouncing 'b' — change to 'c' before timer fires
+    rerender({ value: 'c' })
+    act(() => {
+      jest.advanceTimersByTime(200)
+    })
+    // 400ms total but timer was reset at 200ms, so still not committed
+    expect(result.current).toBe('a')
+
+    act(() => {
+      jest.advanceTimersByTime(100)
+    })
+    // 300ms since last change — now committed
+    expect(result.current).toBe('c')
+  })
+
+  it('never commits intermediate values during rapid changes', () => {
+    const { result, rerender } = renderHook(
+      ({ value }) => useDebouncedValue(value, 300),
+      { initialProps: { value: 'a' } }
+    )
+
+    rerender({ value: 'b' })
+    rerender({ value: 'c' })
+    rerender({ value: 'd' })
+    act(() => {
+      jest.advanceTimersByTime(300)
+    })
+    expect(result.current).toBe('d')
+  })
+
+  describe('leading option', () => {
+    const alwaysLeading = () => true
+    const neverLeading = () => false
+    const leadingWhenNext = (_prev: string, next: string) => next === 'none'
+
+    it('commits immediately when leading returns true', () => {
+      const { result, rerender } = renderHook(
+        ({ value }) =>
+          useDebouncedValue(value, 300, { leading: alwaysLeading }),
+        { initialProps: { value: 'a' } }
+      )
+
+      rerender({ value: 'b' })
+      // No timer advance needed — leading committed synchronously
+      expect(result.current).toBe('b')
+    })
+
+    it('does not commit immediately when leading returns false', () => {
+      const { result, rerender } = renderHook(
+        ({ value }) => useDebouncedValue(value, 300, { leading: neverLeading }),
+        { initialProps: { value: 'a' } }
+      )
+
+      rerender({ value: 'b' })
+      expect(result.current).toBe('a')
+
+      act(() => {
+        jest.advanceTimersByTime(300)
+      })
+      expect(result.current).toBe('b')
+    })
+
+    it('commits immediately only for the matching transition, debounces others', () => {
+      const { result, rerender } = renderHook(
+        ({ value }) =>
+          useDebouncedValue(value, 300, { leading: leadingWhenNext }),
+        { initialProps: { value: 'compiling' } }
+      )
+
+      // active → active: debounced
+      rerender({ value: 'rendering' })
+      expect(result.current).toBe('compiling')
+
+      act(() => {
+        jest.advanceTimersByTime(300)
+      })
+      expect(result.current).toBe('rendering')
+
+      // active → none: immediate
+      rerender({ value: 'none' })
+      expect(result.current).toBe('none')
+    })
+
+    it('active→active transitions during burst resolve to final value', () => {
+      const { result, rerender } = renderHook(
+        ({ value }) =>
+          useDebouncedValue(value, 300, { leading: leadingWhenNext }),
+        { initialProps: { value: 'compiling' } }
+      )
+
+      // Rapid burst: compiling→rendering→compiling→rendering
+      rerender({ value: 'rendering' })
+      rerender({ value: 'compiling' })
+      rerender({ value: 'rendering' })
+
+      // Still on original value, timer hasn't fired
+      expect(result.current).toBe('compiling')
+
+      act(() => {
+        jest.advanceTimersByTime(300)
+      })
+      expect(result.current).toBe('rendering')
+    })
+  })
+})
diff --git a/packages/next/src/next-devtools/dev-overlay/hooks/use-debounced-value.ts b/packages/next/src/next-devtools/dev-overlay/hooks/use-debounced-value.ts
new file mode 100644
index 00000000000..af27b96780a
--- /dev/null
+++ b/packages/next/src/next-devtools/dev-overlay/hooks/use-debounced-value.ts
@@ -0,0 +1,49 @@
+import { useEffect, useState } from 'react'
+
+interface Options<T> {
+  /**
+   * Optional predicate evaluated when `value` changes. If it returns `true`
+   * for the current transition, the new value is committed synchronously,
+   * bypassing the debounce. Useful for "smooth subsequent updates but never
+   * delay the first one" patterns.
+   *
+   * Should be a stable reference (module-level or `useCallback`-wrapped) to
+   * avoid re-running the effect on every render.
+   */
+  leading?: (prev: T, next: T) => boolean
+}
+
+/**
+ * Returns a trailing-edge debounced version of `value`. When `value` changes,
+ * the returned value is updated only after `ms` has elapsed without further
+ * changes.
+ *
+ * The first value is committed synchronously. Subsequent changes are delayed
+ * by `ms` unless `options.leading` returns `true` for the transition.
+ */
+export function useDebouncedValue<T>(
+  value: T,
+  ms: number,
+  options: Options<T> = {}
+): T {
+  const [debounced, setDebounced] = useState(value)
+  const { leading } = options
+
+  // Handle leading/immediate transitions during render rather than in an
+  // effect. When setState is called synchronously during render, React discards
+  // the intermediate render without committing it to the DOM — no extra paint.
+  // This avoids the double-render that would occur if we called setDebounced
+  // inside useEffect for the immediate path.
+  if (!Object.is(value, debounced) && leading?.(debounced, value)) {
+    setDebounced(value)
+  }
+
+  useEffect(() => {
+    if (Object.is(value, debounced)) return
+
+    const id = setTimeout(() => setDebounced(value), ms)
+    return () => clearTimeout(id)
+  }, [value, debounced, ms])
+
+  return debounced
+}
diff --git a/packages/next/src/server/app-render/app-render.tsx b/packages/next/src/server/app-render/app-render.tsx
index e85cf161ad0..103c28a69ca 100644
--- a/packages/next/src/server/app-render/app-render.tsx
+++ b/packages/next/src/server/app-render/app-render.tsx
@@ -1575,6 +1575,23 @@ async function generateDynamicFlightRenderResultWithStagesInDev(
       )
     } else {
       logValidationSkipped(ctx)
+
+      // The main render may record an invalid dynamic usage error on the work
+      // store, e.g. a `'use cache'` fill timeout, or a request API like
+      // `cookies()` being called inside a `'use cache'` scope. Even when we
+      // don't spawn the static shell validation, surface any recorded error
+      // through the dev overlay so client-side navigations see the same error
+      // as initial HTML loads, where the spawned validation forwards it. Wait
+      // for the full stream to finish accumulating so we also catch errors from
+      // the dynamic stage.
+      void accumulatedChunksPromise.then(() => {
+        if (workStore.invalidDynamicUsageError) {
+          logMessagesAndSendErrorsToBrowser(
+            [workStore.invalidDynamicUsageError],
+            ctx
+          )
+        }
+      })
     }
 
     debugChannel = returnedDebugChannel
diff --git a/packages/react-refresh-utils/package.json b/packages/react-refresh-utils/package.json
index 140fc51b3cd..e18857cc281 100644
--- a/packages/react-refresh-utils/package.json
+++ b/packages/react-refresh-utils/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@next/react-refresh-utils",
-  "version": "16.3.0-canary.4",
+  "version": "16.3.0-canary.5",
   "description": "An experimental package providing utilities for React Refresh.",
   "repository": {
     "url": "vercel/next.js",
diff --git a/packages/third-parties/package.json b/packages/third-parties/package.json
index 008ce607a2c..615fea827ee 100644
--- a/packages/third-parties/package.json
+++ b/packages/third-parties/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@next/third-parties",
-  "version": "16.3.0-canary.4",
+  "version": "16.3.0-canary.5",
   "repository": {
     "url": "vercel/next.js",
     "directory": "packages/third-parties"
@@ -27,7 +27,7 @@
     "third-party-capital": "1.0.20"
   },
   "devDependencies": {
-    "next": "16.3.0-canary.4",
+    "next": "16.3.0-canary.5",
     "outdent": "0.8.0",
     "prettier": "2.5.1",
     "typescript": "6.0.2"
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index e5fa90b87c5..4f8a13325bd 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -983,7 +983,7 @@ importers:
   packages/eslint-config-next:
     dependencies:
       '@next/eslint-plugin-next':
-        specifier: 16.3.0-canary.4
+        specifier: 16.3.0-canary.5
         version: link:../eslint-plugin-next
       eslint:
         specifier: '>=9.0.0'
@@ -1060,7 +1060,7 @@ importers:
   packages/next:
     dependencies:
       '@next/env':
-        specifier: 16.3.0-canary.4
+        specifier: 16.3.0-canary.5
         version: link:../next-env
       '@swc/helpers':
         specifier: 0.5.15
@@ -1181,19 +1181,19 @@ importers:
         specifier: 1.2.0
         version: 1.2.0
       '@next/font':
-        specifier: 16.3.0-canary.4
+        specifier: 16.3.0-canary.5
         version: link:../font
       '@next/polyfill-module':
-        specifier: 16.3.0-canary.4
+        specifier: 16.3.0-canary.5
         version: link:../next-polyfill-module
       '@next/polyfill-nomodule':
-        specifier: 16.3.0-canary.4
+        specifier: 16.3.0-canary.5
         version: link:../next-polyfill-nomodule
       '@next/react-refresh-utils':
-        specifier: 16.3.0-canary.4
+        specifier: 16.3.0-canary.5
         version: link:../react-refresh-utils
       '@next/swc':
-        specifier: 16.3.0-canary.4
+        specifier: 16.3.0-canary.5
         version: link:../next-swc
       '@opentelemetry/api':
         specifier: 1.6.0
@@ -1927,7 +1927,7 @@ importers:
         version: 1.0.20
     devDependencies:
       next:
-        specifier: 16.3.0-canary.4
+        specifier: 16.3.0-canary.5
         version: link:../next
       outdent:
         specifier: 0.8.0
diff --git a/test/e2e/app-dir/use-cache-hanging/app/layout.tsx b/test/e2e/app-dir/use-cache-hanging/app/layout.tsx
index 888614deda3..af3f9cfa391 100644
--- a/test/e2e/app-dir/use-cache-hanging/app/layout.tsx
+++ b/test/e2e/app-dir/use-cache-hanging/app/layout.tsx
@@ -1,8 +1,20 @@
+import Link from 'next/link'
 import { ReactNode } from 'react'
 export default function Root({ children }: { children: ReactNode }) {
   return (
     <html>
-      <body>{children}</body>
+      <body>
+        <nav>
+          <Link href="/">Home</Link>
+          {' | '}
+          <Link href="/static">Static</Link>
+          {' | '}
+          <Link href="/runtime">Runtime</Link>
+          {' | '}
+          <Link href="/dynamic">Dynamic</Link>
+        </nav>
+        {children}
+      </body>
     </html>
   )
 }
diff --git a/test/e2e/app-dir/use-cache-hanging/app/page.tsx b/test/e2e/app-dir/use-cache-hanging/app/page.tsx
new file mode 100644
index 00000000000..7a402d64650
--- /dev/null
+++ b/test/e2e/app-dir/use-cache-hanging/app/page.tsx
@@ -0,0 +1,3 @@
+export default function Page() {
+  return <p>Home</p>
+}
diff --git a/test/e2e/app-dir/use-cache-hanging/use-cache-hanging.test.ts b/test/e2e/app-dir/use-cache-hanging/use-cache-hanging.test.ts
index 74b811cbac3..d52767eef0f 100644
--- a/test/e2e/app-dir/use-cache-hanging/use-cache-hanging.test.ts
+++ b/test/e2e/app-dir/use-cache-hanging/use-cache-hanging.test.ts
@@ -1,4 +1,5 @@
 import { nextTestSetup } from 'e2e-utils'
+import { retry } from 'next-test-utils'
 import stripAnsi from 'strip-ansi'
 
 const expectedTimeoutErrorMessage =
@@ -17,7 +18,7 @@ describe('use-cache-hanging', () => {
 
   if (isNextDev) {
     describe('when a "use cache" fill hangs in the static stage', () => {
-      it('should show an error toast after a timeout', async () => {
+      it('should show an error after a timeout', async () => {
         const outputIndex = next.cliOutput.length
         const browser = await next.browser('/static')
 
@@ -46,7 +47,7 @@ describe('use-cache-hanging', () => {
     })
 
     describe('when a "use cache" fill hangs in the runtime stage', () => {
-      it('should show an error toast after a timeout', async () => {
+      it('should show an error after a timeout', async () => {
         const outputIndex = next.cliOutput.length
         const browser = await next.browser('/runtime')
 
@@ -74,6 +75,72 @@ describe('use-cache-hanging', () => {
       })
     })
 
+    describe('when navigating to the static page', () => {
+      it('should show an error toast after a timeout', async () => {
+        const outputIndex = next.cliOutput.length
+        const browser = await next.browser('/')
+
+        await browser.elementByCss('a[href="/static"]').click()
+
+        await retry(() => {
+          const cliOutput = stripAnsi(next.cliOutput.slice(outputIndex))
+
+          expect(cliOutput).toContain(`Error: ${expectedTimeoutErrorMessage}
+    at getCachedData (app/static/page.tsx:6:1)`)
+        }, 20_000)
+
+        await expect(browser).toDisplayCollapsedRedbox(`
+         {
+           "code": "E236",
+           "description": "Filling a cache during prerender timed out, likely because request-specific arguments such as params, searchParams, cookies() or dynamic data were used inside "use cache".",
+           "environmentLabel": "Server",
+           "label": "Console Error",
+           "source": "app/static/page.tsx (6:1) @ getCachedData
+         > 6 | async function getCachedData(): Promise<string> {
+             | ^",
+           "stack": [
+             "getCachedData app/static/page.tsx (6:1)",
+             "Cached app/static/page.tsx (18:24)",
+             "Page app/static/page.tsx (32:10)",
+           ],
+         }
+        `)
+      })
+    })
+
+    describe('when navigating to the runtime page', () => {
+      it('should show an error toast after a timeout', async () => {
+        const outputIndex = next.cliOutput.length
+        const browser = await next.browser('/')
+
+        await browser.elementByCss('a[href="/runtime"]').click()
+
+        await retry(() => {
+          const cliOutput = stripAnsi(next.cliOutput.slice(outputIndex))
+
+          expect(cliOutput).toContain(`Error: ${expectedTimeoutErrorMessage}
+    at getCachedData (app/runtime/page.tsx:8:1)`)
+        }, 20_000)
+
+        await expect(browser).toDisplayCollapsedRedbox(`
+         {
+           "code": "E236",
+           "description": "Filling a cache during prerender timed out, likely because request-specific arguments such as params, searchParams, cookies() or dynamic data were used inside "use cache".",
+           "environmentLabel": "Server",
+           "label": "Console Error",
+           "source": "app/runtime/page.tsx (8:1) @ getCachedData
+         >  8 | async function getCachedData(): Promise<string> {
+              | ^",
+           "stack": [
+             "getCachedData app/runtime/page.tsx (8:1)",
+             "Cached app/runtime/page.tsx (20:24)",
+             "Page app/runtime/page.tsx (42:7)",
+           ],
+         }
+        `)
+      })
+    })
+
     describe('when a "use cache" performs long-running I/O in the dynamic stage', () => {
       it('should not time out', async () => {
         const outputIndex = next.cliOutput.length
diff --git a/turbopack/crates/turbo-tasks-backend/Cargo.toml b/turbopack/crates/turbo-tasks-backend/Cargo.toml
index b588ac6711c..42ed56f3304 100644
--- a/turbopack/crates/turbo-tasks-backend/Cargo.toml
+++ b/turbopack/crates/turbo-tasks-backend/Cargo.toml
@@ -22,6 +22,7 @@ verify_serialization = []
 verify_aggregation_graph = []
 verify_immutable = []
 verify_determinism = ["turbo-tasks/verify_determinism"]
+trace_aggregation_update_stats = []
 trace_aggregation_update_queue = []
 trace_aggregation_update = ["trace_aggregation_update_queue"]
 trace_leaf_distance_update = []
diff --git a/turbopack/crates/turbo-tasks-backend/src/backend/mod.rs b/turbopack/crates/turbo-tasks-backend/src/backend/mod.rs
index 217f857115f..b0f09a0cf00 100644
--- a/turbopack/crates/turbo-tasks-backend/src/backend/mod.rs
+++ b/turbopack/crates/turbo-tasks-backend/src/backend/mod.rs
@@ -2350,11 +2350,22 @@ impl<B: BackingStorage> TurboTasksBackendInner<B> {
         span.record("immutable", is_immutable || is_now_immutable);
 
         if !queue.is_empty() || !old_edges.is_empty() {
-            #[cfg(feature = "trace_task_completion")]
-            let _span = tracing::trace_span!("remove old edges and prepare new children").entered();
+            #[cfg(any(
+                feature = "trace_task_completion",
+                feature = "trace_aggregation_update_stats"
+            ))]
+            let _span =
+                tracing::trace_span!("remove old edges and prepare new children", stats = Empty)
+                    .entered();
             // Remove outdated edges first, before removing in_progress+dirty flag.
             // We need to make sure all outdated edges are removed before the task can potentially
             // be scheduled and executed again
+            #[cfg(feature = "trace_aggregation_update_stats")]
+            {
+                let stats = CleanupOldEdgesOperation::run(task_id, old_edges, queue, ctx);
+                _span.record("stats", tracing::field::debug(stats));
+            }
+            #[cfg(not(feature = "trace_aggregation_update_stats"))]
             CleanupOldEdgesOperation::run(task_id, old_edges, queue, ctx);
         }
 
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 76795e0e25f..83aa7e6a8d9 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
@@ -45,6 +45,10 @@ const MAX_COUNT_BEFORE_YIELD: usize = 1000;
 /// of them per `process()` call before yielding.
 const FIND_AND_SCHEDULE_BATCH_SIZE: usize = 10000;
 const MAX_UPPERS_FOLLOWER_PRODUCT: usize = 31;
+#[cfg(not(feature = "trace_aggregation_update"))]
+const AGGREGATION_UPDATE_CATEGORY: TaskDataCategory = TaskDataCategory::Meta;
+#[cfg(feature = "trace_aggregation_update")]
+const AGGREGATION_UPDATE_CATEGORY: TaskDataCategory = TaskDataCategory::All;
 
 type TaskIdVec = SmallVec<[TaskId; 4]>;
 type TaskIdWithCountVec = SmallVec<[(TaskId, u32); 2]>;
@@ -240,6 +244,12 @@ pub enum AggregationUpdateJob {
     },
     /// Notifies multiple upper tasks that one of its inner tasks has new followers.
     InnerOfUppersHasNewFollowers(Box<InnerOfUppersHasNewFollowersJob>),
+    /// Notifies an upper task that one of its inner tasks has lost a follower.
+    InnerOfUpperLostFollower {
+        upper_id: TaskId,
+        lost_follower_id: TaskId,
+        retry: u16,
+    },
     /// Notifies multiple upper tasks that one of its inner tasks has lost a follower.
     InnerOfUppersLostFollower {
         upper_ids: TaskIdVec,
@@ -788,6 +798,30 @@ impl PartialEq for FindAndScheduleJob {
 
 impl Eq for FindAndScheduleJob {}
 
+#[cfg(feature = "trace_aggregation_update_stats")]
+#[derive(Default, Encode, Decode, Clone, Debug)]
+pub struct AggregationUpdateQueueStats {
+    new_followers: usize,
+    inner_of_upper_has_new_follower: usize,
+    inner_of_uppers_has_new_follower: usize,
+    inner_of_upper_has_new_followers: usize,
+    lost_followers: usize,
+    inner_of_upper_lost_follower: usize,
+    inner_of_upper_lost_followers: usize,
+    inner_of_uppers_lost_follower: usize,
+    increase_active_count: usize,
+    decrease_active_count: usize,
+    balance_edge: usize,
+    balance_edge_batches: usize,
+    update_aggregation_number: usize,
+    update_aggregation_number_batches: usize,
+    optimize_task: usize,
+    aggregated_data_update: usize,
+    find_and_schedule_dirty_batches: usize,
+    find_and_schedule_dirty: usize,
+    schedule_task: usize,
+}
+
 /// Encodes the jobs in the queue. This is used to filter out transient jobs during encoding.
 mod encode_jobs {
     use bincode::{
@@ -858,6 +892,8 @@ pub struct AggregationUpdateQueue {
     optimize_queue: FxRingSet<OptimizeJob>,
     #[bincode(skip, default = "FxHashMap::default")]
     scheduled_tasks: FxHashMap<TaskId, TaskPriority>,
+    #[cfg(feature = "trace_aggregation_update_stats")]
+    pub stats: AggregationUpdateQueueStats,
 }
 
 impl AggregationUpdateQueue {
@@ -871,6 +907,8 @@ impl AggregationUpdateQueue {
             balance_queue: FxRingSet::default(),
             optimize_queue: FxRingSet::default(),
             scheduled_tasks: FxHashMap::default(),
+            #[cfg(feature = "trace_aggregation_update_stats")]
+            stats: AggregationUpdateQueueStats::default(),
         }
     }
 
@@ -884,6 +922,8 @@ impl AggregationUpdateQueue {
             optimize_queue,
             done_aggregation_number_updates: _,
             scheduled_tasks,
+            #[cfg(feature = "trace_aggregation_update_stats")]
+                stats: _,
         } = self;
         jobs.is_empty()
             && aggregation_number_updates.is_empty()
@@ -1003,6 +1043,11 @@ impl AggregationUpdateQueue {
                     let uppers = upper_ids.len();
                     let followers = new_follower_ids.len();
                     if uppers == 1 && followers == 1 {
+                        #[cfg(feature = "trace_aggregation_update_stats")]
+                        {
+                            self.stats.new_followers += 1;
+                            self.stats.inner_of_upper_has_new_follower += 1;
+                        }
                         self.inner_of_upper_has_new_follower(
                             ctx,
                             new_follower_ids[0],
@@ -1020,6 +1065,11 @@ impl AggregationUpdateQueue {
                             } else {
                                 take(upper_ids)
                             };
+                            #[cfg(feature = "trace_aggregation_update_stats")]
+                            {
+                                self.stats.new_followers += uppers;
+                                self.stats.inner_of_uppers_has_new_follower += 1;
+                            }
                             self.inner_of_uppers_has_new_follower(ctx, new_follower_id, upper_ids);
                         }
                     } else if let Some(upper_id) = upper_ids.pop() {
@@ -1032,6 +1082,11 @@ impl AggregationUpdateQueue {
                         } else {
                             take(new_follower_ids)
                         };
+                        #[cfg(feature = "trace_aggregation_update_stats")]
+                        {
+                            self.stats.new_followers += followers;
+                            self.stats.inner_of_upper_has_new_followers += 1;
+                        }
                         self.inner_of_upper_has_new_followers(ctx, new_follower_ids, upper_id);
                     }
                 }
@@ -1040,8 +1095,18 @@ impl AggregationUpdateQueue {
                     new_follower_id,
                 } => {
                     if upper_ids.len() == 1 {
+                        #[cfg(feature = "trace_aggregation_update_stats")]
+                        {
+                            self.stats.new_followers += upper_ids.len();
+                            self.stats.inner_of_upper_has_new_follower += 1;
+                        }
                         self.inner_of_upper_has_new_follower(ctx, new_follower_id, upper_ids[0], 1);
                     } else {
+                        #[cfg(feature = "trace_aggregation_update_stats")]
+                        {
+                            self.stats.new_followers += upper_ids.len();
+                            self.stats.inner_of_uppers_has_new_follower += 1;
+                        }
                         self.inner_of_uppers_has_new_follower(ctx, new_follower_id, upper_ids);
                     }
                 }
@@ -1051,8 +1116,18 @@ impl AggregationUpdateQueue {
                 } => {
                     if upper_ids.len() == 1 {
                         let (id, count) = upper_ids[0];
+                        #[cfg(feature = "trace_aggregation_update_stats")]
+                        {
+                            self.stats.new_followers += upper_ids.len();
+                            self.stats.inner_of_upper_has_new_follower += 1;
+                        }
                         self.inner_of_upper_has_new_follower(ctx, new_follower_id, id, count);
                     } else {
+                        #[cfg(feature = "trace_aggregation_update_stats")]
+                        {
+                            self.stats.new_followers += upper_ids.len();
+                            self.stats.inner_of_uppers_has_new_follower += 1;
+                        }
                         self.inner_of_uppers_has_new_follower(ctx, new_follower_id, upper_ids);
                     }
                 }
@@ -1061,8 +1136,18 @@ impl AggregationUpdateQueue {
                     new_follower_ids,
                 } => {
                     if new_follower_ids.len() == 1 {
+                        #[cfg(feature = "trace_aggregation_update_stats")]
+                        {
+                            self.stats.new_followers += new_follower_ids.len();
+                            self.stats.inner_of_upper_has_new_follower += 1;
+                        }
                         self.inner_of_upper_has_new_follower(ctx, new_follower_ids[0], upper_id, 1);
                     } else {
+                        #[cfg(feature = "trace_aggregation_update_stats")]
+                        {
+                            self.stats.new_followers += new_follower_ids.len();
+                            self.stats.inner_of_upper_has_new_followers += 1;
+                        }
                         self.inner_of_upper_has_new_followers(ctx, new_follower_ids, upper_id);
                     }
                 }
@@ -1072,8 +1157,18 @@ impl AggregationUpdateQueue {
                 } => {
                     if new_follower_ids.len() == 1 {
                         let (id, count) = new_follower_ids[0];
+                        #[cfg(feature = "trace_aggregation_update_stats")]
+                        {
+                            self.stats.new_followers += new_follower_ids.len();
+                            self.stats.inner_of_upper_has_new_follower += 1;
+                        }
                         self.inner_of_upper_has_new_follower(ctx, id, upper_id, count);
                     } else {
+                        #[cfg(feature = "trace_aggregation_update_stats")]
+                        {
+                            self.stats.new_followers += new_follower_ids.len();
+                            self.stats.inner_of_upper_has_new_followers += 1;
+                        }
                         self.inner_of_upper_has_new_followers(ctx, new_follower_ids, upper_id);
                     }
                 }
@@ -1081,14 +1176,45 @@ impl AggregationUpdateQueue {
                     upper_id,
                     new_follower_id,
                 } => {
+                    #[cfg(feature = "trace_aggregation_update_stats")]
+                    {
+                        self.stats.new_followers += 1;
+                        self.stats.inner_of_upper_has_new_follower += 1;
+                    }
                     self.inner_of_upper_has_new_follower(ctx, new_follower_id, upper_id, 1);
                 }
+                AggregationUpdateJob::InnerOfUpperLostFollower {
+                    lost_follower_id,
+                    upper_id,
+                    retry,
+                } => {
+                    #[cfg(feature = "trace_aggregation_update_stats")]
+                    {
+                        self.stats.lost_followers += 1;
+                        self.stats.inner_of_upper_lost_follower += 1;
+                    }
+                    self.inner_of_upper_lost_follower(ctx, lost_follower_id, upper_id, retry);
+                }
                 AggregationUpdateJob::InnerOfUppersLostFollowers(mut boxed) => {
                     let InnerOfUppersLostFollowersJob {
                         upper_ids,
                         lost_follower_ids,
                     } = &mut *boxed;
-                    if upper_ids.len() > lost_follower_ids.len() {
+                    let uppers = upper_ids.len();
+                    let followers = lost_follower_ids.len();
+                    if uppers == 1 && followers == 1 {
+                        #[cfg(feature = "trace_aggregation_update_stats")]
+                        {
+                            self.stats.lost_followers += 1;
+                            self.stats.inner_of_upper_lost_follower += 1;
+                        }
+                        self.inner_of_upper_lost_follower(
+                            ctx,
+                            lost_follower_ids[0],
+                            upper_ids[0],
+                            0,
+                        );
+                    } else if uppers > followers {
                         if let Some(lost_follower_id) = lost_follower_ids.pop() {
                             let upper_ids = if !lost_follower_ids.is_empty() {
                                 let upper_ids = upper_ids.clone();
@@ -1099,6 +1225,11 @@ impl AggregationUpdateQueue {
                             } else {
                                 take(upper_ids)
                             };
+                            #[cfg(feature = "trace_aggregation_update_stats")]
+                            {
+                                self.stats.lost_followers += uppers;
+                                self.stats.inner_of_upper_lost_follower += 1;
+                            }
                             self.inner_of_uppers_lost_follower(ctx, lost_follower_id, upper_ids, 0);
                         }
                     } else if let Some(upper_id) = upper_ids.pop() {
@@ -1111,6 +1242,11 @@ impl AggregationUpdateQueue {
                         } else {
                             take(lost_follower_ids)
                         };
+                        #[cfg(feature = "trace_aggregation_update_stats")]
+                        {
+                            self.stats.lost_followers += followers;
+                            self.stats.inner_of_upper_lost_followers += 1;
+                        }
                         self.inner_of_upper_lost_followers(ctx, lost_follower_ids, upper_id, 0);
                     }
                 }
@@ -1119,19 +1255,61 @@ impl AggregationUpdateQueue {
                     lost_follower_id,
                     retry,
                 } => {
-                    self.inner_of_uppers_lost_follower(ctx, lost_follower_id, upper_ids, retry);
+                    if upper_ids.len() == 1 {
+                        #[cfg(feature = "trace_aggregation_update_stats")]
+                        {
+                            self.stats.lost_followers += upper_ids.len();
+                            self.stats.inner_of_upper_lost_follower += 1;
+                        }
+                        self.inner_of_upper_lost_follower(
+                            ctx,
+                            lost_follower_id,
+                            upper_ids[0],
+                            retry,
+                        );
+                    } else {
+                        #[cfg(feature = "trace_aggregation_update_stats")]
+                        {
+                            self.stats.lost_followers += upper_ids.len();
+                            self.stats.inner_of_uppers_lost_follower += 1;
+                        }
+                        self.inner_of_uppers_lost_follower(ctx, lost_follower_id, upper_ids, retry);
+                    }
                 }
                 AggregationUpdateJob::InnerOfUpperLostFollowers {
                     upper_id,
                     lost_follower_ids,
                     retry,
                 } => {
-                    self.inner_of_upper_lost_followers(ctx, lost_follower_ids, upper_id, retry);
+                    if lost_follower_ids.len() == 1 {
+                        #[cfg(feature = "trace_aggregation_update_stats")]
+                        {
+                            self.stats.lost_followers += lost_follower_ids.len();
+                            self.stats.inner_of_upper_lost_follower += 1;
+                        }
+                        self.inner_of_upper_lost_follower(
+                            ctx,
+                            lost_follower_ids[0],
+                            upper_id,
+                            retry,
+                        );
+                    } else {
+                        #[cfg(feature = "trace_aggregation_update_stats")]
+                        {
+                            self.stats.lost_followers += lost_follower_ids.len();
+                            self.stats.inner_of_upper_lost_followers += 1;
+                        }
+                        self.inner_of_upper_lost_followers(ctx, lost_follower_ids, upper_id, retry);
+                    }
                 }
                 AggregationUpdateJob::AggregatedDataUpdate(box AggregatedDataUpdateJob {
                     upper_ids,
                     update,
                 }) => {
+                    #[cfg(feature = "trace_aggregation_update_stats")]
+                    {
+                        self.stats.aggregated_data_update += 1;
+                    }
                     self.aggregated_data_update(upper_ids, ctx, update);
                 }
                 AggregationUpdateJob::InvalidateDueToCollectiblesChange {
@@ -1178,6 +1356,10 @@ impl AggregationUpdateQueue {
             }
             false
         } else if !self.aggregation_number_updates.is_empty() {
+            #[cfg(feature = "trace_aggregation_update_stats")]
+            {
+                self.stats.update_aggregation_number_batches += 1;
+            }
             let mut remaining = MAX_COUNT_BEFORE_YIELD;
             while remaining > 0 {
                 if let Some((
@@ -1201,6 +1383,10 @@ impl AggregationUpdateQueue {
                             span: None,
                         },
                     );
+                    #[cfg(feature = "trace_aggregation_update_stats")]
+                    {
+                        self.stats.update_aggregation_number += 1;
+                    }
                     self.update_aggregation_number(ctx, task_id, distance, base_aggregation_number);
                     remaining -= 1;
                 } else {
@@ -1209,6 +1395,10 @@ impl AggregationUpdateQueue {
             }
             false
         } else if !self.balance_queue.is_empty() {
+            #[cfg(feature = "trace_aggregation_update_stats")]
+            {
+                self.stats.balance_edge_batches += 1;
+            }
             let mut remaining = MAX_COUNT_BEFORE_YIELD;
             while remaining > 0 {
                 if let Some(BalanceJob {
@@ -1220,6 +1410,10 @@ impl AggregationUpdateQueue {
                 {
                     #[cfg(feature = "trace_aggregation_update_queue")]
                     let _guard = span.map(|s| s.entered());
+                    #[cfg(feature = "trace_aggregation_update_stats")]
+                    {
+                        self.stats.balance_edge += 1;
+                    }
                     self.balance_edge(ctx, upper, task);
                     remaining -= 1;
                 } else {
@@ -1238,6 +1432,10 @@ impl AggregationUpdateQueue {
             // all have the same upper count. Optimizing the root first
             #[cfg(feature = "trace_aggregation_update_queue")]
             let _guard = span.map(|s| s.entered());
+            #[cfg(feature = "trace_aggregation_update_stats")]
+            {
+                self.stats.optimize_task += 1;
+            }
             self.optimize_task(ctx, task_id);
             false
         } else if !self.find_and_schedule.is_empty() {
@@ -1247,9 +1445,18 @@ impl AggregationUpdateQueue {
                 .min(FIND_AND_SCHEDULE_BATCH_SIZE);
             let jobs: SmallVec<[FindAndScheduleJob; 4]> =
                 self.find_and_schedule.drain(..count).collect();
+            #[cfg(feature = "trace_aggregation_update_stats")]
+            {
+                self.stats.find_and_schedule_dirty_batches += 1;
+                self.stats.find_and_schedule_dirty += jobs.len();
+            }
             self.find_and_schedule_dirty(jobs, ctx);
             false
         } else if !self.scheduled_tasks.is_empty() {
+            #[cfg(feature = "trace_aggregation_update_stats")]
+            {
+                self.stats.schedule_task += self.scheduled_tasks.len();
+            }
             ctx.for_each_task_all(
                 self.scheduled_tasks.keys().copied(),
                 "schedule tasks",
@@ -1278,7 +1485,7 @@ impl AggregationUpdateQueue {
             upper_id,
             task_id,
             // For performance reasons this should stay `Meta` and not `All`
-            TaskDataCategory::Meta,
+            AGGREGATION_UPDATE_CATEGORY,
         );
         let upper_aggregation_number = get_aggregation_number(&upper);
         let task_aggregation_number = get_aggregation_number(&task);
@@ -1527,6 +1734,176 @@ impl AggregationUpdateQueue {
         );
     }
 
+    fn inner_of_upper_lost_follower(
+        &mut self,
+        ctx: &mut impl ExecuteContext<'_>,
+        lost_follower_id: TaskId,
+        upper_id: TaskId,
+        mut retry: u16,
+    ) {
+        #[cfg(feature = "trace_aggregation_update")]
+        let _span = trace_span!("lost follower").entered();
+
+        // see documentation of `retry_loop` for more information why this is needed
+        let result = retry_loop(retry, || {
+            // STEP 1
+            let mut follower = ctx.task(
+                lost_follower_id,
+                // For performance reasons this should stay `Meta` and not `All`
+                AGGREGATION_UPDATE_CATEGORY,
+            );
+
+            // STEP 2
+            let mut is_upper = true;
+            let mut removed_upper = false;
+
+            // STEP 3
+            follower.update_upper(upper_id, |old| {
+                let Some(old) = old else {
+                    is_upper = false;
+                    return None;
+                };
+                if old == 1 {
+                    removed_upper = true;
+                    return None;
+                }
+                Some(old - 1)
+            });
+
+            // STEP 4
+            if is_upper {
+                if removed_upper {
+                    let data = AggregatedDataUpdate::from_task(&mut follower).invert();
+                    let followers = get_followers(&follower);
+                    drop(follower);
+
+                    // STEP 5
+                    if !data.is_empty() {
+                        // remove data from upper
+                        let mut upper = ctx.task(
+                            upper_id,
+                            // For performance reasons this should stay `Meta` and not `All`
+                            AGGREGATION_UPDATE_CATEGORY,
+                        );
+                        // STEP 6
+                        let diff = data.apply(&mut upper, ctx.should_track_activeness(), self);
+                        if !diff.is_empty() {
+                            let upper_ids = get_uppers(&upper);
+                            self.push(
+                                AggregatedDataUpdateJob {
+                                    upper_ids,
+                                    update: diff,
+                                }
+                                .into(),
+                            )
+                        }
+                    }
+                    // STEP 7
+                    if !followers.is_empty() {
+                        self.push(AggregationUpdateJob::InnerOfUpperLostFollowers {
+                            upper_id,
+                            lost_follower_ids: followers,
+                            retry: 0,
+                        });
+                    }
+                } else {
+                    drop(follower);
+                }
+
+                // STEP 8
+                return ControlFlow::Break(());
+            }
+
+            drop(follower);
+
+            // STEP 9
+            let mut upper = ctx.task(
+                upper_id,
+                // For performance reasons this should stay `Meta` and not `All`
+                AGGREGATION_UPDATE_CATEGORY,
+            );
+            let mut is_follower = true;
+            let mut removed_follower = false;
+
+            // STEP 10
+            upper.update_followers(lost_follower_id, |old| {
+                let Some(old) = old else {
+                    is_follower = false;
+                    return None;
+                };
+                if old == 1 {
+                    removed_follower = true;
+                    return None;
+                }
+                Some(old - 1)
+            });
+
+            // STEP 11
+            if is_follower {
+                if removed_follower {
+                    // STEP 12
+                    // May optimize the task
+                    if upper.followers_len().is_power_of_two() {
+                        self.push_optimize_task(upper_id);
+                    }
+
+                    // STEP 13
+                    let has_active_count = ctx.should_track_activeness()
+                        && upper.get_activeness().is_some_and(|a| a.active_counter > 0);
+                    let upper_ids = get_uppers(&upper);
+                    drop(upper);
+
+                    // STEP 14
+                    // update active count
+                    if has_active_count {
+                        self.push(AggregationUpdateJob::DecreaseActiveCount {
+                            task: lost_follower_id,
+                        });
+                    }
+
+                    // STEP 15
+                    // notify uppers about lost follower
+                    if !upper_ids.is_empty() {
+                        self.push(AggregationUpdateJob::InnerOfUppersLostFollower {
+                            upper_ids,
+                            lost_follower_id,
+                            retry: 0,
+                        });
+                    }
+                } else {
+                    drop(upper);
+                }
+
+                // STEP 16
+                return ControlFlow::Break(());
+            }
+            ControlFlow::Continue(())
+        });
+
+        // STEP 17
+        if result.is_err() {
+            retry += 1;
+            if retry > MAX_RETRIES {
+                let lost_follower_description = ctx
+                    .task(lost_follower_id, TaskDataCategory::Data)
+                    .get_task_description();
+                let upper_description = ctx
+                    .task(upper_id, TaskDataCategory::Data)
+                    .get_task_description();
+                panic!(
+                    "inner_of_upper_lost_follower is not able to remove follower \
+                     {lost_follower_id} ({lost_follower_description}) from {upper_id} \
+                     {upper_description} as it doesn't exist as upper or follower edges",
+                );
+            }
+            self.push(AggregationUpdateJob::InnerOfUpperLostFollower {
+                upper_id,
+                lost_follower_id,
+                retry,
+            });
+        }
+    }
+
     fn inner_of_uppers_lost_follower(
         &mut self,
         ctx: &mut impl ExecuteContext<'_>,
@@ -1543,7 +1920,7 @@ impl AggregationUpdateQueue {
             let mut follower = ctx.task(
                 lost_follower_id,
                 // For performance reasons this should stay `Meta` and not `All`
-                TaskDataCategory::Meta,
+                AGGREGATION_UPDATE_CATEGORY,
             );
 
             // STEP 2
@@ -1620,7 +1997,7 @@ impl AggregationUpdateQueue {
                 let mut upper = ctx.task(
                     upper_id,
                     // For performance reasons this should stay `Meta` and not `All`
-                    TaskDataCategory::Meta,
+                    AGGREGATION_UPDATE_CATEGORY,
                 );
                 let mut not_a_follower = false;
                 let mut removed_follower = false;
@@ -1733,7 +2110,7 @@ impl AggregationUpdateQueue {
                 let mut follower = ctx.task(
                     lost_follower_id,
                     // For performance reasons this should stay `Meta` and not `All`
-                    TaskDataCategory::Meta,
+                    AGGREGATION_UPDATE_CATEGORY,
                 );
 
                 // STEP 2
@@ -1765,7 +2142,7 @@ impl AggregationUpdateQueue {
                         let mut upper = ctx.task(
                             upper_id,
                             // For performance reasons this should stay `Meta` and not `All`
-                            TaskDataCategory::Meta,
+                            AGGREGATION_UPDATE_CATEGORY,
                         );
                         // STEP 6
                         let diff = data.apply(&mut upper, ctx.should_track_activeness(), self);
@@ -1805,7 +2182,7 @@ impl AggregationUpdateQueue {
             let mut upper = ctx.task(
                 upper_id,
                 // For performance reasons this should stay `Meta` and not `All`
-                TaskDataCategory::Meta,
+                AGGREGATION_UPDATE_CATEGORY,
             );
             swap_retain(&mut lost_follower_ids, |&mut lost_follower_id| {
                 let mut not_a_follower = false;
@@ -1924,7 +2301,7 @@ impl AggregationUpdateQueue {
             let follower = ctx.task(
                 new_follower_id,
                 // For performance reasons this should stay `Meta` and not `All`
-                TaskDataCategory::Meta,
+                AGGREGATION_UPDATE_CATEGORY,
             );
             get_aggregation_number(&follower)
         };
@@ -1940,7 +2317,7 @@ impl AggregationUpdateQueue {
                 let mut upper = ctx.task(
                     upper_id,
                     // For performance reasons this should stay `Meta` and not `All`
-                    TaskDataCategory::Meta,
+                    AGGREGATION_UPDATE_CATEGORY,
                 );
                 // decide if it should be an inner or follower
                 let upper_aggregation_number = get_aggregation_number(&upper);
@@ -2011,7 +2388,7 @@ impl AggregationUpdateQueue {
             let mut new_follower = ctx.task(
                 new_follower_id,
                 // For performance reasons this should stay `Meta` and not `All`
-                TaskDataCategory::Meta,
+                AGGREGATION_UPDATE_CATEGORY,
             );
             let follower_aggregation_number = get_aggregation_number(&new_follower);
 
@@ -2172,7 +2549,7 @@ impl AggregationUpdateQueue {
                 let follower = ctx.task(
                     new_follower_id,
                     // For performance reasons this should stay `Meta` and not `All`
-                    TaskDataCategory::Meta,
+                    AGGREGATION_UPDATE_CATEGORY,
                 );
                 (new_follower_id, count, get_aggregation_number(&follower))
             })
@@ -2192,7 +2569,7 @@ impl AggregationUpdateQueue {
                 let mut upper = ctx.task(
                     upper_id,
                     // For performance reasons this should stay `Meta` and not `All`
-                    TaskDataCategory::Meta,
+                    AGGREGATION_UPDATE_CATEGORY,
                 );
 
                 // decide if it should be an inner or follower
@@ -2289,7 +2666,7 @@ impl AggregationUpdateQueue {
                     let mut new_follower = ctx.task(
                         new_follower_id,
                         // For performance reasons this should stay `Meta` and not `All`
-                        TaskDataCategory::Meta,
+                        AGGREGATION_UPDATE_CATEGORY,
                     );
                     let follower_aggregation_number = get_aggregation_number(&new_follower);
 
@@ -2347,7 +2724,7 @@ impl AggregationUpdateQueue {
             let mut upper = ctx.task(
                 upper_id,
                 // For performance reasons this should stay `Meta` and not `All`
-                TaskDataCategory::Meta,
+                AGGREGATION_UPDATE_CATEGORY,
             );
             let diffs = upper_data_updates
                 .into_iter()
@@ -2388,7 +2765,7 @@ impl AggregationUpdateQueue {
                 let upper = ctx.task(
                     upper_id,
                     // For performance reasons this should stay `Meta` and not `All`
-                    TaskDataCategory::Meta,
+                    AGGREGATION_UPDATE_CATEGORY,
                 );
                 is_active = upper.has_activeness();
             }
@@ -2417,7 +2794,7 @@ impl AggregationUpdateQueue {
             let follower = ctx.task(
                 new_follower_id,
                 // For performance reasons this should stay `Meta` and not `All`
-                TaskDataCategory::Meta,
+                AGGREGATION_UPDATE_CATEGORY,
             );
             get_aggregation_number(&follower)
         };
@@ -2434,7 +2811,7 @@ impl AggregationUpdateQueue {
             let mut upper = ctx.task(
                 upper_id,
                 // For performance reasons this should stay `Meta` and not `All`
-                TaskDataCategory::Meta,
+                AGGREGATION_UPDATE_CATEGORY,
             );
             // decide if it should be an inner or follower
             let upper_aggregation_number = get_aggregation_number(&upper);
@@ -2502,7 +2879,7 @@ impl AggregationUpdateQueue {
             let mut new_follower = ctx.task(
                 new_follower_id,
                 // For performance reasons this should stay `Meta` and not `All`
-                TaskDataCategory::Meta,
+                AGGREGATION_UPDATE_CATEGORY,
             );
             let follower_aggregation_number = get_aggregation_number(&new_follower);
 
@@ -2532,7 +2909,7 @@ impl AggregationUpdateQueue {
                         let mut upper = ctx.task(
                             upper_id,
                             // For performance reasons this should stay `Meta` and not `All`
-                            TaskDataCategory::Meta,
+                            AGGREGATION_UPDATE_CATEGORY,
                         );
                         let diff = data.apply(&mut upper, ctx.should_track_activeness(), self);
                         if !diff.is_empty() {
@@ -2560,7 +2937,7 @@ impl AggregationUpdateQueue {
                         let upper = ctx.task(
                             upper_id,
                             // For performance reasons this should stay `Meta` and not `All`
-                            TaskDataCategory::Meta,
+                            AGGREGATION_UPDATE_CATEGORY,
                         );
                         is_active = upper.has_activeness();
                     }
@@ -2586,7 +2963,7 @@ impl AggregationUpdateQueue {
         let mut task = ctx.task(
             task_id,
             // For performance reasons this should stay `Meta` and not `All`
-            TaskDataCategory::Meta,
+            AGGREGATION_UPDATE_CATEGORY,
         );
         let state = task.get_activeness_mut_or_insert_with(|| ActivenessState::new(task_id));
         let is_new = state.is_empty();
@@ -2631,7 +3008,7 @@ impl AggregationUpdateQueue {
             task_id,
             // For performance reasons this should stay Meta and not All.
             // persistent_task_type is now set eagerly in initialize_new_task.
-            TaskDataCategory::Meta,
+            AGGREGATION_UPDATE_CATEGORY,
         );
         let state = task.get_activeness_mut_or_insert_with(|| ActivenessState::new(task_id));
         let is_new = state.is_empty();
@@ -2678,7 +3055,7 @@ impl AggregationUpdateQueue {
         let mut task = ctx.task(
             task_id,
             // For performance reasons this should stay `Meta` and not `All`
-            TaskDataCategory::Meta,
+            AGGREGATION_UPDATE_CATEGORY,
         );
         let current = task.get_aggregation_number().copied().unwrap_or_default();
         let old = current.effective;
@@ -2710,7 +3087,7 @@ impl AggregationUpdateQueue {
             #[cfg(feature = "trace_aggregation_update")]
             let _span = trace_span!(
                 "update aggregation number",
-                task = ctx.get_task_description(task_id),
+                task = task.get_task_description(),
                 old,
                 aggregation_number
             )
@@ -2883,6 +3260,29 @@ impl AggregationUpdateQueue {
             self.push_optimize_task(task_id);
         }
     }
+
+    #[cfg(feature = "trace_aggregation_update_stats")]
+    pub fn execute_with_stats(
+        mut self,
+        ctx: &mut impl ExecuteContext<'_>,
+    ) -> AggregationUpdateQueueStats {
+        loop {
+            ctx.operation_suspend_point(&self);
+            if self.process(ctx) {
+                return self.stats;
+            }
+        }
+    }
+
+    #[cfg(not(feature = "trace_aggregation_update_stats"))]
+    pub fn execute_with_stats(mut self, ctx: &mut impl ExecuteContext<'_>) {
+        loop {
+            ctx.operation_suspend_point(&self);
+            if self.process(ctx) {
+                return;
+            }
+        }
+    }
 }
 
 impl Operation for AggregationUpdateQueue {
diff --git a/turbopack/crates/turbo-tasks-backend/src/backend/operation/cleanup_old_edges.rs b/turbopack/crates/turbo-tasks-backend/src/backend/operation/cleanup_old_edges.rs
index 4acffba837e..aa544b63278 100644
--- a/turbopack/crates/turbo-tasks-backend/src/backend/operation/cleanup_old_edges.rs
+++ b/turbopack/crates/turbo-tasks-backend/src/backend/operation/cleanup_old_edges.rs
@@ -20,7 +20,7 @@ use crate::{
     data::{CellRef, CollectibleRef, CollectiblesRef},
 };
 
-#[derive(Encode, Decode, Clone, Default)]
+#[derive(Encode, Decode, Clone)]
 pub enum CleanupOldEdgesOperation {
     RemoveEdges {
         task_id: TaskId,
@@ -30,11 +30,20 @@ pub enum CleanupOldEdgesOperation {
     AggregationUpdate {
         queue: AggregationUpdateQueue,
     },
-    #[default]
-    Done,
+    Done {
+        stats: Stats,
+    },
     // TODO Add aggregated edge
 }
 
+impl Default for CleanupOldEdgesOperation {
+    fn default() -> Self {
+        Self::Done {
+            stats: Default::default(),
+        }
+    }
+}
+
 #[derive(Encode, Decode, Clone)]
 pub enum OutdatedEdge {
     Child(TaskId),
@@ -44,24 +53,27 @@ pub enum OutdatedEdge {
     CollectiblesDependency(CollectiblesRef),
 }
 
+#[cfg(feature = "trace_aggregation_update_stats")]
+type Stats = super::aggregation_update::AggregationUpdateQueueStats;
+#[cfg(not(feature = "trace_aggregation_update_stats"))]
+type Stats = ();
+
 impl CleanupOldEdgesOperation {
     pub fn run(
         task_id: TaskId,
         outdated: Vec<OutdatedEdge>,
         queue: AggregationUpdateQueue,
         ctx: &mut impl ExecuteContext<'_>,
-    ) {
+    ) -> Stats {
         CleanupOldEdgesOperation::RemoveEdges {
             task_id,
             outdated,
             queue,
         }
-        .execute(ctx);
+        .execute_with_stats(ctx)
     }
-}
 
-impl Operation for CleanupOldEdgesOperation {
-    fn execute(mut self, ctx: &mut impl ExecuteContext<'_>) {
+    fn execute_with_stats(mut self, ctx: &mut impl ExecuteContext<'_>) -> Stats {
         loop {
             ctx.operation_suspend_point(&self);
             match self {
@@ -222,13 +234,24 @@ impl Operation for CleanupOldEdgesOperation {
                 }
                 CleanupOldEdgesOperation::AggregationUpdate { ref mut queue } => {
                     if queue.process(ctx) {
-                        self = CleanupOldEdgesOperation::Done;
+                        self = CleanupOldEdgesOperation::Done {
+                            #[cfg(feature = "trace_aggregation_update_stats")]
+                            stats: take(&mut queue.stats),
+                            #[cfg(not(feature = "trace_aggregation_update_stats"))]
+                            stats: (),
+                        };
                     }
                 }
-                CleanupOldEdgesOperation::Done => {
-                    return;
+                CleanupOldEdgesOperation::Done { stats } => {
+                    return stats;
                 }
             }
         }
     }
 }
+
+impl Operation for CleanupOldEdgesOperation {
+    fn execute(self, ctx: &mut impl ExecuteContext<'_>) {
+        self.execute_with_stats(ctx);
+    }
+}
diff --git a/turbopack/crates/turbo-tasks-backend/src/backend/operation/connect_children.rs b/turbopack/crates/turbo-tasks-backend/src/backend/operation/connect_children.rs
index c4db6a67d36..d5335b32560 100644
--- a/turbopack/crates/turbo-tasks-backend/src/backend/operation/connect_children.rs
+++ b/turbopack/crates/turbo-tasks-backend/src/backend/operation/connect_children.rs
@@ -109,8 +109,18 @@ pub fn connect_children(
         }
 
         {
-            #[cfg(feature = "trace_task_completion")]
-            let _span = tracing::trace_span!("connect new children").entered();
+            #[cfg(any(
+                feature = "trace_task_completion",
+                feature = "trace_aggregation_update_stats"
+            ))]
+            let _span = tracing::trace_span!("connect new children", stats = tracing::field::Empty)
+                .entered();
+            #[cfg(feature = "trace_aggregation_update_stats")]
+            {
+                let stats = queue.execute_with_stats(ctx);
+                _span.record("stats", tracing::field::debug(stats));
+            }
+            #[cfg(not(feature = "trace_aggregation_update_stats"))]
             queue.execute(ctx);
         }
     }
diff --git a/turbopack/crates/turbo-tasks-macros/src/ident.rs b/turbopack/crates/turbo-tasks-macros/src/ident.rs
index 38d24469f31..7ba863c712f 100644
--- a/turbopack/crates/turbo-tasks-macros/src/ident.rs
+++ b/turbopack/crates/turbo-tasks-macros/src/ident.rs
@@ -1,13 +1,6 @@
 use quote::ToTokens;
 use syn::{GenericArgument, Ident, Path, PathArguments, Type, TypeParamBound, spanned::Spanned};
 
-pub fn get_cast_to_fat_pointer_ident(trait_ident: &Ident, struct_ident: &Ident) -> Ident {
-    Ident::new(
-        &format!("_cast_to_fat_pointer_{struct_ident}_{trait_ident}"),
-        trait_ident.span(),
-    )
-}
-
 pub fn get_native_function_ident(ident: &Ident) -> Ident {
     Ident::new(
         &format!("{}_FUNCTION", ident.to_string().to_uppercase()),
@@ -22,6 +15,21 @@ pub fn get_trait_type_ident(ident: &Ident) -> Ident {
     )
 }
 
+/// Name of the per-trait `VTableRegistry` static, populated by `#[ctor::ctor]` functions emitted
+/// by each `value_impl` expansion.
+pub fn get_trait_vtable_registry_ident(ident: &Ident) -> Ident {
+    Ident::new(&format!("__TurboTasksVTableRegistry_{ident}"), ident.span())
+}
+
+/// Name of the `#[ctor::ctor]` function that registers a per-impl vtable into its trait's
+/// registry. Unique per (concrete-type, trait) pair.
+pub fn get_vtable_register_fn_ident(struct_ident: &Ident, trait_ident: &Ident) -> Ident {
+    Ident::new(
+        &format!("__turbo_tasks_vtable_register_{struct_ident}_{trait_ident}"),
+        trait_ident.span(),
+    )
+}
+
 pub fn get_inherent_impl_function_ident(ty_ident: &Ident, fn_ident: &Ident) -> Ident {
     Ident::new(
         &format!(
diff --git a/turbopack/crates/turbo-tasks-macros/src/value_impl_macro.rs b/turbopack/crates/turbo-tasks-macros/src/value_impl_macro.rs
index fe3d6b58f16..7c61b712a8f 100644
--- a/turbopack/crates/turbo-tasks-macros/src/value_impl_macro.rs
+++ b/turbopack/crates/turbo-tasks-macros/src/value_impl_macro.rs
@@ -16,8 +16,8 @@ use crate::{
     },
     global_name::{global_name_for_method, global_name_for_trait_method_impl},
     ident::{
-        get_cast_to_fat_pointer_ident, get_inherent_impl_function_ident, get_path_ident,
-        get_trait_impl_function_ident, get_type_ident,
+        get_inherent_impl_function_ident, get_path_ident, get_trait_impl_function_ident,
+        get_type_ident, get_vtable_register_fn_ident,
     },
     self_filter::is_self_used,
 };
@@ -173,12 +173,10 @@ pub fn value_impl(args: TokenStream, input: TokenStream) -> TokenStream {
         items: &[ImplItem],
     ) -> TokenStream2 {
         let trait_ident = get_path_ident(trait_path);
+        let vtable_register_ident = get_vtable_register_fn_ident(ty_ident, &trait_ident);
 
         let (impl_generics, _, where_clause) = generics.split_for_impl();
 
-        let cast_to_fat_pointer_ident: Ident =
-            get_cast_to_fat_pointer_ident(&trait_ident, ty_ident);
-
         let mut trait_methods = Vec::new();
         let mut trait_functions = Vec::with_capacity(items.len());
         let mut trait_items = Vec::new();
@@ -299,23 +297,34 @@ pub fn value_impl(args: TokenStream, input: TokenStream) -> TokenStream {
                     value_type: <#ty as turbo_tasks::macro_helpers::RegistryDef::<turbo_tasks::ValueType>>::DEF,
                     trait_type: <::std::boxed::Box<dyn #trait_path> as turbo_tasks::macro_helpers::RegistryDef::<turbo_tasks::TraitType>>::DEF,
                     methods: &METHODS,
+                    finalize_vtable_registry: || {
+                        <::std::boxed::Box<dyn #trait_path> as turbo_tasks::VcValueTrait>::IMPL_VTABLES
+                            .finalize();
+                    },
                 }
             }}
 
-            // These can execute later so they can reference trait_types during registration
-
-            turbo_tasks::macro_helpers::inventory_submit!{
-                turbo_tasks::macro_helpers::CollectableTraitCastFunctions(
-                    <::std::boxed::Box<dyn #trait_path> as turbo_tasks::VcValueTrait>::get_trait_type_id,
-                    <#ty as turbo_tasks::VcValueType>::get_value_type_id,
-                    #cast_to_fat_pointer_ident as *const ()
-                )
-            }
-
+            // Queue this `impl Trait for Concrete` into the trait's `VTableRegistry` at program
+            // load. The ctor runs before `ValueType` ids are assigned, so it just appends to a
+            // `Vec`; the map keyed by `ValueTypeId` is built lazily inside the `VALUES`
+            // `LazyLock` initializer (via `CollectableTraitMethods::finalize_vtable_registry`).
+            // The vtable pointer is materialized at compile time via the null-fat-ptr trick, so
+            // there's no runtime `transmute` or indirect fn call.
+            #[turbo_tasks::macro_helpers::ctor::ctor(
+                crate_path = turbo_tasks::macro_helpers::ctor,
+            )]
             #[allow(non_snake_case)]
-            fn #cast_to_fat_pointer_ident(raw: * const ()) -> *const dyn #trait_path {
-                let typed = raw as *const #ty;
-                typed as *const dyn #trait_path
+            fn #vtable_register_ident() {
+                <::std::boxed::Box<dyn #trait_path> as turbo_tasks::VcValueTrait>::IMPL_VTABLES
+                    .register(
+                        <#ty as turbo_tasks::macro_helpers::RegistryDef::<turbo_tasks::ValueType>>::DEF,
+                        {
+                            let p: *const #ty = ::std::ptr::null();
+                            // This attaches a fat pointer to the null pointer.
+                            let fat: *const dyn #trait_path = p;
+                            fat
+                        },
+                    );
             }
 
             // NOTE(alexkirsz) We can't have a general `turbo_tasks::Upcast<Box<dyn Trait>> for T where T: Trait` because
diff --git a/turbopack/crates/turbo-tasks-macros/src/value_trait_macro.rs b/turbopack/crates/turbo-tasks-macros/src/value_trait_macro.rs
index b9887cf39ec..152c17a1e46 100644
--- a/turbopack/crates/turbo-tasks-macros/src/value_trait_macro.rs
+++ b/turbopack/crates/turbo-tasks-macros/src/value_trait_macro.rs
@@ -11,7 +11,10 @@ use crate::{
         get_receiver_style, split_function_attributes,
     },
     global_name::{global_name_for_trait_method, global_name_for_type},
-    ident::{get_trait_default_impl_function_ident, get_trait_type_ident},
+    ident::{
+        get_trait_default_impl_function_ident, get_trait_type_ident,
+        get_trait_vtable_registry_ident,
+    },
     self_filter::is_self_used,
     value_trait_arguments::ValueTraitArguments,
 };
@@ -67,6 +70,7 @@ pub fn value_trait(args: TokenStream, input: TokenStream) -> TokenStream {
     let supertraits = supertraits.iter().collect::<Vec<_>>();
 
     let trait_type_ident = get_trait_type_ident(trait_ident);
+    let trait_vtable_registry_ident = get_trait_vtable_registry_ident(trait_ident);
     let mut dynamic_trait_fns = Vec::new();
     let mut trait_methods: Vec<TokenStream2> = Vec::new();
     let mut default_methods: Vec<TokenStream2> = Vec::new();
@@ -335,21 +339,26 @@ pub fn value_trait(args: TokenStream, input: TokenStream) -> TokenStream {
             const DEFAULTS: &[Option<&turbo_tasks::macro_helpers::NativeFunction>] = &[#(#default_methods),*];
         }
 
+        // Per-trait `VTableRegistry`, populated during the ctor phase by `value_impl`
+        // expansions. `const`-constructible, so no `LazyLock` / first-access init. Kept
+        // private — the only reference is from the `VcValueTrait::IMPL_VTABLES` assoc const
+        // below.
+        #[doc(hidden)]
+        #[allow(non_upper_case_globals)]
+        static #trait_vtable_registry_ident:
+            turbo_tasks::macro_helpers::VTableRegistry<dyn #trait_ident> =
+            turbo_tasks::macro_helpers::VTableRegistry::new();
+
         #[automatically_derived]
         impl turbo_tasks::VcValueTrait for Box<dyn #trait_ident> {
             type ValueTrait = dyn #trait_ident;
 
+            const IMPL_VTABLES: &'static turbo_tasks::macro_helpers::VTableRegistry<Self::ValueTrait> =
+                &#trait_vtable_registry_ident;
+
             fn get_trait_type_id() -> turbo_tasks::TraitTypeId {
                 turbo_tasks::registry::get_trait_type_id(&#trait_type_ident)
             }
-
-            // TODO: Remove this Lazy VTableRegistry once trait resolution is fully migrated
-            fn get_impl_vtables() -> &'static turbo_tasks::macro_helpers::VTableRegistry<Self::ValueTrait> {
-                static registry: ::std::sync::LazyLock<turbo_tasks::macro_helpers::VTableRegistry<dyn # trait_ident>> =
-                    ::std::sync::LazyLock::new(|| turbo_tasks::macro_helpers::VTableRegistry::new(turbo_tasks::registry::get_trait_type_id(&#trait_type_ident)));
-
-                &*registry
-            }
         }
 
         #[automatically_derived]
diff --git a/turbopack/crates/turbo-tasks/Cargo.toml b/turbopack/crates/turbo-tasks/Cargo.toml
index 77c50eac1e7..4e5f4627001 100644
--- a/turbopack/crates/turbo-tasks/Cargo.toml
+++ b/turbopack/crates/turbo-tasks/Cargo.toml
@@ -28,6 +28,7 @@ async-trait = { workspace = true }
 auto-hash-map = { workspace = true }
 bincode = { workspace = true }
 concurrent-queue = { workspace = true }
+ctor = { workspace = true }
 dashmap = { workspace = true }
 either = { workspace = true }
 erased-serde = { workspace = true }
diff --git a/turbopack/crates/turbo-tasks/src/macro_helpers.rs b/turbopack/crates/turbo-tasks/src/macro_helpers.rs
index ade287f15ba..309cbca218e 100644
--- a/turbopack/crates/turbo-tasks/src/macro_helpers.rs
+++ b/turbopack/crates/turbo-tasks/src/macro_helpers.rs
@@ -1,9 +1,13 @@
 //! Runtime helpers for [turbo-tasks-macro].
 
-use std::sync::LazyLock;
+use std::{
+    cell::SyncUnsafeCell,
+    ptr::{DynMetadata, Pointee},
+};
 
 pub use async_trait::async_trait;
 pub use bincode;
+pub use ctor;
 pub use inventory;
 use rustc_hash::FxHashMap;
 pub use shrink_to_fit;
@@ -11,10 +15,7 @@ pub use tracing;
 
 #[cfg(debug_assertions)]
 use crate::debug::ValueDebugFormatString;
-use crate::{
-    FxDashMap, NonLocalValue, RawVc, TaskInput, TaskPersistence, TraitType, TraitTypeId, ValueType,
-    ValueTypeId,
-};
+use crate::{NonLocalValue, RawVc, TaskInput, TaskPersistence, TraitType, ValueType, ValueTypeId};
 pub use crate::{
     dyn_task_inputs::DynTaskInputs,
     global_name_for_method, global_name_for_scope, global_name_for_trait_method,
@@ -70,7 +71,7 @@ macro_rules! stringify_path {
 /// Rexport std::ptr::metadata so not every crate needs to enable the feature when they use our
 /// macros.
 #[inline(always)]
-pub const fn metadata<T: ?Sized>(ptr: *const T) -> <T as std::ptr::Pointee>::Metadata {
+pub const fn metadata<T: ?Sized>(ptr: *const T) -> <T as Pointee>::Metadata {
     // Ideally we would just `pub use std::ptr::metadata;` but this doesn't seem to work.
     std::ptr::metadata(ptr)
 }
@@ -160,83 +161,131 @@ pub const fn strip_trailing_segments(s: &str, count: usize) -> &str {
     remaining
 }
 
-/// A registry of all the impl vtables for a given VcValue trait
-/// This is constructed in the macro gencode and populated by the registry.
-#[derive(Default)]
-pub struct VTableRegistry<T: ?Sized> {
-    map: FxHashMap<ValueTypeId, <T as std::ptr::Pointee>::Metadata>,
+/// A registry of all the impl vtables for a given VcValue trait.
+///
+/// `const`-constructed as a plain `static`. Populated in two phases:
+///
+/// 1. **ctor phase** (before `main`): `value_impl`-emitted `#[ctor::ctor]` functions push
+///    `(value_type, DynMetadata)` pairs into `pending`. `ValueType` ids are not yet assigned here —
+///    we just accumulate.
+/// 2. **`finalize` phase** (inside the `VALUES` `LazyLock` initializer, after ids are assigned):
+///    `pending` is drained into `inner`, keyed by `ValueTypeId`. Idempotent.
+///
+/// After finalize, the cast path is a single hashmap `.get()` keyed by `u16` — no `LazyLock`
+/// check, no `get_value_type(id)` indirection. The vtable pointer for each
+/// `impl Trait for Concrete` is materialized at compile time, so there's no runtime `transmute`
+/// or indirect fn-pointer call either.
+pub struct VTableRegistry<T>
+where
+    T: Pointee<Metadata = DynMetadata<T>> + ?Sized,
+{
+    /// Accumulator written from ctors. `Some` until `finalize` runs, then `take`n and left
+    /// `None` so any post-finalize call to `register` panics rather than silently dropping
+    /// the registration. The `None` state also makes subsequent `finalize` calls cheap no-ops.
+    #[allow(clippy::type_complexity)]
+    pending: SyncUnsafeCell<Option<Vec<(&'static ValueType, DynMetadata<T>)>>>,
+    /// Built once by `finalize`, read-only thereafter. `None` until finalize runs.
+    inner: SyncUnsafeCell<Option<FxHashMap<ValueTypeId, DynMetadata<T>>>>,
 }
 
-impl<T: ?Sized> VTableRegistry<T> {
-    pub fn new(id: TraitTypeId) -> Self {
-        let mut map = FxHashMap::default();
-        match TRAIT_CAST_FNS.remove(&id) {
-            Some((_, impls)) => {
-                for (value_type_id, RawPtr(raw_fn)) in impls {
-                    // SAFETY: These are generated by the macro gencode in value_impl with this
-                    // signature.
-                    let cast_fn: fn(*const ()) -> *const T = unsafe { std::mem::transmute(raw_fn) };
-                    // Cast a null pointer to a fat pointer using the cast_fn, this allows us to
-                    // capture a vtable Alternatively we could just store the
-                    // cast functions but it will be faster to call 'from_raw_parts' instead of an
-                    // indirect function call.
-                    let ptr = cast_fn(std::ptr::null::<()>());
-                    let metadata = std::ptr::metadata(ptr);
-                    let prev = map.insert(value_type_id, metadata);
-                    debug_assert!(
-                        prev.is_none(),
-                        "multiple cast functions registered for {value_type_id}"
-                    )
-                }
-            }
-            None => {
-                // A trait doesn't have to have any implementations.
-            }
+// SAFETY: writes to `pending` happen only from `#[ctor::ctor]` functions, which run serially on
+// the main thread before `main`. Writes to `inner` happen only from `finalize`, which runs once
+// inside the `VALUES` `LazyLock` initializer (synchronized by the `LazyLock`). Reads of `inner`
+// from `cast` are published by that same `LazyLock` — see the `cast` safety comment.
+unsafe impl<T> Sync for VTableRegistry<T> where T: Pointee<Metadata = DynMetadata<T>> + ?Sized {}
+
+impl<T> VTableRegistry<T>
+where
+    T: Pointee<Metadata = DynMetadata<T>> + ?Sized,
+{
+    pub const fn new() -> Self {
+        Self {
+            pending: SyncUnsafeCell::new(Some(Vec::new())),
+            inner: SyncUnsafeCell::new(None),
         }
+    }
 
-        Self { map }
+    /// Queue an `impl Trait for Concrete` registration. Called from a `#[ctor::ctor]` function
+    /// at program load, before `ValueType` ids are assigned. The actual map is built later by
+    /// [`Self::finalize`].
+    ///
+    /// Panics if called after `finalize`. Since all `value_impl` ctors run before `main` and
+    /// `finalize` runs lazily after `main`, this should be unreachable in normal use; the
+    /// panic guards against future changes that might violate that ordering.
+    pub fn register(&'static self, value_type: &'static ValueType, fat_ptr: *const T) {
+        // SAFETY: ctors run single-threaded at load; no concurrent readers or writers.
+        let pending = unsafe { &mut *self.pending.get() };
+        let Some(pending) = pending.as_mut() else {
+            panic!("VTableRegistry::register called after finalize for {value_type}");
+        };
+        pending.push((value_type, std::ptr::metadata(fat_ptr)));
+    }
+
+    /// Take `pending` into `inner`, resolving each `&'static ValueType` to its assigned
+    /// `ValueTypeId`. Must be called after `VALUES` ids are assigned (i.e. from inside the
+    /// `VALUES` `LazyLock` initializer). Idempotent: a second call is a no-op, which lets
+    /// `register_all_trait_methods` invoke `finalize_vtable_registry` once per impl without
+    /// having to dedup.
+    pub fn finalize(&'static self) {
+        // SAFETY: invoked from inside the `VALUES` `LazyLock` initializer (single-threaded
+        // section synchronized by the `LazyLock`). All ctors completed before `main`.
+        let pending = unsafe { &mut *self.pending.get() };
+        // `take` makes any later `register` call (which would otherwise be silently dropped)
+        // hit the `None` branch and panic; subsequent `finalize` calls also short-circuit here.
+        let Some(pending) = pending.take() else {
+            return;
+        };
+        let inner = unsafe { &mut *self.inner.get() };
+        debug_assert!(inner.is_none(), "inner already populated");
+        let mut map = FxHashMap::with_capacity_and_hasher(pending.len(), Default::default());
+        for (value_type, metadata) in pending {
+            // SAFETY: we're called from inside the `VALUES` `LazyLock` initializer, after
+            // `init_registry` has assigned ids. Calling `get_value_type_id` here would re-enter
+            // `LazyLock::force` and deadlock; read the id cell directly instead.
+            let id = unsafe { crate::registry::get_value_type_id_unchecked(value_type) };
+            let prev = map.insert(id, metadata);
+            debug_assert!(
+                prev.is_none(),
+                "multiple trait impls registered for {value_type}"
+            );
+        }
+        *inner = Some(map);
     }
 
     pub(crate) fn cast(&self, id: ValueTypeId, raw: *const ()) -> *const T {
-        let metadata = self.map.get(&id).unwrap();
+        // SAFETY: any caller in possession of a `ValueTypeId` must have already forced the
+        // `VALUES` `LazyLock` (that's the only way to obtain one). `finalize` ran inside that
+        // initializer, so its write to `inner` happens-before this read via the `LazyLock`'s
+        // acquire fence.
+        let inner = unsafe { &*self.inner.get() };
+        let Some(metadata) = inner.as_ref().and_then(|map| map.get(&id)) else {
+            panic!(
+                "no trait impl registered for value type {}",
+                crate::registry::get_value_type(id)
+            )
+        };
         std::ptr::from_raw_parts(raw, *metadata)
     }
 }
 
-struct RawPtr(*const ());
-// SAFETY: We only store function pointers in here which are safe to send/sync
-unsafe impl Sync for RawPtr {}
-unsafe impl Send for RawPtr {}
-
-// Accumulate all trait impls by trait id
-static TRAIT_CAST_FNS: LazyLock<FxDashMap<TraitTypeId, Vec<(ValueTypeId, RawPtr)>>> =
-    LazyLock::new(|| {
-        let map: FxDashMap<TraitTypeId, Vec<(ValueTypeId, RawPtr)>> = FxDashMap::default();
-        for CollectableTraitCastFunctions(trait_id_fn, value_id_fn, cast_fn) in
-            inventory::iter::<CollectableTraitCastFunctions>
-        {
-            map.entry(trait_id_fn())
-                .or_default()
-                .value_mut()
-                .push((value_id_fn(), RawPtr(*cast_fn)));
-        }
-        map
-    });
-
-// Holds a raw pointer to a function that can perform a fat pointer cast
-pub struct CollectableTraitCastFunctions(
-    pub fn() -> TraitTypeId,
-    pub fn() -> ValueTypeId,
-    pub *const (),
-);
-// SAFETY: We only store function pointers in here.
-unsafe impl Sync for CollectableTraitCastFunctions {}
-inventory::collect! {CollectableTraitCastFunctions}
+impl<T> Default for VTableRegistry<T>
+where
+    T: Pointee<Metadata = DynMetadata<T>> + ?Sized,
+{
+    fn default() -> Self {
+        Self::new()
+    }
+}
 
 pub struct CollectableTraitMethods {
     pub value_type: &'static ValueType,
     pub trait_type: &'static TraitType,
     pub methods: &'static [&'static NativeFunction],
+    /// Calls `<Box<dyn Trait>>::IMPL_VTABLES.finalize()` for the trait this entry corresponds
+    /// to. Invoked from `register_all_trait_methods` after `VALUES` ids are assigned. The same
+    /// trait's registry will be finalized once per impl, but `VTableRegistry::finalize` is
+    /// idempotent.
+    pub finalize_vtable_registry: fn(),
 }
 inventory::collect! {CollectableTraitMethods}
 
diff --git a/turbopack/crates/turbo-tasks/src/registry/mod.rs b/turbopack/crates/turbo-tasks/src/registry/mod.rs
index b5957bd7e49..d810443d8a1 100644
--- a/turbopack/crates/turbo-tasks/src/registry/mod.rs
+++ b/turbopack/crates/turbo-tasks/src/registry/mod.rs
@@ -137,12 +137,15 @@ fn get_item<T: Registerable>(registry: &LazyLock<Box<[&'static T]>>, id: T::Id)
     registry[*id as usize - 1]
 }
 
-/// Get the ID for a registered item. Forces registry init if needed, which
-/// assigns IDs to all items as a side effect.
+/// Read an item's assigned id directly, without touching `LazyLock`.
+///
+/// # Safety
+///
+/// Caller must guarantee that `init_registry` has already written the id for this `item`.
 #[inline]
-fn get_id<T: Registerable>(registry: &LazyLock<Box<[&'static T]>>, item: &'static T) -> T::Id {
-    LazyLock::force(registry);
-    // SAFETY: The ID write happens-before this read thanks to the fence inside of LazyLock
+unsafe fn get_id_unchecked<T: Registerable>(item: &'static T) -> T::Id {
+    // SAFETY: caller guarantees the id has been written. The write and this read are both
+    // inside the registry's single-threaded lazy init.
     let n = unsafe { std::ptr::read(item.ty().id.get()) };
     let Some(id) = NonZeroU16::new(n) else {
         panic!(
@@ -154,6 +157,15 @@ fn get_id<T: Registerable>(registry: &LazyLock<Box<[&'static T]>>, item: &'stati
     T::Id::from(id)
 }
 
+/// Get the ID for a registered item. Forces registry init if needed, which
+/// assigns IDs to all items as a side effect.
+#[inline]
+fn get_id<T: Registerable>(registry: &LazyLock<Box<[&'static T]>>, item: &'static T) -> T::Id {
+    LazyLock::force(registry);
+    // SAFETY: The ID write happens-before this read thanks to the fence inside of LazyLock
+    unsafe { get_id_unchecked(item) }
+}
+
 /// Validate that an ID is within the valid range
 fn validate_id<T: Registerable>(
     registry: &LazyLock<Box<[&'static T]>>,
@@ -209,6 +221,20 @@ pub fn get_value_type_id(value: &'static ValueType) -> ValueTypeId {
     get_id(&VALUES, value)
 }
 
+/// Read a `ValueType`'s assigned id directly, without touching `LazyLock`. See
+/// [`get_id_unchecked`] for the safety contract.
+///
+/// # Safety
+///
+/// The only legitimate caller is `VTableRegistry::finalize`, which runs inside the `VALUES`
+/// `LazyLock` initializer (via `register_all_trait_methods`), after `init_registry` has
+/// assigned ids. Calling `get_value_type_id` from there would re-enter `LazyLock::force` and
+/// deadlock.
+#[inline]
+pub(crate) unsafe fn get_value_type_id_unchecked(value: &'static ValueType) -> ValueTypeId {
+    unsafe { get_id_unchecked(value) }
+}
+
 #[inline]
 pub fn get_value_type(id: ValueTypeId) -> &'static ValueType {
     get_item(&VALUES, id)
diff --git a/turbopack/crates/turbo-tasks/src/trait_ref.rs b/turbopack/crates/turbo-tasks/src/trait_ref.rs
index 4bf6fc9cebd..ff1d0cd55f8 100644
--- a/turbopack/crates/turbo-tasks/src/trait_ref.rs
+++ b/turbopack/crates/turbo-tasks/src/trait_ref.rs
@@ -60,7 +60,7 @@ where
     fn deref(&self) -> &Self::Target {
         // This lookup will fail if the value type stored does not actually implement the trait,
         // which implies a bug in either the registry code or the macro code.
-        let downcast_ptr = <Box<U> as VcValueTrait>::get_impl_vtables().cast(
+        let downcast_ptr = <Box<U> as VcValueTrait>::IMPL_VTABLES.cast(
             self.shared_reference.type_id,
             self.shared_reference.reference.0.as_ptr() as *const (),
         );
diff --git a/turbopack/crates/turbo-tasks/src/value_type.rs b/turbopack/crates/turbo-tasks/src/value_type.rs
index 911ebb54ca7..b95ba964a20 100644
--- a/turbopack/crates/turbo-tasks/src/value_type.rs
+++ b/turbopack/crates/turbo-tasks/src/value_type.rs
@@ -280,7 +280,9 @@ pub(crate) fn register_all_trait_methods(_: &[&'static ValueType]) {
     for entry in inventory::iter::<CollectableTraitMethods> {
         entry
             .value_type
-            .register_trait(entry.trait_type, entry.methods)
+            .register_trait(entry.trait_type, entry.methods);
+        // Reigster all the rust vtables to support into_trait_ref calling stryles
+        (entry.finalize_vtable_registry)();
     }
 }
 
diff --git a/turbopack/crates/turbo-tasks/src/vc/traits.rs b/turbopack/crates/turbo-tasks/src/vc/traits.rs
index c9ffebe0f1e..2bb906b38c9 100644
--- a/turbopack/crates/turbo-tasks/src/vc/traits.rs
+++ b/turbopack/crates/turbo-tasks/src/vc/traits.rs
@@ -123,14 +123,17 @@ pub unsafe trait VcValueType: ShrinkToFit + Sized + Send + Sync + 'static {
 /// [`TraitRef`]: crate::TraitRef
 pub trait VcValueTrait: NonLocalValue + Send + Sync + 'static {
     // The concrete type of the value_trait implementing VcValueTrait
-    type ValueTrait: ?Sized;
+    type ValueTrait: ?Sized + std::ptr::Pointee<Metadata = std::ptr::DynMetadata<Self::ValueTrait>>;
+
+    /// The per-trait vtable registry, populated at program load by `#[ctor::ctor]`
+    /// functions emitted by each `#[turbo_tasks::value_impl]` expansion.
+    ///
+    /// [`VTableRegistry::cast`] panics if the value type being cast doesn't implement this
+    /// trait.
+    const IMPL_VTABLES: &'static VTableRegistry<Self::ValueTrait>;
 
     /// Returns the type id of the trait object.
     fn get_trait_type_id() -> TraitTypeId;
-
-    /// Returns the vtable for an implementation of this trait.
-    /// Panics if ValueTypeId does not implement the trait.
-    fn get_impl_vtables() -> &'static VTableRegistry<Self::ValueTrait>;
 }
 
 /// Marker trait that indicates that a [`Vc<Self>`][crate::Vc] can be upcasted to a
diff --git a/turbopack/crates/turbopack-core/src/module_graph/async_module_info.rs b/turbopack/crates/turbopack-core/src/module_graph/async_module_info.rs
index f924d8ade7b..74b96b454e4 100644
--- a/turbopack/crates/turbopack-core/src/module_graph/async_module_info.rs
+++ b/turbopack/crates/turbopack-core/src/module_graph/async_module_info.rs
@@ -4,7 +4,7 @@ use turbo_tasks::{OperationVc, ResolvedVc, TryFlatJoinIterExt, Vc};
 
 use crate::{
     module::Module,
-    module_graph::{GraphTraversalAction, ModuleGraph, ModuleGraphLayer},
+    module_graph::{GraphTraversalAction, ModuleGraph, ModuleGraphLayer, SingleModuleGraphNode},
 };
 
 /// This lists all the modules that are async (self or transitively because they reference another
@@ -44,13 +44,11 @@ async fn compute_async_module_info_single(
     };
     let graph = graph.read_strongly_consistent().await?;
     let self_async_modules = graph
-        .enumerate_nodes()
-        .map(async |(_, node)| {
+        .iter_reachable_nodes()?
+        .map(async |node| {
             Ok(match node {
-                super::SingleModuleGraphNode::Module(node) => {
-                    node.is_self_async().await?.then_some(*node)
-                }
-                super::SingleModuleGraphNode::VisitedModule { idx: _, module } => {
+                SingleModuleGraphNode::Module(node) => node.is_self_async().await?.then_some(*node),
+                SingleModuleGraphNode::VisitedModule { idx: _, module } => {
                     // If a module is async in the parent then we need to mark reverse dependencies
                     // async in this graph as well.
                     parent_async_modules
diff --git a/turbopack/crates/turbopack-core/src/module_graph/binding_usage_info.rs b/turbopack/crates/turbopack-core/src/module_graph/binding_usage_info.rs
index a6892cafca7..00e0eb879a5 100644
--- a/turbopack/crates/turbopack-core/src/module_graph/binding_usage_info.rs
+++ b/turbopack/crates/turbopack-core/src/module_graph/binding_usage_info.rs
@@ -292,6 +292,22 @@ pub async fn compute_binding_usage_info(
                         .await?
                 );
             }
+
+            static PRINT_USED_EXPORTS: Lazy<bool> = Lazy::new(|| {
+                std::env::var_os("TURBOPACK_PRINT_USED_EXPORTS")
+                    .is_some_and(|v| v == "1" || v == "true")
+            });
+            if *PRINT_USED_EXPORTS {
+                use turbo_tasks::TryJoinIterExt;
+                println!(
+                    "used exports: {:#?}",
+                    used_exports
+                        .iter()
+                        .map(async |(m, v)| Ok((m.ident_string().await?, v,)))
+                        .try_join()
+                        .await?
+                );
+            }
         }
 
         Ok(BindingUsageInfo {
diff --git a/turbopack/crates/turbopack-core/src/module_graph/merged_modules.rs b/turbopack/crates/turbopack-core/src/module_graph/merged_modules.rs
index 70e736d38e5..e7b7762f102 100644
--- a/turbopack/crates/turbopack-core/src/module_graph/merged_modules.rs
+++ b/turbopack/crates/turbopack-core/src/module_graph/merged_modules.rs
@@ -139,9 +139,8 @@ pub async fn compute_merged_modules(module_graph: Vc<ModuleGraph>) -> Result<Vc<
             FxHashSet::with_capacity_and_hasher(module_count, Default::default());
 
         let inner_span = tracing::info_span!("collect mergeable modules");
-        let mergeable = graphs
-            .iter()
-            .flat_map(|g| g.iter_nodes())
+        let mergeable = module_graph
+            .iter_reachable_modules()?
             .map(async |module| {
                 if let Some(mergeable) =
                     ResolvedVc::try_downcast::<Box<dyn MergeableModule>>(module)
diff --git a/turbopack/crates/turbopack-core/src/module_graph/mod.rs b/turbopack/crates/turbopack-core/src/module_graph/mod.rs
index 85d37134e42..72f61548ece 100644
--- a/turbopack/crates/turbopack-core/src/module_graph/mod.rs
+++ b/turbopack/crates/turbopack-core/src/module_graph/mod.rs
@@ -1,6 +1,7 @@
 use std::{
     collections::{BinaryHeap, VecDeque},
     future::Future,
+    iter::FusedIterator,
     ops::Deref,
 };
 
@@ -425,7 +426,8 @@ impl SingleModuleGraph {
         Ok(graph)
     }
 
-    /// Iterate over all nodes in the graph
+    /// WARNING: using this is discouraged, as it doesn't filter out unused or traced references.
+    /// Use iter_reachable_modules or one of the .traverse_* functions instead.
     pub fn iter_nodes(&self) -> impl Iterator<Item = ResolvedVc<Box<dyn Module>>> + '_ {
         self.graph.node_weights().filter_map(|n| match n {
             SingleModuleGraphNode::Module(node) => Some(*node),
@@ -450,7 +452,8 @@ impl SingleModuleGraph {
         self.entries.iter().flat_map(|e| e.entries())
     }
 
-    /// Enumerate all nodes in the graph
+    /// WARNING: using this is discouraged, as it doesn't filter out unused or traced references.
+    /// Use iter_reachable_modules or one of the .traverse_* functions instead.
     pub fn enumerate_nodes(
         &self,
     ) -> impl Iterator<Item = (NodeIndex, &'_ SingleModuleGraphNode)> + '_ {
@@ -933,12 +936,16 @@ impl ModuleGraphSnapshot {
         }
     }
 
+    /// WARNING: using this is discouraged, as it doesn't filter out unused or traced references.
+    /// Use iter_reachable_modules or one of the .traverse_* functions instead.
     pub fn enumerate_nodes(
         &self,
     ) -> impl Iterator<Item = (NodeIndex, &'_ SingleModuleGraphNode)> + '_ {
         self.graphs.iter().flat_map(|g| g.enumerate_nodes())
     }
 
+    /// WARNING: using this is discouraged, as it doesn't filter out unused or traced references.
+    /// Use iter_reachable_modules or one of the .traverse_* functions instead.
     pub fn iter_nodes(&self) -> impl Iterator<Item = ResolvedVc<Box<dyn Module>>> + '_ {
         self.graphs.iter().flat_map(|g| g.iter_nodes())
     }
@@ -981,9 +988,7 @@ impl ModuleGraphSnapshot {
     /// This is primarily useful for debugging.
     pub async fn get_ids(&self) -> Result<FxHashMap<ResolvedVc<Box<dyn Module>>, ReadRef<RcStr>>> {
         Ok(self
-            .graphs
-            .iter()
-            .flat_map(|g| g.iter_nodes())
+            .iter_nodes()
             .map(async |n| Ok((n, n.ident().to_string().await?)))
             .try_join()
             .await?
@@ -1421,7 +1426,76 @@ impl ModuleGraphSnapshot {
 
         Ok(visit_count)
     }
+
+    /// Iterates all reachable modules in the graph, ignoring unused and traced references.
+    pub fn iter_reachable_modules(
+        &self,
+    ) -> Result<impl Iterator<Item = ResolvedVc<Box<dyn Module>>>> {
+        Ok(self.iter_reachable_nodes()?.filter_map(|n| match n {
+            SingleModuleGraphNode::Module(m) => Some(*m),
+            SingleModuleGraphNode::VisitedModule { .. } => None,
+        }))
+    }
+
+    /// Iterates all reachable nodes in the graph, ignoring unused and traced references.
+    /// This includes VisitedModule nodes (which means that some modules are returned twice).
+    pub fn iter_reachable_nodes<'a>(
+        &'a self,
+    ) -> Result<impl Iterator<Item = &'a SingleModuleGraphNode> + 'a> {
+        ModuleGraphSnapshotNodeIterator::new(self)
+    }
+}
+
+struct ModuleGraphSnapshotNodeIterator<'a> {
+    graph: &'a ModuleGraphSnapshot,
+    visited: FxHashSet<GraphNodeIndex>,
+    visit_queue: VecDeque<GraphNodeIndex>,
+}
+
+impl<'a> ModuleGraphSnapshotNodeIterator<'a> {
+    fn new(graph: &'a ModuleGraphSnapshot) -> Result<Self> {
+        let entries = graph
+            .graphs
+            .iter()
+            .flat_map(|g| g.entry_modules())
+            .map(|e| graph.get_entry(e))
+            .collect::<Result<VecDeque<_>>>()?;
+
+        Ok(Self {
+            graph,
+            visited: FxHashSet::default(),
+            visit_queue: entries,
+        })
+    }
+}
+impl<'a> Iterator for ModuleGraphSnapshotNodeIterator<'a> {
+    type Item = &'a SingleModuleGraphNode;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        while let Some(node_idx) = self.visit_queue.pop_front() {
+            if self.visited.insert(node_idx) {
+                let node_weight = self.graph.get_node(node_idx).unwrap();
+                if self
+                    .graph
+                    .should_visit_node(node_weight, Direction::Outgoing)
+                {
+                    let node = node_weight
+                        .target_idx(Direction::Outgoing)
+                        .unwrap_or(node_idx);
+                    self.visit_queue.extend(
+                        self.graph
+                            .iter_graphs_neighbors_rev(node, Direction::Outgoing)
+                            .map(|(_, succ)| succ)
+                            .filter(|succ| !self.visited.contains(succ)),
+                    );
+                }
+                return Some(node_weight);
+            }
+        }
+        None
+    }
 }
+impl FusedIterator for ModuleGraphSnapshotNodeIterator<'_> {}
 
 #[turbo_tasks::value_impl]
 impl SingleModuleGraph {
@@ -1489,8 +1563,13 @@ impl SingleModuleGraph {
     }
 
     #[turbo_tasks::function]
-    pub async fn module_count(&self) -> Result<Vc<u64>> {
-        Ok(Vc::cell(self.number_of_modules as u64))
+    pub async fn module_count(&self) -> Vc<u64> {
+        Vc::cell(self.number_of_modules as u64)
+    }
+
+    #[turbo_tasks::function]
+    pub async fn edge_count(&self) -> Vc<u64> {
+        Vc::cell(self.graph.edge_count() as u64)
     }
 }
 
@@ -2187,6 +2266,209 @@ pub mod tests {
         .unwrap();
     }
 
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn test_iter_nodes_modules_through_layered_graph() {
+        let tt = turbo_tasks::TurboTasks::new(TurboTasksBackend::new(
+            BackendOptions::default(),
+            noop_backing_storage(),
+        ));
+        tt.run_once(async move {
+            #[turbo_tasks::value]
+            struct Results {
+                iter_nodes: Vec<RcStr>,
+                iter_modules: Vec<RcStr>,
+                iter_nodes_single: Vec<Vec<RcStr>>,
+                iter_modules_single: Vec<Vec<RcStr>>,
+            }
+
+            #[turbo_tasks::function(operation)]
+            async fn reverse_traversal_results_operation() -> Result<Vc<Results>> {
+                let fs = VirtualFileSystem::new_with_name(rcstr!("test"));
+                let root = fs.root().await?;
+
+                // a simple linear graph a -> b -> c -> x -> y -> z
+                // but x -> y -> z is in a parent graph
+                let graph = {
+                    let mut deps = FxHashMap::default();
+
+                    deps.insert(rcstr!("a.js"), vec![rcstr!("b.js")]);
+                    deps.insert(rcstr!("b.js"), vec![rcstr!("c.js")]);
+                    deps.insert(rcstr!("c.js"), vec![rcstr!("x.js")]);
+                    deps.insert(rcstr!("x.js"), vec![rcstr!("y.js")]);
+                    deps.insert(rcstr!("y.js"), vec![rcstr!("z.js")]);
+                    deps
+                };
+                let repo = TestRepo {
+                    repo: graph
+                        .iter()
+                        .map(|(k, v)| {
+                            (
+                                root.join(k).unwrap(),
+                                v.iter().map(|f| root.join(f).unwrap()).collect(),
+                            )
+                        })
+                        .collect(),
+                }
+                .cell();
+                let make_module = |name| {
+                    Vc::upcast::<Box<dyn Module>>(MockModule::new(root.join(name).unwrap(), repo))
+                        .to_resolved()
+                };
+                let x_module = make_module("x.js").await?;
+                let a_module = make_module("a.js").await?;
+
+                let parent_graph = SingleModuleGraph::new_with_entries(
+                    ResolvedVc::cell(vec![ChunkGroupEntry::Entry(vec![x_module])]),
+                    false,
+                    false,
+                );
+
+                let module_graph = ModuleGraph::from_graphs(
+                    vec![
+                        parent_graph,
+                        SingleModuleGraph::new_with_entries_visited(
+                            ResolvedVc::cell(vec![ChunkGroupEntry::Entry(vec![a_module])]),
+                            VisitedModules::from_graph(parent_graph),
+                            false,
+                            false,
+                        ),
+                    ],
+                    None,
+                )
+                .connect();
+                let graph_layers = module_graph.iter_graphs().await?;
+
+                Ok(Results {
+                    iter_nodes: module_graph
+                        .await?
+                        .iter_reachable_nodes()?
+                        .map(async |node| {
+                            Ok(match node {
+                                SingleModuleGraphNode::Module(module) => {
+                                    module.ident_string().owned().await?
+                                }
+                                SingleModuleGraphNode::VisitedModule { module, .. } => {
+                                    format!("visited {}", module.ident_string().owned().await?)
+                                        .into()
+                                }
+                            })
+                        })
+                        .try_join()
+                        .await?,
+                    iter_modules: module_graph
+                        .await?
+                        .iter_reachable_modules()?
+                        .map(|m| m.ident_string().owned())
+                        .try_join()
+                        .await?,
+                    iter_nodes_single: graph_layers
+                        .iter()
+                        .map(async |layer| {
+                            layer
+                                .connect()
+                                .await?
+                                .iter_reachable_nodes()?
+                                .map(async |node| {
+                                    Ok(match node {
+                                        SingleModuleGraphNode::Module(module) => {
+                                            module.ident_string().owned().await?
+                                        }
+                                        SingleModuleGraphNode::VisitedModule { module, .. } => {
+                                            format!(
+                                                "visited {}",
+                                                module.ident_string().owned().await?
+                                            )
+                                            .into()
+                                        }
+                                    })
+                                })
+                                .try_join()
+                                .await
+                        })
+                        .try_join()
+                        .await?,
+                    iter_modules_single: graph_layers
+                        .iter()
+                        .map(async |layer| {
+                            layer
+                                .connect()
+                                .await?
+                                .iter_reachable_modules()?
+                                .map(|m| m.ident_string().owned())
+                                .try_join()
+                                .await
+                        })
+                        .try_join()
+                        .await?,
+                }
+                .cell())
+            }
+
+            let traversal_results = reverse_traversal_results_operation()
+                .read_strongly_consistent()
+                .await?;
+
+            assert_eq!(
+                traversal_results.iter_nodes,
+                vec![
+                    rcstr!("[test]/x.js"),
+                    rcstr!("[test]/a.js"),
+                    rcstr!("[test]/y.js"),
+                    rcstr!("[test]/b.js"),
+                    rcstr!("[test]/z.js"),
+                    rcstr!("[test]/c.js"),
+                    rcstr!("visited [test]/x.js")
+                ]
+            );
+            assert_eq!(
+                traversal_results.iter_modules,
+                vec![
+                    rcstr!("[test]/x.js"),
+                    rcstr!("[test]/a.js"),
+                    rcstr!("[test]/y.js"),
+                    rcstr!("[test]/b.js"),
+                    rcstr!("[test]/z.js"),
+                    rcstr!("[test]/c.js")
+                ]
+            );
+            assert_eq!(
+                traversal_results.iter_nodes_single,
+                vec![
+                    vec![
+                        rcstr!("[test]/x.js"),
+                        rcstr!("[test]/y.js"),
+                        rcstr!("[test]/z.js")
+                    ],
+                    vec![
+                        rcstr!("[test]/a.js"),
+                        rcstr!("[test]/b.js"),
+                        rcstr!("[test]/c.js"),
+                        rcstr!("visited [test]/x.js")
+                    ]
+                ]
+            );
+            assert_eq!(
+                traversal_results.iter_modules_single,
+                vec![
+                    vec![
+                        rcstr!("[test]/x.js"),
+                        rcstr!("[test]/y.js"),
+                        rcstr!("[test]/z.js")
+                    ],
+                    vec![
+                        rcstr!("[test]/a.js"),
+                        rcstr!("[test]/b.js"),
+                        rcstr!("[test]/c.js")
+                    ]
+                ]
+            );
+
+            Ok(())
+        })
+        .await
+        .unwrap();
+    }
+
     #[turbo_tasks::value(shared)]
     struct TestRepo {
         repo: FxHashMap<FileSystemPath, Vec<FileSystemPath>>,
diff --git a/turbopack/crates/turbopack-core/src/module_graph/side_effect_module_info.rs b/turbopack/crates/turbopack-core/src/module_graph/side_effect_module_info.rs
index 2034fbdd24e..2a560dad8fb 100644
--- a/turbopack/crates/turbopack-core/src/module_graph/side_effect_module_info.rs
+++ b/turbopack/crates/turbopack-core/src/module_graph/side_effect_module_info.rs
@@ -4,7 +4,7 @@ use turbo_tasks::{ResolvedVc, TryJoinIterExt, Vc};
 
 use crate::{
     module::{Module, ModuleSideEffects},
-    module_graph::{GraphTraversalAction, ModuleGraph, ModuleGraphLayer},
+    module_graph::{GraphTraversalAction, ModuleGraph, ModuleGraphLayer, SingleModuleGraphNode},
 };
 
 /// This lists all the modules that are side effect free
@@ -43,16 +43,16 @@ async fn compute_side_effect_free_module_info_single(
     let parent_side_effect_free_modules = parent_side_effect_free_modules.await?;
     let graph = graph.await?;
     let module_side_effects = graph
-        .enumerate_nodes()
-        .map(async |(_, node)| {
+        .iter_reachable_nodes()?
+        .map(async |node| {
             Ok(match node {
-                super::SingleModuleGraphNode::Module(module) => {
+                SingleModuleGraphNode::Module(module) => {
                     // This turbo task always has a cache hit since it is called when building the
                     // module graph. we could consider moving this information
                     // into to the module graph, but then changes would invalidate the whole graph.
                     (*module, *module.side_effects().await?)
                 }
-                super::SingleModuleGraphNode::VisitedModule { idx: _, module } => (
+                SingleModuleGraphNode::VisitedModule { idx: _, module } => (
                     *module,
                     if parent_side_effect_free_modules.contains(module) {
                         ModuleSideEffects::SideEffectFree
@@ -105,6 +105,44 @@ async fn compute_side_effect_free_module_info_single(
         },
         |_, _, _| Ok(()),
     )?;
+    #[cfg(debug_assertions)]
+    {
+        use once_cell::sync::Lazy;
+        static PRINT_SIDE_EFFECT_INFO: Lazy<bool> = Lazy::new(|| {
+            std::env::var_os("TURBOPACK_PRINT_SIDE_EFFECT_INFO")
+                .is_some_and(|v| v == "1" || v == "true")
+        });
+        if *PRINT_SIDE_EFFECT_INFO {
+            use turbo_tasks::TryJoinIterExt;
+            println!(
+                "side effect free modules: {:#?}",
+                module_side_effects
+                    .iter()
+                    .filter_map(|(m, e)| match e {
+                        ModuleSideEffects::SideEffectful => None,
+                        ModuleSideEffects::SideEffectFree => Some((m, false)),
+                        ModuleSideEffects::ModuleEvaluationIsSideEffectFree => {
+                            if locally_side_effect_free_modules_that_have_side_effects.contains(m) {
+                                None
+                            } else {
+                                Some((m, true))
+                            }
+                        }
+                    })
+                    .map(async |(m, locally)| Ok((
+                        m.ident_string().await?,
+                        if locally {
+                            "inferred locally"
+                        } else {
+                            "declared"
+                        }
+                    )))
+                    .try_join()
+                    .await?
+            );
+        }
+    }
+
     let side_effect_free_modules = module_side_effects
         .into_iter()
         .filter_map(|(m, e)| match e {
diff --git a/turbopack/crates/turbopack-ecmascript/src/references/esm/base.rs b/turbopack/crates/turbopack-ecmascript/src/references/esm/base.rs
index 76f38b7e78a..8782de9af4c 100644
--- a/turbopack/crates/turbopack-ecmascript/src/references/esm/base.rs
+++ b/turbopack/crates/turbopack-ecmascript/src/references/esm/base.rs
@@ -69,12 +69,52 @@ pub enum ReferencedAssetIdent {
     },
     /// The given export (or namespace) should be imported and will be assigned to a new variable.
     Module {
+        /// The name of the variable that will hold the imported namespace. Cached from
+        /// `import_source.get_namespace_ident(..)` at resolution time so downstream sync
+        /// visitors can read it without re-entering the async layer.
         namespace_ident: String,
         ctxt: Option<SyntaxContext>,
         export: Option<RcStr>,
+        /// Describes what to import to populate the variable that `namespace_ident` names.
+        ///
+        /// When the ident was resolved through a re-export chain (e.g. `export * as X from
+        /// './inner'`), this is the final module in that chain, not the directly referenced
+        /// asset — so the `.i(...)` call that initializes the variable loads the module whose
+        /// namespace `namespace_ident` claims to hold.
+        import_source: ImportSource,
     },
 }
 
+/// The source to import when initializing a `ReferencedAssetIdent::Module` variable.
+#[derive(Debug)]
+pub enum ImportSource {
+    /// Import an in-graph module.
+    Module {
+        asset: ResolvedVc<Box<dyn EcmascriptChunkPlaceable>>,
+    },
+    /// Import an external dependency. The emitting site decides between
+    /// `__turbopack_external_import` and `__turbopack_external_require` based on its own
+    /// `import_externals` flag.
+    External { request: RcStr, ty: ExternalType },
+}
+
+impl ImportSource {
+    /// Compute the name of the variable that should hold the imported namespace.
+    pub async fn get_namespace_ident(
+        &self,
+        chunking_context: Vc<Box<dyn ChunkingContext>>,
+    ) -> Result<String> {
+        Ok(match self {
+            ImportSource::Module { asset } => {
+                ReferencedAsset::get_ident_from_placeable(asset, chunking_context).await?
+            }
+            ImportSource::External { request, ty } => {
+                magic_identifier::mangle(&format!("{ty} external {request}"))
+            }
+        })
+    }
+}
+
 impl ReferencedAssetIdent {
     pub fn into_module_namespace_ident(self) -> Option<(String, Option<SyntaxContext>)> {
         match self {
@@ -98,6 +138,7 @@ impl ReferencedAssetIdent {
                 namespace_ident,
                 ctxt,
                 export,
+                import_source: _,
             } => {
                 if let Some(export) = export {
                     Either::Right(MemberExpr {
@@ -233,10 +274,12 @@ impl ReferencedAsset {
                                         // but in the module containing the reexport
                                         ctxt: None,
                                         export,
+                                        import_source,
                                     }) => Some(ReferencedAssetIdent::Module {
                                         namespace_ident,
                                         ctxt: Some(ctxt),
                                         export,
+                                        import_source,
                                     }),
                                     ident => ident,
                                 },
@@ -249,18 +292,26 @@ impl ReferencedAsset {
                     }
                 }
 
+                let import_source = ImportSource::Module { asset: *asset };
                 Some(ReferencedAssetIdent::Module {
-                    namespace_ident: Self::get_ident_from_placeable(asset, chunking_context)
-                        .await?,
+                    namespace_ident: import_source.get_namespace_ident(chunking_context).await?,
                     ctxt: None,
                     export,
+                    import_source,
+                })
+            }
+            ReferencedAsset::External(request, ty) => {
+                let import_source = ImportSource::External {
+                    request: request.clone(),
+                    ty: *ty,
+                };
+                Some(ReferencedAssetIdent::Module {
+                    namespace_ident: import_source.get_namespace_ident(chunking_context).await?,
+                    ctxt: None,
+                    export,
+                    import_source,
                 })
             }
-            ReferencedAsset::External(request, ty) => Some(ReferencedAssetIdent::Module {
-                namespace_ident: magic_identifier::mangle(&format!("{ty} external {request}")),
-                ctxt: None,
-                export,
-            }),
             ReferencedAsset::None | ReferencedAsset::Unresolvable => None,
         })
     }
@@ -617,11 +668,22 @@ impl EsmAssetReference {
                                 scope_hoisting_context,
                             )
                             .await?;
+                        // `referenced_asset` must not be used past this point: the ident carries
+                        // everything about the import target (see `ImportSource`) — notably,
+                        // when the ident was resolved through a re-export chain, the
+                        // directly-referenced asset is the outer (rename) module, not the one
+                        // the emitted variable actually holds.
+                        drop(referenced_asset);
                         match ident {
                             Some(ReferencedAssetIdent::LocalBinding { .. }) => {
                                 // no need to import
                             }
-                            Some(ident @ ReferencedAssetIdent::Module { .. }) => {
+                            Some(ReferencedAssetIdent::Module {
+                                namespace_ident,
+                                ctxt,
+                                export: _,
+                                import_source,
+                            }) => {
                                 let span = this
                                     .issue_source
                                     .to_swc_offsets()
@@ -629,43 +691,31 @@ impl EsmAssetReference {
                                     .map_or(DUMMY_SP, |(start, end)| {
                                         Span::new(BytePos(start), BytePos(end))
                                     });
-                                match &*referenced_asset {
-                                    ReferencedAsset::Unresolvable => {
-                                        unreachable!();
-                                    }
-                                    ReferencedAsset::Some(asset) => {
+                                let name = Ident::new(
+                                    namespace_ident.into(),
+                                    DUMMY_SP,
+                                    ctxt.unwrap_or_default(),
+                                );
+                                let (key, mut call_expr) = match import_source {
+                                    ImportSource::Module { asset } => {
                                         let id = asset.chunk_item_id(chunking_context).await?;
-                                        let (sym, ctxt) =
-                                            ident.into_module_namespace_ident().unwrap();
-                                        let name = Ident::new(
-                                            sym.into(),
-                                            DUMMY_SP,
-                                            ctxt.unwrap_or_default(),
-                                        );
-                                        let mut call_expr = quote!(
-                                            "$turbopack_import($id)" as Expr,
-                                            turbopack_import: Expr = TURBOPACK_IMPORT.into(),
-                                            id: Expr = module_id_to_lit(&id),
-                                        );
-                                        if this.is_pure_import {
-                                            call_expr.set_span(PURE_SP);
-                                        }
-                                        result.push(CodeGenerationHoistedStmt::new(
-                                            id.to_string().into(),
-                                            var_decl_with_span(
-                                                quote!(
-                                                    "var $name = $call;" as Stmt,
-                                                    name = name,
-                                                    call: Expr = call_expr
-                                                ),
-                                                span,
+                                        // Include ctxt in the key to prevent incorrect
+                                        // deduplication when multiple merged modules import the
+                                        // same target but have different syntax contexts (which
+                                        // would cause hygiene to rename one of them).
+                                        (
+                                            format!("{} {:?}", id, ctxt).into(),
+                                            quote!(
+                                                "$turbopack_import($id)" as Expr,
+                                                turbopack_import: Expr = TURBOPACK_IMPORT.into(),
+                                                id: Expr = module_id_to_lit(&id),
                                             ),
-                                        ));
+                                        )
                                     }
-                                    ReferencedAsset::External(
+                                    ImportSource::External {
                                         request,
-                                        ExternalType::EcmaScriptModule,
-                                    ) => {
+                                        ty: ExternalType::EcmaScriptModule,
+                                    } => {
                                         if !*chunking_context
                                             .environment()
                                             .supports_esm_externals()
@@ -677,45 +727,25 @@ impl EsmAssetReference {
                                                 chunking_context.name()
                                             );
                                         }
-                                        let (sym, ctxt) =
-                                            ident.into_module_namespace_ident().unwrap();
-                                        let name = Ident::new(
-                                            sym.into(),
-                                            DUMMY_SP,
-                                            ctxt.unwrap_or_default(),
-                                        );
-                                        let mut call_expr = if import_externals {
+                                        let call = if import_externals {
                                             quote!(
                                                 "$turbopack_external_import($id)" as Expr,
                                                 turbopack_external_import: Expr = TURBOPACK_EXTERNAL_IMPORT.into(),
-                                                id: Expr = Expr::Lit(request.clone().to_string().into())
+                                                id: Expr = Expr::Lit(request.to_string().into())
                                             )
                                         } else {
                                             quote!(
                                                 "$turbopack_external_require($id, () => require($id), true)" as Expr,
                                                 turbopack_external_require: Expr = TURBOPACK_EXTERNAL_REQUIRE.into(),
-                                                id: Expr = Expr::Lit(request.clone().to_string().into())
+                                                id: Expr = Expr::Lit(request.to_string().into())
                                             )
                                         };
-                                        if this.is_pure_import {
-                                            call_expr.set_span(PURE_SP);
-                                        }
-                                        result.push(CodeGenerationHoistedStmt::new(
-                                            name.sym.as_str().into(),
-                                            var_decl_with_span(
-                                                quote!(
-                                                    "var $name = $call;" as Stmt,
-                                                    name = name,
-                                                    call: Expr = call_expr,
-                                                ),
-                                                span,
-                                            ),
-                                        ));
+                                        (name.sym.as_str().into(), call)
                                     }
-                                    ReferencedAsset::External(
+                                    ImportSource::External {
                                         request,
-                                        ExternalType::CommonJs | ExternalType::Url,
-                                    ) => {
+                                        ty: ExternalType::CommonJs | ExternalType::Url,
+                                    } => {
                                         if !*chunking_context
                                             .environment()
                                             .supports_commonjs_externals()
@@ -727,36 +757,16 @@ impl EsmAssetReference {
                                                 chunking_context.name()
                                             );
                                         }
-                                        let (sym, ctxt) =
-                                            ident.into_module_namespace_ident().unwrap();
-                                        let name = Ident::new(
-                                            sym.into(),
-                                            DUMMY_SP,
-                                            ctxt.unwrap_or_default(),
-                                        );
-                                        let mut call_expr = quote!(
+                                        let call = quote!(
                                             "$turbopack_external_require($id, () => require($id), true)" as Expr,
                                             turbopack_external_require: Expr = TURBOPACK_EXTERNAL_REQUIRE.into(),
-                                            id: Expr = Expr::Lit(request.clone().to_string().into())
+                                            id: Expr = Expr::Lit(request.to_string().into())
                                         );
-                                        if this.is_pure_import {
-                                            call_expr.set_span(PURE_SP);
-                                        }
-                                        result.push(CodeGenerationHoistedStmt::new(
-                                            name.sym.as_str().into(),
-                                            var_decl_with_span(
-                                                quote!(
-                                                    "var $name = $call;" as Stmt,
-                                                    name = name,
-                                                    call: Expr = call_expr,
-                                                ),
-                                                span,
-                                            ),
-                                        ));
+                                        (name.sym.as_str().into(), call)
                                     }
                                     // fallback in case we introduce a new `ExternalType`
                                     #[allow(unreachable_patterns)]
-                                    ReferencedAsset::External(request, ty) => {
+                                    ImportSource::External { request, ty, .. } => {
                                         bail!(
                                             "Unsupported external type {:?} for ESM reference \
                                              with request: {:?}",
@@ -764,8 +774,21 @@ impl EsmAssetReference {
                                             request
                                         )
                                     }
-                                    ReferencedAsset::None => {}
                                 };
+                                if this.is_pure_import {
+                                    call_expr.set_span(PURE_SP);
+                                }
+                                result.push(CodeGenerationHoistedStmt::new(
+                                    key,
+                                    var_decl_with_span(
+                                        quote!(
+                                            "var $name = $call;" as Stmt,
+                                            name = name,
+                                            call: Expr = call_expr
+                                        ),
+                                        span,
+                                    ),
+                                ));
                             }
                             None => {
                                 // Nothing to import.
diff --git a/turbopack/crates/turbopack-ecmascript/src/references/esm/binding.rs b/turbopack/crates/turbopack-ecmascript/src/references/esm/binding.rs
index 79ffaa1e4da..c01fe3ab774 100644
--- a/turbopack/crates/turbopack-ecmascript/src/references/esm/binding.rs
+++ b/turbopack/crates/turbopack-ecmascript/src/references/esm/binding.rs
@@ -62,6 +62,14 @@ impl EsmBinding {
         chunking_context: Vc<Box<dyn ChunkingContext>>,
         scope_hoisting_context: ScopeHoistingContext<'_>,
     ) -> Result<CodeGeneration> {
+        if chunking_context
+            .unused_references()
+            .contains_key(&ResolvedVc::upcast(self.reference))
+            .await?
+        {
+            return Ok(CodeGeneration::empty());
+        }
+
         let mut visitors = vec![];
 
         let export = self.export.clone();
diff --git a/turbopack/crates/turbopack-ecmascript/src/references/esm/export.rs b/turbopack/crates/turbopack-ecmascript/src/references/esm/export.rs
index 636200adafa..8353b7d0810 100644
--- a/turbopack/crates/turbopack-ecmascript/src/references/esm/export.rs
+++ b/turbopack/crates/turbopack-ecmascript/src/references/esm/export.rs
@@ -786,7 +786,7 @@ impl EsmExports {
                                         }
                                     }
                                 },
-                                ReferencedAssetIdent::Module { namespace_ident:_, ctxt:_, export:_ } => {
+                                ReferencedAssetIdent::Module { .. } => {
                                     // Otherwise we need to bind as a getter to preserve the 'liveness' of the other modules bindings.
                                     // TODO: If this becomes important it might be faster to use the runtime to copy PropertyDescriptors across modules
                                     // since that would reduce allocations and optimize access. We could do this by passing the module-id up.
diff --git a/turbopack/crates/turbopack-tests/tests/execution/turbopack/exports/self-reexport-star-no-hoisting/input/index.js b/turbopack/crates/turbopack-tests/tests/execution/turbopack/exports/self-reexport-star-no-hoisting/input/index.js
new file mode 100644
index 00000000000..c9e6da35a5e
--- /dev/null
+++ b/turbopack/crates/turbopack-tests/tests/execution/turbopack/exports/self-reexport-star-no-hoisting/input/index.js
@@ -0,0 +1 @@
+import '../../self-reexport-star/input/index.js'
diff --git a/turbopack/crates/turbopack-tests/tests/execution/turbopack/exports/self-reexport-star-no-hoisting/options.json b/turbopack/crates/turbopack-tests/tests/execution/turbopack/exports/self-reexport-star-no-hoisting/options.json
new file mode 100644
index 00000000000..bf30b867b72
--- /dev/null
+++ b/turbopack/crates/turbopack-tests/tests/execution/turbopack/exports/self-reexport-star-no-hoisting/options.json
@@ -0,0 +1,3 @@
+{
+  "scopeHoisting": false
+}
diff --git a/turbopack/crates/turbopack-tests/tests/execution/turbopack/exports/self-reexport-star/input/data.js b/turbopack/crates/turbopack-tests/tests/execution/turbopack/exports/self-reexport-star/input/data.js
index 6a5bb384aaf..494b407b572 100644
--- a/turbopack/crates/turbopack-tests/tests/execution/turbopack/exports/self-reexport-star/input/data.js
+++ b/turbopack/crates/turbopack-tests/tests/execution/turbopack/exports/self-reexport-star/input/data.js
@@ -1,3 +1,5 @@
+import * as Self from './data'
+
 export function foo() {
   return 'foo'
 }
@@ -6,4 +8,18 @@ export function bar() {
   return 'bar'
 }
 
+// Call exports through the module's own namespace object.
+export function fooViaSelf() {
+  return Self.foo()
+}
+
+export function barViaSelf() {
+  return Self.bar()
+}
+
+// Access the re-exported self-namespace via the self-namespace itself.
+export function nestedSelfFoo() {
+  return Self.Data.foo()
+}
+
 export * as Data from './data'
diff --git a/turbopack/crates/turbopack-tests/tests/execution/turbopack/exports/self-reexport-star/input/index.js b/turbopack/crates/turbopack-tests/tests/execution/turbopack/exports/self-reexport-star/input/index.js
index 310eae820a6..fd1c5f6a7fd 100644
--- a/turbopack/crates/turbopack-tests/tests/execution/turbopack/exports/self-reexport-star/input/index.js
+++ b/turbopack/crates/turbopack-tests/tests/execution/turbopack/exports/self-reexport-star/input/index.js
@@ -1,6 +1,47 @@
-import { Data } from './data'
+import { Data, foo, bar, fooViaSelf, barViaSelf, nestedSelfFoo } from './data'
+import * as DataNs from './data'
+import {
+  Data as ChainedData,
+  foo as chainedFoo,
+  bar as chainedBar,
+} from './reexport'
 
 it('should re-export own namespace correctly', () => {
   expect(Data.foo()).toBe('foo')
   expect(Data.bar()).toBe('bar')
 })
+
+it('should expose named exports alongside the self-namespace', () => {
+  expect(foo()).toBe('foo')
+  expect(bar()).toBe('bar')
+})
+
+it('should allow using the self-namespace from inside the module', () => {
+  expect(fooViaSelf()).toBe('foo')
+  expect(barViaSelf()).toBe('bar')
+  expect(nestedSelfFoo()).toBe('foo')
+})
+
+it('should let the self-namespace reference itself recursively', () => {
+  expect(Data.Data.foo()).toBe('foo')
+  expect(Data.Data.Data.bar()).toBe('bar')
+})
+
+it('should expose the same self-namespace via a star-namespace import', () => {
+  expect(DataNs.Data).toBe(Data)
+  expect(DataNs.Data.foo).toBe(foo)
+})
+
+it('should re-export the self-namespace through a chained module', () => {
+  expect(ChainedData).toBe(Data)
+  expect(ChainedData.foo()).toBe('foo')
+  expect(ChainedData.bar()).toBe('bar')
+  expect(chainedFoo).toBe(foo)
+  expect(chainedBar).toBe(bar)
+})
+
+it('should enumerate all expected keys on the self-namespace', () => {
+  expect(Object.keys(Data).sort()).toEqual(
+    ['Data', 'bar', 'barViaSelf', 'foo', 'fooViaSelf', 'nestedSelfFoo'].sort()
+  )
+})
diff --git a/turbopack/crates/turbopack-tests/tests/execution/turbopack/exports/self-reexport-star/input/reexport.js b/turbopack/crates/turbopack-tests/tests/execution/turbopack/exports/self-reexport-star/input/reexport.js
new file mode 100644
index 00000000000..df98d86fb47
--- /dev/null
+++ b/turbopack/crates/turbopack-tests/tests/execution/turbopack/exports/self-reexport-star/input/reexport.js
@@ -0,0 +1,2 @@
+export { Data } from './data'
+export * from './data'
diff --git a/turbopack/crates/turbopack-tests/tests/execution/turbopack/infer-module-side-effects/cross-function/input/index.js b/turbopack/crates/turbopack-tests/tests/execution/turbopack/infer-module-side-effects/cross-function/input/index.js
new file mode 100644
index 00000000000..c7327e64ad1
--- /dev/null
+++ b/turbopack/crates/turbopack-tests/tests/execution/turbopack/infer-module-side-effects/cross-function/input/index.js
@@ -0,0 +1,15 @@
+import { used } from './lib'
+
+it('should skip over module', () => {
+  expect(used()).toBe('used')
+
+  const modules = Array.from(__turbopack_modules__.keys())
+
+  expect(modules).toContainEqual(
+    expect.stringMatching(/cross-function\/input\/lib\.js/)
+  )
+  // TODO the side-effect inference is currently not smart enough to perform cross-function analysis
+  // expect(modules).not.toContainEqual(
+  //   expect.stringMatching(/cross-function\/input\/util\.js/)
+  // )
+})
diff --git a/turbopack/crates/turbopack-tests/tests/execution/turbopack/infer-module-side-effects/cross-function/input/lib.js b/turbopack/crates/turbopack-tests/tests/execution/turbopack/infer-module-side-effects/cross-function/input/lib.js
new file mode 100644
index 00000000000..c0b4314dc36
--- /dev/null
+++ b/turbopack/crates/turbopack-tests/tests/execution/turbopack/infer-module-side-effects/cross-function/input/lib.js
@@ -0,0 +1,9 @@
+import { exec } from './util.js'
+
+export function unused() {
+  return exec
+}
+
+export function used() {
+  return 'used'
+}
diff --git a/turbopack/crates/turbopack-tests/tests/execution/turbopack/infer-module-side-effects/cross-function/input/util.js b/turbopack/crates/turbopack-tests/tests/execution/turbopack/infer-module-side-effects/cross-function/input/util.js
new file mode 100644
index 00000000000..53a02964d56
--- /dev/null
+++ b/turbopack/crates/turbopack-tests/tests/execution/turbopack/infer-module-side-effects/cross-function/input/util.js
@@ -0,0 +1,26 @@
+export function cached(getter) {
+  const set = false
+  return {
+    get value() {
+      if (!set) {
+        const value = getter()
+        Object.defineProperty(this, 'value', { value })
+        return value
+      }
+      throw new Error('cached value already set')
+    },
+  }
+}
+export const allowsEval = cached(() => {
+  try {
+    const F = Function
+    new F('')
+    return true
+  } catch (_) {
+    return false
+  }
+})
+
+export function exec(foo) {
+  return 'x ' + foo
+}
diff --git a/turbopack/crates/turbopack-tests/tests/execution/turbopack/infer-module-side-effects/cross-function/options.json b/turbopack/crates/turbopack-tests/tests/execution/turbopack/infer-module-side-effects/cross-function/options.json
new file mode 100644
index 00000000000..bf30b867b72
--- /dev/null
+++ b/turbopack/crates/turbopack-tests/tests/execution/turbopack/infer-module-side-effects/cross-function/options.json
@@ -0,0 +1,3 @@
+{
+  "scopeHoisting": false
+}
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/remove-unused-imports/exports/output/0_9x_turbopack-tests_tests_snapshot_remove-unused-imports_exports_input_07rt4kf._.js b/turbopack/crates/turbopack-tests/tests/snapshot/remove-unused-imports/exports/output/0_9x_turbopack-tests_tests_snapshot_remove-unused-imports_exports_input_07rt4kf._.js
index 4bc13995ce0..a58c2b7db46 100644
--- a/turbopack/crates/turbopack-tests/tests/snapshot/remove-unused-imports/exports/output/0_9x_turbopack-tests_tests_snapshot_remove-unused-imports_exports_input_07rt4kf._.js
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/remove-unused-imports/exports/output/0_9x_turbopack-tests_tests_snapshot_remove-unused-imports_exports_input_07rt4kf._.js
@@ -16,7 +16,7 @@ __turbopack_context__.s([
 var __TURBOPACK__imported__module__$5b$project$5d2f$turbopack$2f$crates$2f$turbopack$2d$tests$2f$tests$2f$snapshot$2f$remove$2d$unused$2d$imports$2f$exports$2f$input$2f$library$2f$leaf$2e$js__$5b$test$5d$__$28$ecmascript$29$__ = __turbopack_context__.i("[project]/turbopack/crates/turbopack-tests/tests/snapshot/remove-unused-imports/exports/input/library/leaf.js [test] (ecmascript)");
 ;
 function sharedX() {
-    (0, __TURBOPACK__imported__module__$5b$project$5d2f$turbopack$2f$crates$2f$turbopack$2d$tests$2f$tests$2f$snapshot$2f$remove$2d$unused$2d$imports$2f$exports$2f$input$2f$library$2f$leaf$2e$js__$5b$test$5d$__$28$ecmascript$29$__["leafX"])();
+    leafX();
 }
 function sharedY() {
     (0, __TURBOPACK__imported__module__$5b$project$5d2f$turbopack$2f$crates$2f$turbopack$2d$tests$2f$tests$2f$snapshot$2f$remove$2d$unused$2d$imports$2f$exports$2f$input$2f$library$2f$leaf$2e$js__$5b$test$5d$__$28$ecmascript$29$__["leafY"])();
@@ -50,7 +50,7 @@ var __TURBOPACK__imported__module__$5b$project$5d2f$turbopack$2f$crates$2f$turbo
 ;
 (0, __TURBOPACK__imported__module__$5b$project$5d2f$turbopack$2f$crates$2f$turbopack$2d$tests$2f$tests$2f$snapshot$2f$remove$2d$unused$2d$imports$2f$exports$2f$input$2f$library$2f$y$2e$js__$5b$test$5d$__$28$ecmascript$29$__["y"])();
 function helper() {
-    return (0, __TURBOPACK__imported__module__$5b$project$5d2f$turbopack$2f$crates$2f$turbopack$2d$tests$2f$tests$2f$snapshot$2f$remove$2d$unused$2d$imports$2f$exports$2f$input$2f$library$2f$x$2e$js__$5b$test$5d$__$28$ecmascript$29$__["x"])();
+    return x();
 }
 function unused() {
     return helper();
diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/remove-unused-imports/exports/output/0_9x_turbopack-tests_tests_snapshot_remove-unused-imports_exports_input_07rt4kf._.js.map b/turbopack/crates/turbopack-tests/tests/snapshot/remove-unused-imports/exports/output/0_9x_turbopack-tests_tests_snapshot_remove-unused-imports_exports_input_07rt4kf._.js.map
index bfbc3db431e..e9344ecff0b 100644
--- a/turbopack/crates/turbopack-tests/tests/snapshot/remove-unused-imports/exports/output/0_9x_turbopack-tests_tests_snapshot_remove-unused-imports_exports_input_07rt4kf._.js.map
+++ b/turbopack/crates/turbopack-tests/tests/snapshot/remove-unused-imports/exports/output/0_9x_turbopack-tests_tests_snapshot_remove-unused-imports_exports_input_07rt4kf._.js.map
@@ -3,8 +3,8 @@
   "sources": [],
   "sections": [
     {"offset": {"line": 4, "column": 0}, "map": {"version":3,"sources":["turbopack:///[project]/turbopack/crates/turbopack-tests/tests/snapshot/remove-unused-imports/exports/input/library/leaf.js"],"sourcesContent":["export function leafX() {}\nexport function leafY() {}\n"],"names":["leafX","leafY"],"mappings":"AAAO,SAASA,SAAS;AAClB,SAASC,SAAS"}},
-    {"offset": {"line": 15, "column": 0}, "map": {"version":3,"sources":["turbopack:///[project]/turbopack/crates/turbopack-tests/tests/snapshot/remove-unused-imports/exports/input/library/shared.js"],"sourcesContent":["import { leafX, leafY } from './leaf'\n\nexport function sharedX() {\n  leafX()\n}\nexport function sharedY() {\n  leafY()\n}\n"],"names":["sharedX","sharedY"],"mappings":"AAAA;;AAEO,SAASA;IACd,IAAA,uOAAK;AACP;AACO,SAASC;IACd,IAAA,uOAAK;AACP"}},
+    {"offset": {"line": 15, "column": 0}, "map": {"version":3,"sources":["turbopack:///[project]/turbopack/crates/turbopack-tests/tests/snapshot/remove-unused-imports/exports/input/library/shared.js"],"sourcesContent":["import { leafX, leafY } from './leaf'\n\nexport function sharedX() {\n  leafX()\n}\nexport function sharedY() {\n  leafY()\n}\n"],"names":["sharedX","leafX","sharedY"],"mappings":"AAAA;;AAEO,SAASA;IACdC;AACF;AACO,SAASC;IACd,IAAA,uOAAK;AACP"}},
     {"offset": {"line": 32, "column": 0}, "map": {"version":3,"sources":["turbopack:///[project]/turbopack/crates/turbopack-tests/tests/snapshot/remove-unused-imports/exports/input/library/y.js"],"sourcesContent":["import { sharedY } from './shared'\n\nglobalThis.yBundled = true\n\nexport function y() {\n  sharedY()\n}\n"],"names":["globalThis","yBundled","y"],"mappings":"AAAA;;AAEAA,WAAWC,QAAQ,GAAG;AAEf,SAASC;IACd,IAAA,2OAAO;AACT"}},
-    {"offset": {"line": 47, "column": 0}, "map": {"version":3,"sources":["turbopack:///[project]/turbopack/crates/turbopack-tests/tests/snapshot/remove-unused-imports/exports/input/a.js"],"sourcesContent":["import { x } from './library/x.js'\nimport { y } from './library/y.js'\n\ny()\n\nfunction helper() {\n  return x()\n}\n\nexport function unused() {\n  return helper()\n}\n\nexport function used() {\n  return 1234\n}\n"],"names":["helper","unused","used"],"mappings":"AACA;;;AAEA,IAAA,gOAAC;AAED,SAASA;IACP,OAAO,IAAA,gOAAC;AACV;AAEO,SAASC;IACd,OAAOD;AACT;AAEO,SAASE;IACd,OAAO;AACT"}},
+    {"offset": {"line": 47, "column": 0}, "map": {"version":3,"sources":["turbopack:///[project]/turbopack/crates/turbopack-tests/tests/snapshot/remove-unused-imports/exports/input/a.js"],"sourcesContent":["import { x } from './library/x.js'\nimport { y } from './library/y.js'\n\ny()\n\nfunction helper() {\n  return x()\n}\n\nexport function unused() {\n  return helper()\n}\n\nexport function used() {\n  return 1234\n}\n"],"names":["helper","x","unused","used"],"mappings":"AACA;;;AAEA,IAAA,gOAAC;AAED,SAASA;IACP,OAAOC;AACT;AAEO,SAASC;IACd,OAAOF;AACT;AAEO,SAASG;IACd,OAAO;AACT"}},
     {"offset": {"line": 69, "column": 0}, "map": {"version":3,"sources":["turbopack:///[project]/turbopack/crates/turbopack-tests/tests/snapshot/remove-unused-imports/exports/input/index.js"],"sourcesContent":["import { used } from './a.js'\n\nconsole.log(used)\n"],"names":["console","log"],"mappings":"AAAA;;AAEAA,QAAQC,GAAG,CAAC,wNAAI"}}]
 }
\ No newline at end of file
diff --git a/turbopack/crates/turbopack-trace-server/Cargo.toml b/turbopack/crates/turbopack-trace-server/Cargo.toml
index f98d826a726..62c97b6e0a8 100644
--- a/turbopack/crates/turbopack-trace-server/Cargo.toml
+++ b/turbopack/crates/turbopack-trace-server/Cargo.toml
@@ -28,6 +28,7 @@ rustc-demangle = "0.1"
 rustc-hash = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
+smallvec = { workspace = true }
 turbo-rcstr = { workspace = true }
 turbo-tasks-malloc = { workspace = true, default-features = false }
 tungstenite = { version = "0.21.0" }
diff --git a/turbopack/crates/turbopack-trace-server/src/lazy_sorted_vec.rs b/turbopack/crates/turbopack-trace-server/src/lazy_sorted_vec.rs
index 6b8e5ae0ddf..9e1d4a71297 100644
--- a/turbopack/crates/turbopack-trace-server/src/lazy_sorted_vec.rs
+++ b/turbopack/crates/turbopack-trace-server/src/lazy_sorted_vec.rs
@@ -1,7 +1,15 @@
 use std::{cell::UnsafeCell, ops::Deref, sync::Once};
 
+use smallvec::SmallVec;
+
+/// Backing storage for `LazySortedVec`. Inlines a single element so that
+/// the common case (e.g. a leaf span with one self-time event) does not
+/// pay a heap allocation. With one inline slot plus the workspace's
+/// `union` smallvec feature, this is the same size as a `Vec`.
+type Inner<T> = SmallVec<[T; 1]>;
+
 pub struct LazySortedVec<T> {
-    vec: UnsafeCell<Vec<T>>,
+    vec: UnsafeCell<Inner<T>>,
     once: Once,
 }
 
@@ -11,7 +19,7 @@ unsafe impl<T> Sync for LazySortedVec<T> where T: Sync {}
 impl<T> LazySortedVec<T> {
     pub fn new() -> Self {
         Self {
-            vec: UnsafeCell::new(Vec::new()),
+            vec: UnsafeCell::new(SmallVec::new()),
             once: Once::new(),
         }
     }
@@ -21,8 +29,8 @@ impl<T> LazySortedVec<T> {
         self.vec.get_mut().push(value);
     }
 
-    pub fn retain_unordered(&mut self, f: impl FnMut(&T) -> bool) {
-        self.vec.get_mut().retain(f);
+    pub fn retain_unordered(&mut self, mut f: impl FnMut(&T) -> bool) {
+        self.vec.get_mut().retain(|t| f(t));
     }
 
     pub fn iter_mut_unordered(&mut self) -> std::slice::IterMut<'_, T> {
@@ -31,7 +39,7 @@ impl<T> LazySortedVec<T> {
 }
 
 impl<T: Ord> Deref for LazySortedVec<T> {
-    type Target = Vec<T>;
+    type Target = [T];
 
     fn deref(&self) -> &Self::Target {
         let ptr = self.vec.get();
@@ -44,7 +52,7 @@ impl<T: Ord> Deref for LazySortedVec<T> {
         // SAFETY: Returning this reference is safe because the lifetime guarantees that there is no
         // `&mut self` that could cause a simultaneous access to the `vec`, and the `Once`
         // guarantees that the sorting is complete before we return the reference.
-        unsafe { &*ptr }
+        unsafe { &*ptr }.as_slice()
     }
 }
 
@@ -54,10 +62,19 @@ impl<T> Default for LazySortedVec<T> {
     }
 }
 
+impl<T> From<Inner<T>> for LazySortedVec<T> {
+    fn from(vec: Inner<T>) -> Self {
+        Self {
+            vec: UnsafeCell::new(vec),
+            once: Once::new(),
+        }
+    }
+}
+
 impl<T> From<Vec<T>> for LazySortedVec<T> {
     fn from(vec: Vec<T>) -> Self {
         Self {
-            vec: UnsafeCell::new(vec),
+            vec: UnsafeCell::new(SmallVec::from_vec(vec)),
             once: Once::new(),
         }
     }
diff --git a/turbopack/crates/turbopack-trace-server/src/reader/heaptrack.rs b/turbopack/crates/turbopack-trace-server/src/reader/heaptrack.rs
index b53bea1d835..679545e20fe 100644
--- a/turbopack/crates/turbopack-trace-server/src/reader/heaptrack.rs
+++ b/turbopack/crates/turbopack-trace-server/src/reader/heaptrack.rs
@@ -7,7 +7,12 @@ use rustc_hash::{FxHashMap, FxHashSet};
 use turbo_rcstr::{RcStr, rcstr};
 
 use super::TraceFormat;
-use crate::{FxIndexMap, span::SpanIndex, store_container::StoreContainer, timestamp::Timestamp};
+use crate::{
+    FxIndexMap,
+    span::{SpanArgs, SpanIndex},
+    store_container::StoreContainer,
+    timestamp::Timestamp,
+};
 
 #[derive(Debug, Clone, Copy)]
 struct TraceNode {
@@ -276,7 +281,7 @@ impl TraceFormat for HeaptrackFormat {
                                             self.last_timestamp,
                                             RcStr::default(),
                                             rcstr!("recursion"),
-                                            Vec::new(),
+                                            SpanArgs::new(),
                                             &mut outdated_spans,
                                         );
                                         store.complete_span(span_index);
@@ -321,7 +326,7 @@ impl TraceFormat for HeaptrackFormat {
                     } else {
                         "unknown".to_string()
                     };
-                    let mut args = Vec::new();
+                    let mut args = SpanArgs::new();
                     for Frame {
                         function_index,
                         file_index,
diff --git a/turbopack/crates/turbopack-trace-server/src/self_time_tree.rs b/turbopack/crates/turbopack-trace-server/src/self_time_tree.rs
index e36c2463164..6e9d4c36698 100644
--- a/turbopack/crates/turbopack-trace-server/src/self_time_tree.rs
+++ b/turbopack/crates/turbopack-trace-server/src/self_time_tree.rs
@@ -90,8 +90,12 @@ impl<T> SelfTimeTree<T> {
 
     fn distribute_entries(&mut self) {
         if self.children.is_none() {
-            let start = self.entries.iter().min_by_key(|e| e.start).unwrap().start;
-            let end = self.entries.iter().max_by_key(|e| e.end).unwrap().end;
+            let (start, end) = self
+                .entries
+                .iter()
+                .fold((Timestamp::MAX, Timestamp::ZERO), |(lo, hi), e| {
+                    (lo.min(e.start), hi.max(e.end))
+                });
             let middle = (start + end) / 2;
             // Pre-allocate half the split threshold: after distributing, each child
             // typically receives ~SPLIT_COUNT / 2 entries.
@@ -235,7 +239,6 @@ impl<T> SelfTimeTree<T> {
     }
 
     pub fn lookup_range_corrected_time(&self, start: Timestamp, end: Timestamp) -> Timestamp {
-        let mut factor_times_1000 = 0u64;
         #[derive(PartialEq, Eq, PartialOrd, Ord)]
         enum Change {
             Start,
@@ -253,7 +256,18 @@ impl<T> SelfTimeTree<T> {
                 changes.push((e, Change::End));
             }
         });
+
+        // Fast path: every overlapping interval fully contains `[start, end]`, so the
+        // count is constant over the whole window. Skip the sort and the sweep.
+        if changes.is_empty() {
+            if current_count == 0 {
+                return Timestamp::ZERO;
+            }
+            return Timestamp::from_value(*(end - start) / current_count);
+        }
+
         changes.sort_unstable();
+        let mut factor_times_1000 = 0u64;
         let mut current_ts = start;
         for (ts, change) in changes {
             if current_ts < ts {
@@ -443,4 +457,53 @@ mod tests {
         print_tree(&tree, 0);
         assert_balanced(&tree);
     }
+
+    #[test]
+    fn test_corrected_time_no_overlap() {
+        // No intervals at all — corrected time of an empty range is zero.
+        let tree: SelfTimeTree<u32> = SelfTimeTree::new();
+        let r = tree
+            .lookup_range_corrected_time(Timestamp::from_micros(0), Timestamp::from_micros(100));
+        assert_eq!(r, Timestamp::ZERO);
+    }
+
+    #[test]
+    fn test_corrected_time_single_interval() {
+        // One interval matching the query window exactly: correction factor 1, returns full
+        // duration.
+        let mut tree = SelfTimeTree::new();
+        tree.insert(Timestamp::from_micros(0), Timestamp::from_micros(100), 0u32);
+        let r = tree
+            .lookup_range_corrected_time(Timestamp::from_micros(0), Timestamp::from_micros(100));
+        assert_eq!(r, Timestamp::from_micros(100));
+    }
+
+    #[test]
+    fn test_corrected_time_fast_path_full_containment() {
+        // Two intervals each fully contain [10, 20]: count is 2 throughout, answer = 10/2 = 5us.
+        let mut tree = SelfTimeTree::new();
+        tree.insert(Timestamp::from_micros(0), Timestamp::from_micros(100), 0u32);
+        tree.insert(Timestamp::from_micros(5), Timestamp::from_micros(50), 1u32);
+        let r = tree
+            .lookup_range_corrected_time(Timestamp::from_micros(10), Timestamp::from_micros(20));
+        assert_eq!(r, Timestamp::from_micros(5));
+    }
+
+    #[test]
+    fn test_corrected_time_partial_overlap() {
+        // [0, 100] is the query window. Intervals:
+        //   A: [0, 100]    (covers whole window)
+        //   B: [30, 70]    (fully inside, contributes corrections during [30, 70])
+        // Expected:
+        //   [0, 30):  count=1, time=30, corrected = 30 / 1 = 30
+        //   [30, 70): count=2, time=40, corrected = 40 / 2 = 20
+        //   [70, 100): count=1, time=30, corrected = 30 / 1 = 30
+        // Total: 80us
+        let mut tree = SelfTimeTree::new();
+        tree.insert(Timestamp::from_micros(0), Timestamp::from_micros(100), 0u32);
+        tree.insert(Timestamp::from_micros(30), Timestamp::from_micros(70), 1u32);
+        let r = tree
+            .lookup_range_corrected_time(Timestamp::from_micros(0), Timestamp::from_micros(100));
+        assert_eq!(r, Timestamp::from_micros(80));
+    }
 }
diff --git a/turbopack/crates/turbopack-trace-server/src/span.rs b/turbopack/crates/turbopack-trace-server/src/span.rs
index d3c60789f76..ec480b8151e 100644
--- a/turbopack/crates/turbopack-trace-server/src/span.rs
+++ b/turbopack/crates/turbopack-trace-server/src/span.rs
@@ -1,15 +1,21 @@
 use std::{
-    num::NonZeroUsize,
+    num::{NonZeroU64, NonZeroUsize},
     sync::{Arc, OnceLock},
 };
 
 use hashbrown::HashMap;
+use smallvec::SmallVec;
 use turbo_rcstr::RcStr;
 
 use crate::{lazy_sorted_vec::LazySortedVec, timestamp::Timestamp};
 
 pub type SpanIndex = NonZeroUsize;
 
+/// Storage for `Span::args` ~32% of spans have <=1 arg (typically just the
+/// `name` key for `turbo_tasks::function` spans), so inlining one entry
+/// avoids a heap allocation in this common case.
+pub type SpanArgs = SmallVec<[(RcStr, RcStr); 1]>;
+
 pub struct Span {
     // These values won't change after creation:
     pub parent: Option<SpanIndex>,
@@ -17,10 +23,12 @@ pub struct Span {
     pub start: Timestamp,
     pub category: RcStr,
     pub name: RcStr,
-    pub args: Vec<(RcStr, RcStr)>,
+    pub args: SpanArgs,
 
     // This might change during writing:
-    /// The list of events sorted by start time
+    /// The list of events sorted by start time. Backed by a SmallVec so leaf
+    /// spans (~69%, typically just one self-time event) don't pay a heap
+    /// allocation.
     pub events: LazySortedVec<SpanEvent>,
     pub is_complete: bool,
 
@@ -30,18 +38,26 @@ pub struct Span {
     pub self_deallocations: u64,
     pub self_deallocation_count: u64,
 
-    // These values are computed when accessed (and maybe deleted during writing):
-    pub max_depth: OnceLock<u32>,
-    pub total_allocations: OnceLock<u64>,
-    pub total_deallocations: OnceLock<u64>,
-    pub total_persistent_allocations: OnceLock<u64>,
-    pub total_span_count: OnceLock<u64>,
-    pub total_allocation_count: OnceLock<u64>,
-
-    // More nested fields, but memory lazily allocated
-    pub time_data: OnceLock<Box<SpanTimeData>>,
+    // These values are computed when accessed (and maybe deleted during writing).
+    // Bundling the subtree totals into a single OnceLock pays a small cost on
+    // partial reads in exchange for a much-reduced lock count per Span.
+    pub totals: OnceLock<SpanTotals>,
+    pub time_data: SpanTimeData,
     pub extra: OnceLock<Box<SpanExtra>>,
-    pub names: OnceLock<Box<SpanNames>>,
+    /// Lazy first-touch via `OnceLock`, but inline rather than boxed: ~96% of
+    /// spans get names populated after browsing, never invalidated, so the box
+    /// indirection is pure overhead.
+    pub names: OnceLock<SpanNames>,
+}
+
+#[derive(Default)]
+pub struct SpanTotals {
+    pub max_depth: u32,
+    pub allocations: u64,
+    pub deallocations: u64,
+    pub persistent_allocations: u64,
+    pub allocation_count: u64,
+    pub span_count: u64,
 }
 
 #[derive(Default)]
@@ -69,56 +85,127 @@ pub struct SpanExtra {
     pub search_index: OnceLock<HashMap<RcStr, Vec<SpanIndex>>>,
 }
 
-#[derive(Default)]
+#[derive(Clone)]
+pub struct SpanName {
+    pub category: RcStr,
+    pub title: RcStr,
+}
+
 pub struct SpanNames {
-    // These values are computed when accessed (and maybe deleted during writing):
-    pub nice_name: OnceLock<(RcStr, RcStr)>,
-    pub group_name: OnceLock<(RcStr, RcStr)>,
+    pub nice_name: SpanName,
+    pub group_name: SpanName,
 }
 
 impl Span {
-    pub fn time_data(&self) -> &SpanTimeData {
-        self.time_data.get_or_init(|| {
-            Box::new(SpanTimeData {
-                self_end: self.start,
-                ignore_self_time: &self.name == "thread" || &self.name == "blocking",
-                ..Default::default()
-            })
-        })
-    }
-
-    pub fn time_data_mut(&mut self) -> &mut SpanTimeData {
-        self.time_data();
-        self.time_data.get_mut().unwrap()
-    }
-
     pub fn extra(&self) -> &SpanExtra {
         self.extra.get_or_init(Default::default)
     }
 
     pub fn names(&self) -> &SpanNames {
-        self.names.get_or_init(Default::default)
+        self.names.get_or_init(|| self.compute_names())
+    }
+
+    fn compute_names(&self) -> SpanNames {
+        // Classify the span. `turbo_tasks::function` and the resolve-call spans
+        // get special-cased rendering when they carry a `name` arg; everything
+        // else is rendered generically.
+        enum Kind {
+            Function,
+            Resolve,
+            Other,
+        }
+        let kind = match self.name.as_str() {
+            "turbo_tasks::function" => Kind::Function,
+            "turbo_tasks::resolve_call" | "turbo_tasks::resolve_trait_call" => Kind::Resolve,
+            _ => Kind::Other,
+        };
+        let arg_name = self.args.iter().find(|&(k, _)| k == "name").map(|(_, v)| v);
+
+        // Generic fallback used by both names whenever no special case applies.
+        let generic = || SpanName {
+            category: self.category.clone(),
+            title: self.name.clone(),
+        };
+
+        // Each arm constructs the full `SpanNames` so the relationship between
+        // `nice_name` and `group_name` is visible at a glance. The `Some(n)`
+        // rows handle the "this span carries a `name` arg" case; the `None`
+        // arm falls back to the generic shape for both names — including for
+        // function/resolve spans, which (in practice) always carry a name arg,
+        // so the fallback is mostly defensive.
+        match (kind, arg_name) {
+            (Kind::Function, Some(n)) => {
+                let pretty = SpanName {
+                    category: self.name.clone(),
+                    title: n.clone(),
+                };
+                SpanNames {
+                    nice_name: pretty.clone(),
+                    group_name: pretty,
+                }
+            }
+            (Kind::Resolve, Some(n)) => SpanNames {
+                nice_name: SpanName {
+                    category: self.name.clone(),
+                    title: format!("*{n}").into(),
+                },
+                group_name: SpanName {
+                    category: self.category.clone(),
+                    title: format!("{} *{n}", self.name).into(),
+                },
+            },
+            (Kind::Other, Some(n)) => SpanNames {
+                nice_name: SpanName {
+                    category: self.category.clone(),
+                    title: format!("{} {n}", self.name).into(),
+                },
+                group_name: generic(),
+            },
+            (_, None) => SpanNames {
+                nice_name: generic(),
+                group_name: generic(),
+            },
+        }
     }
 }
 
+/// Stores `duration` as `NonZeroU64` so the variant has a niche; combined with
+/// `Child`'s `NonZeroUsize` index, this lets the compiler pack `SpanEvent`
+/// without a separate discriminant byte (saving 8 bytes per event vs. an
+/// `end: Timestamp` layout). Callers must filter zero-duration self-time
+/// events before constructing — see [`SpanEvent::self_time`].
 pub struct SpanEventSelfTime {
     pub start: Timestamp,
-    pub end: Timestamp,
+    pub duration: NonZeroU64,
     pub corrected_self_time: OnceLock<Timestamp>,
 }
 
+impl SpanEventSelfTime {
+    pub fn end(&self) -> Timestamp {
+        Timestamp::from_value(*self.start + self.duration.get())
+    }
+}
+
 pub enum SpanEvent {
     SelfTime(SpanEventSelfTime),
     Child { start: Timestamp, index: SpanIndex },
 }
 
+// 32 bytes = 8 (start) + 8 (duration) + 16 (OnceLock<Timestamp>) for the
+// SelfTime variant; the Child variant fits in 16 and uses the niche, so no
+// extra discriminant byte is needed.
+const _: () = assert!(std::mem::size_of::<SpanEvent>() == 32);
+
 impl SpanEvent {
-    pub fn self_time(start: Timestamp, end: Timestamp) -> Self {
-        Self::SelfTime(SpanEventSelfTime {
+    /// Constructs a `SelfTime` event from start and end timestamps. Returns `None`
+    /// if `end <= start` (zero or negative duration).
+    pub fn self_time(start: Timestamp, end: Timestamp) -> Option<Self> {
+        let duration = NonZeroU64::new(*end.saturating_sub(start))?;
+        Some(SpanEvent::SelfTime(SpanEventSelfTime {
             start,
-            end,
+            duration,
             corrected_self_time: OnceLock::new(),
-        })
+        }))
     }
 
     pub fn start(&self) -> Timestamp {
@@ -150,7 +237,7 @@ impl Ord for SpanEvent {
             .then_with(|| match (self, other) {
                 (SpanEvent::SelfTime(_), SpanEvent::Child { .. }) => std::cmp::Ordering::Less,
                 (SpanEvent::Child { .. }, SpanEvent::SelfTime(_)) => std::cmp::Ordering::Greater,
-                (SpanEvent::SelfTime(a), SpanEvent::SelfTime(b)) => a.end.cmp(&b.end),
+                (SpanEvent::SelfTime(a), SpanEvent::SelfTime(b)) => a.duration.cmp(&b.duration),
                 (
                     SpanEvent::Child { start: _, index: a },
                     SpanEvent::Child { start: _, index: b },
@@ -233,3 +320,38 @@ impl SpanBottomUp {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn span_event_self_time_filters_zero_duration() {
+        let t = Timestamp::from_micros(100);
+        assert!(SpanEvent::self_time(t, t).is_none());
+        // end < start should also return None (saturating_sub clamps to 0).
+        assert!(SpanEvent::self_time(t, Timestamp::from_micros(50)).is_none());
+    }
+
+    #[test]
+    fn span_event_self_time_constructs_positive_duration() {
+        let start = Timestamp::from_micros(100);
+        let end = Timestamp::from_micros(150);
+        let event = SpanEvent::self_time(start, end).unwrap();
+        match event {
+            SpanEvent::SelfTime(self_time) => {
+                assert_eq!(self_time.start, start);
+                assert_eq!(self_time.duration.get(), *end - *start);
+                assert_eq!(self_time.end(), end);
+            }
+            SpanEvent::Child { .. } => panic!("expected SelfTime"),
+        }
+    }
+
+    #[test]
+    fn span_event_size_is_packed() {
+        // Backstop for the const assert; if this fails the const assert above
+        // would also fail, but having a test gives a clearer error message.
+        assert_eq!(std::mem::size_of::<SpanEvent>(), 32);
+    }
+}
diff --git a/turbopack/crates/turbopack-trace-server/src/span_ref.rs b/turbopack/crates/turbopack-trace-server/src/span_ref.rs
index 0dfb41aa4b7..62bb695f852 100644
--- a/turbopack/crates/turbopack-trace-server/src/span_ref.rs
+++ b/turbopack/crates/turbopack-trace-server/src/span_ref.rs
@@ -14,8 +14,8 @@ use crate::{
     FxIndexMap,
     bottom_up::build_bottom_up_graph,
     span::{
-        Span, SpanEvent, SpanEventSelfTime, SpanExtra, SpanGraphEvent, SpanIndex, SpanNames,
-        SpanTimeData,
+        Span, SpanEvent, SpanEventSelfTime, SpanExtra, SpanGraphEvent, SpanIndex, SpanName,
+        SpanNames, SpanTimeData, SpanTotals,
     },
     span_bottom_up_ref::SpanBottomUpRef,
     span_graph_ref::{SpanGraphEventRef, SpanGraphRef, event_map_to_list},
@@ -55,7 +55,7 @@ impl<'a> SpanRef<'a> {
     }
 
     pub fn time_data(&self) -> &'a SpanTimeData {
-        self.span.time_data()
+        &self.span.time_data
     }
 
     pub fn extra(&self) -> &'a SpanExtra {
@@ -88,64 +88,12 @@ impl<'a> SpanRef<'a> {
     }
 
     pub fn nice_name(&self) -> (&'a str, &'a str) {
-        let (category, title) = self.names().nice_name.get_or_init(|| {
-            if let Some(name) = self
-                .span
-                .args
-                .iter()
-                .find(|&(k, _)| k == "name")
-                .map(|(_, v)| v)
-            {
-                if matches!(self.span.name.as_str(), "turbo_tasks::function") {
-                    (self.span.name.clone(), name.clone())
-                } else if matches!(
-                    self.span.name.as_str(),
-                    "turbo_tasks::resolve_call" | "turbo_tasks::resolve_trait_call"
-                ) {
-                    (self.span.name.clone(), format!("*{name}").into())
-                } else {
-                    (
-                        self.span.category.clone(),
-                        format!("{} {name}", self.span.name).into(),
-                    )
-                }
-            } else {
-                (self.span.category.clone(), self.span.name.clone())
-            }
-        });
+        let SpanName { category, title } = &self.names().nice_name;
         (category.as_str(), title.as_str())
     }
 
     pub fn group_name(&self) -> (&'a str, &'a str) {
-        let (category, title) = self.names().group_name.get_or_init(|| {
-            if matches!(self.span.name.as_str(), "turbo_tasks::function") {
-                let name = self
-                    .span
-                    .args
-                    .iter()
-                    .find(|&(k, _)| k == "name")
-                    .map(|(_, v)| v.clone())
-                    .unwrap_or_else(|| self.span.name.clone());
-                (self.span.name.clone(), name)
-            } else if matches!(
-                self.span.name.as_str(),
-                "turbo_tasks::resolve_call" | "turbo_tasks::resolve_trait_call"
-            ) {
-                let name = self
-                    .span
-                    .args
-                    .iter()
-                    .find(|&(k, _)| k == "name")
-                    .map(|(_, v)| RcStr::from(format!("*{v}")))
-                    .unwrap_or_else(|| self.span.name.clone());
-                (
-                    self.span.category.clone(),
-                    format!("{} {name}", self.span.name).into(),
-                )
-            } else {
-                (self.span.category.clone(), self.span.name.clone())
-            }
-        });
+        let SpanName { category, title } = &self.names().group_name;
         (category.as_str(), title.as_str())
     }
 
@@ -236,54 +184,52 @@ impl<'a> SpanRef<'a> {
         })
     }
 
-    pub fn total_allocations(&self) -> u64 {
-        *self.span.total_allocations.get_or_init(|| {
-            self.children()
-                .map(|child| child.total_allocations())
-                .reduce(|a, b| a + b)
-                .unwrap_or_default()
-                + self.self_allocations()
+    /// Compute (or fetch) the bundled subtree totals. All six totals share a
+    /// single `OnceLock`, so the first call walks the subtree once and fills
+    /// every field; subsequent calls return cached values. Children's bundles
+    /// are computed recursively, so depth-many calls happen once per subtree
+    /// regardless of which field is queried first.
+    fn totals(&self) -> &'a SpanTotals {
+        self.span.totals.get_or_init(|| {
+            let mut t = SpanTotals {
+                max_depth: 0,
+                allocations: self.self_allocations(),
+                deallocations: self.self_deallocations(),
+                persistent_allocations: self.self_persistent_allocations(),
+                allocation_count: self.self_allocation_count(),
+                span_count: 1,
+            };
+            for child in self.children() {
+                let c = child.totals();
+                t.max_depth = max(t.max_depth, c.max_depth + 1);
+                t.allocations += c.allocations;
+                t.deallocations += c.deallocations;
+                t.persistent_allocations += c.persistent_allocations;
+                t.allocation_count += c.allocation_count;
+                t.span_count += c.span_count;
+            }
+            t
         })
     }
 
+    pub fn total_allocations(&self) -> u64 {
+        self.totals().allocations
+    }
+
     pub fn total_deallocations(&self) -> u64 {
-        *self.span.total_deallocations.get_or_init(|| {
-            self.children()
-                .map(|child| child.total_deallocations())
-                .reduce(|a, b| a + b)
-                .unwrap_or_default()
-                + self.self_deallocations()
-        })
+        self.totals().deallocations
     }
 
     pub fn total_persistent_allocations(&self) -> u64 {
-        *self.span.total_persistent_allocations.get_or_init(|| {
-            self.children()
-                .map(|child| child.total_persistent_allocations())
-                .reduce(|a, b| a + b)
-                .unwrap_or_default()
-                + self.self_persistent_allocations()
-        })
+        self.totals().persistent_allocations
     }
 
     pub fn total_allocation_count(&self) -> u64 {
-        *self.span.total_allocation_count.get_or_init(|| {
-            self.children()
-                .map(|child| child.total_allocation_count())
-                .reduce(|a, b| a + b)
-                .unwrap_or_default()
-                + self.self_allocation_count()
-        })
+        self.totals().allocation_count
     }
 
     pub fn total_span_count(&self) -> u64 {
-        *self.span.total_span_count.get_or_init(|| {
-            self.children()
-                .map(|child| child.total_span_count())
-                .reduce(|a, b| a + b)
-                .unwrap_or_default()
-                + 1
-        })
+        self.totals().span_count
     }
 
     pub fn corrected_self_time(&self) -> Timestamp {
@@ -319,12 +265,7 @@ impl<'a> SpanRef<'a> {
     }
 
     pub fn max_depth(&self) -> u32 {
-        *self.span.max_depth.get_or_init(|| {
-            self.children()
-                .map(|child| child.max_depth() + 1)
-                .max()
-                .unwrap_or_default()
-        })
+        self.totals().max_depth
     }
 
     pub fn graph(&self) -> impl Iterator<Item = SpanGraphEventRef<'a>> + '_ {
@@ -571,20 +512,19 @@ impl<'a> SpanEventSelfTimeRef<'a> {
     }
 
     pub fn end(&self) -> Timestamp {
-        self.self_time.end
+        self.self_time.end()
     }
 
     pub fn corrected_self_time(&self) -> Timestamp {
         *self.self_time.corrected_self_time.get_or_init(|| {
-            let duration = self.self_time.end - self.self_time.start;
-            if !duration.is_zero() {
-                self.store.set_max_self_time_lookup(self.self_time.end);
-                self.store.self_time_tree.as_ref().map_or(duration, |tree| {
-                    tree.lookup_range_corrected_time(self.self_time.start, self.self_time.end)
-                })
-            } else {
-                Timestamp::ZERO
-            }
+            // `duration` is `NonZeroU64`, so zero-duration events are filtered
+            // at construction time (see `SpanEvent::self_time`).
+            let end = self.self_time.end();
+            let duration = Timestamp::from_value(self.self_time.duration.get());
+            self.store.set_max_self_time_lookup(end);
+            self.store.self_time_tree.as_ref().map_or(duration, |tree| {
+                tree.lookup_range_corrected_time(self.self_time.start, end)
+            })
         })
     }
 }
@@ -611,3 +551,115 @@ impl SpanEventRef<'_> {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use rustc_hash::FxHashSet;
+    use turbo_rcstr::RcStr;
+
+    use crate::{span::SpanArgs, span_ref::SpanRef, store::Store, timestamp::Timestamp};
+
+    fn span_ref<'a>(store: &'a Store, idx: crate::span::SpanIndex) -> SpanRef<'a> {
+        SpanRef {
+            span: &store.spans[idx.get()],
+            store,
+            index: idx.get(),
+        }
+    }
+
+    #[test]
+    fn totals_aggregate_subtree() {
+        let mut store = Store::new();
+        let mut outdated = FxHashSet::default();
+
+        // root → a → b
+        // root → c
+        let a = store.add_span(
+            None,
+            Timestamp::from_micros(0),
+            RcStr::default(),
+            RcStr::from("a"),
+            SpanArgs::new(),
+            &mut outdated,
+        );
+        let b = store.add_span(
+            Some(a),
+            Timestamp::from_micros(1),
+            RcStr::default(),
+            RcStr::from("b"),
+            SpanArgs::new(),
+            &mut outdated,
+        );
+        let c = store.add_span(
+            None,
+            Timestamp::from_micros(2),
+            RcStr::default(),
+            RcStr::from("c"),
+            SpanArgs::new(),
+            &mut outdated,
+        );
+
+        // Use values large enough that the 32-byte/4-allocation tracing
+        // overhead subtraction in `self_allocations()` / `self_allocation_count()`
+        // doesn't dominate.
+        store.add_allocation(a, 1000, 10, &mut outdated);
+        store.add_allocation(b, 500, 5, &mut outdated);
+        store.add_allocation(c, 200, 2, &mut outdated);
+
+        let a_ref = span_ref(&store, a);
+        let b_ref = span_ref(&store, b);
+        let c_ref = span_ref(&store, c);
+
+        // Sanity: per-span self_* values reflect the saturating overhead subtraction.
+        assert_eq!(a_ref.self_allocations(), 1000 - 32);
+        assert_eq!(b_ref.self_allocations(), 500 - 32);
+        assert_eq!(c_ref.self_allocations(), 200 - 32);
+
+        // Totals are the recursive subtree sum of self_*.
+        assert_eq!(
+            a_ref.total_allocations(),
+            a_ref.self_allocations() + b_ref.self_allocations()
+        );
+        assert_eq!(b_ref.total_allocations(), b_ref.self_allocations());
+        assert_eq!(c_ref.total_allocations(), c_ref.self_allocations());
+
+        // span_count is 1 + child count.
+        assert_eq!(a_ref.total_span_count(), 2);
+        assert_eq!(b_ref.total_span_count(), 1);
+        assert_eq!(c_ref.total_span_count(), 1);
+
+        // total_allocation_count similarly.
+        assert_eq!(
+            a_ref.total_allocation_count(),
+            a_ref.self_allocation_count() + b_ref.self_allocation_count()
+        );
+    }
+
+    #[test]
+    fn totals_invalidate_and_recompute() {
+        let mut store = Store::new();
+        let mut outdated = FxHashSet::default();
+        let s = store.add_span(
+            None,
+            Timestamp::from_micros(0),
+            RcStr::default(),
+            RcStr::from("s"),
+            SpanArgs::new(),
+            &mut outdated,
+        );
+        store.add_allocation(s, 1000, 10, &mut outdated);
+
+        // Cache the totals.
+        let before = span_ref(&store, s).total_allocations();
+        assert_eq!(before, 1000 - 32);
+
+        // Add more allocations and invalidate.
+        let mut outdated = FxHashSet::default();
+        store.add_allocation(s, 200, 2, &mut outdated);
+        store.invalidate_outdated_spans(&outdated);
+
+        // After invalidation, the cached totals must be recomputed from new self_*.
+        let after = span_ref(&store, s).total_allocations();
+        assert_eq!(after, 1200 - 32);
+    }
+}
diff --git a/turbopack/crates/turbopack-trace-server/src/store.rs b/turbopack/crates/turbopack-trace-server/src/store.rs
index 74c6f4406d7..47ca38fdc0e 100644
--- a/turbopack/crates/turbopack-trace-server/src/store.rs
+++ b/turbopack/crates/turbopack-trace-server/src/store.rs
@@ -10,7 +10,7 @@ use turbo_rcstr::{RcStr, rcstr};
 
 use crate::{
     self_time_tree::SelfTimeTree,
-    span::{Span, SpanEvent, SpanIndex},
+    span::{Span, SpanArgs, SpanEvent, SpanIndex, SpanTimeData},
     span_ref::SpanRef,
     timestamp::Timestamp,
 };
@@ -45,20 +45,18 @@ fn new_root_span() -> Span {
         start: Timestamp::MAX,
         category: RcStr::default(),
         name: rcstr!("(root)"),
-        args: vec![],
+        args: SpanArgs::new(),
         events: Default::default(),
         is_complete: true,
-        max_depth: OnceLock::new(),
         self_allocations: 0,
         self_allocation_count: 0,
         self_deallocations: 0,
         self_deallocation_count: 0,
-        total_allocations: OnceLock::new(),
-        total_deallocations: OnceLock::new(),
-        total_persistent_allocations: OnceLock::new(),
-        total_allocation_count: OnceLock::new(),
-        total_span_count: OnceLock::new(),
-        time_data: OnceLock::new(),
+        totals: OnceLock::new(),
+        time_data: SpanTimeData {
+            self_end: Timestamp::MAX,
+            ..Default::default()
+        },
         extra: OnceLock::new(),
         names: OnceLock::new(),
     }
@@ -109,10 +107,11 @@ impl Store {
         start: Timestamp,
         category: RcStr,
         name: RcStr,
-        args: Vec<(RcStr, RcStr)>,
+        args: SpanArgs,
         outdated_spans: &mut FxHashSet<SpanIndex>,
     ) -> SpanIndex {
         let id = SpanIndex::new(self.spans.len()).unwrap();
+        let ignore_self_time = &name == "thread" || &name == "blocking";
         self.spans.push(Span {
             parent,
             depth: 0,
@@ -120,19 +119,18 @@ impl Store {
             category,
             name,
             args,
-            events: vec![].into(),
+            events: Default::default(),
             is_complete: false,
-            max_depth: OnceLock::new(),
             self_allocations: 0,
             self_allocation_count: 0,
             self_deallocations: 0,
             self_deallocation_count: 0,
-            total_allocations: OnceLock::new(),
-            total_deallocations: OnceLock::new(),
-            total_persistent_allocations: OnceLock::new(),
-            total_allocation_count: OnceLock::new(),
-            total_span_count: OnceLock::new(),
-            time_data: OnceLock::new(),
+            totals: OnceLock::new(),
+            time_data: SpanTimeData {
+                self_end: start,
+                ignore_self_time,
+                ..Default::default()
+            },
             extra: OnceLock::new(),
             names: OnceLock::new(),
         });
@@ -213,16 +211,19 @@ impl Store {
         end: Timestamp,
         outdated_spans: &mut FxHashSet<SpanIndex>,
     ) {
+        let event = SpanEvent::self_time(start, end);
         let span = &mut self.spans[span_index.get()];
-        let time_data = span.time_data_mut();
+        let time_data = &mut span.time_data;
         if time_data.ignore_self_time {
             return;
         }
         outdated_spans.insert(span_index);
         time_data.self_time += end - start;
         time_data.self_end = max(time_data.self_end, end);
-        span.events.push(SpanEvent::self_time(start, end));
-        self.insert_self_time(start, end, span_index, outdated_spans);
+        if let Some(event) = event {
+            span.events.push(event);
+            self.insert_self_time(start, end, span_index, outdated_spans);
+        }
     }
 
     pub fn set_total_time(
@@ -239,7 +240,7 @@ impl Store {
         };
         let mut children = span
             .children()
-            .map(|c| (c.span.start, c.span.time_data().self_end, c.index()))
+            .map(|c| (c.span.start, c.span.time_data.self_end, c.index()))
             .collect::<Vec<_>>();
         children.sort();
         let self_end = start_time + total_time;
@@ -249,14 +250,18 @@ impl Store {
         for (start, end, index) in children {
             if start > current {
                 if start > self_end {
-                    events.push(SpanEvent::self_time(current, self_end));
-                    self.insert_self_time(current, self_end, span_index, outdated_spans);
-                    self_time += self_end - current;
+                    if let Some(event) = SpanEvent::self_time(current, self_end) {
+                        events.push(event);
+                        self.insert_self_time(current, self_end, span_index, outdated_spans);
+                        self_time += self_end - current;
+                    }
                     break;
                 }
-                events.push(SpanEvent::self_time(current, start));
-                self.insert_self_time(current, start, span_index, outdated_spans);
-                self_time += start - current;
+                if let Some(event) = SpanEvent::self_time(current, start) {
+                    events.push(event);
+                    self.insert_self_time(current, start, span_index, outdated_spans);
+                    self_time += start - current;
+                }
             }
             events.push(SpanEvent::Child { start, index });
             current = max(current, end);
@@ -264,20 +269,16 @@ impl Store {
         current -= start_time;
         if current < total_time {
             self_time += total_time - current;
-            events.push(SpanEvent::self_time(
-                current + start_time,
-                start_time + total_time,
-            ));
-            self.insert_self_time(
-                current + start_time,
-                start_time + total_time,
-                span_index,
-                outdated_spans,
-            );
+            let st = current + start_time;
+            let en = start_time + total_time;
+            if let Some(event) = SpanEvent::self_time(st, en) {
+                events.push(event);
+                self.insert_self_time(st, en, span_index, outdated_spans);
+            }
         }
         let span = &mut self.spans[span_index.get()];
         outdated_spans.insert(span_index);
-        let time_data = span.time_data_mut();
+        let time_data = &mut span.time_data;
         time_data.self_time = self_time;
         time_data.self_end = self_end;
         span.events = events.into();
@@ -385,22 +386,16 @@ impl Store {
 
     pub fn invalidate_outdated_spans(&mut self, outdated_spans: &FxHashSet<SpanId>) {
         fn invalidate_span(span: &mut Span) {
-            if let Some(time_data) = span.time_data.get_mut() {
-                time_data.end.take();
-                time_data.total_time.take();
-                time_data.corrected_self_time.take();
-                time_data.corrected_total_time.take();
-            }
+            span.time_data.end.take();
+            span.time_data.total_time.take();
+            span.time_data.corrected_self_time.take();
+            span.time_data.corrected_total_time.take();
             for event in span.events.iter_mut_unordered() {
                 if let SpanEvent::SelfTime(self_time) = event {
                     self_time.corrected_self_time.take();
                 }
             }
-            span.total_allocations.take();
-            span.total_deallocations.take();
-            span.total_persistent_allocations.take();
-            span.total_allocation_count.take();
-            span.total_span_count.take();
+            span.totals.take();
             span.extra.take();
         }
 
diff --git a/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/imports/.gitignore b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/imports/.gitignore
new file mode 100644
index 00000000000..a9412d2d9e9
--- /dev/null
+++ b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/imports/.gitignore
@@ -0,0 +1,2 @@
+# include node_modules for testing
+!node_modules 
diff --git a/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/imports/input.js b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/imports/input.js
index 8e507194d98..78cbc7ac107 100644
--- a/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/imports/input.js
+++ b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/imports/input.js
@@ -1,2 +1,5 @@
 import { x } from '#x'
 console.log(x)
+
+import { pkg } from '#pkg'
+console.log(pkg)
diff --git a/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/imports/node_modules/pkg/index.js b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/imports/node_modules/pkg/index.js
new file mode 100644
index 00000000000..97a8aff4164
--- /dev/null
+++ b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/imports/node_modules/pkg/index.js
@@ -0,0 +1 @@
+export const pkg = 'pkg'
diff --git a/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/imports/output.js b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/imports/output.js
index 2194c2c4617..b1158136694 100644
--- a/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/imports/output.js
+++ b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/imports/output.js
@@ -1,5 +1,6 @@
 ;[
   'test/unit/imports/input.js',
   'test/unit/imports/node.js',
+  'test/unit/imports/node_modules/pkg/index.js',
   'test/unit/imports/package.json',
 ]
diff --git a/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/imports/package.json b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/imports/package.json
index c137c0a885d..4efe69bd7cb 100644
--- a/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/imports/package.json
+++ b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/imports/package.json
@@ -7,6 +7,7 @@
       "default": {
         "node": "./node.js"
       }
-    }
+    },
+    "#pkg": "pkg"
   }
 }
diff --git a/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-constructor/.gitignore b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-constructor/.gitignore
new file mode 100644
index 00000000000..cf4bab9ddde
--- /dev/null
+++ b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-constructor/.gitignore
@@ -0,0 +1 @@
+!node_modules
diff --git a/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-constructor/input.js b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-constructor/input.js
new file mode 100644
index 00000000000..d8ad9edf24a
--- /dev/null
+++ b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-constructor/input.js
@@ -0,0 +1,6 @@
+import pino from 'pino'
+const logger = pino({
+  transport: {
+    target: 'my-pino-transport',
+  },
+})
diff --git a/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-constructor/node_modules/my-pino-transport/index.js b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-constructor/node_modules/my-pino-transport/index.js
new file mode 100644
index 00000000000..37d7332f73a
--- /dev/null
+++ b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-constructor/node_modules/my-pino-transport/index.js
@@ -0,0 +1 @@
+module.exports = function () {}
diff --git a/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-constructor/node_modules/my-pino-transport/package.json b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-constructor/node_modules/my-pino-transport/package.json
new file mode 100644
index 00000000000..d594a426e60
--- /dev/null
+++ b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-constructor/node_modules/my-pino-transport/package.json
@@ -0,0 +1,4 @@
+{
+  "name": "my-pino-transport",
+  "main": "index.js"
+}
diff --git a/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-constructor/node_modules/pino/index.js b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-constructor/node_modules/pino/index.js
new file mode 100644
index 00000000000..0865ac461ac
--- /dev/null
+++ b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-constructor/node_modules/pino/index.js
@@ -0,0 +1,2 @@
+module.exports = function pino() {}
+module.exports.transport = function transport() {}
diff --git a/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-constructor/node_modules/pino/package.json b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-constructor/node_modules/pino/package.json
new file mode 100644
index 00000000000..0c3a11ad6f3
--- /dev/null
+++ b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-constructor/node_modules/pino/package.json
@@ -0,0 +1,4 @@
+{
+  "name": "pino",
+  "main": "index.js"
+}
diff --git a/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-constructor/output.js b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-constructor/output.js
new file mode 100644
index 00000000000..7ca02977b1a
--- /dev/null
+++ b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-constructor/output.js
@@ -0,0 +1,8 @@
+;[
+  'test/unit/pino-transport-constructor/input.js',
+  'test/unit/pino-transport-constructor/node_modules/my-pino-transport/index.js',
+  'test/unit/pino-transport-constructor/node_modules/my-pino-transport/package.json',
+  'test/unit/pino-transport-constructor/node_modules/pino/index.js',
+  'test/unit/pino-transport-constructor/node_modules/pino/package.json',
+  'test/unit/pino-transport-constructor/package.json',
+]
diff --git a/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-constructor/package.json b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-constructor/package.json
new file mode 100644
index 00000000000..e986b24bbae
--- /dev/null
+++ b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-constructor/package.json
@@ -0,0 +1,4 @@
+{
+  "private": true,
+  "type": "module"
+}
diff --git a/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-fastify/.gitignore b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-fastify/.gitignore
new file mode 100644
index 00000000000..cf4bab9ddde
--- /dev/null
+++ b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-fastify/.gitignore
@@ -0,0 +1 @@
+!node_modules
diff --git a/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-fastify/input.js b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-fastify/input.js
new file mode 100644
index 00000000000..7c3a973c072
--- /dev/null
+++ b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-fastify/input.js
@@ -0,0 +1,8 @@
+import fastify from 'fastify'
+const app = fastify({
+  logger: {
+    transport: {
+      target: 'my-pino-transport',
+    },
+  },
+})
diff --git a/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-fastify/node_modules/fastify/index.js b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-fastify/node_modules/fastify/index.js
new file mode 100644
index 00000000000..d187b5ddbae
--- /dev/null
+++ b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-fastify/node_modules/fastify/index.js
@@ -0,0 +1 @@
+module.exports = function fastify() {}
diff --git a/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-fastify/node_modules/fastify/package.json b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-fastify/node_modules/fastify/package.json
new file mode 100644
index 00000000000..47a1597f2c8
--- /dev/null
+++ b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-fastify/node_modules/fastify/package.json
@@ -0,0 +1,4 @@
+{
+  "name": "fastify",
+  "main": "index.js"
+}
diff --git a/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-fastify/node_modules/my-pino-transport/index.js b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-fastify/node_modules/my-pino-transport/index.js
new file mode 100644
index 00000000000..37d7332f73a
--- /dev/null
+++ b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-fastify/node_modules/my-pino-transport/index.js
@@ -0,0 +1 @@
+module.exports = function () {}
diff --git a/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-fastify/node_modules/my-pino-transport/package.json b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-fastify/node_modules/my-pino-transport/package.json
new file mode 100644
index 00000000000..d594a426e60
--- /dev/null
+++ b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-fastify/node_modules/my-pino-transport/package.json
@@ -0,0 +1,4 @@
+{
+  "name": "my-pino-transport",
+  "main": "index.js"
+}
diff --git a/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-fastify/node_modules/pino/index.js b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-fastify/node_modules/pino/index.js
new file mode 100644
index 00000000000..0865ac461ac
--- /dev/null
+++ b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-fastify/node_modules/pino/index.js
@@ -0,0 +1,2 @@
+module.exports = function pino() {}
+module.exports.transport = function transport() {}
diff --git a/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-fastify/node_modules/pino/package.json b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-fastify/node_modules/pino/package.json
new file mode 100644
index 00000000000..0c3a11ad6f3
--- /dev/null
+++ b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-fastify/node_modules/pino/package.json
@@ -0,0 +1,4 @@
+{
+  "name": "pino",
+  "main": "index.js"
+}
diff --git a/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-fastify/output.js b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-fastify/output.js
new file mode 100644
index 00000000000..57032123cba
--- /dev/null
+++ b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-fastify/output.js
@@ -0,0 +1,8 @@
+;[
+  'test/unit/pino-transport-fastify/input.js',
+  'test/unit/pino-transport-fastify/node_modules/fastify/index.js',
+  'test/unit/pino-transport-fastify/node_modules/fastify/package.json',
+  'test/unit/pino-transport-fastify/node_modules/my-pino-transport/index.js',
+  'test/unit/pino-transport-fastify/node_modules/my-pino-transport/package.json',
+  'test/unit/pino-transport-fastify/package.json',
+]
diff --git a/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-fastify/package.json b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-fastify/package.json
new file mode 100644
index 00000000000..e986b24bbae
--- /dev/null
+++ b/turbopack/crates/turbopack-tracing/tests/node-file-trace/test/unit/pino-transport-fastify/package.json
@@ -0,0 +1,4 @@
+{
+  "private": true,
+  "type": "module"
+}
diff --git a/turbopack/crates/turbopack-tracing/tests/unit.rs b/turbopack/crates/turbopack-tracing/tests/unit.rs
index 6f053f720d9..14f7ed7bade 100644
--- a/turbopack/crates/turbopack-tracing/tests/unit.rs
+++ b/turbopack/crates/turbopack-tracing/tests/unit.rs
@@ -136,6 +136,8 @@ static ALLOC: turbo_tasks_malloc::TurboMalloc = turbo_tasks_malloc::TurboMalloc;
 #[case::path_sep("path-sep")]
 // #[case::phantomjs_prebuilt("phantomjs-prebuilt")]
 // #[case::pino_transport("pino-transport")]
+// #[case::pino_transport_constructor("pino-transport-constructor")]
+// #[case::pino_transport_fastify("pino-transport-fastify")]
 // #[case::pino_transport_targets("pino-transport-targets")]
 // #[case::pixelmatch("pixelmatch")]
 // #[case::pkg_dir_outside_base("pkg-dir-outside-base")]
diff --git a/turbopack/crates/turbopack/src/global_module_ids.rs b/turbopack/crates/turbopack/src/global_module_ids.rs
index 58b9dc287b2..7590a40394d 100644
--- a/turbopack/crates/turbopack/src/global_module_ids.rs
+++ b/turbopack/crates/turbopack/src/global_module_ids.rs
@@ -1,5 +1,5 @@
 use anyhow::{Context, Result, bail};
-use rustc_hash::FxHashMap;
+use rustc_hash::{FxHashMap, FxHashSet};
 use smallvec::SmallVec;
 use tracing::Instrument;
 use turbo_rcstr::RcStr;
@@ -23,17 +23,13 @@ pub async fn get_global_module_id_strategy(
     let span = tracing::info_span!("compute module id map");
     async move {
         let module_graph = module_graph.await?;
-        let graphs = &module_graph.graphs;
 
-        // All modules in the graph
-        let module_idents = graphs
-            .iter()
-            .flat_map(|graph| graph.iter_nodes())
-            .map(|m| m.ident());
-
-        // And additionally, all the modules that are inserted by chunking (i.e. async loaders)
+        // All modules in the graph and additionally, all the modules that are inserted by chunking
+        // (i.e. async loaders)
+        let mut modules = FxHashSet::default();
         let mut async_idents = vec![];
         module_graph.traverse_edges_unordered(|parent, current| {
+            modules.insert(current);
             if let Some((
                 _,
                 &RefData {
@@ -49,7 +45,9 @@ pub async fn get_global_module_id_strategy(
             Ok(())
         })?;
 
-        let mut module_id_map = module_idents
+        let mut module_id_map = modules
+            .into_iter()
+            .map(|m| m.ident())
             .chain(async_idents.into_iter())
             .map(|ident| async move {
                 let ident = ident.to_resolved().await?;