@angular-devkit/build-angular 17.0.0-rc.2 → 17.0.0-rc.4

package/src/tools/esbuild/javascript-transformer.js

@@ -20,16 +20,12 @@ const piscina_1 = __importDefault(require("piscina"));
  * and advanced optimizations.
  */
 class JavaScriptTransformer {
+    maxThreads;
     #workerPool;
     #commonOptions;
-    constructor(options, maxThreads) {
-        this.#workerPool = new piscina_1.default({
-            filename: require.resolve('./javascript-transformer-worker'),
-            minThreads: 1,
-            maxThreads,
-            // Shutdown idle threads after 1 second of inactivity
-            idleTimeout: 1000,
-        });
+    #pendingfileResults;
+    constructor(options, maxThreads, reuseResults) {
+        this.maxThreads = maxThreads;
         // Extract options to ensure only the named options are serialized and sent to the worker
         const { sourcemap, thirdPartySourcemaps = false, advancedOptimizations = false, jit = false, } = options;
         this.#commonOptions = {
@@ -38,6 +34,20 @@ class JavaScriptTransformer {
             advancedOptimizations,
             jit,
         };
+        // Currently only tracks pending file transform results
+        if (reuseResults) {
+            this.#pendingfileResults = new Map();
+        }
+    }
+    #ensureWorkerPool() {
+        this.#workerPool ??= new piscina_1.default({
+            filename: require.resolve('./javascript-transformer-worker'),
+            minThreads: 1,
+            maxThreads: this.maxThreads,
+            // Shutdown idle threads after 1 second of inactivity
+            idleTimeout: 1000,
+        });
+        return this.#workerPool;
     }
     /**
      * Performs JavaScript transformations on a file from the filesystem.
@@ -47,13 +57,19 @@ class JavaScriptTransformer {
      * @returns A promise that resolves to a UTF-8 encoded Uint8Array containing the result.
      */
     transformFile(filename, skipLinker) {
-        // Always send the request to a worker. Files are almost always from node modules which means
-        // they may need linking. The data is also not yet available to perform most transformation checks.
-        return this.#workerPool.run({
-            filename,
-            skipLinker,
-            ...this.#commonOptions,
-        });
+        const pendingKey = `${!!skipLinker}--${filename}`;
+        let pending = this.#pendingfileResults?.get(pendingKey);
+        if (pending === undefined) {
+            // Always send the request to a worker. Files are almost always from node modules which means
+            // they may need linking. The data is also not yet available to perform most transformation checks.
+            pending = this.#ensureWorkerPool().run({
+                filename,
+                skipLinker,
+                ...this.#commonOptions,
+            });
+            this.#pendingfileResults?.set(pendingKey, pending);
+        }
+        return pending;
     }
     /**
      * Performs JavaScript transformations on the provided data of a file. The file does not need
@@ -71,7 +87,7 @@ class JavaScriptTransformer {
                 (!!this.#commonOptions.thirdPartySourcemaps || !/[\\/]node_modules[\\/]/.test(filename));
             return Buffer.from(keepSourcemap ? data : data.replace(/^\/\/# sourceMappingURL=[^\r\n]*/gm, ''), 'utf-8');
         }
-        return this.#workerPool.run({
+        return this.#ensureWorkerPool().run({
             filename,
             data,
             skipLinker,
