@expo/cli 0.17.10 → 0.18.1

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

@@ -1,66 +1,136 @@
-"use strict";
+/**
+ * Copyright © 2022 650 Industries.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */ "use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.getDeepLinkHandler = getDeepLinkHandler;
-var _config = require("@expo/config");
-var runtimeEnv = _interopRequireWildcard(require("@expo/env"));
-var _chalk = _interopRequireDefault(require("chalk"));
-var _nodeFetch = _interopRequireDefault(require("node-fetch"));
-var _path = _interopRequireDefault(require("path"));
-var _bundleApiRoutes = require("./bundleApiRoutes");
-var _createServerRouteMiddleware = require("./createServerRouteMiddleware");
-var _fetchRouterManifest = require("./fetchRouterManifest");
-var _instantiateMetro = require("./instantiateMetro");
-var _metroWatchTypeScriptFiles = require("./metroWatchTypeScriptFiles");
-var _router = require("./router");
-var _serializeHtml = require("./serializeHtml");
-var _waitForMetroToObserveTypeScriptFile = require("./waitForMetroToObserveTypeScriptFile");
-var _log = require("../../../log");
-var _getDevClientProperties = _interopRequireDefault(require("../../../utils/analytics/getDevClientProperties"));
-var _rudderstackClient = require("../../../utils/analytics/rudderstackClient");
-var _errors = require("../../../utils/errors");
-var _port = require("../../../utils/port");
-var _bundlerDevServer = require("../BundlerDevServer");
-var _getStaticRenderFunctions = require("../getStaticRenderFunctions");
-var _contextModuleSourceMapsMiddleware = require("../middleware/ContextModuleSourceMapsMiddleware");
-var _createFileMiddleware = require("../middleware/CreateFileMiddleware");
-var _devToolsPluginMiddleware = require("../middleware/DevToolsPluginMiddleware");
-var _faviconMiddleware = require("../middleware/FaviconMiddleware");
-var _historyFallbackMiddleware = require("../middleware/HistoryFallbackMiddleware");
-var _interstitialPageMiddleware = require("../middleware/InterstitialPageMiddleware");
-var _manifestMiddleware = require("../middleware/ManifestMiddleware");
-var _reactDevToolsPageMiddleware = require("../middleware/ReactDevToolsPageMiddleware");
-var _runtimeRedirectMiddleware = require("../middleware/RuntimeRedirectMiddleware");
-var _serveStaticMiddleware = require("../middleware/ServeStaticMiddleware");
-var _metroOptions = require("../middleware/metroOptions");
-var _mutations = require("../middleware/mutations");
-var _startTypescriptTypeGeneration = require("../type-generation/startTypescriptTypeGeneration");
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ForwardHtmlError: ()=>ForwardHtmlError,
+    MetroBundlerDevServer: ()=>MetroBundlerDevServer,
+    getDeepLinkHandler: ()=>getDeepLinkHandler
+});
+function _config() {
+    const data = require("@expo/config");
+    _config = function() {
+        return data;
+    };
+    return data;
+}
+function _env() {
+    const data = /*#__PURE__*/ _interopRequireWildcard(require("@expo/env"));
+    _env = function() {
+        return data;
+    };
+    return data;
+}
+function _assert() {
+    const data = /*#__PURE__*/ _interopRequireDefault(require("assert"));
+    _assert = function() {
+        return data;
+    };
+    return data;
+}
+function _chalk() {
+    const data = /*#__PURE__*/ _interopRequireDefault(require("chalk"));
+    _chalk = function() {
+        return data;
+    };
+    return data;
+}
+function _nodeFetch() {
+    const data = /*#__PURE__*/ _interopRequireDefault(require("node-fetch"));
+    _nodeFetch = function() {
+        return data;
+    };
+    return data;
+}
+function _path() {
+    const data = /*#__PURE__*/ _interopRequireDefault(require("path"));
+    _path = function() {
+        return data;
+    };
+    return data;
+}
+const _createServerRouteMiddleware = require("./createServerRouteMiddleware");
+const _fetchRouterManifest = require("./fetchRouterManifest");
+const _instantiateMetro = require("./instantiateMetro");
+const _metroErrorInterface = require("./metroErrorInterface");
+const _metroWatchTypeScriptFiles = require("./metroWatchTypeScriptFiles");
+const _router = require("./router");
+const _serializeHtml = require("./serializeHtml");
+const _waitForMetroToObserveTypeScriptFile = require("./waitForMetroToObserveTypeScriptFile");
+const _log = require("../../../log");
+const _getDevClientProperties = /*#__PURE__*/ _interopRequireDefault(require("../../../utils/analytics/getDevClientProperties"));
+const _errors = require("../../../utils/errors");
+const _port = require("../../../utils/port");
+const _telemetry = require("../../../utils/telemetry");
+const _bundlerDevServer = require("../BundlerDevServer");
+const _getStaticRenderFunctions = require("../getStaticRenderFunctions");
+const _contextModuleSourceMapsMiddleware = require("../middleware/ContextModuleSourceMapsMiddleware");
+const _createFileMiddleware = require("../middleware/CreateFileMiddleware");
+const _devToolsPluginMiddleware = require("../middleware/DevToolsPluginMiddleware");
+const _faviconMiddleware = require("../middleware/FaviconMiddleware");
+const _historyFallbackMiddleware = require("../middleware/HistoryFallbackMiddleware");
+const _interstitialPageMiddleware = require("../middleware/InterstitialPageMiddleware");
+const _manifestMiddleware = require("../middleware/ManifestMiddleware");
+const _reactDevToolsPageMiddleware = require("../middleware/ReactDevToolsPageMiddleware");
+const _runtimeRedirectMiddleware = require("../middleware/RuntimeRedirectMiddleware");
+const _serveStaticMiddleware = require("../middleware/ServeStaticMiddleware");
+const _metroOptions = require("../middleware/metroOptions");
+const _mutations = require("../middleware/mutations");
+const _startTypescriptTypeGeneration = require("../type-generation/startTypescriptTypeGeneration");
 function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
