@angular/build 18.0.0-next.3

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

@@ -0,0 +1,88 @@
+/**
+ * @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
+ */
+/**
+ * @fileoverview
+ * Provides infrastructure for common caching functionality within the build system.
+ */
+/**
+ * A backing data store for one or more Cache instances.
+ * The interface is intentionally designed to support using a JavaScript
+ * Map instance as a potential cache store.
+ */
+export interface CacheStore<V> {
+    /**
+     * Returns the specified value from the cache store or `undefined` if not found.
+     * @param key The key to retrieve from the store.
+     */
+    get(key: string): V | undefined | Promise<V | undefined>;
+    /**
+     * Returns whether the provided key is present in the cache store.
+     * @param key The key to check from the store.
+     */
+    has(key: string): boolean | Promise<boolean>;
+    /**
+     * Adds a new value to the cache store if the key is not present.
+     * Updates the value for the key if already present.
+     * @param key The key to associate with the value in the cache store.
+     * @param value The value to add to the cache store.
+     */
+    set(key: string, value: V): this | Promise<this>;
+}
+/**
+ * A cache object that allows accessing and storing key/value pairs in
+ * an underlying CacheStore. This class is the primary method for consumers
+ * to use a cache.
+ */
+export declare class Cache<V, S extends CacheStore<V> = CacheStore<V>> {
+    protected readonly store: S;
+    readonly namespace?: string | undefined;
+    constructor(store: S, namespace?: string | undefined);
+    /**
+     * Prefixes a key with the cache namespace if present.
+     * @param key A key string to prefix.
+     * @returns A prefixed key if a namespace is present. Otherwise the provided key.
+     */
+    protected withNamespace(key: string): string;
+    /**
+     * Gets the value associated with a provided key if available.
+     * Otherwise, creates a value using the factory creator function, puts the value
+     * in the cache, and returns the new value.
+     * @param key A key associated with the value.
+     * @param creator A factory function for the value if no value is present.
+     * @returns A value associated with the provided key.
+     */
+    getOrCreate(key: string, creator: () => V | Promise<V>): Promise<V>;
+    /**
+     * Gets the value associated with a provided key if available.
+     * @param key A key associated with the value.
+     * @returns A value associated with the provided key if present. Otherwise, `undefined`.
+     */
+    get(key: string): Promise<V | undefined>;
+    /**
+     * Puts a value in the cache and associates it with the provided key.
+     * If the key is already present, the value is updated instead.
+     * @param key A key associated with the value.
+     * @param value A value to put in the cache.
+     */
+    put(key: string, value: V): Promise<void>;
+}
+/**
+ * A lightweight in-memory cache implementation based on a JavaScript Map object.
+ */
+export declare class MemoryCache<V> extends Cache<V, Map<string, V>> {
+    constructor();
+    /**
+     * Removes all entries from the cache instance.
+     */
+    clear(): void;
+    /**
+     * Provides all the values currently present in the cache instance.
+     * @returns An iterable of all values in the cache.
+     */
+    values(): IterableIterator<V>;
+}

package/src/tools/esbuild/cache.js

