diff --git a/turbopack/crates/turbopack-ecmascript/src/lib.rs b/turbopack/crates/turbopack-ecmascript/src/lib.rs
index cd0f0ba084d13..2a03e9f22785c 100644
--- a/turbopack/crates/turbopack-ecmascript/src/lib.rs
+++ b/turbopack/crates/turbopack-ecmascript/src/lib.rs
@@ -426,18 +426,21 @@ impl EcmascriptAnalyzable for EcmascriptModuleAsset {
         let generate_source_map = chunking_context.reference_module_source_maps(Vc::upcast(self));
 
         Ok(EcmascriptModuleContent::new(
-            *parsed,
-            self.ident(),
-            module_type_result.module_type,
-            module_graph,
-            chunking_context,
-            (analyze.references(), *analyze_ref.esm_references),
-            *analyze_ref.code_generation,
-            *analyze_ref.async_module,
-            generate_source_map,
-            *analyze_ref.source_map,
-            *analyze_ref.exports,
-            async_module_info,
+            EcmascriptModuleContentOptions {
+                parsed,
+                ident: self.ident(),
+                specified_module_type: module_type_result.module_type,
+                module_graph,
+                chunking_context,
+                references: analyze.references(),
+                esm_references: *analyze_ref.esm_references,
+                code_generation: *analyze_ref.code_generation,
+                async_module: *analyze_ref.async_module,
+                generate_source_map,
+                original_source_map: analyze_ref.source_map,
+                exports: *analyze_ref.exports,
+                async_module_info,
+            },
         ))
     }
 }