-function _interopRequireWildcard(obj) {
-    if (obj && obj.__esModule) {
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
         return obj;
-    } else {
-        var newObj = {};
-        if (obj != null) {
-            for(var key in obj){
-                if (Object.prototype.hasOwnProperty.call(obj, key)) {
-                    var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {};
-                    if (desc.get || desc.set) {
-                        Object.defineProperty(newObj, key, desc);
-                    } else {
-                        newObj[key] = obj[key];
-                    }
-                }
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
             }
         }
-        newObj.default = obj;
-        return newObj;
     }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
 }
 class ForwardHtmlError extends _errors.CommandError {
     constructor(message, html, statusCode){
@@ -69,7 +139,6 @@ class ForwardHtmlError extends _errors.CommandError {
         this.statusCode = statusCode;
     }
 }
-exports.ForwardHtmlError = ForwardHtmlError;
 const debug = require("debug")("expo:start:server:metro");
 /** 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;
@@ -82,29 +151,45 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
         var // If the manually defined port is busy then an error should be thrown...
         _port1;
         const port = (_port1 = options.port) != null ? _port1 : // Otherwise use the default port based on the runtime target.
-        (options.devClient ? Number(process.env.RCT_METRO_PORT) || DEV_CLIENT_METRO_PORT : await (0, _port).getFreePortAsync(EXPO_GO_METRO_PORT));
+        (options.devClient ? Number(process.env.RCT_METRO_PORT) || DEV_CLIENT_METRO_PORT : await (0, _port.getFreePortAsync)(EXPO_GO_METRO_PORT));
         return port;
     }
-    async exportExpoRouterApiRoutesAsync({ mode , outputDir , prerenderManifest , baseUrl , routerRoot  }) {
-        const appDir = _path.default.join(this.projectRoot, routerRoot);
+    async exportExpoRouterApiRoutesAsync({ includeSourceMaps , outputDir , prerenderManifest  }) {
+        const { routerRoot  } = this.instanceMetroOptions;
+        (0, _assert().default)(routerRoot != null, "The server must be started before calling exportExpoRouterApiRoutesAsync.");
+        const appDir = _path().default.join(this.projectRoot, routerRoot);
         const manifest = await this.getExpoRouterRoutesManifestAsync({
             appDir
         });
         const files = new Map();
         for (const route of manifest.apiRoutes){
-            var ref;
-            const filepath = _path.default.join(appDir, route.file);
-            const contents = await (0, _bundleApiRoutes).bundleApiRoute(this.projectRoot, filepath, {
-                mode,
-                routerRoot,
-                port: (ref = this.getInstance()) == null ? void 0 : ref.location.port,
-                shouldThrow: true,
-                baseUrl
-            });
-            const artifactFilename = _path.default.join(outputDir, _path.default.relative(appDir, filepath.replace(/\.[tj]sx?$/, ".js")));
+            const filepath = _path().default.join(appDir, route.file);
+            const contents = await this.bundleApiRoute(filepath);
+            const artifactFilename = _path().default.join(outputDir, _path().default.relative(appDir, filepath.replace(/\.[tj]sx?$/, ".js")));
             if (contents) {
+                let src = contents.src;
+                if (includeSourceMaps && contents.map) {
+                    // TODO(kitten): Merge the source map transformer in the future
+                    // https://github.com/expo/expo/blob/0dffdb15/packages/%40expo/metro-config/src/serializer/serializeChunks.ts#L422-L439
+                    // Alternatively, check whether `sourcesRoot` helps here
+                    const artifactBasename = encodeURIComponent(_path().default.basename(artifactFilename) + ".map");
+                    src = src.replace(/\/\/# sourceMappingURL=.*/g, `//# sourceMappingURL=${artifactBasename}`);
+                    files.set(artifactFilename + ".map", {
+                        contents: JSON.stringify({
+                            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(contents.map.sources.length).fill(null),
+                            names: contents.map.names,
+                            mappings: contents.map.mappings
+                        }),
+                        targetDomain: "server"
+                    });
+                }
                 files.set(artifactFilename, {
-                    contents: contents.src,
+                    contents: src,
                     targetDomain: "server"
                 });
             }