@@ -0,0 +1,92 @@
+"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.MemoryCache = exports.Cache = void 0;
+/**
+ * A cache object that allows accessing and storing key/value pairs in
+ * an underlying CacheStore. This class is the primary method for consumers
+ * to use a cache.
+ */
+class Cache {
+    store;
+    namespace;
+    constructor(store, namespace) {
+        this.store = store;
+        this.namespace = namespace;
+    }
+    /**
+     * Prefixes a key with the cache namespace if present.
+     * @param key A key string to prefix.
+     * @returns A prefixed key if a namespace is present. Otherwise the provided key.
+     */
+    withNamespace(key) {
+        if (this.namespace) {
+            return `${this.namespace}:${key}`;
+        }
+        return key;
+    }
+    /**
+     * Gets the value associated with a provided key if available.
+     * Otherwise, creates a value using the factory creator function, puts the value
+     * in the cache, and returns the new value.
+     * @param key A key associated with the value.
+     * @param creator A factory function for the value if no value is present.
+     * @returns A value associated with the provided key.
+     */
+    async getOrCreate(key, creator) {
+        const namespacedKey = this.withNamespace(key);
+        let value = await this.store.get(namespacedKey);
+        if (value === undefined) {
+            value = await creator();
+            await this.store.set(namespacedKey, value);
+        }
+        return value;
+    }
+    /**
+     * Gets the value associated with a provided key if available.
+     * @param key A key associated with the value.
+     * @returns A value associated with the provided key if present. Otherwise, `undefined`.
+     */
+    async get(key) {
+        const value = await this.store.get(this.withNamespace(key));
+        return value;
+    }
+    /**
+     * Puts a value in the cache and associates it with the provided key.
+     * If the key is already present, the value is updated instead.
+     * @param key A key associated with the value.
+     * @param value A value to put in the cache.
+     */
+    async put(key, value) {
+        await this.store.set(this.withNamespace(key), value);
+    }
+}
+exports.Cache = Cache;
+/**
+ * A lightweight in-memory cache implementation based on a JavaScript Map object.
+ */
+class MemoryCache extends Cache {
+    constructor() {
+        super(new Map());
+    }
+    /**
+     * Removes all entries from the cache instance.
+     */
+    clear() {
+        this.store.clear();
+    }
+    /**
+     * Provides all the values currently present in the cache instance.
+     * @returns An iterable of all values in the cache.
+     */
+    values() {
+        return this.store.values();
+    }
+}
+exports.MemoryCache = MemoryCache;

package/src/tools/esbuild/commonjs-checker.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @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
+ */
+import type { Metafile, PartialMessage } from 'esbuild';
+/**
+ * Checks the input files of a build to determine if any of the files included
+ * in the build are not ESM. ESM files can be tree-shaken and otherwise optimized
+ * in ways that CommonJS and other module formats cannot. The esbuild metafile
+ * information is used as the basis for the analysis as it contains information
+ * for each input file including its respective format.
+ *
+ * If any allowed dependencies are provided via the `allowedCommonJsDependencies`
+ * parameter, both the direct import and any deep imports will be ignored and no
+ * diagnostic will be generated. Use `'*'` as entry to skip the check.
+ *
+ * If a module has been issued a diagnostic message, then all descendant modules
+ * will not be checked. This prevents a potential massive amount of inactionable
+ * messages since the initial module import is the cause of the problem.
+ *
+ * @param metafile An esbuild metafile object to check.
+ * @param allowedCommonJsDependencies An optional list of allowed dependencies.
+ * @returns Zero or more diagnostic messages for any non-ESM modules.
+ */
+export declare function checkCommonJSModules(metafile: Metafile, allowedCommonJsDependencies?: string[]): PartialMessage[];

package/src/tools/esbuild/commonjs-checker.js

