fix: replace runner-side path normalization with fetchModule-side resolve

docs/guide/api-environment-runtimes.md

@@ -182,8 +182,9 @@ type ModuleRunnerTransport = unknown
 interface ModuleRunnerOptions {
   /**
    * Root of the project
+   * @deprecated not used anymore and to be removed
    */
-  root: string
+  root?: string
   /**
    * A set of methods to communicate with the server.
    */

packages/vite/src/module-runner/runner.ts

@@ -17,7 +17,6 @@ import type {
   SSRImportMetadata,
 } from './types'
 import {
-  normalizeAbsoluteUrl,
   posixDirname,
   posixPathToFileHref,
   posixResolve,
@@ -52,7 +51,6 @@ export class ModuleRunner {
   })
   private readonly transport: NormalizedModuleRunnerTransport
   private readonly resetSourceMapSupport?: () => void
-  private readonly root: string
   private readonly concurrentModuleNodePromises = new Map<
     string,
     Promise<EvaluatedModuleNode>
@@ -65,8 +63,6 @@ export class ModuleRunner {
     public evaluator: ModuleEvaluator = new ESModulesEvaluator(),
     private debug?: ModuleRunnerDebugger,
   ) {
-    const root = this.options.root
-    this.root = root[root.length - 1] === '/' ? root : `${root}/`
     this.evaluatedModules = options.evaluatedModules ?? new EvaluatedModules()
     this.transport = normalizeModuleRunnerTransport(options.transport)
     if (options.hmr !== false) {
@@ -237,8 +233,6 @@ export class ModuleRunner {
     url: string,
     importer?: string,
   ): Promise<EvaluatedModuleNode> {
-    url = normalizeAbsoluteUrl(url, this.root)
-
     let cached = this.concurrentModuleNodePromises.get(url)
     if (!cached) {
       const cachedModule = this.evaluatedModules.getModuleByUrl(url)

packages/vite/src/module-runner/types.ts

@@ -85,8 +85,9 @@ export interface ModuleRunnerHmr {
 export interface ModuleRunnerOptions {
   /**
    * Root of the project
+   * @deprecated not used and to be removed
    */
-  root: string
+  root?: string
   /**
    * A set of methods to communicate with the server.
    */

packages/vite/src/module-runner/utils.ts

@@ -1,26 +1,5 @@
 import * as pathe from 'pathe'
-import { isWindows, slash } from '../shared/utils'
-
-export function normalizeAbsoluteUrl(url: string, root: string): string {
-  url = slash(url)
-
-  // file:///C:/root/id.js -> C:/root/id.js
-  if (url.startsWith('file://')) {
-    // 8 is the length of "file:///"
-    url = decodeURI(url.slice(isWindows ? 8 : 7))
-  }
-
-  // strip root from the URL because fetchModule prefers a public served url path
-  // packages/vite/src/node/server/moduleGraph.ts:17
-  if (url.startsWith(root)) {
-    // /root/id.js -> /id.js
-    // C:/root/id.js -> /id.js
-    // 1 is to keep the leading slash
-    url = url.slice(root.length - 1)
-  }
-
-  return url
-}
+import { isWindows } from '../shared/utils'
 
 export const decodeBase64 =
   typeof atob !== 'undefined'

packages/vite/src/node/ssr/fetchModule.ts

@@ -33,13 +33,16 @@ export async function fetchModule(
     return { externalize: url, type: 'builtin' }
   }
 
-  if (isExternalUrl(url)) {
+  // handle file urls from not statically analyzable dynamic import
+  const isFileUrl = url.startsWith('file://')
+
+  if (isExternalUrl(url) && !isFileUrl) {
     return { externalize: url, type: 'network' }
   }
 
   // if there is no importer, the file is an entry point
   // entry points are always internalized
-  if (importer && url[0] !== '.' && url[0] !== '/') {
+  if (!isFileUrl && importer && url[0] !== '.' && url[0] !== '/') {
     const { isProduction, root } = environment.config
     const { externalConditions, dedupe, preserveSymlinks } =
       environment.config.resolve
@@ -74,7 +77,7 @@ export async function fetchModule(
 
   // this is an entry point module, very high chance it's not resolved yet
   // for example: runner.import('./some-file') or runner.import('/some-file')
-  if (!importer) {
+  if (isFileUrl || !importer) {
     const resolved = await environment.pluginContainer.resolveId(url)
     if (!resolved) {
       throw new Error(`[vite] cannot find entry point module '${url}'.`)
@@ -84,8 +87,8 @@ export async function fetchModule(
 
   url = unwrapId(url)
 
-  let mod = await environment.moduleGraph.getModuleByUrl(url)
-  const cached = !!mod?.transformResult
+  const mod = await environment.moduleGraph.ensureEntryFromUrl(url)
+  const cached = !!mod.transformResult
 
   // if url is already cached, we can just confirm it's also cached on the server
   if (options.cached && cached) {
@@ -102,17 +105,6 @@ export async function fetchModule(
     )
   }
 
-  // module entry should be created by transformRequest
-  mod ??= await environment.moduleGraph.getModuleByUrl(url)
-
-  if (!mod) {
-    throw new Error(
-      `[vite] cannot find module '${url}' ${
-        importer ? ` imported from '${importer}'` : ''
-      }.`,
-    )
-  }
-
   if (options.inlineSourceMap !== false) {
     result = inlineSourceMap(mod, result, options.startOffset)
   }

packages/vite/src/node/ssr/runtime/__tests__/fixtures/dynamic-import.js

@@ -1,16 +1,20 @@
 import path from 'node:path'
 import * as staticModule from './simple'
+import { pathToFileURL } from 'node:url'
 
 export const initialize = async () => {
   const nameRelative = './simple'
   const nameAbsolute = '/fixtures/simple'
   const nameAbsoluteExtension = '/fixtures/simple.js'
+  const absolutePath = path.join(import.meta.dirname, "simple.js")
+  const fileUrl = pathToFileURL(absolutePath)
   return {
     dynamicProcessed: await import('./simple'),
     dynamicRelative: await import(nameRelative),
     dynamicAbsolute: await import(nameAbsolute),
     dynamicAbsoluteExtension: await import(nameAbsoluteExtension),
-    dynamicAbsoluteFull: await import(path.join(import.meta.dirname, "simple.js")),
+    dynamicAbsoluteFull: await import((process.platform === 'win32' ? '/@fs/' : '') + absolutePath),
+    dynamicFileUrl: await import(fileUrl),
     static: staticModule,
   }
 }

packages/vite/src/node/ssr/runtime/__tests__/server-runtime.spec.ts

@@ -165,6 +165,7 @@ describe('module runner initialization', async () => {
     expect(modules.static).toBe(modules.dynamicAbsolute)
     expect(modules.static).toBe(modules.dynamicAbsoluteExtension)
     expect(modules.static).toBe(modules.dynamicAbsoluteFull)
+    expect(modules.static).toBe(modules.dynamicFileUrl)
   })
 
   it('correctly imports a virtual module', async ({ runner }) => {
@@ -250,3 +251,41 @@ describe('optimize-deps', async () => {
     expect(mod.default.hello()).toMatchInlineSnapshot(`"world"`)
   })
 })
+
+describe('resolveId absolute path entry', async () => {
+  const it = await createModuleRunnerTester({
+    plugins: [
+      {
+        name: 'test-resolevId',
+        enforce: 'pre',
+        resolveId(source) {
+          if (
+            source ===
+            posix.join(this.environment.config.root, 'fixtures/basic.js')
+          ) {
+            return '\0virtual:basic'
+          }
+        },
+        load(id) {
+          if (id === '\0virtual:basic') {
+            return `export const name = "virtual:basic"`
+          }
+        },
+      },
+    ],
+  })
+
+  it('ssrLoadModule', async ({ server }) => {
+    const mod = await server.ssrLoadModule(
+      posix.join(server.config.root, 'fixtures/basic.js'),
+    )
+    expect(mod.name).toMatchInlineSnapshot(`"virtual:basic"`)
+  })
+
+  it('runner', async ({ server, runner }) => {
+    const mod = await runner.import(
+      posix.join(server.config.root, 'fixtures/basic.js'),
+    )
+    expect(mod.name).toMatchInlineSnapshot(`"virtual:basic"`)
+  })
+})

packages/vite/src/node/ssr/runtime/__tests__/server-source-maps.spec.ts

@@ -19,12 +19,12 @@ describe('module runner initialization', async () => {
     }
   }
   const serializeStack = (runner: ModuleRunner, err: Error) => {
-    return err.stack!.split('\n')[1].replace(runner.options.root, '<root>')
+    return err.stack!.split('\n')[1].replace(runner.options.root!, '<root>')
   }
   const serializeStackDeep = (runtime: ModuleRunner, err: Error) => {
     return err
       .stack!.split('\n')
-      .map((s) => s.replace(runtime.options.root, '<root>'))
+      .map((s) => s.replace(runtime.options.root!, '<root>'))
   }
 
   it('source maps are correctly applied to stack traces', async ({

packages/vite/src/node/ssr/runtime/__tests__/utils.ts

@@ -71,6 +71,7 @@ export async function createModuleRunnerTester(
             }
           },
         },
+        ...(config.plugins ?? []),
       ],
       ...config,
     })