@embroider/compat 3.5.2-unstable.9f1e74e → 3.5.2

package/src/compat-app-builder.js

@@ -1,46 +1,78 @@
 "use strict";
+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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+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.CompatAppBuilder = void 0;
 const core_1 = require("@embroider/core");
+const walk_sync_1 = __importDefault(require("walk-sync"));
 const path_1 = require("path");
 const dependency_rules_1 = require("./dependency-rules");
 const flatMap_1 = __importDefault(require("lodash/flatMap"));
+const sortBy_1 = __importDefault(require("lodash/sortBy"));
+const flatten_1 = __importDefault(require("lodash/flatten"));
+const partition_1 = __importDefault(require("lodash/partition"));
 const mergeWith_1 = __importDefault(require("lodash/mergeWith"));
 const cloneDeep_1 = __importDefault(require("lodash/cloneDeep"));
+const resolve_1 = require("resolve");
 const bind_decorator_1 = __importDefault(require("bind-decorator"));
 const fs_extra_1 = require("fs-extra");
+const ember_html_1 = require("@embroider/core/src/ember-html");
 const portable_babel_config_1 = require("@embroider/core/src/portable-babel-config");
 const app_files_1 = require("@embroider/core/src/app-files");
 const portable_1 = require("@embroider/core/src/portable");
+const assert_never_1 = __importDefault(require("assert-never"));
 const typescript_memoize_1 = require("typescript-memoize");
 const path_2 = require("path");
-const resolve_1 = __importDefault(require("resolve"));
+const resolve_2 = __importDefault(require("resolve"));
 const fs_extra_2 = require("fs-extra");
 const node_1 = require("@embroider/macros/src/node");
