@expo/cli 0.18.18 → 0.18.19

package/build/src/start/server/metro/MetroBundlerDevServer.js

@@ -14,6 +14,7 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    ForwardHtmlError: ()=>ForwardHtmlError,
     MetroBundlerDevServer: ()=>MetroBundlerDevServer,
     getDeepLinkHandler: ()=>getDeepLinkHandler
 });
@@ -45,23 +46,9 @@ function _chalk() {
     };
     return data;
 }
-function _baseJSBundle() {
-    const data = /*#__PURE__*/ _interopRequireDefault(require("metro/src/DeltaBundler/Serializers/baseJSBundle"));
-    _baseJSBundle = function() {
-        return data;
-    };
-    return data;
-}
-function _sourceMapGenerator() {
-    const data = require("metro/src/DeltaBundler/Serializers/sourceMapGenerator");
-    _sourceMapGenerator = function() {
-        return data;
-    };
-    return data;
-}
-function _bundleToString() {
-    const data = /*#__PURE__*/ _interopRequireDefault(require("metro/src/lib/bundleToString"));
-    _bundleToString = function() {
+function _nodeFetch() {
+    const data = /*#__PURE__*/ _interopRequireDefault(require("node-fetch"));
+    _nodeFetch = function() {
         return data;
     };
     return data;
@@ -77,7 +64,6 @@ const _createServerRouteMiddleware = require("./createServerRouteMiddleware");
 const _fetchRouterManifest = require("./fetchRouterManifest");
 const _instantiateMetro = require("./instantiateMetro");
 const _metroErrorInterface = require("./metroErrorInterface");
-const _metroPrivateServer = require("./metroPrivateServer");
 const _metroWatchTypeScriptFiles = require("./metroWatchTypeScriptFiles");
 const _router = require("./router");
 const _serializeHtml = require("./serializeHtml");
@@ -147,8 +133,14 @@ function _interopRequireWildcard(obj, nodeInterop) {
     }
     return newObj;
 }
+class ForwardHtmlError extends _errors.CommandError {
+    constructor(message, html, statusCode){
+        super(message);
+        this.html = html;
+        this.statusCode = statusCode;
+    }
+}
 const debug = require("debug")("expo:start:server:metro");
-const getGraphId = require("metro/src/lib/getGraphId");
 /** Default port to use for apps running in Expo Go. */ const EXPO_GO_METRO_PORT = 8081;
 /** Default port to use for apps that run in standard React Native projects or Expo Dev Clients. */ const DEV_CLIENT_METRO_PORT = 8081;
 class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
@@ -183,17 +175,16 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
                     // Alternatively, check whether `sourcesRoot` helps here
                     const artifactBasename = encodeURIComponent(_path().default.basename(artifactFilename) + ".map");
                     src = src.replace(/\/\/# sourceMappingURL=.*/g, `//# sourceMappingURL=${artifactBasename}`);
-                    const parsedMap = JSON.parse(contents.map);
                     files.set(artifactFilename + ".map", {
                         contents: JSON.stringify({
-                            version: parsedMap.version,
-                            sources: parsedMap.sources.map((source)=>{
+                            version: contents.map.version,
+                            sources: contents.map.sources.map((source)=>{
                                 source = typeof source === "string" && source.startsWith(this.projectRoot) ? _path().default.relative(this.projectRoot, source) : source;
                                 return source.split(_path().default.sep).join("/");
                             }),
-                            sourcesContent: new Array(parsedMap.sources.length).fill(null),
-                            names: parsedMap.names,
-                            mappings: parsedMap.mappings
+                            sourcesContent: new Array(contents.map.sources.length).fill(null),
+                            names: contents.map.names,
+                            mappings: contents.map.mappings
                         }),
                         targetDomain: "server"
                     });
@@ -230,8 +221,14 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
     }
     async getStaticRenderFunctionAsync() {
         var ref;
+        const { mode , minify , isExporting  } = this.instanceMetroOptions;
+        (0, _assert().default)(mode != null && isExporting != null, "The server must be started before calling ssrLoadModule.");
         const url = this.getDevServerUrl();
-        const { getStaticContent , getManifest , getBuildTimeServerManifestAsync  } = await this.ssrLoadModule("expo-router/node/render.js");
+        const { getStaticContent , getManifest , getBuildTimeServerManifestAsync  } = await this.ssrLoadModule("expo-router/node/render.js", {
+            minify,
+            mode,
+            isExporting
+        });
         const { exp  } = (0, _config().getConfig)(this.projectRoot);
         return {
             serverManifest: await getBuildTimeServerManifestAsync(),
@@ -247,39 +244,79 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
         };
     }
     async getStaticResourcesAsync({ includeSourceMaps , mainModuleName  } = {}) {
-        const { mode , minify , isExporting , baseUrl , reactCompiler , routerRoot , asyncRoutes  } = this.instanceMetroOptions;
-        (0, _assert().default)(mode != null && isExporting != null && baseUrl != null && routerRoot != null && reactCompiler != null && asyncRoutes != null, "The server must be started before calling getStaticResourcesAsync.");
+        var ref;
+        const { mode , minify , isExporting , baseUrl , routerRoot , asyncRoutes  } = this.instanceMetroOptions;
+        (0, _assert().default)(mode != null && isExporting != null && baseUrl != null && routerRoot != null && asyncRoutes != null, "The server must be started before calling getStaticPageAsync.");
         const platform = "web";
-        const resolvedMainModuleName = mainModuleName != null ? mainModuleName : "." + _path().default.sep + (0, _manifestMiddleware.resolveMainModuleName)(this.projectRoot, {
-            platform
-        });
-        return await this.metroImportAsArtifactsAsync(resolvedMainModuleName, {
+        const devBundleUrlPathname = (0, _metroOptions.createBundleUrlPath)({
             splitChunks: isExporting && !_env1.env.EXPO_NO_BUNDLE_SPLITTING,
             platform,
             mode,
             minify,
             environment: "client",
+            serializerOutput: "static",
             serializerIncludeMaps: includeSourceMaps,
-            mainModuleName: resolvedMainModuleName,
+            mainModuleName: mainModuleName != null ? mainModuleName : (0, _manifestMiddleware.resolveMainModuleName)(this.projectRoot, {
+                platform
+            }),
             lazy: (0, _metroOptions.shouldEnableAsyncImports)(this.projectRoot),
             asyncRoutes,
             baseUrl,
             isExporting,
             routerRoot,
-            reactCompiler,
             bytecode: false
         });
+        const bundleUrl = new URL(devBundleUrlPathname, this.getDevServerUrl());
+        // Fetch the generated HTML from our custom Metro serializer
+        const results = await (0, _nodeFetch().default)(bundleUrl.toString());
+        const txt = await results.text();
+        let data;
+        try {
+            data = JSON.parse(txt);
+        } catch (error) {
+            debug(txt);
+            // Metro can throw this error when the initial module id cannot be resolved.
+            if (!results.ok && txt.startsWith("<!DOCTYPE html>")) {
+                throw new ForwardHtmlError(`Metro failed to bundle the project. Check the console for more information.`, txt, results.status);
+            }
+            _log.Log.error("Failed to generate resources with Metro, the Metro config may not be using the correct serializer. Ensure the metro.config.js is extending the expo/metro-config and is not overriding the serializer.");
+            throw error;
+        }
+        // NOTE: This could potentially need more validation in the future.
+        if ("artifacts" in data && Array.isArray(data.artifacts)) {
+            return data;
+        }
+        if (data != null && (data.errors || ((ref = data.type) == null ? void 0 : ref.match(/.*Error$/)))) {
+            // {
+            //   type: 'InternalError',
+            //   errors: [],
+            //   message: 'Metro has encountered an error: While trying to resolve module `stylis` from file `/Users/evanbacon/Documents/GitHub/lab/emotion-error-test/node_modules/@emotion/cache/dist/emotion-cache.browser.esm.js`, the package `/Users/evanbacon/Documents/GitHub/lab/emotion-error-test/node_modules/stylis/package.json` was successfully found. However, this package itself specifies a `main` module field that could not be resolved (`/Users/evanbacon/Documents/GitHub/lab/emotion-error-test/node_modules/stylis/dist/stylis.mjs`. Indeed, none of these files exist:\n' +
+            //     '\n' +
+            //     '  * /Users/evanbacon/Documents/GitHub/lab/emotion-error-test/node_modules/stylis/dist/stylis.mjs(.web.ts|.ts|.web.tsx|.tsx|.web.js|.js|.web.jsx|.jsx|.web.json|.json|.web.cjs|.cjs|.web.scss|.scss|.web.sass|.sass|.web.css|.css)\n' +
+            //     '  * /Users/evanbacon/Documents/GitHub/lab/emotion-error-test/node_modules/stylis/dist/stylis.mjs/index(.web.ts|.ts|.web.tsx|.tsx|.web.js|.js|.web.jsx|.jsx|.web.json|.json|.web.cjs|.cjs|.web.scss|.scss|.web.sass|.sass|.web.css|.css): /Users/evanbacon/Documents/GitHub/lab/emotion-error-test/node_modules/metro/src/node-haste/DependencyGraph.js (289:17)\n' +
+            //     '\n' +
+            //     '\x1B[0m \x1B[90m 287 |\x1B[39m         }\x1B[0m\n' +
+            //     '\x1B[0m \x1B[90m 288 |\x1B[39m         \x1B[36mif\x1B[39m (error \x1B[36minstanceof\x1B[39m \x1B[33mInvalidPackageError\x1B[39m) {\x1B[0m\n' +
+            //     '\x1B[0m\x1B[31m\x1B[1m>\x1B[22m\x1B[39m\x1B[90m 289 |\x1B[39m           \x1B[36mthrow\x1B[39m \x1B[36mnew\x1B[39m \x1B[33mPackageResolutionError\x1B[39m({\x1B[0m\n' +
+            //     '\x1B[0m \x1B[90m     |\x1B[39m                 \x1B[31m\x1B[1m^\x1B[22m\x1B[39m\x1B[0m\n' +
+            //     '\x1B[0m \x1B[90m 290 |\x1B[39m             packageError\x1B[33m:\x1B[39m error\x1B[33m,\x1B[39m\x1B[0m\n' +
+            //     '\x1B[0m \x1B[90m 291 |\x1B[39m             originModulePath\x1B[33m:\x1B[39m \x1B[36mfrom\x1B[39m\x1B[33m,\x1B[39m\x1B[0m\n' +
+            //     '\x1B[0m \x1B[90m 292 |\x1B[39m             targetModuleName\x1B[33m:\x1B[39m to\x1B[33m,\x1B[39m\x1B[0m'
+            // }
+            // The Metro logger already showed this error.
+            throw new Error(data.message);
+        }
+        throw new Error("Invalid resources returned from the Metro serializer. Expected array, found: " + data);
     }
     async getStaticPageAsync(pathname) {
-        const { mode , isExporting , baseUrl , reactCompiler , routerRoot , asyncRoutes  } = this.instanceMetroOptions;
-        (0, _assert().default)(mode != null && isExporting != null && baseUrl != null && reactCompiler != null && routerRoot != null && asyncRoutes != null, "The server must be started before calling getStaticPageAsync.");
+        const { mode , isExporting , baseUrl , routerRoot , asyncRoutes  } = this.instanceMetroOptions;
+        (0, _assert().default)(mode != null && isExporting != null && baseUrl != null && routerRoot != null && asyncRoutes != null, "The server must be started before calling getStaticPageAsync.");
         const platform = "web";
         const devBundleUrlPathname = (0, _metroOptions.createBundleUrlPath)({
             splitChunks: isExporting && !_env1.env.EXPO_NO_BUNDLE_SPLITTING,
             platform,
             mode,
             environment: "client",
-            reactCompiler,
             mainModuleName: (0, _manifestMiddleware.resolveMainModuleName)(this.projectRoot, {
                 platform
             }),
@@ -319,165 +356,36 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
     // Set when the server is started.
     instanceMetroOptions = {};
     async ssrLoadModule(filePath, specificOptions = {}) {
-        const res = await this.ssrLoadModuleContents(filePath, specificOptions);
-        return (0, _getStaticRenderFunctions.evalMetroAndWrapFunctions)(this.projectRoot, res.src, res.filename);
-    }
-    async metroImportAsArtifactsAsync(filePath, specificOptions = {}) {
-        const results = await this.ssrLoadModuleContents(filePath, {
-            serializerOutput: "static",
-            ...specificOptions
-        });
-        // NOTE: This could potentially need more validation in the future.
-        if (results.artifacts && results.assets) {
-            return {
-                artifacts: results.artifacts,
-                assets: results.assets,
-                src: results.src,
-                filename: results.filename,
-                map: results.map
-            };
-        }
-        throw new _errors.CommandError("Invalid bundler results: " + results);
-    }
-    async metroLoadModuleContents(filePath, specificOptions, extraOptions = {}) {
-        const { baseUrl  } = this.instanceMetroOptions;
-        (0, _assert().default)(baseUrl != null, "The server must be started before calling metroLoadModuleContents.");
-        const opts = {
-            // TODO: Possibly issues with using an absolute path here...
-            // mainModuleName: filePath,
-            lazy: false,
-            asyncRoutes: false,
-            inlineSourceMap: false,
-            engine: "hermes",
-            minify: false,
-            // bytecode: false,
+        const { baseUrl , routerRoot , isExporting  } = this.instanceMetroOptions;
+        (0, _assert().default)(baseUrl != null && routerRoot != null && isExporting != null, "The server must be started before calling ssrLoadModule.");
+        return (await (0, _getStaticRenderFunctions.getStaticRenderFunctionsForEntry)(this.projectRoot, this.getDevServerUrl(), {
             // Bundle in Node.js mode for SSR.
             environment: "node",
-            // platform: 'web',
-            // mode: 'development',
-            //
+            platform: "web",
+            mode: "development",
+            bytecode: false,
             ...this.instanceMetroOptions,
             baseUrl,
-            // routerRoot,
-            // isExporting,
+            routerRoot,
+            isExporting,
             ...specificOptions
-        };
-        const expoBundleOptions = (0, _metroOptions.getMetroDirectBundleOptions)(opts);
-        var _customResolverOptions, _dev;
-        const resolverOptions = {
-            customResolverOptions: (_customResolverOptions = expoBundleOptions.customResolverOptions) != null ? _customResolverOptions : {},
-            dev: (_dev = expoBundleOptions.dev) != null ? _dev : true
-        };
-        var _dev1, _minify, _unstable_transformProfile, ref, _customTransformOptions, _platform;
-        const transformOptions = {
-            dev: (_dev1 = expoBundleOptions.dev) != null ? _dev1 : true,
-            hot: true,
-            minify: (_minify = expoBundleOptions.minify) != null ? _minify : false,
-            type: "module",
-            unstable_transformProfile: (ref = (_unstable_transformProfile = extraOptions.unstable_transformProfile) != null ? _unstable_transformProfile : expoBundleOptions.unstable_transformProfile) != null ? ref : "default",
-            customTransformOptions: (_customTransformOptions = expoBundleOptions.customTransformOptions) != null ? _customTransformOptions : Object.create(null),
-            platform: (_platform = expoBundleOptions.platform) != null ? _platform : "web",
-            runtimeBytecodeVersion: expoBundleOptions.runtimeBytecodeVersion
-        };
-        const resolvedEntryFilePath = await this.resolveRelativePathAsync(filePath, {
-            resolverOptions,
-            transformOptions
-        });
-        // Use fully qualified URL with all options to represent the file path that's used for source maps and HMR. This prevents collisions.
-        const filename = (0, _metroOptions.createBundleUrlPath)({
-            ...opts,
-            mainModuleName: resolvedEntryFilePath
-        });
-        var _lazy, _shallow, _inlineSourceMap, _modulesOnly, _runModule, _sourceMapUrl;
-        // https://github.com/facebook/metro/blob/2405f2f6c37a1b641cc379b9c733b1eff0c1c2a1/packages/metro/src/lib/parseOptionsFromUrl.js#L55-L87
-        const results = await this._bundleDirectAsync(resolvedEntryFilePath, {
-            graphOptions: {
-                lazy: (_lazy = expoBundleOptions.lazy) != null ? _lazy : false,
-                shallow: (_shallow = expoBundleOptions.shallow) != null ? _shallow : false
-            },
-            resolverOptions,
-            serializerOptions: {
-                ...expoBundleOptions.serializerOptions,
-                inlineSourceMap: (_inlineSourceMap = expoBundleOptions.inlineSourceMap) != null ? _inlineSourceMap : false,
-                modulesOnly: (_modulesOnly = expoBundleOptions.modulesOnly) != null ? _modulesOnly : false,
-                runModule: (_runModule = expoBundleOptions.runModule) != null ? _runModule : true,
-                // @ts-expect-error
-                sourceUrl: expoBundleOptions.sourceUrl,
-                // @ts-expect-error
-                sourceMapUrl: (_sourceMapUrl = extraOptions.sourceMapUrl) != null ? _sourceMapUrl : expoBundleOptions.sourceMapUrl
-            },
-            transformOptions
-        });
-        return {
-            ...results,
-            filename
-        };
+        }, filePath)).fn;
     }
     async ssrLoadModuleContents(filePath, specificOptions = {}) {
         const { baseUrl , routerRoot , isExporting  } = this.instanceMetroOptions;
-        (0, _assert().default)(baseUrl != null && routerRoot != null && isExporting != null, "The server must be started before calling ssrLoadModuleContents.");
-        const opts = {
-            // TODO: Possibly issues with using an absolute path here...
-            mainModuleName: filePath,
-            lazy: false,
-            asyncRoutes: false,
-            inlineSourceMap: false,
-            engine: "hermes",
-            minify: false,
-            bytecode: false,
+        (0, _assert().default)(baseUrl != null && routerRoot != null && isExporting != null, "The server must be started before calling ssrLoadModule.");
+        return await (0, _getStaticRenderFunctions.requireFileContentsWithMetro)(this.projectRoot, this.getDevServerUrl(), filePath, {
             // Bundle in Node.js mode for SSR.
             environment: "node",
             platform: "web",
             mode: "development",
-            //
+            bytecode: false,
             ...this.instanceMetroOptions,
-            // Mostly disable compiler in SSR bundles.
-            reactCompiler: false,
             baseUrl,
             routerRoot,
             isExporting,
             ...specificOptions
-        };
-        // https://github.com/facebook/metro/blob/2405f2f6c37a1b641cc379b9c733b1eff0c1c2a1/packages/metro/src/lib/parseOptionsFromUrl.js#L55-L87
-        const { filename , bundle , map , ...rest } = await this.metroLoadModuleContents(filePath, opts);
-        const scriptContents = wrapBundle(bundle);
-        if (map) {
-            debug("Registering SSR source map for:", filename);
-            _getStaticRenderFunctions.cachedSourceMaps.set(filename, {
-                url: this.projectRoot,
-                map
-            });
-        } else {
-            debug("No SSR source map found for:", filename);
-        }
-        return {
-            ...rest,
-            src: scriptContents,
-            filename,
-            map
-        };
-    }
-    async legacySinglePageExportBundleAsync(options, extraOptions = {}) {
-        const { baseUrl , routerRoot , isExporting  } = this.instanceMetroOptions;
-        (0, _assert().default)(baseUrl != null && routerRoot != null && isExporting != null, "The server must be started before calling legacySinglePageExportBundleAsync.");
-        const opts = {
-            ...this.instanceMetroOptions,
-            baseUrl,
-            routerRoot,
-            isExporting,
-            ...options,
-            environment: "client",
-            serializerOutput: "static"
-        };
-        // https://github.com/facebook/metro/blob/2405f2f6c37a1b641cc379b9c733b1eff0c1c2a1/packages/metro/src/lib/parseOptionsFromUrl.js#L55-L87
-        if (!opts.mainModuleName.startsWith(_path().default.sep)) {
-            opts.mainModuleName = "." + _path().default.sep + opts.mainModuleName;
-        }
-        const output = await this.metroLoadModuleContents(opts.mainModuleName, opts, extraOptions);
-        return {
-            artifacts: output.artifacts,
-            assets: output.assets
-        };
+        });
     }
     async watchEnvironmentVariables() {
         if (!this.instance) {
@@ -501,24 +409,26 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
             });
         });
     }
+    getExpoLineOptions() {
+        return this.instanceMetroOptions;
+    }
     async startImplementationAsync(options) {
-        var ref, ref1;
+        var ref;
         options.port = await this.resolvePortAsync(options);
         this.urlCreator = this.getUrlCreator(options);
         const config = (0, _config().getConfig)(this.projectRoot, {
             skipSDKVersionRequirement: true
         });
         const { exp  } = config;
-        var ref2;
+        var ref1;
         const useServerRendering = [
             "static",
             "server"
-        ].includes((ref2 = (ref = exp.web) == null ? void 0 : ref.output) != null ? ref2 : "");
+        ].includes((ref1 = (ref = exp.web) == null ? void 0 : ref.output) != null ? ref1 : "");
         const baseUrl = (0, _metroOptions.getBaseUrlFromExpoConfig)(exp);
         var _mode;
         const asyncRoutes = (0, _metroOptions.getAsyncRoutesFromExpoConfig)(exp, (_mode = options.mode) != null ? _mode : "development", "web");
         const routerRoot = (0, _router.getRouterDirectoryModuleIdWithManifest)(this.projectRoot, exp);
-        const reactCompiler = !!((ref1 = exp.experiments) == null ? void 0 : ref1.reactCompiler);
         const appDir = _path().default.join(this.projectRoot, routerRoot);
         var _mode1;
         const mode = (_mode1 = options.mode) != null ? _mode1 : "development";
@@ -527,7 +437,6 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
             baseUrl,
             mode,
             routerRoot,
-            reactCompiler,
             minify: options.minify,
             asyncRoutes
         };
@@ -581,12 +490,12 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
             // This should come after the static middleware so it doesn't serve the favicon from `public/favicon.ico`.
             middleware.use(new _faviconMiddleware.FaviconMiddleware(this.projectRoot).getHandler());
             if (useServerRendering) {
-                var ref3;
+                var ref2;
                 middleware.use((0, _createServerRouteMiddleware.createRouteHandlerMiddleware)(this.projectRoot, {
                     appDir,
                     routerRoot,
                     config,
-                    ...(ref3 = config.exp.extra) == null ? void 0 : ref3.router,
+                    ...(ref2 = config.exp.extra) == null ? void 0 : ref2.router,
                     bundleApiRoute: (functionFilePath)=>this.ssrImportApiRoute(functionFilePath),
                     getStaticPageAsync: (pathname)=>{
                         return this.getStaticPageAsync(pathname);
@@ -630,7 +539,6 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
                 callback == null ? void 0 : callback(err);
             });
         };
-        (0, _metroPrivateServer.assertMetroPrivateServer)(metro);
         this.metro = metro;
         return {
             server,
@@ -716,17 +624,13 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
                 debug("Bundle API route:", this.instanceMetroOptions.routerRoot, filePath);
                 return await this.ssrLoadModuleContents(filePath);
             } catch (error) {
-                var ref;
-                const appDir = ((ref = this.instanceMetroOptions) == null ? void 0 : ref.routerRoot) ? _path().default.join(this.projectRoot, this.instanceMetroOptions.routerRoot) : undefined;
-                const relativePath = appDir ? _path().default.relative(appDir, filePath) : filePath;
-                // Expected errors: invalid syntax, missing resolutions.
-                // Wrap with command error for better error messages.
-                const err = new _errors.CommandError("API_ROUTE", (0, _chalk().default)`Failed to bundle API Route: {bold ${relativePath}}\n\n` + error.message);
-                for(const key in error){
-                    // @ts-expect-error
-                    err[key] = error[key];
+                if (error instanceof Error) {
+                    await (0, _metroErrorInterface.logMetroErrorAsync)({
+                        error,
+                        projectRoot: this.projectRoot
+                    });
                 }
-                throw err;
+                throw error;
             } finally{
             // pendingRouteOperations.delete(filepath);
             }
@@ -750,7 +654,7 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
                     const htmlServerError = await (0, _metroErrorInterface.getErrorOverlayHtmlAsync)({
                         error,
                         projectRoot: this.projectRoot,
-                        routerRoot: this.instanceMetroOptions.routerRoot
+                        routerRoot: this.getExpoLineOptions().routerRoot
                     });
                     return new Response(htmlServerError, {
                         status: 500,
@@ -770,188 +674,6 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
     invalidateApiRouteCache() {
         this.pendingRouteOperations.clear();
     }
-    // Direct Metro access
-    // Emulates the Metro dev server .bundle endpoint without having to go through a server.
-    async _bundleDirectAsync(resolvedEntryFilePath, { transformOptions , resolverOptions , graphOptions , serializerOptions  }) {
-        var ref;
-        (0, _assert().default)(this.metro, "Metro server must be running to bundle directly.");
-        const config = this.metro._config;
-        const buildNumber = this.metro.getNewBuildNumber();
-        const bundlePerfLogger = config.unstable_perfLoggerFactory == null ? void 0 : config.unstable_perfLoggerFactory("BUNDLING_REQUEST", {
-            key: buildNumber
-        });
-        const onProgress = (transformedFileCount, totalFileCount)=>{
-            var ref, ref1;
-            (ref = this.metro) == null ? void 0 : (ref1 = ref._reporter) == null ? void 0 : ref1.update == null ? void 0 : ref1.update({
-                buildID: getBuildID(buildNumber),
-                type: "bundle_transform_progressed",
-                transformedFileCount,
-                totalFileCount
-            });
-        };
-        const revPromise = this.getMetroRevision(resolvedEntryFilePath, {
-            graphOptions,
-            transformOptions,
-            resolverOptions
-        });
-        bundlePerfLogger == null ? void 0 : bundlePerfLogger.point("resolvingAndTransformingDependencies_start");
-        bundlePerfLogger == null ? void 0 : bundlePerfLogger.annotate({
-            bool: {
-                initial_build: revPromise == null
-            }
-        });
-        (ref = this.metro) == null ? void 0 : ref._reporter.update({
-            buildID: getBuildID(buildNumber),
-            bundleDetails: {
-                bundleType: transformOptions.type,
-                dev: transformOptions.dev,
-                entryFile: resolvedEntryFilePath,
-                minify: transformOptions.minify,
-                platform: transformOptions.platform,
-                // @ts-expect-error: typed incorrectly upstream
-                customResolverOptions: resolverOptions.customResolverOptions,
-                customTransformOptions: transformOptions.customTransformOptions
-            },
-            isPrefetch: false,
-            type: "bundle_build_started"
-        });
-        try {
-            const { delta , revision  } = await (revPromise != null ? this.metro.getBundler().updateGraph(await revPromise, false) : this.metro.getBundler().initializeGraph(// NOTE: Using absolute path instead of relative input path is a breaking change.
-            // entryFile,
-            resolvedEntryFilePath, transformOptions, resolverOptions, {
-                onProgress,
-                shallow: graphOptions.shallow,
-                // @ts-expect-error: typed incorrectly
-                lazy: graphOptions.lazy
-            }));
-            bundlePerfLogger == null ? void 0 : bundlePerfLogger.annotate({
-                int: {
-                    graph_node_count: revision.graph.dependencies.size
-                }
-            });
-            bundlePerfLogger == null ? void 0 : bundlePerfLogger.point("resolvingAndTransformingDependencies_end");
-            bundlePerfLogger == null ? void 0 : bundlePerfLogger.point("serializingBundle_start");
-            const shouldAddToIgnoreList = this.metro._shouldAddModuleToIgnoreList.bind(this.metro);
-            const serializer = this.getMetroSerializer();
-            var _unstable_serverRoot;
-            const bundle = await serializer(// NOTE: Using absolute path instead of relative input path is a breaking change.
-            // entryFile,
-            resolvedEntryFilePath, revision.prepend, revision.graph, {
-                asyncRequireModulePath: await this.metro._resolveRelativePath(config.transformer.asyncRequireModulePath, {
-                    relativeTo: "project",
-                    resolverOptions,
-                    transformOptions
-                }),
-                // ...serializerOptions,
-                processModuleFilter: config.serializer.processModuleFilter,
-                createModuleId: this.metro._createModuleId,
-                getRunModuleStatement: config.serializer.getRunModuleStatement,
-                includeAsyncPaths: graphOptions.lazy,
-                dev: transformOptions.dev,
-                projectRoot: config.projectRoot,
-                modulesOnly: serializerOptions.modulesOnly,
-                runBeforeMainModule: config.serializer.getModulesRunBeforeMainModule(resolvedEntryFilePath),
-                runModule: serializerOptions.runModule,
-                sourceMapUrl: serializerOptions.sourceMapUrl,
-                sourceUrl: serializerOptions.sourceUrl,
-                inlineSourceMap: serializerOptions.inlineSourceMap,
-                serverRoot: (_unstable_serverRoot = config.server.unstable_serverRoot) != null ? _unstable_serverRoot : config.projectRoot,
-                shouldAddToIgnoreList,
-                // @ts-expect-error: passed to our serializer to enable non-serial return values.
-                serializerOptions
-            });
-            this.metro._reporter.update({
-                buildID: getBuildID(buildNumber),
-                type: "bundle_build_done"
-            });
-            bundlePerfLogger == null ? void 0 : bundlePerfLogger.point("serializingBundle_end");
-            let bundleCode = null;
-            let bundleMap = null;
-            // @ts-expect-error: If the output is multi-bundle...
-            if (serializerOptions.output === "static") {
-                try {
-                    var ref1, ref2;
-                    const parsed = typeof bundle === "string" ? JSON.parse(bundle) : bundle;
-                    (0, _assert().default)("artifacts" in parsed && Array.isArray(parsed.artifacts), "Expected serializer to return an object with key artifacts to contain an array of serial assets.");
-                    const artifacts = parsed.artifacts;
-                    const assets = parsed.assets;
-                    const bundleCode1 = artifacts.filter((asset)=>asset.type === "js")[0];
-                    var ref3;
-                    const bundleMap1 = (ref3 = (ref1 = artifacts.filter((asset)=>asset.type === "map")) == null ? void 0 : (ref2 = ref1[0]) == null ? void 0 : ref2.source) != null ? ref3 : "";
-                    return {
-                        numModifiedFiles: delta.reset ? delta.added.size + revision.prepend.length : delta.added.size + delta.modified.size + delta.deleted.size,
-                        lastModifiedDate: revision.date,
-                        nextRevId: revision.id,
-                        bundle: bundleCode1.source,
-                        map: bundleMap1,
-                        artifacts,
-                        assets
-                    };
-                } catch (error) {
-                    throw new Error("Serializer did not return expected format. The project copy of `expo/metro-config` may be out of date. Error: " + error.message);
-                }
-            }
-            if (typeof bundle === "string") {
-                bundleCode = bundle;
-                // Create the source map in a second pass...
-                let { prepend , graph  } = revision;
-                if (serializerOptions.modulesOnly) {
-                    prepend = [];
-                }
-                bundleMap = await sourceMapStringAsync([
-                    //
-                    ...prepend,
-                    ...this.metro._getSortedModules(graph), 
-                ], {
-                    excludeSource: serializerOptions.excludeSource,
-                    processModuleFilter: config.serializer.processModuleFilter,
-                    shouldAddToIgnoreList
-                });
-            } else {
-                bundleCode = bundle.code;
-                bundleMap = bundle.map;
-            }
-            return {
-                numModifiedFiles: delta.reset ? delta.added.size + revision.prepend.length : delta.added.size + delta.modified.size + delta.deleted.size,
-                lastModifiedDate: revision.date,
-                nextRevId: revision.id,
-                bundle: bundleCode,
-                map: bundleMap
-            };
-        } catch (error1) {
-            this.metro._reporter.update({
-                buildID: getBuildID(buildNumber),
-                type: "bundle_build_failed"
-            });
-            throw error1;
-        }
-    }
-    getMetroSerializer() {
-        var ref, ref1;
-        return ((ref = this.metro) == null ? void 0 : (ref1 = ref._config) == null ? void 0 : ref1.serializer.customSerializer) || ((entryPoint, preModules, graph, options)=>(0, _bundleToString().default)((0, _baseJSBundle().default)(entryPoint, preModules, graph, options)).code);
-    }
-    getMetroRevision(resolvedEntryFilePath, { graphOptions , transformOptions , resolverOptions  }) {
-        (0, _assert().default)(this.metro, "Metro server must be running to bundle directly.");
-        const config = this.metro._config;
-        const graphId = getGraphId(resolvedEntryFilePath, transformOptions, {
-            unstable_allowRequireContext: config.transformer.unstable_allowRequireContext,
-            resolverOptions,
-            shallow: graphOptions.shallow,
-            lazy: graphOptions.lazy
-        });
-        return this.metro.getBundler().getRevisionByGraphId(graphId);
-    }
-    async resolveRelativePathAsync(moduleId, { resolverOptions , transformOptions  }) {
-        (0, _assert().default)(this.metro, "cannot invoke resolveRelativePathAsync without metro instance");
-        return await this.metro._resolveRelativePath(moduleId, {
-            relativeTo: "server",
-            resolverOptions,
-            transformOptions
-        });
-    }
-}
-function getBuildID(buildNumber) {
-    return buildNumber.toString(36);
 }
 function getDeepLinkHandler(projectRoot) {
     return async ({ runtime  })=>{
@@ -963,16 +685,5 @@ function getDeepLinkHandler(projectRoot) {
         });
     };
 }
-function wrapBundle(str) {
-    // Skip the metro runtime so debugging is a bit easier.
-    // Replace the __r() call with an export statement.
-    // Use gm to apply to the last require line. This is needed when the bundle has side-effects.
-    return str.replace(/^(__r\(.*\);)$/gm, "module.exports = $1");
-}
-async function sourceMapStringAsync(modules, options) {
-    return (await (0, _sourceMapGenerator().sourceMapGeneratorNonBlocking)(modules, options)).toString(undefined, {
-        excludeSource: options.excludeSource
-    });
-}
 
 //# sourceMappingURL=MetroBundlerDevServer.js.map