diff --git a/packages/ember-tsc/package.json b/packages/ember-tsc/package.json
index 4f8c5f799..02160a8c1 100644
--- a/packages/ember-tsc/package.json
+++ b/packages/ember-tsc/package.json
@@ -19,6 +19,10 @@
       "types": "./lib/transform/index.d.ts",
       "default": "./lib/transform/index.js"
     },
+    "./transform/standalone": {
+      "types": "./lib/transform/template/rewrite-module-standalone.d.ts",
+      "default": "./lib/transform/template/rewrite-module-standalone.js"
+    },
     "./bin/*": "./bin/*.js",
     "./globals": "./types/globals/index.d.ts",
     "./-private/dsl": {
@@ -87,6 +91,7 @@
     "@volar/test-utils": "~2.4.28",
     "@volar/typescript": "~2.4.28",
     "content-tag": "^4.2.0",
+    "ember-estree": "^0.8.0",
     "silent-error": "^1.1.1",
     "volar-service-html": "~0.0.71",
     "volar-service-typescript": "~0.0.71",
diff --git a/packages/ember-tsc/src/environment-ember-template-imports/-private/environment/common.ts b/packages/ember-tsc/src/environment-ember-template-imports/-private/environment/common.ts
index 70fd1f365..41ea87b22 100644
--- a/packages/ember-tsc/src/environment-ember-template-imports/-private/environment/common.ts
+++ b/packages/ember-tsc/src/environment-ember-template-imports/-private/environment/common.ts
@@ -3,6 +3,8 @@ export type PreprocessData = {
 };
 
 export type TemplateLocation = {
+  /** content-tag's classification: a class's own template, or a template expression. */
+  type: 'expression' | 'class-member';
   startTagOffset: number;
   startTagLength: number;
   endTagOffset: number;
diff --git a/packages/ember-tsc/src/environment-ember-template-imports/-private/environment/preprocess.ts b/packages/ember-tsc/src/environment-ember-template-imports/-private/environment/preprocess.ts
index 19314f054..554912555 100644
--- a/packages/ember-tsc/src/environment-ember-template-imports/-private/environment/preprocess.ts
+++ b/packages/ember-tsc/src/environment-ember-template-imports/-private/environment/preprocess.ts
@@ -3,7 +3,7 @@ import { GLOBAL_TAG, PreprocessData, TemplateLocation } from './common.js';
 
 // A `<template>` becomes a tagged-template expression `___T`...``. In a class
 // body a bare expression is not a valid member, so there it is wrapped in a
-// computed-property name `[___T`...`]` (rewritten to a static block during
+// computed-property name `;[___T`...`]` (rewritten to a static block during
 // transform). In every other position it is emitted bare: that keeps a
 // user-authored array such as `[<template/>]` a single array literal, so it
 // can never be confused with — and collapsed into — the wrapper.
@@ -16,6 +16,12 @@ const p = new Preprocessor();
 export const preprocess: GlintExtensionPreprocess<PreprocessData> = (source, path) => {
   let templates = p.parse(source, { filename: path });
 
+  // content-tag reports a class's own template before any template that
+  // appears earlier in its heritage clause (`class A extends mixin(<template>
+  // ...</template>) { <template>...</template> }`); the splicing below needs
+  // them in source order.
+  templates.sort((a, b) => a.range.startUtf16Codepoint - b.range.startUtf16Codepoint);
+
   let templateLocations: Array<TemplateLocation> = [];
   let contents = '';
   let sourceOffset = 0;
@@ -30,7 +36,11 @@ export const preprocess: GlintExtensionPreprocess<PreprocessData> = (source, pat
 
     let isClassMember = template.type === 'class-member';
 
-    if (isClassMember) contents += '[';
+    // The leading `;` is an empty class element. It stops the `[` from being
+    // read as an element access on a preceding field whose initializer has
+    // no trailing semicolon (`isChecked = (v) => v === 1\n<template>...`
+    // would otherwise become `1[___T`...`]`, an expression template).
+    if (isClassMember) contents += ';[';
 
     // `transformedStart`/`transformedEnd` bracket the tag literal itself
     // (`___T`...``), excluding any class-member `[ ]`, so they line up exactly
@@ -48,6 +58,7 @@ export const preprocess: GlintExtensionPreprocess<PreprocessData> = (source, pat
 
     sourceOffset = endTagEnd;
     templateLocations.push({
+      type: template.type,
       startTagOffset,
       endTagOffset,
       startTagLength: startTagEnd - startTagOffset,
diff --git a/packages/ember-tsc/src/transform/template/inlining/index.ts b/packages/ember-tsc/src/transform/template/inlining/index.ts
index 0f09206c2..1bb0dc304 100644
--- a/packages/ember-tsc/src/transform/template/inlining/index.ts
+++ b/packages/ember-tsc/src/transform/template/inlining/index.ts
@@ -1,3 +1,4 @@
+import { GlintEmitMetadata } from '@glint/ember-tsc/config-types';
 import type ts from 'typescript';
 import { CorrelatedSpan, Directive, TransformError } from '../transformed-module.js';
 import { TSLib } from '../../util.js';
@@ -10,6 +11,27 @@ export type CorrelatedSpansResult = {
   partialSpans: Array<PartialCorrelatedSpan>;
 };
 
+export type ImportedBinding = { specifier: string; source: string; synthetic: boolean };
+export type ImportedBindings = Record<string, ImportedBinding>;
+
+/**
+ * Everything the template transform needs to know about one embedded
+ * `<template>`, independent of how the surrounding script was analyzed.
+ * `rewriteModule` derives this from the TypeScript AST; the standalone entry
+ * point derives it from content-tag's parse output and a lightweight scan of
+ * the script (see `script-scanner.ts`).
+ */
+export type EmbeddedTemplate = {
+  /** The template's text, as authored between the tags. */
+  template: string;
+  /** Offsets into the original script, in the same shape as `GlintEmitMetadata['templateLocation']`. */
+  templateLocation: NonNullable<GlintEmitMetadata['templateLocation']>;
+  thisBinding: TemplateThisBinding;
+  /** Text emitted before / after the template's transformed output (e.g. `export default `). */
+  prepend?: string | undefined;
+  append?: string | undefined;
+};
+
 /**
  * How the `{{this}}` of an embedded template should be bound, based on where
  * the template sits in the surrounding module:
@@ -39,22 +61,43 @@ export type CorrelatedSpansResult = {
 export type TemplateThisBinding = 'backing-class' | 'lexical' | 'context';
 
 /**
- * Given an AST node for an embedded template, determines how the template's
- * `{{this}}` should be bound. See {@link TemplateThisBinding}.
+ * The ancestor kinds that decide a template's `this` binding, in the order
+ * met walking outward from the template. See {@link TemplateThisBinding}.
  */
-export function templateThisBinding(ts: TSLib, node: ts.Node): TemplateThisBinding {
-  let current: ts.Node | null = node;
-  do {
-    if (ts.isClassStaticBlockDeclaration(current)) {
-      return 'backing-class';
-    }
-    if (ts.isHeritageClause(current)) {
-      return 'context';
-    }
-    if (ts.isClassLike(current)) {
-      return 'lexical';
-    }
-  } while ((current = current.parent));
+export type ThisBindingAncestor = 'static-block' | 'heritage-clause' | 'class' | 'other';
 
+/**
+ * Resolves a template's `this` binding from its ancestors, innermost first:
+ * the first static block, heritage clause or class met decides.
+ */
+export function thisBindingFromAncestors(
+  ancestors: Iterable<ThisBindingAncestor>,
+): TemplateThisBinding {
+  for (let ancestor of ancestors) {
+    switch (ancestor) {
+      case 'static-block':
+        return 'backing-class';
+      case 'heritage-clause':
+        return 'context';
+      case 'class':
+        return 'lexical';
+    }
+  }
   return 'context';
 }
+
+/**
+ * Given a TS AST node for an embedded template, determines how the template's
+ * `{{this}}` should be bound. See {@link TemplateThisBinding}.
+ */
+export function templateThisBinding(ts: TSLib, node: ts.Node): TemplateThisBinding {
+  return thisBindingFromAncestors(
+    (function* () {
+      for (let current = node.parent; current; current = current.parent) {
+        if (ts.isClassStaticBlockDeclaration(current)) yield 'static-block';
+        else if (ts.isHeritageClause(current)) yield 'heritage-clause';
+        else if (ts.isClassLike(current)) yield 'class';
+      }
+    })(),
+  );
+}
diff --git a/packages/ember-tsc/src/transform/template/inlining/tagged-strings.ts b/packages/ember-tsc/src/transform/template/inlining/tagged-strings.ts
index 13f9977e3..6f2bbdf7a 100644
--- a/packages/ember-tsc/src/transform/template/inlining/tagged-strings.ts
+++ b/packages/ember-tsc/src/transform/template/inlining/tagged-strings.ts
@@ -9,7 +9,14 @@ import { GlintEnvironment } from '../../../config/index.js';
 import { assert, TSLib } from '../../util.js';
 import { templateToTypescript } from '../template-to-typescript.js';
 import { Directive, Range, SourceFile, TransformError } from '../transformed-module.js';
-import { CorrelatedSpansResult, templateThisBinding, PartialCorrelatedSpan } from './index.js';
+import {
+  CorrelatedSpansResult,
+  EmbeddedTemplate,
+  ImportedBinding,
+  ImportedBindings,
+  templateThisBinding,
+  PartialCorrelatedSpan,
+} from './index.js';
 
 export function calculateTaggedTemplateSpans(
   ts: TSLib,
@@ -17,126 +24,150 @@ export function calculateTaggedTemplateSpans(
   meta: GlintEmitMetadata | undefined,
   script: SourceFile,
   environment: GlintEnvironment,
+): CorrelatedSpansResult {
+  let tag = node.tag;
+
+  if (!ts.isIdentifier(tag)) {
+    return { errors: [], directives: [], partialSpans: [] };
+  }
+
+  let importedBindings = collectImportedBindings(ts, tag.getSourceFile());
+  if (!resolveTagInfo(importedBindings, tag, environment)) {
+    return { errors: [], directives: [], partialSpans: [] };
+  }
+
+  assert(
+    ts.isNoSubstitutionTemplateLiteral(node.template),
+    'No interpolated values in template strings',
+  );
+
+  // The gts/gjs transform records where the `<template>` sat in the original
+  // source on every tag literal it synthesizes.
+  let templateLocation = meta?.templateLocation;
+  assert(templateLocation, 'Template literal is missing its original location');
+
+  return calculateTemplateSpans(
+    {
+      // Use the cooked text (`text`) rather than `rawText`. For .gts files, the
+      // gts preprocessor (see `environment-ember-template-imports/-private/
+      // environment/preprocess.ts`) escapes backticks and `${{` sequences inside
+      // template content so the wrapped chunk parses as a valid JS template
+      // literal. `rawText` preserves those backslash-escapes as literal
+      // characters, which inflates the template length by 1 per escape and
+      // shifts every downstream source-map offset by the same amount (manifests
+      // as hover/go-to-definition spans landing past the start of any identifier
+      // that follows an escaped backtick or `${{` in the same template, e.g.
+      // hyphenated keywords used after backtick-quoted text in a comment). The
+      // cooked `text` reverses those escapes, restoring 1:1 correspondence with
+      // the original source.
+      template: node.template.text,
+      templateLocation,
+      thisBinding: templateThisBinding(ts, node),
+      prepend: meta?.prepend,
+      append: meta?.append,
+    },
+    importedBindings,
+    script,
+    environment,
+  );
+}
+
+/**
+ * Rewrites one embedded template into its TypeScript representation and
+ * returns the resulting correlated span (plus any errors and directives). This
+ * is the shared core behind `rewriteModule` and `rewriteModuleStandalone`.
+ */
+export function calculateTemplateSpans(
+  embedded: EmbeddedTemplate,
+  importedBindings: ImportedBindings,
+  script: SourceFile,
+  environment: GlintEnvironment,
 ): CorrelatedSpansResult {
   let directives: Array<Directive> = [];
   let errors: Array<TransformError> = [];
   let partialSpans: Array<PartialCorrelatedSpan> = [];
-  let tag = node.tag;
 
-  if (!ts.isIdentifier(tag)) {
+  let tagConfig = environment.getTemplateConfig();
+  if (!tagConfig) {
     return { errors, directives, partialSpans };
   }
 
-  let importedBindings = collectImportedBindings(ts, tag.getSourceFile());
-  let info = resolveTagInfo(importedBindings, tag, environment);
-  if (info) {
-    assert(
-      ts.isNoSubstitutionTemplateLiteral(node.template),
-      'No interpolated values in template strings',
-    );
-
-    let { typesModule, globals } = info.tagConfig;
-    // Use the cooked text (`text`) rather than `rawText`. For .gts files, the
-    // gts preprocessor (see `environment-ember-template-imports/-private/
-    // environment/preprocess.ts`) escapes backticks and `${{` sequences inside
-    // template content so the wrapped chunk parses as a valid JS template
-    // literal. `rawText` preserves those backslash-escapes as literal
-    // characters, which inflates the template length by 1 per escape and
-    // shifts every downstream source-map offset by the same amount (manifests
-    // as hover/go-to-definition spans landing past the start of any identifier
-    // that follows an escaped backtick or `${{` in the same template, e.g.
-    // hyphenated keywords used after backtick-quoted text in a comment). The
-    // cooked `text` reverses those escapes, restoring 1:1 correspondence with
-    // the original source.
-    let template = node.template.text;
-
-    // environment-specific transforms may emit templateLocation in meta, in
-    // which case we use that. Otherwise we use the reported location from the
-    // node itself (which is presumably correct because no transform has messed
-    // with it).
-    let templateLocation = meta?.templateLocation ?? {
-      start: node.getStart(),
-      end: node.getEnd(),
-      contentStart: node.template.getStart() + 1,
-      contentEnd: node.template.getEnd() - 1,
-    };
-
-    let embeddingSyntax = {
-      prefix: script.contents.slice(templateLocation.start, templateLocation.contentStart),
-      suffix: script.contents.slice(templateLocation.contentEnd, templateLocation.end),
-    };
-
-    // The `<template>` form's backing import is always compiler-synthesized
-    // (see `resolveTagInfo`), so there is never a user-written tag binding to
-    // reference in a preamble.
-    let preamble: Array<string> = [];
-
-    let specialForms = collectSpecialForms(importedBindings, info.tagConfig.specialForms ?? {});
-
-    // A lexical import should win over the environment's global keyword list,
-    // because the import is the canonical reference to the value (and is
-    // typed accordingly) while the global entry is a same-named alias.
-    // Concretely: `import { on } from '@ember/modifier'` followed by
-    // `{{on ...}}` must resolve to the imported `OnModifier`, not to the
-    // `Globals.on` entry (typed as `never` on ember-source < 7.1 by the
-    // `Ember71Only<...>` probe). Without this we surface
-    // `TS2349: Type 'never' has no call signatures.` See typed-ember/glint#1113.
-    //
-    // Keyword-style globals (`if`, `unless`, `yield`, `component`, `modifier`,
-    // `helper`) are deliberately exempt: their semantics are baked into the
-    // template language, not derivable from an import. Even if a user imports
-    // a same-named value, `{{(modifier ...)}}` still has to dispatch to the
-    // `bind-invokable` special form (which routes through `Globals.modifier`).
-    let keywordSpecialForms = info.tagConfig.specialForms?.globals ?? {};
-    let effectiveGlobals = globals?.filter(
-      (name) => name in keywordSpecialForms || !(name in importedBindings),
-    );
-
-    let thisBinding = templateThisBinding(ts, node);
-
-    let transformedTemplate = templateToTypescript(template, {
-      typesModule: typesModule,
-      meta,
-      preamble,
-      globals: effectiveGlobals,
-      embeddingSyntax,
-      specialForms,
-      backingValue: thisBinding === 'backing-class' ? 'this' : undefined,
-      lexicalThis: thisBinding === 'lexical',
-      useJsDoc: environment.isUntypedScript(script.filename),
-    });
+  let { typesModule, globals } = tagConfig;
+  let { template, templateLocation, thisBinding, prepend, append } = embedded;
 
-    for (let { message, location } of transformedTemplate.errors) {
-      if (location) {
-        errors.push({
-          source: script,
-          message,
-          location: addOffset(location, templateLocation.start),
-        });
-      } else {
-        errors.push({
-          source: script,
-          message,
-          location: {
-            start: tag.getStart(),
-            end: tag.getEnd(),
-          },
-        });
-      }
-    }
+  let embeddingSyntax = {
+    prefix: script.contents.slice(templateLocation.start, templateLocation.contentStart),
+    suffix: script.contents.slice(templateLocation.contentEnd, templateLocation.end),
+  };
+
+  // The `<template>` form's backing import is always compiler-synthesized
+  // (see `resolveTagInfo`), so there is never a user-written tag binding to
+  // reference in a preamble.
+  let preamble: Array<string> = [];
 
-    if (transformedTemplate.result) {
-      partialSpans.push({
-        originalFile: script,
-        originalStart: templateLocation.start,
-        originalLength: templateLocation.end - templateLocation.start,
-        insertionPoint: templateLocation.start,
-        transformedSource: transformedTemplate.result.code,
-        glimmerAstMapping: transformedTemplate.result.mapping,
+  let specialForms = collectSpecialForms(importedBindings, tagConfig.specialForms ?? {});
+
+  // A lexical import should win over the environment's global keyword list,
+  // because the import is the canonical reference to the value (and is
+  // typed accordingly) while the global entry is a same-named alias.
+  // Concretely: `import { on } from '@ember/modifier'` followed by
+  // `{{on ...}}` must resolve to the imported `OnModifier`, not to the
+  // `Globals.on` entry (typed as `never` on ember-source < 7.1 by the
+  // `Ember71Only<...>` probe). Without this we surface
+  // `TS2349: Type 'never' has no call signatures.` See typed-ember/glint#1113.
+  //
+  // Keyword-style globals (`if`, `unless`, `yield`, `component`, `modifier`,
+  // `helper`) are deliberately exempt: their semantics are baked into the
+  // template language, not derivable from an import. Even if a user imports
+  // a same-named value, `{{(modifier ...)}}` still has to dispatch to the
+  // `bind-invokable` special form (which routes through `Globals.modifier`).
+  let keywordSpecialForms = tagConfig.specialForms?.globals ?? {};
+  let effectiveGlobals = globals?.filter(
+    (name) => name in keywordSpecialForms || !(name in importedBindings),
+  );
+
+  let transformedTemplate = templateToTypescript(template, {
+    typesModule: typesModule,
+    meta: { prepend, append, templateLocation },
+    preamble,
+    globals: effectiveGlobals,
+    embeddingSyntax,
+    specialForms,
+    backingValue: thisBinding === 'backing-class' ? 'this' : undefined,
+    lexicalThis: thisBinding === 'lexical',
+    useJsDoc: environment.isUntypedScript(script.filename),
+  });
+
+  for (let { message, location } of transformedTemplate.errors) {
+    if (location) {
+      errors.push({
+        source: script,
+        message,
+        location: addOffset(location, templateLocation.start),
+      });
+    } else {
+      errors.push({
+        source: script,
+        message,
+        location: {
+          start: templateLocation.start,
+          end: templateLocation.end,
+        },
       });
     }
   }
 
+  if (transformedTemplate.result) {
+    partialSpans.push({
+      originalFile: script,
+      originalStart: templateLocation.start,
+      originalLength: templateLocation.end - templateLocation.start,
+      insertionPoint: templateLocation.start,
+      transformedSource: transformedTemplate.result.code,
+      glimmerAstMapping: transformedTemplate.result.mapping,
+    });
+  }
+
   return { errors, directives, partialSpans };
 }
 
@@ -191,9 +222,6 @@ function resolveTagInfo(
   return { importedBinding, tagConfig };
 }
 
-type ImportedBinding = { specifier: string; source: string; synthetic: boolean };
-type ImportedBindings = Record<string, ImportedBinding>;
-
 function collectImportedBindings(ts: TSLib, sourceFile: ts.SourceFile): ImportedBindings {
   let result: ImportedBindings = {};
   for (let statement of sourceFile.statements) {
diff --git a/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts b/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts
new file mode 100644
index 000000000..4cc06486c
--- /dev/null
+++ b/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts
@@ -0,0 +1,273 @@
+import { toTree, VisitorPath } from 'ember-estree';
+import * as path from 'node:path';
+import { GlintEnvironment } from '../../config/index.js';
+import type { PreprocessData } from '../../environment-ember-template-imports/-private/environment/common.js';
+import {
+  EmbeddedTemplate,
+  ImportedBindings,
+  PartialCorrelatedSpan,
+  TemplateThisBinding,
+  ThisBindingAncestor,
+  thisBindingFromAncestors,
+} from './inlining/index.js';
+import { calculateTemplateSpans } from './inlining/tagged-strings.js';
+import {
+  buildTransformedModule,
+  parseError,
+  RewriteInput,
+  toTransformError,
+} from './rewrite-module.js';
+import TransformedModule, { Directive, TransformError } from './transformed-module.js';
+
+/**
+ * What the transform needs to know about a script beyond its text: which
+ * names it imports, and where each `<template>` sits. `rewriteModule` reads
+ * this off the TypeScript AST; this entry reads it off ember-estree's.
+ */
+type ScriptAnalysis = {
+  /** oxc's diagnostics for the script; see `rewriteModuleStandalone`. */
+  errors: Array<ScriptError>;
+  imports: ImportedBindings;
+  /**
+   * Keyed by the offset of each template's `<template>` tag. A template with
+   * no entry is emitted as a context-bound expression (`{{this}}` is the
+   * template context) with no `export default`.
+   */
+  placements: Map<number, TemplatePlacement>;
+};
+
+type ScriptError = { message: string; labels?: Array<{ start: number; end: number }> };
+
+type TemplatePlacement = {
+  thisBinding: TemplateThisBinding;
+  /**
+   * Whether the template is the whole of an expression statement: the RFC 931
+   * implicit `export default` form.
+   */
+  isExpressionStatement: boolean;
+};
+
+/**
+ * Like `rewriteModule`, but without a TypeScript compiler API.
+ *
+ * The script is analyzed with ember-estree (content-tag + oxc-parser), so
+ * embedders that pair the transform with a compiler that has no JS API
+ * (TypeScript 7, build plugins, content mappers) do not need a second
+ * TypeScript install just to run the transform. The output is identical to
+ * `rewriteModule`'s for the same input.
+ *
+ * oxc does not recover from script syntax errors the way TypeScript's parser
+ * does. When it reports any, this entry does what `rewriteModule` does when
+ * content-tag fails to parse the file: the raw source is kept as the
+ * transformed text with verification disabled, the error is recorded on
+ * `errors`, and the type-checker's own (recovering) parser powers completions
+ * in the script until it parses again. Templates in such a file are not
+ * checked until then, exactly as on the content-tag path.
+ *
+ * Exposed only as `@glint/ember-tsc/transform/standalone` so that the
+ * language server, tsserver plugin and `ember-tsc` never load ember-estree
+ * (and oxc-parser's native binary).
+ */
+export function rewriteModuleStandalone(
+  { script }: RewriteInput,
+  environment: GlintEnvironment,
+): TransformedModule | null {
+  let { filename, contents } = script;
+  let { preprocess } = environment.getConfigForExtension(path.extname(filename)) ?? {};
+
+  if (!preprocess) {
+    return null;
+  }
+
+  let errors: Array<TransformError> = [];
+  let directives: Array<Directive> = [];
+  let partialSpans: Array<PartialCorrelatedSpan> = [];
+
+  let data: PreprocessData;
+  try {
+    data = preprocess(contents, filename).data;
+  } catch (e) {
+    errors.push(toTransformError(parseError(e, filename), script));
+    return buildTransformedModule(script, { errors, directives, partialSpans });
+  }
+
+  if (!data.templateLocations.length) {
+    return null;
+  }
+
+  let {
+    errors: scriptErrors,
+    imports,
+    placements,
+  } = analyzeScript(blankTemplateBodies(contents, data), filename);
+
+  if (scriptErrors.length) {
+    let [{ message, labels }] = scriptErrors;
+    let start = Math.min(labels?.[0]?.start ?? 0, Math.max(0, contents.length - 1));
+    errors.push({
+      // Recorded as a content-tag error because that is the flag the
+      // consumers key on to keep the raw source and disable verification;
+      // see `TransformedModule#toVolarMappings`.
+      isContentTagError: true,
+      message,
+      source: script,
+      location: { start, end: Math.min(start + 1, contents.length) },
+    });
+    return buildTransformedModule(script, { errors, directives, partialSpans });
+  }
+
+  for (let location of data.templateLocations) {
+    let start = location.startTagOffset;
+    let end = location.endTagOffset + location.endTagLength;
+    let contentStart = location.startTagOffset + location.startTagLength;
+    let contentEnd = location.endTagOffset;
+    let placement = placements.get(start);
+
+    let embedded: EmbeddedTemplate = {
+      template: contents.slice(contentStart, contentEnd),
+      templateLocation: { start, end, contentStart, contentEnd },
+      thisBinding: placement?.thisBinding ?? 'context',
+    };
+
+    if (location.type === 'class-member') {
+      // The class's own template. `rewriteModule` rewrites the preprocessed
+      // `;[___T`...`]` member into a static block and emits the template
+      // inside it; see `isETITemplateProperty` in the environment transform.
+      embedded.thisBinding = 'backing-class';
+      embedded.prepend = 'static { ';
+      embedded.append = ' }';
+    } else if (placement?.isExpressionStatement) {
+      // A template that is the whole of an expression statement is the
+      // implicit default export (RFC 931); see `isETIDefaultTemplate` and
+      // `isETIDefaultSatisfiesTemplate` in the environment transform.
+      embedded.prepend = 'export default ';
+    }
+
+    let result = calculateTemplateSpans(embedded, imports, script, environment);
+    errors.push(...result.errors);
+    directives.push(...result.directives);
+    partialSpans.push(...result.partialSpans);
+  }
+
+  return buildTransformedModule(script, { errors, directives, partialSpans });
+}
+
+type Node = { type: string; start?: number; end?: number };
+
+type ImportDeclaration = Node & {
+  source: { value: string };
+  specifiers: Array<
+    Node & { local: { name: string }; imported?: { name?: string; value?: string } }
+  >;
+};
+
+type ClassNode = Node & { superClass?: Node | null; implements?: Array<Node> };
+
+// ember-estree splices a `GlimmerTemplate` in place of the whole expression
+// statement when the two span the same range, so the template's parent is
+// then the statement list itself rather than the `ExpressionStatement`.
+const STATEMENT_LISTS = new Set(['Program', 'BlockStatement', 'StaticBlock', 'SwitchCase']);
+
+/**
+ * Replaces the body of every `<template>` with spaces of the same length.
+ * Only the script is analyzed here; the templates are parsed by
+ * `calculateTemplateSpans`, which also reports their errors. Blanking them
+ * keeps every offset the same, spares ember-estree a second handlebars parse
+ * of each one, and means a template that does not parse cannot abort the
+ * script analysis.
+ */
+function blankTemplateBodies(contents: string, data: PreprocessData): string {
+  let out = '';
+  let cursor = 0;
+  for (let location of data.templateLocations) {
+    let contentStart = location.startTagOffset + location.startTagLength;
+    let contentEnd = location.endTagOffset;
+    out += contents.slice(cursor, contentStart);
+    out += contents.slice(contentStart, contentEnd).replace(/[^\n]/g, ' ');
+    cursor = contentEnd;
+  }
+  return out + contents.slice(cursor);
+}
+
+/**
+ * Reads import bindings and the syntactic placement of every template off
+ * ember-estree's traversal of the module. See `rewriteModuleStandalone` for
+ * what happens when the script does not parse.
+ */
+function analyzeScript(contents: string, filename: string): ScriptAnalysis {
+  let imports: ImportedBindings = {};
+  let placements = new Map<number, TemplatePlacement>();
+  let errors: Array<ScriptError> = [];
+
+  let file = toTree(contents, {
+    filePath: filename,
+    visitors: {
+      ImportDeclaration(node) {
+        collectImportedBindings(node as ImportDeclaration, imports);
+      },
+      GlimmerTemplate(node, path) {
+        placements.set(node.start as number, {
+          thisBinding: thisBindingFromAncestors(ancestorsOf(path)),
+          isExpressionStatement: isExpressionStatement(path),
+        });
+      },
+    },
+  });
+
+  if ('errors' in file) errors = file.errors as Array<ScriptError>;
+
+  return { errors, imports, placements };
+}
+
+function* ancestorsOf(path: VisitorPath): Generator<ThisBindingAncestor> {
+  for (
+    let child = path, parent = path.parentPath;
+    parent;
+    child = parent, parent = parent.parentPath
+  ) {
+    let node = parent.node;
+    switch (node.type) {
+      case 'StaticBlock':
+        yield 'static-block';
+        break;
+      case 'ClassDeclaration':
+      case 'ClassExpression': {
+        let { superClass, implements: implemented } = node as ClassNode;
+        if (superClass === child.node || implemented?.includes(child.node)) yield 'heritage-clause';
+        break;
+      }
+      case 'ClassBody':
+        yield 'class';
+        break;
+    }
+  }
+}
+
+function isExpressionStatement(path: VisitorPath): boolean {
+  let parent = path.parent;
+  if (parent?.type === 'TSSatisfiesExpression') {
+    return path.parentPath?.parent?.type === 'ExpressionStatement';
+  }
+  return (
+    parent !== null && (parent.type === 'ExpressionStatement' || STATEMENT_LISTS.has(parent.type))
+  );
+}
+
+function collectImportedBindings(statement: ImportDeclaration, result: ImportedBindings): void {
+  let { source, specifiers } = statement;
+  for (let specifier of specifiers) {
+    if (specifier.type === 'ImportDefaultSpecifier') {
+      result[specifier.local.name] = {
+        specifier: 'default',
+        source: source.value,
+        synthetic: false,
+      };
+    } else if (specifier.type === 'ImportSpecifier' && specifier.imported) {
+      result[specifier.local.name] = {
+        specifier: specifier.imported.name ?? specifier.imported.value ?? specifier.local.name,
+        source: source.value,
+        synthetic: false,
+      };
+    }
+  }
+}
diff --git a/packages/ember-tsc/src/transform/template/rewrite-module.ts b/packages/ember-tsc/src/transform/template/rewrite-module.ts
index 23c6a323a..fe54ba90d 100644
--- a/packages/ember-tsc/src/transform/template/rewrite-module.ts
+++ b/packages/ember-tsc/src/transform/template/rewrite-module.ts
@@ -42,6 +42,17 @@ export function rewriteModule(
     clientId,
   );
 
+  return buildTransformedModule(script, { errors, directives, partialSpans });
+}
+
+/**
+ * Assembles the final `TransformedModule` from the spans and errors collected
+ * for a script. Shared by `rewriteModule` and `rewriteModuleStandalone`.
+ */
+export function buildTransformedModule(
+  script: SourceFile,
+  { errors, directives, partialSpans }: CorrelatedSpansResult,
+): TransformedModule | null {
   if (!partialSpans.length && !errors.length) {
     return null;
   }
@@ -90,58 +101,7 @@ function calculateCorrelatedSpans(
   let { ast, emitMetadata, error } = parseScript(ts, script, environment);
 
   if (error) {
-    if (typeof error === 'string') {
-      errors.push({
-        message: error,
-        location: { start: 0, end: script.contents.length - 1 },
-        source: script,
-      });
-    } else if ('isContentTagError' in error && error.isContentTagError) {
-      // Translate content-tag's 1-based (line, column) into an absolute
-      // offset in the original source. We use the line/column verbatim
-      // (rather than shifting back a line) so the diagnostic lands exactly
-      // where content-tag's own snippet points — including for cases like
-      // `Unexpected eof` where the report sits at the end of a broken
-      // closing tag. The previous implementation summed the first
-      // `error.line` lines' lengths *without* their newlines, which by
-      // coincidence landed on the line above for some inputs and pointed
-      // at a blank line (or past EOF) for others (e.g. a `.gts` ending in
-      // `</templat\n`, which would render an empty source snippet).
-      let lines = script.contents.split('\n');
-      let lineIdx = Math.max(0, Math.min(error.line - 1, lines.length - 1));
-      let lineStart = 0;
-      for (let i = 0; i < lineIdx; i++) {
-        lineStart += lines[i].length + 1; // +1 for the consumed `\n`
-      }
-      let lineLength = lines[lineIdx]?.length ?? 0;
-      // Clamp the column to the last *character* of the line, not the
-      // newline that follows it. Otherwise a 1-char-wide diagnostic at
-      // (line N, col past EOL) would span across the `\n` into line N+1
-      // and TS would render two source-snippet lines (the second one
-      // empty) instead of just the offending one.
-      let col = lineLength === 0 ? 0 : Math.max(0, Math.min(error.column - 1, lineLength - 1));
-      let start = lineStart + col;
-      let end = Math.min(start + 1, script.contents.length);
-
-      errors.push({
-        isContentTagError: true,
-        // Use only `error.message` here. `error.help` is content-tag's pretty-
-        // printed source snippet with its own (1-based, post-error-line) line
-        // numbers, which conflict with the line/column the surrounding
-        // diagnostic surface (tsc, tsserver, LSP) reports for `location`.
-        // Including both produced output like
-        //   src/Foo.gts(6,11): error TS0: Unexpected token ...
-        //
-        //    7 │ }
-        // where the two line numbers disagree and confuse readers.
-        message: error.message,
-        source: script,
-        location: {
-          start,
-          end,
-        },
-      });
-    }
+    errors.push(toTransformError(error, script));
 
     // We've hit a parsing error, so we need to immediately return as the parsed
     // document must be correct before we can continue.
@@ -176,7 +136,7 @@ function calculateCorrelatedSpans(
   return { errors, directives, partialSpans };
 }
 
-type ParseError =
+export type ParseError =
   | string
   | {
       isContentTagError: true;
@@ -194,6 +154,66 @@ type ParseResult = {
   error?: ParseError;
 };
 
+/**
+ * Translates the error thrown by an environment's `preprocess` step (for the
+ * built-in environment: content-tag) into a `TransformError` positioned in the
+ * original source.
+ */
+export function toTransformError(error: ParseError, script: SourceFile): TransformError {
+  if (typeof error === 'string') {
+    return {
+      message: error,
+      location: { start: 0, end: script.contents.length - 1 },
+      source: script,
+    };
+  }
+
+  // Translate content-tag's 1-based (line, column) into an absolute
+  // offset in the original source. We use the line/column verbatim
+  // (rather than shifting back a line) so the diagnostic lands exactly
+  // where content-tag's own snippet points — including for cases like
+  // `Unexpected eof` where the report sits at the end of a broken
+  // closing tag. The previous implementation summed the first
+  // `error.line` lines' lengths *without* their newlines, which by
+  // coincidence landed on the line above for some inputs and pointed
+  // at a blank line (or past EOF) for others (e.g. a `.gts` ending in
+  // `</templat\n`, which would render an empty source snippet).
+  let lines = script.contents.split('\n');
+  let lineIdx = Math.max(0, Math.min(error.line - 1, lines.length - 1));
+  let lineStart = 0;
+  for (let i = 0; i < lineIdx; i++) {
+    lineStart += lines[i].length + 1; // +1 for the consumed `\n`
+  }
+  let lineLength = lines[lineIdx]?.length ?? 0;
+  // Clamp the column to the last *character* of the line, not the
+  // newline that follows it. Otherwise a 1-char-wide diagnostic at
+  // (line N, col past EOL) would span across the `\n` into line N+1
+  // and TS would render two source-snippet lines (the second one
+  // empty) instead of just the offending one.
+  let col = lineLength === 0 ? 0 : Math.max(0, Math.min(error.column - 1, lineLength - 1));
+  let start = lineStart + col;
+  let end = Math.min(start + 1, script.contents.length);
+
+  return {
+    isContentTagError: true,
+    // Use only `error.message` here. `error.help` is content-tag's pretty-
+    // printed source snippet with its own (1-based, post-error-line) line
+    // numbers, which conflict with the line/column the surrounding
+    // diagnostic surface (tsc, tsserver, LSP) reports for `location`.
+    // Including both produced output like
+    //   src/Foo.gts(6,11): error TS0: Unexpected token ...
+    //
+    //    7 │ }
+    // where the two line numbers disagree and confuse readers.
+    message: error.message,
+    source: script,
+    location: {
+      start,
+      end,
+    },
+  };
+}
+
 function parseScript(ts: TSLib, script: SourceFile, environment: GlintEnvironment): ParseResult {
   let { filename, contents } = script;
   let extension = path.extname(filename);
@@ -244,7 +264,7 @@ function parseScript(ts: TSLib, script: SourceFile, environment: GlintEnvironmen
   return { ast, emitMetadata, error };
 }
 
-function parseError(e: unknown, filename: string): ParseError {
+export function parseError(e: unknown, filename: string): ParseError {
   if (typeof e === 'object' && e !== null) {
     // Parse Errors from the rust parser
     if ('source_code' in e) {
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 41fd0b827..cdc6c8e4f 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -116,6 +116,9 @@ importers:
       content-tag:
         specifier: ^4.2.0
         version: 4.2.0
+      ember-estree:
+        specifier: ^0.8.0
+        version: 0.8.0
       silent-error:
         specifier: ^1.1.1
         version: 1.1.1
@@ -1749,6 +1752,15 @@ packages:
       '@embroider/core': ^4.2.4
       vite: '>= 5.2.0'
 
+  '@emnapi/core@1.10.0':
+    resolution: {integrity: sha512-yq6OkJ4p82CAfPl0u9mQebQHKPJkY7WrIuk205cTYnYe+k2Z8YBh11FrbRG/H6ihirqcacOgl2BIO8oyMQLeXw==}
+
+  '@emnapi/runtime@1.10.0':
+    resolution: {integrity: sha512-ewvYlk86xUoGI0zQRNq/mC+16R1QeDlKQy21Ki3oSYXNgLb45GV1P6A0M+/s6nyCuNDqe5VpaY84BzXGwVbwFA==}
+
+  '@emnapi/wasi-threads@1.2.1':
+    resolution: {integrity: sha512-uTII7OYF+/Mes/MrcIOYp5yOtSMLBWSIoLPpcgwipoiKbli6k322tcoFsxoIIxPDqW01SQGAgko4EzZi2BNv2w==}
+
   '@esbuild/aix-ppc64@0.24.2':
     resolution: {integrity: sha512-thpVCb/rhxE/BnMLQ7GReQLLN8q9qbHmI55F4489/ByVg2aQaQ6kbcLb6FHkocZzQhxc4gx0sCk0tJkKBFzDhA==}
     engines: {node: '>=18'}
@@ -2405,6 +2417,13 @@ packages:
     resolution: {integrity: sha512-3lBouSuF7CqlseLB+FKES0K4FQ02JrbEoRtJhxnsyB1s5v4AP03gsoohN8jp7DcOImhaR9scYdztq3/sLfk/qQ==}
     engines: {node: '>=14.18.0'}
 
+  '@napi-rs/wasm-runtime@1.2.3':
+    resolution: {integrity: sha512-UMduMbqO5s5zF2NkNacMT/yK5Y5QiKvWr2+50bzIIxFDwVJ2h49b+oyjaCGPhJxd2/gC2x39EHv/gHVuu36x2Q==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=23.5.0}
+    peerDependencies:
+      '@emnapi/core': ^1.7.1 || ^2.0.0-alpha.4
+      '@emnapi/runtime': ^1.7.1 || ^2.0.0-alpha.4
+
   '@nicolo-ribaudo/eslint-scope-5-internals@5.1.1-v1':
     resolution: {integrity: sha512-54/JRvkLIzzDWshCWfuhadfrfZVPiElY8Fcgmg1HroEly/EDSszzhBAsarCux+D/kOslTRquNzuyGSmUSTTHGg==}
 
@@ -2492,6 +2511,128 @@ packages:
   '@octokit/types@13.10.0':
     resolution: {integrity: sha512-ifLaO34EbbPj0Xgro4G5lP5asESjwHracYJvVaPIyXMuiuXLlhic3S47cBdTb+jfODkTE5YtGCLt3Ay3+J97sA==}
 
+  '@oxc-parser/binding-android-arm-eabi@0.130.0':
+    resolution: {integrity: sha512-h/xYU8/7ADWzVSf5I+YalLpj33LOy9CI/zgbJNIZ5eunRBG+Czqa3lZsvuPHHf3rOt6z1c5+UzoxjbAzAvhwVw==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm]
+    os: [android]
+
+  '@oxc-parser/binding-android-arm64@0.130.0':
+    resolution: {integrity: sha512-oFWFJrsGv9siFM4HjMqKNB7IuIZD/SMmZdCXl8xyx7lDplGvPKyewpOo272rSWgMXe2Wx7bWI0Yj+gkHv4qbeg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [android]
+
+  '@oxc-parser/binding-darwin-arm64@0.130.0':
+    resolution: {integrity: sha512-sGUzupdTplK9jQg7eJZ878HfEgQjJNBc6dAYVWJ9W5aU+J8rLfRJhTVsKThiu1pNwm6Y1qKCcbC6WhNWSXR3Ig==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@oxc-parser/binding-darwin-x64@0.130.0':
+    resolution: {integrity: sha512-PsB4cdCISbC00Uy8eiD8bc2AkGWjZqrSrJnkBFuG2ptrrf6mZ2F5gLFSjOAVMMgZPg8B1D7OydJwLWSfyI2Plg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [darwin]
+
+  '@oxc-parser/binding-freebsd-x64@0.130.0':
+    resolution: {integrity: sha512-DgABp3l38hS77JbXCV4qk1+n6DPym5u8zzwuweokezm2tX194nDSJDENbDRECxVsiNbprKATLbk+Z5wlHT0OHw==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@oxc-parser/binding-linux-arm-gnueabihf@0.130.0':
+    resolution: {integrity: sha512-4Kn3CTEmwFrzhTSC/JuUW16qovmaMdX7jeSKbL8w0pLtLww7To1a2XJi9Z5uD8QWUkfUHhqfV+VD6dVzBnWzoA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm]
+    os: [linux]
+
+  '@oxc-parser/binding-linux-arm-musleabihf@0.130.0':
+    resolution: {integrity: sha512-D35KZM3F4rRu1uAFKyBlg3Gaf/ybCjyaPR1hfgvk5ex8NtcTmRgc0JgSighEyNg96TPrFhemFba68SZuxaha8w==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm]
+    os: [linux]
+
+  '@oxc-parser/binding-linux-arm64-gnu@0.130.0':
+    resolution: {integrity: sha512-Q9o7oVlo955KHwS8l1u0bCzIx+JsZUA3XToLXC+MsMhye/9LeBQbt84nh120cl2XLy+TEzvugYDiHShg5yaX6Q==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [linux]
+
+  '@oxc-parser/binding-linux-arm64-musl@0.130.0':
+    resolution: {integrity: sha512-EiJ/gC0ljbcwVpycC8YWw6ggMbtsPX8XMOt0mPx0aqWeMsNR+L9m05Flbvd5T+GlivG+GkSWQL7tM9SRFpM/dw==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [linux]
+
+  '@oxc-parser/binding-linux-ppc64-gnu@0.130.0':
+    resolution: {integrity: sha512-b+h/lsLLurp756dMGizNs5uPaJfyEdWrTcV5t8M609jWm1DEHB1StpRXCkyvwtkJx3m+qL5BNQ0dEKan/4yGFA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@oxc-parser/binding-linux-riscv64-gnu@0.130.0':
+    resolution: {integrity: sha512-O19Cil83XAyjEFfo8WhkMwY58ALqZ7ckjGL+25mjMIuF84urWBeANH0FC8B8BsSSygWU3/1aY3ADdDbp+wlBnw==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@oxc-parser/binding-linux-riscv64-musl@0.130.0':
+    resolution: {integrity: sha512-BgXRVC0+83n3YzCscLQjj6nbyeBIVeZYPTI4fFMAE4WNm2+4RXhWp03IVizL7esIz36kgmT48aebk1iM+cs8sw==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@oxc-parser/binding-linux-s390x-gnu@0.130.0':
+    resolution: {integrity: sha512-6tJz0xvnGhsokE7N1WlUSBXibpYmT9xSJFS1Ce41Km/+8gQvdlW8MLhRv8PD0L7ix8vRG0FDDepp3jdOFzdVdw==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [s390x]
+    os: [linux]
+
+  '@oxc-parser/binding-linux-x64-gnu@0.130.0':
+    resolution: {integrity: sha512-9aCWj83dp3heTQGmGnZGdIWgxjZrr/7VQ0TGFHH5PKByxJKF2Hcr4qvaSUHhhGEa3MSsDjTL1YDP8RAgdL5/Cg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [linux]
+
+  '@oxc-parser/binding-linux-x64-musl@0.130.0':
+    resolution: {integrity: sha512-afXt87aZBqrUVli8TB/I8H1G50RDWcwirjWtXGXYqJ2ZqWEiErH7V72j3LUSDZaivmtu2OLX0KQ/mbhP81mr7A==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [linux]
+
+  '@oxc-parser/binding-openharmony-arm64@0.130.0':
+    resolution: {integrity: sha512-I0NCrZV/YZuCGWgqwNN/GO/iXlLF2z+Wgc7u+Aa9N4P51oYeIa0XT+zVBUne4csO9GqxskXgI4g8JzzWGRpfOw==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [openharmony]
+
+  '@oxc-parser/binding-wasm32-wasi@0.130.0':
+    resolution: {integrity: sha512-sJgQkGaBX0WJvPUDfwciex6IcTk5O5NLQ1bhEb6f3nBruh1GshKMRSMt2bxZlYrgBzjyBbJzsnO+InPG0bg+fA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [wasm32]
+
+  '@oxc-parser/binding-win32-arm64-msvc@0.130.0':
+    resolution: {integrity: sha512-bjcma99sQrNh6RY4mPO9yTkfxql6TDFoN3HWdK31RCKXwNhcDgJXW/l8PUtzKNiQ+9vpKJfJtQq+LklBuxSOBA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [win32]
+
+  '@oxc-parser/binding-win32-ia32-msvc@0.130.0':
+    resolution: {integrity: sha512-hRYbv6HhpSTzT4xTiIkadLI7upLQxuOdLPR/9nL1fTjwhgutBTPXrwaAPb/jTFVx6/8C7Jb5HcUKhmNwloTbFA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [ia32]
+    os: [win32]
+
+  '@oxc-parser/binding-win32-x64-msvc@0.130.0':
+    resolution: {integrity: sha512-RBpA9TsRucJq6HNVNCFF1iKg+QeTkLdZf7hi4xaOGCPvMZWvDHjQgSOEZMUpuW4JNciHbxNhLEYmz5CVygjVGQ==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [win32]
+
+  '@oxc-project/types@0.130.0':
+    resolution: {integrity: sha512-ibD2usx9JRu7f5pu2tMKMI4cpA4NgXJQoYRP4pQ7Pxmn1l6k/53qWtQWZayhYy3X4QZkt90Ot+mJEaeXouio6Q==}
+
   '@pkgjs/parseargs@0.11.0':
     resolution: {integrity: sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==}
     engines: {node: '>=14'}
@@ -2758,6 +2899,9 @@ packages:
     resolution: {integrity: sha512-0B44GyEafxJLAZSixH9VBnm9kDFCpaLXu86httaJSDEm1nfl3WWI/XfY4diPsOyOg+pc9N1/YfqH7uKM2dF0lA==}
     deprecated: Please use @ember/app-tsconfig or @ember/library-tsconfig instead. These live at https://github.com/ember-cli/tsconfigs
 
+  '@tybys/wasm-util@0.10.3':
+    resolution: {integrity: sha512-F3fo1MYrRJYL3zER0OUOmkutjr1Vp23m7OsSgp7nq4SP6OqX6C/56XFIPAl5bt3zaBRjmW7SGz3u/6LwFpYcOg==}
+
   '@types/babel__code-frame@7.0.6':
     resolution: {integrity: sha512-Anitqkl3+KrzcW2k77lRlg/GfLZLWXBuNgbEcIOU6M92yw42vsd3xV/Z/yAHEj8m+KUjL6bWOVOFqX8PFPJ4LA==}
 
@@ -4384,6 +4528,9 @@ packages:
       '@typescript-eslint/parser':
         optional: true
 
+  ember-estree@0.8.0:
+    resolution: {integrity: sha512-FvH2jGEkcIMPDPgQLHFVSTyF5p7HscVIiJ36v6ce1C9q/6KXCcE0EB2idaGcDWlhB42I3PmLg+vLbUp2GIznBQ==}
+
   ember-modifier@4.2.0:
     resolution: {integrity: sha512-BJ48eTEGxD8J7+lofwVmee7xDgNDgpr5dd6+MSu4gk+I6xb35099RMNorXY5hjjwMJEyi/IRR6Yn3M7iJMz8Zw==}
     peerDependencies:
@@ -6504,6 +6651,10 @@ packages:
     resolution: {integrity: sha512-qFOyK5PjiWZd+QQIh+1jhdb9LpxTF0qs7Pm8o5QHYZ0M3vKqSqzsZaEB6oWlxZ+q2sJBMI/Ktgd2N5ZwQoRHfg==}
     engines: {node: '>= 0.4'}
 
+  oxc-parser@0.130.0:
+    resolution: {integrity: sha512-X0PJ+NmOok8qP3vK9uaW431ngkdM9UPEK7KG466urtIL2+EYTEgbZK2yqe2MWKJKBjRlFweP/pJPx0x9muMEVw==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+
   p-defer@1.0.0:
     resolution: {integrity: sha512-wB3wfAxZpk2AzOfUMJNL+d36xothRSyj8EXOa4f6GMqYDN9BJaaSISbsk+wS9abmnebVw95C2Kb5t85UmpCxuw==}
     engines: {node: '>=4'}
@@ -10277,6 +10428,22 @@ snapshots:
       - supports-color
       - utf-8-validate
 
+  '@emnapi/core@1.10.0':
+    dependencies:
+      '@emnapi/wasi-threads': 1.2.1
+      tslib: 2.8.1
+    optional: true
+
+  '@emnapi/runtime@1.10.0':
+    dependencies:
+      tslib: 2.8.1
+    optional: true
+
+  '@emnapi/wasi-threads@1.2.1':
+    dependencies:
+      tslib: 2.8.1
+    optional: true
+
   '@esbuild/aix-ppc64@0.24.2':
     optional: true
 
@@ -11117,6 +11284,13 @@ snapshots:
       jju: 1.4.0
       js-yaml: 4.1.1
 
+  '@napi-rs/wasm-runtime@1.2.3(8738cc0ffd7f5348356f0f10f02ca7f5)':
+    dependencies:
+      '@emnapi/core': 1.10.0
+      '@emnapi/runtime': 1.10.0
+      '@tybys/wasm-util': 0.10.3
+    optional: true
+
   '@nicolo-ribaudo/eslint-scope-5-internals@5.1.1-v1':
     dependencies:
       eslint-scope: 5.1.1
@@ -11230,6 +11404,72 @@ snapshots:
     dependencies:
       '@octokit/openapi-types': 24.2.0
 
+  '@oxc-parser/binding-android-arm-eabi@0.130.0':
+    optional: true
+
+  '@oxc-parser/binding-android-arm64@0.130.0':
+    optional: true
+
+  '@oxc-parser/binding-darwin-arm64@0.130.0':
+    optional: true
+
+  '@oxc-parser/binding-darwin-x64@0.130.0':
+    optional: true
+
+  '@oxc-parser/binding-freebsd-x64@0.130.0':
+    optional: true
+
+  '@oxc-parser/binding-linux-arm-gnueabihf@0.130.0':
+    optional: true
+
+  '@oxc-parser/binding-linux-arm-musleabihf@0.130.0':
+    optional: true
+
+  '@oxc-parser/binding-linux-arm64-gnu@0.130.0':
+    optional: true
+
+  '@oxc-parser/binding-linux-arm64-musl@0.130.0':
+    optional: true
+
+  '@oxc-parser/binding-linux-ppc64-gnu@0.130.0':
+    optional: true
+
+  '@oxc-parser/binding-linux-riscv64-gnu@0.130.0':
+    optional: true
+
+  '@oxc-parser/binding-linux-riscv64-musl@0.130.0':
+    optional: true
+
+  '@oxc-parser/binding-linux-s390x-gnu@0.130.0':
+    optional: true
+
+  '@oxc-parser/binding-linux-x64-gnu@0.130.0':
+    optional: true
+
+  '@oxc-parser/binding-linux-x64-musl@0.130.0':
+    optional: true
+
+  '@oxc-parser/binding-openharmony-arm64@0.130.0':
+    optional: true
+
+  '@oxc-parser/binding-wasm32-wasi@0.130.0':
+    dependencies:
+      '@emnapi/core': 1.10.0
+      '@emnapi/runtime': 1.10.0
+      '@napi-rs/wasm-runtime': 1.2.3(8738cc0ffd7f5348356f0f10f02ca7f5)
+    optional: true
+
+  '@oxc-parser/binding-win32-arm64-msvc@0.130.0':
+    optional: true
+
+  '@oxc-parser/binding-win32-ia32-msvc@0.130.0':
+    optional: true
+
+  '@oxc-parser/binding-win32-x64-msvc@0.130.0':
+    optional: true
+
+  '@oxc-project/types@0.130.0': {}
+
   '@pkgjs/parseargs@0.11.0':
     optional: true
 
@@ -11469,6 +11709,11 @@ snapshots:
 
   '@tsconfig/ember@3.0.9': {}
 
+  '@tybys/wasm-util@0.10.3':
+    dependencies:
+      tslib: 2.8.1
+    optional: true
+
   '@types/babel__code-frame@7.0.6': {}
 
   '@types/body-parser@1.19.6':
@@ -13647,6 +13892,13 @@ snapshots:
       - eslint
       - typescript
 
+  ember-estree@0.8.0:
+    dependencies:
+      '@glimmer/env': 0.1.7
+      '@glimmer/syntax': 0.95.0
+      content-tag: 4.2.0
+      oxc-parser: 0.130.0
+
   ember-modifier@4.2.0(23852ec33942378a099928ec3a8cfa5f):
     dependencies:
       '@embroider/addon-shim': 1.9.0
@@ -16638,6 +16890,31 @@ snapshots:
       object-keys: 1.1.1
       safe-push-apply: 1.0.0
 
+  oxc-parser@0.130.0:
+    dependencies:
+      '@oxc-project/types': 0.130.0
+    optionalDependencies:
+      '@oxc-parser/binding-android-arm-eabi': 0.130.0
+      '@oxc-parser/binding-android-arm64': 0.130.0
+      '@oxc-parser/binding-darwin-arm64': 0.130.0
+      '@oxc-parser/binding-darwin-x64': 0.130.0
+      '@oxc-parser/binding-freebsd-x64': 0.130.0
+      '@oxc-parser/binding-linux-arm-gnueabihf': 0.130.0
+      '@oxc-parser/binding-linux-arm-musleabihf': 0.130.0
+      '@oxc-parser/binding-linux-arm64-gnu': 0.130.0
+      '@oxc-parser/binding-linux-arm64-musl': 0.130.0
+      '@oxc-parser/binding-linux-ppc64-gnu': 0.130.0
+      '@oxc-parser/binding-linux-riscv64-gnu': 0.130.0
+      '@oxc-parser/binding-linux-riscv64-musl': 0.130.0
+      '@oxc-parser/binding-linux-s390x-gnu': 0.130.0
+      '@oxc-parser/binding-linux-x64-gnu': 0.130.0
+      '@oxc-parser/binding-linux-x64-musl': 0.130.0
+      '@oxc-parser/binding-openharmony-arm64': 0.130.0
+      '@oxc-parser/binding-wasm32-wasi': 0.130.0
+      '@oxc-parser/binding-win32-arm64-msvc': 0.130.0
+      '@oxc-parser/binding-win32-ia32-msvc': 0.130.0
+      '@oxc-parser/binding-win32-x64-msvc': 0.130.0
+
   p-defer@1.0.0: {}
 
   p-finally@1.0.0: {}
diff --git a/test-packages/package-test-core/__tests__/transform/rewrite-standalone.test.ts b/test-packages/package-test-core/__tests__/transform/rewrite-standalone.test.ts
new file mode 100644
index 000000000..fe7ef4a15
--- /dev/null
+++ b/test-packages/package-test-core/__tests__/transform/rewrite-standalone.test.ts
@@ -0,0 +1,279 @@
+import { GlintEnvironment } from '@glint/ember-tsc/config/index';
+import { rewriteModule } from '@glint/ember-tsc/transform/index';
+import { rewriteModuleStandalone } from '@glint/ember-tsc/transform/standalone';
+import { stripIndent } from 'common-tags';
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { join, relative, resolve } from 'node:path';
+import ts from 'typescript';
+import { describe, expect, test } from 'vitest';
+
+const env = GlintEnvironment.load({});
+
+// `rewriteModuleStandalone` must produce exactly what `rewriteModule` does
+// for the same input; the only difference is how the script is analyzed.
+function expectParity(filename: string, contents: string): void {
+  let script = { filename, contents };
+  let viaTypescript = rewriteModule(ts, { script }, env);
+  let standalone = rewriteModuleStandalone({ script }, env);
+
+  if (!viaTypescript || !standalone) {
+    expect(standalone).toEqual(viaTypescript);
+    return;
+  }
+
+  expect(standalone.transformedContents).toEqual(viaTypescript.transformedContents);
+  expect(standalone.errors).toEqual(viaTypescript.errors);
+  expect(standalone.directives.map(describeDirective)).toEqual(
+    viaTypescript.directives.map(describeDirective),
+  );
+  expect(standalone.toDebugString()).toEqual(viaTypescript.toDebugString());
+}
+
+function describeDirective(directive: {
+  kind: string;
+  location: unknown;
+  areaOfEffect: unknown;
+}): unknown {
+  return {
+    kind: directive.kind,
+    location: directive.location,
+    areaOfEffect: directive.areaOfEffect,
+  };
+}
+
+function collectTemplateFiles(dir: string, out: Array<string>): Array<string> {
+  for (const name of readdirSync(dir)) {
+    if (name === 'node_modules' || name.startsWith('.')) continue;
+    const path = join(dir, name);
+    if (statSync(path).isDirectory()) {
+      collectTemplateFiles(path, out);
+    } else if (/\.g[jt]s$/.test(name)) {
+      out.push(path);
+    }
+  }
+  return out;
+}
+
+describe('Transform: rewriteModuleStandalone', () => {
+  describe('matches rewriteModule on the test-packages corpus', () => {
+    const root = resolve(__dirname, '..', '..', '..');
+    const files = collectTemplateFiles(root, []).sort();
+
+    expect(files.length).toBeGreaterThan(50);
+
+    for (const file of files) {
+      test(relative(root, file), () => {
+        expectParity(file, readFileSync(file, 'utf8'));
+      });
+    }
+  });
+
+  describe('template placement', () => {
+    test('class member, class field, nested class and arrow field', () => {
+      expectParity(
+        'test.gts',
+        stripIndent`
+          import Component from '@glimmer/component';
+
+          export default class Outer extends Component {
+            field = <template>{{this.field}}</template>;
+            arrow = () => <template>{{this.arrow}}</template>;
+            method() {
+              class Inner extends Component {
+                <template>{{this.inner}}</template>
+              }
+              return <template>{{this.method}}</template>;
+            }
+            <template><this.field /></template>
+          }
+        `,
+      );
+    });
+
+    test('static block and heritage clause', () => {
+      expectParity(
+        'test.gts',
+        stripIndent`
+          import Component from '@glimmer/component';
+
+          const mixin = (base: typeof Component, template: unknown): typeof Component => base;
+
+          export class WithStatic extends Component {
+            static {
+              const x = <template>{{this.static}}</template>;
+              x;
+            }
+          }
+
+          export class WithHeritage extends mixin(Component, <template>{{this.heritage}}</template>) {
+            <template>{{this.own}}</template>
+          }
+        `,
+      );
+    });
+
+    test('class headers with braces in type arguments and decorators', () => {
+      expectParity(
+        'test.gts',
+        stripIndent`
+          import Component from '@glimmer/component';
+
+          function dec(_opts: { a: number }) {
+            return (target: unknown) => target;
+          }
+
+          @dec({ a: 1 })
+          export default class Generic<T extends { id: string } = { id: string }> extends Component<{
+            Args: { items: Array<T> };
+          }> {
+            key = 'class';
+            <template>{{@items.length}}</template>
+          }
+
+          const record = { class: 'x', kind: 'class' };
+          record.class;
+        `,
+      );
+    });
+
+    test('implicit default export, satisfies, and operand positions', () => {
+      expectParity(
+        'test.gts',
+        stripIndent`
+          import type { TOC } from '@ember/component/template-only';
+
+          const A = <template>a</template>;
+          const list = [<template>b</template>, <template>c</template>];
+          const fn = () => <template>d</template>;
+          fn(<template>e</template>);
+          export const S = <template>f</template> satisfies TOC<{}>;
+
+          <template>{{A}}{{list}}</template> satisfies TOC<{}>;
+        `,
+      );
+    });
+
+    test('templates after statements that rely on automatic semicolon insertion', () => {
+      expectParity(
+        'test.gts',
+        stripIndent`
+          const x = 1
+          const y = x
+          <template>{{x}}</template>
+        `,
+      );
+    });
+
+    test('strings, comments, regexes and template literals containing confusing tokens', () => {
+      expectParity(
+        'test.gts',
+        stripIndent`
+          import Component from '@glimmer/component';
+
+          const s = "class { <template>";
+          const t = 'import { on } from "@ember/modifier"';
+          const r = /class\\s+{/g;
+          const tl = \`\${'class'} { \${(() => { return 1; })()} } \\\` \`;
+          // class {
+          /* import { on } from '@ember/modifier' */
+
+          export default class Real extends Component {
+            <template>{{on}} {{s}} {{t}} {{r}} {{tl}}</template>
+          }
+        `,
+      );
+    });
+
+    test('gjs uses JSDoc emit', () => {
+      expectParity(
+        'test.gjs',
+        stripIndent`
+          import Component from '@glimmer/component';
+
+          export default class Foo extends Component {
+            <template>{{@bar}}</template>
+          }
+
+          <template>{{this}}</template>
+        `,
+      );
+    });
+  });
+
+  describe('parse errors', () => {
+    test('content-tag parse error', () => {
+      expectParity(
+        'test.gts',
+        stripIndent`
+          import Component from '@glimmer/component';
+
+          export default class Broken extends Component {
+            <template>
+              <div></div>
+            </template
+          }
+        `,
+      );
+    });
+
+    test('handlebars parse error', () => {
+      expectParity(
+        'test.gts',
+        stripIndent`
+          export default <template>
+            {{#if}}
+          </template>;
+        `,
+      );
+    });
+
+    test('script syntax error keeps the raw source, like a content-tag error', () => {
+      // oxc yields an empty program on an unrecoverable script error where
+      // TypeScript's parser keeps going, so the standalone entry cannot know
+      // where the templates sit. It falls back the way `rewriteModule` does
+      // when content-tag fails: raw source, verification off, the error on
+      // `errors`, and the type-checker's own parser recovers from there.
+      let script = {
+        filename: 'test.gts',
+        contents: stripIndent`
+          import { fn } from '@ember/helper';
+          let planets = []);
+          export default class Demo {
+            <template>{{fn this.remove}}</template>
+          }
+        `,
+      };
+
+      let standalone = rewriteModuleStandalone({ script }, env);
+
+      expect(standalone?.transformedContents).toEqual(script.contents);
+      expect(standalone?.errors.map((e) => [e.isContentTagError, e.message])).toEqual([
+        [true, 'Expected a semicolon or an implicit semicolon after a statement, but found none'],
+      ]);
+      expect(standalone?.toVolarMappings().every((m) => m.data.verification === false)).toBe(true);
+    });
+
+    test('no templates', () => {
+      expectParity('test.gts', `export const x = 1;\n`);
+      expectParity('test.ts', `export const x = 1;\n`);
+    });
+  });
+
+  describe('imports', () => {
+    test('imported bindings shadow globals and resolve special forms', () => {
+      expectParity(
+        'test.gts',
+        stripIndent`
+          import { on } from '@ember/modifier';
+          import { hash as h, array } from '@ember/helper';
+          import type { TOC } from '@ember/component/template-only';
+          import Component, { type Foo } from '@glimmer/component';
+
+          <template>
+            <button {{on "click" this.go}}>{{h a=1}} {{array 1 2}}</button>
+          </template>
+        `,
+      );
+    });
+  });
+});
diff --git a/test-packages/package-test-core/__tests__/transform/rewrite.test.ts b/test-packages/package-test-core/__tests__/transform/rewrite.test.ts
index 7ed1a8aa7..1ce57e375 100644
--- a/test-packages/package-test-core/__tests__/transform/rewrite.test.ts
+++ b/test-packages/package-test-core/__tests__/transform/rewrite.test.ts
@@ -83,6 +83,39 @@ describe('Transform: rewriteModule', () => {
     // contextual typing — `typeTest(context, <template>...)` from
     // `@glint/type-test` types `{{this}}` as the given context. Emitting the
     // module's lexical `this` (type `undefined`) instead broke that. (#1186)
+    // A field initializer with no trailing semicolon is followed directly by
+    // the class's template. The preprocessed `[___T`...`]` member must not be
+    // read as an element access on that initializer (`value[___T`...`]`),
+    // which emitted the class's own template as a context-bound expression.
+    test('with a class member template after a field without a semicolon', () => {
+      let script = {
+        filename: 'test.gts',
+        contents: stripIndent`
+          import Component from '@glimmer/component';
+          export default class MyComponent extends Component {
+            isChecked = (value: unknown) => this.args.value === value
+
+            <template>{{this.isChecked 1}}</template>
+          }
+        `,
+      };
+
+      let transformedModule = rewriteModule(ts, { script }, env);
+
+      expect(transformedModule?.errors).toEqual([]);
+      expect(transformedModule?.transformedContents).toMatchInlineSnapshot(`
+        "import Component from '@glimmer/component';
+        export default class MyComponent extends Component {
+          isChecked = (value: unknown) => this.args.value === value
+
+          static { ({} as typeof import("@glint/ember-tsc/-private/dsl")).templateForBackingValue(this, function(__glintRef__, __glintDSL__: typeof import("@glint/ember-tsc/-private/dsl")) {
+        __glintDSL__.emitContent(__glintDSL__.resolve(__glintRef__.this.isChecked)(1));
+        __glintRef__; __glintDSL__;
+        }) }
+        }"
+      `);
+    });
+
     test('with a module-scope expression template referencing {{this}}', () => {
       let script = {
         filename: 'test.gts',
diff --git a/test-packages/package-test-core/__tests__/transform/template-tag-transformation.test.ts b/test-packages/package-test-core/__tests__/transform/template-tag-transformation.test.ts
index 544b756b5..5c2c7e80b 100644
--- a/test-packages/package-test-core/__tests__/transform/template-tag-transformation.test.ts
+++ b/test-packages/package-test-core/__tests__/transform/template-tag-transformation.test.ts
@@ -30,6 +30,7 @@ describe('Environment: ETI', () => {
       expect(result.data).toEqual({
         templateLocations: [
           {
+            type: 'expression',
             startTagOffset: source.indexOf('<template>'),
             startTagLength: '<template>'.length,
             endTagOffset: source.indexOf('</template>'),
@@ -53,6 +54,7 @@ describe('Environment: ETI', () => {
       expect(result.data).toEqual({
         templateLocations: [
           {
+            type: 'expression',
             startTagOffset: source.indexOf('<template>'),
             startTagLength: '<template>'.length,
             endTagOffset: source.indexOf('</template>'),
@@ -129,14 +131,14 @@ describe('Environment: ETI', () => {
       `;
 
       // The top-level template is an expression (bare); the one in the class
-      // body is a class member (wrapped in `[ ]` as a computed-property name).
+      // body is a class member (wrapped in `[ ]` as a computed-property name, preceded by an empty `;` element).
       let transformed = stripIndent`
         ___T\`
           <Foo />
         \`
 
         class Foo {
-          [___T\`Hello\`]
+          ;[___T\`Hello\`]
         }
       `;
 
@@ -149,6 +151,7 @@ describe('Environment: ETI', () => {
       expect(result.data).toEqual({
         templateLocations: [
           {
+            type: 'expression',
             startTagOffset: source.indexOf('<template>'),
             startTagLength: '<template>'.length,
             endTagOffset: source.indexOf('</template>'),
@@ -156,6 +159,7 @@ describe('Environment: ETI', () => {
             ...tagSpan(transformed),
           },
           {
+            type: 'class-member',
             startTagOffset: source.indexOf('<template>', sourceClassOffset),
             startTagLength: '<template>'.length,
             endTagOffset: source.indexOf('</template>', sourceClassOffset),
@@ -186,6 +190,7 @@ describe('Environment: ETI', () => {
       expect(result.data).toEqual({
         templateLocations: [
           {
+            type: 'expression',
             startTagOffset: source.indexOf('<template>'),
             startTagLength: '<template>'.length,
             endTagOffset: source.indexOf('</template>'),
@@ -193,6 +198,7 @@ describe('Environment: ETI', () => {
             ...tagSpan(transformed),
           },
           {
+            type: 'expression',
             startTagOffset: source.lastIndexOf('<template>'),
             startTagLength: '<template>'.length,
             endTagOffset: source.lastIndexOf('</template>'),
@@ -317,7 +323,7 @@ describe('Environment: ETI', () => {
           "class MyClass {
             $foo: string = 'bar';
 
-            [___T\`{{this.$foo}}\`];
+            ;[___T\`{{this.$foo}}\`];
           }"
         `);
       });
@@ -437,12 +443,14 @@ describe('Environment: ETI', () => {
       let classStart = source.indexOf('class');
       let { meta, sourceFile } = applyTransform(source);
       let firstTemplate = (sourceFile.statements[1] as ts.ExpressionStatement).expression;
-      let secondTemplate = (
+      let secondTemplate = // `members[0]` is the empty `;` element preprocess emits ahead of
+        // the template member.
         (
-          (sourceFile.statements[2] as ts.ClassDeclaration)
-            .members[0] as ts.ClassStaticBlockDeclaration
-        ).body.statements[0] as ts.ExpressionStatement
-      ).expression;
+          (
+            (sourceFile.statements[2] as ts.ClassDeclaration)
+              .members[1] as ts.ClassStaticBlockDeclaration
+          ).body.statements[0] as ts.ExpressionStatement
+        ).expression;
 
       let firstStart = source.indexOf('<template>');
       let firstContentStart = firstStart + '<template>'.length;
@@ -537,7 +545,7 @@ describe('Environment: ETI', () => {
       let secondTemplate = (
         (
           (sourceFile.statements[3] as ts.ClassDeclaration)
-            .members[0] as ts.ClassStaticBlockDeclaration
+            .members[1] as ts.ClassStaticBlockDeclaration
         ).body.statements[0] as ts.ExpressionStatement
       ).expression;