@@ -0,0 +1,151 @@
+"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.checkCommonJSModules = void 0;
+/**
+ * Checks the input files of a build to determine if any of the files included
+ * in the build are not ESM. ESM files can be tree-shaken and otherwise optimized
+ * in ways that CommonJS and other module formats cannot. The esbuild metafile
+ * information is used as the basis for the analysis as it contains information
+ * for each input file including its respective format.
+ *
+ * If any allowed dependencies are provided via the `allowedCommonJsDependencies`
+ * parameter, both the direct import and any deep imports will be ignored and no
+ * diagnostic will be generated. Use `'*'` as entry to skip the check.
+ *
+ * If a module has been issued a diagnostic message, then all descendant modules
+ * will not be checked. This prevents a potential massive amount of inactionable
+ * messages since the initial module import is the cause of the problem.
+ *
+ * @param metafile An esbuild metafile object to check.
+ * @param allowedCommonJsDependencies An optional list of allowed dependencies.
+ * @returns Zero or more diagnostic messages for any non-ESM modules.
+ */
+function checkCommonJSModules(metafile, allowedCommonJsDependencies) {
+    const messages = [];
+    const allowedRequests = new Set(allowedCommonJsDependencies);
+    if (allowedRequests.has('*')) {
+        return messages;
+    }
+    // Ignore Angular locale definitions which are currently UMD
+    allowedRequests.add('@angular/common/locales');
+    // Ignore zone.js due to it currently being built with a UMD like structure.
+    // Once the build output is updated to be fully ESM, this can be removed.
+    allowedRequests.add('zone.js');
+    // Used by '@angular/platform-server' and is in a seperate chunk that is unused when
+    // using `provideHttpClient(withFetch())`.
+    allowedRequests.add('xhr2');
+    // Packages used by @angular/ssr.
+    // While critters is ESM it has a number of direct and transtive CJS deps.
+    allowedRequests.add('express');
+    allowedRequests.add('critters');
+    // Find all entry points that contain code (JS/TS)
+    const files = [];
+    for (const { entryPoint } of Object.values(metafile.outputs)) {
+        if (!entryPoint) {
+            continue;
+        }
+        if (!isPathCode(entryPoint)) {
+            continue;
+        }
+        files.push(entryPoint);
+    }
+    // Track seen files so they are only analyzed once.
+    // Bundler runtime code is also ignored since it cannot be actionable.
+    const seenFiles = new Set(['<runtime>']);
+    // Analyze the files present by walking the import graph
+    let currentFile;
+    while ((currentFile = files.shift())) {
+        const input = metafile.inputs[currentFile];
+        for (const imported of input.imports) {
+            // Ignore imports that were already seen or not originally in the code (bundler injected)
+            if (!imported.original || seenFiles.has(imported.path)) {
+                continue;
+            }
+            seenFiles.add(imported.path);
+            // If the dependency is allowed ignore all other checks
+            if (allowedRequests.has(imported.original)) {
+                continue;
+            }
+            // Only check actual code files
+            if (!isPathCode(imported.path)) {
+                continue;
+            }
+            // Check if non-relative import is ESM format and issue a diagnostic if the file is not allowed
+            if (!isPotentialRelative(imported.original) &&
+                metafile.inputs[imported.path].format !== 'esm') {
+                const request = imported.original;
+                let notAllowed = true;
+                if (allowedRequests.has(request)) {
+                    notAllowed = false;
+                }
+                else {
+                    // Check for deep imports of allowed requests
+                    for (const allowed of allowedRequests) {
+                        if (request.startsWith(allowed + '/')) {
+                            notAllowed = false;
+                            break;
+                        }
+                    }
+                }
+                if (notAllowed) {
+                    // Issue a diagnostic message for CommonJS module
+                    messages.push(createCommonJSModuleError(request, currentFile));
+                }
+                // Skip all descendants since they are also most likely not ESM but solved by addressing this import
+                continue;
+            }
+            // Add the path so that its imports can be checked
+            files.push(imported.path);
+        }
+    }
+    return messages;
+}
+exports.checkCommonJSModules = checkCommonJSModules;
+/**
+ * Determines if a file path has an extension that is a JavaScript or TypeScript
+ * code file.
+ *
+ * @param name A path to check for code file extensions.
+ * @returns True, if a code file path; false, otherwise.
+ */
+function isPathCode(name) {
+    return /\.[cm]?[jt]sx?$/.test(name);
+}
+/**
+ * Test an import module specifier to determine if the string potentially references a relative file.
+ * npm packages should not start with a period so if the first character is a period than it is not a
+ * package. While this is sufficient for the use case in the CommmonJS checker, only checking the
+ * first character does not definitely indicate the specifier is a relative path.
+ *
+ * @param specifier An import module specifier.
+ * @returns True, if specifier is potentially relative; false, otherwise.
+ */
+function isPotentialRelative(specifier) {
+    return specifier[0] === '.';
+}
+/**
+ * Creates an esbuild diagnostic message for a given non-ESM module request.
+ *
+ * @param request The requested non-ESM module name.
+ * @param importer The path of the file containing the import.
+ * @returns A message representing the diagnostic.
+ */
+function createCommonJSModuleError(request, importer) {
+    const error = {
+        text: `Module '${request}' used by '${importer}' is not ESM`,
+        notes: [
+            {
+                text: 'CommonJS or AMD dependencies can cause optimization bailouts.\n' +
+                    'For more information see: https://angular.io/guide/build#configuring-commonjs-dependencies',
+            },
+        ],
+    };
+    return error;
+}

