diff --git a/.claude/rules/plugins.md b/.claude/rules/plugins.md
index 4dc52d88f..49b650bbd 100644
--- a/.claude/rules/plugins.md
+++ b/.claude/rules/plugins.md
@@ -6,7 +6,7 @@ paths:
 
 # Plugin system
 
-94 built-in plugins implementing the `Plugin` trait with enablers (package.json detection), static patterns, and optional `resolve_config()` for AST-based config parsing.
+95 built-in plugins implementing the `Plugin` trait with enablers (package.json detection), static patterns, and optional `resolve_config()` for AST-based config parsing.
 
 ## Rich config parsing (16 plugins)
 
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4d3841667..bfc773898 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- **Ember.js / Glimmer / Embroider plugin.** New built-in plugin activates on `ember-source`, `ember-cli`, `@embroider/core`, `@embroider/compat`, or `@glimmer/component`. Whitelists the build- / CLI- / runtime-resolved tooling that no source file imports (`ember-source` itself, `ember-cli`, `ember-cli-htmlbars`, `ember-cli-babel`, `ember-auto-import`, `@embroider/core`, `@glint/core` + the two glint environment shims, `ember-cli-test-loader`, `ember-exam`, `ember-template-lint`, `ember-template-imports`, `@ember/optional-features`, `loader.js`, ...) so those packages do not surface as `unused-dependency`. Packages a modern Ember app imports directly (`@glimmer/component`, `@glimmer/tracking`, `@ember-data/*`, `@embroider/{compat,webpack,vite,addon-shim,macros,router,test-setup}`, `@glint/template`, `@ember/test-helpers`, `ember-qunit`, `qunit`, `qunit-dom`, `ember-load-initializers`, `ember-resolver`, ...) are deliberately omitted; the normal import graph credits them, and listing them in the tooling allowlist would mask real removals when a user drops the dependency. Declares scoped used-class-member rules for `Component`, `Route`, `Controller`, `Service`, `Helper`, `Modifier`, `Application`, and `Router` so framework-invoked lifecycle methods (`model`, `setupController`, `compute`, `modify`, `willDestroy`, `didInsertElement`, ...) are not flagged as unused on subclasses. Exposes Ember's classic-layout filesystem conventions (`app/components/**`, `app/routes/**`, `app/services/**`, `addon/**`, `tests/**/*-test.{js,ts,gjs,gts}`, `config/`, `ember-cli-build.js`, `testem.js`) as entry-point globs since the Ember resolver loads those modules by convention rather than via static `import`. `.gts` / `.gjs` single-file components were already parseable thanks to the existing `<template>`-stripping helper; tracking imports referenced only inside `<template>` blocks (and inside co-located `.hbs` templates) is intentionally deferred to a follow-up that will extend the same scaffolding with `sfc_template`-style scanning.
+- **Glimmer `<template>` blocks credit imported-binding usage in `.gts` / `.gjs`.** Imports referenced only inside a `<template>...</template>` block — PascalCase tag invocation (`<HelloWorld />`), mustache helper (`{{capitalize x}}`), sub-expression helper (`{{if (and a b) "y" "n"}}`), element modifier (`{{on "click" handle}}`), dotted reference (`{{utils.formatDate value}}`) — are no longer flagged as `unused-import`. Handlebars/Glimmer built-in keywords (`if`, `unless`, `each`, `let`, `yield`, ...), `this.*` chains, `@arg` references, and named-argument keys are never resolved as imports. Block-parameter introductions (`as |item index|`) are accumulated as template-scope locals so they shadow same-named imports. Co-located `.hbs` templates remain a known limitation: imports referenced only inside a sibling `.hbs` file still surface as unused on the sibling `.js`/`.ts`; the plugin's `entry_patterns` keep the JS sibling reachable as a file, and migrating to `.gts` removes the limitation entirely.
+
 ### Fixed
 
 - **VS Code: tree view no longer crashes with `The "path" argument must be of type string. Received undefined` when an unlisted dependency is present.** The extension's TypeScript type for `UnlistedDependency` had drifted from the Rust struct: it declared a single top-level `path` field but the actual JSON shape carries `imported_from: ImportSite[]` (so one unlisted dependency reports every site that imports it, with per-site file / line / column). When the user's project produced at least one unlisted dependency, the tree view's `unlisted-dependencies` mapping passed `d.path` (`undefined`) into Node's `path.isAbsolute`, which threw and prevented the tree from rendering, so the "Unused Code" tab silently fell back to the empty "No unused code found" welcome message. The fix updates the TypeScript type to match the Rust shape, mirrors the existing `duplicate_exports.locations.flatMap` pattern to emit one tree row per import site (so each row navigates to the actual import line), and hardens `resolveFilePath` to return empty strings on undefined / empty input as a defensive guard against any future shape drift. The audit also surfaced two latent type drifts in the same file that hadn't crashed yet only because no consumer happened to read the missing fields: `UnusedDependency` now declares the `location` (`"dependencies" | "devDependencies" | "optionalDependencies"`), `line`, and optional `used_in_workspaces` fields that the Rust struct has always emitted, and `TypeOnlyDependency` now declares the `line` field. Thanks [@FunctionDJ](https://github.com/FunctionDJ) for the report. (Closes [#323](https://github.com/fallow-rs/fallow/issues/323))
diff --git a/README.md b/README.md
index 48e69343a..cb2b5351c 100644
--- a/README.md
+++ b/README.md
@@ -56,7 +56,7 @@ Health Summary
 
 **Static analysis is free and open source. Runtime intelligence is optional.**
 
-94 framework plugins. No Node.js runtime required for static analysis. No config needed for the first run.
+95 framework plugins. No Node.js runtime required for static analysis. No config needed for the first run.
 
 Fallow builds a project-wide understanding of your TS/JS codebase instead of checking one file at a time. Use it to review AI-generated changes faster, clean up dead code, reduce duplication, find risky complexity, and enforce architecture boundaries. Add the runtime layer when you want to know what actually executed in production.
 
