@expo/cli 0.18.19 → 0.18.21

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

@@ -14,7 +14,6 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    ForwardHtmlError: ()=>ForwardHtmlError,
     MetroBundlerDevServer: ()=>MetroBundlerDevServer,
     getDeepLinkHandler: ()=>getDeepLinkHandler
 });
@@ -46,9 +45,23 @@ function _chalk() {
     };
     return data;
 }
-function _nodeFetch() {
-    const data = /*#__PURE__*/ _interopRequireDefault(require("node-fetch"));
-    _nodeFetch = function() {
+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() {
         return data;
     };
     return data;
@@ -64,6 +77,7 @@ 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");
@@ -133,14 +147,8 @@ 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 {
@@ -175,16 +183,17 @@ 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: contents.map.version,
-                            sources: contents.map.sources.map((source)=>{
+                            version: parsedMap.version,
+                            sources: parsedMap.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("/");
+                                return (0, _metroOptions.convertPathToModuleSpecifier)(source);
                             }),
-                            sourcesContent: new Array(contents.map.sources.length).fill(null),
-                            names: contents.map.names,
-                            mappings: contents.map.mappings
+                            sourcesContent: new Array(parsedMap.sources.length).fill(null),
+                            names: parsedMap.names,
+                            mappings: parsedMap.mappings
                         }),
                         targetDomain: "server"
                     });
@@ -221,14 +230,8 @@ 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", {
-            minify,
-            mode,
-            isExporting
-        });
+        const { getStaticContent , getManifest , getBuildTimeServerManifestAsync  } = await this.ssrLoadModule("expo-router/node/render.js");
         const { exp  } = (0, _config().getConfig)(this.projectRoot);
         return {
             serverManifest: await getBuildTimeServerManifestAsync(),
@@ -244,79 +247,39 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
         };
     }
     async getStaticResourcesAsync({ includeSourceMaps , mainModuleName  } = {}) {
-        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 { 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.");
         const platform = "web";
-        const devBundleUrlPathname = (0, _metroOptions.createBundleUrlPath)({
+        const resolvedMainModuleName = mainModuleName != null ? mainModuleName : "./" + (0, _manifestMiddleware.resolveMainModuleName)(this.projectRoot, {
+            platform
+        });
+        return await this.metroImportAsArtifactsAsync(resolvedMainModuleName, {
             splitChunks: isExporting && !_env1.env.EXPO_NO_BUNDLE_SPLITTING,
             platform,
             mode,
             minify,
             environment: "client",
-            serializerOutput: "static",
             serializerIncludeMaps: includeSourceMaps,
-            mainModuleName: mainModuleName != null ? mainModuleName : (0, _manifestMiddleware.resolveMainModuleName)(this.projectRoot, {
-                platform
-            }),
+            mainModuleName: resolvedMainModuleName,
             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 , 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 { 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 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
             }),
@@ -356,36 +319,165 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
     // Set when the server is started.
     instanceMetroOptions = {};
     async ssrLoadModule(filePath, specificOptions = {}) {
-        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(), {
+        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,
             // Bundle in Node.js mode for SSR.
             environment: "node",
-            platform: "web",
-            mode: "development",
-            bytecode: false,
+            // platform: 'web',
+            // mode: 'development',
+            //
             ...this.instanceMetroOptions,
             baseUrl,
-            routerRoot,
-            isExporting,
+            // routerRoot,
+            // isExporting,
             ...specificOptions
-        }, filePath)).fn;
+        };
+        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
+        };
     }
     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 ssrLoadModule.");
-        return await (0, _getStaticRenderFunctions.requireFileContentsWithMetro)(this.projectRoot, this.getDevServerUrl(), filePath, {
+        (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: (0, _metroOptions.convertPathToModuleSpecifier)(filePath),
+            lazy: false,
+            asyncRoutes: false,
+            inlineSourceMap: false,
+            engine: "hermes",
+            minify: false,
+            bytecode: false,
             // 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("/")) {
+            opts.mainModuleName = "./" + opts.mainModuleName;
+        }
+        const output = await this.metroLoadModuleContents(opts.mainModuleName, opts, extraOptions);
+        return {
+            artifacts: output.artifacts,
+            assets: output.assets
+        };
     }
     async watchEnvironmentVariables() {
         if (!this.instance) {
@@ -409,26 +501,24 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
             });
         });
     }
