@depup/expo__cli 55.0.22-depup.1 → 57.0.9-depup.0

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

@@ -10,14 +10,14 @@ Object.defineProperty(exports, "__esModule", {
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
         enumerable: true,
-        get: all[name]
+        get: Object.getOwnPropertyDescriptor(all, name).get
     });
 }
 _export(exports, {
-    MetroBundlerDevServer: function() {
+    get MetroBundlerDevServer () {
         return MetroBundlerDevServer;
     },
-    event: function() {
+    get event () {
         return event;
     }
 });
@@ -42,13 +42,6 @@ function _baseJSBundle() {
     };
     return data;
 }
-function _sourceMapGenerator() {
-    const data = require("@expo/metro/metro/DeltaBundler/Serializers/sourceMapGenerator");
-    _sourceMapGenerator = function() {
-        return data;
-    };
-    return data;
-}
 function _bundleToString() {
     const data = /*#__PURE__*/ _interop_require_default(require("@expo/metro/metro/lib/bundleToString"));
     _bundleToString = function() {
@@ -63,6 +56,13 @@ function _getGraphId() {
     };
     return data;
 }
+function _sourceMap() {
+    const data = require("@expo/metro-config/build/serializer/sourceMap");
+    _sourceMap = function() {
+        return data;
+    };
+    return data;
+}
 function _assert() {
     const data = /*#__PURE__*/ _interop_require_default(require("assert"));
     _assert = function() {
@@ -84,13 +84,6 @@ function _private() {
     };
     return data;
 }
-function _https() {
-    const data = /*#__PURE__*/ _interop_require_default(require("https"));
-    _https = function() {
-        return data;
-    };
-    return data;
-}
 function _path() {
     const data = /*#__PURE__*/ _interop_require_default(require("path"));
     _path = function() {
@@ -114,6 +107,8 @@ const _errors = require("../../../utils/errors");
 const _filePath = require("../../../utils/filePath");
 const _nodeEnv = require("../../../utils/nodeEnv");
 const _port = require("../../../utils/port");
+const _AndroidAppIdResolver = require("../../platforms/android/AndroidAppIdResolver");
+const _AppleAppIdResolver = require("../../platforms/ios/AppleAppIdResolver");
 const _BundlerDevServer = require("../BundlerDevServer");
 const _getStaticRenderFunctions = require("../getStaticRenderFunctions");
 const _resolveLoader = require("./resolveLoader");
@@ -124,11 +119,12 @@ const _DomComponentsMiddleware = require("../middleware/DomComponentsMiddleware"
 const _FaviconMiddleware = require("../middleware/FaviconMiddleware");
 const _HistoryFallbackMiddleware = require("../middleware/HistoryFallbackMiddleware");
 const _InterstitialPageMiddleware = require("../middleware/InterstitialPageMiddleware");
-const _ManifestMiddleware = require("../middleware/ManifestMiddleware");
+const _OpenMiddleware = require("../middleware/OpenMiddleware");
 const _RuntimeRedirectMiddleware = require("../middleware/RuntimeRedirectMiddleware");
 const _ServeStaticMiddleware = require("../middleware/ServeStaticMiddleware");
 const _metroOptions = require("../middleware/metroOptions");
 const _mutations = require("../middleware/mutations");
+const _openHandlers = require("../middleware/openHandlers");
 const _startTypescriptTypeGeneration = require("../type-generation/startTypescriptTypeGeneration");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
@@ -429,7 +425,7 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
     async getStaticResourcesAsync({ includeSourceMaps, mainModuleName, clientBoundaries = this.instanceMetroOptions.clientBoundaries ?? [], platform = 'web' } = {}) {
         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 resolvedMainModuleName = mainModuleName ?? './' + (0, _ManifestMiddleware.resolveMainModuleName)(this.projectRoot, {
+        const resolvedMainModuleName = mainModuleName ?? './' + (0, _paths().resolveRelativeEntryPoint)(this.projectRoot, {
             platform
         });
         return await this.metroImportAsArtifactsAsync(resolvedMainModuleName, {
@@ -450,9 +446,48 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
             bytecode: false
         });
     }
+    async getDevServerRenderOptionsAsync({ location, route, request, resolveMetadata }) {
+        var _exp_extra_router, _exp_extra;
+        const { exp } = (0, _config().getConfig)(this.projectRoot);
+        const resolvedLoaderRoute = (0, _resolveLoader.fromServerManifestRoute)(location.pathname, route);
+        const params = (resolvedLoaderRoute == null ? void 0 : resolvedLoaderRoute.params) ?? {};
+        const renderOptions = {
+            params
+        };
+        if (resolveMetadata) {
+            // TODO(@hassankhan): Revisit if we support request-less `generateMetadata()` during SSG
+            if (!request) {
+                throw new _errors.CommandError('SSR_STREAMING_REQUEST_REQUIRED', 'Invariant violation: development streaming SSR requires a request to resolve metadata.');
+            }
+            renderOptions.metadata = await resolveMetadata({
+                route: {
+                    file: route.file,
+                    page: route.page
+                },
+                request,
+                params
+            });
+        }
+        const useServerDataLoaders = ((_exp_extra = exp.extra) == null ? void 0 : (_exp_extra_router = _exp_extra.router) == null ? void 0 : _exp_extra_router.unstable_useServerDataLoaders) === true;
+        if (!useServerDataLoaders || !resolvedLoaderRoute) {
+            return renderOptions;
+        }
+        const loaderResult = await this.executeServerDataLoaderAsync(location, resolvedLoaderRoute, request);
+        if (!loaderResult) {
+            return renderOptions;
+        }
+        const loaderData = loaderResult instanceof Response ? await loaderResult.json() : loaderResult;
+        const resolvedLoaderKey = (0, _private().resolveLoaderContextKey)(resolvedLoaderRoute.contextKey, resolvedLoaderRoute.params);
+        renderOptions.loader = {
+            data: loaderData ?? null,
+            key: resolvedLoaderKey
+        };
+        return renderOptions;
+    }
     /**
    * This function is invoked when running in development via `expo start`
    */ async getStaticPageAsync(pathname, route, request) {
+        var _exp_web, _exp_extra_router, _exp_extra;
         const { exp } = (0, _config().getConfig)(this.projectRoot);
         const { mode, isExporting, clientBoundaries, 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.');
@@ -463,7 +498,7 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
             mode,
             environment: 'client',
             reactCompiler,
-            mainModuleName: (0, _ManifestMiddleware.resolveMainModuleName)(this.projectRoot, {
+            mainModuleName: (0, _paths().resolveRelativeEntryPoint)(this.projectRoot, {
                 platform
             }),
             lazy: !_env.env.EXPO_NO_METRO_LAZY,
@@ -474,8 +509,47 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
             clientBoundaries,
             bytecode: false
         });
+        const isSSREnabled = ((_exp_web = exp.web) == null ? void 0 : _exp_web.output) === 'server' && ((_exp_extra = exp.extra) == null ? void 0 : (_exp_extra_router = _exp_extra.router) == null ? void 0 : _exp_extra_router.unstable_useServerRendering) === true;
+        const location = new URL(pathname, this.getDevServerUrlOrAssert());
+        if (isSSREnabled) {
+            if (!request) {
+                throw new _errors.CommandError('SSR_STREAMING_REQUEST_REQUIRED', 'Invariant violation: development streaming SSR requires a request.');
+            }
+            const { getStreamingContent, resolveMetadata } = await this.ssrLoadModule(require.resolve('@expo/router-server/node/render.js'), {
+                // Development streaming SSR intentionally stays on the non-RSC server renderer.
+                environment: 'node',
+                minify: false,
+                isExporting,
+                platform
+            });
+            const { artifacts: resources } = await this.getStaticResourcesAsync({
+                clientBoundaries: []
+            });
+            const { cssHrefs, externalCss, inlineCss } = getStreamingCssAssetsFromSerialAssets(resources);
+            const { loader, metadata } = await this.getDevServerRenderOptionsAsync({
+                location,
+                route,
+                request,
+                resolveMetadata
+            });
+            const content = await getStreamingContent(location, {
+                loader,
+                metadata,
+                request: request,
+                assets: {
+                    css: cssHrefs,
+                    externalCss,
+                    inlineCss,
+                    js: [
+                        devBundleUrlPathname
+                    ]
+                }
+            });
+            return {
+                content
+            };
+        }
         const bundleStaticHtml = async ()=>{
-            var _exp_extra_router, _exp_extra;
             const { getStaticContent } = await this.ssrLoadModule(require.resolve('@expo/router-server/node/render.js'), {
                 // This must always use the legacy rendering resolution (no `react-server`) because it leverages
                 // the previous React SSG utilities which aren't available in React 19.
@@ -484,27 +558,14 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
                 isExporting,
                 platform
             });
-            const location = new URL(pathname, this.getDevServerUrlOrAssert());
-            const useServerDataLoaders = (_exp_extra = exp.extra) == null ? void 0 : (_exp_extra_router = _exp_extra.router) == null ? void 0 : _exp_extra_router.unstable_useServerDataLoaders;
-            if (!useServerDataLoaders) {
-                return await getStaticContent(location);
-            }
-            const resolvedLoaderRoute = (0, _resolveLoader.fromServerManifestRoute)(location.pathname, route);
-            if (!resolvedLoaderRoute) {
-                return await getStaticContent(location);
-            }
-            const loaderResult = await this.executeServerDataLoaderAsync(location, resolvedLoaderRoute, request);
-            if (!loaderResult) {
-                return await getStaticContent(location);
-            }
-            const loaderData = await loaderResult.json();
-            const resolvedLoaderKey = (0, _private().resolveLoaderContextKey)(resolvedLoaderRoute.contextKey, resolvedLoaderRoute.params);
-            return await getStaticContent(location, {
-                loader: {
-                    data: loaderData,
-                    key: resolvedLoaderKey
-                }
+            const { loader } = await this.getDevServerRenderOptionsAsync({
+                location,
+                route,
+                request
             });
+            return await getStaticContent(location, loader ? {
+                loader
+            } : undefined);
         };
         const [{ artifacts: resources }, staticHtml] = await Promise.all([
             this.getStaticResourcesAsync({
@@ -603,7 +664,8 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
                 modulesOnly: expoBundleOptions.modulesOnly ?? false,
                 runModule: expoBundleOptions.runModule ?? true,
                 sourceUrl: expoBundleOptions.sourceUrl,
-                sourceMapUrl: extraOptions.sourceMapUrl ?? expoBundleOptions.sourceMapUrl
+                sourceMapUrl: extraOptions.sourceMapUrl ?? expoBundleOptions.sourceMapUrl,
+                excludeSource: expoBundleOptions.serializerOptions.excludeSource ?? false
             },
             transformOptions
         });
@@ -640,15 +702,6 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
         // 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,
@@ -873,14 +926,16 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
             apiRoutes: hasApiRoutes,
             exporting: !!options.isExporting
         });
-        const { metro, hmrServer, server, middleware, messageSocket } = await (0, _instantiateMetro.instantiateMetroAsync)(this, parsedOptions, {
+        const { metro, hmrServer, address, server, middleware, messageSocket } = await (0, _instantiateMetro.instantiateMetroAsync)(this, parsedOptions, {
             isExporting: !!options.isExporting,
-            exp
+            exp,
+            devToolsPluginManager: this.devToolsPluginManager
         });
-        const protocol = server instanceof _https().default.Server ? 'https' : 'http';
         // Required for symbolication:
-        process.env.EXPO_DEV_SERVER_ORIGIN = `${protocol}://localhost:${options.port}`;
+        const serverBaseUrl = `${(address == null ? void 0 : address.protocol) ?? 'http'}://localhost:${(address == null ? void 0 : address.port) ?? options.port}`;
+        process.env.EXPO_DEV_SERVER_ORIGIN = serverBaseUrl;
         if (!options.isExporting) {
+            var _metro__config_server, _metro__config;
             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());
@@ -910,14 +965,54 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
                 }
             });
             middleware.use(deepLinkMiddleware.getHandler());
-            const serverRoot = (0, _paths().getMetroServerRoot)(this.projectRoot);
+            const getHostSupport = (platform)=>{
+                if (platform === 'ios' && process.platform !== 'darwin') {
+                    return {
+                        canOpen: false,
+                        reason: `iOS simulators require macOS with Xcode installed; this dev server is running on ${process.platform}.`
+                    };
+                }
+                return {
+                    canOpen: true
+                };
+            };
+            // Read all dev-server state live — pressing `s` in the terminal toggles `isDevClient`
+            // and the scheme, and `expo-dev-client` can be installed mid-run (re-resolved by
+            // isRedirectPageEnabled on every call).
+            const openMiddleware = new _OpenMiddleware.OpenMiddleware(this.projectRoot, {
+                serverBaseUrl,
+                getHostSupport,
+                getInfo: (0, _openHandlers.createInfoHandler)({
+                    urlCreator: this.getUrlCreator(),
+                    getIsDevClient: ()=>this.isDevClient,
+                    getIsRedirectPageEnabled: ()=>this.isRedirectPageEnabled(),
+                    getAppId: async (platform)=>{
+                        if (platform === 'web') return null;
+                        const resolver = platform === 'ios' ? new _AppleAppIdResolver.AppleAppIdResolver(this.projectRoot) : new _AndroidAppIdResolver.AndroidAppIdResolver(this.projectRoot);
+                        try {
+                            return await resolver.getAppIdAsync();
+                        } catch  {
+                            // Surfacing the error would block the dry-run; consumers can detect the missing id
+                            // from `appId: null` and prompt the user to configure ios.bundleIdentifier /
+                            // android.package.
+                            return null;
+                        }
+                    }
+                }),
+                open: (0, _openHandlers.createOpen)({
+                    getIsDevClient: ()=>this.isDevClient,
+                    openPlatformAsync: (target, resolver)=>this.openPlatformAsync(target, resolver)
+                })
+            });
+            middleware.use(openMiddleware.getHandler());
             const domComponentRenderer = (0, _DomComponentsMiddleware.createDomComponentsMiddleware)({
-                metroRoot: serverRoot,
                 projectRoot: this.projectRoot
             }, instanceMetroOptions);
             // Add support for DOM components.
             // TODO: Maybe put behind a flag for now?
             middleware.use(domComponentRenderer);
+            // NOTE: Optional is to accommodate mocks in tests
+            const serverRoot = ((_metro__config = metro._config) == null ? void 0 : (_metro__config_server = _metro__config.server) == null ? void 0 : _metro__config_server.unstable_serverRoot) ?? this.projectRoot;
             middleware.use(new _CreateFileMiddleware.CreateFileMiddleware({
                 metroRoot: serverRoot,
                 projectRoot: this.projectRoot,
@@ -950,8 +1045,7 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
                 (0, _waitForMetroToObserveTypeScriptFile.observeAnyFileChanges)({
                     metro,
                     server
-                }, (events)=>{
-                    var _exp_extra_router, _exp_extra;
+                }, ({ changes })=>{
                     if (hasApiRoutes) {
                         // 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
@@ -960,25 +1054,15 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
                         // 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
+                        for (const change of changes.addedFiles){
+                            if (// 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.
-                            _event_metadata;
-                            if (((_event_metadata = event.metadata) == null ? void 0 : _event_metadata.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)) {
+                            // Ensure the file is in the project's routes directory to prevent false positives in monorepos.
+                            change[0].startsWith(appDir) && (0, _router.isApiRouteConvention)(change[0])) {
                                 (0, _router.warnInvalidWebOutput)();
                             }
                         }
                     }
-                    // Handle loader file changes for HMR
-                    if ((_exp_extra = exp.extra) == null ? void 0 : (_exp_extra_router = _exp_extra.router) == null ? void 0 : _exp_extra_router.unstable_useServerDataLoaders) {
-                        for (const event of events){
-                            var _event_metadata1;
-                            if (((_event_metadata1 = event.metadata) == null ? void 0 : _event_metadata1.type) !== 'd') {
-                                this.handleLoaderFileChange(event.filePath);
-                            }
-                        }
-                    }
                 });
             }
             // If React 19 is enabled, then add RSC middleware to the dev server.
@@ -1026,8 +1110,9 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
                             return this.executeServerDataLoaderAsync(url, resolvedLoaderRoute, isSSREnabled ? request : undefined);
                         },
                         getStaticPageAsync: async (pathname, route, request)=>{
-                            // TODO: Add server rendering when RSC is enabled.
                             if (isReactServerComponentsEnabled) {
+                                // RSC development HTML intentionally stays on the existing temporary SPA/template path.
+                                // Non-RSC streaming SSR is handled by `MetroBundlerDevServer#getStaticPageAsync()`.
                                 // NOTE: This is a temporary hack to return the SPA/template index.html in development when RSC is enabled.
                                 // While this technically works, it doesn't provide the correct experience of server rendering the React code to HTML first.
                                 const html = await manifestMiddleware.getSingleHtmlTemplateAsync();
@@ -1069,6 +1154,11 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
                 this.metro = null;
                 this.hmrServer = null;
                 this.ssrHmrClients = new Map();
+                for (const unlisten of this.loaderGraphListeners.values()){
+                    unlisten();
+                }
+                this.loaderGraphListeners.clear();
+                this.pendingLoaderInvalidationChangeIds.clear();
                 callback == null ? void 0 : callback(err);
             });
         };
@@ -1078,11 +1168,11 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
             server,
             location: {
                 // The port is the main thing we want to send back.
-                port: options.port,
+                port: (address == null ? void 0 : address.port) ?? options.port,
                 // localhost isn't always correct.
                 host: 'localhost',
-                url: `${protocol}://localhost:${options.port}`,
-                protocol
+                url: serverBaseUrl,
+                protocol: (address == null ? void 0 : address.protocol) ?? 'http'
             },
             middleware,
             messageSocket
@@ -1157,6 +1247,8 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
                 debug('Skipping TypeScript check because Metro is not running (headless).');
                 return resolve(false);
             }
+            // TODO(@kitten): This is highly inefficient. We shouldn't watch all changes to determine this
+            // and instead use startup heuristic and do a pre-bundling check
             const off = (0, _metroWatchTypeScriptFiles.metroWatchTypeScriptFiles)({
                 projectRoot: this.projectRoot,
                 server: this.instance.server,
@@ -1242,7 +1334,7 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
             if (!(apiRoute == null ? void 0 : apiRoute.src)) {
                 return null;
             }
-            return (0, _getStaticRenderFunctions.evalMetroNoHandling)(this.projectRoot, apiRoute.src, apiRoute.filename);
+            return (0, _getStaticRenderFunctions.evalMetroNoHandling)(this.projectRoot, apiRoute.src, apiRoute.filename, apiRoute.map);
         } catch (error) {
             // Format any errors that were thrown in the global scope of the evaluation.
             if (error instanceof Error) {
@@ -1300,8 +1392,6 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
                 isLoaderBundle: true
             });
             if (routeModule.loader) {
-                // Register this module for loader HMR
-                this.setupLoaderHmr(modulePath);
                 const maybeResponse = await routeModule.loader(request, route.params);
                 let data;
                 if (maybeResponse instanceof Response) {
@@ -1378,29 +1468,48 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
         };
         this.registerSsrHmrAsync(url.toString(), onReload);
     }
-    setupLoaderHmr(modulePath) {
-        if (this.watchedLoaderFiles.has(modulePath)) {
+    // Subscribe to a loader bundle's Metro graph so we can broadcast `loader-invalidate` and
+    // drop the SSR module eval cache when the loader's dependency graph is dirtied. This avoids
+    // the full-page reload the old stub used and keeps client state across loader edits.
+    setupLoaderGraphListener(graphId, resolvedEntryFilePath, graph) {
+        if (this.loaderGraphListeners.has(graphId) || !this.metro) {
             return;
         }
-        this.watchedLoaderFiles.add(modulePath);
-        debug('[Loader HMR] Registering loader file for HMR:', modulePath);
-    }
-    handleLoaderFileChange(changedFilePath) {
-        for (const loaderPath of this.watchedLoaderFiles){
-            const possibleExtensions = [
-                '.tsx',
-                '.ts',
-                '.jsx',
-                '.js'
-            ];
-            const isLoaderFile = possibleExtensions.some((ext)=>changedFilePath === loaderPath + ext || changedFilePath === loaderPath);
-            if (isLoaderFile) {
-                debug('[Loader HMR] Loader file changed, triggering reload:', changedFilePath);
-                this.broadcastMessage('sendDevCommand', {
-                    name: 'reload'
-                });
+        const deltaBundler = this.metro.getBundler().getDeltaBundler();
+        const onChange = async (changeEvent)=>{
+            debug('[Loader HMR] Graph change detected for:', resolvedEntryFilePath);
+            if (!this.shouldBroadcastLoaderInvalidation(changeEvent == null ? void 0 : changeEvent.changeId)) {
+                return;
             }
+            if (typeof globalThis.__c === 'function') {
+                globalThis.__c();
+            }
+            this.broadcastMessage('sendDevCommand', {
+                name: 'loader-invalidate',
+                data: {
+                    scope: 'all'
+                }
+            });
+        };
+        const unlisten = deltaBundler.listen(graph, onChange);
+        this.loaderGraphListeners.set(graphId, unlisten);
+    }
+    shouldBroadcastLoaderInvalidation(changeId) {
+        if (!changeId) {
+            return true;
+        }
+        if (this.pendingLoaderInvalidationChangeIds.has(changeId)) {
+            return false;
         }
+        this.pendingLoaderInvalidationChangeIds.add(changeId);
+        // All listeners for a single filesystem change are dispatched synchronously from one
+        // DeltaCalculator EventEmitter.emit(), so dedupe collisions resolve within microseconds.
+        // The timeout exists only to bound memory: without it, this Set would accumulate one entry
+        // per change for the lifetime of the dev server.
+        setTimeout(()=>{
+            this.pendingLoaderInvalidationChangeIds.delete(changeId);
+        }, 500);
+        return true;
     }
     // Direct Metro access
     // Emulates the Metro dev server .bundle endpoint without having to go through a server.
@@ -1447,13 +1556,14 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
             type: 'bundle_build_started'
         });
         try {
+            var _transformOptions_customTransformOptions;
             let delta;
             let revision;
             try {
-                var _transformOptions_customTransformOptions;
+                var _transformOptions_customTransformOptions1;
                 // TODO: Some bug in Metro/RSC causes this to break when changing imports in server components.
                 // We should resolve the bug because it results in ~6x faster bundling to reuse the graph revision.
-                if (((_transformOptions_customTransformOptions = transformOptions.customTransformOptions) == null ? void 0 : _transformOptions_customTransformOptions.environment) === 'react-server') {
+                if (((_transformOptions_customTransformOptions1 = transformOptions.customTransformOptions) == null ? void 0 : _transformOptions_customTransformOptions1.environment) === 'react-server') {
                     const props = await this.metro.getBundler().initializeGraph(// NOTE: Using absolute path instead of relative input path is a breaking change.
                     // entryFile,
                     resolvedEntryFilePath, transformOptions, resolverOptions, {
@@ -1479,6 +1589,9 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
                 (0, _metroErrorInterface.dropStackIfContainsCodeFrame)(error);
                 throw error;
             }
+            if (!this.instanceMetroOptions.isExporting && transformOptions.dev !== false && ((_transformOptions_customTransformOptions = transformOptions.customTransformOptions) == null ? void 0 : _transformOptions_customTransformOptions.isLoaderBundle) === 'true') {
+                this.setupLoaderGraphListener(revision.graphId, resolvedEntryFilePath, revision.graph);
+            }
             bundlePerfLogger == null ? void 0 : bundlePerfLogger.annotate({
                 int: {
                     graph_node_count: revision.graph.dependencies.size
@@ -1527,13 +1640,13 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
             let bundleMap = null;
             if (serializerOptions.output === 'static') {
                 try {
-                    var _artifacts_filter_, _artifacts_filter;
+                    var _artifacts_find;
                     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 bundleCode = artifacts.filter((asset)=>asset.type === 'js')[0];
-                    const bundleMap = ((_artifacts_filter = artifacts.filter((asset)=>asset.type === 'map')) == null ? void 0 : (_artifacts_filter_ = _artifacts_filter[0]) == null ? void 0 : _artifacts_filter_.source) ?? '';
+                    const bundleCode = artifacts.find((asset)=>asset.type === 'js');
+                    const bundleMap = ((_artifacts_find = artifacts.find((asset)=>asset.type === 'map')) == null ? void 0 : _artifacts_find.source) ?? '';
                     return {
                         numModifiedFiles: delta.reset ? delta.added.size + revision.prepend.length : delta.added.size + delta.modified.size + delta.deleted.size,
                         lastModifiedDate: revision.date,
@@ -1554,7 +1667,7 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
                 if (serializerOptions.modulesOnly) {
                     prepend = [];
                 }
-                bundleMap = await sourceMapStringAsync([
+                bundleMap = await (0, _sourceMap().sourceMapStringNonBlocking)([
                     //
                     ...prepend,
                     ...this.metro._getSortedModules(graph)
@@ -1610,7 +1723,7 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
         });
     }
     constructor(...args){
-        super(...args), this.metro = null, this.hmrServer = null, this.ssrHmrClients = new Map(), // Set when the server is started.
+        super(...args), this.metro = null, this.hmrServer = null, this.ssrHmrClients = new Map(), this.loaderGraphListeners = new Map(), this.pendingLoaderInvalidationChangeIds = new Set(), // Set when the server is started.
         this.instanceMetroOptions = {}, this.ssrLoadModule = async (filePath, specificOptions = {}, extras = {})=>{
             // NOTE(@kitten): We don't properly initialize the server-side modules
             // Instead, we first load an entrypoint with an empty bundle to initialize the runtime instead
@@ -1624,13 +1737,13 @@ class MetroBundlerDevServer extends _BundlerDevServer.BundlerDevServer {
             extras.hot && this.instanceMetroOptions.isExporting !== true) {
                 // Register SSR HMR
                 const serverRoot = (0, _paths().getMetroServerRoot)(this.projectRoot);
-                const relativePath = _path().default.relative(serverRoot, res.filename);
+                const relativePath = (0, _filePath.toPosixPath)(_path().default.relative(serverRoot, res.filename));
                 const url = new URL(relativePath, this.getDevServerUrlOrAssert());
                 this.setupHmr(url);
             }
-            return (0, _getStaticRenderFunctions.evalMetroAndWrapFunctions)(this.projectRoot, res.src, res.filename, specificOptions.isExporting ?? this.instanceMetroOptions.isExporting);
+            return (0, _getStaticRenderFunctions.evalMetroAndWrapFunctions)(this.projectRoot, res.src, res.filename, res.map, specificOptions.isExporting ?? this.instanceMetroOptions.isExporting);
         }, this.rscRenderer = null, this.onReloadRscEvent = null, // API Routes
-        this.pendingRouteOperations = new Map(), this.watchedLoaderFiles = new Set();
+        this.pendingRouteOperations = new Map();
     }
 }
 function getBuildID(buildNumber) {
@@ -1642,13 +1755,31 @@ function wrapBundle(str) {
     // 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
-    });
-}
 function unique(array) {
     return Array.from(new Set(array));
 }
+function getStreamingCssAssetsFromSerialAssets(resources) {
+    const cssHrefs = [];
+    const externalCss = [];
+    const inlineCss = [];
+    for (const asset of resources){
+        if (asset.type === 'css') {
+            inlineCss.push({
+                source: asset.source,
+                hmrId: asset.metadata.hmrId
+            });
+        } else if (asset.type === 'css-external') {
+            externalCss.push({
+                href: asset.filename,
+                media: asset.metadata.media
+            });
+        }
+    }
+    return {
+        cssHrefs,
+        externalCss,
+        inlineCss
+    };
+}
 
 //# sourceMappingURL=MetroBundlerDevServer.js.map