package/src/tools/esbuild/compiler-plugin-options.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @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
+ */
+import { NormalizedApplicationBuildOptions } from '../../builders/application/options';
+import type { createCompilerPlugin } from './angular/compiler-plugin';
+import type { SourceFileCache } from './angular/source-file-cache';
+type CreateCompilerPluginParameters = Parameters<typeof createCompilerPlugin>;
+export declare function createCompilerPluginOptions(options: NormalizedApplicationBuildOptions, target: string[], sourceFileCache?: SourceFileCache): {
+    pluginOptions: CreateCompilerPluginParameters[0];
+    styleOptions: CreateCompilerPluginParameters[1];
+};
+export {};

package/src/tools/esbuild/compiler-plugin-options.js

@@ -0,0 +1,49 @@
+"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.createCompilerPluginOptions = void 0;
+function createCompilerPluginOptions(options, target, sourceFileCache) {
+    const { workspaceRoot, optimizationOptions, sourcemapOptions, tsconfig, outputNames, fileReplacements, externalDependencies, preserveSymlinks, stylePreprocessorOptions, advancedOptimizations, inlineStyleLanguage, jit, cacheOptions, tailwindConfiguration, postcssConfiguration, publicPath, } = options;
+    return {
+        // JS/TS options
+        pluginOptions: {
+            sourcemap: !!sourcemapOptions.scripts,
+            thirdPartySourcemaps: sourcemapOptions.vendor,
+            tsconfig,
+            jit,
+            advancedOptimizations,
+            fileReplacements,
+            sourceFileCache,
+            loadResultCache: sourceFileCache?.loadResultCache,
+            incremental: !!options.watch,
+        },
+        // Component stylesheet options
+        styleOptions: {
+            workspaceRoot,
+            inlineFonts: !!optimizationOptions.fonts.inline,
+            optimization: !!optimizationOptions.styles.minify,
+            sourcemap: 
+            // Hidden component stylesheet sourcemaps are inaccessible which is effectively
+            // the same as being disabled. Disabling has the advantage of avoiding the overhead
+            // of sourcemap processing.
+            sourcemapOptions.styles && !sourcemapOptions.hidden ? 'linked' : false,
+            outputNames,
+            includePaths: stylePreprocessorOptions?.includePaths,
+            externalDependencies,
+            target,
+            inlineStyleLanguage,
+            preserveSymlinks,
+            tailwindConfiguration,
+            postcssConfiguration,
+            cacheOptions,
+            publicPath,
+        },
+    };
+}
+exports.createCompilerPluginOptions = createCompilerPluginOptions;

package/src/tools/esbuild/external-packages-plugin.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @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
+ */
+import type { Plugin } from 'esbuild';
+/**
+ * Creates a plugin that marks any resolved path as external if it is within a node modules directory.
+ * This is used instead of the esbuild `packages` option to avoid marking files that should be loaded
+ * via customized loaders. This is necessary to prevent Vite development server pre-bundling errors.
+ *
+ * @returns An esbuild plugin.
+ */
+export declare function createExternalPackagesPlugin(options?: {
+    exclude?: string[];
+}): Plugin;

package/src/tools/esbuild/external-packages-plugin.js

