@embroider/compat 3.5.1-unstable.c8b5bd4 → 3.5.1-unstable.d7336b2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@embroider/compat",
-  "version": "3.5.1-unstable.c8b5bd4",
+  "version": "3.5.1-unstable.d7336b2",
   "private": false,
   "description": "Backward compatibility layer for the Embroider build system.",
   "repository": {
@@ -30,7 +30,7 @@
     "@babel/preset-env": "^7.14.5",
     "@babel/runtime": "^7.18.6",
     "@babel/traverse": "^7.14.5",
-    "@embroider/macros": "1.16.2-unstable.c8b5bd4",
+    "@embroider/macros": "1.16.2-unstable.d7336b2",
     "@types/babel__code-frame": "^7.0.2",
     "@types/yargs": "^17.0.3",
     "assert-never": "^1.1.0",
@@ -66,7 +66,7 @@
     "yargs": "^17.0.1"
   },
   "devDependencies": {
-    "@embroider/core": "3.4.10-unstable.c8b5bd4",
+    "@embroider/core": "3.4.10-unstable.d7336b2",
     "@embroider/sample-transforms": "workspace:*",
     "@embroider/test-support": "workspace:*",
     "@glimmer/syntax": "^0.84.3",
@@ -91,7 +91,7 @@
     "typescript": "^5.4.5"
   },
   "peerDependencies": {
-    "@embroider/core": "3.4.10-unstable.c8b5bd4"
+    "@embroider/core": "3.4.10-unstable.d7336b2"
   },
   "engines": {
     "node": "12.* || 14.* || >= 16"

package/src/compat-app-builder.d.ts

@@ -19,6 +19,7 @@ export declare class CompatAppBuilder {
     constructor(root: string, origAppPackage: Package, appPackageWithMovedDeps: Package, options: Required<Options>, compatApp: CompatApp, configTree: V1Config, contentForTree: ContentForConfig, synthVendor: Package, synthStyles: Package);
     private fastbootJSSrcDir;
     private extractAssets;
+    private findTestemAsset;
     private activeAddonChildren;
     private get allActiveAddons();
     private isActiveAddon;
@@ -30,7 +31,10 @@ export declare class CompatAppBuilder {
     private rootURL;
     private activeRules;
     private resolverConfig;
+    private scriptPriority;
     private get resolvableExtensionsPattern();
+    private impliedAssets;
+    private impliedAddonAssets;
     private babelConfig;
     private insertEmberApp;
     private findActiveAddons;
@@ -39,13 +43,13 @@ export declare class CompatAppBuilder {
     private get fastbootConfig();
     private engines;
     private updateAppJS;
-    private get staticAppPathsPattern();
     private prepareAsset;
     private prepareAssets;
     private assetIsValid;
     private updateOnDiskAsset;
     private updateInMemoryAsset;
     private updateBuiltEmberAsset;
+    private updateConcatenatedAsset;
     private updateAssets;
     private gatherAssets;
     private firstBuild;
@@ -57,8 +61,14 @@ export declare class CompatAppBuilder {
     private addResolverConfig;
     private addContentForConfig;
     private addEmberEnvConfig;
-    private addAppBoot;
+    private shouldSplitRoute;
+    private splitRoute;
+    private topAppJSAsset;
+    private get staticAppPathsPattern();
+    private requiredOtherFiles;
+    private appJSAsset;
     private importPaths;
+    private routeEntrypoint;
     private testJSEntrypoint;
 }
 interface TreeNames {

package/src/compat-app-builder.js

@@ -1,10 +1,33 @@
 "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 };
 };
@@ -14,8 +37,12 @@ const core_1 = require("@embroider/core");
 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");
@@ -25,9 +52,10 @@ 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,
@@ -55,11 +83,36 @@ class CompatAppBuilder {
     }
     extractAssets(treePaths) {
         let assets = [];
+        // 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
@@ -195,18 +248,63 @@ class CompatAppBuilder {
             // 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());
     }
+    impliedAssets(type, engine) {
+        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,
+            };
+        });
+        return result;
+    }
+    impliedAddonAssets(type, { engine }) {
+        let result = [];
+        for (let addon of (0, sortBy_1.default)(Array.from(engine.addons.keys()), 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;
+    }
     async babelConfig(resolverConfig) {
         let babel = (0, cloneDeep_1.default)(this.compatApp.babelConfig());
         if (!babel.plugins) {
@@ -285,7 +383,8 @@ class CompatAppBuilder {
         // 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) {
-            html.insertScriptTag(html.javascript, '@embroider/core/entrypoint', { type: 'module' });
+            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
@@ -425,14 +524,9 @@ 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) {
         if (asset.kind === 'ember') {
             let prior = this.assets.get(asset.relativePath);
@@ -470,6 +564,13 @@ class CompatAppBuilder {
                 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) {
@@ -487,6 +588,33 @@ class CompatAppBuilder {
         (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) {
         let assets = this.prepareAssets(requestedAssets, appFiles);
         for (let asset of assets.values()) {
@@ -504,6 +632,9 @@ class CompatAppBuilder {
                 case 'built-ember':
                     this.updateBuiltEmberAsset(asset);
                     break;
+                case 'concatenated-asset':
+                    await this.updateConcatenatedAsset(asset);
+                    break;
                 default:
                     (0, assert_never_1.default)(asset);
             }
@@ -514,6 +645,7 @@ class CompatAppBuilder {
             }
         }
         this.assets = assets;
+        return [...assets.values()];
     }
     gatherAssets(inputPaths) {
         // first gather all the assets out of addons
@@ -547,12 +679,20 @@ class CompatAppBuilder {
         }
         let appFiles = this.updateAppJS(inputPaths.appJS);
         let assets = this.gatherAssets(inputPaths);
-        await this.updateAssets(assets, appFiles);
+        let finalAssets = await this.updateAssets(assets, appFiles);
         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,
@@ -573,7 +713,6 @@ class CompatAppBuilder {
         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);
         this.addBabelConfig(babelConfig);
         (0, fs_extra_1.writeFileSync)((0, path_2.join)(this.root, 'macros-config.json'), JSON.stringify(this.compatApp.macrosConfig.babelPluginConfig()[0], null, 2));
@@ -624,7 +763,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,
@@ -653,8 +792,179 @@ class CompatAppBuilder {
             spaces: 2,
         });
     }
-    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 : '');
+    shouldSplitRoute(routeName) {
+        return (!this.options.splitAtRoutes ||
+            this.options.splitAtRoutes.find(pattern => {
+                if (typeof pattern === 'string') {
+                    return pattern === routeName;
+                }
+                else {
+                    return pattern.test(routeName);
+                }
+            }));
+    }
+    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);
+        }
+    }
+    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,
+        });
+    }
+    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.isApp && 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));
+        let params = {
+            amdModules,
+            fastbootOnlyAmdModules,
+            lazyRoutes,
+            lazyEngines,
+            eagerModules,
+            styles,
+            // this is a backward-compatibility feature: addons can force inclusion of modules.
+            defineModulesFrom: './-embroider-implicit-modules.js',
+        };
+        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$/, '');
@@ -663,6 +973,18 @@ class CompatAppBuilder {
             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) {
@@ -673,12 +995,22 @@ class CompatAppBuilder {
         // 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 = [];
         for (let relativePath of engine.tests) {
             amdModules.push(this.importPaths(engine, relativePath));
         }
         let source = entryTemplate({
             amdModules,
+            eagerModules,
             testSuffix: true,
             // this is a backward-compatibility feature: addons can force inclusion of test support modules.
             defineModulesFrom: './-embroider-implicit-test-modules.js',
@@ -696,6 +1028,9 @@ 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);
@@ -722,10 +1057,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 => {
@@ -759,8 +1094,9 @@ let d = w.define;
 {{/if}}
 
 
-import "ember-testing";
-import "@embroider/core/entrypoint";
+{{#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}}");});
@@ -827,6 +1163,21 @@ if (!runningTests) {
   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;
@@ -875,6 +1226,9 @@ function addCachablePlugin(babelConfig) {
         ]);
     }
 }
+function excludeDotFiles(files) {
+    return files.filter(file => !file.startsWith('.') && !file.includes('/.'));
+}
 class ParsedEmberAsset {
     constructor(asset) {
         this.kind = 'parsed-ember';
@@ -894,4 +1248,15 @@ class BuiltEmberAsset {
         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