-    getExpoLineOptions() {
-        return this.instanceMetroOptions;
-    }
     async startImplementationAsync(options) {
-        var ref;
+        var ref, ref1;
         options.port = await this.resolvePortAsync(options);
         this.urlCreator = this.getUrlCreator(options);
         const config = (0, _config().getConfig)(this.projectRoot, {
             skipSDKVersionRequirement: true
         });
         const { exp  } = config;
-        var ref1;
+        var ref2;
         const useServerRendering = [
             "static",
             "server"
-        ].includes((ref1 = (ref = exp.web) == null ? void 0 : ref.output) != null ? ref1 : "");
+        ].includes((ref2 = (ref = exp.web) == null ? void 0 : ref.output) != null ? ref2 : "");
         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";
@@ -437,6 +527,7 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
             baseUrl,
             mode,
             routerRoot,
+            reactCompiler,
             minify: options.minify,
             asyncRoutes
         };
@@ -448,86 +539,89 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
         // Required for symbolication:
         process.env.EXPO_DEV_SERVER_ORIGIN = `http://localhost:${options.port}`;
         const { metro , server , middleware , messageSocket  } = await (0, _instantiateMetro.instantiateMetroAsync)(this, parsedOptions, {
-            isExporting: !!options.isExporting
-        });
-        const manifestMiddleware = await this.getManifestMiddlewareAsync(options);
-        // Important that we noop source maps for context modules as soon as possible.
-        (0, _mutations.prependMiddleware)(middleware, new _contextModuleSourceMapsMiddleware.ContextModuleSourceMapsMiddleware().getHandler());
-        // We need the manifest handler to be the first middleware to run so our
-        // routes take precedence over static files. For example, the manifest is
-        // served from '/' and if the user has an index.html file in their project
-        // then the manifest handler will never run, the static middleware will run
-        // and serve index.html instead of the manifest.
-        // https://github.com/expo/expo/issues/13114
-        (0, _mutations.prependMiddleware)(middleware, manifestMiddleware.getHandler());
-        var _scheme;
-        middleware.use(new _interstitialPageMiddleware.InterstitialPageMiddleware(this.projectRoot, {
-            // TODO: Prevent this from becoming stale.
-            scheme: (_scheme = options.location.scheme) != null ? _scheme : null
-        }).getHandler());
-        middleware.use(new _reactDevToolsPageMiddleware.ReactDevToolsPageMiddleware(this.projectRoot).getHandler());
-        middleware.use(new _devToolsPluginMiddleware.DevToolsPluginMiddleware(this.projectRoot, this.devToolsPluginManager).getHandler());
-        const deepLinkMiddleware = new _runtimeRedirectMiddleware.RuntimeRedirectMiddleware(this.projectRoot, {
-            onDeepLink: getDeepLinkHandler(this.projectRoot),
-            getLocation: ({ runtime  })=>{
-                if (runtime === "custom") {
-                    var ref;
-                    return (ref = this.urlCreator) == null ? void 0 : ref.constructDevClientUrl();
-                } else {
-                    var ref1;
-                    return (ref1 = this.urlCreator) == null ? void 0 : ref1.constructUrl({
-                        scheme: "exp"
-                    });
-                }
-            }
+            isExporting: !!options.isExporting,
+            exp
         });
