diff --git a/crates/next-core/src/next_client_reference/ecmascript_client_reference/ecmascript_client_reference_transition.rs b/crates/next-core/src/next_client_reference/ecmascript_client_reference/ecmascript_client_reference_transition.rs
index 045d2c7035b69..8c74b601d2f8a 100644
--- a/crates/next-core/src/next_client_reference/ecmascript_client_reference/ecmascript_client_reference_transition.rs
+++ b/crates/next-core/src/next_client_reference/ecmascript_client_reference/ecmascript_client_reference_transition.rs
@@ -61,7 +61,7 @@ impl Transition for NextEcmascriptClientReferenceTransition {
         let this = self.await?;
 
         let ident = match part {
-            Some(part) => source.ident().with_part(part),
+            Some(part) => source.ident().with_part(*part),
             None => source.ident(),
         };
         let ident_ref = ident.await?;
diff --git a/turbopack/crates/node-file-trace/src/lib.rs b/turbopack/crates/node-file-trace/src/lib.rs
index 197248c429954..f827c0fc0acbb 100644
--- a/turbopack/crates/node-file-trace/src/lib.rs
+++ b/turbopack/crates/node-file-trace/src/lib.rs
@@ -569,7 +569,7 @@ async fn create_module_asset(
     process_cwd: Option<RcStr>,
     module_options: TransientInstance<ModuleOptionsContext>,
     resolve_options: TransientInstance<ResolveOptionsContext>,
-) -> Vc<ModuleAssetContext> {
+) -> Result<Vc<ModuleAssetContext>> {
     let env = Environment::new(Value::new(ExecutionEnvironment::NodeJsLambda(
         NodeJsEnvironment {
             cwd: Vc::cell(process_cwd),
@@ -580,14 +580,18 @@ async fn create_module_asset(
     let compile_time_info = CompileTimeInfo::builder(env).cell();
     let glob_mappings = vec![
         (
-            root,
-            Glob::new("**/*/next/dist/server/next.js".into()),
-            ImportMapping::Ignore.into(),
+            root.to_resolved().await?,
+            Glob::new("**/*/next/dist/server/next.js".into())
+                .to_resolved()
+                .await?,
+            ImportMapping::Ignore.resolved_cell(),
         ),
         (
-            root,
-            Glob::new("**/*/next/dist/bin/next".into()),
-            ImportMapping::Ignore.into(),
+            root.to_resolved().await?,
+            Glob::new("**/*/next/dist/bin/next".into())
+                .to_resolved()
+                .await?,
+            ImportMapping::Ignore.resolved_cell(),
         ),
     ];
     let mut resolve_options = ResolveOptionsContext::clone(&*resolve_options);
@@ -603,13 +607,13 @@ async fn create_module_asset(
         );
     }
 
-    ModuleAssetContext::new(
+    Ok(ModuleAssetContext::new(
         Default::default(),
         compile_time_info,
         ModuleOptionsContext::clone(&*module_options).cell(),
         resolve_options.cell(),
         Vc::cell("node_file_trace".into()),
-    )
+    ))
 }
 
 fn register() {
diff --git a/turbopack/crates/turbopack-browser/src/chunking_context.rs b/turbopack/crates/turbopack-browser/src/chunking_context.rs
index d1bab2c0355e1..4f677f4248fb6 100644
--- a/turbopack/crates/turbopack-browser/src/chunking_context.rs
+++ b/turbopack/crates/turbopack-browser/src/chunking_context.rs
@@ -386,7 +386,7 @@ impl ChunkingContext for BrowserChunkingContext {
 
             let mut assets: Vec<Vc<Box<dyn OutputAsset>>> = chunks
                 .iter()
-                .map(|chunk| self.generate_chunk(*chunk))
+                .map(|chunk| self.generate_chunk(**chunk))
                 .collect();
 
             if this.enable_hot_module_replacement {
@@ -455,7 +455,7 @@ impl ChunkingContext for BrowserChunkingContext {
 
             let mut assets: Vec<Vc<Box<dyn OutputAsset>>> = chunks
                 .iter()
-                .map(|chunk| self.generate_chunk(*chunk))
+                .map(|chunk| self.generate_chunk(**chunk))
                 .collect();
 
             let other_assets = Vc::cell(assets.clone());
diff --git a/turbopack/crates/turbopack-browser/src/ecmascript/merged/update.rs b/turbopack/crates/turbopack-browser/src/ecmascript/merged/update.rs
index 79809d5395d6a..48ea045b72879 100644
--- a/turbopack/crates/turbopack-browser/src/ecmascript/merged/update.rs
+++ b/turbopack/crates/turbopack-browser/src/ecmascript/merged/update.rs
@@ -215,7 +215,7 @@ pub(super) async fn update_ecmascript_merged_chunk(
                         if merged_module_map.get(&module_id) != Some(module_hash) {
                             let entry = EcmascriptModuleEntry::from_code(
                                 &module_id,
-                                module_code,
+                                *module_code,
                                 chunk_path,
                             )
                             .await?;
@@ -227,7 +227,7 @@ pub(super) async fn update_ecmascript_merged_chunk(
 
                     for (module_id, module_code) in chunk_partial.modified {
                         let entry =
-                            EcmascriptModuleEntry::from_code(&module_id, module_code, chunk_path)
+                            EcmascriptModuleEntry::from_code(&module_id, *module_code, chunk_path)
                                 .await?;
                         merged_update.entries.insert(module_id, entry);
                     }
diff --git a/turbopack/crates/turbopack-browser/src/ecmascript/update.rs b/turbopack/crates/turbopack-browser/src/ecmascript/update.rs
index 5c54f8aeb4b22..fb92948275f64 100644
--- a/turbopack/crates/turbopack-browser/src/ecmascript/update.rs
+++ b/turbopack/crates/turbopack-browser/src/ecmascript/update.rs
@@ -1,5 +1,5 @@
 use anyhow::Result;
-use turbo_tasks::{FxIndexMap, ReadRef, Vc};
+use turbo_tasks::{FxIndexMap, ReadRef, ResolvedVc, Vc};
 use turbopack_core::{chunk::ModuleId, code_builder::Code};
 
 use super::{content::EcmascriptDevChunkContent, version::EcmascriptDevChunkVersion};
@@ -11,9 +11,9 @@ pub(super) enum EcmascriptChunkUpdate {
 }
 
 pub(super) struct EcmascriptChunkPartialUpdate {
-    pub added: FxIndexMap<ReadRef<ModuleId>, (u64, Vc<Code>)>,
+    pub added: FxIndexMap<ReadRef<ModuleId>, (u64, ResolvedVc<Code>)>,
     pub deleted: FxIndexMap<ReadRef<ModuleId>, u64>,
-    pub modified: FxIndexMap<ReadRef<ModuleId>, Vc<Code>>,
+    pub modified: FxIndexMap<ReadRef<ModuleId>, ResolvedVc<Code>>,
 }
 
 pub(super) async fn update_ecmascript_chunk(
@@ -40,7 +40,8 @@ pub(super) async fn update_ecmascript_chunk(
     for (id, from_hash) in &from.entries_hashes {
         if let Some(entry) = entries.get(id) {
             if *entry.hash.await? != *from_hash {
-                modified.insert(id.clone(), entry.code);
+                let resolved_code = entry.code.to_resolved().await?;
+                modified.insert(id.clone(), resolved_code);
             }
         } else {
             deleted.insert(id.clone(), *from_hash);
@@ -50,7 +51,10 @@ pub(super) async fn update_ecmascript_chunk(
     // Remaining entries are added
     for (id, entry) in entries.iter() {
         if !from.entries_hashes.contains_key(id) {
-            added.insert(id.clone(), (*entry.hash.await?, entry.code));
+            added.insert(
+                id.clone(),
+                (*entry.hash.await?, entry.code.to_resolved().await?),
+            );
         }
     }
 
diff --git a/turbopack/crates/turbopack-cli-utils/src/runtime_entry.rs b/turbopack/crates/turbopack-cli-utils/src/runtime_entry.rs
index 6bee158c7413f..8f38df55b861a 100644
--- a/turbopack/crates/turbopack-cli-utils/src/runtime_entry.rs
+++ b/turbopack/crates/turbopack-cli-utils/src/runtime_entry.rs
@@ -62,7 +62,7 @@ impl RuntimeEntry {
 }
 
 #[turbo_tasks::value(transparent)]
-pub struct RuntimeEntries(Vec<Vc<RuntimeEntry>>);
+pub struct RuntimeEntries(Vec<ResolvedVc<RuntimeEntry>>);
 
 #[turbo_tasks::value_impl]
 impl RuntimeEntries {
diff --git a/turbopack/crates/turbopack-cli/src/build/mod.rs b/turbopack/crates/turbopack-cli/src/build/mod.rs
index 635fa6f6472fd..ec08685b3a6ea 100644
--- a/turbopack/crates/turbopack-cli/src/build/mod.rs
+++ b/turbopack/crates/turbopack-cli/src/build/mod.rs
@@ -118,7 +118,7 @@ impl TurbopackBuildBuilder {
                     self.entry_requests
                         .iter()
                         .cloned()
-                        .map(EntryRequest::cell)
+                        .map(EntryRequest::resolved_cell) // Changed from cell() to resolved_cell()
                         .collect(),
                 )
                 .cell(),
diff --git a/turbopack/crates/turbopack-cli/src/dev/web_entry_source.rs b/turbopack/crates/turbopack-cli/src/dev/web_entry_source.rs
index 5412fecaa604a..9e19737bd4b30 100644
--- a/turbopack/crates/turbopack-cli/src/dev/web_entry_source.rs
+++ b/turbopack/crates/turbopack-cli/src/dev/web_entry_source.rs
@@ -72,7 +72,8 @@ pub async fn get_client_runtime_entries(
                 request.to_resolved().await?,
                 project_path.join("_".into()).to_resolved().await?,
             )
-            .cell(),
+            .resolved_cell()
+            .into(),
         )
     };
 
@@ -82,7 +83,8 @@ pub async fn get_client_runtime_entries(
                 .to_resolved()
                 .await?,
         ))
-        .cell(),
+        .resolved_cell()
+        .into(),
     );
 
     Ok(Vc::cell(runtime_entries))
diff --git a/turbopack/crates/turbopack-cli/src/util.rs b/turbopack/crates/turbopack-cli/src/util.rs
index 69ebdf0da9d4f..6e5c6a449a131 100644
--- a/turbopack/crates/turbopack-cli/src/util.rs
+++ b/turbopack/crates/turbopack-cli/src/util.rs
@@ -2,11 +2,11 @@ use std::{env::current_dir, path::PathBuf};
 
 use anyhow::{Context, Result};
 use dunce::canonicalize;
-use turbo_tasks::{RcStr, Vc};
+use turbo_tasks::{RcStr, ResolvedVc, Vc};
 use turbo_tasks_fs::{DiskFileSystem, FileSystem};
 
 #[turbo_tasks::value(transparent)]
-pub struct EntryRequests(pub Vec<Vc<EntryRequest>>);
+pub struct EntryRequests(pub Vec<ResolvedVc<EntryRequest>>);
 
 #[turbo_tasks::value(shared)]
 #[derive(Clone)]
diff --git a/turbopack/crates/turbopack-core/src/chunk/available_chunk_items.rs b/turbopack/crates/turbopack-core/src/chunk/available_chunk_items.rs
index b05c9d31f1de0..f5d12bf9dd101 100644
--- a/turbopack/crates/turbopack-core/src/chunk/available_chunk_items.rs
+++ b/turbopack/crates/turbopack-core/src/chunk/available_chunk_items.rs
@@ -17,7 +17,9 @@ pub struct AvailableChunkItemInfo {
 pub struct OptionAvailableChunkItemInfo(Option<AvailableChunkItemInfo>);
 
 #[turbo_tasks::value(transparent)]
-pub struct AvailableChunkItemInfoMap(FxIndexMap<Vc<Box<dyn ChunkItem>>, AvailableChunkItemInfo>);
+pub struct AvailableChunkItemInfoMap(
+    FxIndexMap<ResolvedVc<Box<dyn ChunkItem>>, AvailableChunkItemInfo>,
+);
 
 /// Allows to gather information about which assets are already available.
 /// Adding more roots will form a linked list like structure to allow caching
@@ -49,7 +51,7 @@ impl AvailableChunkItems {
             .into_iter()
             .map(|(&chunk_item, &info)| async move {
                 Ok(self
-                    .get(chunk_item)
+                    .get(*chunk_item)
                     .await?
                     .is_none()
                     .then_some((chunk_item, info)))
@@ -89,7 +91,8 @@ impl AvailableChunkItems {
         &self,
         chunk_item: Vc<Box<dyn ChunkItem>>,
     ) -> Result<Vc<OptionAvailableChunkItemInfo>> {
-        if let Some(&info) = self.chunk_items.await?.get(&chunk_item) {
+        let resolved_chunk_item = chunk_item.to_resolved().await?;
+        if let Some(&info) = self.chunk_items.await?.get(&resolved_chunk_item) {
             return Ok(Vc::cell(Some(info)));
         };
         if let Some(parent) = self.parent {
diff --git a/turbopack/crates/turbopack-core/src/chunk/chunk_group.rs b/turbopack/crates/turbopack-core/src/chunk/chunk_group.rs
index 2cebdd266cf39..b84ebdba7902a 100644
--- a/turbopack/crates/turbopack-core/src/chunk/chunk_group.rs
+++ b/turbopack/crates/turbopack-core/src/chunk/chunk_group.rs
@@ -2,7 +2,9 @@ use std::collections::HashSet;
 
 use anyhow::Result;
 use auto_hash_map::AutoSet;
-use turbo_tasks::{FxIndexMap, FxIndexSet, TryFlatJoinIterExt, TryJoinIterExt, Value, Vc};
+use turbo_tasks::{
+    FxIndexMap, FxIndexSet, ResolvedVc, TryFlatJoinIterExt, TryJoinIterExt, Value, Vc,
+};
 
 use super::{
     availability_info::AvailabilityInfo, available_chunk_items::AvailableChunkItemInfo,
@@ -12,7 +14,7 @@ use super::{
 use crate::{module::Module, output::OutputAssets, reference::ModuleReference};
 
 pub struct MakeChunkGroupResult {
-    pub chunks: Vec<Vc<Box<dyn Chunk>>>,
+    pub chunks: Vec<ResolvedVc<Box<dyn Chunk>>>,
     pub availability_info: AvailabilityInfo,
 }
 
@@ -104,14 +106,17 @@ pub async fn make_chunk_group(
     let availability_info = {
         let map = chunk_items
             .iter()
-            .map(|(&chunk_item, async_info)| {
-                (
-                    chunk_item,
+            .map(|(&chunk_item, async_info)| async move {
+                Ok((
+                    chunk_item.to_resolved().await?,
                     AvailableChunkItemInfo {
                         is_async: async_info.is_some(),
                     },
-                )
+                ))
             })
+            .try_join()
+            .await?
+            .into_iter()
             .collect();
         let map = Vc::cell(map);
         availability_info.with_chunk_items(map).await?
@@ -121,7 +126,7 @@ pub async fn make_chunk_group(
     let async_loaders = async_modules
         .into_iter()
         .map(|module| {
-            chunking_context.async_loader_chunk_item(module, Value::new(availability_info))
+            chunking_context.async_loader_chunk_item(*module, Value::new(availability_info))
         })
         .collect::<Vec<_>>();
     let has_async_loaders = !async_loaders.is_empty();
@@ -164,8 +169,15 @@ pub async fn make_chunk_group(
         chunks.extend(async_loader_chunks.iter().copied());
     }
 
+    // Convert chunks to ResolvedVc
+    let resolved_chunks = chunks
+        .into_iter()
+        .map(|chunk| chunk.to_resolved())
+        .try_join()
+        .await?;
+
     Ok(MakeChunkGroupResult {
-        chunks,
+        chunks: resolved_chunks,
         availability_info,
     })
 }
diff --git a/turbopack/crates/turbopack-core/src/chunk/mod.rs b/turbopack/crates/turbopack-core/src/chunk/mod.rs
index 1daf8422e0e06..a0d731fcd7489 100644
--- a/turbopack/crates/turbopack-core/src/chunk/mod.rs
+++ b/turbopack/crates/turbopack-core/src/chunk/mod.rs
@@ -190,7 +190,7 @@ type AsyncInfo = FxIndexMap<Vc<Box<dyn ChunkItem>>, Vec<Vc<Box<dyn ChunkItem>>>>
 
 pub struct ChunkContentResult {
     pub chunk_items: FxIndexSet<Vc<Box<dyn ChunkItem>>>,
-    pub async_modules: FxIndexSet<Vc<Box<dyn ChunkableModule>>>,
+    pub async_modules: FxIndexSet<ResolvedVc<Box<dyn ChunkableModule>>>,
     pub external_module_references: FxIndexSet<Vc<Box<dyn ModuleReference>>>,
     /// A map from local module to all children from which the async module
     /// status is inherited
@@ -245,7 +245,7 @@ enum ChunkContentGraphNode {
     /// will be inherited.
     InheritAsyncInfo {
         item: Vc<Box<dyn ChunkItem>>,
-        references: Vec<(Vc<Box<dyn ChunkItem>>, InheritAsyncEdge)>,
+        references: Vec<(ResolvedVc<Box<dyn ChunkItem>>, InheritAsyncEdge)>,
     },
 }
 
@@ -413,7 +413,10 @@ async fn graph_node_to_referenced_nodes(
                                         ident: module.ident().to_string().await?,
                                     },
                                 }),
-                                Some((chunk_item, InheritAsyncEdge::LocalModule)),
+                                Some((
+                                    chunk_item.to_resolved().await?,
+                                    InheritAsyncEdge::LocalModule,
+                                )),
                             ))
                         }
                         ChunkingType::Passthrough => {
@@ -590,9 +593,9 @@ async fn chunk_content_internal_parallel(
             Ok(Some(ChunkGraphEdge {
                 key: Some(entry.to_resolved().await?),
                 node: ChunkContentGraphNode::ChunkItem {
-                    item: chunkable_module
+                    item: *chunkable_module
                         .as_chunk_item(chunking_context)
-                        .resolve()
+                        .to_resolved()
                         .await?,
                     ident: chunkable_module.ident().to_string().await?,
                 },
@@ -626,10 +629,10 @@ async fn chunk_content_internal_parallel(
         match graph_node {
             ChunkContentGraphNode::PassthroughChunkItem { .. } => {}
             ChunkContentGraphNode::ChunkItem { item, .. } => {
-                chunk_items.insert(item);
+                chunk_items.insert(*item.to_resolved().await?);
             }
             ChunkContentGraphNode::AsyncModule { module } => {
-                let module = module.resolve().await?;
+                let module = module.to_resolved().await?;
                 async_modules.insert(module);
             }
             ChunkContentGraphNode::ExternalModuleReference(reference) => {
@@ -640,12 +643,12 @@ async fn chunk_content_internal_parallel(
                 for &(reference, ty) in &references {
                     match ty {
                         InheritAsyncEdge::LocalModule => local_back_edges_inherit_async
-                            .entry(reference)
+                            .entry(*reference)
                             .or_insert_with(Vec::new)
                             .push(item),
                         InheritAsyncEdge::AvailableAsyncModule => {
                             available_async_modules_back_edges_inherit_async
-                                .entry(reference)
+                                .entry(*reference)
                                 .or_insert_with(Vec::new)
                                 .push(item)
                         }
@@ -654,7 +657,7 @@ async fn chunk_content_internal_parallel(
                 forward_edges_inherit_async
                     .entry(item)
                     .or_insert_with(Vec::new)
-                    .extend(references.into_iter().map(|(r, _)| r));
+                    .extend(references.into_iter().map(|(r, _)| *r));
             }
         }
     }
@@ -733,17 +736,24 @@ pub struct ChunkItems(pub Vec<Vc<Box<dyn ChunkItem>>>);
 
 #[turbo_tasks::value]
 pub struct AsyncModuleInfo {
-    pub referenced_async_modules: AutoSet<Vc<Box<dyn ChunkItem>>>,
+    pub referenced_async_modules: AutoSet<ResolvedVc<Box<dyn ChunkItem>>>,
 }
 
 #[turbo_tasks::value_impl]
 impl AsyncModuleInfo {
     #[turbo_tasks::function]
-    pub fn new(referenced_async_modules: Vec<Vc<Box<dyn ChunkItem>>>) -> Vc<Self> {
-        Self {
-            referenced_async_modules: referenced_async_modules.into_iter().collect(),
+    pub async fn new(referenced_async_modules: Vec<Vc<Box<dyn ChunkItem>>>) -> Result<Vc<Self>> {
+        let resolved_modules = futures::future::try_join_all(
+            referenced_async_modules
+                .into_iter()
+                .map(|m| m.to_resolved()),
+        )
+        .await?;
+
+        Ok(Self {
+            referenced_async_modules: resolved_modules.into_iter().collect(),
         }
-        .cell()
+        .cell())
     }
 }
 
diff --git a/turbopack/crates/turbopack-core/src/chunk/optimize.rs b/turbopack/crates/turbopack-core/src/chunk/optimize.rs
index bea7a542ce426..4da9b7a8cac53 100644
--- a/turbopack/crates/turbopack-core/src/chunk/optimize.rs
+++ b/turbopack/crates/turbopack-core/src/chunk/optimize.rs
@@ -4,17 +4,17 @@
 //! their size and eliminating duplicates between them.
 
 use anyhow::Result;
-use turbo_tasks::{TryJoinIterExt, Vc};
+use turbo_tasks::{ResolvedVc, TryJoinIterExt, Vc};
 use turbo_tasks_fs::{FileSystemPath, FileSystemPathOption};
 
 use crate::chunk::containment_tree::{ContainmentTree, ContainmentTreeKey};
 
 #[derive(Debug, Clone, Eq, PartialEq, Hash)]
-struct FileSystemPathKey(Vc<FileSystemPath>);
+struct FileSystemPathKey(ResolvedVc<FileSystemPath>);
 
 impl FileSystemPathKey {
     async fn new(path: Vc<FileSystemPath>) -> Result<Self> {
-        Ok(Self(path.resolve().await?))
+        Ok(Self(path.to_resolved().await?))
     }
 }
 
diff --git a/turbopack/crates/turbopack-core/src/introspect/output_asset.rs b/turbopack/crates/turbopack-core/src/introspect/output_asset.rs
index 946cdd30a8dd4..7bc76640063a9 100644
--- a/turbopack/crates/turbopack-core/src/introspect/output_asset.rs
+++ b/turbopack/crates/turbopack-core/src/introspect/output_asset.rs
@@ -1,5 +1,5 @@
 use anyhow::Result;
-use turbo_tasks::{RcStr, ValueToString, Vc};
+use turbo_tasks::{RcStr, ResolvedVc, ValueToString, Vc};
 
 use super::{
     utils::{children_from_output_assets, content_to_details},
@@ -8,15 +8,20 @@ use super::{
 use crate::{asset::Asset, output::OutputAsset};
 
 #[turbo_tasks::value]
-pub struct IntrospectableOutputAsset(Vc<Box<dyn OutputAsset>>);
+pub struct IntrospectableOutputAsset(ResolvedVc<Box<dyn OutputAsset>>);
 
 #[turbo_tasks::value_impl]
 impl IntrospectableOutputAsset {
     #[turbo_tasks::function]
     pub async fn new(asset: Vc<Box<dyn OutputAsset>>) -> Result<Vc<Box<dyn Introspectable>>> {
-        Ok(Vc::try_resolve_sidecast::<Box<dyn Introspectable>>(asset)
-            .await?
-            .unwrap_or_else(|| Vc::upcast(IntrospectableOutputAsset(asset).cell())))
+        let resolved_asset = asset.to_resolved().await?;
+        Ok(
+            *ResolvedVc::try_sidecast::<Box<dyn Introspectable>>(resolved_asset)
+                .await?
+                .unwrap_or_else(|| {
+                    ResolvedVc::upcast(IntrospectableOutputAsset(resolved_asset).resolved_cell())
+                }),
+        )
     }
 }
 
diff --git a/turbopack/crates/turbopack-core/src/reference_type.rs b/turbopack/crates/turbopack-core/src/reference_type.rs
index 735e51bf79620..76fd2c332a354 100644
--- a/turbopack/crates/turbopack-core/src/reference_type.rs
+++ b/turbopack/crates/turbopack-core/src/reference_type.rs
@@ -1,7 +1,7 @@
 use std::fmt::Display;
 
 use anyhow::Result;
-use turbo_tasks::{FxIndexMap, RcStr, Vc};
+use turbo_tasks::{FxIndexMap, RcStr, ResolvedVc, Vc};
 
 use crate::{module::Module, resolve::ModulePart};
 
@@ -42,7 +42,7 @@ pub enum ImportWithType {
 #[turbo_tasks::value(serialization = "auto_for_input")]
 #[derive(Debug, Default, Clone, Hash)]
 pub enum EcmaScriptModulesReferenceSubType {
-    ImportPart(Vc<ModulePart>),
+    ImportPart(ResolvedVc<ModulePart>),
     Import,
     ImportWithType(ImportWithType),
     DynamicImport,
diff --git a/turbopack/crates/turbopack-core/src/resolve/mod.rs b/turbopack/crates/turbopack-core/src/resolve/mod.rs
index 48cd30d40cc0b..279b48aa16cad 100644
--- a/turbopack/crates/turbopack-core/src/resolve/mod.rs
+++ b/turbopack/crates/turbopack-core/src/resolve/mod.rs
@@ -1070,7 +1070,7 @@ async fn exports_field(package_json_path: Vc<FileSystemPath>) -> Result<Vc<Expor
 enum ImportsFieldResult {
     Some(
         #[turbo_tasks(debug_ignore, trace_ignore)] ImportsField,
-        Vc<FileSystemPath>,
+        ResolvedVc<FileSystemPath>,
     ),
     None,
 }
@@ -1094,7 +1094,9 @@ async fn imports_field(lookup_path: Vc<FileSystemPath>) -> Result<Vc<ImportsFiel
         return Ok(ImportsFieldResult::None.cell());
     };
     match imports.try_into() {
-        Ok(imports) => Ok(ImportsFieldResult::Some(imports, **package_json_path).cell()),
+        Ok(imports) => {
+            Ok(ImportsFieldResult::Some(imports, package_json_path.to_resolved().await?).cell())
+        }
         Err(err) => {
             PackageJsonIssue {
                 path: **package_json_path,
@@ -2522,14 +2524,17 @@ async fn resolve_import_map_result(
         ImportMapResult::Result(result) => Some(*result),
         ImportMapResult::Alias(request, alias_lookup_path) => {
             let request = *request;
-            let lookup_path = alias_lookup_path.unwrap_or(lookup_path);
+            let lookup_path = match alias_lookup_path {
+                Some(path) => path,
+                None => &lookup_path.to_resolved().await?,
+            };
             // We must avoid cycles during resolving
-            if request.resolve().await? == original_request
-                && lookup_path.resolve().await? == original_lookup_path
+            if request.resolve().await? == original_request.to_resolved().await?
+                && *lookup_path == original_lookup_path.to_resolved().await?
             {
                 None
             } else {
-                let result = resolve_internal(lookup_path, request, options);
+                let result = resolve_internal(**lookup_path, *request, options);
                 Some(result.with_replaced_request_key_pattern(
                     request.request_pattern(),
                     original_request.request_pattern(),
@@ -2717,7 +2722,7 @@ async fn resolve_package_internal_with_imports_field(
 
     handle_exports_imports_field(
         package_json_path.parent(),
-        *package_json_path,
+        **package_json_path,
         resolve_options,
         imports,
         specifier,
diff --git a/turbopack/crates/turbopack-core/src/resolve/options.rs b/turbopack/crates/turbopack-core/src/resolve/options.rs
index 762c70b900d1e..796e6a72ff5ce 100644
--- a/turbopack/crates/turbopack-core/src/resolve/options.rs
+++ b/turbopack/crates/turbopack-core/src/resolve/options.rs
@@ -117,7 +117,7 @@ pub enum ReplacedImportMapping {
     Ignore,
     Empty,
     Alternatives(Vec<Vc<ReplacedImportMapping>>),
-    Dynamic(Vc<Box<dyn ImportMappingReplacement>>),
+    Dynamic(ResolvedVc<Box<dyn ImportMappingReplacement>>),
 }
 
 impl ImportMapping {
@@ -162,7 +162,9 @@ impl AliasTemplate for Vc<ImportMapping> {
                         .try_join()
                         .await?,
                 ),
-                ImportMapping::Dynamic(replacement) => ReplacedImportMapping::Dynamic(*replacement),
+                ImportMapping::Dynamic(replacement) => {
+                    ReplacedImportMapping::Dynamic(replacement.to_resolved().await?)
+                }
             }
             .cell())
         })
@@ -300,14 +302,18 @@ impl ImportMap {
 #[turbo_tasks::value(shared)]
 #[derive(Clone, Default)]
 pub struct ResolvedMap {
-    pub by_glob: Vec<(Vc<FileSystemPath>, Vc<Glob>, Vc<ImportMapping>)>,
+    pub by_glob: Vec<(
+        ResolvedVc<FileSystemPath>,
+        ResolvedVc<Glob>,
+        ResolvedVc<ImportMapping>,
+    )>,
 }
 
 #[turbo_tasks::value(shared)]
 #[derive(Clone, Debug)]
 pub enum ImportMapResult {
     Result(Vc<ResolveResult>),
-    Alias(Vc<Request>, Option<Vc<FileSystemPath>>),
+    Alias(ResolvedVc<Request>, Option<ResolvedVc<FileSystemPath>>),
     Alternatives(Vec<ImportMapResult>),
     NoEntry,
 }
@@ -318,27 +324,32 @@ async fn import_mapping_to_result(
     request: Vc<Request>,
 ) -> Result<ImportMapResult> {
     Ok(match &*mapping.await? {
-        ReplacedImportMapping::Direct(result) => ImportMapResult::Result(*result),
+        ReplacedImportMapping::Direct(result) => {
+            ImportMapResult::Result(*result.to_resolved().await?)
+        }
         ReplacedImportMapping::External(name, ty) => ImportMapResult::Result(
-            ResolveResult::primary(if let Some(name) = name {
+            *ResolveResult::primary(if let Some(name) = name {
                 ResolveResultItem::External(name.clone(), *ty)
             } else if let Some(request) = request.await?.request() {
                 ResolveResultItem::External(request, *ty)
             } else {
                 bail!("Cannot resolve external reference without request")
             })
-            .cell(),
+            .resolved_cell(),
+        ),
+        ReplacedImportMapping::Ignore => ImportMapResult::Result(
+            *ResolveResult::primary(ResolveResultItem::Ignore).resolved_cell(),
+        ),
+        ReplacedImportMapping::Empty => ImportMapResult::Result(
+            *ResolveResult::primary(ResolveResultItem::Empty).resolved_cell(),
         ),
-        ReplacedImportMapping::Ignore => {
-            ImportMapResult::Result(ResolveResult::primary(ResolveResultItem::Ignore).into())
-        }
-        ReplacedImportMapping::Empty => {
-            ImportMapResult::Result(ResolveResult::primary(ResolveResultItem::Empty).into())
-        }
         ReplacedImportMapping::PrimaryAlternative(name, context) => {
             let request = Request::parse(Value::new(name.clone()));
-
-            ImportMapResult::Alias(request, *context)
+            let context = match context {
+                Some(c) => Some((*c).to_resolved().await?),
+                None => None,
+            };
+            ImportMapResult::Alias(request.to_resolved().await?, context)
         }
         ReplacedImportMapping::Alternatives(list) => ImportMapResult::Alternatives(
             list.iter()
diff --git a/turbopack/crates/turbopack-ecmascript/src/references/async_module.rs b/turbopack/crates/turbopack-ecmascript/src/references/async_module.rs
index 1be520f9e505d..67520294e2a6a 100644
--- a/turbopack/crates/turbopack-ecmascript/src/references/async_module.rs
+++ b/turbopack/crates/turbopack-ecmascript/src/references/async_module.rs
@@ -123,7 +123,7 @@ impl AsyncModule {
                     ReferencedAsset::Some(placeable) => {
                         let chunk_item = placeable
                             .as_chunk_item(Vc::upcast(chunking_context))
-                            .resolve()
+                            .to_resolved()
                             .await?;
                         if async_module_info
                             .referenced_async_modules
diff --git a/turbopack/crates/turbopack-ecmascript/src/references/esm/base.rs b/turbopack/crates/turbopack-ecmascript/src/references/esm/base.rs
index b41a16c8b904b..3bdd572fd0eae 100644
--- a/turbopack/crates/turbopack-ecmascript/src/references/esm/base.rs
+++ b/turbopack/crates/turbopack-ecmascript/src/references/esm/base.rs
@@ -153,7 +153,7 @@ impl ModuleReference for EsmAssetReference {
         let ty = if matches!(self.annotations.module_type(), Some("json")) {
             EcmaScriptModulesReferenceSubType::ImportWithType(ImportWithType::Json)
         } else if let Some(part) = &self.export_name {
-            EcmaScriptModulesReferenceSubType::ImportPart(**part)
+            EcmaScriptModulesReferenceSubType::ImportPart(part.to_resolved().await?)
         } else {
             EcmaScriptModulesReferenceSubType::Import
         };
diff --git a/turbopack/crates/turbopack-nodejs/src/chunking_context.rs b/turbopack/crates/turbopack-nodejs/src/chunking_context.rs
index 719856fc7e721..3bad35b5c4134 100644
--- a/turbopack/crates/turbopack-nodejs/src/chunking_context.rs
+++ b/turbopack/crates/turbopack-nodejs/src/chunking_context.rs
@@ -282,7 +282,7 @@ impl ChunkingContext for NodeJsChunkingContext {
 
             let mut assets: Vec<Vc<Box<dyn OutputAsset>>> = chunks
                 .iter()
-                .map(|chunk| self.generate_chunk(*chunk))
+                .map(|chunk| self.generate_chunk(**chunk))
                 .collect();
 
             // Resolve assets
@@ -333,7 +333,7 @@ impl ChunkingContext for NodeJsChunkingContext {
         let other_chunks: Vec<_> = extra_chunks
             .iter()
             .copied()
-            .chain(chunks.iter().map(|chunk| self.generate_chunk(*chunk)))
+            .chain(chunks.iter().map(|chunk| self.generate_chunk(**chunk)))
             .collect();
 
         let Some(module) = Vc::try_resolve_downcast(module).await? else {
diff --git a/turbopack/crates/turbopack/src/lib.rs b/turbopack/crates/turbopack/src/lib.rs
index 3dc82e7e63aa1..61d90bdee2541 100644
--- a/turbopack/crates/turbopack/src/lib.rs
+++ b/turbopack/crates/turbopack/src/lib.rs
@@ -484,7 +484,7 @@ async fn process_default_internal(
     let reference_type = reference_type.into_value();
     let part: Option<Vc<ModulePart>> = match &reference_type {
         ReferenceType::EcmaScriptModules(EcmaScriptModulesReferenceSubType::ImportPart(part)) => {
-            Some(*part)
+            Some(**part)
         }
         _ => None,
     };