@embroider/core 2.1.0 → 2.1.1-unstable.21eae41

package/src/module-resolver.js

@@ -1,96 +1,374 @@
 "use strict";
-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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Resolver = void 0;
 const shared_internals_1 = require("@embroider/shared-internals");
 const path_1 = require("path");
 const shared_internals_2 = require("@embroider/shared-internals");
-const typescript_memoize_1 = require("typescript-memoize");
+const debug_1 = __importDefault(require("debug"));
+const assert_never_1 = __importDefault(require("assert-never"));
+const resolve_1 = __importDefault(require("resolve"));
+const virtual_content_1 = require("./virtual-content");
+const debug = (0, debug_1.default)('embroider:resolver');
+function logTransition(reason, before, after = before) {
+    if (after.isVirtual) {
+        debug(`virtualized %s in %s because %s`, before.specifier, before.fromFile, reason);
+    }
+    else if (before.specifier !== after.specifier) {
+        if (before.fromFile !== after.fromFile) {
+            debug(`aliased and rehomed: %s to %s, from %s to %s because %s`, before.specifier, after.specifier, before.fromFile, after.fromFile, reason);
+        }
+        else {
+            debug(`aliased: %s to %s in %s because`, before.specifier, after.specifier, before.fromFile, reason);
+        }
+    }
+    else if (before.fromFile !== after.fromFile) {
+        debug(`rehomed: %s from %s to %s because`, before.specifier, before.fromFile, after.fromFile, reason);
+    }
+    else {
+        debug(`unchanged: %s in %s because %s`, before.specifier, before.fromFile, reason);
+    }
+    return after;
+}
+const compatPattern = /#embroider_compat\/(?<type>[^\/]+)\/(?<rest>.*)/;
+class NodeModuleRequest {
+    constructor(specifier, fromFile, isVirtual = false) {
+        this.specifier = specifier;
+        this.fromFile = fromFile;
+        this.isVirtual = isVirtual;
+    }
+    alias(specifier) {
+        return new NodeModuleRequest(specifier, this.fromFile);
+    }
+    rehome(fromFile) {
+        return new NodeModuleRequest(this.specifier, fromFile);
+    }
+    virtualize(filename) {
+        return new NodeModuleRequest(filename, this.fromFile, true);
+    }
+}
 class Resolver {
-    constructor(filename, options) {
-        this.filename = filename;
+    constructor(options) {
         this.options = options;
-        this.originalFilename = options.relocatedFiles[filename] || filename;
     }
-    resolve(specifier, isDynamic) {
-        if (specifier === '@embroider/macros') {
+    beforeResolve(request) {
+        if (request.specifier === '@embroider/macros') {
             // the macros package is always handled directly within babel (not
             // necessarily as a real resolvable package), so we should not mess with it.
             // It might not get compiled away until *after* our plugin has run, which is
             // why we need to know about it.
-            return { result: 'continue' };
+            return logTransition('early exit', request);
+        }
+        request = this.handleGlobalsCompat(request);
+        request = this.handleRenaming(request);
+        return this.preHandleExternal(request);
+    }
+    // This encapsulates the whole resolving process. Given a `defaultResolve`
+    // that calls your build system's normal module resolver, this does both pre-
+    // and post-resolution adjustments as needed to implement our compatibility
+    // rules.
+    //
+    // Depending on the plugin architecture you're working in, it may be easier to
+    // call beforeResolve and fallbackResolve directly, in which case matching the
+    // details of the recursion to what this method does are your responsibility.
+    async resolve(request, defaultResolve) {
+        let gen = this.internalResolve(request, defaultResolve);
+        let out = gen.next();
+        while (!out.done) {
+            out = gen.next(await out.value);
+        }
+        return out.value;
+    }
+    // synchronous alternative to resolve() above. Because our own internals are
+    // all synchronous, you can use this if your defaultResolve function is
+    // synchronous. At present, we need this for the case where we are compiling
+    // non-strict templates and doing component resolutions inside the template
+    // compiler inside babel, which is a synchronous context.
+    resolveSync(request, defaultResolve) {
+        let gen = this.internalResolve(request, defaultResolve);
+        let out = gen.next();
+        while (!out.done) {
+            out = gen.next(out.value);
+        }
+        return out.value;
+    }
+    // Our core implementation is a generator so it can power both resolve() and
+    // resolveSync()
+    *internalResolve(request, defaultResolve) {
+        request = this.beforeResolve(request);
+        let resolution = yield defaultResolve(request);
+        switch (resolution.type) {
+            case 'found':
+                return resolution;
+            case 'not_found':
+                break;
+            default:
+                throw (0, assert_never_1.default)(resolution);
+        }
+        let nextRequest = this.fallbackResolve(request);
+        if (nextRequest === request) {
+            // no additional fallback is available.
+            return resolution;
+        }
+        if (nextRequest.isVirtual) {
+            // virtual requests are terminal, there is no more beforeResolve or
+            // fallbackResolve around them. The defaultResolve is expected to know how
+            // to implement them.
+            return yield defaultResolve(nextRequest);
         }
-        let maybeRenamed = this.handleRenaming(specifier);
-        let resolution = this.handleExternal(maybeRenamed, isDynamic);
-        if (resolution.result === 'continue' && maybeRenamed !== specifier) {
-            return { result: 'redirect-to', specifier: maybeRenamed };
+        return yield* this.internalResolve(nextRequest, defaultResolve);
+    }
+    // Use standard NodeJS resolving, with our required compatibility rules on
+    // top. This is a convenience method for calling resolveSync with the
+    // defaultResolve already configured to be "do the normal node thing".
+    nodeResolve(specifier, fromFile) {
+        let resolution = this.resolveSync(new NodeModuleRequest(specifier, fromFile), request => {
+            if (request.isVirtual) {
+                return {
+                    type: 'found',
+                    result: {
+                        type: 'virtual',
+                        content: (0, virtual_content_1.virtualContent)(request.specifier),
+                        filename: request.specifier,
+                    },
+                };
+            }
+            try {
+                let filename = resolve_1.default.sync(request.specifier, {
+                    basedir: (0, path_1.dirname)(request.fromFile),
+                    extensions: this.options.resolvableExtensions,
+                });
+                return { type: 'found', result: { type: 'real', filename } };
+            }
+            catch (err) {
+                if (err.code !== 'MODULE_NOT_FOUND') {
+                    throw err;
+                }
+                return { type: 'not_found', err };
+            }
+        });
+        switch (resolution.type) {
+            case 'not_found':
+                return resolution;
+            case 'found':
+                return resolution.result;
+            default:
+                throw (0, assert_never_1.default)(resolution);
         }
-        return resolution;
     }
-    owningPackage() {
-        return shared_internals_2.PackageCache.shared('embroider-stage3', this.options.appRoot).ownerOfFile(this.originalFilename);
+    owningPackage(fromFile) {
+        return shared_internals_2.PackageCache.shared('embroider-stage3', this.options.appRoot).ownerOfFile(fromFile);
     }
-    relocatedIntoPackage() {
-        if (this.originalFilename !== this.filename) {
-            let owning = shared_internals_2.PackageCache.shared('embroider-stage3', this.options.appRoot).ownerOfFile(this.filename);
+    originalPackage(fromFile) {
+        let originalFile = this.options.relocatedFiles[fromFile];
+        if (originalFile) {
+            let owning = shared_internals_2.PackageCache.shared('embroider-stage3', this.options.appRoot).ownerOfFile(originalFile);
             if (owning && !owning.isV2Ember()) {
-                throw new Error(`bug: it should only be possible to get relocated into a v2 ember package here`);
+                throw new Error(`bug: it should only be possible for a v2 ember package to own relocated files`);
             }
             return owning;
         }
     }
-    handleRenaming(specifier) {
-        let packageName = (0, shared_internals_1.packageName)(specifier);
+    handleGlobalsCompat(request) {
+        let match = compatPattern.exec(request.specifier);
+        if (!match) {
+            return request;
+        }
+        let { type, rest } = match.groups;
+        let fromPkg = this.owningPackage(request.fromFile);
+        if (!(fromPkg === null || fromPkg === void 0 ? void 0 : fromPkg.isV2Ember())) {
+            return request;
+        }
+        let engine = this.owningEngine(fromPkg);
+        switch (type) {
+            case 'helpers':
+                return this.resolveHelper(rest, engine, request);
+            case 'components':
+                return this.resolveComponent(rest, engine, request);
+            case 'modifiers':
+                return this.resolveModifier(rest, engine, request);
+            case 'ambiguous':
+                return this.resolveHelperOrComponent(rest, engine, request);
+            default:
+                throw new Error(`bug: unexepected #embroider_compat specifier: ${request.specifier}`);
+        }
+    }
+    resolveHelper(path, inEngine, request) {
+        let target = this.parseGlobalPath(path, inEngine);
+        return request
+            .alias(`${target.packageName}/helpers/${target.memberName}`)
+            .rehome((0, path_1.resolve)(inEngine.root, 'package.json'));
+    }
+    resolveComponent(path, inEngine, request) {
+        let target = this.parseGlobalPath(path, inEngine);
+        let hbsModule = null;
+        let jsModule = null;
+        // first, the various places our template might be.
+        for (let candidate of this.componentTemplateCandidates(target.packageName)) {
+            let resolution = this.nodeResolve(`${target.packageName}${candidate.prefix}${target.memberName}${candidate.suffix}`, target.from);
+            if (resolution.type === 'real') {
+                hbsModule = resolution.filename;
+                break;
+            }
+        }
+        // then the various places our javascript might be.
+        for (let candidate of this.componentJSCandidates(target.packageName)) {
+            let resolution = this.nodeResolve(`${target.packageName}${candidate.prefix}${target.memberName}${candidate.suffix}`, target.from);
+            // .hbs is a resolvable extension for us, so we need to exclude it here.
+            // It matches as a priority lower than .js, so finding an .hbs means
+            // there's definitely not a .js.
+            if (resolution.type === 'real' && !resolution.filename.endsWith('.hbs')) {
+                jsModule = resolution.filename;
+                break;
+            }
+        }
+        if (hbsModule) {
+            return logTransition(`resolveComponent found legacy HBS`, request, request.virtualize((0, virtual_content_1.virtualPairComponent)(hbsModule, jsModule)));
+        }
+        else if (jsModule) {
+            return logTransition(`resolveComponent found only JS`, request, request.alias(jsModule).rehome(target.from));
+        }
+        else {
+            return logTransition(`resolveComponent failed`, request);
+        }
+    }
+    resolveHelperOrComponent(path, inEngine, request) {
+        // resolveHelper just rewrites our request to one that should target the
+        // component, so here to resolve the ambiguity we need to actually resolve
+        // that candidate to see if it works.
+        let helperCandidate = this.resolveHelper(path, inEngine, request);
+        let helperMatch = this.nodeResolve(helperCandidate.specifier, helperCandidate.fromFile);
+        if (helperMatch.type === 'real') {
+            return helperCandidate;
+        }
+        // unlike resolveHelper, resolveComponent already does pre-resolution in
+        // order to deal with its own internal ambiguity around JS vs HBS vs
+        // colocation.≥
+        let componentMatch = this.resolveComponent(path, inEngine, request);
+        if (componentMatch !== request) {
+            return componentMatch;
+        }
+        // this is the hard failure case -- we were supposed to find something and
+        // didn't. Let the normal resolution process progress so the user gets a
+        // normal build error.
+        return request;
+    }
+    resolveModifier(path, inEngine, request) {
+        let target = this.parseGlobalPath(path, inEngine);
+        return request
+            .alias(`${target.packageName}/modifiers/${target.memberName}`)
+            .rehome((0, path_1.resolve)(inEngine.root, 'package.json'));
+    }
+    *componentTemplateCandidates(inPackageName) {
+        yield { prefix: '/templates/components/', suffix: '' };
+        yield { prefix: '/components/', suffix: '/template' };
+        let pods = this.podPrefix(inPackageName);
+        if (pods) {
+            yield { prefix: `${pods}/components/`, suffix: '/template' };
+        }
+    }
+    *componentJSCandidates(inPackageName) {
+        yield { prefix: '/components/', suffix: '' };
+        yield { prefix: '/components/', suffix: '/component' };
+        let pods = this.podPrefix(inPackageName);
+        if (pods) {
+            yield { prefix: `${pods}/components/`, suffix: '/component' };
+        }
+    }
+    podPrefix(targetPackageName) {
+        if (targetPackageName === this.options.modulePrefix && this.options.podModulePrefix) {
+            if (!this.options.podModulePrefix.startsWith(this.options.modulePrefix)) {
+                throw new Error(`Your podModulePrefix (${this.options.podModulePrefix}) does not start with your app module prefix (${this.options.modulePrefix}). Not gonna support that silliness.`);
+            }
+            return this.options.podModulePrefix.slice(this.options.modulePrefix.length);
+        }
+    }
+    // for paths that come from non-strict templates
+    parseGlobalPath(path, inEngine) {
+        let parts = path.split('@');
+        if (parts.length > 1 && parts[0].length > 0) {
+            return { packageName: parts[0], memberName: parts[1], from: (0, path_1.resolve)(inEngine.root, 'pacakge.json') };
+        }
+        else {
+            return { packageName: inEngine.packageName, memberName: path, from: (0, path_1.resolve)(inEngine.root, 'pacakge.json') };
+        }
+    }
+    owningEngine(pkg) {
+        if (pkg.root === this.options.appRoot) {
+            // the app is always the first engine
+            return this.options.engines[0];
+        }
+        let owningEngine = this.options.engines.find(e => e.activeAddons.find(a => a.root === pkg.root));
+        if (!owningEngine) {
+            throw new Error(`bug in @embroider/core/src/module-resolver: cannot figure out the owning engine for ${pkg.root}`);
+        }
+        return owningEngine;
+    }
+    handleRenaming(request) {
+        if (request.isVirtual) {
+            return request;
+        }
+        let packageName = (0, shared_internals_1.packageName)(request.specifier);
         if (!packageName) {
-            return specifier;
+            return request;
         }
         for (let [candidate, replacement] of Object.entries(this.options.renameModules)) {
-            if (candidate === specifier) {
-                return replacement;
+            if (candidate === request.specifier) {
+                return logTransition(`renameModules`, request, request.alias(replacement));
             }
             for (let extension of this.options.resolvableExtensions) {
-                if (candidate === specifier + '/index' + extension) {
-                    return replacement;
+                if (candidate === request.specifier + '/index' + extension) {
+                    return logTransition(`renameModules`, request, request.alias(replacement));
                 }
-                if (candidate === specifier + extension) {
-                    return replacement;
+                if (candidate === request.specifier + extension) {
+                    return logTransition(`renameModules`, request, request.alias(replacement));
                 }
             }
         }
         if (this.options.renamePackages[packageName]) {
-            return specifier.replace(packageName, this.options.renamePackages[packageName]);
+            return logTransition(`renamePackages`, request, request.alias(request.specifier.replace(packageName, this.options.renamePackages[packageName])));
         }
-        let pkg = this.owningPackage();
+        let pkg = this.owningPackage(request.fromFile);
         if (!pkg || !pkg.isV2Ember()) {
-            return specifier;
+            return request;
         }
         if (pkg.meta['auto-upgraded'] && pkg.name === packageName) {
-            // we found a self-import, make it relative. Only auto-upgraded packages get
-            // this help, v2 packages are natively supposed to use relative imports for
-            // their own modules, and we want to push them all to do that correctly.
-            let fullPath = specifier.replace(packageName, pkg.root);
-            return (0, shared_internals_2.explicitRelative)((0, path_1.dirname)(this.filename), fullPath);
-        }
-        let relocatedIntoPkg = this.relocatedIntoPackage();
-        if (relocatedIntoPkg && pkg.meta['auto-upgraded'] && relocatedIntoPkg.name === packageName) {
-            // a file that was relocated into a package does a self-import of that
-            // package's name. This can happen when an addon (like ember-cli-mirage)
-            // emits files from its own treeForApp that contain imports of the app's own
-            // fully qualified name.
-            let fullPath = specifier.replace(packageName, relocatedIntoPkg.root);
-            return (0, shared_internals_2.explicitRelative)((0, path_1.dirname)(this.filename), fullPath);
-        }
-        return specifier;
-    }
-    handleExternal(specifier, isDynamic) {
-        let pkg = this.owningPackage();
+            // we found a self-import, resolve it for them. Only auto-upgraded
+            // packages get this help, v2 packages are natively supposed to make their
+            // own modules resolvable, and we want to push them all to do that
+            // correctly.
+            return logTransition(`v1 self-import`, request, this.resolveWithinPackage(request, pkg));
+        }
+        let originalPkg = this.originalPackage(request.fromFile);
+        if (originalPkg && pkg.meta['auto-upgraded'] && originalPkg.name === packageName) {
+            // A file that was relocated out of a package is importing that package's
+            // name, it should find its own original copy.
+            return logTransition(`self-import in app-js`, request, this.resolveWithinPackage(request, originalPkg));
+        }
+        return request;
+    }
+    resolveWithinPackage(request, pkg) {
+        if ('exports' in pkg.packageJSON) {
+            // this is the easy case -- a package that uses exports can safely resolve
+            // its own name, so it's enough to let it resolve the (self-targeting)
+            // specifier from its own package root.
+            return request.rehome((0, path_1.resolve)(pkg.root, 'package.json'));
+        }
+        else {
+            // otherwise we need to just assume that internal naming is simple
+            return request.alias(request.specifier.replace(pkg.name, '.')).rehome((0, path_1.resolve)(pkg.root, 'package.json'));
+        }
+    }
+    preHandleExternal(request) {
+        if (request.isVirtual) {
+            return request;
+        }
+        let { specifier, fromFile } = request;
+        let pkg = this.owningPackage(fromFile);
         if (!pkg || !pkg.isV2Ember()) {
-            return { result: 'continue' };
+            return request;
         }
         let packageName = (0, shared_internals_1.packageName)(specifier);
         if (!packageName) {
@@ -99,20 +377,20 @@ class Resolver {
             // we do allow them to be explicitly externalized by the package author (or
             // a compat adapter). In the metadata, they would be listed in
             // package-relative form, so we need to convert this specifier to that.
-            let absoluteSpecifier = (0, path_1.resolve)((0, path_1.dirname)(this.filename), specifier);
+            let absoluteSpecifier = (0, path_1.resolve)((0, path_1.dirname)(fromFile), specifier);
             let packageRelativeSpecifier = (0, shared_internals_2.explicitRelative)(pkg.root, absoluteSpecifier);
             if (isExplicitlyExternal(packageRelativeSpecifier, pkg)) {
                 let publicSpecifier = absoluteSpecifier.replace(pkg.root, pkg.name);
-                return { result: 'external', specifier: publicSpecifier };
+                return external('beforeResolve', request, publicSpecifier);
             }
             else {
-                return { result: 'continue' };
+                return request;
             }
         }
         // absolute package imports can also be explicitly external based on their
         // full specifier name
         if (isExplicitlyExternal(specifier, pkg)) {
-            return { result: 'external', specifier };
+            return external('beforeResolve', request, specifier);
         }
         if (!pkg.meta['auto-upgraded'] && shared_internals_1.emberVirtualPeerDeps.has(packageName)) {
             // Native v2 addons are allowed to use the emberVirtualPeerDeps like
@@ -125,120 +403,167 @@ class Resolver {
             // original place they might accidentally resolve the emberVirtualPeerDeps
             // that are present there in v1 format.
             //
-            // So before we even check isResolvable, we adjust these imports to point at
-            // the app's copies instead.
-            if (shared_internals_1.emberVirtualPeerDeps.has(packageName)) {
-                if (!this.options.activeAddons[packageName]) {
-                    throw new Error(`${pkg.name} is trying to import the app's ${packageName} package, but it seems to be missing`);
-                }
-                return {
-                    result: 'redirect-to',
-                    specifier: (0, shared_internals_2.explicitRelative)((0, path_1.dirname)(this.filename), specifier.replace(packageName, this.options.activeAddons[packageName])),
-                };
+            // So before we let normal resolving happen, we adjust these imports to
+            // point at the app's copies instead.
+            if (!this.options.activeAddons[packageName]) {
+                throw new Error(`${pkg.name} is trying to import the app's ${packageName} package, but it seems to be missing`);
             }
+            let newHome = (0, path_1.resolve)(this.options.appRoot, 'package.json');
+            return logTransition(`emberVirtualPeerDeps in v2 addon`, request, request.rehome(newHome));
         }
-        let relocatedPkg = this.relocatedIntoPackage();
-        if (relocatedPkg) {
-            // this file has been moved into another package (presumably the app).
-            // first try to resolve from the destination package
-            if (isResolvable(packageName, relocatedPkg, this.options.appRoot)) {
-                // self-imports are legal in the app tree, even for v2 packages.
-                if (!pkg.meta['auto-upgraded'] && packageName !== pkg.name) {
-                    throw new Error(`${pkg.name} is trying to import ${packageName} from within its app tree. This is unsafe, because ${pkg.name} can't control which dependencies are resolvable from the app`);
+        if (pkg.meta['auto-upgraded'] && !pkg.hasDependency('ember-auto-import')) {
+            try {
+                let dep = shared_internals_2.PackageCache.shared('embroider-stage3', this.options.appRoot).resolve(packageName, pkg);
+                if (!dep.isEmberPackage()) {
+                    // classic ember addons can only import non-ember dependencies if they
+                    // have ember-auto-import.
+                    return external('v1 package without auto-import', request, specifier);
                 }
-                return { result: 'continue' };
             }
-            else {
-                // second try to resolve from the source package
-                let targetPkg = isResolvable(packageName, pkg, this.options.appRoot);
-                if (targetPkg) {
-                    // self-imports are legal in the app tree, even for v2 packages.
-                    if (!pkg.meta['auto-upgraded'] && packageName !== pkg.name) {
-                        throw new Error(`${pkg.name} is trying to import ${packageName} from within its app tree. This is unsafe, because ${pkg.name} can't control which dependencies are resolvable from the app`);
-                    }
-                    // we found it, but we need to rewrite it because it's not really going to
-                    // resolve from where its sitting
-                    return {
-                        result: 'redirect-to',
-                        specifier: (0, shared_internals_2.explicitRelative)((0, path_1.dirname)(this.filename), specifier.replace(packageName, targetPkg.root)),
-                    };
+            catch (err) {
+                if (err.code !== 'MODULE_NOT_FOUND') {
+                    throw err;
                 }
             }
         }
-        else {
-            if (isResolvable(packageName, pkg, this.options.appRoot)) {
+        // assertions on what native v2 addons can import
+        if (!pkg.meta['auto-upgraded']) {
+            let originalPkg = this.originalPackage(fromFile);
+            if (originalPkg) {
+                // this file has been moved into another package (presumably the app).
+                if (packageName !== pkg.name) {
+                    // the only thing that native v2 addons are allowed to import from
+                    // within the app tree is their own name.
+                    throw new Error(`${pkg.name} is trying to import ${packageName} from within its app tree. This is unsafe, because ${pkg.name} can't control which dependencies are resolvable from the app`);
+                }
+            }
+            else {
+                // this file has not been moved. The normal case.
                 if (!pkg.meta['auto-upgraded'] && !reliablyResolvable(pkg, packageName)) {
                     throw new Error(`${pkg.name} is trying to import from ${packageName} but that is not one of its explicit dependencies`);
                 }
-                return { result: 'continue' };
             }
         }
+        return request;
+    }
+    fallbackResolve(request) {
+        let { specifier, fromFile } = request;
+        if (compatPattern.test(specifier)) {
+            // Some kinds of compat requests get rewritten into other things
+            // deterministically. For example, "#embroider_compat/helpers/whatever"
+            // means only "the-current-engine/helpers/whatever", and if that doesn't
+            // actually exist it's that path that will show up as a missing import.
+            //
+            // But others have an ambiguous meaning. For example,
+            // #embroider_compat/components/whatever can mean several different
+            // things. If we're unable to find any of them, the actual
+            // "#embroider_compat" request will fall through all the way to here.
+            //
+            // In that case, we don't want to externalize that failure. We know it's
+            // not a classic runtime thing. It's better to let it be a build error
+            // here.
+            return request;
+        }
+        let pkg = this.owningPackage(fromFile);
+        if (!pkg || !pkg.isV2Ember()) {
+            return request;
+        }
+        let packageName = (0, shared_internals_1.packageName)(specifier);
+        if (!packageName) {
+            // this is a relative import, we have nothing more to for it.
+            return request;
+        }
+        let originalPkg = this.originalPackage(fromFile);
+        if (originalPkg) {
+            // we didn't find it from the original package, so try from the relocated
+            // package
+            return logTransition(`relocation fallback`, request, request.rehome((0, path_1.resolve)(originalPkg.root, 'package.json')));
+        }
         // auto-upgraded packages can fall back to the set of known active addons
         //
         // v2 packages can fall back to the set of known active addons only to find
         // themselves (which is needed due to app tree merging)
         if ((pkg.meta['auto-upgraded'] || packageName === pkg.name) && this.options.activeAddons[packageName]) {
-            return {
-                result: 'redirect-to',
-                specifier: (0, shared_internals_2.explicitRelative)((0, path_1.dirname)(this.filename), specifier.replace(packageName, this.options.activeAddons[packageName])),
-            };
+            return logTransition(`activeAddons`, request, this.resolveWithinPackage(request, shared_internals_2.PackageCache.shared('embroider-stage3', this.options.appRoot).get(this.options.activeAddons[packageName])));
         }
         if (pkg.meta['auto-upgraded']) {
             // auto-upgraded packages can fall back to attempting to find dependencies at
             // runtime. Native v2 packages can only get this behavior in the
             // isExplicitlyExternal case above because they need to explicitly ask for
             // externals.
-            return { result: 'external', specifier };
+            return external('v1 catch-all fallback', request, specifier);
         }
         else {
             // native v2 packages don't automatically externalize *everything* the way
             // auto-upgraded packages do, but they still externalize known and approved
             // ember virtual packages (like @ember/component)
             if (shared_internals_1.emberVirtualPackages.has(packageName)) {
-                return { result: 'external', specifier };
+                return external('emberVirtualPackages', request, specifier);
             }
         }
-        // non-resolvable imports in dynamic positions become runtime errors, not
-        // build-time errors, so we emit the runtime error module here before the
-        // stage3 packager has a chance to see the missing module. (Maybe some stage3
-        // packagers will have this behavior by default, because it would make sense,
-        // but webpack at least does not.)
-        if (isDynamic) {
-            return { result: 'runtime-failure', specifier };
-        }
         // this is falling through with the original specifier which was
         // non-resolvable, which will presumably cause a static build error in stage3.
-        return { result: 'continue' };
+        return request;
     }
-}
-__decorate([
-    (0, typescript_memoize_1.Memoize)()
-], Resolver.prototype, "owningPackage", null);
-__decorate([
-    (0, typescript_memoize_1.Memoize)()
-], Resolver.prototype, "relocatedIntoPackage", null);
-exports.Resolver = Resolver;
-function isExplicitlyExternal(specifier, fromPkg) {
-    return Boolean(fromPkg.isV2Addon() && fromPkg.meta['externals'] && fromPkg.meta['externals'].includes(specifier));
-}
-function isResolvable(packageName, fromPkg, appRoot) {
-    try {
-        let dep = shared_internals_2.PackageCache.shared('embroider-stage3', appRoot).resolve(packageName, fromPkg);
-        if (!dep.isEmberPackage() && fromPkg.meta['auto-upgraded'] && !fromPkg.hasDependency('ember-auto-import')) {
-            // classic ember addons can only import non-ember dependencies if they
-            // have ember-auto-import.
-            //
-            // whereas native v2 packages can always import any dependency
-            return false;
+    // check whether the given file with the given owningPackage is an addon's
+    // appTree, and if so return the notional location within the app (or owning
+    // engine) that it "logically" lives at.
+    reverseSearchAppTree(owningPackage, fromFile) {
+        // if the requesting file is in an addon's app-js, the request should
+        // really be understood as a request for a module in the containing engine
+        if (owningPackage.isV2Addon()) {
+            let appJS = owningPackage.meta['app-js'];
+            if (appJS) {
+                let fromPackageRelativePath = (0, shared_internals_2.explicitRelative)(owningPackage.root, fromFile);
+                for (let [inAppName, inAddonName] of Object.entries(appJS)) {
+                    if (inAddonName === fromPackageRelativePath) {
+                        return { owningEngine: this.owningEngine(owningPackage), inAppName };
+                    }
+                }
+            }
         }
-        return dep;
     }
-    catch (err) {
-        if (err.code !== 'MODULE_NOT_FOUND') {
-            throw err;
+    // check if this file is resolvable as a global component, and if so return
+    // its dasherized name
+    reverseComponentLookup(filename) {
+        const owningPackage = this.owningPackage(filename);
+        if (!(owningPackage === null || owningPackage === void 0 ? void 0 : owningPackage.isV2Ember())) {
+            return;
+        }
+        let engineConfig = this.options.engines.find(e => e.root === owningPackage.root);
+        if (engineConfig) {
+            // we're directly inside an engine, so we're potentially resolvable as a
+            // global component
+            // this kind of mapping is not true in general for all packages, but it
+            // *is* true for all classical engines (which includes apps) since they
+            // don't support package.json `exports`. As for a future v2 engine or app:
+            // this whole method is only relevant for implementing packageRules, which
+            // should only be for classic stuff. v2 packages should do the right
+            // things from the beginning and not need packageRules about themselves.
+            let inAppName = (0, shared_internals_2.explicitRelative)(engineConfig.root, filename);
+            return this.tryReverseComponent(engineConfig.packageName, inAppName);
+        }
+        let engineInfo = this.reverseSearchAppTree(owningPackage, filename);
+        if (engineInfo) {
+            // we're in some addon's app tree, so we're potentially resolvable as a
+            // global component
+            return this.tryReverseComponent(engineInfo.owningEngine.packageName, engineInfo.inAppName);
         }
-        return false;
     }
+    tryReverseComponent(inEngineName, relativePath) {
+        let extensionless = relativePath.replace((0, shared_internals_1.extensionsPattern)(this.options.resolvableExtensions), '');
+        let candidates = [...this.componentJSCandidates(inEngineName), ...this.componentTemplateCandidates(inEngineName)];
+        for (let candidate of candidates) {
+            if (extensionless.startsWith(`.${candidate.prefix}`) && extensionless.endsWith(candidate.suffix)) {
+                return extensionless.slice(candidate.prefix.length + 1, extensionless.length - candidate.suffix.length);
+            }
+        }
+        return undefined;
+    }
+}
+exports.Resolver = Resolver;
+function isExplicitlyExternal(specifier, fromPkg) {
+    return Boolean(fromPkg.isV2Addon() && fromPkg.meta['externals'] && fromPkg.meta['externals'].includes(specifier));
 }
 // we don't want to allow things that resolve only by accident that are likely
 // to break in other setups. For example: import your dependencies'
@@ -252,9 +577,13 @@ function reliablyResolvable(pkg, packageName) {
     if (pkg.name === packageName && pkg.packageJSON.exports) {
         return true;
     }
-    if (shared_internals_1.emberVirtualPeerDeps.has(packageName)) {
+    if (shared_internals_1.emberVirtualPeerDeps.has(packageName) || shared_internals_1.emberVirtualPackages.has(packageName)) {
         return true;
     }
     return false;
 }
+function external(label, request, specifier) {
+    let filename = (0, virtual_content_1.virtualExternalModule)(specifier);
+    return logTransition(label, request, request.virtualize(filename));
+}
 //# sourceMappingURL=module-resolver.js.map