-        middleware.use(deepLinkMiddleware.getHandler());
-        middleware.use(new _createFileMiddleware.CreateFileMiddleware(this.projectRoot).getHandler());
-        // Append support for redirecting unhandled requests to the index.html page on web.
-        if (this.isTargetingWeb()) {
-            // This MUST be after the manifest middleware so it doesn't have a chance to serve the template `public/index.html`.
-            middleware.use(new _serveStaticMiddleware.ServeStaticMiddleware(this.projectRoot).getHandler());
-            // 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 ref2;
-                middleware.use((0, _createServerRouteMiddleware.createRouteHandlerMiddleware)(this.projectRoot, {
-                    appDir,
-                    routerRoot,
-                    config,
-                    ...(ref2 = config.exp.extra) == null ? void 0 : ref2.router,
-                    bundleApiRoute: (functionFilePath)=>this.ssrImportApiRoute(functionFilePath),
-                    getStaticPageAsync: (pathname)=>{
-                        return this.getStaticPageAsync(pathname);
+        if (!options.isExporting) {
+            const manifestMiddleware = await this.getManifestMiddlewareAsync(options);
+            // Important that we noop source maps for context modules as soon as possible.
+            (0, _mutations.prependMiddleware)(middleware, new _contextModuleSourceMapsMiddleware.ContextModuleSourceMapsMiddleware().getHandler());
+            // We need the manifest handler to be the first middleware to run so our
+            // routes take precedence over static files. For example, the manifest is
+            // served from '/' and if the user has an index.html file in their project
+            // then the manifest handler will never run, the static middleware will run
+            // and serve index.html instead of the manifest.
+            // https://github.com/expo/expo/issues/13114
+            (0, _mutations.prependMiddleware)(middleware, manifestMiddleware.getHandler());
+            var _scheme;
+            middleware.use(new _interstitialPageMiddleware.InterstitialPageMiddleware(this.projectRoot, {
+                // TODO: Prevent this from becoming stale.
+                scheme: (_scheme = options.location.scheme) != null ? _scheme : null
+            }).getHandler());
+            middleware.use(new _reactDevToolsPageMiddleware.ReactDevToolsPageMiddleware(this.projectRoot).getHandler());
+            middleware.use(new _devToolsPluginMiddleware.DevToolsPluginMiddleware(this.projectRoot, this.devToolsPluginManager).getHandler());
+            const deepLinkMiddleware = new _runtimeRedirectMiddleware.RuntimeRedirectMiddleware(this.projectRoot, {
+                onDeepLink: getDeepLinkHandler(this.projectRoot),
+                getLocation: ({ runtime  })=>{
+                    if (runtime === "custom") {
+                        var ref;
+                        return (ref = this.urlCreator) == null ? void 0 : ref.constructDevClientUrl();
+                    } else {
+                        var ref1;
+                        return (ref1 = this.urlCreator) == null ? void 0 : ref1.constructUrl({
+                            scheme: "exp"
+                        });
                     }
-                }));
-                (0, _waitForMetroToObserveTypeScriptFile.observeAnyFileChanges)({
-                    metro,
-                    server
-                }, (events)=>{
-                    var ref;
-                    if (((ref = exp.web) == null ? void 0 : ref.output) === "server") {
-                        // NOTE(EvanBacon): We aren't sure what files the API routes are using so we'll just invalidate
-                        // aggressively to ensure we always have the latest. The only caching we really get here is for
-                        // cases where the user is making subsequent requests to the same API route without changing anything.
-                        // This is useful for testing but pretty suboptimal. Luckily our caching is pretty aggressive so it makes
-                        // up for a lot of the overhead.
-                        this.invalidateApiRouteCache();
-                    } else if (!(0, _router.hasWarnedAboutApiRoutes)()) {
-                        for (const event of events){
-                            var // If the user did not delete a file that matches the Expo Router API Route convention, then we should warn that
-                            // API Routes are not enabled in the project.
-                            ref1;
-                            if (((ref1 = event.metadata) == null ? void 0 : ref1.type) !== "d" && // Ensure the file is in the project's routes directory to prevent false positives in monorepos.
-                            event.filePath.startsWith(appDir) && (0, _router.isApiRouteConvention)(event.filePath)) {
-                                (0, _router.warnInvalidWebOutput)();
+                }
+            });
+            middleware.use(deepLinkMiddleware.getHandler());
+            middleware.use(new _createFileMiddleware.CreateFileMiddleware(this.projectRoot).getHandler());
+            // Append support for redirecting unhandled requests to the index.html page on web.
+            if (this.isTargetingWeb()) {
+                // This MUST be after the manifest middleware so it doesn't have a chance to serve the template `public/index.html`.
+                middleware.use(new _serveStaticMiddleware.ServeStaticMiddleware(this.projectRoot).getHandler());
+                // 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;
+                    middleware.use((0, _createServerRouteMiddleware.createRouteHandlerMiddleware)(this.projectRoot, {
+                        appDir,
+                        routerRoot,
+                        config,
+                        ...(ref3 = config.exp.extra) == null ? void 0 : ref3.router,
+                        bundleApiRoute: (functionFilePath)=>this.ssrImportApiRoute(functionFilePath),
+                        getStaticPageAsync: (pathname)=>{
+                            return this.getStaticPageAsync(pathname);
+                        }
+                    }));
+                    (0, _waitForMetroToObserveTypeScriptFile.observeAnyFileChanges)({
+                        metro,
+                        server
+                    }, (events)=>{
+                        var ref;
+                        if (((ref = exp.web) == null ? void 0 : ref.output) === "server") {
+                            // NOTE(EvanBacon): We aren't sure what files the API routes are using so we'll just invalidate
+                            // aggressively to ensure we always have the latest. The only caching we really get here is for
+                            // cases where the user is making subsequent requests to the same API route without changing anything.
+                            // This is useful for testing but pretty suboptimal. Luckily our caching is pretty aggressive so it makes
+                            // up for a lot of the overhead.
+                            this.invalidateApiRouteCache();
+                        } else if (!(0, _router.hasWarnedAboutApiRoutes)()) {
+                            for (const event of events){
+                                var // If the user did not delete a file that matches the Expo Router API Route convention, then we should warn that
+                                // API Routes are not enabled in the project.
+                                ref1;
+                                if (((ref1 = event.metadata) == null ? void 0 : ref1.type) !== "d" && // Ensure the file is in the project's routes directory to prevent false positives in monorepos.
+                                event.filePath.startsWith(appDir) && (0, _router.isApiRouteConvention)(event.filePath)) {
+                                    (0, _router.warnInvalidWebOutput)();
+                                }
                             }
                         }
-                    }
-                });
-            } else {
-                // This MUST run last since it's the fallback.
-                middleware.use(new _historyFallbackMiddleware.HistoryFallbackMiddleware(manifestMiddleware.getHandler().internal).getHandler());
+                    });
+                } else {
+                    // This MUST run last since it's the fallback.
+                    middleware.use(new _historyFallbackMiddleware.HistoryFallbackMiddleware(manifestMiddleware.getHandler().internal).getHandler());
+                }
             }
         }
         // Extend the close method to ensure that we clean up the local info.
@@ -539,6 +633,7 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
                 callback == null ? void 0 : callback(err);
             });
         };
