metro 0.80.9 → 0.80.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metro",
-  "version": "0.80.9",
+  "version": "0.80.10",
   "description": "🚇 The JavaScript bundler for React Native.",
   "main": "src/index.js",
   "bin": "src/cli.js",
@@ -27,34 +27,34 @@
     "debug": "^2.2.0",
     "denodeify": "^1.2.1",
     "error-stack-parser": "^2.0.6",
+    "flow-enums-runtime": "^0.0.6",
     "graceful-fs": "^4.2.4",
-    "hermes-parser": "0.20.1",
+    "hermes-parser": "0.23.0",
     "image-size": "^1.0.2",
     "invariant": "^2.2.4",
     "jest-worker": "^29.6.3",
     "jsc-safe-url": "^0.2.2",
     "lodash.throttle": "^4.1.1",
-    "metro-babel-transformer": "0.80.9",
-    "metro-cache": "0.80.9",
-    "metro-cache-key": "0.80.9",
-    "metro-config": "0.80.9",
-    "metro-core": "0.80.9",
-    "metro-file-map": "0.80.9",
-    "metro-resolver": "0.80.9",
-    "metro-runtime": "0.80.9",
-    "metro-source-map": "0.80.9",
-    "metro-symbolicate": "0.80.9",
-    "metro-transform-plugins": "0.80.9",
-    "metro-transform-worker": "0.80.9",
+    "metro-babel-transformer": "0.80.10",
+    "metro-cache": "0.80.10",
+    "metro-cache-key": "0.80.10",
+    "metro-config": "0.80.10",
+    "metro-core": "0.80.10",
+    "metro-file-map": "0.80.10",
+    "metro-resolver": "0.80.10",
+    "metro-runtime": "0.80.10",
+    "metro-source-map": "0.80.10",
+    "metro-symbolicate": "0.80.10",
+    "metro-transform-plugins": "0.80.10",
+    "metro-transform-worker": "0.80.10",
     "mime-types": "^2.1.27",
     "node-fetch": "^2.2.0",
     "nullthrows": "^1.1.1",
-    "rimraf": "^3.0.2",
     "serialize-error": "^2.1.0",
     "source-map": "^0.5.6",
     "strip-ansi": "^6.0.0",
     "throat": "^5.0.0",
-    "ws": "^7.5.1",
+    "ws": "^7.5.10",
     "yargs": "^17.6.2"
   },
   "devDependencies": {
@@ -66,8 +66,8 @@
     "dedent": "^0.7.0",
     "jest-snapshot": "^29.6.3",
     "jest-snapshot-serializer-raw": "^1.2.0",
-    "metro-babel-register": "0.80.9",
-    "metro-memory-fs": "0.80.9",
+    "metro-babel-register": "0.80.10",
+    "metro-memory-fs": "0.80.10",
     "mock-req": "^0.2.0",
     "mock-res": "^0.6.0",
     "stack-trace": "^0.0.10"

package/src/DeltaBundler/Serializers/baseJSBundle.js

@@ -35,6 +35,7 @@ function baseJSBundle(entryPoint, preModules, graph, options) {
       shouldAddToIgnoreList: options.shouldAddToIgnoreList,
       sourceMapUrl: options.sourceMapUrl,
       sourceUrl: options.sourceUrl,
+      getSourceUrl: options.getSourceUrl,
     }),
     processModulesOptions
   )

package/src/DeltaBundler/Serializers/baseJSBundle.js.flow

@@ -67,6 +67,7 @@ function baseJSBundle(
       shouldAddToIgnoreList: options.shouldAddToIgnoreList,
       sourceMapUrl: options.sourceMapUrl,
       sourceUrl: options.sourceUrl,
+      getSourceUrl: options.getSourceUrl,
     }),
     processModulesOptions,
   )

package/src/DeltaBundler/Serializers/getRamBundleInfo.js

@@ -21,6 +21,7 @@ async function getRamBundleInfo(entryPoint, pre, graph, options) {
         excludeSource: options.excludeSource,
         processModuleFilter: options.processModuleFilter,
         shouldAddToIgnoreList: options.shouldAddToIgnoreList,
+        getSourceUrl: options.getSourceUrl,
       }),
       name: path.basename(module.path),
       sourcePath: module.path,

package/src/DeltaBundler/Serializers/getRamBundleInfo.js.flow

