[BUGFIX] Fix runtime/lint errors in StrictResolver tests and add missing pluralizations (#21403)

* Fix `module` global lint error in StrictResolver basic-test

The nested 'weird scenarios' module was using the QUnit global `module`
instead of `QUnit.module`, which fails the `qunit/no-global-module-test`
lint rule and also breaks the test bundle at runtime.



* Fix runtime errors and add missing pluralizations

- Use the global `QUnit` in the resolver test files instead of
  `import * as QUnit from 'qunit'`. The vite virtual qunit module
  only exports `q`, so the namespace import produces `{ q }` and
  destructuring `test` / `module` from it yields `undefined`. This
  caused "Uncaught TypeError: test is not a function" at script load
  and prevented the entire test bundle from running. All other Ember
  test files in this repo already use `QUnit` as a global.

- Add `helper` and `service` to `KNOWN_EASY_PLURALS`. The PR's tests
  (resolves the standard ember types via default pluralization,
  module paths with ./ prefix are normalized, etc.) expect
  `service:foo -> services/foo` and `helper:foo -> helpers/foo`,
  but the resolver was leaving them un-pluralized.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* Fix `project is not defined` in strictResolver smoke scenario

The generated app.js template iterates the outer scenarios' `project`
parameter instead of its own inner `modules` parameter — at runtime in
the app, `project` is undefined, so the smoke app crashes at load with
`ReferenceError: project is not defined`.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* Add strict-resolver.js to tree-shakability snapshots

The PR adds @ember/engine/lib/strict-resolver.ts as a new entrypoint
which is fully tree-shakable. Node.js Tests' tree-shakability snapshot
needs to include it. This check was skipped on the PR's original CI
because Basic Test failed first.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* Fix `fixModulePrefix` regex in strictResolver smoke scenario

\`compatModules\` from \`@embroider/virtual/compat-modules\` emits keys
shaped like \`<modulePrefix>/<rest>\` (e.g.
\`v2-app-template/routes/example-gjs-route\`). The strict resolver
expects \`./<rest>\` (or just \`<rest>\` — leading \`./\` is normalized
off).

The previous regex \`new RegExp(\`/\${config.modulePrefix}\\//\`)\`
was buggy two ways:

- In a template literal, \`\\/\` is just \`/\` (the backslash before a
  slash is not an escape sequence in a string), so the pattern
  actually was \`/<modulePrefix>//\` — a literal double slash.
- The leading slash required a slash before the prefix, but
  compatModules' keys do not have one.

Together those meant the regex never matched any key, so the strict
resolver received \`<modulePrefix>/routes/example-gjs-route\` and
could not resolve \`route:example-gjs-route\`. The router then
threw \`UnrecognizedURLError\` on the smoke acceptance test.

Replace the regex with a plain \`startsWith\` / \`slice\` since the
modulePrefix can contain regex-special characters and a plain string
strip is unambiguous. This makes the \`strictResolver-basics\` smoke
test (both regular and Deprecations Removed variants) pass.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: NullVoxPopuli-ai-agent <theprecognition+claude@gmail.com>
Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: 3 people

packages/@ember/engine/lib/strict-resolver.ts

@@ -4,10 +4,12 @@ const KNOWN_EASY_PLURALS = new Set([
   'adapter',
   'component',
   'controller',
+  'helper',
   'model',
   'modifier',
   'route',
   'serializer',
+  'service',
   'template',
 ]);
 

packages/@ember/engine/tests/resolver/basic-test.js

@@ -1,9 +1,8 @@
 import { StrictResolver } from '@ember/engine/lib/strict-resolver';
 
-import * as QUnit from 'qunit';
-const { test } = QUnit;
+const { module, test } = QUnit;
 
-QUnit.module('StrictResolver', function (hooks) {
+module('StrictResolver', function (hooks) {
   let resolver;
   let modules;
 
@@ -12,7 +11,7 @@ QUnit.module('StrictResolver', function (hooks) {
     resolver = new StrictResolver(modules);
   });
 
-  QUnit.module('#resolve + #addModules', function () {
+  module('#resolve + #addModules', function () {
     test('resolves the standard ember types via default pluralization', function (assert) {
       // All of these go through the same `type + 's' -> dir` path. One table-
       // driven test keeps the coverage without nine copies of the same setup.
@@ -63,7 +62,7 @@ QUnit.module('StrictResolver', function (hooks) {
     });
   });
 
-  QUnit.module('#addModules + normalization', function () {
+  module('#addModules + normalization', function () {
     test('normalization', function (assert) {
       assert.strictEqual(resolver.normalize('controller:posts'), 'controller:posts');
       assert.strictEqual(resolver.normalize('controller:postsIndex'), 'controller:posts-index');

packages/@ember/engine/tests/resolver/registry_test.ts

@@ -1,12 +1,11 @@
-import * as QUnit from 'qunit';
 import Application from '@ember/application';
 import Service from '@ember/service';
 import { run } from '@ember/runloop';
 import type ApplicationInstance from '@ember/application/instance';
 
-const { test } = QUnit;
+const { module, test } = QUnit;
 
-QUnit.module('strict-resolver | Application with modules', function (hooks) {
+module('strict-resolver | Application with modules', function (hooks) {
   let app: Application | undefined;
   let instance: ApplicationInstance | undefined;
 

smoke-tests/scenarios/scenarios.ts

@@ -37,12 +37,16 @@ function strictResolver(project: Project) {
 
         /**
          * See: https://github.com/embroider-build/embroider/issues/2708
+         *
+         * @embroider/virtual/compat-modules emits keys like
+         * \`<modulePrefix>/<rest>\`. The strict resolver expects \`./<rest>\`.
          */
         function fixModulePrefix(modules) {
           let fixed = {};
+          let prefix = config.modulePrefix + '/';
 
-          for (let [key, module] of Object.entries(project)) {
-            let newName = key.replace(new RegExp(\`/\${config.modulePrefix}\//\`), './');
+          for (let [key, module] of Object.entries(modules)) {
+            let newName = key.startsWith(prefix) ? './' + key.slice(prefix.length) : key;
             fixed[newName] = module;
           }
 

tests/node-vitest/tree-shakability.test.js

@@ -58,6 +58,7 @@ it('[dev] has expected tree-shakable entrypoints', async () => {
       "ember-source/@ember/deprecated-features/index.js",
       "ember-source/@ember/destroyable/index.js",
       "ember-source/@ember/engine/lib/engine-parent.js",
+      "ember-source/@ember/engine/lib/strict-resolver.js",
       "ember-source/@ember/engine/parent.js",
       "ember-source/@ember/owner/index.js",
       "ember-source/@ember/reactive/index.js",
@@ -251,6 +252,7 @@ it('[prod] has expected tree-shakable entrypoints', async () => {
       "ember-source/@ember/deprecated-features/index.js",
       "ember-source/@ember/destroyable/index.js",
       "ember-source/@ember/engine/lib/engine-parent.js",
+      "ember-source/@ember/engine/lib/strict-resolver.js",
       "ember-source/@ember/engine/parent.js",
       "ember-source/@ember/owner/index.js",
       "ember-source/@ember/reactive/index.js",