+        (0, _metroPrivateServer.assertMetroPrivateServer)(metro);
         this.metro = metro;
         return {
             server,
@@ -624,13 +719,17 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
                 debug("Bundle API route:", this.instanceMetroOptions.routerRoot, filePath);
                 return await this.ssrLoadModuleContents(filePath);
             } catch (error) {
-                if (error instanceof Error) {
-                    await (0, _metroErrorInterface.logMetroErrorAsync)({
-                        error,
-                        projectRoot: this.projectRoot
-                    });
+                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];
                 }
-                throw error;
+                throw err;
             } finally{
             // pendingRouteOperations.delete(filepath);
             }
@@ -654,7 +753,7 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
                     const htmlServerError = await (0, _metroErrorInterface.getErrorOverlayHtmlAsync)({
                         error,
                         projectRoot: this.projectRoot,
-                        routerRoot: this.getExpoLineOptions().routerRoot
+                        routerRoot: this.instanceMetroOptions.routerRoot
                     });
                     return new Response(htmlServerError, {
                         status: 500,
@@ -674,6 +773,188 @@ 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((0, _metroOptions.convertPathToModuleSpecifier)(moduleId), {
+            relativeTo: "server",
+            resolverOptions,
+            transformOptions
+        });
+    }
+}
+function getBuildID(buildNumber) {
+    return buildNumber.toString(36);
 }
 function getDeepLinkHandler(projectRoot) {
     return async ({ runtime  })=>{
@@ -685,5 +966,16 @@ 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