@@ -0,0 +1,70 @@
+"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.createExternalPackagesPlugin = void 0;
+const node_path_1 = require("node:path");
+const EXTERNAL_PACKAGE_RESOLUTION = Symbol('EXTERNAL_PACKAGE_RESOLUTION');
+/**
+ * Creates a plugin that marks any resolved path as external if it is within a node modules directory.
+ * This is used instead of the esbuild `packages` option to avoid marking files that should be loaded
+ * via customized loaders. This is necessary to prevent Vite development server pre-bundling errors.
+ *
+ * @returns An esbuild plugin.
+ */
+function createExternalPackagesPlugin(options) {
+    const exclusions = options?.exclude?.length ? new Set(options.exclude) : undefined;
+    return {
+        name: 'angular-external-packages',
+        setup(build) {
+            const loaderOptionKeys = build.initialOptions.loader && Object.keys(build.initialOptions.loader);
+            // Safe to use native packages external option if no loader options or exclusions present
+            if (!exclusions && !loaderOptionKeys?.length) {
+                build.initialOptions.packages = 'external';
+                return;
+            }
+            const loaderFileExtensions = new Set(loaderOptionKeys);
+            // Only attempt resolve of non-relative and non-absolute paths
+            build.onResolve({ filter: /^[^./]/ }, async (args) => {
+                if (args.pluginData?.[EXTERNAL_PACKAGE_RESOLUTION]) {
+                    return null;
+                }
+                if (exclusions?.has(args.path)) {
+                    return null;
+                }
+                const { importer, kind, resolveDir, namespace, pluginData = {} } = args;
+                pluginData[EXTERNAL_PACKAGE_RESOLUTION] = true;
+                const result = await build.resolve(args.path, {
+                    importer,
+                    kind,
+                    namespace,
+                    pluginData,
+                    resolveDir,
+                });
+                // Return result if unable to resolve or explicitly marked external (externalDependencies option)
+                if (!result.path || result.external) {
+                    return result;
+                }
+                // Allow customized loaders to run against configured paths regardless of location
+                if (loaderFileExtensions.has((0, node_path_1.extname)(result.path))) {
+                    return result;
+                }
+                // Mark paths from a node modules directory as external
+                if (/[\\/]node_modules[\\/]/.test(result.path)) {
+                    return {
+                        path: args.path,
+                        external: true,
+                    };
+                }
+                // Otherwise return original result
+                return result;
+            });
+        },
+    };
+}
+exports.createExternalPackagesPlugin = createExternalPackagesPlugin;

package/src/tools/esbuild/global-scripts.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @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
+ */
+import type { NormalizedApplicationBuildOptions } from '../../builders/application/options';
+import { BundlerOptionsFactory } from './bundler-context';
+/**
+ * Create an esbuild 'build' options object for all global scripts defined in the user provied
+ * build options.
+ * @param options The builder's user-provider normalized options.
+ * @returns An esbuild BuildOptions object.
+ */
+export declare function createGlobalScriptsBundleOptions(options: NormalizedApplicationBuildOptions, target: string[], initial: boolean): BundlerOptionsFactory | undefined;

package/src/tools/esbuild/global-scripts.js

