diff --git a/packages/@ember/-internals/deprecations/index.ts b/packages/@ember/-internals/deprecations/index.ts
index 041b533468d..14dc41b3ce4 100644
--- a/packages/@ember/-internals/deprecations/index.ts
+++ b/packages/@ember/-internals/deprecations/index.ts
@@ -106,6 +106,15 @@ export const DEPRECATIONS = {
       available: '5.9.0',
     },
   }),
+  DEPRECATE_COMPONENT_TEMPLATE_RESOLVING: deprecation({
+    id: 'component-template-resolving',
+    url: 'https://deprecations.emberjs.com/id/component-template-resolving',
+    until: '6.0.0',
+    for: 'ember-source',
+    since: {
+      available: '5.9.0',
+    },
+  }),
 };
 
 export function deprecateUntil(message: string, deprecation: DeprecationObject) {
diff --git a/packages/@ember/-internals/glimmer/lib/resolver.ts b/packages/@ember/-internals/glimmer/lib/resolver.ts
index 26530594b4c..3df207331b0 100644
--- a/packages/@ember/-internals/glimmer/lib/resolver.ts
+++ b/packages/@ember/-internals/glimmer/lib/resolver.ts
@@ -45,6 +45,7 @@ import { default as uniqueId } from './helpers/unique-id';
 import actionModifier from './modifiers/action';
 import { mountHelper } from './syntax/mount';
 import { outletHelper } from './syntax/outlet';
+import { DEPRECATIONS, deprecateUntil } from '@ember/-internals/deprecations';
 
 function instrumentationPayload(name: string) {
   return { object: `component:${name}` };
@@ -63,9 +64,22 @@ function layoutFor(
   owner: InternalOwner,
   options?: RegisterOptions
 ): Nullable<Template> {
+  if (DEPRECATIONS.DEPRECATE_COMPONENT_TEMPLATE_RESOLVING.isRemoved) {
+    return null;
+  }
+
   let templateFullName = `template:components/${name}` as const;
 
-  return (owner.lookup(templateFullName, options) as Template) || null;
+  let result = (owner.lookup(templateFullName, options) as Template) || null;
+
+  if (result) {
+    deprecateUntil(
+      `Components with separately resolved templates are deprecated. Migrate to either co-located js/ts + hbs files or to gjs/gts. Tried to lookup '${templateFullName}'.`,
+      DEPRECATIONS.DEPRECATE_COMPONENT_TEMPLATE_RESOLVING
+    );
+  }
+
+  return result;
 }
 
 type LookupResult =
diff --git a/packages/@ember/-internals/glimmer/tests/integration/application/debug-render-tree-test.ts b/packages/@ember/-internals/glimmer/tests/integration/application/debug-render-tree-test.ts
index 8be91a4e555..fdec69d40a2 100644
--- a/packages/@ember/-internals/glimmer/tests/integration/application/debug-render-tree-test.ts
+++ b/packages/@ember/-internals/glimmer/tests/integration/application/debug-render-tree-test.ts
@@ -1,8 +1,10 @@
 import {
   ApplicationTestCase,
   ModuleBasedTestResolver,
+  expectDeprecation,
   moduleFor,
   strip,
+  testUnless,
 } from 'internal-test-helpers';
 
 import { ENV } from '@ember/-internals/environment';
@@ -22,6 +24,8 @@ import type { SimpleElement, SimpleNode } from '@simple-dom/interface';
 import type { EmberPrecompileOptions } from 'ember-template-compiler';
 import { compile } from 'ember-template-compiler';
 import { runTask } from 'internal-test-helpers/lib/run';
+import { DEPRECATIONS } from '@ember/-internals/deprecations';
+import templateOnly from '@ember/component/template-only';
 
 interface CapturedBounds {
   parentElement: SimpleElement;
@@ -204,10 +208,13 @@ if (ENV._DEBUG_RENDER_TREE) {
                 )
               );
               this.register(
-                'template:components/inspect-model',
-                compileTemplate('{{@model}}', {
-                  moduleName: 'foo/components/inspect-model.hbs',
-                })
+                'component:inspect-model',
+                setComponentTemplate(
+                  compileTemplate('{{@model}}', {
+                    moduleName: 'foo/components/inspect-model.hbs',
+                  }),
+                  templateOnly()
+                )
               );
             }
 
@@ -242,10 +249,13 @@ if (ENV._DEBUG_RENDER_TREE) {
                 )
               );
               this.register(
-                'template:components/inspect-model',
-                compileTemplate('{{@model}}', {
-                  moduleName: 'bar/components/inspect-model.hbs',
-                })
+                'component:inspect-model',
+                setComponentTemplate(
+                  compileTemplate('{{@model}}', {
+                    moduleName: 'bar/components/inspect-model.hbs',
+                  }),
+                  templateOnly()
+                )
               );
             }
 
@@ -608,10 +618,13 @@ if (ENV._DEBUG_RENDER_TREE) {
                 })
               );
               this.register(
-                'template:components/hello',
-                compileTemplate('<span>Hello {{@message}}</span>', {
-                  moduleName: 'foo/components/hello.hbs',
-                })
+                'component:hello',
+                setComponentTemplate(
+                  compileTemplate('<span>Hello {{@message}}</span>', {
+                    moduleName: 'foo/components/hello.hbs',
+                  }),
+                  templateOnlyComponent()
+                )
               );
             }
 
@@ -775,7 +788,13 @@ if (ENV._DEBUG_RENDER_TREE) {
         ]);
       }
 
