[Turbopack] fix import.meta.url in monorepo (#72612)

### What?

fixes the computation of `import.meta.url` inside of monorepos (when the root_path != project_path)

### How?

We add a new argument to the ChunkingContext that represents the relative path from the output folder to the root of the monorepo. Since they are on different filesystems, we can't compute them from the values alone.

crates/next-api/src/project.rs

@@ -647,6 +647,18 @@ impl Project {
         ))
     }
 
+    #[turbo_tasks::function]
+    pub async fn node_root_to_root_path(self: Vc<Self>) -> Result<Vc<RcStr>> {
+        let this = self.await?;
+        let output_root_to_root_path = self
+            .project_path()
+            .join(this.dist_dir.clone())
+            .await?
+            .get_relative_path_to(&*self.project_root_path().await?)
+            .context("Project path need to be in root path")?;
+        Ok(Vc::cell(output_root_to_root_path))
+    }
+
     #[turbo_tasks::function]
     pub async fn project_path(self: Vc<Self>) -> Result<Vc<FileSystemPath>> {
         let this = self.await?;
@@ -695,6 +707,7 @@ impl Project {
             NodeJsChunkingContext::builder(
                 self.project_root_path().to_resolved().await?,
                 node_root,
+                self.node_root_to_root_path().to_resolved().await?,
                 node_root,
                 node_root.join("build/chunks".into()).to_resolved().await?,
                 node_root.join("build/assets".into()).to_resolved().await?,
@@ -822,6 +835,7 @@ impl Project {
         get_client_chunking_context(
             self.project_root_path(),
             self.client_relative_path(),
+            Vc::cell("/ROOT".into()),
             self.next_config().computed_asset_prefix(),
             self.client_compile_time_info().environment(),
             self.next_mode(),
@@ -840,6 +854,7 @@ impl Project {
                 self.next_mode(),
                 self.project_root_path(),
                 self.node_root(),
+                self.node_root_to_root_path(),
                 self.client_relative_path(),
                 self.next_config().computed_asset_prefix(),
                 self.server_compile_time_info().environment(),
@@ -851,6 +866,7 @@ impl Project {
                 self.next_mode(),
                 self.project_root_path(),
                 self.node_root(),
+                self.node_root_to_root_path(),
                 self.server_compile_time_info().environment(),
                 self.module_id_strategy(),
                 self.next_config().turbo_minify(self.next_mode()),
@@ -868,6 +884,7 @@ impl Project {
                 self.next_mode(),
                 self.project_root_path(),
                 self.node_root(),
+                self.node_root_to_root_path(),
                 self.client_relative_path(),
                 self.next_config().computed_asset_prefix(),
                 self.edge_compile_time_info().environment(),
@@ -879,6 +896,7 @@ impl Project {
                 self.next_mode(),
                 self.project_root_path(),
                 self.node_root(),
+                self.node_root_to_root_path(),
                 self.edge_compile_time_info().environment(),
                 self.module_id_strategy(),
                 self.next_config().turbo_minify(self.next_mode()),

crates/next-core/src/next_client/context.rs

@@ -398,8 +398,9 @@ pub async fn get_client_module_options_context(
 
 #[turbo_tasks::function]
 pub async fn get_client_chunking_context(
-    project_path: ResolvedVc<FileSystemPath>,
+    root_path: ResolvedVc<FileSystemPath>,
     client_root: ResolvedVc<FileSystemPath>,
+    client_root_to_root_path: ResolvedVc<RcStr>,
     asset_prefix: ResolvedVc<Option<RcStr>>,
     environment: ResolvedVc<Environment>,
     mode: Vc<NextMode>,
@@ -408,8 +409,9 @@ pub async fn get_client_chunking_context(
 ) -> Result<Vc<Box<dyn ChunkingContext>>> {
     let next_mode = mode.await?;
     let mut builder = BrowserChunkingContext::builder(
-        project_path,
+        root_path,
         client_root,
+        client_root_to_root_path,
         client_root,
         client_root
             .join("static/chunks".into())

crates/next-core/src/next_edge/context.rs

@@ -200,8 +200,9 @@ pub async fn get_edge_resolve_options_context(
 #[turbo_tasks::function]
 pub async fn get_edge_chunking_context_with_client_assets(
     mode: Vc<NextMode>,
-    project_path: ResolvedVc<FileSystemPath>,
+    root_path: ResolvedVc<FileSystemPath>,
     node_root: ResolvedVc<FileSystemPath>,
+    output_root_to_root_path: ResolvedVc<RcStr>,
     client_root: ResolvedVc<FileSystemPath>,
     asset_prefix: ResolvedVc<Option<RcStr>>,
     environment: ResolvedVc<Environment>,
@@ -212,8 +213,9 @@ pub async fn get_edge_chunking_context_with_client_assets(
     let next_mode = mode.await?;
     Ok(Vc::upcast(
         BrowserChunkingContext::builder(
-            project_path,
+            root_path,
             output_root,
+            output_root_to_root_path,
             client_root,
             output_root.join("chunks/ssr".into()).to_resolved().await?,
             client_root
@@ -237,8 +239,9 @@ pub async fn get_edge_chunking_context_with_client_assets(
 #[turbo_tasks::function]
 pub async fn get_edge_chunking_context(
     mode: Vc<NextMode>,
-    project_path: ResolvedVc<FileSystemPath>,
+    root_path: ResolvedVc<FileSystemPath>,
     node_root: ResolvedVc<FileSystemPath>,
+    node_root_to_root_path: ResolvedVc<RcStr>,
     environment: ResolvedVc<Environment>,
     module_id_strategy: ResolvedVc<Box<dyn ModuleIdStrategy>>,
     turbo_minify: Vc<bool>,
@@ -247,8 +250,9 @@ pub async fn get_edge_chunking_context(
     let next_mode = mode.await?;
     Ok(Vc::upcast(
         BrowserChunkingContext::builder(
-            project_path,
+            root_path,
             output_root,
+            node_root_to_root_path,
             output_root,
             output_root.join("chunks".into()).to_resolved().await?,
             output_root.join("assets".into()).to_resolved().await?,

crates/next-core/src/next_server/context.rs

@@ -976,6 +976,7 @@ pub async fn get_server_chunking_context_with_client_assets(
     mode: Vc<NextMode>,
     root_path: ResolvedVc<FileSystemPath>,
     node_root: ResolvedVc<FileSystemPath>,
+    node_root_to_root_path: ResolvedVc<RcStr>,
     client_root: ResolvedVc<FileSystemPath>,
     asset_prefix: ResolvedVc<Option<RcStr>>,
     environment: ResolvedVc<Environment>,
@@ -989,6 +990,7 @@ pub async fn get_server_chunking_context_with_client_assets(
     let mut builder = NodeJsChunkingContext::builder(
         root_path,
         node_root,
+        node_root_to_root_path,
         client_root,
         node_root
             .join("server/chunks/ssr".into())
@@ -1021,6 +1023,7 @@ pub async fn get_server_chunking_context(
     mode: Vc<NextMode>,
     root_path: ResolvedVc<FileSystemPath>,
     node_root: ResolvedVc<FileSystemPath>,
+    node_root_to_root_path: ResolvedVc<RcStr>,
     environment: ResolvedVc<Environment>,
     module_id_strategy: ResolvedVc<Box<dyn ModuleIdStrategy>>,
     turbo_minify: Vc<bool>,
@@ -1032,6 +1035,7 @@ pub async fn get_server_chunking_context(
     let mut builder = NodeJsChunkingContext::builder(
         root_path,
         node_root,
+        node_root_to_root_path,
         node_root,
         node_root.join("server/chunks".into()).to_resolved().await?,
         node_root.join("server/assets".into()).to_resolved().await?,

test/e2e/app-dir/non-root-project-monorepo/apps/web/app/import-meta-url-rsc/page.tsx

@@ -0,0 +1,5 @@
+const text = import.meta.url
+
+export default function Page() {
+  return <p>{text}</p>
+}

test/e2e/app-dir/non-root-project-monorepo/apps/web/app/import-meta-url-ssr/page.tsx

@@ -0,0 +1,7 @@
+'use client'
+
+const text = import.meta.url
+
+export default function Page() {
+  return <p>{text}</p>
+}

test/e2e/app-dir/non-root-project-monorepo/non-root-project-monorepo.test.ts

@@ -48,6 +48,38 @@ describe('non-root-project-monorepo', () => {
     })
   })
 
+  describe('import.meta.url', () => {
+    it('should work during RSC', async () => {
+      const $ = await next.render$('/import-meta-url-rsc')
+      expect($('p').text()).toMatch(
+        /^file:\/\/.*\/next-install-[^/]+\/apps\/web\/app\/import-meta-url-rsc\/page.tsx$/
+      )
+    })
+
+    it('should work during SSR', async () => {
+      const $ = await next.render$('/import-meta-url-ssr')
+      expect($('p').text()).toMatch(
+        /^file:\/\/.*\/next-install-[^/]+\/apps\/web\/app\/import-meta-url-ssr\/page.tsx$/
+      )
+    })
+
+    it('should work on client-side', async () => {
+      const browser = await next.browser('/import-meta-url-ssr')
+      await assertNoRedbox(browser)
+      if (isTurbopack) {
+        // Turbopack intentionally doesn't expose the full path to the browser bundles
+        expect(await browser.elementByCss('p').text()).toBe(
+          'file:///ROOT/apps/web/app/import-meta-url-ssr/page.tsx'
+        )
+      } else {
+        expect(await browser.elementByCss('p').text()).toMatch(
+          /^file:\/\/.*\/next-install-[^/]+\/apps\/web\/app\/import-meta-url-ssr\/page.tsx$/
+        )
+      }
+      await browser.close()
+    })
+  })
+
   if (isNextDev) {
     describe('source-maps', () => {
       function normalizeStackTrace(stack: string): string {

turbopack/crates/turbopack-browser/src/chunking_context.rs

@@ -118,6 +118,8 @@ pub struct BrowserChunkingContext {
     should_use_file_source_map_uris: bool,
     /// This path is used to compute the url to request chunks from
     output_root: ResolvedVc<FileSystemPath>,
+    /// The relative path from the output_root to the root_path.
+    output_root_to_root_path: ResolvedVc<RcStr>,
     /// This path is used to compute the url to request assets from
     client_root: ResolvedVc<FileSystemPath>,
     /// Chunks are placed at this path
@@ -154,6 +156,7 @@ impl BrowserChunkingContext {
     pub fn builder(
         root_path: ResolvedVc<FileSystemPath>,
         output_root: ResolvedVc<FileSystemPath>,
+        output_root_to_root_path: ResolvedVc<RcStr>,
         client_root: ResolvedVc<FileSystemPath>,
         chunk_root_path: ResolvedVc<FileSystemPath>,
         asset_root_path: ResolvedVc<FileSystemPath>,
@@ -165,6 +168,7 @@ impl BrowserChunkingContext {
                 name: None,
                 root_path,
                 output_root,
+                output_root_to_root_path,
                 client_root,
                 chunk_root_path,
                 should_use_file_source_map_uris: false,
@@ -286,6 +290,11 @@ impl ChunkingContext for BrowserChunkingContext {
         *self.output_root
     }
 
+    #[turbo_tasks::function]
+    fn output_root_to_root_path(&self) -> Vc<RcStr> {
+        *self.output_root_to_root_path
+    }
+
     #[turbo_tasks::function]
     fn environment(&self) -> Vc<Environment> {
         *self.environment

turbopack/crates/turbopack-browser/src/ecmascript/evaluate/chunk.rs

@@ -69,6 +69,7 @@ impl EcmascriptDevEvaluateChunk {
         let environment = this.chunking_context.environment();
 
         let output_root = this.chunking_context.output_root().await?;
+        let output_root_to_root_path = this.chunking_context.output_root_to_root_path();
         let chunk_path_vc = self.ident().path();
         let chunk_path = chunk_path_vc.await?;
         let chunk_public_path = if let Some(path) = output_root.get_path_to(&chunk_path) {
@@ -145,7 +146,7 @@ impl EcmascriptDevEvaluateChunk {
                     environment,
                     chunking_context.chunk_base_path(),
                     Value::new(chunking_context.runtime_type()),
-                    Vc::cell(output_root.to_string().into()),
+                    output_root_to_root_path,
                 );
                 code.push_code(&*runtime_code.await?);
             }
@@ -154,7 +155,7 @@ impl EcmascriptDevEvaluateChunk {
                     environment,
                     chunking_context.chunk_base_path(),
                     Value::new(chunking_context.runtime_type()),
-                    Vc::cell(output_root.to_string().into()),
+                    output_root_to_root_path,
                 );
                 code.push_code(&*runtime_code.await?);
             }

turbopack/crates/turbopack-cli/src/build/mod.rs

@@ -189,19 +189,23 @@ async fn build_internal(
         .unwrap_or(project_relative)
         .replace(MAIN_SEPARATOR, "/")
         .into();
-    let project_path = project_fs
-        .root()
-        .join(project_relative)
-        .to_resolved()
-        .await?;
+    let root_path = project_fs.root().to_resolved().await?;
+    let project_path = root_path.join(project_relative).to_resolved().await?;
     let build_output_root = output_fs.root().join("dist".into()).to_resolved().await?;
 
     let node_env = NodeEnv::Production.cell();
 
+    let build_output_root_to_root_path = project_path
+        .join("dist".into())
+        .await?
+        .get_relative_path_to(&*root_path.await?)
+        .context("Project path is in root path")?;
+
     let chunking_context = Vc::upcast(
         NodeJsChunkingContext::builder(
-            project_path,
+            root_path,
             build_output_root,
+            ResolvedVc::cell(build_output_root_to_root_path),
             build_output_root,
             build_output_root,
             build_output_root,
@@ -217,7 +221,7 @@ async fn build_internal(
 
     let compile_time_info = get_client_compile_time_info(browserslist_query, node_env);
     let execution_context =
-        ExecutionContext::new(*project_path, chunking_context, load_env(*project_path));
+        ExecutionContext::new(*root_path, chunking_context, load_env(*root_path));
     let asset_context = get_client_asset_context(
         *project_path,
         execution_context,

turbopack/crates/turbopack-cli/src/dev/mod.rs

@@ -242,19 +242,28 @@ async fn source(
         .into();
 
     let output_fs = output_fs(project_dir);
-    let fs = project_fs(root_dir);
-    let project_path = fs.root().join(project_relative).to_resolved().await?;
+    let fs: Vc<Box<dyn FileSystem>> = project_fs(root_dir);
+    let root_path = fs.root().to_resolved().await?;
+    let project_path = root_path.join(project_relative).to_resolved().await?;
 
-    let env = load_env(*project_path);
+    let env = load_env(*root_path);
     let build_output_root = output_fs
         .root()
         .join(".turbopack/build".into())
         .to_resolved()
         .await?;
 
+    let build_output_root_to_root_path = project_path
+        .join(".turbopack/build".into())
+        .await?
+        .get_relative_path_to(&*root_path.await?)
+        .context("Project path is in root path")?;
+    let build_output_root_to_root_path = ResolvedVc::cell(build_output_root_to_root_path);
+
     let build_chunking_context = NodeJsChunkingContext::builder(
-        project_path,
+        root_path,
         build_output_root,
+        build_output_root_to_root_path,
         build_output_root,
         build_output_root
             .join("chunks".into())
@@ -270,7 +279,7 @@ async fn source(
     .build();
 
     let execution_context =
-        ExecutionContext::new(*project_path, Vc::upcast(build_chunking_context), env);
+        ExecutionContext::new(*root_path, Vc::upcast(build_chunking_context), env);
 
     let server_fs = Vc::upcast::<Box<dyn FileSystem>>(ServerFileSystem::new());
     let server_root = server_fs.root();
@@ -292,11 +301,12 @@ async fn source(
         })
         .collect();
 
-    let web_source = create_web_entry_source(
-        *project_path,
+    let web_source: ResolvedVc<Box<dyn ContentSource>> = create_web_entry_source(
+        *root_path,
         execution_context,
         entry_requests,
         server_root,
+        Vc::cell("/ROOT".into()),
         env,
         eager_compile,
         NodeEnv::Development.cell(),