@@ -121,7 +206,7 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
     }
     async getExpoRouterRoutesManifestAsync({ appDir  }) {
         // getBuiltTimeServerManifest
-        const manifest = await (0, _fetchRouterManifest).fetchManifest(this.projectRoot, {
+        const manifest = await (0, _fetchRouterManifest.fetchManifest)(this.projectRoot, {
             asJson: true,
             appDir
         });
@@ -130,21 +215,19 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
         }
         return manifest;
     }
-    async getStaticRenderFunctionAsync({ mode , minify =mode !== "development" , baseUrl , routerRoot  }) {
+    async getStaticRenderFunctionAsync() {
+        const { mode , minify , isExporting  } = this.instanceMetroOptions;
+        (0, _assert().default)(mode != null && minify != null && isExporting != null, "The server must be started before calling ssrLoadModule.");
         const url = this.getDevServerUrl();
-        const { getStaticContent , getManifest , getBuildTimeServerManifestAsync  } = await (0, _getStaticRenderFunctions).getStaticRenderFunctions(this.projectRoot, url, {
+        const { getStaticContent , getManifest , getBuildTimeServerManifestAsync  } = await this.ssrLoadModule("expo-router/node/render.js", {
             minify,
-            dev: mode !== "production",
-            // Ensure the API Routes are included
-            environment: "node",
-            baseUrl,
-            routerRoot
+            mode,
+            isExporting
         });
         return {
             serverManifest: await getBuildTimeServerManifestAsync(),
             // Get routes from Expo Router.
             manifest: await getManifest({
-                fetchData: true,
                 preserveApiRoutes: false
             }),
             // Get route generating function
@@ -153,19 +236,22 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
             }
         };
     }
-    async getStaticResourcesAsync({ mode , minify =mode !== "development" , includeSourceMaps , baseUrl , mainModuleName , isExporting , asyncRoutes , routerRoot  }) {
+    async getStaticResourcesAsync({ includeSourceMaps , mainModuleName  } = {}) {
         var ref;
-        const devBundleUrlPathname = (0, _metroOptions).createBundleUrlPath({
-            platform: "web",
+        const { mode , minify , isExporting , baseUrl , routerRoot , asyncRoutes  } = this.instanceMetroOptions;
+        (0, _assert().default)(mode != null && minify != 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)({
+            platform,
             mode,
             minify,
             environment: "client",
             serializerOutput: "static",
             serializerIncludeMaps: includeSourceMaps,
-            mainModuleName: mainModuleName != null ? mainModuleName : (0, _manifestMiddleware).resolveMainModuleName(this.projectRoot, {
-                platform: "web"
+            mainModuleName: mainModuleName != null ? mainModuleName : (0, _manifestMiddleware.resolveMainModuleName)(this.projectRoot, {
+                platform
             }),
-            lazy: (0, _metroOptions).shouldEnableAsyncImports(this.projectRoot),
+            lazy: (0, _metroOptions.shouldEnableAsyncImports)(this.projectRoot),
             asyncRoutes,
             baseUrl,
             isExporting,
@@ -174,7 +260,7 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
         });
         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 results = await (0, _nodeFetch().default)(bundleUrl.toString());
         const txt = await results.text();
         let data;
         try {
@@ -214,15 +300,18 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
         }
         throw new Error("Invalid resources returned from the Metro serializer. Expected array, found: " + data);
     }
-    async getStaticPageAsync(pathname, { mode , minify =mode !== "development" , baseUrl , routerRoot , isExporting , asyncRoutes  }) {
-        const devBundleUrlPathname = (0, _metroOptions).createBundleUrlPath({
-            platform: "web",
+    async getStaticPageAsync(pathname) {
+        const { mode , minify , isExporting , baseUrl , routerRoot , asyncRoutes  } = this.instanceMetroOptions;
+        (0, _assert().default)(mode != null && minify != 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)({
+            platform,
             mode,
             environment: "client",
-            mainModuleName: (0, _manifestMiddleware).resolveMainModuleName(this.projectRoot, {
-                platform: "web"
+            mainModuleName: (0, _manifestMiddleware.resolveMainModuleName)(this.projectRoot, {
+                platform
             }),
-            lazy: (0, _metroOptions).shouldEnableAsyncImports(this.projectRoot),
+            lazy: (0, _metroOptions.shouldEnableAsyncImports)(this.projectRoot),
             baseUrl,
             isExporting,
             asyncRoutes,
@@ -230,30 +319,21 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
             bytecode: false
         });
         const bundleStaticHtml = async ()=>{
-            const { getStaticContent  } = await (0, _getStaticRenderFunctions).getStaticRenderFunctions(this.projectRoot, this.getDevServerUrl(), {
+            const { getStaticContent  } = await this.ssrLoadModule("expo-router/node/render.js", {
                 minify: false,
-                dev: mode !== "production",
-                // Ensure the API Routes are included
-                environment: "node",
-                baseUrl,
-                routerRoot
+                mode,
+                isExporting,
+                platform
             });
             const location = new URL(pathname, this.getDevServerUrl());
             return await getStaticContent(location);
         };
         const [{ artifacts: resources  }, staticHtml] = await Promise.all([
-            this.getStaticResourcesAsync({
-                isExporting,
-                mode,
-                minify,
-                baseUrl,
-                asyncRoutes,
-                routerRoot
-            }),
+            this.getStaticResourcesAsync(),
             bundleStaticHtml(), 
         ]);
-        const content = (0, _serializeHtml).serializeHtmlWithAssets({
-            mode,
+        const content = (0, _serializeHtml.serializeHtmlWithAssets)({
+            isExporting,
             resources,
             template: staticHtml,
             devBundleUrl: devBundleUrlPathname,
@@ -264,6 +344,40 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
             resources
         };
     }
+    // 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(), {
+            // Bundle in Node.js mode for SSR.
+            environment: "node",
+            platform: "web",
+            mode: "development",
+            bytecode: false,
+            ...this.instanceMetroOptions,
+            baseUrl,
+            routerRoot,
+            isExporting,
+            ...specificOptions
+        }, 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 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,
+            baseUrl,
+            routerRoot,
+            isExporting,
+            ...specificOptions
+        });
+    }
     async watchEnvironmentVariables() {
         if (!this.instance) {
             throw new Error("Cannot observe environment variable changes without a running Metro instance.");
@@ -274,22 +388,49 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
             debug("Skipping Environment Variable observation because Metro is not running (headless).");
             return;
         }
-        const envFiles = runtimeEnv.getFiles(process.env.NODE_ENV).map((fileName)=>_path.default.join(this.projectRoot, fileName)
-        );
-        (0, _waitForMetroToObserveTypeScriptFile).observeFileChanges({
+        const envFiles = _env().getFiles(process.env.NODE_ENV).map((fileName)=>_path().default.join(this.projectRoot, fileName));
+        (0, _waitForMetroToObserveTypeScriptFile.observeFileChanges)({
             metro: this.metro,
             server: this.instance.server
         }, envFiles, ()=>{
             debug("Reloading environment variables...");
             // Force reload the environment variables.
-            runtimeEnv.load(this.projectRoot, {
+            _env().load(this.projectRoot, {
                 force: true
             });
         });
     }
+    getExpoLineOptions() {
+        return this.instanceMetroOptions;
+    }
     async startImplementationAsync(options) {
+        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 ref1;
+        const useServerRendering = [
+            "static",
+            "server"
+        ].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 appDir = _path().default.join(this.projectRoot, routerRoot);
+        var _mode1;
+        const mode = (_mode1 = options.mode) != null ? _mode1 : "development";
+        this.instanceMetroOptions = {
+            isExporting: !!options.isExporting,
+            baseUrl,
+            mode,
+            routerRoot,
+            minify: options.minify,
+            asyncRoutes
+        };
         const parsedOptions = {
             port: options.port,
             maxWorkers: options.maxWorkers,
@@ -297,19 +438,19 @@ 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, {
+        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());
+        (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());
+        (0, _mutations.prependMiddleware)(middleware, manifestMiddleware.getHandler());
         var _scheme;
         middleware.use(new _interstitialPageMiddleware.InterstitialPageMiddleware(this.projectRoot, {
             // TODO: Prevent this from becoming stale.
@@ -324,8 +465,8 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
                     var ref;
                     return (ref = this.urlCreator) == null ? void 0 : ref.constructDevClientUrl();
                 } else {
-                    var ref2;
-                    return (ref2 = this.urlCreator) == null ? void 0 : ref2.constructUrl({
+                    var ref1;
+                    return (ref1 = this.urlCreator) == null ? void 0 : ref1.constructUrl({
                         scheme: "exp"
                     });
                 }
@@ -335,46 +476,21 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
         middleware.use(new _createFileMiddleware.CreateFileMiddleware(this.projectRoot).getHandler());
         // Append support for redirecting unhandled requests to the index.html page on web.
         if (this.isTargetingWeb()) {
-            var ref3;
-            const config = (0, _config).getConfig(this.projectRoot, {
-                skipSDKVersionRequirement: true
-            });
-            const { exp  } = config;
-            var ref1;
-            const useServerRendering = [
-                "static",
-                "server"
-            ].includes((ref1 = (ref3 = exp.web) == null ? void 0 : ref3.output) != null ? ref1 : "");
             // 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) {
-                const baseUrl = (0, _metroOptions).getBaseUrlFromExpoConfig(exp);
-                var _mode1;
-                const asyncRoutes = (0, _metroOptions).getAsyncRoutesFromExpoConfig(exp, (_mode1 = options.mode) != null ? _mode1 : "development", "web");
-                const routerRoot = (0, _router).getRouterDirectoryModuleIdWithManifest(this.projectRoot, exp);
-                const appDir = _path.default.join(this.projectRoot, routerRoot);
-                middleware.use((0, _createServerRouteMiddleware).createRouteHandlerMiddleware(this.projectRoot, {
-                    ...options,
+                middleware.use((0, _createServerRouteMiddleware.createRouteHandlerMiddleware)(this.projectRoot, {
                     appDir,
-                    baseUrl,
                     routerRoot,
                     config,
-                    getWebBundleUrl: manifestMiddleware.getWebBundleUrl.bind(manifestMiddleware),
+                    bundleApiRoute: (functionFilePath)=>this.ssrImportApiRoute(functionFilePath),
                     getStaticPageAsync: (pathname)=>{
-                        var _mode;
-                        return this.getStaticPageAsync(pathname, {
-                            isExporting: !!options.isExporting,
-                            mode: (_mode = options.mode) != null ? _mode : "development",
-                            minify: options.minify,
-                            baseUrl,
-                            asyncRoutes,
-                            routerRoot
-                        });
+                        return this.getStaticPageAsync(pathname);
                     }
                 }));
-                (0, _waitForMetroToObserveTypeScriptFile).observeAnyFileChanges({
+                (0, _waitForMetroToObserveTypeScriptFile.observeAnyFileChanges)({
                     metro,
                     server
                 }, (events)=>{
@@ -385,15 +501,15 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
                         // 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.
-                        (0, _bundleApiRoutes).invalidateApiRouteCache();
-                    } else if (!(0, _router).hasWarnedAboutApiRoutes()) {
+                        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.
-                            ref4;
-                            if (((ref4 = event.metadata) == null ? void 0 : ref4.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();
+                            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)();
                             }
                         }
                     }
@@ -440,7 +556,7 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
                 debug("Skipping TypeScript check because Metro is not running (headless).");
                 return resolve(false);
             }
-            const off = (0, _metroWatchTypeScriptFiles).metroWatchTypeScriptFiles({
+            const off = (0, _metroWatchTypeScriptFiles.metroWatchTypeScriptFiles)({
                 projectRoot: this.projectRoot,
                 server: this.instance.server,
                 metro: this.metro,
@@ -453,9 +569,7 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
                 callback: async ()=>{
                     // Run once, this prevents the TypeScript project prerequisite from running on every file change.
                     off();
-                    const { TypeScriptProjectPrerequisite  } = await Promise.resolve().then(function() {
-                        return _interopRequireWildcard(require("../../doctor/typescript/TypeScriptProjectPrerequisite.js"));
-                    });
+                    const { TypeScriptProjectPrerequisite  } = await Promise.resolve().then(()=>/*#__PURE__*/ _interopRequireWildcard(require("../../doctor/typescript/TypeScriptProjectPrerequisite.js")));
                     try {
                         const req = new TypeScriptProjectPrerequisite(this.projectRoot);
                         await req.bootstrapAsync();
@@ -464,7 +578,7 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
                         // Ensure the process doesn't fail if the TypeScript check fails.
                         // This could happen during the install.
                         _log.Log.log();
-                        _log.Log.error(_chalk.default.red`Failed to automatically setup TypeScript for your project. Try restarting the dev server to fix.`);
+                        _log.Log.error(_chalk().default.red`Failed to automatically setup TypeScript for your project. Try restarting the dev server to fix.`);
                         _log.Log.exception(error);
                         resolve(false);
                     }
@@ -474,7 +588,7 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
     }
     async startTypeScriptServices() {
         var ref;
-        return (0, _startTypescriptTypeGeneration).startTypescriptTypeGenerationAsync({
+        return (0, _startTypescriptTypeGeneration.startTypescriptTypeGenerationAsync)({
             server: (ref = this.instance) == null ? void 0 : ref.server,
             metro: this.metro,
             projectRoot: this.projectRoot
@@ -487,15 +601,76 @@ class MetroBundlerDevServer extends _bundlerDevServer.BundlerDevServer {
             "./rn-cli.config.js"
         ];
     }
+    pendingRouteOperations = new Map();
+    // API Routes
+    // Bundle the API Route with Metro and return the string contents to be evaluated in the server.
+    async bundleApiRoute(filePath) {
+        if (this.pendingRouteOperations.has(filePath)) {
+            return this.pendingRouteOperations.get(filePath);
+        }
+        const bundleAsync = async ()=>{
+            try {
+                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
+                    });
+                }
+                throw error;
+            } finally{
+            // pendingRouteOperations.delete(filepath);
+            }
+        };
+        const route = bundleAsync();
+        this.pendingRouteOperations.set(filePath, route);
+        return route;
+    }
+    async ssrImportApiRoute(filePath) {
+        // TODO: Cache the evaluated function.
+        try {
+            const apiRoute = await this.bundleApiRoute(filePath);
+            if (!(apiRoute == null ? void 0 : apiRoute.src)) {
+                return null;
+            }
+            return (0, _getStaticRenderFunctions.evalMetroNoHandling)(this.projectRoot, apiRoute.src, apiRoute.filename);
+        } catch (error) {
+            // Format any errors that were thrown in the global scope of the evaluation.
+            if (error instanceof Error) {
+                try {
+                    const htmlServerError = await (0, _metroErrorInterface.getErrorOverlayHtmlAsync)({
+                        error,
+                        projectRoot: this.projectRoot,
+                        routerRoot: this.getExpoLineOptions().routerRoot
+                    });
+                    return new Response(htmlServerError, {
+                        status: 500,
+                        headers: {
+                            "Content-Type": "text/html"
+                        }
+                    });
+                } catch (internalError) {
+                    debug("Failed to generate Metro server error UI for API Route error:", internalError);
+                    throw error;
+                }
+            } else {
+                throw error;
+            }
+        }
+    }
+    invalidateApiRouteCache() {
+        this.pendingRouteOperations.clear();
+    }
 }
-exports.MetroBundlerDevServer = MetroBundlerDevServer;
 function getDeepLinkHandler(projectRoot) {
     return async ({ runtime  })=>{
         if (runtime === "expo") return;
-        const { exp  } = (0, _config).getConfig(projectRoot);
-        await (0, _rudderstackClient).logEventAsync("dev client start command", {
+        const { exp  } = (0, _config().getConfig)(projectRoot);
+        await (0, _telemetry.logEventAsync)("dev client start command", {
             status: "started",
-            ...(0, _getDevClientProperties).default(projectRoot, exp)
+            ...(0, _getDevClientProperties.default)(projectRoot, exp)
         });
     };
 }