@@ -490,11 +490,11 @@ See the [full configuration reference](https://docs.fallow.tools/configuration/o
 
 ## Framework plugins
 
-94 built-in plugins detect entry points, convention exports, config-defined aliases, and template-visible usage for your framework automatically.
+95 built-in plugins detect entry points, convention exports, config-defined aliases, and template-visible usage for your framework automatically.
 
 | Category | Plugins |
 |---|---|
-| **Frameworks** | Next.js, Nuxt, Remix, Qwik, SvelteKit, Gatsby, Astro, Angular, NestJS, Lit, Expo, Expo Router, Electron, and more |
+| **Frameworks** | Next.js, Nuxt, Remix, Qwik, SvelteKit, Gatsby, Astro, Angular, NestJS, Lit, Ember, Expo, Expo Router, Electron, and more |
 | **Bundlers** | Vite, Webpack, Rspack, Rsbuild, Rollup, Rolldown, Tsup, Tsdown, Parcel |
 | **Testing** | Vitest, Jest, Playwright, Cypress, Storybook, Mocha, Ava, tap, tsd |
 | **CSS** | Tailwind, PostCSS, UnoCSS, PandaCSS |
diff --git a/crates/core/src/plugins/ember.rs b/crates/core/src/plugins/ember.rs
new file mode 100644
index 000000000..5ef0905b0
--- /dev/null
+++ b/crates/core/src/plugins/ember.rs
@@ -0,0 +1,330 @@
+//! Ember.js / Glimmer / Embroider plugin.
+//!
+//! Activates on `ember-source`, `ember-cli`, `@embroider/core`,
+//! `@embroider/compat`, or `@glimmer/component` dependencies. Tracks Ember's
+//! build, test, and runtime tooling deps (so they are not flagged as unused),
+//! whitelists the lifecycle and reflectively-invoked members on Ember's class
+//! hierarchy, and exposes Ember's filesystem-resolved conventions (the classic
+//! `app/`, `addon/`, and `tests/` layouts) as entry-point globs since those
+//! files are loaded by the Ember resolver rather than by static `import`.
+//!
+//! Template-block import tracking (`<template>...</template>`, `.gjs`/`.gts`
+//! single-file components, and `.hbs` references) is handled separately by the
+//! Glimmer-aware extractor in `crates/extract/src/glimmer.rs`. Decorator-form
+//! component, service, helper, and modifier registration (`@classic`,
+//! `@service`, `@tracked`, `@action`) flows through the visitor and is not
+//! re-implemented here. This plugin only handles the lifecycle and convention
+//! members that the framework calls reflectively at runtime.
+
+use fallow_config::{ScopedUsedClassMemberRule, UsedClassMemberRule};
+
+use super::Plugin;
+
+const ENABLERS: &[&str] = &[
+    "ember-source",
+    "ember-cli",
+    "@embroider/core",
+    "@embroider/compat",
+    "@glimmer/component",
+];
+
+/// Packages required by an Ember project but never statically imported from
+/// source. Anything an `import` statement can reach in a modern Ember app
+/// (`@glimmer/component`, `@ember/test-helpers`, `@ember-data/*`, ...) is
+/// intentionally omitted: the normal import graph already credits those, so
+/// listing them here would only mask real removals when a user genuinely
+/// drops a dependency.
+const TOOLING_DEPENDENCIES: &[&str] = &[
+    // Core Ember runtime / build pipeline
+    //
+    // `ember-source` is the meta-package: source code imports through the
+    // `@ember/*` namespace (e.g. `@ember/application`, `@ember/routing/route`)
+    // and never references the `ember-source` specifier directly.
+    "ember-source",
+    "ember-cli",
+    "ember-cli-htmlbars",
+    "ember-cli-babel",
+    "ember-auto-import",
+    // Embroider runtime core. The compat / webpack / vite halves are
+    // `require()`'d from `ember-cli-build.js` (which is an entry pattern),
+    // and `@embroider/addon-shim` is `require()`'d from each v2 addon's
+    // `index.js` (reached via `package.json#main`); they're credited through
+    // the normal import graph and don't need an allowlist entry. The macros /
+    // router / test-setup halves are imported from source and likewise rely
+    // on the import graph.
+    "@embroider/core",
+    // Glint type-checker CLI + tsconfig environment shims (`@glint/template`
+    // IS imported as type-only and so is omitted here).
+    "@glint/core",
+    "@glint/environment-ember-loose",
+    "@glint/environment-ember-template-imports",
+    // Test infrastructure invoked by the runner, not imported from source
+    // (`ember-qunit`, `qunit`, `qunit-dom`, `@ember/test-helpers` are imported
+    // and so are omitted here).
+    "ember-cli-test-loader",
+    "ember-exam",
+    // Common addons that act through ember-cli config, package.json keys, or
+    // the build server rather than via source imports.
+    "ember-template-lint",
+    "ember-template-imports",
+    "ember-source-channel-url",
+    "@ember/optional-features",
+    "ember-cli-dependency-checker",
+    "ember-cli-inject-live-reload",
+    "ember-cli-sri",
+    "ember-cli-terser",
+    "loader.js",
+];
+
+/// Glimmer / classic Ember component lifecycle members called by the framework
+/// at runtime. Covers both `@glimmer/component` and the legacy
+/// `@ember/component` class hierarchy.
+const COMPONENT_MEMBERS: &[&str] = &[
+    "willDestroy",
+    "didInsertElement",
+    "didRender",
+    "didUpdate",
+    "didReceiveAttrs",
+    "willRender",
+    "willUpdate",
+    "willClearRender",
+    "willDestroyElement",
+    "didDestroyElement",
+];
+
+/// Route hooks called by the Ember router during transitions, plus the
+/// convention properties (`actions`, `queryParams`, `templateName`,
+/// `controllerName`) that the resolver reads reflectively.
+const ROUTE_MEMBERS: &[&str] = &[
+    "model",
+    "beforeModel",
+    "afterModel",
+    "setupController",
+    "resetController",
+    "redirect",
+    "serialize",
+    "deserialize",
+    "activate",
+    "deactivate",
+    "actions",
+    "queryParams",
+    "templateName",
+    "controllerName",
+];
+
+const CONTROLLER_MEMBERS: &[&str] = &["actions", "queryParams"];
+
+const SERVICE_MEMBERS: &[&str] = &["init", "willDestroy"];
+
+const HELPER_MEMBERS: &[&str] = &["compute", "recompute"];
+
+const MODIFIER_MEMBERS: &[&str] = &[
+    "modify",
+    "willDestroy",
+    "didReceiveArguments",
+    "didInstall",
+    "didUpdateArguments",
+    "willRemove",
+];
+
+const APPLICATION_MEMBERS: &[&str] = &["ready", "willDestroy", "init"];
+
+const ROUTER_MEMBERS: &[&str] = &[
+    "map",
+    "location",
+    "rootURL",
+    "willTransition",
+    "didTransition",
+];
+
+const ENTRY_PATTERNS: &[&str] = &[
+    // Classic app/ layout
+    "app/app.{js,ts,gjs,gts}",
+    "app/router.{js,ts}",
+    "app/index.html",
+    "app/components/**/*.{js,ts,gjs,gts,hbs}",
+    "app/routes/**/*.{js,ts,gjs,gts}",
+    "app/controllers/**/*.{js,ts}",
+    "app/templates/**/*.{hbs,gjs,gts}",
+    "app/models/**/*.{js,ts}",
+    "app/services/**/*.{js,ts}",
+    "app/helpers/**/*.{js,ts,gjs,gts}",
+    "app/modifiers/**/*.{js,ts}",
+    "app/initializers/**/*.{js,ts}",
+    "app/instance-initializers/**/*.{js,ts}",
+    "app/adapters/**/*.{js,ts}",
+    "app/serializers/**/*.{js,ts}",
+    "app/transforms/**/*.{js,ts}",
+    // v1 addon layout
+    "addon/**/*.{js,ts,gjs,gts,hbs}",
+    "addon-test-support/**/*.{js,ts,gjs,gts}",
+    // Tests
+    "tests/test-helper.{js,ts}",
+    "tests/index.html",
+    "tests/**/*-test.{js,ts,gjs,gts}",
+    // Build / config
+    "config/environment.js",
+    "config/targets.js",
+    "config/optional-features.json",
+    "config/deprecation-workflow.js",
+    "ember-cli-build.js",
+    "testem.js",
+];
+
+fn scoped_rule(extends: &str, members: &[&str]) -> UsedClassMemberRule {
+    UsedClassMemberRule::Scoped(ScopedUsedClassMemberRule {
+        extends: Some(extends.to_string()),
+        implements: None,
+        members: members.iter().map(|s| (*s).to_string()).collect(),
+    })
+}
+
+pub struct EmberPlugin;
+
+impl Plugin for EmberPlugin {
+    fn name(&self) -> &'static str {
+        "ember"
+    }
+
+    fn enablers(&self) -> &'static [&'static str] {
+        ENABLERS
+    }
+
+    fn tooling_dependencies(&self) -> &'static [&'static str] {
+        TOOLING_DEPENDENCIES
+    }
+
+    fn used_class_member_rules(&self) -> Vec<UsedClassMemberRule> {
+        vec![
+            scoped_rule("Component", COMPONENT_MEMBERS),
+            scoped_rule("Route", ROUTE_MEMBERS),
+            scoped_rule("Controller", CONTROLLER_MEMBERS),
+            scoped_rule("Service", SERVICE_MEMBERS),
+            scoped_rule("Helper", HELPER_MEMBERS),
+            scoped_rule("Modifier", MODIFIER_MEMBERS),
+            scoped_rule("Application", APPLICATION_MEMBERS),
+            scoped_rule("Router", ROUTER_MEMBERS),
+        ]
+    }
+
+    fn entry_patterns(&self) -> &'static [&'static str] {
+        ENTRY_PATTERNS
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn enablers_cover_classic_embroider_and_glimmer() {
+        let plugin = EmberPlugin;
+        assert!(plugin.enablers().contains(&"ember-source"));
+        assert!(plugin.enablers().contains(&"@embroider/core"));
+        assert!(plugin.enablers().contains(&"@glimmer/component"));
+    }
+
+    #[test]
+    fn tooling_dependencies_cover_runtime_only_packages() {
+        let plugin = EmberPlugin;
+        let deps = plugin.tooling_dependencies();
+        // Build / CLI / config-only packages that no source file imports must
+        // be credited via the tooling list.
+        assert!(deps.contains(&"ember-source"));
+        assert!(deps.contains(&"ember-cli-htmlbars"));
+        assert!(deps.contains(&"@embroider/core"));
+        assert!(deps.contains(&"@glint/core"));
+        assert!(deps.contains(&"ember-exam"));
+        assert!(deps.contains(&"loader.js"));
+    }
+
+    #[test]
+    fn tooling_dependencies_omits_source_imported_packages() {
+        // Packages a modern Ember app imports directly (`import Component from
+        // '@glimmer/component'`, `import { tracked } from '@glimmer/tracking'`,
+        // `import { module, test } from 'qunit'`, etc.) MUST NOT appear in
+        // the tooling list. The normal import graph already credits them, and
+        // listing them here would mask a real removal when a user genuinely
+        // drops the dependency.
+        let plugin = EmberPlugin;
+        let deps = plugin.tooling_dependencies();
+        for name in [
+            "@glimmer/component",
+            "@glimmer/tracking",
+            "@glimmer/env",
+            "@glint/template",
+            "@ember/test-helpers",
+            "ember-qunit",
+            "qunit",
+            "qunit-dom",
+            "ember-data",
+            "@ember-data/store",
+            "@ember-data/model",
+            "@embroider/macros",
+            "@embroider/router",
+            "@embroider/test-setup",
+            // Reached via the normal import graph through `ember-cli-build.js`
+            // (an entry pattern) which `require()`s the build half, and via
+            // each v2 addon's `package.json#main` index.js for the shim.
+            "@embroider/webpack",
+            "@embroider/vite",
+            "@embroider/addon-shim",
+            "ember-load-initializers",
+            "ember-resolver",
+        ] {
+            assert!(
+                !deps.contains(&name),
+                "{name} is imported from source in modern Ember; remove from tooling_dependencies"
+            );
+        }
+    }
+
+    #[test]
+    fn lifecycle_rules_scope_component_members_to_glimmer_component() {
+        let rules = EmberPlugin.used_class_member_rules();
+        let component_rule = rules.iter().find_map(|r| match r {
+            UsedClassMemberRule::Scoped(s) if s.extends.as_deref() == Some("Component") => Some(s),
+            _ => None,
+        });
+        let component_rule = component_rule.expect("Component-scoped rule missing");
+        assert!(component_rule.members.iter().any(|m| m == "willDestroy"));
+        assert!(
+            component_rule
+                .members
+                .iter()
+                .any(|m| m == "didInsertElement")
+        );
+    }
+
+    #[test]
+    fn lifecycle_rules_scope_route_members_to_route_class() {
+        let rules = EmberPlugin.used_class_member_rules();
+        let route_rule = rules.iter().find_map(|r| match r {
+            UsedClassMemberRule::Scoped(s) if s.extends.as_deref() == Some("Route") => Some(s),
+            _ => None,
+        });
+        let route_rule = route_rule.expect("Route-scoped rule missing");
+        assert!(route_rule.members.iter().any(|m| m == "model"));
+        assert!(route_rule.members.iter().any(|m| m == "beforeModel"));
+        assert!(route_rule.members.iter().any(|m| m == "setupController"));
+    }
+
+    #[test]
+    fn unrelated_classes_get_no_lifecycle_rule_match() {
+        let rules = EmberPlugin.used_class_member_rules();
+        for r in &rules {
+            let UsedClassMemberRule::Scoped(s) = r else {
+                continue;
+            };
+            assert!(!s.matches_heritage(Some("UserService"), &[]));
+        }
+    }
+
+    #[test]
+    fn entry_patterns_cover_classic_layout() {
+        let plugin = EmberPlugin;
+        let patterns = plugin.entry_patterns();
+        assert!(patterns.contains(&"app/components/**/*.{js,ts,gjs,gts,hbs}"));
+        assert!(patterns.contains(&"tests/**/*-test.{js,ts,gjs,gts}"));
+    }
+}
diff --git a/crates/core/src/plugins/mod.rs b/crates/core/src/plugins/mod.rs
index ab74a1dbb..685c03984 100644
--- a/crates/core/src/plugins/mod.rs
+++ b/crates/core/src/plugins/mod.rs
@@ -33,6 +33,7 @@ const RUNTIME_ENTRY_POINT_PLUGINS: &[&str] = &[
     "convex",
     "docusaurus",
     "electron",
+    "ember",
     "expo",
     "expo-router",
     "gatsby",
@@ -980,6 +981,7 @@ mod dependency_cruiser;
 mod docusaurus;
 mod drizzle;
 mod electron;
+mod ember;
 mod eslint;
 mod expo;
 mod expo_router;
diff --git a/crates/core/src/plugins/registry/builtin.rs b/crates/core/src/plugins/registry/builtin.rs
index 8ed1aec3d..a9bfdc8dc 100644
--- a/crates/core/src/plugins/registry/builtin.rs
+++ b/crates/core/src/plugins/registry/builtin.rs
@@ -8,20 +8,21 @@ use super::super::{
     changesets::ChangesetsPlugin, commitizen::CommitizenPlugin, commitlint::CommitlintPlugin,
     convex::ConvexPlugin, cspell::CspellPlugin, cucumber::CucumberPlugin, cypress::CypressPlugin,
     dependency_cruiser::DependencyCruiserPlugin, docusaurus::DocusaurusPlugin,
-    drizzle::DrizzlePlugin, electron::ElectronPlugin, eslint::EslintPlugin, expo::ExpoPlugin,
-    expo_router::ExpoRouterPlugin, gatsby::GatsbyPlugin, graphql_codegen::GraphqlCodegenPlugin,
-    hardhat::HardhatPlugin, husky::HuskyPlugin, i18next::I18nextPlugin, jest::JestPlugin,
-    karma::KarmaPlugin, knex::KnexPlugin, kysely::KyselyPlugin, lefthook::LefthookPlugin,
-    lint_staged::LintStagedPlugin, lit::LitPlugin, markdownlint::MarkdownlintPlugin,
-    mocha::MochaPlugin, msw::MswPlugin, nestjs::NestJsPlugin, next_intl::NextIntlPlugin,
-    nextjs::NextJsPlugin, nitro::NitroPlugin, nodemon::NodemonPlugin, nuxt::NuxtPlugin,
-    nx::NxPlugin, nyc::NycPlugin, openapi_ts::OpenapiTsPlugin, oxlint::OxlintPlugin,
-    pandacss::PandaCssPlugin, parcel::ParcelPlugin, playwright::PlaywrightPlugin, plop::PlopPlugin,
-    pm2::Pm2Plugin, pnpm::PnpmPlugin, postcss::PostCssPlugin, prettier::PrettierPlugin,
-    prisma::PrismaPlugin, qwik::QwikPlugin, react_native::ReactNativePlugin,
-    react_router::ReactRouterPlugin, relay::RelayPlugin, remark::RemarkPlugin, remix::RemixPlugin,
-    rolldown::RolldownPlugin, rollup::RollupPlugin, rsbuild::RsbuildPlugin, rspack::RspackPlugin,
-    sanity::SanityPlugin, semantic_release::SemanticReleasePlugin, sentry::SentryPlugin,
+    drizzle::DrizzlePlugin, electron::ElectronPlugin, ember::EmberPlugin, eslint::EslintPlugin,
+    expo::ExpoPlugin, expo_router::ExpoRouterPlugin, gatsby::GatsbyPlugin,
+    graphql_codegen::GraphqlCodegenPlugin, hardhat::HardhatPlugin, husky::HuskyPlugin,
+    i18next::I18nextPlugin, jest::JestPlugin, karma::KarmaPlugin, knex::KnexPlugin,
+    kysely::KyselyPlugin, lefthook::LefthookPlugin, lint_staged::LintStagedPlugin, lit::LitPlugin,
+    markdownlint::MarkdownlintPlugin, mocha::MochaPlugin, msw::MswPlugin, nestjs::NestJsPlugin,
+    next_intl::NextIntlPlugin, nextjs::NextJsPlugin, nitro::NitroPlugin, nodemon::NodemonPlugin,
+    nuxt::NuxtPlugin, nx::NxPlugin, nyc::NycPlugin, openapi_ts::OpenapiTsPlugin,
+    oxlint::OxlintPlugin, pandacss::PandaCssPlugin, parcel::ParcelPlugin,
+    playwright::PlaywrightPlugin, plop::PlopPlugin, pm2::Pm2Plugin, pnpm::PnpmPlugin,
+    postcss::PostCssPlugin, prettier::PrettierPlugin, prisma::PrismaPlugin, qwik::QwikPlugin,
+    react_native::ReactNativePlugin, react_router::ReactRouterPlugin, relay::RelayPlugin,
+    remark::RemarkPlugin, remix::RemixPlugin, rolldown::RolldownPlugin, rollup::RollupPlugin,
+    rsbuild::RsbuildPlugin, rspack::RspackPlugin, sanity::SanityPlugin,
+    semantic_release::SemanticReleasePlugin, sentry::SentryPlugin,
     simple_git_hooks::SimpleGitHooksPlugin, storybook::StorybookPlugin, stylelint::StylelintPlugin,
     sveltekit::SvelteKitPlugin, svgo::SvgoPlugin, svgr::SvgrPlugin, swc::SwcPlugin,
     syncpack::SyncpackPlugin, tailwind::TailwindPlugin, tanstack_router::TanstackRouterPlugin,
@@ -61,6 +62,7 @@ pub fn create_builtin_plugins() -> Vec<Box<dyn Plugin>> {
         Box::new(QwikPlugin),
         Box::new(ConvexPlugin),
         Box::new(LitPlugin),
+        Box::new(EmberPlugin),
         // Bundlers
         Box::new(VitePlugin),
         Box::new(WebpackPlugin),
diff --git a/crates/extract/src/glimmer.rs b/crates/extract/src/glimmer.rs
index d22fbcc13..eedf6409c 100644
--- a/crates/extract/src/glimmer.rs
+++ b/crates/extract/src/glimmer.rs
@@ -1,5 +1,6 @@
 //! Helpers for Glimmer component files (`.gts` / `.gjs`).
 
+use std::ops::Range;
 use std::path::Path;
 
 /// Return `true` for Glimmer source files.
@@ -10,13 +11,15 @@ pub fn is_glimmer_file(path: &Path) -> bool {
         .is_some_and(|ext| ext == "gts" || ext == "gjs")
 }
 
-/// Blank Glimmer `<template>` blocks while preserving byte offsets and line
-/// numbers for the JavaScript/TypeScript parser.
+/// Locate `<template>...</template>` block byte ranges. The returned ranges
+/// span from the opening `<` of `<template` through the closing `>` of
+/// `</template>`. An unclosed `<template` consumes from its start to the end
+/// of the source. The byte offsets are stable and the same offsets used by
+/// [`strip_glimmer_templates`] so callers can correlate the two passes.
 #[must_use]
-pub fn strip_glimmer_templates(source: &str) -> Option<String> {
-    let mut bytes = source.as_bytes().to_vec();
+pub fn find_template_ranges(source: &str) -> Vec<Range<usize>> {
+    let mut ranges = Vec::new();
     let mut cursor = 0;
-    let mut changed = false;
 
     while let Some(relative_start) = source[cursor..].find("<template") {
         let start = cursor + relative_start;
@@ -25,31 +28,63 @@ pub fn strip_glimmer_templates(source: &str) -> Option<String> {
             .map_or(source.len(), |relative_end| {
                 start + relative_end + "</template>".len()
             });
+        ranges.push(start..end);
+        if end >= source.len() {
+            break;
+        }
+        cursor = end;
+    }
+
+    ranges
+}
+
+/// Blank Glimmer `<template>` blocks while preserving byte offsets and line
+/// numbers for the JavaScript/TypeScript parser.
+#[must_use]
+pub fn strip_glimmer_templates(source: &str) -> Option<String> {
+    let ranges = find_template_ranges(source);
+    if ranges.is_empty() {
+        return None;
+    }
 
-        for byte in &mut bytes[start..end] {
+    let mut bytes = source.as_bytes().to_vec();
+    for range in ranges {
+        for byte in &mut bytes[range] {
             if !matches!(*byte, b'\n' | b'\r') {
                 *byte = b' ';
             }
         }
-
-        changed = true;
-        cursor = end;
-        if cursor >= source.len() {
-            break;
-        }
     }
 
-    if changed {
-        String::from_utf8(bytes).ok()
-    } else {
-        None
-    }
+    String::from_utf8(bytes).ok()
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
+    #[test]
+    fn find_template_ranges_captures_all_blocks() {
+        let source = "a<template>b\nc</template>d<template>e</template>f";
+        let ranges = find_template_ranges(source);
+        assert_eq!(ranges.len(), 2);
+        assert_eq!(&source[ranges[0].clone()], "<template>b\nc</template>");
+        assert_eq!(&source[ranges[1].clone()], "<template>e</template>");
+    }
+
+    #[test]
+    fn find_template_ranges_handles_unclosed_block() {
+        let source = "<template>nope";
+        let ranges = find_template_ranges(source);
+        assert_eq!(ranges.len(), 1);
+        assert_eq!(ranges[0], 0..source.len());
+    }
+
+    #[test]
+    fn find_template_ranges_returns_empty_when_absent() {
+        assert!(find_template_ranges("export const x = 1;").is_empty());
+    }
+
     #[test]
     fn strips_template_blocks_and_preserves_newlines() {
         let source =
diff --git a/crates/extract/src/parse.rs b/crates/extract/src/parse.rs
index 94038791d..856e27b59 100644
--- a/crates/extract/src/parse.rs
+++ b/crates/extract/src/parse.rs
@@ -190,9 +190,52 @@ pub fn parse_source_to_module(
     info.complexity = complexity;
     info.flag_uses = flag_uses;
 
+    if is_glimmer_file(path) {
+        apply_glimmer_template_usage(&mut info, source);
+    }
+
     info
 }
 
+/// Credit imported bindings referenced only inside `<template>...</template>`
+/// blocks of a Glimmer `.gts` / `.gjs` single-file component.
+///
+/// The JS/TS parser sees template blocks as blank-padded whitespace (see
+/// [`crate::glimmer::strip_glimmer_templates`]), so a binding consumed only
+/// through `<HelloWorld />` or `{{capitalize x}}` would otherwise be flagged
+/// as `unused-import`. The scanner walks each captured template range over
+/// the *original* (un-stripped) source and merges the resulting
+/// [`TemplateUsage`] into `info` using the same retain/extend pattern as
+/// [`crate::sfc`].
+fn apply_glimmer_template_usage(info: &mut ModuleInfo, source: &str) {
+    use rustc_hash::FxHashSet;
+
+    let template_ranges = crate::glimmer::find_template_ranges(source);
+    if template_ranges.is_empty() {
+        return;
+    }
+
+    let imported_bindings: FxHashSet<String> = info
+        .imports
+        .iter()
+        .filter(|import| !import.local_name.is_empty())
+        .map(|import| import.local_name.clone())
+        .collect();
+    if imported_bindings.is_empty() {
+        return;
+    }
+
+    let usage = crate::sfc_template::glimmer::collect_glimmer_template_usage(
+        source,
+        &template_ranges,
+        &imported_bindings,
+    );
+    info.unused_import_bindings
+        .retain(|binding| !usage.used_bindings.contains(binding));
+    info.member_accesses.extend(usage.member_accesses);
+    info.whole_object_uses.extend(usage.whole_object_uses);
+}
+
 /// Synthesise `<template>` complexity findings for inline `@Component({ template: \`...\` })`
 /// decorators captured by the visitor pass.
 ///
diff --git a/crates/extract/src/sfc_template/glimmer.rs b/crates/extract/src/sfc_template/glimmer.rs
new file mode 100644
index 000000000..d55f70a80
--- /dev/null
+++ b/crates/extract/src/sfc_template/glimmer.rs
@@ -0,0 +1,673 @@
+//! Template-visible import-usage scanner for Glimmer `<template>` blocks in
+//! `.gts` / `.gjs` single-file components.
+//!
+//! Glimmer/Handlebars syntax is not JavaScript, so we cannot reuse the Oxc-
+//! backed expression analyzer that powers Vue and Svelte template scanning.
+//! Instead this module walks each `<template>...</template>` body with a
+//! purpose-built tokenizer that recognises the constructs which can legally
+//! reference a JS-scope binding:
+//!
+//! - `<HelloWorld />` and `<HelloWorld>...</HelloWorld>` — PascalCase tag
+//!   invocations credit a binding by tag name. Strict-mode `.gts` / `.gjs`
+//!   components are JavaScript bindings, so namespaced tags (`<Forms::Input />`)
+//!   and member-style tags (`<Buttons.Primary />`) are deliberately out of
+//!   scope — they're a classic-resolver / `.hbs` concept and `.hbs` is itself
+//!   a known limitation. Strict-mode code that wants that shape imports the
+//!   leaf component directly (`import Input from './forms/input'; <Input />`).
+//! - `{{capitalize x}}` — Handlebars helper invocation credits each bareword
+//!   identifier that is not a built-in keyword, a literal, a `this.` chain,
+//!   an `@arg`, or a named-argument key.
+//! - `{{if (and a b) "yes" "no"}}` — sub-expressions are scanned recursively
+//!   inside `(...)`.
+//! - `<button {{on "click" handleClick}} />` — modifier mustaches inside
+//!   element-attribute position scan the same as regular mustaches.
+//! - `{{utils.formatDate value}}` — dotted member references credit the base
+//!   binding and emit a `MemberAccess { object: utils, member: formatDate }`.
+//!
+//! Block-parameter introductions (`{{#each items as |item index|}}`) are
+//! accumulated as template-scope locals so they shadow same-named imports.
+//! The scope is intentionally template-wide rather than block-precise: a
+//! local introduced in one `{{#each}}` will (pessimistically) shadow the
+//! same-named import elsewhere in the same template. This trades a small
+//! false-negative for staying out of the parser business; promoting to a
+//! block-precise scope is a follow-up.
+
+use std::ops::Range;
+
+use rustc_hash::FxHashSet;
+
+use crate::MemberAccess;
+use crate::template_usage::TemplateUsage;
+
+/// Handlebars / Glimmer keywords that must never be resolved as imports —
+/// scoped to **strict mode** (`.gts` / `.gjs`) semantics.
+///
+/// Includes language keywords (control flow, scope) and the literal-name
+/// keywords. Helpers that are ambient in classic `.hbs` but require explicit
+/// imports from `@ember/helper` in strict mode (`hash`, `array`, `concat`,
+/// `fn`, `mut`, `get`) are deliberately omitted: if the user imported them
+/// the template scanner SHOULD credit those imports, and if they didn't the
+/// `imported_bindings` lookup short-circuits anyway. Same reasoning for the
+/// built-in components `Input` and `Textarea` (imported from
+/// `@ember/component` in strict mode). Plain `input` / `textarea` are HTML
+/// DOM elements, never Ember tokens, and aren't listed.
+const BUILTIN_KEYWORDS: &[&str] = &[
+    // Control-flow blocks and inline forms
+    "if",
+    "unless",
+    "else",
+    "each",
+    "each-in",
+    "let",
+    "with",
+    "in-element",
+    "key",
+    // Component / yield machinery (`component`, `helper`, `modifier` are
+    // template-language keywords that introduce a `(component "name" ...)`
+    // / `(helper ...)` / `(modifier ...)` sub-expression — they are NOT the
+    // same as the same-named JS bindings a user might import).
+    "yield",
+    "outlet",
+    "component",
+    "helper",
+    "modifier",
+    "mount",
+    "unbound",
+    // Built-in components and helpers that are still ambient in strict mode
+    "link-to",
+    "LinkTo",
+    // Debugging
+    "debugger",
+    "log",
+    // Literal-name keywords
+    "true",
+    "false",
+    "null",
+    "undefined",
+    "this",
+];
+
+/// Collect template-visible import usage for every `<template>...</template>`
+/// block in a Glimmer (`.gts` / `.gjs`) source file.
+///
+/// `template_ranges` MUST be the byte ranges previously captured by
+/// `crate::glimmer::find_template_ranges(source)`; the caller is expected to
+/// pass them through rather than re-scan the file.
+#[must_use]
+pub fn collect_glimmer_template_usage(
+    source: &str,
+    template_ranges: &[Range<usize>],
+    imported_bindings: &FxHashSet<String>,
+) -> TemplateUsage {
+    let mut usage = TemplateUsage::default();
+    if imported_bindings.is_empty() || template_ranges.is_empty() {
+        return usage;
+    }
+
+    for range in template_ranges {
+        let Some(body) = template_body(source, range.clone()) else {
+            continue;
+        };
+
+        let locals = extract_block_params(body);
+        scan_tags(body, imported_bindings, &locals, &mut usage);
+        scan_mustaches(body, imported_bindings, &locals, &mut usage);
+    }
+
+    usage
+}
+
+/// Slice the inner body of a `<template>...</template>` range, stripping the
+/// outer tags. Returns `None` if the range does not look like a well-formed
+/// template wrapper (e.g. unclosed at end-of-file).
+fn template_body(source: &str, range: Range<usize>) -> Option<&str> {
+    let slice = source.get(range)?;
+    let body_start = slice.find('>').map(|i| i + 1)?;
+    let body_end = slice.rfind("</template>").unwrap_or(slice.len());
+    if body_end < body_start {
+        return None;
+    }
+    slice.get(body_start..body_end)
+}
+
+// ── block params ─────────────────────────────────────────────────────────
+
+/// Walk a template body and harvest every identifier introduced via
+/// `as |x y|` block-parameter syntax. The scan is purely textual and does
+/// not respect `{{#each}}` block boundaries, so locals introduced in one
+/// block effectively shadow the same name across the whole template. This
+/// is a deliberate trade-off (see module doc).
+fn extract_block_params(body: &str) -> Vec<String> {
+    let mut locals = Vec::new();
+    let bytes = body.as_bytes();
+    let mut cursor = 0;
+
+    while let Some(relative) = body[cursor..].find("as ") {
+        let absolute = cursor + relative;
+        let after_as = absolute + "as ".len();
+        // Find the next pipe; the matching close pipe defines the param list.
+        let Some(open_pipe_rel) = body[after_as..].find('|') else {
+            break;
+        };
+        let open_pipe = after_as + open_pipe_rel;
+        // Only whitespace may appear between `as ` and the opening pipe.
+        if body[after_as..open_pipe]
+            .bytes()
+            .any(|b| !b.is_ascii_whitespace())
+        {
+            cursor = open_pipe + 1;
+            continue;
+        }
+        let Some(close_pipe_rel) = body[open_pipe + 1..].find('|') else {
+            break;
+        };
+        let close_pipe = open_pipe + 1 + close_pipe_rel;
+        let inner = &body[open_pipe + 1..close_pipe];
+        for token in inner.split_whitespace() {
+            if is_plain_identifier(token) {
+                locals.push(token.to_string());
+            }
+        }
+        cursor = close_pipe + 1;
+        if cursor >= bytes.len() {
+            break;
+        }
+    }
+
+    locals
+}
+
+// ── tag scanning ─────────────────────────────────────────────────────────
+
+/// Scan opening element tags for PascalCase component invocations.
+/// `<HelloWorld @x="y" />` credits binding `HelloWorld`.
+///
+/// Only plain identifier tag names are recognised — strict-mode `.gts` /
+/// `.gjs` components are JavaScript bindings, so namespaced or member-style
+/// tag invocations (`<Forms::Input />`, `<Buttons.Primary />`) are out of
+/// scope. They're a classic-resolver / `.hbs` concept and `.hbs` is itself a
+/// known limitation of the plugin. Strict-mode code that wants the same
+/// shape simply imports the leaf component directly (`import Input from
+/// './forms/input'; <Input />`).
+fn scan_tags(
+    body: &str,
+    imported_bindings: &FxHashSet<String>,
+    locals: &[String],
+    usage: &mut TemplateUsage,
+) {
+    let bytes = body.as_bytes();
+    let mut index = 0;
+
+    while index < bytes.len() {
+        if bytes[index] != b'<' {
+            index += 1;
+            continue;
+        }
+        // Skip closing tags, comments, doctype, processing instructions.
+        let next = bytes.get(index + 1).copied();
+        if matches!(next, Some(b'/' | b'!' | b'?')) {
+            index += 1;
+            continue;
+        }
+        let Some(first) = next else { break };
+        if !first.is_ascii_uppercase() {
+            index += 1;
+            continue;
+        }
+
+        // Read a plain identifier tag name (A-Z, a-z, 0-9, underscore, $).
+        let name_start = index + 1;
+        let mut end = name_start;
+        while end < bytes.len() {
+            let byte = bytes[end];
+            if !(byte.is_ascii_alphanumeric() || byte == b'_' || byte == b'$') {
+                break;
+            }
+            end += 1;
+        }
+        if end > name_start {
+            credit_binding(&body[name_start..end], imported_bindings, locals, usage);
+        }
+        index = end.max(index + 1);
+    }
+}
+
+// ── mustache scanning ────────────────────────────────────────────────────
+
+/// Walk every `{{ ... }}` section in the template body and credit any
+/// imported bindings or member-accesses referenced inside. Triple-stash
+/// `{{{ ... }}}` (unescaped HTML output) is handled by the same code path
+/// because the inner content scans identically.
+fn scan_mustaches(
+    body: &str,
+    imported_bindings: &FxHashSet<String>,
+    locals: &[String],
+    usage: &mut TemplateUsage,
+) {
+    let bytes = body.as_bytes();
+    let mut index = 0;
+    while index + 1 < bytes.len() {
+        if bytes[index] != b'{' || bytes[index + 1] != b'{' {
+            index += 1;
+            continue;
+        }
+        // Skip Handlebars comments: {{!-- ... --}} and {{! ... }}.
+        let after_open = index + 2;
+        let comment_form = matches!(bytes.get(after_open), Some(b'!'));
+        let Some(close_rel) = body[after_open..].find("}}") else {
+            break;
+        };
+        let close = after_open + close_rel;
+        if comment_form {
+            index = close + 2;
+            continue;
+        }
+        let inner = &body[after_open..close];
+        scan_mustache_inner(inner, imported_bindings, locals, usage);
+        index = close + 2;
+    }
+}
+
+/// Tokenize the contents of one `{{ ... }}` (or one `( ... )` sub-expression)
+/// and credit each token that resolves to an imported binding.
+fn scan_mustache_inner(
+    inner: &str,
+    imported_bindings: &FxHashSet<String>,
+    locals: &[String],
+    usage: &mut TemplateUsage,
+) {
+    let inner = inner.trim_matches(|c: char| c.is_whitespace() || c == '~');
+    if inner.is_empty() {
+        return;
+    }
+    // Block markers: `#each`, `/each`, `^else`. Skip the leading sigil but
+    // keep tokenizing the rest of the line — the helper name itself (e.g.
+    // `each`) is a built-in we filter below, but its arguments aren't.
+    let inner = inner
+        .strip_prefix('#')
+        .or_else(|| inner.strip_prefix('/'))
+        .or_else(|| inner.strip_prefix('^'))
+        .unwrap_or(inner);
+
+    for token in TokenSplitter::new(inner) {
+        credit_token(token, imported_bindings, locals, usage);
+    }
+}
+
+fn credit_token(
+    token: &str,
+    imported_bindings: &FxHashSet<String>,
+    locals: &[String],
+    usage: &mut TemplateUsage,
+) {
+    let token = token.trim();
+    if token.is_empty() {
+        return;
+    }
+
+    // Sub-expression: recurse into the parens.
+    if let Some(stripped) = token.strip_prefix('(').and_then(|s| s.strip_suffix(')')) {
+        scan_mustache_inner(stripped, imported_bindings, locals, usage);
+        return;
+    }
+
+    // Named argument: `key=value` — credit the value, drop the key.
+    if let Some((_key, value)) = token.split_once('=')
+        && !value.is_empty()
+    {
+        credit_token(value, imported_bindings, locals, usage);
+        return;
+    }
+
+    // Literals: numbers, strings, hashbar negatives.
+    if is_literal(token) {
+        return;
+    }
+
+    // `@arg` and `this.foo` chains never resolve to an import binding.
+    if token.starts_with('@') || token.starts_with("this.") || token == "this" {
+        return;
+    }
+
+    // Built-in keywords (`if`, `each`, `yield`, ...).
+    if BUILTIN_KEYWORDS.contains(&token) {
+        return;
+    }
+
+    // Dotted reference: credit the head and emit a member access.
+    if let Some((head, rest)) = token.split_once('.')
+        && is_plain_identifier(head)
+    {
+        if BUILTIN_KEYWORDS.contains(&head) {
+            return;
+        }
+        credit_binding(head, imported_bindings, locals, usage);
+        if let Some(first_member) = rest.split('.').next()
+            && is_plain_identifier(first_member)
+        {
+            push_member_access(usage, head, first_member);
+        }
+        return;
+    }
+
+    // Bare identifier.
+    if is_plain_identifier(token) {
+        credit_binding(token, imported_bindings, locals, usage);
+    }
+}
+
+/// Iterator that yields whitespace-separated top-level tokens from a
+/// Handlebars expression body, treating `(...)` as a single atomic token
+/// and respecting string literals (single, double, backtick).
+struct TokenSplitter<'a> {
+    bytes: &'a [u8],
+    source: &'a str,
+    index: usize,
+}
+
+impl<'a> TokenSplitter<'a> {
+    fn new(source: &'a str) -> Self {
+        Self {
+            bytes: source.as_bytes(),
+            source,
+            index: 0,
+        }
+    }
+}
+
+impl<'a> Iterator for TokenSplitter<'a> {
+    type Item = &'a str;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        while self.index < self.bytes.len() && self.bytes[self.index].is_ascii_whitespace() {
+            self.index += 1;
+        }
+        if self.index >= self.bytes.len() {
+            return None;
+        }
+        let start = self.index;
+        let mut paren_depth: u32 = 0;
+        let mut in_quote: Option<u8> = None;
+        let mut escape = false;
+
+        while self.index < self.bytes.len() {
+            let byte = self.bytes[self.index];
+
+            if let Some(quote) = in_quote {
+                if escape {
+                    escape = false;
+                } else if byte == b'\\' {
+                    escape = true;
+                } else if byte == quote {
+                    in_quote = None;
+                }
+                self.index += 1;
+                continue;
+            }
+
+            match byte {
+                b'(' => paren_depth += 1,
+                b')' => paren_depth = paren_depth.saturating_sub(1),
+                b'"' | b'\'' | b'`' => in_quote = Some(byte),
+                b if b.is_ascii_whitespace() && paren_depth == 0 => break,
+                _ => {}
+            }
+            self.index += 1;
+        }
+
+        Some(&self.source[start..self.index])
+    }
+}
+
+// ── helpers ──────────────────────────────────────────────────────────────
+
+fn is_plain_identifier(token: &str) -> bool {
+    let mut chars = token.chars();
+    let Some(first) = chars.next() else {
+        return false;
+    };
+    if !(first.is_ascii_alphabetic() || first == '_' || first == '$') {
+        return false;
+    }
+    chars.all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '$')
+}
+
+fn is_literal(token: &str) -> bool {
+    let first = token.as_bytes().first().copied();
+    matches!(
+        first,
+        Some(b'"' | b'\'' | b'`' | b'0'..=b'9' | b'-' | b'+' | b'.')
+    )
+}
+
+fn credit_binding(
+    name: &str,
+    imported_bindings: &FxHashSet<String>,
+    locals: &[String],
+    usage: &mut TemplateUsage,
+) {
+    if name.is_empty()
+        || locals.iter().any(|local| local == name)
+        || !imported_bindings.contains(name)
+    {
+        return;
+    }
+    usage.used_bindings.insert(name.to_string());
+}
+
+fn push_member_access(usage: &mut TemplateUsage, object: &str, member: &str) {
+    let already_present = usage
+        .member_accesses
+        .iter()
+        .any(|existing| existing.object == object && existing.member == member);
+    if already_present {
+        return;
+    }
+    usage.member_accesses.push(MemberAccess {
+        object: object.to_string(),
+        member: member.to_string(),
+    });
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn imported(names: &[&str]) -> FxHashSet<String> {
+        names.iter().map(|name| (*name).to_string()).collect()
+    }
+
+    fn usage_for(source: &str, names: &[&str]) -> TemplateUsage {
+        let ranges = crate::glimmer::find_template_ranges(source);
+        collect_glimmer_template_usage(source, &ranges, &imported(names))
+    }
+
+    #[test]
+    fn pascal_case_tag_credits_binding() {
+        let usage = usage_for(
+            "<template><HelloWorld @name=\"x\" /></template>",
+            &["HelloWorld"],
+        );
+        assert!(usage.used_bindings.contains("HelloWorld"));
+    }
+
+    #[test]
+    fn namespaced_tag_credits_only_head_segment() {
+        // Strict-mode `.gts` / `.gjs` does not use classic-resolver namespaced
+        // tags; if a user wrote one anyway we should at minimum credit the
+        // leading identifier (so a half-migrated file doesn't surface false
+        // unused-imports) and skip the rest.
+        let usage = usage_for("<template><Forms::Input /></template>", &["Forms"]);
+        assert!(usage.used_bindings.contains("Forms"));
+        assert!(
+            usage.member_accesses.is_empty(),
+            "member-style splits are intentionally not tracked",
+        );
+    }
+
+    #[test]
+    fn member_style_tag_credits_only_head_segment() {
+        // Same shape, dot separator. The leaf component should be imported
+        // directly in strict mode; if someone writes `<Buttons.Primary />`
+        // anyway, credit `Buttons` and leave `Primary` alone.
+        let usage = usage_for("<template><Buttons.Primary /></template>", &["Buttons"]);
+        assert!(usage.used_bindings.contains("Buttons"));
+        assert!(usage.member_accesses.is_empty());
+    }
+
+    #[test]
+    fn mustache_identifier_credits_binding() {
+        let usage = usage_for("<template>{{capitalize name}}</template>", &["capitalize"]);
+        assert!(usage.used_bindings.contains("capitalize"));
+    }
+
+    #[test]
+    fn sub_expression_helper_credits_binding() {
+        let usage = usage_for(
+            "<template>{{if (and a b) \"yes\" \"no\"}}</template>",
+            &["and"],
+        );
+        assert!(usage.used_bindings.contains("and"));
+    }
+
+    #[test]
+    fn modifier_invocation_credits_binding() {
+        let usage = usage_for(
+            "<template><button {{on \"click\" handleClick}} /></template>",
+            &["on"],
+        );
+        assert!(usage.used_bindings.contains("on"));
+    }
+
+    #[test]
+    fn this_and_arg_references_are_not_credited() {
+        let usage = usage_for(
+            "<template>{{this.name}} {{@arg}}</template>",
+            &["name", "arg"],
+        );
+        assert!(usage.used_bindings.is_empty());
+    }
+
+    #[test]
+    fn block_params_shadow_imports_template_wide() {
+        let usage = usage_for(
+            "<template>{{#each items as |item|}}{{item}}{{/each}}</template>",
+            &["item", "items"],
+        );
+        assert!(usage.used_bindings.contains("items"));
+        assert!(!usage.used_bindings.contains("item"));
+    }
+
+    #[test]
+    fn dotted_namespace_credits_binding_and_member() {
+        let usage = usage_for(
+            "<template>{{utils.formatDate value}}</template>",
+            &["utils"],
+        );
+        assert!(usage.used_bindings.contains("utils"));
+        assert_eq!(usage.member_accesses.len(), 1);
+        assert_eq!(usage.member_accesses[0].object, "utils");
+        assert_eq!(usage.member_accesses[0].member, "formatDate");
+    }
+
+    #[test]
+    fn multiple_template_blocks_all_contribute() {
+        let usage = usage_for(
+            "<template><Foo /></template>\nconst x = 1;\n<template>{{bar}}</template>",
+            &["Foo", "bar"],
+        );
+        assert!(usage.used_bindings.contains("Foo"));
+        assert!(usage.used_bindings.contains("bar"));
+    }
+
+    #[test]
+    fn malformed_template_produces_empty_usage() {
+        let usage = usage_for("<template>{{ unclosed", &["unclosed"]);
+        // Unclosed mustache yields no credits; the scan must not panic.
+        assert!(usage.used_bindings.is_empty());
+    }
+
+    #[test]
+    fn handlebars_comment_is_skipped() {
+        let usage = usage_for(
+            "<template>{{!-- {{capitalize x}} --}}</template>",
+            &["capitalize"],
+        );
+        assert!(usage.used_bindings.is_empty());
+    }
+
+    #[test]
+    fn builtin_keywords_are_not_credited() {
+        // Even if an import shadow-names a built-in keyword, the template's
+        // bareword should not be credited; that would mask real unused
+        // imports for users who happen to name a helper `if`.
+        let usage = usage_for("<template>{{if condition \"a\" \"b\"}}</template>", &["if"]);
+        assert!(usage.used_bindings.is_empty());
+    }
+
+    #[test]
+    fn strict_mode_helper_imports_are_credited() {
+        // `hash`, `array`, `concat`, `fn`, `mut`, `get` are ambient in classic
+        // `.hbs` but must be imported from `@ember/helper` in strict mode.
+        // The scanner must credit them when used in `<template>`, otherwise
+        // every strict-mode app surfaces these imports as `unused-import`.
+        for name in ["hash", "array", "concat", "fn", "mut", "get"] {
+            let template = format!("<template>{{{{{name} a=1}}}}</template>");
+            let usage = usage_for(&template, &[name]);
+            assert!(
+                usage.used_bindings.contains(name),
+                "expected strict-mode helper `{name}` to be credited",
+            );
+        }
+    }
+
+    #[test]
+    fn strict_mode_input_textarea_tag_imports_are_credited() {
+        // `<Input />` and `<Textarea />` are ambient in classic `.hbs` but
+        // imported from `@ember/component` in strict mode. Same goes for
+        // their use inside a containing element.
+        let usage = usage_for(
+            "<template><form><Input /><Textarea /></form></template>",
+            &["Input", "Textarea"],
+        );
+        assert!(usage.used_bindings.contains("Input"));
+        assert!(usage.used_bindings.contains("Textarea"));
+    }
+
+    #[test]
+    fn lowercase_dom_tags_are_never_credited() {
+        // `input` and `textarea` are HTML DOM elements, never Ember imports.
+        // Even if someone has `import { input } from '...'`, the scanner
+        // can't see a tag-name match because tag-name scanning only fires on
+        // ASCII-uppercase first chars.
+        let usage = usage_for(
+            "<template><input /><textarea /></template>",
+            &["input", "textarea"],
+        );
+        assert!(usage.used_bindings.is_empty());
+    }
+
+    #[test]
+    fn named_arg_value_is_credited_not_key() {
+        let usage = usage_for(
+            "<template>{{my-helper key=binding}}</template>",
+            &["my-helper", "binding", "key"],
+        );
+        assert!(usage.used_bindings.contains("binding"));
+        // The key `key` is the attr name, not a value reference.
+        assert!(!usage.used_bindings.contains("key"));
+    }
+
+    #[test]
+    fn pascal_case_block_tag_with_closing_does_not_double_count() {
+        let usage = usage_for("<template><MyMenu>inner</MyMenu></template>", &["MyMenu"]);
+        assert!(usage.used_bindings.contains("MyMenu"));
+    }
+
+    #[test]
+    fn empty_imports_short_circuits() {
+        let usage = usage_for("<template>{{foo}} <Bar /></template>", &[]);
+        assert!(usage.used_bindings.is_empty());
+        assert!(usage.member_accesses.is_empty());
+    }
+}
diff --git a/crates/extract/src/sfc_template/mod.rs b/crates/extract/src/sfc_template/mod.rs
index d3756e15b..9dbcc868b 100644
--- a/crates/extract/src/sfc_template/mod.rs
+++ b/crates/extract/src/sfc_template/mod.rs
@@ -6,6 +6,7 @@
 //! pretending to be a full framework compiler.
 
 pub mod angular;
+pub mod glimmer;
 mod scanners;
 mod shared;
 mod svelte;
diff --git a/crates/extract/src/tests/mod.rs b/crates/extract/src/tests/mod.rs
index ddb335b0c..649488fc5 100644
--- a/crates/extract/src/tests/mod.rs
+++ b/crates/extract/src/tests/mod.rs
@@ -47,3 +47,217 @@ fn parses_glimmer_typescript_as_typescript() {
             .any(|export| export.name.matches_str("ServiceRef"))
     );
 }
+
+#[test]
+fn glimmer_template_only_pascal_tag_credits_import() {
+    let info = parse_source_to_module(
+        FileId(0),
+        Path::new("app.gts"),
+        "import HelloWorld from './hello-world';\nimport { greeting } from './lib';\n\
+         <template><HelloWorld @msg={{greeting}} /></template>\n",
+        0,
+        false,
+    );
+
+    assert!(
+        info.unused_import_bindings.is_empty(),
+        "expected HelloWorld and greeting to be credited via the <template> block, \
+         but unused_import_bindings = {:?}",
+        info.unused_import_bindings,
+    );
+}
+
+#[test]
+fn glimmer_dotted_template_reference_emits_member_access() {
+    let info = parse_source_to_module(
+        FileId(0),
+        Path::new("app.gts"),
+        "import * as utils from './utils';\n<template>{{utils.formatDate value}}</template>\n",
+        0,
+        false,
+    );
+
+    assert!(info.unused_import_bindings.is_empty());
+    assert!(
+        info.member_accesses
+            .iter()
+            .any(|access| access.object == "utils" && access.member == "formatDate")
+    );
+}
+
+#[test]
+fn glimmer_import_used_only_inside_template_is_not_flagged() {
+    // Regression for the original symptom: an import that is referenced ONLY
+    // inside the template block was previously surfaced as `unused-import`
+    // because the template body is blanked before the JS parse.
+    let info = parse_source_to_module(
+        FileId(0),
+        Path::new("counter.gts"),
+        "import { capitalize } from './helpers';\n\
+         <template>{{capitalize name}}</template>\n",
+        0,
+        false,
+    );
+
+    assert!(info.unused_import_bindings.is_empty());
+}
+
+// ── negative cases: confirm the scanner does NOT over-credit ───────────
+//
+// The trio above only proves the credit path works. These tests fail the
+// suite if the scanner regresses into crediting bindings it shouldn't (or
+// if `info.unused_import_bindings` ever gets stubbed back to an empty set
+// by mistake): each one declares an import that is genuinely unreachable
+// and asserts it surfaces in `unused_import_bindings`.
+
+fn assert_unused(info: &ModuleInfo, expected: &[&str]) {
+    let mut actual: Vec<&str> = info
+        .unused_import_bindings
+        .iter()
+        .map(String::as_str)
+        .collect();
+    actual.sort_unstable();
+    let mut expected = expected.to_vec();
+    expected.sort_unstable();
+    assert_eq!(
+        actual, expected,
+        "unused_import_bindings did not match expected set"
+    );
+}
+
+#[test]
+fn glimmer_import_referenced_nowhere_is_flagged_unused() {
+    let info = parse_source_to_module(
+        FileId(0),
+        Path::new("app.gts"),
+        "import { unused } from './lib';\n\
+         <template>hello world</template>\n",
+        0,
+        false,
+    );
+    assert_unused(&info, &["unused"]);
+}
+
+#[test]
+fn glimmer_import_referenced_only_via_this_dot_in_template_is_flagged() {
+    // `this.greeting` reads a class property — even when `greeting` happens
+    // to also be an imported binding name, the template scanner must not
+    // credit the import.
+    let info = parse_source_to_module(
+        FileId(0),
+        Path::new("app.gts"),
+        "import { greeting } from './lib';\n\
+         <template>{{this.greeting}}</template>\n",
+        0,
+        false,
+    );
+    assert_unused(&info, &["greeting"]);
+}
+
+#[test]
+fn glimmer_import_referenced_only_via_arg_in_template_is_flagged() {
+    // `@name` is a template argument, not a module-scope binding. An import
+    // named `name` is genuinely unused here.
+    let info = parse_source_to_module(
+        FileId(0),
+        Path::new("app.gts"),
+        "import { name } from './lib';\n\
+         <template>{{@name}}</template>\n",
+        0,
+        false,
+    );
+    assert_unused(&info, &["name"]);
+}
+
+#[test]
+fn glimmer_import_shadowing_builtin_helper_is_flagged() {
+    // `each` is a Glimmer built-in helper keyword; the scanner must NEVER
+    // resolve it to an import binding, even if the user did `import { each }`.
+    // (Built-ins like `if` / `let` are reserved words and can't be import
+    // identifiers, so `each` is the realistic regression to lock in.)
+    let info = parse_source_to_module(
+        FileId(0),
+        Path::new("app.gts"),
+        "import { each } from './lib';\n\
+         <template>{{#each items as |x|}}{{x}}{{/each}}</template>\n",
+        0,
+        false,
+    );
+    assert_unused(&info, &["each"]);
+}
+
+#[test]
+fn glimmer_import_shadowed_by_block_param_is_flagged() {
+    // `as |item|` introduces a template-scope local. References to `item`
+    // inside the block resolve to the local, NOT to the same-named import,
+    // so the import must surface as unused.
+    let info = parse_source_to_module(
+        FileId(0),
+        Path::new("app.gts"),
+        "import { item } from './lib';\n\
+         <template>{{#each items as |item|}}{{item}}{{/each}}</template>\n",
+        0,
+        false,
+    );
+    assert!(
+        info.unused_import_bindings.iter().any(|b| b == "item"),
+        "`item` should be flagged unused (shadowed by block param), \
+         unused_import_bindings = {:?}",
+        info.unused_import_bindings,
+    );
+}
+
+#[test]
+fn glimmer_mix_of_used_and_unused_imports_flags_only_the_unused() {
+    let info = parse_source_to_module(
+        FileId(0),
+        Path::new("app.gts"),
+        "import HelloWorld from './hello-world';\n\
+         import { greeting } from './lib';\n\
+         import { stale } from './lib';\n\
+         <template><HelloWorld @msg={{greeting}} /></template>\n",
+        0,
+        false,
+    );
+    assert_unused(&info, &["stale"]);
+}
+
+#[test]
+fn glimmer_strict_mode_helper_imports_from_ember_helper_are_credited() {
+    // Strict-mode `.gts` requires `hash`, `array`, `concat`, `fn`, `mut`,
+    // `get` to be imported from `@ember/helper`; using them in `<template>`
+    // must keep the import credited. Regression for the case where these
+    // names were misclassified as ambient built-ins and never credited.
+    let info = parse_source_to_module(
+        FileId(0),
+        Path::new("form.gts"),
+        "import { hash, array, concat, fn, get } from '@ember/helper';\n\
+         <template>\n  \
+           {{#let (hash a=(array 1 2) label=(concat \"x\" \"y\")) as |opts|}}\n    \
+             <button {{on \"click\" (fn this.save opts)}}>{{get opts \"label\"}}</button>\n  \
+           {{/let}}\n\
+         </template>\n",
+        0,
+        false,
+    );
+    assert!(
+        info.unused_import_bindings.is_empty(),
+        "expected hash/array/concat/fn/get to be credited via the template, \
+         unused_import_bindings = {:?}",
+        info.unused_import_bindings,
+    );
+}
+
+#[test]
+fn glimmer_file_without_template_still_flags_unused_imports() {
+    // Sanity: the scanner only ever ADDS credit; on a `.gts` file with no
+    // `<template>` block at all, an unused import must still surface.
+    let info = parse_source_to_module(
+        FileId(0),
+        Path::new("plain.gts"),
+        "import { unused } from './lib';\nexport const x = 1;\n",
+        0,
+        false,
+    );
+    assert_unused(&info, &["unused"]);
+}
diff --git a/tests/fixtures/ember-classic/app/app.ts b/tests/fixtures/ember-classic/app/app.ts
new file mode 100644
index 000000000..22ca740d8
--- /dev/null
+++ b/tests/fixtures/ember-classic/app/app.ts
@@ -0,0 +1,21 @@
+import Application from '@ember/application';
+import Resolver from 'ember-resolver';
+import loadInitializers from 'ember-load-initializers';
+import Router from './router';
+
+const config = {
+  modulePrefix: 'ember-classic-fixture',
+  environment: 'development',
+  rootURL: '/',
+  locationType: 'history',
+};
+
+export default class App extends Application {
+  modulePrefix = config.modulePrefix;
+  podModulePrefix = undefined;
+  Resolver = Resolver;
+}
+
+(App.prototype as any).Router = Router;
+
+loadInitializers(App as any, config.modulePrefix);
diff --git a/tests/fixtures/ember-classic/app/components/counter.gts b/tests/fixtures/ember-classic/app/components/counter.gts
new file mode 100644
index 000000000..40b7a49fc
--- /dev/null
+++ b/tests/fixtures/ember-classic/app/components/counter.gts
@@ -0,0 +1,20 @@
+import Component from '@glimmer/component';
+import { tracked } from '@glimmer/tracking';
+import { on } from '@ember/modifier';
+
+export default class Counter extends Component {
+  @tracked count = 0;
+
+  increment = () => {
+    this.count = this.count + 1;
+  }
+
+  // `on` is referenced ONLY inside the <template> block below. Without the
+  // Glimmer template scanner this import would surface as `unused-import`;
+  // with it, the modifier mustache `{{on "click" ...}}` credits the binding.
+  <template>
+    <button type="button" {{on "click" this.increment}}>
+      Count: {{this.count}}
+    </button>
+  </template>
+}
diff --git a/tests/fixtures/ember-classic/app/components/hello-world.gts b/tests/fixtures/ember-classic/app/components/hello-world.gts
new file mode 100644
index 000000000..22070b3c1
--- /dev/null
+++ b/tests/fixtures/ember-classic/app/components/hello-world.gts
@@ -0,0 +1,15 @@
+import Component from '@glimmer/component';
+import { tracked } from '@glimmer/tracking';
+
+interface HelloWorldSignature {
+  Element: HTMLHeadingElement;
+  Args: { name: string };
+}
+
+export default class HelloWorld extends Component<HelloWorldSignature> {
+  @tracked greeting = 'Hello';
+
+  <template>
+    <h1>{{this.greeting}}, {{@name}}!</h1>
+  </template>
+}
diff --git a/tests/fixtures/ember-classic/app/controllers/application.ts b/tests/fixtures/ember-classic/app/controllers/application.ts
new file mode 100644
index 000000000..bc1ef32aa
--- /dev/null
+++ b/tests/fixtures/ember-classic/app/controllers/application.ts
@@ -0,0 +1,12 @@
+import Controller from "@ember/controller";
+import { tracked } from "@glimmer/tracking";
+
+export default class ApplicationController extends Controller {
+  queryParams = ["q"];
+
+  @tracked q = "";
+
+  reset = () => {
+    this.q = "";
+  };
+}
diff --git a/tests/fixtures/ember-classic/app/helpers/format-date.ts b/tests/fixtures/ember-classic/app/helpers/format-date.ts
new file mode 100644
index 000000000..ba7189bba
--- /dev/null
+++ b/tests/fixtures/ember-classic/app/helpers/format-date.ts
@@ -0,0 +1,10 @@
+import Helper from '@ember/component/helper';
+
+export default class FormatDate extends Helper<{
+  Args: { Positional: [Date] };
+  Return: string;
+}> {
+  compute([date]: [Date]) {
+    return date.toISOString();
+  }
+}
diff --git a/tests/fixtures/ember-classic/app/index.html b/tests/fixtures/ember-classic/app/index.html
new file mode 100644
index 000000000..e5f0a5d26
--- /dev/null
+++ b/tests/fixtures/ember-classic/app/index.html
@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>EmberClassicFixture</title>
+    <meta name="description" content="">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+  </head>
+  <body>
+    <script src="assets/vendor.js"></script>
+    <script src="assets/ember-classic-fixture.js"></script>
+  </body>
+</html>
diff --git a/tests/fixtures/ember-classic/app/models/user.ts b/tests/fixtures/ember-classic/app/models/user.ts
new file mode 100644
index 000000000..a0d241eb3
--- /dev/null
+++ b/tests/fixtures/ember-classic/app/models/user.ts
@@ -0,0 +1,6 @@
+import Model, { attr } from '@ember-data/model';
+
+export default class User extends Model {
+  @attr('string') declare name: string;
+  @attr('string') declare email: string;
+}
diff --git a/tests/fixtures/ember-classic/app/modifiers/autofocus.ts b/tests/fixtures/ember-classic/app/modifiers/autofocus.ts
new file mode 100644
index 000000000..fdbd1a54c
--- /dev/null
+++ b/tests/fixtures/ember-classic/app/modifiers/autofocus.ts
@@ -0,0 +1,9 @@
+import Modifier from 'ember-modifier';
+
+export default class AutofocusModifier extends Modifier<{
+  Element: HTMLElement;
+}> {
+  modify(element: HTMLElement) {
+    element.focus();
+  }
+}
diff --git a/tests/fixtures/ember-classic/app/router.ts b/tests/fixtures/ember-classic/app/router.ts
new file mode 100644
index 000000000..0c3fea1df
--- /dev/null
+++ b/tests/fixtures/ember-classic/app/router.ts
@@ -0,0 +1,15 @@
+import EmberRouter from '@ember/routing/router';
+
+const config = {
+  rootURL: '/',
+  locationType: 'history' as const,
+};
+
+export default class Router extends EmberRouter {
+  location = config.locationType;
+  rootURL = config.rootURL;
+}
+
+Router.map(function (this: any) {
+  this.route('about');
+});
diff --git a/tests/fixtures/ember-classic/app/routes/application.ts b/tests/fixtures/ember-classic/app/routes/application.ts
new file mode 100644
index 000000000..6be587a3a
--- /dev/null
+++ b/tests/fixtures/ember-classic/app/routes/application.ts
@@ -0,0 +1,19 @@
+import Route from '@ember/routing/route';
+import { service } from '@ember/service';
+import type SessionService from 'ember-classic-fixture/services/session';
+import User from 'ember-classic-fixture/models/user';
+
+export default class ApplicationRoute extends Route {
+  @service declare session: SessionService;
+
+  async model() {
+    const user = new User();
+    user.name = 'world';
+    return user;
+  }
+
+  setupController(controller: any, model: any) {
+    super.setupController(controller, model);
+    this.session.touch();
+  }
+}
diff --git a/tests/fixtures/ember-classic/app/routes/index.ts b/tests/fixtures/ember-classic/app/routes/index.ts
new file mode 100644
index 000000000..bd06aea3a
--- /dev/null
+++ b/tests/fixtures/ember-classic/app/routes/index.ts
@@ -0,0 +1,7 @@
+import Route from '@ember/routing/route';
+
+export default class IndexRoute extends Route {
+  async model() {
+    return { hello: 'world' };
+  }
+}
diff --git a/tests/fixtures/ember-classic/app/services/session.ts b/tests/fixtures/ember-classic/app/services/session.ts
new file mode 100644
index 000000000..315236df1
--- /dev/null
+++ b/tests/fixtures/ember-classic/app/services/session.ts
@@ -0,0 +1,20 @@
+import Service from '@ember/service';
+import { tracked } from '@glimmer/tracking';
+
+export default class SessionService extends Service {
+  @tracked lastTouched: number = 0;
+
+  init() {
+    super.init();
+    this.lastTouched = Date.now();
+  }
+
+  touch() {
+    this.lastTouched = Date.now();
+  }
+
+  willDestroy() {
+    super.willDestroy();
+    this.lastTouched = 0;
+  }
+}
diff --git a/tests/fixtures/ember-classic/app/templates/application.hbs b/tests/fixtures/ember-classic/app/templates/application.hbs
new file mode 100644
index 000000000..e78f7126e
--- /dev/null
+++ b/tests/fixtures/ember-classic/app/templates/application.hbs
@@ -0,0 +1,3 @@
+<HelloWorld @name="world" />
+<Counter />
+{{outlet}}
diff --git a/tests/fixtures/ember-classic/config/environment.js b/tests/fixtures/ember-classic/config/environment.js
new file mode 100644
index 000000000..2f8cfcafa
--- /dev/null
+++ b/tests/fixtures/ember-classic/config/environment.js
@@ -0,0 +1,12 @@
+'use strict';
+
+module.exports = function (environment) {
+  return {
+    modulePrefix: 'ember-classic-fixture',
+    environment,
+    rootURL: '/',
+    locationType: 'history',
+    EmberENV: {},
+    APP: {},
+  };
+};
diff --git a/tests/fixtures/ember-classic/config/optional-features.json b/tests/fixtures/ember-classic/config/optional-features.json
new file mode 100644
index 000000000..0967ef424
--- /dev/null
+++ b/tests/fixtures/ember-classic/config/optional-features.json
@@ -0,0 +1 @@
+{}
diff --git a/tests/fixtures/ember-classic/config/targets.js b/tests/fixtures/ember-classic/config/targets.js
new file mode 100644
index 000000000..f0000d3d7
--- /dev/null
+++ b/tests/fixtures/ember-classic/config/targets.js
@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = {
+  browsers: ['last 2 Chrome versions'],
+};
diff --git a/tests/fixtures/ember-classic/ember-cli-build.js b/tests/fixtures/ember-classic/ember-cli-build.js
new file mode 100644
index 000000000..40894a4a1
--- /dev/null
+++ b/tests/fixtures/ember-classic/ember-cli-build.js
@@ -0,0 +1,8 @@
+'use strict';
+
+const EmberApp = require('ember-cli/lib/broccoli/ember-app');
+
+module.exports = function (defaults) {
+  const app = new EmberApp(defaults, {});
+  return app.toTree();
+};
diff --git a/tests/fixtures/ember-classic/package.json b/tests/fixtures/ember-classic/package.json
new file mode 100644
index 000000000..a49b6d6a7
--- /dev/null
+++ b/tests/fixtures/ember-classic/package.json
@@ -0,0 +1,32 @@
+{
+  "name": "ember-classic-fixture",
+  "private": true,
+  "dependencies": {
+    "ember-source": "^5.12.0",
+    "ember-cli": "^5.12.0",
+    "ember-cli-htmlbars": "^6.3.0",
+    "ember-cli-babel": "^8.2.0",
+    "ember-auto-import": "^2.7.0",
+    "ember-load-initializers": "^3.0.1",
+    "ember-resolver": "^13.0.0",
+    "@glimmer/component": "^2.0.0",
+    "@glimmer/tracking": "^1.1.2",
+    "ember-data": "^5.3.0",
+    "@ember-data/model": "^5.3.0",
+    "@ember-data/store": "^5.3.0",
+    "@embroider/macros": "^1.16.0",
+    "ember-modifier": "^4.2.0",
+    "loader.js": "^4.7.0"
+  },
+  "devDependencies": {
+    "ember-qunit": "^8.1.0",
+    "qunit": "^2.20.0",
+    "qunit-dom": "^3.2.0",
+    "@ember/test-helpers": "^4.0.0",
+    "ember-template-lint": "^6.0.0",
+    "@glint/core": "^1.4.0",
+    "@glint/environment-ember-loose": "^1.4.0",
+    "typescript": "^5.4.0",
+    "@embroider/test-setup": "^4.0.0"
+  }
+}
diff --git a/tests/fixtures/ember-classic/testem.js b/tests/fixtures/ember-classic/testem.js
new file mode 100644
index 000000000..977fd30d7
--- /dev/null
+++ b/tests/fixtures/ember-classic/testem.js
@@ -0,0 +1,14 @@
+'use strict';
+
+module.exports = {
+  test_page: 'tests/index.html?hidepassed',
+  disable_watching: true,
+  launch_in_ci: ['Chrome'],
+  launch_in_dev: ['Chrome'],
+  browser_start_timeout: 120,
+  browser_args: {
+    Chrome: {
+      ci: ['--headless', '--disable-gpu', '--no-sandbox'],
+    },
+  },
+};
diff --git a/tests/fixtures/ember-classic/tests/index.html b/tests/fixtures/ember-classic/tests/index.html
new file mode 100644
index 000000000..07eafa047
--- /dev/null
+++ b/tests/fixtures/ember-classic/tests/index.html
@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>EmberClassicFixture Tests</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <link rel="stylesheet" href="assets/test-support.css">
+  </head>
+  <body>
+    <div id="qunit"></div>
+    <div id="qunit-fixture"></div>
+    <div id="ember-testing-container">
+      <div id="ember-testing"></div>
+    </div>
+    <script src="assets/vendor.js"></script>
+    <script src="assets/test-support.js"></script>
+    <script src="assets/ember-classic-fixture.js"></script>
+    <script src="assets/tests.js"></script>
+  </body>
+</html>
diff --git a/tests/fixtures/ember-classic/tests/integration/components/hello-world-test.gts b/tests/fixtures/ember-classic/tests/integration/components/hello-world-test.gts
new file mode 100644
index 000000000..76297f28e
--- /dev/null
+++ b/tests/fixtures/ember-classic/tests/integration/components/hello-world-test.gts
@@ -0,0 +1,13 @@
+import { module, test } from 'qunit';
+import { setupRenderingTest } from 'ember-qunit';
+import { render } from '@ember/test-helpers';
+import HelloWorld from 'ember-classic-fixture/components/hello-world';
+
+module('Integration | Component | hello-world', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('it renders a greeting', async function (assert) {
+    await render(<template><HelloWorld @name="qunit" /></template>);
+    assert.dom('h1').includesText('qunit');
+  });
+});
diff --git a/tests/fixtures/ember-classic/tests/test-helper.ts b/tests/fixtures/ember-classic/tests/test-helper.ts
new file mode 100644
index 000000000..9b5dbd5e4
--- /dev/null
+++ b/tests/fixtures/ember-classic/tests/test-helper.ts
@@ -0,0 +1,14 @@
+import { setApplication } from '@ember/test-helpers';
+import { start, setupEmberOnerrorValidation } from 'ember-qunit';
+import Application from 'ember-classic-fixture/app';
+
+const config = {
+  modulePrefix: 'ember-classic-fixture',
+  environment: 'test',
+  rootURL: '/',
+};
+
+setApplication(Application.create({ ...config, autoboot: false }));
+
+setupEmberOnerrorValidation();
+start();
diff --git a/tests/fixtures/ember-classic/tests/unit/services/session-test.ts b/tests/fixtures/ember-classic/tests/unit/services/session-test.ts
new file mode 100644
index 000000000..03ac68c0f
--- /dev/null
+++ b/tests/fixtures/ember-classic/tests/unit/services/session-test.ts
@@ -0,0 +1,13 @@
+import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+import type SessionService from 'ember-classic-fixture/services/session';
+
+module('Unit | Service | session', function (hooks) {
+  setupTest(hooks);
+
+  test('touch updates lastTouched', function (assert) {
+    const service = (this as any).owner.lookup('service:session') as SessionService;
+    service.touch();
+    assert.ok(service.lastTouched > 0, 'lastTouched is set');
+  });
+});