@@ -82,10 +98,18 @@ class JavaScriptTransformer {
      * Stops all active transformation tasks and shuts down all workers.
      * @returns A void promise that resolves when closing is complete.
      */
-    close() {
-        // Workaround piscina bug where a worker thread will be recreated after destroy to meet the minimum.
-        this.#workerPool.options.minThreads = 0;
-        return this.#workerPool.destroy();
+    async close() {
+        this.#pendingfileResults?.clear();
+        if (this.#workerPool) {
+            // Workaround piscina bug where a worker thread will be recreated after destroy to meet the minimum.
+            this.#workerPool.options.minThreads = 0;
+            try {
+                await this.#workerPool.destroy();
+            }
+            finally {
+                this.#workerPool = undefined;
+            }
+        }
     }
 }
 exports.JavaScriptTransformer = JavaScriptTransformer;

package/src/tools/esbuild/utils.d.ts

@@ -10,7 +10,7 @@ import { BuildOptions, Metafile, OutputFile, PartialMessage } from 'esbuild';
 import { BudgetCalculatorResult } from '../../utils/bundle-calculator';
 import { BuildOutputFile, BuildOutputFileType, InitialFileRecord } from './bundler-context';
 import { BuildOutputAsset } from './bundler-execution-result';
-export declare function logBuildStats(context: BuilderContext, metafile: Metafile, initial: Map<string, InitialFileRecord>, budgetFailures: BudgetCalculatorResult[] | undefined, estimatedTransferSizes?: Map<string, number>): void;
+export declare function logBuildStats(context: BuilderContext, metafile: Metafile, initial: Map<string, InitialFileRecord>, budgetFailures: BudgetCalculatorResult[] | undefined, changedFiles?: Set<string>, estimatedTransferSizes?: Map<string, number>): void;
 export declare function calculateEstimatedTransferSizes(outputFiles: OutputFile[]): Promise<Map<string, number>>;
 export declare function withSpinner<T>(text: string, action: () => T | Promise<T>): Promise<T>;
 export declare function withNoProgress<T>(text: string, action: () => T | Promise<T>): Promise<T>;

package/src/tools/esbuild/utils.js

@@ -46,8 +46,9 @@ const spinner_1 = require("../../utils/spinner");
 const stats_1 = require("../webpack/utils/stats");
 const bundler_context_1 = require("./bundler-context");
 const compressAsync = (0, node_util_1.promisify)(node_zlib_1.brotliCompress);
-function logBuildStats(context, metafile, initial, budgetFailures, estimatedTransferSizes) {
+function logBuildStats(context, metafile, initial, budgetFailures, changedFiles, estimatedTransferSizes) {
     const stats = [];
+    let unchangedCount = 0;
     for (const [file, output] of Object.entries(metafile.outputs)) {
         // Only display JavaScript and CSS files
         if (!file.endsWith('.js') && !file.endsWith('.css')) {
@@ -58,6 +59,11 @@ function logBuildStats(context, metafile, initial, budgetFailures, estimatedTran
         if (output['ng-component']) {
             continue;
         }
+        // Show only changed files if a changed list is provided
+        if (changedFiles && !changedFiles.has(file)) {
+            ++unchangedCount;
+            continue;
+        }
         let name = initial.get(file)?.name;
         if (name === undefined && output.entryPoint) {
             name = node_path_1.default
@@ -70,8 +76,16 @@ function logBuildStats(context, metafile, initial, budgetFailures, estimatedTran
             stats: [file, name ?? '-', output.bytes, estimatedTransferSizes?.get(file) ?? '-'],
         });
     }
-    const tableText = (0, stats_1.generateBuildStatsTable)(stats, true, true, !!estimatedTransferSizes, budgetFailures);
-    context.logger.info('\n' + tableText + '\n');
+    if (stats.length > 0) {
+        const tableText = (0, stats_1.generateBuildStatsTable)(stats, true, unchangedCount === 0, !!estimatedTransferSizes, budgetFailures);
+        context.logger.info('\n' + tableText + '\n');
+    }
+    else if (changedFiles !== undefined) {
+        context.logger.info('\nNo output file changes.\n');
+    }
+    if (unchangedCount > 0) {
+        context.logger.info(`Unchanged output files: ${unchangedCount}`);
+    }
 }
 exports.logBuildStats = logBuildStats;
 async function calculateEstimatedTransferSizes(outputFiles) {
@@ -327,7 +341,7 @@ function transformSupportedBrowsersToTargets(supportedBrowsers) {
     return transformed;
 }
 exports.transformSupportedBrowsersToTargets = transformSupportedBrowsersToTargets;
-const SUPPORTED_NODE_VERSIONS = '>=18.13.0';
+const SUPPORTED_NODE_VERSIONS = '^18.13.0 || >=20.9.0';
 /**
  * Transform supported Node.js versions to esbuild target.
  * @see https://esbuild.github.io/api/#target

package/src/utils/bundle-calculator.js

@@ -228,7 +228,7 @@ class AnyComponentStyleCalculator extends Calculator {
  * Calculate the bytes given a string value.
  */
 function calculateBytes(input, baseline, factor = 1) {
-    const matches = input.match(/^\s*(\d+(?:\.\d+)?)\s*(%|(?:[mM]|[kK]|[gG])?[bB])?\s*$/);
+    const matches = input.trim().match(/^(\d+(?:\.\d+)?)[ \t]*(%|[kmg]?b)?$/i);
     if (!matches) {
         return NaN;
     }

package/src/utils/environment-options.d.ts

@@ -12,3 +12,4 @@ export declare const maxWorkers: number;
 export declare const useParallelTs: boolean;
 export declare const useLegacySass: boolean;
 export declare const debugPerformance: boolean;
+export declare const shouldWatchRoot: boolean;

package/src/utils/environment-options.js

@@ -7,7 +7,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.debugPerformance = exports.useLegacySass = exports.useParallelTs = exports.maxWorkers = exports.allowMinify = exports.shouldBeautify = exports.allowMangle = void 0;
+exports.shouldWatchRoot = exports.debugPerformance = exports.useLegacySass = exports.useParallelTs = exports.maxWorkers = exports.allowMinify = exports.shouldBeautify = exports.allowMangle = void 0;
 const color_1 = require("./color");
 function isDisabled(variable) {
     return variable === '0' || variable.toLowerCase() === 'false';
@@ -68,8 +68,11 @@ exports.allowMinify = debugOptimize.minify;
  */
 const maxWorkersVariable = process.env['NG_BUILD_MAX_WORKERS'];
 exports.maxWorkers = isPresent(maxWorkersVariable) ? +maxWorkersVariable : 4;
+// Default to enabled unless inside a Web Container which currently fails when transferring MessagePort objects
 const parallelTsVariable = process.env['NG_BUILD_PARALLEL_TS'];
-exports.useParallelTs = !isPresent(parallelTsVariable) || !isDisabled(parallelTsVariable);
+exports.useParallelTs = isPresent(parallelTsVariable)
+    ? !isDisabled(parallelTsVariable)
+    : !process.versions.webcontainer;
 const legacySassVariable = process.env['NG_BUILD_LEGACY_SASS'];
 exports.useLegacySass = (() => {
     if (!isPresent(legacySassVariable)) {
@@ -81,3 +84,5 @@ exports.useLegacySass = (() => {
 })();
 const debugPerfVariable = process.env['NG_BUILD_DEBUG_PERF'];
 exports.debugPerformance = isPresent(debugPerfVariable) && isEnabled(debugPerfVariable);
+const watchRootVariable = process.env['NG_BUILD_WATCH_ROOT'];
+exports.shouldWatchRoot = isPresent(watchRootVariable) && isEnabled(watchRootVariable);

package/src/utils/load-esm.js

@@ -8,6 +8,10 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadEsmModule = void 0;
+/**
+ * Lazily compiled dynamic import loader function.
+ */
+let load;
 /**
  * This uses a dynamic import to load a module which may be ESM.
  * CommonJS code can load ESM code via a dynamic import. Unfortunately, TypeScript
@@ -21,6 +25,7 @@ exports.loadEsmModule = void 0;
  * @returns A Promise that resolves to the dynamically imported module.
  */
 function loadEsmModule(modulePath) {
-    return new Function('modulePath', `return import(modulePath);`)(modulePath);
+    load ??= new Function('modulePath', `return import(modulePath);`);
+    return load(modulePath);
 }
 exports.loadEsmModule = loadEsmModule;

package/src/utils/routes-extractor/extractor.d.ts

@@ -11,5 +11,5 @@ interface RouterResult {
     success: boolean;
     redirect: boolean;
 }
-export declare function extractRoutes(bootstrapAppFnOrModule: (() => Promise<ApplicationRef>) | Type<unknown>, document: string, url: string): AsyncIterableIterator<RouterResult>;
+export declare function extractRoutes(bootstrapAppFnOrModule: (() => Promise<ApplicationRef>) | Type<unknown>, document: string): AsyncIterableIterator<RouterResult>;
 export {};

package/src/utils/routes-extractor/extractor.js

@@ -38,11 +38,11 @@ async function* getRoutesFromRouterConfig(routes, compiler, parentInjector, pare
         }
     }
 }
-export async function* extractRoutes(bootstrapAppFnOrModule, document, url) {
+export async function* extractRoutes(bootstrapAppFnOrModule, document) {
     const platformRef = createPlatformFactory(platformCore, 'server', [
         {
             provide: INITIAL_CONFIG,
-            useValue: { document, url },
+            useValue: { document, url: '' },
         },
         {
             provide: ɵConsole,

package/src/utils/server-rendering/esm-in-memory-loader/loader-hooks.d.ts

@@ -5,10 +5,6 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-/**
- * Node.js ESM loader to redirect imports to in memory files.
- * @see: https://nodejs.org/api/esm.html#loaders for more information about loaders.
- */
 export interface ESMInMemoryFileLoaderWorkerData {
     outputFiles: Record<string, string>;
     workspaceRoot: string;

package/src/utils/server-rendering/esm-in-memory-loader/loader-hooks.js

@@ -6,16 +6,24 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.load = exports.resolve = exports.initialize = void 0;
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_crypto_1 = require("node:crypto");
 const node_path_1 = require("node:path");
 const node_url_1 = require("node:url");
 const url_1 = require("url");
 const javascript_transformer_1 = require("../../../tools/esbuild/javascript-transformer");
 const node_18_utils_1 = require("./node-18-utils");
-const TRANSFORMED_FILES = {};
-const CHUNKS_REGEXP = /file:\/\/\/(main\.server|chunk-\w+)\.mjs/;
-let workspaceRootFile;
+/**
+ * Node.js ESM loader to redirect imports to in memory files.
+ * @see: https://nodejs.org/api/esm.html#loaders for more information about loaders.
+ */
+const MEMORY_URL_SCHEME = 'memory://';
+let memoryVirtualRootUrl;
 let outputFiles;
 const javascriptTransformer = new javascript_transformer_1.JavaScriptTransformer(
 // Always enable JIT linking to support applications built with and without AOT.
@@ -24,44 +32,89 @@ const javascriptTransformer = new javascript_transformer_1.JavaScriptTransformer
 { sourcemap: true, jit: true }, 1);
 (0, node_18_utils_1.callInitializeIfNeeded)(initialize);
 function initialize(data) {
-    workspaceRootFile = (0, node_url_1.pathToFileURL)((0, node_path_1.join)(data.workspaceRoot, 'index.mjs')).href;
+    // This path does not actually exist but is used to overlay the in memory files with the
+    // actual filesystem for resolution purposes.
+    // A custom URL schema (such as `memory://`) cannot be used for the resolve output because
+    // the in-memory files may use `import.meta.url` in ways that assume a file URL.
+    // `createRequire` is one example of this usage.
+    memoryVirtualRootUrl = (0, node_url_1.pathToFileURL)((0, node_path_1.join)(data.workspaceRoot, `.angular/prerender-root/${(0, node_crypto_1.randomUUID)()}/`)).href;
     outputFiles = data.outputFiles;
 }
 exports.initialize = initialize;
 function resolve(specifier, context, nextResolve) {
-    if (!isFileProtocol(specifier)) {
-        const normalizedSpecifier = specifier.replace(/^\.\//, '');
-        if (normalizedSpecifier in outputFiles) {
+    // In-memory files loaded from external code will contain a memory scheme
+    if (specifier.startsWith(MEMORY_URL_SCHEME)) {
+        let memoryUrl;
+        try {
+            memoryUrl = new URL(specifier);
+        }
+        catch {
+            node_assert_1.default.fail('External code attempted to use malformed memory scheme: ' + specifier);
+        }
+        // Resolve with a URL based from the virtual filesystem root
+        return {
+            format: 'module',
+            shortCircuit: true,
+            url: new URL(memoryUrl.pathname.slice(1), memoryVirtualRootUrl).href,
+        };
+    }
+    // Use next/default resolve if the parent is not from the virtual root
+    if (!context.parentURL?.startsWith(memoryVirtualRootUrl)) {
+        return nextResolve(specifier, context);
+    }
+    // Check for `./` and `../` relative specifiers
+    const isRelative = specifier[0] === '.' &&
+        (specifier[1] === '/' || (specifier[1] === '.' && specifier[2] === '/'));
+    // Relative specifiers from memory file should be based from the parent memory location
+    if (isRelative) {
+        let specifierUrl;
+        try {
+            specifierUrl = new URL(specifier, context.parentURL);
+        }
+        catch { }
+        if (specifierUrl?.pathname &&
+            Object.hasOwn(outputFiles, specifierUrl.href.slice(memoryVirtualRootUrl.length))) {
             return {
                 format: 'module',
                 shortCircuit: true,
-                // File URLs need to absolute. In Windows these also need to include the drive.
-                // The `/` will be resolved to the drive letter.
-                url: (0, node_url_1.pathToFileURL)('/' + normalizedSpecifier).href,
+                url: specifierUrl.href,
             };
         }
+        node_assert_1.default.fail(`In-memory ESM relative file should always exist: '${context.parentURL}' --> '${specifier}'`);
     }
+    // Update the parent URL to allow for module resolution for the workspace.
+    // This handles bare specifiers (npm packages) and absolute paths.
     // Defer to the next hook in the chain, which would be the
     // Node.js default resolve if this is the last user-specified loader.
-    return nextResolve(specifier, isBundleEntryPointOrChunk(context) ? { ...context, parentURL: workspaceRootFile } : context);
+    return nextResolve(specifier, {
+        ...context,
+        parentURL: new URL('index.js', memoryVirtualRootUrl).href,
+    });
 }
 exports.resolve = resolve;
 async function load(url, context, nextLoad) {
-    if (isFileProtocol(url)) {
+    const { format } = context;
+    // Load the file from memory if the URL is based in the virtual root
+    if (url.startsWith(memoryVirtualRootUrl)) {
+        const source = outputFiles[url.slice(memoryVirtualRootUrl.length)];
+        (0, node_assert_1.default)(source !== undefined, 'Resolved in-memory ESM file should always exist: ' + url);
+        // In-memory files have already been transformer during bundling and can be returned directly
+        return {
+            format,
+            shortCircuit: true,
+            source,
+        };
+    }
+    // Only module files potentially require transformation. Angular libraries that would
+    // need linking are ESM only.
+    if (format === 'module' && isFileProtocol(url)) {
         const filePath = (0, url_1.fileURLToPath)(url);
-        // Remove '/' or drive letter for Windows that was added in the above 'resolve'.
-        let source = outputFiles[(0, node_path_1.relative)('/', filePath)] ?? TRANSFORMED_FILES[filePath];
-        if (source === undefined) {
-            source = TRANSFORMED_FILES[filePath] = Buffer.from(await javascriptTransformer.transformFile(filePath)).toString('utf-8');
-        }
-        if (source !== undefined) {
-            const { format } = context;
-            return {
-                format,
-                shortCircuit: true,
-                source,
-            };
-        }
+        const source = await javascriptTransformer.transformFile(filePath);
+        return {
+            format,
+            shortCircuit: true,
+            source,
+        };
     }
     // Let Node.js handle all other URLs.
     return nextLoad(url);
@@ -73,9 +126,6 @@ function isFileProtocol(url) {
 function handleProcessExit() {
     void javascriptTransformer.close();
 }
-function isBundleEntryPointOrChunk(context) {
-    return !!context.parentURL && CHUNKS_REGEXP.test(context.parentURL);
-}
 process.once('exit', handleProcessExit);
 process.once('SIGINT', handleProcessExit);
 process.once('uncaughtException', handleProcessExit);

package/src/utils/server-rendering/fetch-patch.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export declare function patchFetchToLoadInMemoryAssets(): void;

package/src/utils/server-rendering/fetch-patch.js

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchFetchToLoadInMemoryAssets = void 0;
+const mrmime_1 = require("mrmime");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const node_worker_threads_1 = require("node:worker_threads");
+const undici_1 = require("undici");
+/**
+ * This is passed as workerData when setting up the worker via the `piscina` package.
+ */
+const { assetFiles } = node_worker_threads_1.workerData;
+const assetsCache = new Map();
+const RESOLVE_PROTOCOL = 'resolve:';
+function patchFetchToLoadInMemoryAssets() {
+    const global = globalThis;
+    const originalFetch = global.fetch;
+    const patchedFetch = async (input, init) => {
+        let url;
+        if (input instanceof URL) {
+            url = input;
+        }
+        else if (typeof input === 'string') {
+            url = new URL(input, RESOLVE_PROTOCOL + '//');
+        }
+        else if (typeof input === 'object' && 'url' in input) {
+            url = new URL(input.url, RESOLVE_PROTOCOL + '//');
+        }
+        else {
+            return originalFetch(input, init);
+        }
+        const { pathname, protocol } = url;
+        if (protocol !== RESOLVE_PROTOCOL || !assetFiles[pathname]) {
+            // Only handle relative requests or files that are in assets.
+            return originalFetch(input, init);
+        }
+        const cachedAsset = assetsCache.get(pathname);
+        if (cachedAsset) {
+            const { content, headers } = cachedAsset;
+            return new undici_1.Response(content, {
+                headers,
+            });
+        }
+        const extension = (0, node_path_1.extname)(pathname);
+        const mimeType = (0, mrmime_1.lookup)(extension);
+        const content = await (0, promises_1.readFile)(assetFiles[pathname]);
+        const headers = mimeType
+            ? {
+                'Content-Type': mimeType,
+            }
+            : undefined;
+        assetsCache.set(pathname, { headers, content });
+        return new undici_1.Response(content, {
+            headers,
+        });
+    };
+    global.fetch = patchedFetch;
+}
+exports.patchFetchToLoadInMemoryAssets = patchFetchToLoadInMemoryAssets;

package/src/utils/server-rendering/prerender.js

@@ -16,7 +16,6 @@ const node_path_1 = require("node:path");
 const piscina_1 = __importDefault(require("piscina"));
 const bundler_context_1 = require("../../tools/esbuild/bundler-context");
 const node_18_utils_1 = require("./esm-in-memory-loader/node-18-utils");
-const prerender_server_1 = require("./prerender-server");
 async function prerenderPages(workspaceRoot, appShellOptions = {}, prerenderOptions = {}, outputFiles, assets, document, sourcemap = false, inlineCriticalCss = false, maxThreads = 1, verbose = false) {
     const outputFilesForWorker = {};
     const serverBundlesSourceMaps = new Map();
@@ -45,37 +44,33 @@ async function prerenderPages(workspaceRoot, appShellOptions = {}, prerenderOpti
         }
     }
     serverBundlesSourceMaps.clear();
-    // Start server to handle HTTP requests to assets.
-    // TODO: consider starting this is a seperate process to avoid any blocks to the main thread.
-    const { address: assetsServerAddress, close: closeAssetsServer } = await (0, prerender_server_1.startServer)(assets);
-    try {
-        // Get routes to prerender
-        const { routes: allRoutes, warnings: routesWarnings } = await getAllRoutes(workspaceRoot, outputFilesForWorker, document, appShellOptions, prerenderOptions, sourcemap, verbose, assetsServerAddress);
-        if (routesWarnings?.length) {
-            warnings.push(...routesWarnings);
-        }
-        if (allRoutes.size < 1) {
-            return {
-                errors,
-                warnings,
-                output: {},
-                prerenderedRoutes: allRoutes,
-            };
-        }
-        // Render routes
-        const { warnings: renderingWarnings, errors: renderingErrors, output, } = await renderPages(sourcemap, allRoutes, maxThreads, workspaceRoot, outputFilesForWorker, inlineCriticalCss, document, assetsServerAddress, appShellOptions);
-        errors.push(...renderingErrors);
-        warnings.push(...renderingWarnings);
+    const assetsReversed = {};
+    for (const { source, destination } of assets) {
+        assetsReversed[addLeadingSlash(destination.replace(/\\/g, node_path_1.posix.sep))] = source;
+    }
+    // Get routes to prerender
+    const { routes: allRoutes, warnings: routesWarnings } = await getAllRoutes(workspaceRoot, outputFilesForWorker, assetsReversed, document, appShellOptions, prerenderOptions, sourcemap, verbose);
+    if (routesWarnings?.length) {
+        warnings.push(...routesWarnings);
+    }
+    if (allRoutes.size < 1) {
         return {
             errors,
             warnings,
-            output,
+            output: {},
             prerenderedRoutes: allRoutes,
         };
     }
-    finally {
-        void closeAssetsServer?.();
-    }
+    // Render routes
+    const { warnings: renderingWarnings, errors: renderingErrors, output, } = await renderPages(sourcemap, allRoutes, maxThreads, workspaceRoot, outputFilesForWorker, assetsReversed, inlineCriticalCss, document, appShellOptions);
+    errors.push(...renderingErrors);
+    warnings.push(...renderingWarnings);
+    return {
+        errors,
+        warnings,
+        output,
+        prerenderedRoutes: allRoutes,
+    };
 }
 exports.prerenderPages = prerenderPages;
 class RoutesSet extends Set {
@@ -83,7 +78,7 @@ class RoutesSet extends Set {
         return super.add(addLeadingSlash(value));
     }
 }
-async function renderPages(sourcemap, allRoutes, maxThreads, workspaceRoot, outputFilesForWorker, inlineCriticalCss, document, baseUrl, appShellOptions) {
+async function renderPages(sourcemap, allRoutes, maxThreads, workspaceRoot, outputFilesForWorker, assetFilesForWorker, inlineCriticalCss, document, appShellOptions) {
     const output = {};
     const warnings = [];
     const errors = [];
@@ -97,9 +92,9 @@ async function renderPages(sourcemap, allRoutes, maxThreads, workspaceRoot, outp
         workerData: {
             workspaceRoot,
             outputFiles: outputFilesForWorker,
+            assetFiles: assetFilesForWorker,
             inlineCriticalCss,
             document,
-            baseUrl,
         },
         execArgv: workerExecArgv,
     });
@@ -139,7 +134,7 @@ async function renderPages(sourcemap, allRoutes, maxThreads, workspaceRoot, outp
         output,
     };
 }
-async function getAllRoutes(workspaceRoot, outputFilesForWorker, document, appShellOptions, prerenderOptions, sourcemap, verbose, assetsServerAddress) {
+async function getAllRoutes(workspaceRoot, outputFilesForWorker, assetFilesForWorker, document, appShellOptions, prerenderOptions, sourcemap, verbose) {
     const { routesFile, discoverRoutes } = prerenderOptions;
     const routes = new RoutesSet();
     const { route: appShellRoute } = appShellOptions;
@@ -165,9 +160,9 @@ async function getAllRoutes(workspaceRoot, outputFilesForWorker, document, appSh
         workerData: {
             workspaceRoot,
             outputFiles: outputFilesForWorker,
+            assetFiles: assetFilesForWorker,
             document,
             verbose,
-            url: assetsServerAddress,
         },
         execArgv: workerExecArgv,
     });

package/src/utils/server-rendering/render-worker.d.ts

@@ -10,11 +10,13 @@ import { RenderResult, ServerContext } from './render-page';
 export interface RenderWorkerData extends ESMInMemoryFileLoaderWorkerData {
     document: string;
     inlineCriticalCss?: boolean;
-    baseUrl: string;
+    assetFiles: Record</** Destination */ string, /** Source */ string>;
 }
 export interface RenderOptions {
     route: string;
     serverContext: ServerContext;
 }
 /** Renders an application based on a provided options. */
-export default function (options: RenderOptions): Promise<RenderResult>;
+declare function render(options: RenderOptions): Promise<RenderResult>;
+declare const _default: typeof render;
+export default _default;

package/src/utils/server-rendering/render-worker.js

@@ -8,19 +8,25 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 const node_worker_threads_1 = require("node:worker_threads");
+const load_esm_1 = require("../load-esm");
+const fetch_patch_1 = require("./fetch-patch");
 const render_page_1 = require("./render-page");
 /**
  * This is passed as workerData when setting up the worker via the `piscina` package.
  */
-const { outputFiles, document, inlineCriticalCss, baseUrl } = node_worker_threads_1.workerData;
+const { outputFiles, document, inlineCriticalCss } = node_worker_threads_1.workerData;
 /** Renders an application based on a provided options. */
-function default_1(options) {
+function render(options) {
     return (0, render_page_1.renderPage)({
         ...options,
-        route: baseUrl + options.route,
         outputFiles,
         document,
         inlineCriticalCss,
+        loadBundle: async (path) => await (0, load_esm_1.loadEsmModule)(new URL(path, 'memory://')),
     });
 }
-exports.default = default_1;
+function initialize() {
+    (0, fetch_patch_1.patchFetchToLoadInMemoryAssets)();
+    return render;
+}
+exports.default = initialize();