+const fast_sourcemap_concat_1 = __importDefault(require("fast-sourcemap-concat"));
 const escape_string_regexp_1 = __importDefault(require("escape-string-regexp"));
 const sync_dir_1 = require("./sync-dir");
 // This exists during the actual broccoli build step. As opposed to CompatApp,
 // which also exists during pipeline-construction time.
 class CompatAppBuilder {
-    constructor(root, origAppPackage, appPackageWithMovedDeps, options, compatApp, configTree, contentForTree, synthVendor, synthStyles) {
+    constructor(root, origAppPackage, appPackageWithMovedDeps, options, compatApp, configTree, synthVendor, synthStyles) {
         this.root = root;
         this.origAppPackage = origAppPackage;
         this.appPackageWithMovedDeps = appPackageWithMovedDeps;
         this.options = options;
         this.compatApp = compatApp;
         this.configTree = configTree;
-        this.contentForTree = contentForTree;
         this.synthVendor = synthVendor;
         this.synthStyles = synthStyles;
+        // for each relativePath, an Asset we have already emitted
+        this.assets = new Map();
         this.firstBuild = true;
     }
     fastbootJSSrcDir() {
@@ -49,6 +81,54 @@ class CompatAppBuilder {
             return target;
         }
     }
+    extractAssets(treePaths) {
+        let assets = [];
+        // Everything in our traditional public tree is an on-disk asset
+        if (treePaths.publicTree) {
+            walk_sync_1.default
+                .entries(treePaths.publicTree, {
+                directories: false,
+            })
+                .forEach(entry => {
+                assets.push({
+                    kind: 'on-disk',
+                    relativePath: entry.relativePath,
+                    sourcePath: entry.fullPath,
+                    mtime: entry.mtime,
+                    size: entry.size,
+                });
+            });
+        }
+        // ember-cli traditionally outputs a dummy testem.js file to prevent
+        // spurious errors when running tests under "ember s".
+        if (this.compatApp.shouldBuildTests) {
+            let testemAsset = this.findTestemAsset();
+            if (testemAsset) {
+                assets.push(testemAsset);
+            }
+        }
+        for (let asset of this.emberEntrypoints(treePaths.htmlTree)) {
+            assets.push(asset);
+        }
+        return assets;
+    }
+    findTestemAsset() {
+        let sourcePath;
+        try {
+            sourcePath = (0, resolve_1.sync)('ember-cli/lib/broccoli/testem.js', { basedir: this.root });
+        }
+        catch (err) { }
+        if (sourcePath) {
+            let stat = (0, fs_extra_1.statSync)(sourcePath);
+            return {
+                kind: 'on-disk',
+                relativePath: 'testem.js',
+                sourcePath,
+                mtime: stat.mtime.getTime(),
+                size: stat.size,
+            };
+        }
+    }
     activeAddonChildren(pkg) {
         let result = pkg.dependencies.filter(this.isActiveAddon).filter(
         // When looking for child addons, we want to ignore 'peerDependencies' of
@@ -97,19 +177,43 @@ class CompatAppBuilder {
         // For TS, we defer to ember-cli-babel, and the setting for
         // "enableTypescriptTransform" can be set with and without
         // ember-cli-typescript
-        return ['.wasm', '.mjs', '.js', '.json', '.ts', '.hbs', '.hbs.js', '.gjs', '.gts'];
+        return ['.wasm', '.mjs', '.js', '.json', '.ts', '.hbs', '.hbs.js'];
     }
-    addEmberEntrypoints(htmlTreePath) {
-        let classicEntrypoints = ['index.html', 'tests/index.html'];
+    *emberEntrypoints(htmlTreePath) {
+        let classicEntrypoints = [
+            { entrypoint: 'index.html', includeTests: false },
+            { entrypoint: 'tests/index.html', includeTests: true },
+        ];
         if (!this.compatApp.shouldBuildTests) {
             classicEntrypoints.pop();
         }
-        for (let entrypoint of classicEntrypoints) {
+        for (let { entrypoint, includeTests } of classicEntrypoints) {
             let sourcePath = (0, path_2.join)(htmlTreePath, entrypoint);
-            let rewrittenAppPath = (0, path_2.join)(this.root, entrypoint);
-            (0, fs_extra_1.writeFileSync)(rewrittenAppPath, (0, fs_extra_1.readFileSync)(sourcePath));
+            let stats = (0, fs_extra_1.statSync)(sourcePath);
+            let asset = {
+                kind: 'ember',
+                relativePath: entrypoint,
+                includeTests,
+                sourcePath,
+                mtime: stats.mtime.getTime(),
+                size: stats.size,
+                rootURL: this.rootURL(),
+                prepare: (dom) => {
+                    let scripts = [...dom.window.document.querySelectorAll('script')];
+                    let styles = [...dom.window.document.querySelectorAll('link[rel*="stylesheet"]')];
+                    return {
+                        javascript: this.compatApp.findAppScript(scripts, entrypoint),
+                        styles: this.compatApp.findAppStyles(styles, entrypoint),
+                        implicitScripts: this.compatApp.findVendorScript(scripts, entrypoint),
+                        implicitStyles: this.compatApp.findVendorStyles(styles, entrypoint),
+                        testJavascript: this.compatApp.findTestScript(scripts),
+                        implicitTestScripts: this.compatApp.findTestSupportScript(scripts),
+                        implicitTestStyles: this.compatApp.findTestSupportStyles(styles),
+                    };
+                },
+            };
+            yield asset;
         }
-        return classicEntrypoints;
     }
     modulePrefix() {
         return this.configTree.readConfig().modulePrefix;
@@ -129,6 +233,10 @@ class CompatAppBuilder {
     resolverConfig(engines) {
         let renamePackages = Object.assign({}, ...this.allActiveAddons.map(dep => dep.meta['renamed-packages']));
         let renameModules = Object.assign({}, ...this.allActiveAddons.map(dep => dep.meta['renamed-modules']));
+        let activeAddons = {};
+        for (let addon of this.allActiveAddons) {
+            activeAddons[addon.name] = addon.root;
+        }
         let options = {
             staticHelpers: this.options.staticHelpers,
             staticModifiers: this.options.staticModifiers,
@@ -137,6 +245,7 @@ class CompatAppBuilder {
         };
         let config = {
             // this part is the base ModuleResolverOptions as required by @embroider/core
+            activeAddons,
             renameModules,
             renamePackages,
             resolvableExtensions: this.resolvableExtensions(),
@@ -148,34 +257,118 @@ class CompatAppBuilder {
                 root: (0, fs_extra_1.realpathSync)(index === 0 ? this.root : appFiles.engine.package.root),
                 fastbootFiles: appFiles.fastbootFiles,
                 activeAddons: [...appFiles.engine.addons]
-                    .map(([addon, canResolveFromFile]) => ({
-                    name: addon.name,
-                    root: addon.root,
-                    canResolveFromFile,
+                    .map(a => ({
+                    name: a.name,
+                    root: a.root,
                 }))
                     // the traditional order is the order in which addons will run, such
                     // that the last one wins. Our resolver's order is the order to
                     // search, so first one wins.
                     .reverse(),
-                isLazy: appFiles.engine.package.isLazyEngine(),
             })),
             amdCompatibility: this.options.amdCompatibility,
             // this is the additional stufff that @embroider/compat adds on top to do
             // global template resolving
             modulePrefix: this.modulePrefix(),
-            splitAtRoutes: this.options.splitAtRoutes,
             podModulePrefix: this.podModulePrefix(),
             activePackageRules: this.activeRules(),
             options,
-            autoRun: this.compatApp.autoRun,
-            staticAppPaths: this.options.staticAppPaths,
         };
         return config;
     }
+    scriptPriority(pkg) {
+        switch (pkg.name) {
+            case 'loader.js':
+                return 0;
+            case 'ember-source':
+                return 10;
+            default:
+                return 1000;
+        }
+    }
     get resolvableExtensionsPattern() {
         return (0, core_1.extensionsPattern)(this.resolvableExtensions());
     }
-    async babelConfig(resolverConfig) {
+    impliedAssets(type, engine, emberENV) {
+        let result = this.impliedAddonAssets(type, engine).map((sourcePath) => {
+            let stats = (0, fs_extra_1.statSync)(sourcePath);
+            return {
+                kind: 'on-disk',
+                relativePath: (0, core_1.explicitRelative)(this.root, sourcePath),
+                sourcePath,
+                mtime: stats.mtimeMs,
+                size: stats.size,
+            };
+        });
+        if (type === 'implicit-scripts') {
+            result.unshift({
+                kind: 'in-memory',
+                relativePath: '_testing_prefix_.js',
+                source: `var runningTests=false;`,
+            });
+            result.unshift({
+                kind: 'in-memory',
+                relativePath: '_ember_env_.js',
+                source: `window.EmberENV={ ...(window.EmberENV || {}), ...${JSON.stringify(emberENV, null, 2)} };`,
+            });
+            result.push({
+                kind: 'in-memory',
+                relativePath: '_loader_.js',
+                source: `loader.makeDefaultExport=false;`,
+            });
+        }
+        if (type === 'implicit-test-scripts') {
+            // this is the traditional test-support-suffix.js
+            result.push({
+                kind: 'in-memory',
+                relativePath: '_testing_suffix_.js',
+                source: `
+        var runningTests=true;
+        if (typeof Testem !== 'undefined' && (typeof QUnit !== 'undefined' || typeof Mocha !== 'undefined')) {
+          Testem.hookIntoTestFramework();
+        }`,
+            });
+            // whether or not anybody was actually using @embroider/macros
+            // explicitly as an addon, we ensure its test-support file is always
+            // present.
+            if (!result.find(s => s.kind === 'on-disk' && s.sourcePath.endsWith('embroider-macros-test-support.js'))) {
+                result.unshift({
+                    kind: 'on-disk',
+                    sourcePath: require.resolve('@embroider/macros/src/vendor/embroider-macros-test-support'),
+                    mtime: 0,
+                    size: 0,
+                    relativePath: 'embroider-macros-test-support.js',
+                });
+            }
+        }
+        return result;
+    }
+    impliedAddonAssets(type, { engine }) {
+        let result = [];
+        for (let addon of (0, sortBy_1.default)(Array.from(engine.addons), this.scriptPriority.bind(this))) {
+            let implicitScripts = addon.meta[type];
+            if (implicitScripts) {
+                let styles = [];
+                let options = { basedir: addon.root };
+                for (let mod of implicitScripts) {
+                    if (type === 'implicit-styles') {
+                        // exclude engines because they will handle their own css importation
+                        if (!addon.isLazyEngine()) {
+                            styles.push(resolve_2.default.sync(mod, options));
+                        }
+                    }
+                    else {
+                        result.push(resolve_2.default.sync(mod, options));
+                    }
+                }
+                if (styles.length) {
+                    result = [...styles, ...result];
+                }
+            }
+        }
+        return result;
+    }
+    babelConfig(resolverConfig) {
         let babel = (0, cloneDeep_1.default)(this.compatApp.babelConfig());
         if (!babel.plugins) {
             babel.plugins = [];
@@ -185,10 +378,7 @@ class CompatAppBuilder {
         babel.plugins.push(require.resolve('@babel/plugin-syntax-dynamic-import'));
         // https://github.com/webpack/webpack/issues/12154
         babel.plugins.push(require.resolve('./rename-require-plugin'));
-        babel.plugins.push([
-            require.resolve('babel-plugin-ember-template-compilation'),
-            await this.etcOptions(resolverConfig),
-        ]);
+        babel.plugins.push([require.resolve('babel-plugin-ember-template-compilation'), this.etcOptions(resolverConfig)]);
         // this is @embroider/macros configured for full stage3 resolution
         babel.plugins.push(...this.compatApp.macrosConfig.babelPluginConfig());
         let colocationOptions = {
@@ -240,6 +430,107 @@ class CompatAppBuilder {
         addCachablePlugin(portable.config);
         return portable;
     }
+    insertEmberApp(asset, appFiles, prepared, emberENV) {
+        let html = asset.html;
+        if (this.fastbootConfig) {
+            // ignore scripts like ember-cli-livereload.js which are not really associated with
+            // "the app".
+            let ignoreScripts = html.dom.window.document.querySelectorAll('script');
+            ignoreScripts.forEach(script => {
+                script.setAttribute('data-fastboot-ignore', '');
+            });
+        }
+        // our tests entrypoint already includes a correct module dependency on the
+        // app, so we only insert the app when we're not inserting tests
+        if (!asset.fileAsset.includeTests) {
+            let appJS = this.topAppJSAsset(appFiles, prepared);
+            html.insertScriptTag(html.javascript, appJS.relativePath, { type: 'module' });
+        }
+        if (this.fastbootConfig) {
+            // any extra fastboot app files get inserted into our html.javascript
+            // section, after the app has been inserted.
+            for (let script of this.fastbootConfig.extraAppFiles) {
+                html.insertScriptTag(html.javascript, script, { tag: 'fastboot-script' });
+            }
+        }
+        html.insertStyleLink(html.styles, `assets/${this.origAppPackage.name}.css`);
+        const parentEngine = appFiles.find(e => !e.engine.parent);
+        let vendorJS = this.implicitScriptsAsset(prepared, parentEngine, emberENV);
+        if (vendorJS) {
+            html.insertScriptTag(html.implicitScripts, vendorJS.relativePath);
+        }
+        if (this.fastbootConfig) {
+            // any extra fastboot vendor files get inserted into our
+            // html.implicitScripts section, after the regular implicit script
+            // (vendor.js) have been inserted.
+            for (let script of this.fastbootConfig.extraVendorFiles) {
+                html.insertScriptTag(html.implicitScripts, script, { tag: 'fastboot-script' });
+            }
+        }
+        let implicitStyles = this.implicitStylesAsset(prepared, parentEngine);
+        if (implicitStyles) {
+            html.insertStyleLink(html.implicitStyles, implicitStyles.relativePath);
+        }
+        if (!asset.fileAsset.includeTests) {
+            return;
+        }
+        // Test-related assets happen below this point
+        let testJS = this.testJSEntrypoint(appFiles, prepared);
+        html.insertScriptTag(html.testJavascript, testJS.relativePath, { type: 'module' });
+        let implicitTestScriptsAsset = this.implicitTestScriptsAsset(prepared, parentEngine);
+        if (implicitTestScriptsAsset) {
+            html.insertScriptTag(html.implicitTestScripts, implicitTestScriptsAsset.relativePath);
+        }
+        let implicitTestStylesAsset = this.implicitTestStylesAsset(prepared, parentEngine);
+        if (implicitTestStylesAsset) {
+            html.insertStyleLink(html.implicitTestStyles, implicitTestStylesAsset.relativePath);
+        }
+    }
+    implicitScriptsAsset(prepared, application, emberENV) {
+        let asset = prepared.get('assets/vendor.js');
+        if (!asset) {
+            let implicitScripts = this.impliedAssets('implicit-scripts', application, emberENV);
+            if (implicitScripts.length > 0) {
+                asset = new ConcatenatedAsset('assets/vendor.js', implicitScripts, this.resolvableExtensionsPattern);
+                prepared.set(asset.relativePath, asset);
+            }
+        }
+        return asset;
+    }
+    implicitStylesAsset(prepared, application) {
+        let asset = prepared.get('assets/vendor.css');
+        if (!asset) {
+            let implicitStyles = this.impliedAssets('implicit-styles', application);
+            if (implicitStyles.length > 0) {
+                // we reverse because we want the synthetic vendor style at the top
+                asset = new ConcatenatedAsset('assets/vendor.css', implicitStyles.reverse(), this.resolvableExtensionsPattern);
+                prepared.set(asset.relativePath, asset);
+            }
+        }
+        return asset;
+    }
+    implicitTestScriptsAsset(prepared, application) {
+        let testSupportJS = prepared.get('assets/test-support.js');
+        if (!testSupportJS) {
+            let implicitTestScripts = this.impliedAssets('implicit-test-scripts', application);
+            if (implicitTestScripts.length > 0) {
+                testSupportJS = new ConcatenatedAsset('assets/test-support.js', implicitTestScripts, this.resolvableExtensionsPattern);
+                prepared.set(testSupportJS.relativePath, testSupportJS);
+            }
+        }
+        return testSupportJS;
+    }
+    implicitTestStylesAsset(prepared, application) {
+        let asset = prepared.get('assets/test-support.css');
+        if (!asset) {
+            let implicitTestStyles = this.impliedAssets('implicit-test-styles', application);
+            if (implicitTestStyles.length > 0) {
+                asset = new ConcatenatedAsset('assets/test-support.css', implicitTestStyles, this.resolvableExtensionsPattern);
+                prepared.set(asset.relativePath, asset);
+            }
+        }
+        return asset;
+    }
     // recurse to find all active addons that don't cross an engine boundary.
     // Inner engines themselves will be returned, but not those engines' children.
     // The output set's insertion order is the proper ember-cli compatible
@@ -249,31 +540,22 @@ class CompatAppBuilder {
             if (!child.isEngine()) {
                 this.findActiveAddons(child, engine, true);
             }
-            let canResolveFrom;
-            if (pkg === this.appPackageWithMovedDeps) {
-                // we want canResolveFrom to always be a rewritten package path, and our
-                // app's package is not rewritten yet here.
-                canResolveFrom = (0, path_1.resolve)(this.root, 'package.json');
-            }
-            else {
-                // whereas our addons are already moved
-                canResolveFrom = (0, path_1.resolve)(pkg.root, 'package.json');
-            }
-            engine.addons.set(child, canResolveFrom);
+            engine.addons.add(child);
         }
         // ensure addons are applied in the correct order, if set (via @embroider/compat/v1-addon)
         if (!isChild) {
-            engine.addons = new Map([...engine.addons].sort(([a], [b]) => {
+            engine.addons = new Set([...engine.addons].sort((a, b) => {
                 return (a.meta['order-index'] || 0) - (b.meta['order-index'] || 0);
             }));
         }
     }
-    partitionEngines() {
+    partitionEngines(appJSPath) {
         let queue = [
             {
                 package: this.appPackageWithMovedDeps,
-                addons: new Map(),
-                isApp: true,
+                addons: new Set(),
+                parent: undefined,
+                sourcePath: appJSPath,
                 modulePrefix: this.modulePrefix(),
                 appRelativePath: '.',
             },
@@ -286,13 +568,14 @@ class CompatAppBuilder {
                 break;
             }
             this.findActiveAddons(current.package, current);
-            for (let addon of current.addons.keys()) {
+            for (let addon of current.addons) {
                 if (addon.isEngine() && !seenEngines.has(addon)) {
                     seenEngines.add(addon);
                     queue.push({
                         package: addon,
-                        addons: new Map(),
-                        isApp: !current,
+                        addons: new Set(),
+                        parent: current,
+                        sourcePath: addon.root,
                         modulePrefix: addon.name,
                         appRelativePath: (0, core_1.explicitRelative)(this.root, addon.root),
                     });
@@ -318,8 +601,8 @@ class CompatAppBuilder {
     updateAppJS(appJSPath) {
         var _a;
         if (!this.engines) {
-            this.engines = this.partitionEngines().map(engine => {
-                if (engine.isApp) {
+            this.engines = this.partitionEngines(appJSPath).map(engine => {
+                if (engine.sourcePath === appJSPath) {
                     // this is the app. We have more to do for the app than for other
                     // engines.
                     let fastbootSync;
@@ -341,7 +624,7 @@ class CompatAppBuilder {
                     // their files, not doing any actual copying or building.
                     return {
                         engine,
-                        appSync: new sync_dir_1.SyncDir(engine.package.root, undefined),
+                        appSync: new sync_dir_1.SyncDir(engine.sourcePath, undefined),
                         // AFAIK, we've never supported a fastboot overlay directory in an
                         // engine. But if we do need that, it would go here.
                         fastbootSync: undefined,
@@ -355,13 +638,164 @@ class CompatAppBuilder {
         }
         return this.engines.map(({ engine, appSync, fastbootSync }) => {
             var _a;
-            return new app_files_1.AppFiles(engine, appSync.files, (_a = fastbootSync === null || fastbootSync === void 0 ? void 0 : fastbootSync.files) !== null && _a !== void 0 ? _a : new Set(), this.resolvableExtensionsPattern, this.staticAppPathsPattern, this.podModulePrefix());
+            return new app_files_1.AppFiles(engine, appSync.files, (_a = fastbootSync === null || fastbootSync === void 0 ? void 0 : fastbootSync.files) !== null && _a !== void 0 ? _a : new Set(), this.resolvableExtensionsPattern, this.podModulePrefix());
         });
     }
-    get staticAppPathsPattern() {
-        if (this.options.staticAppPaths.length > 0) {
-            return new RegExp('^(?:' + this.options.staticAppPaths.map(staticAppPath => (0, escape_string_regexp_1.default)(staticAppPath)).join('|') + ')(?:$|/)');
+    prepareAsset(asset, appFiles, prepared, emberENV) {
+        if (asset.kind === 'ember') {
+            let prior = this.assets.get(asset.relativePath);
+            let parsed;
+            if (prior && prior.kind === 'built-ember' && prior.parsedAsset.validFor(asset)) {
+                // we can reuse the parsed html
+                parsed = prior.parsedAsset;
+                parsed.html.clear();
+            }
+            else {
+                parsed = new ParsedEmberAsset(asset);
+            }
+            this.insertEmberApp(parsed, appFiles, prepared, emberENV);
+            prepared.set(asset.relativePath, new BuiltEmberAsset(parsed));
+        }
+        else {
+            prepared.set(asset.relativePath, asset);
+        }
+    }
+    prepareAssets(requestedAssets, appFiles, emberENV) {
+        let prepared = new Map();
+        for (let asset of requestedAssets) {
+            this.prepareAsset(asset, appFiles, prepared, emberENV);
+        }
+        return prepared;
+    }
+    assetIsValid(asset, prior) {
+        if (!prior) {
+            return false;
+        }
+        switch (asset.kind) {
+            case 'on-disk':
+                return prior.kind === 'on-disk' && prior.size === asset.size && prior.mtime === asset.mtime;
+            case 'in-memory':
+                return prior.kind === 'in-memory' && stringOrBufferEqual(prior.source, asset.source);
+            case 'built-ember':
+                return prior.kind === 'built-ember' && prior.source === asset.source;
+            case 'concatenated-asset':
+                return (prior.kind === 'concatenated-asset' &&
+                    prior.sources.length === asset.sources.length &&
+                    prior.sources.every((priorFile, index) => {
+                        let newFile = asset.sources[index];
+                        return this.assetIsValid(newFile, priorFile);
+                    }));
+        }
+    }
+    updateOnDiskAsset(asset) {
+        let destination = (0, path_2.join)(this.root, asset.relativePath);
+        (0, fs_extra_2.ensureDirSync)((0, path_2.dirname)(destination));
+        (0, fs_extra_2.copySync)(asset.sourcePath, destination, { dereference: true });
+    }
+    updateInMemoryAsset(asset) {
+        let destination = (0, path_2.join)(this.root, asset.relativePath);
+        (0, fs_extra_2.ensureDirSync)((0, path_2.dirname)(destination));
+        (0, fs_extra_1.writeFileSync)(destination, asset.source, 'utf8');
+    }
+    updateBuiltEmberAsset(asset) {
+        let destination = (0, path_2.join)(this.root, asset.relativePath);
+        (0, fs_extra_2.ensureDirSync)((0, path_2.dirname)(destination));
+        (0, fs_extra_1.writeFileSync)(destination, asset.source, 'utf8');
+    }
+    async updateConcatenatedAsset(asset) {
+        let concat = new fast_sourcemap_concat_1.default({
+            outputFile: (0, path_2.join)(this.root, asset.relativePath),
+            mapCommentType: asset.relativePath.endsWith('.js') ? 'line' : 'block',
+            baseDir: this.root,
+        });
+        if (process.env.EMBROIDER_CONCAT_STATS) {
+            let MeasureConcat = (await Promise.resolve().then(() => __importStar(require('@embroider/core/src/measure-concat')))).default;
+            concat = new MeasureConcat(asset.relativePath, concat, this.root);
+        }
+        for (let source of asset.sources) {
+            switch (source.kind) {
+                case 'on-disk':
+                    concat.addFile((0, core_1.explicitRelative)(this.root, source.sourcePath));
+                    break;
+                case 'in-memory':
+                    if (typeof source.source !== 'string') {
+                        throw new Error(`attempted to concatenated a Buffer-backed in-memory asset`);
+                    }
+                    concat.addSpace(source.source);
+                    break;
+                default:
+                    (0, assert_never_1.default)(source);
+            }
+        }
+        await concat.end();
+    }
+    async updateAssets(requestedAssets, appFiles, emberENV) {
+        let assets = this.prepareAssets(requestedAssets, appFiles, emberENV);
+        for (let asset of assets.values()) {
+            if (this.assetIsValid(asset, this.assets.get(asset.relativePath))) {
+                continue;
+            }
+            (0, core_1.debug)('rebuilding %s', asset.relativePath);
+            switch (asset.kind) {
+                case 'on-disk':
+                    this.updateOnDiskAsset(asset);
+                    break;
+                case 'in-memory':
+                    this.updateInMemoryAsset(asset);
+                    break;
+                case 'built-ember':
+                    this.updateBuiltEmberAsset(asset);
+                    break;
+                case 'concatenated-asset':
+                    await this.updateConcatenatedAsset(asset);
+                    break;
+                default:
+                    (0, assert_never_1.default)(asset);
+            }
+        }
+        for (let oldAsset of this.assets.values()) {
+            if (!assets.has(oldAsset.relativePath)) {
+                (0, fs_extra_1.unlinkSync)((0, path_2.join)(this.root, oldAsset.relativePath));
+            }
         }
+        this.assets = assets;
+        return [...assets.values()];
+    }
+    gatherAssets(inputPaths) {
+        // first gather all the assets out of addons
+        let assets = [];
+        for (let pkg of this.allActiveAddons) {
+            if (pkg.meta['public-assets']) {
+                for (let [filename, appRelativeURL] of Object.entries(pkg.meta['public-assets'] || {})) {
+                    let sourcePath = (0, path_1.resolve)(pkg.root, filename);
+                    let stats = (0, fs_extra_1.statSync)(sourcePath);
+                    assets.push({
+                        kind: 'on-disk',
+                        sourcePath,
+                        relativePath: appRelativeURL,
+                        mtime: stats.mtimeMs,
+                        size: stats.size,
+                    });
+                }
+            }
+        }
+        if (this.activeFastboot) {
+            const source = `
+      (function(){
+        var key = '_embroider_macros_runtime_config';
+        if (!window[key]){ window[key] = [];}
+        window[key].push(function(m) {
+          m.setGlobalConfig('fastboot', Object.assign({}, m.getGlobalConfig().fastboot, { isRunning: true }));
+        });
+      }())`;
+            assets.push({
+                kind: 'in-memory',
+                source,
+                relativePath: 'assets/embroider_macros_fastboot_init.js',
+            });
+        }
+        // and finally tack on the ones from our app itself
+        return assets.concat(this.extractAssets(inputPaths));
     }
     async build(inputPaths) {
         // on the first build, we lock down the macros config. on subsequent builds,
@@ -373,18 +807,29 @@ class CompatAppBuilder {
             this.firstBuild = false;
         }
         let appFiles = this.updateAppJS(inputPaths.appJS);
-        let assetPaths = this.addEmberEntrypoints(inputPaths.htmlTree);
+        let emberENV = this.configTree.readConfig().EmberENV;
+        let assets = this.gatherAssets(inputPaths);
+        let finalAssets = await this.updateAssets(assets, appFiles, emberENV);
+        let assetPaths = assets.map(asset => asset.relativePath);
         if (this.activeFastboot) {
             // when using fastboot, our own package.json needs to be in the output so fastboot can read it.
             assetPaths.push('package.json');
         }
+        for (let asset of finalAssets) {
+            // our concatenated assets all have map files that ride along. Here we're
+            // telling the final stage packager to be sure and serve the map files
+            // too.
+            if (asset.kind === 'concatenated-asset') {
+                assetPaths.push(asset.sourcemapPath);
+            }
+        }
         let meta = {
             type: 'app',
             version: 2,
             assets: assetPaths,
             babel: {
                 filename: '_babel_config_.js',
-                isParallelSafe: true, // TODO
+                isParallelSafe: true,
                 majorVersion: this.compatApp.babelMajorVersion(),
                 fileFilter: '_babel_filter_.js',
             },
@@ -396,12 +841,8 @@ class CompatAppBuilder {
         (0, fs_extra_1.writeFileSync)((0, path_2.join)(this.root, 'package.json'), JSON.stringify(pkg, null, 2), 'utf8');
         let resolverConfig = this.resolverConfig(appFiles);
         this.addResolverConfig(resolverConfig);
-        this.addContentForConfig(this.contentForTree.readContents());
-        this.addEmberEnvConfig(this.configTree.readConfig().EmberENV);
-        this.addAppBoot(this.compatApp.appBoot.readAppBoot());
-        let babelConfig = await this.babelConfig(resolverConfig);
+        let babelConfig = this.babelConfig(resolverConfig);
         this.addBabelConfig(babelConfig);
-        this.addMacrosConfig(this.compatApp.macrosConfig.babelPluginConfig()[0]);
     }
     combinePackageJSON(meta) {
         let pkgLayers = [this.origAppPackage.packageJSON];
@@ -414,7 +855,7 @@ class CompatAppBuilder {
         pkgLayers.push({ keywords: ['ember-addon'], 'ember-addon': meta });
         return combinePackageJSON(...pkgLayers);
     }
-    async etcOptions(resolverConfig) {
+    etcOptions(resolverConfig) {
         let transforms = this.compatApp.htmlbarsPlugins;
         let { plugins: macroPlugins, setConfig } = node_1.MacrosConfig.transforms();
         setConfig(this.compatApp.macrosConfig);
@@ -431,7 +872,7 @@ class CompatAppBuilder {
             transforms.push([require.resolve('./resolver-transform'), opts]);
         }
         let resolver = new core_1.Resolver(resolverConfig);
-        let resolution = await resolver.nodeResolve('ember-source/vendor/ember/ember-template-compiler', (0, path_1.resolve)(this.root, 'package.json'));
+        let resolution = resolver.nodeResolve('ember-source/vendor/ember/ember-template-compiler', (0, path_1.resolve)(this.root, 'package.json'));
         if (resolution.type !== 'real') {
             throw new Error(`bug: unable to resolve ember-template-compiler from ${this.root}`);
         }
@@ -449,7 +890,7 @@ class CompatAppBuilder {
                 if (i < hint.resolve.length - 1) {
                     target = (0, path_2.join)(target, 'package.json');
                 }
-                cursor = resolve_1.default.sync(target, { basedir: (0, path_2.dirname)(cursor) });
+                cursor = resolve_2.default.sync(target, { basedir: (0, path_2.dirname)(cursor) });
             }
             return {
                 requireFile: cursor,
@@ -462,35 +903,246 @@ class CompatAppBuilder {
         if (!pconfig.isParallelSafe) {
             (0, core_1.warn)('Your build is slower because some babel plugins are non-serializable');
         }
-        (0, fs_extra_1.writeFileSync)((0, path_2.join)((0, core_1.locateEmbroiderWorkingDir)(this.compatApp.root), '_babel_config_.js'), `module.exports = ${JSON.stringify(pconfig.config, null, 2)}`, 'utf8');
-        (0, fs_extra_1.writeFileSync)((0, path_2.join)((0, core_1.locateEmbroiderWorkingDir)(this.compatApp.root), '_babel_filter_.js'), babelFilterTemplate({ skipBabel: this.options.skipBabel, appRoot: this.origAppPackage.root }), 'utf8');
+        (0, fs_extra_1.writeFileSync)((0, path_2.join)(this.root, '_babel_config_.js'), `module.exports = ${JSON.stringify(pconfig.config, null, 2)}`, 'utf8');
+        (0, fs_extra_1.writeFileSync)((0, path_2.join)(this.root, '_babel_filter_.js'), babelFilterTemplate({ skipBabel: this.options.skipBabel, appRoot: this.origAppPackage.root }), 'utf8');
     }
     addResolverConfig(config) {
         (0, fs_extra_1.outputJSONSync)((0, path_2.join)((0, core_1.locateEmbroiderWorkingDir)(this.compatApp.root), 'resolver.json'), config, { spaces: 2 });
     }
-    addContentForConfig(contentForConfig) {
-        (0, fs_extra_1.outputJSONSync)((0, path_2.join)((0, core_1.locateEmbroiderWorkingDir)(this.compatApp.root), 'content-for.json'), contentForConfig, {
-            spaces: 2,
-        });
+    shouldSplitRoute(routeName) {
+        return (!this.options.splitAtRoutes ||
+            this.options.splitAtRoutes.find(pattern => {
+                if (typeof pattern === 'string') {
+                    return pattern === routeName;
+                }
+                else {
+                    return pattern.test(routeName);
+                }
+            }));
     }
-    addEmberEnvConfig(emberEnvConfig) {
-        (0, fs_extra_1.outputJSONSync)((0, path_2.join)((0, core_1.locateEmbroiderWorkingDir)(this.compatApp.root), 'ember-env.json'), emberEnvConfig, {
-            spaces: 2,
-        });
+    splitRoute(routeName, files, addToParent, addLazyBundle) {
+        let shouldSplit = routeName && this.shouldSplitRoute(routeName);
+        let ownFiles = [];
+        let ownNames = new Set();
+        if (files.template) {
+            if (shouldSplit) {
+                ownFiles.push(files.template);
+                ownNames.add(routeName);
+            }
+            else {
+                addToParent(routeName, files.template);
+            }
+        }
+        if (files.controller) {
+            if (shouldSplit) {
+                ownFiles.push(files.controller);
+                ownNames.add(routeName);
+            }
+            else {
+                addToParent(routeName, files.controller);
+            }
+        }
+        if (files.route) {
+            if (shouldSplit) {
+                ownFiles.push(files.route);
+                ownNames.add(routeName);
+            }
+            else {
+                addToParent(routeName, files.route);
+            }
+        }
+        for (let [childName, childFiles] of files.children) {
+            this.splitRoute(`${routeName}.${childName}`, childFiles, (childRouteName, childFile) => {
+                // this is our child calling "addToParent"
+                if (shouldSplit) {
+                    ownFiles.push(childFile);
+                    ownNames.add(childRouteName);
+                }
+                else {
+                    addToParent(childRouteName, childFile);
+                }
+            }, (routeNames, files) => {
+                addLazyBundle(routeNames, files);
+            });
+        }
+        if (ownFiles.length > 0) {
+            addLazyBundle([...ownNames], ownFiles);
+        }
     }
-    addMacrosConfig(macrosConfig) {
-        (0, fs_extra_1.outputJSONSync)((0, path_2.join)((0, core_1.locateEmbroiderWorkingDir)(this.compatApp.root), 'macros-config.json'), macrosConfig, {
-            spaces: 2,
+    topAppJSAsset(engines, prepared) {
+        let [app, ...childEngines] = engines;
+        let relativePath = `assets/${this.origAppPackage.name}.js`;
+        return this.appJSAsset(relativePath, app, childEngines, prepared, {
+            autoRun: this.compatApp.autoRun,
+            appBoot: !this.compatApp.autoRun ? this.compatApp.appBoot.readAppBoot() : '',
+            mainModule: (0, core_1.explicitRelative)((0, path_2.dirname)(relativePath), 'app'),
+            appConfig: this.configTree.readConfig().APP,
         });
     }
-    addAppBoot(appBoot) {
-        (0, fs_extra_1.writeFileSync)((0, path_2.join)((0, core_1.locateEmbroiderWorkingDir)(this.compatApp.root), 'ember-app-boot.js'), appBoot !== null && appBoot !== void 0 ? appBoot : '');
+    get staticAppPathsPattern() {
+        if (this.options.staticAppPaths.length > 0) {
+            return new RegExp('^(?:' + this.options.staticAppPaths.map(staticAppPath => (0, escape_string_regexp_1.default)(staticAppPath)).join('|') + ')(?:$|/)');
+        }
+    }
+    requiredOtherFiles(appFiles) {
+        let pattern = this.staticAppPathsPattern;
+        if (pattern) {
+            return appFiles.otherAppFiles.filter(f => {
+                return !pattern.test(f);
+            });
+        }
+        else {
+            return appFiles.otherAppFiles;
+        }
+    }
+    appJSAsset(relativePath, appFiles, childEngines, prepared, entryParams) {
+        let cached = prepared.get(relativePath);
+        if (cached) {
+            return cached;
+        }
+        let eagerModules = [];
+        let requiredAppFiles = [this.requiredOtherFiles(appFiles)];
+        if (!this.options.staticComponents) {
+            requiredAppFiles.push(appFiles.components);
+        }
+        if (!this.options.staticHelpers) {
+            requiredAppFiles.push(appFiles.helpers);
+        }
+        if (!this.options.staticModifiers) {
+            requiredAppFiles.push(appFiles.modifiers);
+        }
+        let styles = [];
+        // only import styles from engines with a parent (this excludeds the parent application) as their styles
+        // will be inserted via a direct <link> tag.
+        if (appFiles.engine.parent && appFiles.engine.package.isLazyEngine()) {
+            let implicitStyles = this.impliedAssets('implicit-styles', appFiles);
+            for (let style of implicitStyles) {
+                styles.push({
+                    path: (0, core_1.explicitRelative)('assets/_engine_', style.relativePath),
+                });
+            }
+            let engineMeta = appFiles.engine.package.meta;
+            if (engineMeta && engineMeta['implicit-styles']) {
+                for (let style of engineMeta['implicit-styles']) {
+                    styles.push({
+                        path: (0, core_1.explicitRelative)((0, path_2.dirname)(relativePath), (0, path_2.join)(appFiles.engine.appRelativePath, style)),
+                    });
+                }
+            }
+        }
+        let lazyEngines = [];
+        for (let childEngine of childEngines) {
+            let asset = this.appJSAsset(`assets/_engine_/${encodeURIComponent(childEngine.engine.package.name)}.js`, childEngine, [], prepared);
+            if (childEngine.engine.package.isLazyEngine()) {
+                lazyEngines.push({
+                    names: [childEngine.engine.package.name],
+                    path: (0, core_1.explicitRelative)((0, path_2.dirname)(relativePath), asset.relativePath),
+                });
+            }
+            else {
+                eagerModules.push((0, core_1.explicitRelative)((0, path_2.dirname)(relativePath), asset.relativePath));
+            }
+        }
+        let lazyRoutes = [];
+        for (let [routeName, routeFiles] of appFiles.routeFiles.children) {
+            this.splitRoute(routeName, routeFiles, (_, filename) => {
+                requiredAppFiles.push([filename]);
+            }, (routeNames, files) => {
+                let routeEntrypoint = `assets/_route_/${encodeURIComponent(routeNames[0])}.js`;
+                if (!prepared.has(routeEntrypoint)) {
+                    prepared.set(routeEntrypoint, this.routeEntrypoint(appFiles, routeEntrypoint, files));
+                }
+                lazyRoutes.push({
+                    names: routeNames,
+                    path: this.importPaths(appFiles, routeEntrypoint).buildtime,
+                });
+            });
+        }
+        let [fastboot, nonFastboot] = (0, partition_1.default)(excludeDotFiles((0, flatten_1.default)(requiredAppFiles)), file => appFiles.isFastbootOnly.get(file));
+        let amdModules = nonFastboot.map(file => this.importPaths(appFiles, file));
+        let fastbootOnlyAmdModules = fastboot.map(file => this.importPaths(appFiles, file));
+        // this is a backward-compatibility feature: addons can force inclusion of
+        // modules.
+        eagerModules.push('./-embroider-implicit-modules.js');
+        let params = { amdModules, fastbootOnlyAmdModules, lazyRoutes, lazyEngines, eagerModules, styles };
+        if (entryParams) {
+            Object.assign(params, entryParams);
+        }
+        let source = entryTemplate(params);
+        let asset = {
+            kind: 'in-memory',
+            source,
+            relativePath,
+        };
+        prepared.set(relativePath, asset);
+        return asset;
+    }
+    importPaths({ engine }, engineRelativePath) {
+        let noHBS = engineRelativePath.replace(this.resolvableExtensionsPattern, '').replace(/\.hbs$/, '');
+        return {
+            runtime: `${engine.modulePrefix}/${noHBS}`,
+            buildtime: path_1.posix.join(engine.package.name, engineRelativePath),
+        };
+    }
+    routeEntrypoint(appFiles, relativePath, files) {
+        let [fastboot, nonFastboot] = (0, partition_1.default)(files, file => appFiles.isFastbootOnly.get(file));
+        let asset = {
+            kind: 'in-memory',
+            source: routeEntryTemplate({
+                files: nonFastboot.map(f => this.importPaths(appFiles, f)),
+                fastbootOnlyFiles: fastboot.map(f => this.importPaths(appFiles, f)),
+            }),
+            relativePath,
+        };
+        return asset;
+    }
+    testJSEntrypoint(appFiles, prepared) {
+        let asset = prepared.get(`assets/test.js`);
+        if (asset) {
+            return asset;
+        }
+        // We're only building tests from the first engine (the app). This is the
+        // normal thing to do -- tests from engines don't automatically roll up into
+        // the app.
+        let engine = appFiles[0];
+        const myName = 'assets/test.js';
+        // tests necessarily also include the app. This is where we account for
+        // that. The classic solution was to always include the app's separate
+        // script tag in the tests HTML, but that isn't as easy for final stage
+        // packagers to understand. It's better to express it here as a direct
+        // module dependency.
+        let eagerModules = [
+            'ember-testing',
+            (0, core_1.explicitRelative)((0, path_2.dirname)(myName), this.topAppJSAsset(appFiles, prepared).relativePath),
+        ];
+        let amdModules = [];
+        // this is a backward-compatibility feature: addons can force inclusion of
+        // test support modules.
+        eagerModules.push('./-embroider-implicit-test-modules.js');
+        for (let relativePath of engine.tests) {
+            amdModules.push(this.importPaths(engine, relativePath));
+        }
+        let source = entryTemplate({
+            amdModules,
+            eagerModules,
+            testSuffix: true,
+        });
+        asset = {
+            kind: 'in-memory',
+            source,
+            relativePath: myName,
+        };
+        prepared.set(asset.relativePath, asset);
+        return asset;
     }
 }
 exports.CompatAppBuilder = CompatAppBuilder;
 __decorate([
     (0, typescript_memoize_1.Memoize)()
 ], CompatAppBuilder.prototype, "fastbootJSSrcDir", null);
+__decorate([
+    (0, typescript_memoize_1.Memoize)()
+], CompatAppBuilder.prototype, "findTestemAsset", null);
 __decorate([
     (0, typescript_memoize_1.Memoize)()
 ], CompatAppBuilder.prototype, "allActiveAddons", null);
@@ -517,10 +1169,10 @@ __decorate([
 ], CompatAppBuilder.prototype, "fastbootConfig", null);
 __decorate([
     (0, typescript_memoize_1.Memoize)()
-], CompatAppBuilder.prototype, "staticAppPathsPattern", null);
+], CompatAppBuilder.prototype, "portableHints", null);
 __decorate([
     (0, typescript_memoize_1.Memoize)()
-], CompatAppBuilder.prototype, "portableHints", null);
+], CompatAppBuilder.prototype, "staticAppPathsPattern", null);
 function defaultAddonPackageRules() {
     return (0, fs_extra_2.readdirSync)((0, path_2.join)(__dirname, 'addon-dependency-rules'))
         .map(filename => {
@@ -532,6 +1184,104 @@ function defaultAddonPackageRules() {
         .filter(Boolean)
         .reduce((a, b) => a.concat(b), []);
 }
+const entryTemplate = (0, core_1.jsHandlebarsCompile)(`
+import { importSync as i, macroCondition, getGlobalConfig } from '@embroider/macros';
+let w = window;
+let d = w.define;
+
+{{#if styles}}
+  if (macroCondition(!getGlobalConfig().fastboot?.isRunning)) {
+    {{#each styles as |stylePath| ~}}
+      i("{{js-string-escape stylePath.path}}");
+    {{/each}}
+  }
+{{/if}}
+
+{{#each eagerModules as |eagerModule| ~}}
+  i("{{js-string-escape eagerModule}}");
+{{/each}}
+
+{{#each amdModules as |amdModule| ~}}
+  d("{{js-string-escape amdModule.runtime}}", function(){ return i("{{js-string-escape amdModule.buildtime}}");});
+{{/each}}
+
+{{#if fastbootOnlyAmdModules}}
+  if (macroCondition(getGlobalConfig().fastboot?.isRunning)) {
+    {{#each fastbootOnlyAmdModules as |amdModule| ~}}
+      d("{{js-string-escape amdModule.runtime}}", function(){ return i("{{js-string-escape amdModule.buildtime}}");});
+    {{/each}}
+  }
+{{/if}}
+
+
+{{#if lazyRoutes}}
+w._embroiderRouteBundles_ = [
+  {{#each lazyRoutes as |route|}}
+  {
+    names: {{json-stringify route.names}},
+    load: function() {
+      return import("{{js-string-escape route.path}}");
+    }
+  },
+  {{/each}}
+]
+{{/if}}
+
+{{#if lazyEngines}}
+w._embroiderEngineBundles_ = [
+  {{#each lazyEngines as |engine|}}
+  {
+    names: {{json-stringify engine.names}},
+    load: function() {
+      return import("{{js-string-escape engine.path}}");
+    }
+  },
+  {{/each}}
+]
+{{/if}}
+
+{{#if autoRun ~}}
+if (!runningTests) {
+  i("{{js-string-escape mainModule}}").default.create({{json-stringify appConfig}});
+}
+{{else  if appBoot ~}}
+  {{ appBoot }}
+{{/if}}
+
+{{#if testSuffix ~}}
+  {{!- TODO: both of these suffixes should get dynamically generated so they incorporate
+       any content-for added by addons. -}}
+
+
+  {{!- this is the traditional tests-suffix.js -}}
+  i('../tests/test-helper');
+  EmberENV.TESTS_FILE_LOADED = true;
+{{/if}}
+`);
+const routeEntryTemplate = (0, core_1.jsHandlebarsCompile)(`
+import { importSync as i } from '@embroider/macros';
+let d = window.define;
+{{#each files as |amdModule| ~}}
+d("{{js-string-escape amdModule.runtime}}", function(){ return i("{{js-string-escape amdModule.buildtime}}");});
+{{/each}}
+{{#if fastbootOnlyFiles}}
+  import { macroCondition, getGlobalConfig } from '@embroider/macros';
+  if (macroCondition(getGlobalConfig().fastboot?.isRunning)) {
+    {{#each fastbootOnlyFiles as |amdModule| ~}}
+    d("{{js-string-escape amdModule.runtime}}", function(){ return i("{{js-string-escape amdModule.buildtime}}");});
+    {{/each}}
+  }
+{{/if}}
+`);
+function stringOrBufferEqual(a, b) {
+    if (typeof a === 'string' && typeof b === 'string') {
+        return a === b;
+    }
+    if (a instanceof Buffer && b instanceof Buffer) {
+        return Buffer.compare(a, b) === 0;
+    }
+    return false;
+}
 const babelFilterTemplate = (0, core_1.jsHandlebarsCompile)(`
 const { babelFilter } = require(${JSON.stringify(require.resolve('@embroider/core'))});
 module.exports = babelFilter({{json-stringify skipBabel}}, "{{js-string-escape appRoot}}");
@@ -571,4 +1321,37 @@ function addCachablePlugin(babelConfig) {
         ]);
     }
 }
+function excludeDotFiles(files) {
+    return files.filter(file => !file.startsWith('.') && !file.includes('/.'));
+}
+class ParsedEmberAsset {
+    constructor(asset) {
+        this.kind = 'parsed-ember';
+        this.fileAsset = asset;
+        this.html = new ember_html_1.PreparedEmberHTML(asset);
+        this.relativePath = asset.relativePath;
+    }
+    validFor(other) {
+        return this.fileAsset.mtime === other.mtime && this.fileAsset.size === other.size;
+    }
+}
+class BuiltEmberAsset {
+    constructor(asset) {
+        this.kind = 'built-ember';
+        this.parsedAsset = asset;
+        this.source = asset.html.dom.serialize();
+        this.relativePath = asset.relativePath;
+    }
+}
+class ConcatenatedAsset {
+    constructor(relativePath, sources, resolvableExtensions) {
+        this.relativePath = relativePath;
+        this.sources = sources;
+        this.resolvableExtensions = resolvableExtensions;
+        this.kind = 'concatenated-asset';
+    }
+    get sourcemapPath() {
+        return this.relativePath.replace(this.resolvableExtensions, '') + '.map';
+    }
+}
 //# sourceMappingURL=compat-app-builder.js.map