-      async '@test template-only components'() {
+      async [`${testUnless(
+        DEPRECATIONS.DEPRECATE_COMPONENT_TEMPLATE_RESOLVING.isRemoved
+      )} template-only components`]() {
+        expectDeprecation(
+          /resolved templates/,
+          DEPRECATIONS.DEPRECATE_COMPONENT_TEMPLATE_RESOLVING.isEnabled
+        );
         this.addTemplate(
           'application',
           strip`
@@ -800,7 +819,7 @@ if (ENV._DEBUG_RENDER_TREE) {
             name: 'hello-world',
             args: { positional: [], named: { name: 'first' } },
             instance: null,
-            template: 'my-app/templates/components/hello-world.hbs',
+            template: '(unknown template module)',
             bounds: this.nodeBounds(this.element!.firstChild),
             children: [],
           },
@@ -816,7 +835,7 @@ if (ENV._DEBUG_RENDER_TREE) {
             name: 'hello-world',
             args: { positional: [], named: { name: 'first' } },
             instance: null,
-            template: 'my-app/templates/components/hello-world.hbs',
+            template: '(unknown template module)',
             bounds: this.nodeBounds(this.element!.firstChild),
             children: [],
           },
@@ -825,7 +844,7 @@ if (ENV._DEBUG_RENDER_TREE) {
             name: 'hello-world',
             args: { positional: [], named: { name: 'second' } },
             instance: null,
-            template: 'my-app/templates/components/hello-world.hbs',
+            template: '(unknown template module)',
             bounds: this.nodeBounds(this.element!.lastChild),
             children: [],
           },
@@ -841,7 +860,7 @@ if (ENV._DEBUG_RENDER_TREE) {
             name: 'hello-world',
             args: { positional: [], named: { name: 'first' } },
             instance: null,
-            template: 'my-app/templates/components/hello-world.hbs',
+            template: '(unknown template module)',
             bounds: this.nodeBounds(this.element!.firstChild),
             children: [],
           },
@@ -873,7 +892,7 @@ if (ENV._DEBUG_RENDER_TREE) {
             name: 'hello-world',
             args: { positional: [], named: { name: 'first' } },
             instance: null,
-            template: 'my-app/templates/components/hello-world.hbs',
+            template: '(unknown template module)',
             bounds: this.nodeBounds(this.element!.firstChild),
             children: [],
           },
@@ -889,7 +908,7 @@ if (ENV._DEBUG_RENDER_TREE) {
             name: 'hello-world',
             args: { positional: [], named: { name: 'first' } },
             instance: null,
-            template: 'my-app/templates/components/hello-world.hbs',
+            template: '(unknown template module)',
             bounds: this.nodeBounds(this.element!.firstChild),
             children: [],
           },
@@ -898,7 +917,7 @@ if (ENV._DEBUG_RENDER_TREE) {
             name: 'hello-world',
             args: { positional: [], named: { name: 'second' } },
             instance: null,
-            template: 'my-app/templates/components/hello-world.hbs',
+            template: '(unknown template module)',
             bounds: this.nodeBounds(this.element!.lastChild),
             children: [],
           },
@@ -914,7 +933,7 @@ if (ENV._DEBUG_RENDER_TREE) {
             name: 'hello-world',
             args: { positional: [], named: { name: 'first' } },
             instance: null,
-            template: 'my-app/templates/components/hello-world.hbs',
+            template: '(unknown template module)',
             bounds: this.nodeBounds(this.element!.firstChild),
             children: [],
           },
@@ -936,7 +955,7 @@ if (ENV._DEBUG_RENDER_TREE) {
         this.addComponent('hello-world', {
           ComponentClass: setComponentTemplate(
             compileTemplate('{{@name}}', { moduleName: 'my-app/components/hello-world.hbs' }),
-            templateOnlyComponent()
+            templateOnlyComponent('my-app/components/hello-world', 'HelloWorld')
           ),
         });
 
@@ -1021,7 +1040,7 @@ if (ENV._DEBUG_RENDER_TREE) {
             name: 'hello-world',
             args: { positional: [], named: { name: 'first' } },
             instance: (instance: Record<string, string>) => instance['name'] === 'first',
-            template: 'my-app/templates/components/hello-world.hbs',
+            template: '(unknown template module)',
             bounds: this.nodeBounds(this.element!.firstChild),
             children: [],
           },
@@ -1037,7 +1056,7 @@ if (ENV._DEBUG_RENDER_TREE) {
             name: 'hello-world',
             args: { positional: [], named: { name: 'first' } },
             instance: (instance: Record<string, string>) => instance['name'] === 'first',
-            template: 'my-app/templates/components/hello-world.hbs',
+            template: '(unknown template module)',
             bounds: this.nodeBounds(this.element!.firstChild),
             children: [],
           },
@@ -1046,7 +1065,7 @@ if (ENV._DEBUG_RENDER_TREE) {
             name: 'hello-world',
             args: { positional: [], named: { name: 'second' } },
             instance: (instance: Record<string, string>) => instance['name'] === 'second',
-            template: 'my-app/templates/components/hello-world.hbs',
+            template: '(unknown template module)',
             bounds: this.nodeBounds(this.element!.lastChild),
             children: [],
           },
@@ -1062,7 +1081,7 @@ if (ENV._DEBUG_RENDER_TREE) {
             name: 'hello-world',
             args: { positional: [], named: { name: 'first' } },
             instance: (instance: Record<string, string>) => instance['name'] === 'first',
-            template: 'my-app/templates/components/hello-world.hbs',
+            template: '(unknown template module)',
             bounds: this.nodeBounds(this.element!.firstChild),
             children: [],
           },
@@ -1106,7 +1125,7 @@ if (ENV._DEBUG_RENDER_TREE) {
             name: 'hello-world',
             args: { positional: [], named: { name: 'first' } },
             instance: (instance: Record<string, string>) => instance['name'] === 'first',
-            template: 'my-app/templates/components/hello-world.hbs',
+            template: '(unknown template module)',
             bounds: this.nodeBounds(this.element!.firstChild),
             children: [],
           },
@@ -1122,7 +1141,7 @@ if (ENV._DEBUG_RENDER_TREE) {
             name: 'hello-world',
             args: { positional: [], named: { name: 'first' } },
             instance: (instance: Record<string, string>) => instance['name'] === 'first',
-            template: 'my-app/templates/components/hello-world.hbs',
+            template: '(unknown template module)',
             bounds: this.nodeBounds(this.element!.firstChild),
             children: [],
           },
@@ -1131,7 +1150,7 @@ if (ENV._DEBUG_RENDER_TREE) {
             name: 'hello-world',
             args: { positional: [], named: { name: 'second' } },
             instance: (instance: Record<string, string>) => instance['name'] === 'second',
-            template: 'my-app/templates/components/hello-world.hbs',
+            template: '(unknown template module)',
             bounds: this.nodeBounds(this.element!.lastChild),
             children: [],
           },
@@ -1147,7 +1166,7 @@ if (ENV._DEBUG_RENDER_TREE) {
             name: 'hello-world',
             args: { positional: [], named: { name: 'first' } },
             instance: (instance: Record<string, string>) => instance['name'] === 'first',
-            template: 'my-app/templates/components/hello-world.hbs',
+            template: '(unknown template module)',
             bounds: this.nodeBounds(this.element!.firstChild),
             children: [],
           },
diff --git a/packages/@ember/-internals/glimmer/tests/integration/application/engine-test.js b/packages/@ember/-internals/glimmer/tests/integration/application/engine-test.js
index 247c9c27674..1354ef45fd9 100644
--- a/packages/@ember/-internals/glimmer/tests/integration/application/engine-test.js
+++ b/packages/@ember/-internals/glimmer/tests/integration/application/engine-test.js
@@ -14,6 +14,8 @@ import Engine from '@ember/engine';
 import { next } from '@ember/runloop';
 
 import { compile } from '../../utils/helpers';
+import { setComponentTemplate } from '@glimmer/manager';
+import { templateOnlyComponent } from '@glimmer/runtime';
 
 moduleFor(
   'Application test: engine rendering',
@@ -217,10 +219,8 @@ moduleFor(
             );
             this.register('template:application', sharedTemplate);
             this.register(
-              'template:components/ambiguous-curlies',
-              compile(strip`
-        <p>Component!</p>
-      `)
+              'component:ambiguous-curlies',
+              setComponentTemplate(compile(`<p>Component!</p>`), templateOnlyComponent())
             );
           },
         })
@@ -275,10 +275,8 @@ moduleFor(
             );
             this.register('component:my-component', sharedComponent);
             this.register(
-              'template:components/ambiguous-curlies',
-              compile(strip`
-                <p>Component!</p>
-              `)
+              'component:ambiguous-curlies',
+              setComponentTemplate(compile(`<p>Component!</p>`), templateOnlyComponent())
             );
           },
         })
diff --git a/packages/@ember/-internals/glimmer/tests/integration/components/append-test.js b/packages/@ember/-internals/glimmer/tests/integration/components/append-test.js
index ae7cbd22079..e2ca6840649 100644
--- a/packages/@ember/-internals/glimmer/tests/integration/components/append-test.js
+++ b/packages/@ember/-internals/glimmer/tests/integration/components/append-test.js
@@ -1,8 +1,10 @@
-import { moduleFor, RenderingTestCase, strip, runTask } from 'internal-test-helpers';
+import { moduleFor, RenderingTestCase, strip, runTask, testUnless } from 'internal-test-helpers';
 
 import { set } from '@ember/object';
 
 import { Component, compile } from '../../utils/helpers';
+import { DEPRECATIONS } from '../../../../deprecations';
+import { setComponentTemplate } from '@glimmer/manager';
 
 class AbstractAppendTest extends RenderingTestCase {
   constructor() {
@@ -37,7 +39,249 @@ class AbstractAppendTest extends RenderingTestCase {
     this.ids.push(component.elementId);
   }
 
-  ['@test lifecycle hooks during component append'](assert) {
+  [`@test (new) lifecycle hooks during component append`](assert) {
+    let hooks = [];
+
+    let componentsByName = {};
+
+    let createLogger = (name, template, extras = {}) => {
+      function pushHook(hookName) {
+        hooks.push([name, hookName]);
+      }
+
+      let LoggerComponent = Component.extend({
+        init() {
+          this._super(...arguments);
+          if (name in componentsByName) {
+            throw new TypeError('Component named: ` ' + name + ' ` already registered');
+          }
+          componentsByName[name] = this;
+          pushHook('init');
+          this.on('init', () => pushHook('on(init)'));
+        },
+
+        didReceiveAttrs() {
+          pushHook('didReceiveAttrs');
+        },
+
+        willInsertElement() {
+          pushHook('willInsertElement');
+        },
+
+        willRender() {
+          pushHook('willRender');
+        },
+
+        didInsertElement() {
+          pushHook('didInsertElement');
+        },
+
+        didRender() {
+          pushHook('didRender');
+        },
+
+        didUpdateAttrs() {
+          pushHook('didUpdateAttrs');
+        },
+
+        willUpdate() {
+          pushHook('willUpdate');
+        },
+
+        didUpdate() {
+          pushHook('didUpdate');
+        },
+
+        willDestroyElement() {
+          pushHook('willDestroyElement');
+        },
+
+        willClearRender() {
+          pushHook('willClearRender');
+        },
+
+        didDestroyElement() {
+          pushHook('didDestroyElement');
+        },
+
+        willDestroy() {
+          pushHook('willDestroy');
+          this._super(...arguments);
+        },
+      });
+
+      let local = LoggerComponent.extend(extras);
+
+      setComponentTemplate(compile(template), local);
+
+      this.owner.register(`component:${name}`, local);
+
+      return local;
+    };
+
+    createLogger(
+      'x-parent',
+      `[parent: {{this.foo}}]
+       [parent: {{this.parentValue}}
+
+        <XChild @bar={{this.foo}} @childValue={{this.childValue}}>
+         [yielded: {{this.foo}}]
+        </XChild>
+      `
+    );
+    createLogger(
+      'x-child',
+      `
+      [child: {{this.bar}}]
+      [child: {{this.childValue}}]
+      {{yield}}`
+    );
+
+    this.render(
+      `
+      {{#if this.show}}
+        <XParent @foo={{this.foo}} @parentValue={{this.parentValue}} @childValue={{this.childValue}} />
+      {{/if}}`,
+      { parentValue: 1, childValue: 1, foo: 'zomg', show: true }
+    );
+
+    assert.deepEqual(
+      hooks,
+      [
+        ['x-parent', 'init'],
+        ['x-parent', 'on(init)'],
+        ['x-parent', 'didReceiveAttrs'],
+        ['x-parent', 'willRender'],
+        ['x-parent', 'willInsertElement'],
+        ['x-child', 'init'],
+        ['x-child', 'on(init)'],
+        ['x-child', 'didReceiveAttrs'],
+        ['x-child', 'willRender'],
+        ['x-child', 'willInsertElement'],
+        ['x-child', 'didInsertElement'],
+        ['x-child', 'didRender'],
+        ['x-parent', 'didInsertElement'],
+        ['x-parent', 'didRender'],
+      ],
+      'creation of x-parent'
+    );
+
+    hooks.length = 0;
+    runTask(() => this.rerender());
+
+    assert.deepEqual(hooks, [], 'no-op re-render of parent');
+
+    hooks.length = 0;
+
+    runTask(() => set(this.context, 'parentValue', 2));
+    runTask(() => this.rerender());
+
+    assert.deepEqual(
+      hooks,
+      [
+        ['x-parent', 'didUpdateAttrs'],
+        ['x-parent', 'didReceiveAttrs'],
+        ['x-parent', 'willUpdate'],
+        ['x-parent', 'willRender'],
+        ['x-parent', 'didUpdate'],
+        ['x-parent', 'didRender'],
+      ],
+      'rerender x-parent'
+    );
+
+    hooks.length = 0;
+
+    runTask(() => set(this.context, 'childValue', 2));
+
+    assert.deepEqual(
+      hooks,
+
+      [
+        ['x-parent', 'didUpdateAttrs'],
+        ['x-parent', 'didReceiveAttrs'],
+        ['x-parent', 'willUpdate'],
+        ['x-parent', 'willRender'],
+        ['x-child', 'didUpdateAttrs'],
+        ['x-child', 'didReceiveAttrs'],
+        ['x-child', 'willUpdate'],
+        ['x-child', 'willRender'],
+        ['x-child', 'didUpdate'],
+        ['x-child', 'didRender'],
+        ['x-parent', 'didUpdate'],
+        ['x-parent', 'didRender'],
+      ],
+      'rerender x-child'
+    );
+
+    hooks.length = 0;
+
+    runTask(() => set(this.context, 'foo', 'wow'));
+
+    assert.deepEqual(
+      hooks,
+      [
+        ['x-parent', 'didUpdateAttrs'],
+        ['x-parent', 'didReceiveAttrs'],
+        ['x-parent', 'willUpdate'],
+        ['x-parent', 'willRender'],
+        ['x-child', 'didUpdateAttrs'],
+        ['x-child', 'didReceiveAttrs'],
+        ['x-child', 'willUpdate'],
+        ['x-child', 'willRender'],
+        ['x-child', 'didUpdate'],
+        ['x-child', 'didRender'],
+        ['x-parent', 'didUpdate'],
+        ['x-parent', 'didRender'],
+      ],
+      'set foo = wow'
+    );
+
+    hooks.length = 0;
+
+    runTask(() => set(this.context, 'foo', 'zomg'));
+
+    assert.deepEqual(
+      hooks,
+      [
+        ['x-parent', 'didUpdateAttrs'],
+        ['x-parent', 'didReceiveAttrs'],
+        ['x-parent', 'willUpdate'],
+        ['x-parent', 'willRender'],
+        ['x-child', 'didUpdateAttrs'],
+        ['x-child', 'didReceiveAttrs'],
+        ['x-child', 'willUpdate'],
+        ['x-child', 'willRender'],
+        ['x-child', 'didUpdate'],
+        ['x-child', 'didRender'],
+        ['x-parent', 'didUpdate'],
+        ['x-parent', 'didRender'],
+      ],
+      'set foo = zomg'
+    );
+
+    hooks.length = 0;
+
+    runTask(() => set(this.context, 'show', false));
+
+    assert.deepEqual(
+      hooks,
+      [
+        ['x-parent', 'willDestroyElement'],
+        ['x-parent', 'willClearRender'],
+        ['x-child', 'willDestroyElement'],
+        ['x-child', 'willClearRender'],
+        ['x-parent', 'didDestroyElement'],
+        ['x-child', 'didDestroyElement'],
+        ['x-parent', 'willDestroy'],
+        ['x-child', 'willDestroy'],
+      ],
+      'destroy'
+    );
+  }
+
+  [`${testUnless(
+    DEPRECATIONS.DEPRECATE_COMPONENT_TEMPLATE_RESOLVING.isRemoved
+  )} lifecycle hooks during component append`](assert) {
     let hooks = [];
 
     let oldRegisterComponent = this.registerComponent;
@@ -110,7 +354,7 @@ class AbstractAppendTest extends RenderingTestCase {
             this._super(...arguments);
           },
         }),
-        template: _options.template,
+        resolveableTemplate: _options.resolveableTemplate,
       };
 
       oldRegisterComponent.call(this, name, options);
@@ -121,7 +365,7 @@ class AbstractAppendTest extends RenderingTestCase {
         layoutName: 'components/x-parent',
       }),
 
-      template:
+      resolveableTemplate:
         '[parent: {{this.foo}}]{{#x-child bar=this.foo}}[yielded: {{this.foo}}]{{/x-child}}',
     });
 
@@ -130,7 +374,7 @@ class AbstractAppendTest extends RenderingTestCase {
         tagName: '',
       }),
 
-      template: '[child: {{this.bar}}]{{yield}}',
+      resolveableTemplate: '[child: {{this.bar}}]{{yield}}',
     });
 
     let XParent;
@@ -283,7 +527,9 @@ class AbstractAppendTest extends RenderingTestCase {
     );
   }
 
-  ['@test appending, updating and destroying a single component'](assert) {
+  [`${testUnless(
+    DEPRECATIONS.DEPRECATE_COMPONENT_TEMPLATE_RESOLVING.isRemoved
+  )} appending, updating and destroying a single component`](assert) {
     let willDestroyCalled = 0;
 
     this.registerComponent('x-parent', {
@@ -294,7 +540,7 @@ class AbstractAppendTest extends RenderingTestCase {
         },
       }),
 
-      template:
+      resolveableTemplate:
         '[parent: {{this.foo}}]{{#x-child bar=this.foo}}[yielded: {{this.foo}}]{{/x-child}}',
     });
 
@@ -303,7 +549,7 @@ class AbstractAppendTest extends RenderingTestCase {
         tagName: '',
       }),
 
-      template: '[child: {{this.bar}}]{{yield}}',
+      resolveableTemplate: '[child: {{this.bar}}]{{yield}}',
     });
 
     let XParent;
@@ -389,7 +635,9 @@ class AbstractAppendTest extends RenderingTestCase {
     assert.equal(renderer._roots.length, 0, 'released the root component');
   }
 
-  ['@test appending, updating and destroying multiple components'](assert) {
+  [`${testUnless(
+    DEPRECATIONS.DEPRECATE_COMPONENT_TEMPLATE_RESOLVING.isRemoved
+  )} appending, updating and destroying multiple components`](assert) {
     let willDestroyCalled = 0;
 
     this.registerComponent('x-first', {
@@ -401,7 +649,7 @@ class AbstractAppendTest extends RenderingTestCase {
         },
       }),
 
-      template: 'x-first {{this.foo}}!',
+      resolveableTemplate: 'x-first {{this.foo}}!',
     });
 
     this.registerComponent('x-second', {
@@ -413,7 +661,7 @@ class AbstractAppendTest extends RenderingTestCase {
         },
       }),
 
-      template: 'x-second {{this.bar}}!',
+      resolveableTemplate: 'x-second {{this.bar}}!',
     });
 
     let First, Second;
@@ -704,7 +952,7 @@ moduleFor(
         ComponentClass: Component.extend({
           layoutName: 'components/foo-bar',
         }),
-        template: 'FOO BAR!',
+        resolveableTemplate: 'FOO BAR!',
       });
 
       let FooBar = this.owner.factoryFor('component:foo-bar');
diff --git a/packages/@ember/-internals/glimmer/tests/integration/components/component-template-test.js b/packages/@ember/-internals/glimmer/tests/integration/components/component-template-test.js
index cc9ae573d96..d43ff551fbb 100644
--- a/packages/@ember/-internals/glimmer/tests/integration/components/component-template-test.js
+++ b/packages/@ember/-internals/glimmer/tests/integration/components/component-template-test.js
@@ -1,8 +1,15 @@
 import { DEBUG } from '@glimmer/env';
-import { moduleFor, RenderingTestCase, runTask } from 'internal-test-helpers';
+import {
+  expectDeprecation,
+  moduleFor,
+  RenderingTestCase,
+  runTask,
+  testUnless,
+} from 'internal-test-helpers';
 
 import { setComponentTemplate, getComponentTemplate } from '@glimmer/manager';
 import { Component, compile } from '../../utils/helpers';
+import { DEPRECATIONS } from '../../../../deprecations';
 
 moduleFor(
   'Components test: setComponentTemplate',
@@ -21,10 +28,14 @@ moduleFor(
       this.assertComponentElement(this.firstChild, { content: 'hello' });
     }
 
-    '@test it takes precedence over resolver'() {
+    [`${testUnless(
+      DEPRECATIONS.DEPRECATE_COMPONENT_TEMPLATE_RESOLVING.isRemoved
+    )} it takes precedence over resolver`]() {
+      expectDeprecation('', DEPRECATIONS.DEPRECATE_COMPONENT_TEMPLATE_RESOLVING.isEnabled);
+
       this.registerComponent('foo-bar', {
         ComponentClass: setComponentTemplate(compile('hello'), Component.extend()),
-        template: 'noooooo!',
+        resolveableTemplate: 'noooooo!',
       });
 
       this.render('<FooBar />');
diff --git a/packages/@ember/-internals/glimmer/tests/integration/components/curly-components-test.js b/packages/@ember/-internals/glimmer/tests/integration/components/curly-components-test.js
index 63ade99e232..afa67145fd3 100644
--- a/packages/@ember/-internals/glimmer/tests/integration/components/curly-components-test.js
+++ b/packages/@ember/-internals/glimmer/tests/integration/components/curly-components-test.js
@@ -1267,7 +1267,7 @@ moduleFor(
         this.registerComponent('non-block', {
           template: 'In layout - someProp: {{attrs.someProp}}',
         });
-      }, "Using {{attrs}} to reference named arguments is not supported. {{attrs.someProp}} should be updated to {{@someProp}}. ('my-app/templates/components/non-block.hbs' @ L1:C24) ");
+      }, 'Using {{attrs}} to reference named arguments is not supported. {{attrs.someProp}} should be updated to {{@someProp}}. (L1:C24) ');
     }
 
     // Perhaps change this test to `{{this.attrs.someProp.value}}` when removing the deprecation?
@@ -1579,7 +1579,7 @@ moduleFor(
         this.registerComponent('with-block', {
           template: 'In layout - someProp: {{attrs.someProp}} - {{yield}}',
         });
-      }, "Using {{attrs}} to reference named arguments is not supported. {{attrs.someProp}} should be updated to {{@someProp}}. ('my-app/templates/components/with-block.hbs' @ L1:C24) ");
+      }, 'Using {{attrs}} to reference named arguments is not supported. {{attrs.someProp}} should be updated to {{@someProp}}. (L1:C24) ');
     }
 
     // Perhaps change this test to `{{this.attrs.someProp.value}}` when removing the deprecation?
@@ -3325,7 +3325,7 @@ moduleFor(
           template:
             'MyVar1: {{attrs.myVar}} {{this.myVar}} MyVar2: {{this.myVar2}} {{attrs.myVar2}}',
         });
-      }, "Using {{attrs}} to reference named arguments is not supported. {{attrs.myVar}} should be updated to {{@myVar}}. ('my-app/templates/components/foo-bar.hbs' @ L1:C10) ");
+      }, 'Using {{attrs}} to reference named arguments is not supported. {{attrs.myVar}} should be updated to {{@myVar}}. (L1:C10) ');
     }
 
     // Perhaps change this test to `{{this.attrs.myVar.value}}` when removing the deprecation?
diff --git a/packages/@ember/-internals/glimmer/tests/integration/components/strict-mode-test.js b/packages/@ember/-internals/glimmer/tests/integration/components/strict-mode-test.js
index fd11a25c617..01f2ad32399 100644
--- a/packages/@ember/-internals/glimmer/tests/integration/components/strict-mode-test.js
+++ b/packages/@ember/-internals/glimmer/tests/integration/components/strict-mode-test.js
@@ -367,7 +367,7 @@ moduleFor(
     '@test Can use LinkTo'() {
       let Foo = defineComponent({ LinkTo }, '<LinkTo @route="index">Index</LinkTo>');
 
-      this.addComponent('foo', { ComponentClass: Foo });
+      this.add('component:foo', Foo);
       this.addTemplate('index', `<Foo/>`);
 
       return this.visit('/').then(() => {
diff --git a/packages/@ember/-internals/glimmer/tests/integration/components/template-only-components-test.js b/packages/@ember/-internals/glimmer/tests/integration/components/template-only-components-test.js
index e555f5a511a..50780d86b77 100644
--- a/packages/@ember/-internals/glimmer/tests/integration/components/template-only-components-test.js
+++ b/packages/@ember/-internals/glimmer/tests/integration/components/template-only-components-test.js
@@ -191,7 +191,7 @@ moduleFor(
 
       this.registerComponent('foo-bar', {
         ComponentClass,
-        template: 'this should not be rendered',
+        resolveableTemplate: 'this should not be rendered',
       });
 
       this.render('{{foo-bar}}');
diff --git a/packages/@ember/-internals/glimmer/tests/integration/custom-component-manager-test.js b/packages/@ember/-internals/glimmer/tests/integration/custom-component-manager-test.js
index 4c42d0f6616..6dfcc65284a 100644
--- a/packages/@ember/-internals/glimmer/tests/integration/custom-component-manager-test.js
+++ b/packages/@ember/-internals/glimmer/tests/integration/custom-component-manager-test.js
@@ -117,7 +117,8 @@ moduleFor(
     }
 
     ['@test it can have no template context']() {
-      let ComponentClass = setComponentManager(() => {
+      class ComponentWithNoTemplate {}
+      setComponentManager(() => {
         return EmberObject.create({
           capabilities: componentCapabilities('3.13'),
 
@@ -131,11 +132,11 @@ moduleFor(
             return null;
           },
         });
-      }, {});
+      }, ComponentWithNoTemplate);
 
       this.registerComponent('foo-bar', {
         template: `<p>{{@greeting}} world</p>`,
-        ComponentClass,
+        ComponentClass: ComponentWithNoTemplate,
       });
 
       this.render('{{foo-bar greeting="hello"}}');
diff --git a/packages/@ember/-internals/glimmer/tests/integration/mount-test.js b/packages/@ember/-internals/glimmer/tests/integration/mount-test.js
index b537c7f89bd..ce57ccd5586 100644
--- a/packages/@ember/-internals/glimmer/tests/integration/mount-test.js
+++ b/packages/@ember/-internals/glimmer/tests/integration/mount-test.js
@@ -1,6 +1,7 @@
 import {
   moduleFor,
   ApplicationTestCase,
+  defineComponent,
   ModuleBasedTestResolver,
   RenderingTestCase,
   runTask,
@@ -279,19 +280,17 @@ moduleFor(
             );
             this.register(
               'component:tagless-component',
-              Component.extend({
-                tagName: '',
-                init() {
-                  this._super(...arguments);
-                  component = this;
-                },
-              })
-            );
-            this.register(
-              'template:components/tagless-component',
-              compile('Tagless Component', {
-                moduleName: 'my-app/templates/components/tagless-component.hbs',
-              })
+              defineComponent(
+                {},
+                'Tagless Component',
+                Component.extend({
+                  tagName: '',
+                  init() {
+                    this._super(...arguments);
+                    component = this;
+                  },
+                })
+              )
             );
           },
         })
diff --git a/packages/@ember/-internals/glimmer/tests/unit/runtime-resolver-cache-test.js b/packages/@ember/-internals/glimmer/tests/unit/runtime-resolver-cache-test.js
index 60b0ae934a8..5321c033eae 100644
--- a/packages/@ember/-internals/glimmer/tests/unit/runtime-resolver-cache-test.js
+++ b/packages/@ember/-internals/glimmer/tests/unit/runtime-resolver-cache-test.js
@@ -5,11 +5,14 @@ import {
   runDestroy,
   runAppend,
   runTask,
+  testUnless,
+  expectDeprecation,
 } from 'internal-test-helpers';
 
 import { set } from '@ember/object';
 import { templateCacheCounters } from '@ember/-internals/glimmer';
 import { Component } from '../utils/helpers';
+import { DEPRECATIONS } from '../../../deprecations';
 
 moduleFor(
   'ember-glimmer runtime resolver cache',
@@ -122,9 +125,12 @@ moduleFor(
       this.expectCacheChanges({}, 'toggle back to component-two no change');
     }
 
-    ['@test each template is only compiled once']() {
+    [`${testUnless(
+      DEPRECATIONS.DEPRECATE_COMPONENT_TEMPLATE_RESOLVING.isRemoved
+    )} each template is only compiled once`]() {
+      expectDeprecation(/msg here/, DEPRECATIONS.DEPRECATE_COMPONENT_TEMPLATE_RESOLVING.isEnabled);
       // static layout
-      this.registerComponent('component-one', { template: 'One' });
+      this.registerComponent('component-one', { resolveableTemplate: 'One' });
 
       // test directly import template factory onto late bound layout
       let Two = Component.extend({
diff --git a/packages/@ember/application/tests/visit_test.js b/packages/@ember/application/tests/visit_test.js
index ab4f71d9cf0..e8268f55532 100644
--- a/packages/@ember/application/tests/visit_test.js
+++ b/packages/@ember/application/tests/visit_test.js
@@ -3,6 +3,7 @@ import {
   ModuleBasedTestResolver,
   ApplicationTestCase,
   runTask,
+  defineComponent,
 } from 'internal-test-helpers';
 import { service } from '@ember/service';
 import EmberObject from '@ember/object';
@@ -516,12 +517,9 @@ moduleFor(
           this._super.apply(this, args);
           this.register('template:application', compile('{{cache-money}}'));
           this.register(
-            'template:components/cache-money',
-            compile(`
-          <p>Dis cache money</p>
-        `)
+            'component:cache-money',
+            defineComponent({}, `<p>Dis cache money</p>`, Component.extend({}))
           );
-          this.register('component:cache-money', Component.extend({}));
         },
       });
       this.add('engine:blog', BlogEngine);
@@ -560,12 +558,9 @@ moduleFor(
           this._super.apply(this, args);
           this.register('template:application', compile('{{cache-money}}'));
           this.register(
-            'template:components/cache-money',
-            compile(`
-          <p>Dis cache money</p>
-        `)
+            'component:cache-money',
+            defineComponent({}, `<p>Dis cache money</p>`, Component.extend({}))
           );
-          this.register('component:cache-money', Component.extend({}));
         },
       });
       this.add('engine:blog', BlogEngine);
@@ -663,64 +658,59 @@ moduleFor(
 
       this.addTemplate('show', '{{component @model.componentName model=@model.componentData}}');
 
-      this.addTemplate(
-        'components/x-foo',
-        `
-        <h1>X-Foo</h1>
-        <p>Hello {{@model.name}}, I have been clicked {{this.isolatedCounter.value}} times ({{this.sharedCounter.value}} times combined)!</p>
-        `
-      );
-
       this.add(
         'component:x-foo',
-        Component.extend({
-          tagName: 'x-foo',
-
-          isolatedCounter: service(),
-          sharedCounter: service(),
-
-          init() {
-            this._super();
-            xFooInitCalled = true;
-          },
-
-          didInsertElement() {
-            xFooDidInsertElementCalled = true;
-          },
-
-          click() {
-            this.get('isolatedCounter').increment();
-            this.get('sharedCounter').increment();
-          },
-        })
-      );
-
-      this.addTemplate(
-        'components/x-bar',
-        `
-        <h1>X-Bar</h1>
-        <button {{on "click" this.incrementCounter}}>Join {{this.counter.value}} others in clicking me!</button>
-        `
+        defineComponent(
+          {},
+          `<h1>X-Foo</h1>
+           <p>Hello {{@model.name}}, I have been clicked {{this.isolatedCounter.value}} times ({{this.sharedCounter.value}} times combined)!</p>`,
+
+          Component.extend({
+            tagName: 'x-foo',
+
+            isolatedCounter: service(),
+            sharedCounter: service(),
+
+            init() {
+              this._super();
+              xFooInitCalled = true;
+            },
+
+            didInsertElement() {
+              xFooDidInsertElementCalled = true;
+            },
+
+            click() {
+              this.get('isolatedCounter').increment();
+              this.get('sharedCounter').increment();
+            },
+          })
+        )
       );
 
       this.add(
         'component:x-bar',
-        Component.extend({
-          counter: service('sharedCounter'),
-
-          incrementCounter: action(function () {
-            this.get('counter').increment();
-          }),
-
-          init() {
-            this._super();
-            xBarInitCalled = true;
-          },
-
-          didInsertElement() {
-            xBarDidInsertElementCalled = true;
-          },
-        })
+        defineComponent(
+          null,
+          `<h1>X-Bar</h1>
+          <button {{on "click" this.incrementCounter}}>Join {{this.counter.value}} others in clicking me!</button>`,
+          Component.extend({
+            counter: service('sharedCounter'),
+
+            incrementCounter: action(function () {
+              this.get('counter').increment();
+            }),
+
+            init() {
+              this._super();
+              xBarInitCalled = true;
+            },
+
+            didInsertElement() {
+              xBarDidInsertElementCalled = true;
+            },
+          })
+        )
       );
 
       let fixtureElement = document.querySelector('#qunit-fixture');
diff --git a/packages/ember/tests/application_lifecycle_test.js b/packages/ember/tests/application_lifecycle_test.js
index 0b7d080b7ab..8fcf689361b 100644
--- a/packages/ember/tests/application_lifecycle_test.js
+++ b/packages/ember/tests/application_lifecycle_test.js
@@ -1,4 +1,9 @@
-import { moduleFor, AutobootApplicationTestCase, runTask } from 'internal-test-helpers';
+import {
+  moduleFor,
+  AutobootApplicationTestCase,
+  runTask,
+  defineComponent,
+} from 'internal-test-helpers';
 import Application from '@ember/application';
 import Route from '@ember/routing/route';
 import Router from '@ember/routing/router';
@@ -140,15 +145,18 @@ moduleFor(
 
         this.add(
           'component:foo-bar',
-          Component.extend({
-            wowza() {
-              assert.ok(true, 'fired the event!');
-            },
-          })
+          defineComponent(
+            {},
+            `<div id='wowza-thingy'></div>`,
+            Component.extend({
+              wowza() {
+                assert.ok(true, 'fired the event!');
+              },
+            })
+          )
         );
 
         this.addTemplate('application', `{{foo-bar}}`);
-        this.addTemplate('components/foo-bar', `<div id='wowza-thingy'></div>`);
       });
 
       this.$('#wowza-thingy').trigger('wowza');
@@ -172,15 +180,18 @@ moduleFor(
 
         this.add(
           'component:foo-bar',
-          Component.extend({
-            jerky() {
-              assert.ok(true, 'fired the event!');
-            },
-          })
+          defineComponent(
+            {},
+            `<div id='herky-thingy'></div>`,
+            Component.extend({
+              jerky() {
+                assert.ok(true, 'fired the event!');
+              },
+            })
+          )
         );
 
         this.addTemplate('application', `{{foo-bar}}`);
-        this.addTemplate('components/foo-bar', `<div id='herky-thingy'></div>`);
       });
 
       this.$('#herky-thingy').trigger('herky');
diff --git a/packages/ember/tests/component_registration_test.js b/packages/ember/tests/component_registration_test.js
index bb7dacb694a..4139bc55125 100644
--- a/packages/ember/tests/component_registration_test.js
+++ b/packages/ember/tests/component_registration_test.js
@@ -2,8 +2,10 @@ import Application from '@ember/application';
 import Controller from '@ember/controller';
 import { Component } from '@ember/-internals/glimmer';
 import { compile } from 'ember-template-compiler';
-import { moduleFor, ApplicationTestCase } from 'internal-test-helpers';
+import { moduleFor, testUnless, ApplicationTestCase, defineComponent } from 'internal-test-helpers';
 import { DEBUG } from '@glimmer/env';
+import { DEPRECATIONS } from '@ember/-internals/deprecations';
+import templateOnly from '@ember/component/template-only';
 
 moduleFor(
   'Application Lifecycle - Component Registration',
@@ -14,7 +16,10 @@ moduleFor(
     }
 
     ['@test The helper becomes the body of the component']() {
-      this.addTemplate('components/expand-it', '<p>hello {{yield}}</p>');
+      this.addComponent('expand-it', {
+        ComponentClass: templateOnly(),
+        template: '<p>hello {{yield}}</p>',
+      });
       this.addTemplate('application', 'Hello world {{#expand-it}}world{{/expand-it}}');
 
       return this.visit('/').then(() => {
@@ -23,7 +28,6 @@ moduleFor(
     }
 
     ['@test If a component is registered, it is used'](assert) {
-      this.addTemplate('components/expand-it', '<p>hello {{yield}}</p>');
       this.addTemplate('application', `Hello world {{#expand-it}}world{{/expand-it}}`);
 
       this.application.instanceInitializer({
@@ -31,9 +35,13 @@ moduleFor(
         initialize(applicationInstance) {
           applicationInstance.register(
             'component:expand-it',
-            Component.extend({
-              classNames: 'testing123',
-            })
+            defineComponent(
+              {},
+              `<p>hello {{yield}}</p>`,
+              Component.extend({
+                classNames: 'testing123',
+              })
+            )
           );
         },
       });
@@ -70,7 +78,9 @@ moduleFor(
       });
     }
 
-    ['@test Late-registered components can be rendered with template registered on the container'](
+    [`${testUnless(
+      DEPRECATIONS.DEPRECATE_COMPONENT_TEMPLATE_RESOLVING.isRemoved
+    )} Late-registered components can be rendered with template registered on the container`](
       assert
     ) {
       this.addTemplate(
@@ -104,7 +114,9 @@ moduleFor(
       });
     }
 
-    ['@test Late-registered components can be rendered with ONLY the template registered on the container'](
+    [`${testUnless(
+      DEPRECATIONS.DEPRECATE_COMPONENT_TEMPLATE_RESOLVING.isRemoved
+    )} Late-registered components can be rendered with ONLY the template registered on the container`](
       assert
     ) {
       this.addTemplate(
diff --git a/packages/ember/tests/integration/multiple-app-test.js b/packages/ember/tests/integration/multiple-app-test.js
index 656647275d9..0674c7350ad 100644
--- a/packages/ember/tests/integration/multiple-app-test.js
+++ b/packages/ember/tests/integration/multiple-app-test.js
@@ -1,4 +1,4 @@
-import { moduleFor, ApplicationTestCase, runTask } from 'internal-test-helpers';
+import { moduleFor, ApplicationTestCase, runTask, defineComponent } from 'internal-test-helpers';
 import Application from '@ember/application';
 import { Component } from '@ember/-internals/glimmer';
 import { getOwner } from '@ember/-internals/owner';
@@ -48,12 +48,16 @@ moduleFor(
     addFactoriesToResolver(actions, resolver) {
       resolver.add(
         'component:special-button',
-        Component.extend({
-          doStuff: action(function () {
-            let rootElement = getOwner(this).application.rootElement;
-            actions.push(rootElement);
-          }),
-        })
+        defineComponent(
+          null,
+          `<button class='do-stuff' {{on "click" this.doStuff}}>Button</button>`,
+          Component.extend({
+            doStuff: action(function () {
+              let rootElement = getOwner(this).application.rootElement;
+              actions.push(rootElement);
+            }),
+          })
+        )
       );
 
       resolver.add(
@@ -67,17 +71,6 @@ moduleFor(
           }
         )
       );
-      resolver.add(
-        'template:components/special-button',
-        this.compile(
-          `
-        <button class='do-stuff' {{on "click" this.doStuff}}>Button</button>
-      `,
-          {
-            moduleName: 'my-app/templates/components/special-button.hbs',
-          }
-        )
-      );
     }
 
     [`@test booting multiple applications can properly handle events`](assert) {
diff --git a/packages/internal-test-helpers/lib/test-cases/abstract-application.ts b/packages/internal-test-helpers/lib/test-cases/abstract-application.ts
index 05acec12a80..b6b89d87fbd 100644
--- a/packages/internal-test-helpers/lib/test-cases/abstract-application.ts
+++ b/packages/internal-test-helpers/lib/test-cases/abstract-application.ts
@@ -79,7 +79,7 @@ export default abstract class AbstractApplicationTestCase extends AbstractTestCa
     return this.application.resolveRegistration('router:main') as typeof Router;
   }
 
-  compile(templateString: string, options: Partial<EmberPrecompileOptions> = {}): object {
+  compile(templateString: string, options: Partial<EmberPrecompileOptions> = {}) {
     return compile(templateString, options);
   }
 }
diff --git a/packages/internal-test-helpers/lib/test-cases/rendering.ts b/packages/internal-test-helpers/lib/test-cases/rendering.ts
index e2b4ef86039..27de1e8f693 100644
--- a/packages/internal-test-helpers/lib/test-cases/rendering.ts
+++ b/packages/internal-test-helpers/lib/test-cases/rendering.ts
@@ -2,7 +2,7 @@ import type { EmberPrecompileOptions } from 'ember-template-compiler';
 import { compile } from 'ember-template-compiler';
 import { EventDispatcher } from '@ember/-internals/views';
 import type { Renderer } from '@ember/-internals/glimmer';
-import Component from '@ember/component';
+import Component, { setComponentTemplate } from '@ember/component';
 import { helper, Helper, _resetRenderers } from '@ember/-internals/glimmer';
 import type Resolver from '../test-resolver';
 import { ModuleBasedResolver } from '../test-resolver';
@@ -13,6 +13,7 @@ import { runAppend, runDestroy, runTask } from '../run';
 import type { InternalFactory } from '@ember/-internals/owner';
 import type { BootOptions, EngineInstanceOptions } from '@ember/engine/instance';
 import type EngineInstance from '@ember/engine/instance';
+import templateOnly from '@ember/component/template-only';
 
 const TextNode = window.Text;
 
@@ -101,15 +102,31 @@ export default abstract class RenderingTestCase extends AbstractTestCase {
     }
   }
 
-  addComponent(name: string, { ComponentClass = null, template = null }) {
+  addComponent(
+    name: string,
+    { ComponentClass = null, template = null, resolveableTemplate = null }
+  ) {
     if (ComponentClass) {
-      this.resolver.add(`component:${name}`, ComponentClass);
+      let localClass = ComponentClass as typeof Component;
+
+      this.resolver.add(`component:${name}`, localClass);
+
+      if (typeof template === 'string') {
+        setComponentTemplate(this.compile(template), ComponentClass ? localClass : templateOnly());
+      }
+
+      return;
     }
 
     if (typeof template === 'string') {
+      let toComponent = setComponentTemplate(this.compile(template), templateOnly());
+      this.resolver.add(`component:${name}`, toComponent);
+    }
+
+    if (typeof resolveableTemplate === 'string') {
       this.resolver.add(
         `template:components/${name}`,
-        this.compile(template, {
+        this.compile(resolveableTemplate, {
           moduleName: `components/${name}`,
         })
       );
@@ -176,17 +193,35 @@ export default abstract class RenderingTestCase extends AbstractTestCase {
     this.owner.register(`helper:${name}`, definition);
   }
 
-  registerComponent(name: string, { ComponentClass = Component, template = null }) {
+  registerComponent(
+    name: string,
+    { ComponentClass = Component, template = null, resolveableTemplate = null }
+  ) {
     let { owner } = this;
 
     if (ComponentClass) {
+      // We cannot set templates multiple times on a class
+      if (ComponentClass === Component) {
+        // @ts-expect-error - class/instance types in TS are hard
+        ComponentClass = class extends Component {};
+      }
+
       owner.register(`component:${name}`, ComponentClass);
+
+      if (typeof template === 'string') {
+        setComponentTemplate(this.compile(template), ComponentClass);
+      }
     }
 
     if (typeof template === 'string') {
+      let toComponent = setComponentTemplate(this.compile(template), templateOnly());
+      this.resolver.add(`component:${name}`, toComponent);
+    }
+
+    if (typeof resolveableTemplate === 'string') {
       owner.register(
         `template:components/${name}`,
-        this.compile(template, {
+        this.compile(resolveableTemplate, {
           moduleName: `my-app/templates/components/${name}.hbs`,
         })
       );
diff --git a/packages/internal-test-helpers/lib/test-cases/test-resolver-application.ts b/packages/internal-test-helpers/lib/test-cases/test-resolver-application.ts
index e292fecc4ef..ea4b4d6df64 100644
--- a/packages/internal-test-helpers/lib/test-cases/test-resolver-application.ts
+++ b/packages/internal-test-helpers/lib/test-cases/test-resolver-application.ts
@@ -1,8 +1,10 @@
 import AbstractApplicationTestCase from './abstract-application';
 import type Resolver from '../test-resolver';
 import { ModuleBasedResolver } from '../test-resolver';
-import Component from '@ember/component';
+import Component, { setComponentTemplate } from '@ember/component';
+import { Component as InternalGlimmerComponent } from '@ember/-internals/glimmer';
 import type { InternalFactory } from '@ember/-internals/owner';
+import templateOnly from '@ember/component/template-only';
 
 export default abstract class TestResolverApplicationTestCase extends AbstractApplicationTestCase {
   abstract resolver?: Resolver;
@@ -31,16 +33,61 @@ export default abstract class TestResolverApplicationTestCase extends AbstractAp
     {
       ComponentClass = Component,
       template = null,
-    }: { ComponentClass?: object | null; template?: string | null }
+      resolveableTemplate = null,
+    }: {
+      ComponentClass?: object | null;
+      template?: string | null;
+      resolveableTemplate?: string | null;
+    }
   ) {
     if (ComponentClass) {
-      this.resolver!.add(`component:${name}`, ComponentClass);
+      // We cannot set templates multiple times on a class
+      //
+      // Some of this is almost exclusively for the hot-reload test.
+      // But there are a lot of places where it was expected to have multiple templates associated
+      // with the same component class (due to the older resolveable templates)
+      //
+      // We'll want to clean thsi up over time, and probably phase out `addComponent` entirely,
+      // and expclusively use `add` w/ `defineComponent`
+      if (ComponentClass === Component) {
+        ComponentClass = class extends Component {};
+      }
+
+      if (ComponentClass === InternalGlimmerComponent) {
+        ComponentClass = class extends InternalGlimmerComponent {};
+      }
+
+      if ('extend' in ComponentClass) {
+        ComponentClass = (ComponentClass as any).extend({});
+      }
+
+      if ((ComponentClass as any).moduleName === '@glimmer/component/template-only') {
+        ComponentClass = templateOnly();
+      }
+
+      this.resolver!.add(`component:${name}`, ComponentClass as Component);
+
+      if (typeof template === 'string') {
+        // moduleName not passed to this.compile, because *it's just wrong*.
+        // moduleName represents a path-on-disk, and we can't guarantee we have that mapping.
+        setComponentTemplate(this.compile(template, {}), ComponentClass as Component);
+      }
+
+      return;
     }
 
     if (typeof template === 'string') {
+      // moduleName not passed to this.compile, because *it's just wrong*.
+      // moduleName represents a path-on-disk, and we can't guarantee we have that mapping.
+      let toComponent = setComponentTemplate(this.compile(template, {}), templateOnly());
+
+      this.resolver!.add(`component:${name}`, toComponent);
+    }
+
+    if (typeof resolveableTemplate === 'string') {
       this.resolver!.add(
         `template:components/${name}`,
-        this.compile(template, {
+        this.compile(resolveableTemplate, {
           moduleName: `my-app/templates/components/${name}.hbs`,
         })
       );
diff --git a/smoke-tests/ember-test-app/package.json b/smoke-tests/ember-test-app/package.json
index fcefe5f4962..2dc788d1144 100644
--- a/smoke-tests/ember-test-app/package.json
+++ b/smoke-tests/ember-test-app/package.json
@@ -19,47 +19,46 @@
     "lint:js": "eslint . --cache",
     "lint:js:fix": "eslint . --fix",
     "start": "ember serve",
-    "test": "npm-run-all --print-name \"lint\" \"test:*\"",
+    "test": "ember test",
     "test:ember": "ember test"
   },
   "devDependencies": {
     "@babel/core": "^7.24.4",
     "@ember/optional-features": "^2.0.0",
     "@ember/string": "^3.0.1",
-    "@ember/test-helpers": "^2.8.1",
+    "@ember/test-helpers": "^3.3.0",
     "@glimmer/component": "^1.1.2",
     "@glimmer/tracking": "^1.1.2",
-    "babel-eslint": "^10.1.0",
     "broccoli-asset-rev": "^3.0.0",
     "ember-auto-import": "^2.4.3",
-    "ember-cli": "~4.8.0",
-    "ember-cli-app-version": "^5.0.0",
+    "ember-cli": "~5.7.0",
+    "ember-cli-app-version": "^6.0.1",
     "ember-cli-babel": "^8.2.0",
     "ember-cli-dependency-checker": "^3.3.1",
     "ember-cli-htmlbars": "^6.1.1",
     "ember-cli-inject-live-reload": "^2.1.0",
     "ember-cli-sri": "^2.1.1",
     "ember-cli-terser": "^4.0.2",
-    "ember-data": "~4.11.0",
+    "ember-data": "~5.3.3",
     "ember-fetch": "^8.1.2",
     "ember-load-initializers": "^2.1.2",
-    "ember-page-title": "^7.0.0",
-    "ember-qunit": "^6.0.0",
-    "ember-resolver": "^8.0.3",
+    "ember-page-title": "^8.2.3",
+    "ember-qunit": "^8.0.2",
+    "ember-resolver": "^11.0.1",
     "ember-source": "~4.8.0",
-    "ember-template-lint": "^4.16.1",
-    "ember-welcome-page": "^6.2.0",
-    "eslint": "^7.32.0",
-    "eslint-config-prettier": "^8.5.0",
-    "eslint-plugin-ember": "^11.1.0",
+    "ember-template-lint": "^6.0.0",
+    "ember-welcome-page": "^7.0.2",
+    "eslint": "^8.0.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-ember": "^12.0.2",
     "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-prettier": "^4.2.1",
-    "eslint-plugin-qunit": "^7.3.1",
+    "eslint-plugin-prettier": "^5.1.3",
+    "eslint-plugin-qunit": "^8.1.1",
     "loader.js": "^4.7.0",
     "npm-run-all": "^4.1.5",
-    "prettier": "^2.7.1",
+    "prettier": "^3.2.5",
     "qunit": "^2.19.2",
-    "qunit-dom": "^2.0.0",
+    "qunit-dom": "^3.1.1",
     "webpack": "^5.74.0"
   },
   "engines": {
diff --git a/tests/index.html b/tests/index.html
index 326dd8318bb..c7bb55176d5 100644
--- a/tests/index.html
+++ b/tests/index.html
@@ -103,6 +103,13 @@
 
         QUnit.config.urlConfig.push('forceskip');
 
+        QUnit.config.urlConfig.push({
+          id: 'OVERRIDE_DEPRECATION_VERSION',
+          value: ['20.0.0', '6.0.0', '5.12.0'],
+          label: 'Deprecation Version',
+        });
+
+
         if (QUnit.config.seed) {
           QUnit.config.reorder = false;
         }