@@ -0,0 +1,142 @@
+"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
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGlobalScriptsBundleOptions = void 0;
+const magic_string_1 = __importStar(require("magic-string"));
+const node_assert_1 = __importDefault(require("node:assert"));
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const error_1 = require("../../utils/error");
+const load_result_cache_1 = require("./load-result-cache");
+const sourcemap_ignorelist_plugin_1 = require("./sourcemap-ignorelist-plugin");
+const virtual_module_plugin_1 = require("./virtual-module-plugin");
+/**
+ * Create an esbuild 'build' options object for all global scripts defined in the user provied
+ * build options.
+ * @param options The builder's user-provider normalized options.
+ * @returns An esbuild BuildOptions object.
+ */
+function createGlobalScriptsBundleOptions(options, target, initial) {
+    const { globalScripts, optimizationOptions, outputNames, preserveSymlinks, sourcemapOptions, jsonLogs, workspaceRoot, } = options;
+    const namespace = 'angular:script/global';
+    const entryPoints = {};
+    let found = false;
+    for (const script of globalScripts) {
+        if (script.initial === initial) {
+            found = true;
+            entryPoints[script.name] = `${namespace}:${script.name}`;
+        }
+    }
+    // Skip if there are no entry points for the style loading type
+    if (found === false) {
+        return;
+    }
+    return (loadCache) => {
+        return {
+            absWorkingDir: workspaceRoot,
+            bundle: false,
+            splitting: false,
+            entryPoints,
+            entryNames: initial ? outputNames.bundles : '[name]',
+            assetNames: outputNames.media,
+            mainFields: ['script', 'browser', 'main'],
+            conditions: ['script'],
+            resolveExtensions: ['.mjs', '.js'],
+            logLevel: options.verbose && !jsonLogs ? 'debug' : 'silent',
+            metafile: true,
+            minify: optimizationOptions.scripts,
+            outdir: workspaceRoot,
+            sourcemap: sourcemapOptions.scripts && (sourcemapOptions.hidden ? 'external' : true),
+            write: false,
+            platform: 'neutral',
+            target,
+            preserveSymlinks,
+            plugins: [
+                (0, sourcemap_ignorelist_plugin_1.createSourcemapIgnorelistPlugin)(),
+                (0, virtual_module_plugin_1.createVirtualModulePlugin)({
+                    namespace,
+                    external: true,
+                    // Add the `js` extension here so that esbuild generates an output file with the extension
+                    transformPath: (path) => path.slice(namespace.length + 1) + '.js',
+                    loadContent: (args, build) => (0, load_result_cache_1.createCachedLoad)(loadCache, async (args) => {
+                        const files = globalScripts.find(({ name }) => name === args.path.slice(0, -3))?.files;
+                        (0, node_assert_1.default)(files, `Invalid operation: global scripts name not found [${args.path}]`);
+                        // Global scripts are concatenated using magic-string instead of bundled via esbuild.
+                        const bundleContent = new magic_string_1.Bundle();
+                        const watchFiles = [];
+                        for (const filename of files) {
+                            let fileContent;
+                            try {
+                                // Attempt to read as a relative path from the workspace root
+                                const fullPath = node_path_1.default.join(workspaceRoot, filename);
+                                fileContent = await (0, promises_1.readFile)(fullPath, 'utf-8');
+                                watchFiles.push(fullPath);
+                            }
+                            catch (e) {
+                                (0, error_1.assertIsError)(e);
+                                if (e.code !== 'ENOENT') {
+                                    throw e;
+                                }
+                                // If not found, attempt to resolve as a module specifier
+                                const resolveResult = await build.resolve(filename, {
+                                    kind: 'entry-point',
+                                    resolveDir: workspaceRoot,
+                                });
+                                if (resolveResult.errors.length) {
+                                    // Remove resolution failure notes about marking as external since it doesn't apply
+                                    // to global scripts.
+                                    resolveResult.errors.forEach((error) => (error.notes = []));
+                                    return {
+                                        errors: resolveResult.errors,
+                                        warnings: resolveResult.warnings,
+                                    };
+                                }
+                                watchFiles.push(resolveResult.path);
+                                fileContent = await (0, promises_1.readFile)(resolveResult.path, 'utf-8');
+                            }
+                            bundleContent.addSource(new magic_string_1.default(fileContent, { filename }));
+                        }
+                        return {
+                            contents: bundleContent.toString(),
+                            loader: 'js',
+                            watchFiles,
+                        };
+                    }).call(build, args),
+                }),
+            ],
+        };
+    };
+}
+exports.createGlobalScriptsBundleOptions = createGlobalScriptsBundleOptions;