@@ -757,24 +760,44 @@ pub struct EcmascriptModuleContent {
     // pub refresh: bool,
 }
 
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize, TaskInput)]
+pub struct EcmascriptModuleContentOptions {
+    parsed: ResolvedVc<ParseResult>,
+    ident: Vc<AssetIdent>,
+    specified_module_type: SpecifiedModuleType,
+    module_graph: Vc<ModuleGraph>,
+    chunking_context: Vc<Box<dyn ChunkingContext>>,
+    references: Vc<ModuleReferences>,
+    esm_references: Vc<EsmAssetReferences>,
+    code_generation: Vc<CodeGens>,
+    async_module: Vc<OptionAsyncModule>,
+    generate_source_map: Vc<bool>,
+    original_source_map: ResolvedVc<OptionStringifiedSourceMap>,
+    exports: Vc<EcmascriptExports>,
+    async_module_info: Option<Vc<AsyncModuleInfo>>,
+}
+
 #[turbo_tasks::value_impl]
 impl EcmascriptModuleContent {
     /// Creates a new [`Vc<EcmascriptModuleContent>`].
     #[turbo_tasks::function]
-    pub async fn new(
-        parsed: ResolvedVc<ParseResult>,
-        ident: ResolvedVc<AssetIdent>,
-        specified_module_type: SpecifiedModuleType,
-        module_graph: Vc<ModuleGraph>,
-        chunking_context: Vc<Box<dyn ChunkingContext>>,
-        (references, esm_references): (Vc<ModuleReferences>, Vc<EsmAssetReferences>),
-        code_generation: Vc<CodeGens>,
-        async_module: Vc<OptionAsyncModule>,
-        generate_source_map: Vc<bool>,
-        original_source_map: ResolvedVc<OptionStringifiedSourceMap>,
-        exports: Vc<EcmascriptExports>,
-        async_module_info: Option<Vc<AsyncModuleInfo>>,
-    ) -> Result<Vc<Self>> {
+    pub async fn new(input: EcmascriptModuleContentOptions) -> Result<Vc<Self>> {
+        let EcmascriptModuleContentOptions {
+            parsed,
+            ident,
+            specified_module_type,
+            module_graph,
+            chunking_context,
+            references,
+            esm_references,
+            code_generation,
+            async_module,
+            generate_source_map,
+            original_source_map,
+            exports,
+            async_module_info,
+        } = input;
+
         let additional_code_gens = [
             if let Some(async_module) = &*async_module.await? {
                 Some(
@@ -839,7 +862,7 @@ impl EcmascriptModuleContent {
     ) -> Result<Vc<Self>> {
         gen_content_with_code_gens(
             parsed.to_resolved().await?,
-            ident.to_resolved().await?,
+            ident,
             specified_module_type,
             &[],
             generate_source_map,
@@ -851,7 +874,7 @@ impl EcmascriptModuleContent {
 
 async fn gen_content_with_code_gens(
     parsed: ResolvedVc<ParseResult>,
-    ident: ResolvedVc<AssetIdent>,
+    ident: Vc<AssetIdent>,
     specified_module_type: SpecifiedModuleType,
     code_gens: impl IntoIterator<Item = &CodeGeneration>,
     generate_source_map: Vc<bool>,
diff --git a/turbopack/crates/turbopack-ecmascript/src/side_effect_optimization/locals/chunk_item.rs b/turbopack/crates/turbopack-ecmascript/src/side_effect_optimization/locals/chunk_item.rs
index 8750f2f0c570e..9c4e87091b707 100644
--- a/turbopack/crates/turbopack-ecmascript/src/side_effect_optimization/locals/chunk_item.rs
+++ b/turbopack/crates/turbopack-ecmascript/src/side_effect_optimization/locals/chunk_item.rs
@@ -13,7 +13,7 @@ use crate::{
         EcmascriptChunkItem, EcmascriptChunkItemContent, EcmascriptChunkPlaceable,
         EcmascriptChunkType,
     },
-    EcmascriptModuleContent,
+    EcmascriptModuleContent, EcmascriptModuleContentOptions,
 };
 
 /// The chunk item for [EcmascriptModuleLocalsModule].
@@ -41,7 +41,7 @@ impl EcmascriptChunkItem for EcmascriptModuleLocalsChunkItem {
         let module_graph = self.module_graph;
         let exports = self.module.get_exports();
         let original_module = module.module;
-        let parsed = original_module.parse().resolve().await?;
+        let parsed = original_module.parse().to_resolved().await?;
 
         let analyze = original_module.analyze();
         let analyze_result = analyze.await?;
@@ -53,23 +53,21 @@ impl EcmascriptChunkItem for EcmascriptModuleLocalsChunkItem {
         let generate_source_map =
             chunking_context.reference_module_source_maps(*ResolvedVc::upcast(self.module));
 
-        let content = EcmascriptModuleContent::new(
+        let content = EcmascriptModuleContent::new(EcmascriptModuleContentOptions {
             parsed,
-            self.module.ident(),
-            module_type_result.module_type,
-            *module_graph,
-            *chunking_context,
-            (
-                analyze.local_references(),
-                *analyze_result.esm_local_references,
-            ),
-            *analyze_result.code_generation,
-            *analyze_result.async_module,
+            ident: self.module.ident(),
+            specified_module_type: module_type_result.module_type,
+            module_graph: *module_graph,
+            chunking_context: *chunking_context,
+            references: analyze.local_references(),
+            esm_references: *analyze_result.esm_local_references,
+            code_generation: *analyze_result.code_generation,
+            async_module: *analyze_result.async_module,
             generate_source_map,
-            *analyze_result.source_map,
+            original_source_map: analyze_result.source_map,
             exports,
             async_module_info,
-        );
+        });
 
         Ok(EcmascriptChunkItemContent::new(
             content,
diff --git a/turbopack/crates/turbopack-ecmascript/src/tree_shake/chunk_item.rs b/turbopack/crates/turbopack-ecmascript/src/tree_shake/chunk_item.rs
index da9bbeaf89eea..bd6314fffdcb0 100644
--- a/turbopack/crates/turbopack-ecmascript/src/tree_shake/chunk_item.rs
+++ b/turbopack/crates/turbopack-ecmascript/src/tree_shake/chunk_item.rs
@@ -20,7 +20,7 @@ use crate::{
     runtime_functions::{TURBOPACK_EXPORT_NAMESPACE, TURBOPACK_IMPORT},
     tree_shake::side_effect_module::SideEffectsModule,
     utils::StringifyModuleId,
-    EcmascriptModuleContent,
+    EcmascriptModuleContent, EcmascriptModuleContentOptions,
 };
 
 /// This is an implementation of [ChunkItem] for
@@ -49,7 +49,9 @@ impl EcmascriptChunkItem for EcmascriptModulePartChunkItem {
         let module = self.module.await?;
 
         let split_data = split_module(*module.full_module);
-        let parsed = part_of_module(split_data, module.part.clone());
+        let parsed = part_of_module(split_data, module.part.clone())
+            .to_resolved()
+            .await?;
 
         let analyze = self.module.analyze();
         let analyze_ref = analyze.await?;
@@ -60,20 +62,21 @@ impl EcmascriptChunkItem for EcmascriptModulePartChunkItem {
             .chunking_context
             .reference_module_source_maps(*ResolvedVc::upcast(self.module));
 
-        let content = EcmascriptModuleContent::new(
+        let content = EcmascriptModuleContent::new(EcmascriptModuleContentOptions {
             parsed,
-            self.module.ident(),
-            module_type_result.module_type,
-            *self.module_graph,
-            *self.chunking_context,
-            (analyze.references(), *analyze_ref.esm_references),
-            *analyze_ref.code_generation,
-            *analyze_ref.async_module,
+            ident: self.module.ident(),
+            specified_module_type: module_type_result.module_type,
+            module_graph: *self.module_graph,
+            chunking_context: *self.chunking_context,
+            references: analyze.references(),
+            esm_references: *analyze_ref.esm_references,
+            code_generation: *analyze_ref.code_generation,
+            async_module: *analyze_ref.async_module,
             generate_source_map,
-            *analyze_ref.source_map,
-            *analyze_ref.exports,
+            original_source_map: analyze_ref.source_map,
+            exports: *analyze_ref.exports,
             async_module_info,
-        );
+        });
 
         Ok(EcmascriptChunkItemContent::new(
             content,