@@ -65,6 +65,7 @@ async function getRamBundleInfo(
         excludeSource: options.excludeSource,
         processModuleFilter: options.processModuleFilter,
         shouldAddToIgnoreList: options.shouldAddToIgnoreList,
+        getSourceUrl: options.getSourceUrl,
       }),
       name: path.basename(module.path),
       sourcePath: module.path,

package/src/DeltaBundler/Serializers/helpers/getSourceMapInfo.js

@@ -5,7 +5,7 @@ function getSourceMapInfo(module, options) {
   return {
     ...getJsOutput(module).data,
     isIgnored: options.shouldAddToIgnoreList(module),
-    path: module.path,
+    path: options?.getSourceUrl?.(module) ?? module.path,
     source: options.excludeSource ? "" : getModuleSource(module),
   };
 }

package/src/DeltaBundler/Serializers/helpers/getSourceMapInfo.js.flow

@@ -24,6 +24,7 @@ function getSourceMapInfo(
   options: {
     +excludeSource: boolean,
     +shouldAddToIgnoreList: (Module<>) => boolean,
+    getSourceUrl: ?(module: Module<>) => string,
   },
 ): {
   +map: Array<MetroSourceMapSegmentTuple>,
@@ -37,7 +38,7 @@ function getSourceMapInfo(
   return {
     ...getJsOutput(module).data,
     isIgnored: options.shouldAddToIgnoreList(module),
-    path: module.path,
+    path: options?.getSourceUrl?.(module) ?? module.path,
     source: options.excludeSource ? '' : getModuleSource(module),
   };
 }

package/src/DeltaBundler/Serializers/sourceMapGenerator.js

@@ -19,6 +19,7 @@ function getSourceMapInfosImpl(isBlocking, onDone, modules, options) {
     const info = getSourceMapInfo(mod, {
       excludeSource: options.excludeSource,
       shouldAddToIgnoreList: options.shouldAddToIgnoreList,
+      getSourceUrl: options.getSourceUrl,
     });
     sourceMapInfos.push(info);
     return false;

package/src/DeltaBundler/Serializers/sourceMapGenerator.js.flow

@@ -24,6 +24,7 @@ export type SourceMapGeneratorOptions = $ReadOnly<{
   excludeSource: boolean,
   processModuleFilter: (module: Module<>) => boolean,
   shouldAddToIgnoreList: (module: Module<>) => boolean,
+  getSourceUrl: ?(module: Module<>) => string,
 }>;
 
 function getSourceMapInfosImpl(
@@ -43,9 +44,11 @@ function getSourceMapInfosImpl(
     }
 
     const mod = modulesToProcess.shift();
+    // $FlowFixMe[incompatible-call]
     const info = getSourceMapInfo(mod, {
       excludeSource: options.excludeSource,
       shouldAddToIgnoreList: options.shouldAddToIgnoreList,
+      getSourceUrl: options.getSourceUrl,
     });
     sourceMapInfos.push(info);
     return false;

package/src/DeltaBundler/Serializers/sourceMapString.js

@@ -1,9 +1,21 @@
 "use strict";
 
-const { sourceMapGenerator } = require("./sourceMapGenerator");
+const {
+  sourceMapGenerator,
+  sourceMapGeneratorNonBlocking,
+} = require("./sourceMapGenerator");
 function sourceMapString(modules, options) {
   return sourceMapGenerator(modules, options).toString(undefined, {
     excludeSource: options.excludeSource,
   });
 }
-module.exports = sourceMapString;
+async function sourceMapStringNonBlocking(modules, options) {
+  const generator = await sourceMapGeneratorNonBlocking(modules, options);
+  return generator.toString(undefined, {
+    excludeSource: options.excludeSource,
+  });
+}
+module.exports = {
+  sourceMapString,
+  sourceMapStringNonBlocking,
+};

package/src/DeltaBundler/Serializers/sourceMapString.js.flow

@@ -14,7 +14,10 @@
 import type {Module} from '../types.flow';
 import type {SourceMapGeneratorOptions} from './sourceMapGenerator';
 
-const {sourceMapGenerator} = require('./sourceMapGenerator');
+const {
+  sourceMapGenerator,
+  sourceMapGeneratorNonBlocking,
+} = require('./sourceMapGenerator');
 
 function sourceMapString(
   modules: $ReadOnlyArray<Module<>>,
@@ -25,4 +28,17 @@ function sourceMapString(
   });
 }
 
-module.exports = sourceMapString;
+async function sourceMapStringNonBlocking(
+  modules: $ReadOnlyArray<Module<>>,
+  options: SourceMapGeneratorOptions,
+): Promise<string> {
+  const generator = await sourceMapGeneratorNonBlocking(modules, options);
+  return generator.toString(undefined, {
+    excludeSource: options.excludeSource,
+  });
+}
+
+module.exports = {
+  sourceMapString,
+  sourceMapStringNonBlocking,
+};

package/src/DeltaBundler/Transformer.js

@@ -64,7 +64,7 @@ class Transformer {
     const localPath = path.relative(this._config.projectRoot, filePath);
     const partialKey = stableHash([
       this._baseHash,
-      localPath,
+      path.sep === "/" ? localPath : localPath.replaceAll(path.sep, "/"),
       customTransformOptions,
       dev,
       experimentalImportSupport,

package/src/DeltaBundler/Transformer.js.flow

@@ -105,8 +105,10 @@ class Transformer {
       // This is the hash related to the global Bundler config.
       this._baseHash,
 
-      // Path.
-      localPath,
+      // Project-relative, posix-separated path for portability. Necessary in
+      // addition to content hash because transformers receive path as an
+      // input, and may apply e.g. extension-based logic.
+      path.sep === '/' ? localPath : localPath.replaceAll(path.sep, '/'),
 
       customTransformOptions,
       dev,

package/src/DeltaBundler/types.flow.js.flow

@@ -23,7 +23,7 @@ export type MixedOutput = {
   +type: string,
 };
 
-export type AsyncDependencyType = 'async' | 'prefetch' | 'weak';
+export type AsyncDependencyType = 'async' | 'maybeSync' | 'prefetch' | 'weak';
 
 export type TransformResultDependency = $ReadOnly<{
   /**
@@ -175,4 +175,5 @@ export type SerializerOptions = $ReadOnly<{
   shouldAddToIgnoreList: (Module<>) => boolean,
   sourceMapUrl: ?string,
   sourceUrl: ?string,
+  getSourceUrl: ?(Module<>) => string,
 }>;

package/src/ModuleGraph/worker/collectDependencies.js

@@ -67,6 +67,21 @@ function collectDependencies(ast, options) {
         visited.add(path.node);
         return;
       }
+      if (
+        callee.type === "MemberExpression" &&
+        callee.object.type === "Identifier" &&
+        callee.object.name === "require" &&
+        callee.property.type === "Identifier" &&
+        callee.property.name === "unstable_importMaybeSync" &&
+        !callee.computed &&
+        !path.scope.getBinding("require")
+      ) {
+        processImportCall(path, state, {
+          asyncType: "maybeSync",
+        });
+        visited.add(path.node);
+        return;
+      }
       if (
         name != null &&
         state.dependencyCalls.has(name) &&
@@ -261,10 +276,21 @@ function processImportCall(path, state, options) {
     path
   );
   const transformer = state.dependencyTransformer;
-  if (options.asyncType === "async") {
-    transformer.transformImportCall(path, dep, state);
-  } else {
-    transformer.transformPrefetch(path, dep, state);
+  switch (options.asyncType) {
+    case "async":
+      transformer.transformImportCall(path, dep, state);
+      break;
+    case "maybeSync":
+      transformer.transformImportMaybeSyncCall(path, dep, state);
+      break;
+    case "prefetch":
+      transformer.transformPrefetch(path, dep, state);
+      break;
+    case "weak":
+      throw new Error("Unreachable");
+    default:
+      options.asyncType;
+      throw new Error("Unreachable");
   }
 }
 function processRequireCall(path, state) {
@@ -380,6 +406,12 @@ const makeAsyncPrefetchTemplate = template.expression(`
 const makeAsyncPrefetchTemplateWithName = template.expression(`
   require(ASYNC_REQUIRE_MODULE_PATH).prefetch(MODULE_ID, DEPENDENCY_MAP.paths, MODULE_NAME)
 `);
+const makeAsyncImportMaybeSyncTemplate = template.expression(`
+  require(ASYNC_REQUIRE_MODULE_PATH).unstable_importMaybeSync(MODULE_ID, DEPENDENCY_MAP.paths)
+`);
+const makeAsyncImportMaybeSyncTemplateWithName = template.expression(`
+  require(ASYNC_REQUIRE_MODULE_PATH).unstable_importMaybeSync(MODULE_ID, DEPENDENCY_MAP.paths, MODULE_NAME)
+`);
 const makeResolveWeakTemplate = template.expression(`
   MODULE_ID
 `);
@@ -409,6 +441,24 @@ const DefaultDependencyTransformer = {
     };
     path.replaceWith(makeNode(opts));
   },
+  transformImportMaybeSyncCall(path, dependency, state) {
+    const makeNode = state.keepRequireNames
+      ? makeAsyncImportMaybeSyncTemplateWithName
+      : makeAsyncImportMaybeSyncTemplate;
+    const opts = {
+      ASYNC_REQUIRE_MODULE_PATH: nullthrows(
+        state.asyncRequireModulePathStringLiteral
+      ),
+      MODULE_ID: createModuleIDExpression(dependency, state),
+      DEPENDENCY_MAP: nullthrows(state.dependencyMapIdentifier),
+      ...(state.keepRequireNames
+        ? {
+            MODULE_NAME: createModuleNameLiteral(dependency),
+          }
+        : null),
+    };
+    path.replaceWith(makeNode(opts));
+  },
   transformPrefetch(path, dependency, state) {
     const makeNode = state.keepRequireNames
       ? makeAsyncPrefetchTemplateWithName

package/src/ModuleGraph/worker/collectDependencies.js.flow

@@ -112,6 +112,11 @@ export interface DependencyTransformer {
     dependency: InternalDependency,
     state: State,
   ): void;
+  transformImportMaybeSyncCall(
+    path: NodePath<>,
+    dependency: InternalDependency,
+    state: State,
+  ): void;
   transformPrefetch(
     path: NodePath<>,
     dependency: InternalDependency,
@@ -214,6 +219,26 @@ function collectDependencies(
         return;
       }
 
+      // Match `require.unstable_importMaybeSync`
+      if (
+        callee.type === 'MemberExpression' &&
+        // `require`
+        callee.object.type === 'Identifier' &&
+        callee.object.name === 'require' &&
+        // `unstable_importMaybeSync`
+        callee.property.type === 'Identifier' &&
+        callee.property.name === 'unstable_importMaybeSync' &&
+        !callee.computed &&
+        // Ensure `require` refers to the global and not something else.
+        !path.scope.getBinding('require')
+      ) {
+        processImportCall(path, state, {
+          asyncType: 'maybeSync',
+        });
+        visited.add(path.node);
+        return;
+      }
+
       if (
         name != null &&
         state.dependencyCalls.has(name) &&
@@ -456,10 +481,21 @@ function processImportCall(
 
   const transformer = state.dependencyTransformer;
 
-  if (options.asyncType === 'async') {
-    transformer.transformImportCall(path, dep, state);
-  } else {
-    transformer.transformPrefetch(path, dep, state);
+  switch (options.asyncType) {
+    case 'async':
+      transformer.transformImportCall(path, dep, state);
+      break;
+    case 'maybeSync':
+      transformer.transformImportMaybeSyncCall(path, dep, state);
+      break;
+    case 'prefetch':
+      transformer.transformPrefetch(path, dep, state);
+      break;
+    case 'weak':
+      throw new Error('Unreachable');
+    default:
+      options.asyncType as empty;
+      throw new Error('Unreachable');
   }
 }
 
@@ -639,6 +675,14 @@ const makeAsyncPrefetchTemplateWithName = template.expression(`
   require(ASYNC_REQUIRE_MODULE_PATH).prefetch(MODULE_ID, DEPENDENCY_MAP.paths, MODULE_NAME)
 `);
 
+const makeAsyncImportMaybeSyncTemplate = template.expression(`
+  require(ASYNC_REQUIRE_MODULE_PATH).unstable_importMaybeSync(MODULE_ID, DEPENDENCY_MAP.paths)
+`);
+
+const makeAsyncImportMaybeSyncTemplateWithName = template.expression(`
+  require(ASYNC_REQUIRE_MODULE_PATH).unstable_importMaybeSync(MODULE_ID, DEPENDENCY_MAP.paths, MODULE_NAME)
+`);
+
 const makeResolveWeakTemplate = template.expression(`
   MODULE_ID
 `);
@@ -683,6 +727,27 @@ const DefaultDependencyTransformer: DependencyTransformer = {
     path.replaceWith(makeNode(opts));
   },
 
+  transformImportMaybeSyncCall(
+    path: NodePath<>,
+    dependency: InternalDependency,
+    state: State,
+  ): void {
+    const makeNode = state.keepRequireNames
+      ? makeAsyncImportMaybeSyncTemplateWithName
+      : makeAsyncImportMaybeSyncTemplate;
+    const opts = {
+      ASYNC_REQUIRE_MODULE_PATH: nullthrows(
+        state.asyncRequireModulePathStringLiteral,
+      ),
+      MODULE_ID: createModuleIDExpression(dependency, state),
+      DEPENDENCY_MAP: nullthrows(state.dependencyMapIdentifier),
+      ...(state.keepRequireNames
+        ? {MODULE_NAME: createModuleNameLiteral(dependency)}
+        : null),
+    };
+    path.replaceWith(makeNode(opts));
+  },
+
   transformPrefetch(
     path: NodePath<>,
     dependency: InternalDependency,

package/src/Server.js

@@ -1,5 +1,6 @@
 "use strict";
 
+var _types = require("./shared/types.flow");
 const { getAsset } = require("./Assets");
 const baseJSBundle = require("./DeltaBundler/Serializers/baseJSBundle");
 const getAllFiles = require("./DeltaBundler/Serializers/getAllFiles");
@@ -8,7 +9,9 @@ const {
   getExplodedSourceMap,
 } = require("./DeltaBundler/Serializers/getExplodedSourceMap");
 const getRamBundleInfo = require("./DeltaBundler/Serializers/getRamBundleInfo");
-const sourceMapString = require("./DeltaBundler/Serializers/sourceMapString");
+const {
+  sourceMapStringNonBlocking,
+} = require("./DeltaBundler/Serializers/sourceMapString");
 const IncrementalBundler = require("./IncrementalBundler");
 const ResourceNotFoundError = require("./IncrementalBundler/ResourceNotFoundError");
 const bundleToString = require("./lib/bundleToString");
@@ -60,6 +63,22 @@ class Server {
     this._reporter = config.reporter;
     this._logger = Logger;
     this._platforms = new Set(this._config.resolver.platforms);
+    this._allowedSuffixesForSourceRequests = [
+      ...new Set(
+        [
+          ...this._config.resolver.sourceExts,
+          ...this._config.watcher.additionalExts,
+          ...this._config.resolver.assetExts,
+        ].map((ext) => "." + ext)
+      ),
+    ];
+    this._sourceRequestRoutingMap = [
+      ["/[metro-project]/", path.resolve(this._config.projectRoot)],
+      ...this._config.watchFolders.map((watchFolder, index) => [
+        `/[metro-watchFolders]/${index}/`,
+        path.resolve(watchFolder),
+      ]),
+    ];
     this._isEnded = false;
     this._createModuleId = config.serializer.createModuleIdFactory();
     this._bundler = new IncrementalBundler(config, {
@@ -128,6 +147,8 @@ class Server {
         this._config.server.unstable_serverRoot ?? this._config.projectRoot,
       shouldAddToIgnoreList: (module) =>
         this._shouldAddModuleToIgnoreList(module),
+      getSourceUrl: (module) =>
+        this._getModuleSourceUrl(module, serializerOptions.sourcePaths),
     };
     let bundleCode = null;
     let bundleMap = null;
@@ -150,12 +171,14 @@ class Server {
       ).code;
     }
     if (!bundleMap) {
-      bundleMap = sourceMapString(
+      bundleMap = await sourceMapStringNonBlocking(
         [...prepend, ...this._getSortedModules(graph)],
         {
           excludeSource: serializerOptions.excludeSource,
           processModuleFilter: this._config.serializer.processModuleFilter,
           shouldAddToIgnoreList: bundleOptions.shouldAddToIgnoreList,
+          getSourceUrl: (module) =>
+            this._getModuleSourceUrl(module, serializerOptions.sourcePaths),
         }
       );
     }
@@ -215,6 +238,8 @@ class Server {
         this._config.server.unstable_serverRoot ?? this._config.projectRoot,
       shouldAddToIgnoreList: (module) =>
         this._shouldAddModuleToIgnoreList(module),
+      getSourceUrl: (module) =>
+        this._getModuleSourceUrl(module, serializerOptions.sourcePaths),
     });
   }
   async getAssets(options) {
@@ -342,7 +367,7 @@ class Server {
   async _processRequest(req, res, next) {
     const originalUrl = req.url;
     req.url = this._rewriteAndNormalizeUrl(req.url);
-    const urlObj = url.parse(req.url, true);
+    const urlObj = url.parse(decodeURI(req.url), true);
     const { host } = req.headers;
     debug(
       `Handling request: ${host ? "http://" + host : ""}${req.url}` +
@@ -393,9 +418,58 @@ class Server {
     } else if (pathname === "/symbolicate") {
       await this._symbolicate(req, res);
     } else {
-      next();
+      let handled = false;
+      for (const [pathnamePrefix, normalizedRootDir] of this
+        ._sourceRequestRoutingMap) {
+        if (pathname.startsWith(pathnamePrefix)) {
+          const relativePathname = pathname.substr(pathnamePrefix.length);
+          await this._processSourceRequest(
+            relativePathname,
+            normalizedRootDir,
+            res
+          );
+          handled = true;
+          break;
+        }
+      }
+      if (!handled) {
+        next();
+      }
     }
   }
+  async _processSourceRequest(relativePathname, rootDir, res) {
+    if (
+      !this._allowedSuffixesForSourceRequests.some((suffix) =>
+        relativePathname.endsWith(suffix)
+      )
+    ) {
+      res.writeHead(404);
+      res.end();
+      return;
+    }
+    const depGraph = await this._bundler.getBundler().getDependencyGraph();
+    const filePath = path.join(rootDir, relativePathname);
+    try {
+      depGraph.getSha1(filePath);
+    } catch {
+      res.writeHead(404);
+      res.end();
+      return;
+    }
+    const mimeType = mime.lookup(path.basename(relativePathname));
+    res.setHeader("Content-Type", mimeType);
+    const stream = fs.createReadStream(filePath);
+    stream.pipe(res);
+    stream.on("error", (error) => {
+      if (error.code === "ENOENT") {
+        res.writeHead(404);
+        res.end();
+      } else {
+        res.writeHead(500);
+        res.end();
+      }
+    });
+  }
   _createRequestProcessor({
     createStartEntry,
     createEndEntry,
@@ -673,6 +747,8 @@ class Server {
             this._config.server.unstable_serverRoot ?? this._config.projectRoot,
           shouldAddToIgnoreList: (module) =>
             this._shouldAddModuleToIgnoreList(module),
+          getSourceUrl: (module) =>
+            this._getModuleSourceUrl(module, serializerOptions.sourcePaths),
         }
       );
       bundlePerfLogger.point("serializingBundle_end");
@@ -795,12 +871,17 @@ class Server {
       if (serializerOptions.modulesOnly) {
         prepend = [];
       }
-      return sourceMapString([...prepend, ...this._getSortedModules(graph)], {
-        excludeSource: serializerOptions.excludeSource,
-        processModuleFilter: this._config.serializer.processModuleFilter,
-        shouldAddToIgnoreList: (module) =>
-          this._shouldAddModuleToIgnoreList(module),
-      });
+      return await sourceMapStringNonBlocking(
+        [...prepend, ...this._getSortedModules(graph)],
+        {
+          excludeSource: serializerOptions.excludeSource,
+          processModuleFilter: this._config.serializer.processModuleFilter,
+          shouldAddToIgnoreList: (module) =>
+            this._shouldAddModuleToIgnoreList(module),
+          getSourceUrl: (module) =>
+            this._getModuleSourceUrl(module, serializerOptions.sourcePaths),
+        }
+      );
     },
     finish({ mres, result }) {
       mres.setHeader("Content-Type", "application/json");
@@ -1057,6 +1138,7 @@ class Server {
     shallow: false,
     sourceMapUrl: null,
     sourceUrl: null,
+    sourcePaths: _types.SourcePathsMode.Absolute,
   };
   _getServerRootDir() {
     return this._config.server.unstable_serverRoot ?? this._config.projectRoot;
@@ -1074,6 +1156,27 @@ class Server {
       this._config.serializer.isThirdPartyModule(module)
     );
   }
+  _getModuleSourceUrl(module, mode) {
+    switch (mode) {
+      case _types.SourcePathsMode.ServerUrl:
+        for (const [pathnamePrefix, normalizedRootDir] of this
+          ._sourceRequestRoutingMap) {
+          if (module.path.startsWith(normalizedRootDir + path.sep)) {
+            const relativePath = module.path.slice(
+              normalizedRootDir.length + 1
+            );
+            const relativePathPosix = relativePath.split(path.sep).join("/");
+            return pathnamePrefix + encodeURI(relativePathPosix);
+          }
+        }
+        const modulePathPosix = module.path.split(path.sep).join("/");
+        return modulePathPosix.startsWith("/")
+          ? encodeURI(modulePathPosix)
+          : "/" + encodeURI(modulePathPosix);
+      case _types.SourcePathsMode.Absolute:
+        return module.path;
+    }
+  }
 }
 function* zip(xs, ys) {
   const ysIter = ys[Symbol.iterator]();