From 82ea8835f84277349f72a3484ede699c2ab7b425 Mon Sep 17 00:00:00 2001
From: NullVoxPopuli-ai-agent
 <268630448+NullVoxPopuli-ai-agent@users.noreply.github.com>
Date: Mon, 24 Aug 2026 11:45:12 -0400
Subject: [PATCH 01/13] Add rewriteModuleStandalone, a TypeScript-free entry to
 the transform

`rewriteModule` parses the content-tag-preprocessed script with the
`TSLib` it is given and reads template placement, `this` binding and
import bindings off the AST. Embedders that pair the transform with a
compiler that has no JS API (TypeScript 7) had to carry a second
TypeScript install just for that parse.

`rewriteModuleStandalone(input, environment)` derives the same
information from content-tag's parse output (template ranges and the
class-member flag) plus a small scanner over the script that tracks
strings, comments, template literals, regexes and bracket nesting to
find import declarations, class bodies, static blocks and statement
starts. The template emit itself is shared: `calculateTemplateSpans`
now takes a plain `EmbeddedTemplate` and `calculateTaggedTemplateSpans`
is a thin adapter over the TS node.

`rewriteModule` keeps its signature and behaviour for every current
caller. A parity test runs both entry points over every .gts/.gjs in
test-packages and over targeted edge cases and asserts identical
output, errors, directives and span mappings.

Two preprocess fixes surfaced by that parity check, both of which also
affect `rewriteModule`:

- content-tag reports a class's own template before a template that
  appears earlier in its heritage clause; sort the parse output so the
  splice happens in source order.
- A class member template after a field initializer with no trailing
  semicolon became `value[___T`...`]`, an element access, so the class's
  own template was emitted as a context-bound expression. Emit `;[...]`
  (a `;` is an empty class element) so it always parses as a member.

Fixes #1224

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FsXgxh6vNRWMCNcAQ3g6TN
---
 .../-private/environment/common.ts            |   2 +
 .../-private/environment/preprocess.ts        |  15 +-
 packages/ember-tsc/src/index.ts               |   2 +
 packages/ember-tsc/src/transform/index.ts     |   1 +
 .../src/transform/template/inlining/index.ts  |  22 +
 .../template/inlining/script-scanner.ts       | 488 ++++++++++++++++++
 .../template/inlining/tagged-strings.ts       | 254 +++++----
 .../template/rewrite-module-standalone.ts     | 113 ++++
 .../src/transform/template/rewrite-module.ts  | 128 +++--
 .../transform/rewrite-standalone.test.ts      | 326 ++++++++++++
 .../__tests__/transform/rewrite.test.ts       |  33 ++
 .../template-tag-transformation.test.ts       |  20 +-
 12 files changed, 1232 insertions(+), 172 deletions(-)
 create mode 100644 packages/ember-tsc/src/transform/template/inlining/script-scanner.ts
 create mode 100644 packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts
 create mode 100644 test-packages/package-test-core/__tests__/transform/rewrite-standalone.test.ts

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/index.ts b/packages/ember-tsc/src/index.ts
index 7fd8dcee1..b4f50602b 100644
--- a/packages/ember-tsc/src/index.ts
+++ b/packages/ember-tsc/src/index.ts
@@ -4,6 +4,7 @@ import { createEmberLanguagePlugin } from './volar/ember-language-plugin.js';
 import { VirtualGtsCode } from './volar/gts-virtual-code.js';
 import { augmentDiagnostics } from './transform/diagnostics/augmentation.js';
 import { getTransformErrorDiagnostics } from './transform/diagnostics/transform-errors.js';
+import { rewriteModuleStandalone } from './transform/template/rewrite-module-standalone.js';
 
 export {
   loadConfig,
@@ -13,6 +14,7 @@ export {
   VirtualGtsCode,
   augmentDiagnostics,
   getTransformErrorDiagnostics,
+  rewriteModuleStandalone,
 };
 
 export type { GlintConfig };
diff --git a/packages/ember-tsc/src/transform/index.ts b/packages/ember-tsc/src/transform/index.ts
index 3577bf97d..d655e70cb 100644
--- a/packages/ember-tsc/src/transform/index.ts
+++ b/packages/ember-tsc/src/transform/index.ts
@@ -2,3 +2,4 @@ export type { Directive, default as TransformedModule } from './template/transfo
 export type { Diagnostic } from './diagnostics/index.js';
 
 export { rewriteModule } from './template/rewrite-module.js';
+export { rewriteModuleStandalone } from './template/rewrite-module-standalone.js';
diff --git a/packages/ember-tsc/src/transform/template/inlining/index.ts b/packages/ember-tsc/src/transform/template/inlining/index.ts
index 0f09206c2..0f3b75048 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:
diff --git a/packages/ember-tsc/src/transform/template/inlining/script-scanner.ts b/packages/ember-tsc/src/transform/template/inlining/script-scanner.ts
new file mode 100644
index 000000000..7764c5752
--- /dev/null
+++ b/packages/ember-tsc/src/transform/template/inlining/script-scanner.ts
@@ -0,0 +1,488 @@
+import { ImportedBindings, TemplateThisBinding } from './index.js';
+
+/**
+ * What the transform needs to know about the position of one embedded
+ * template within its script.
+ */
+export type TemplateContext = {
+  /** How `{{this}}` binds at this position; see {@link TemplateThisBinding}. */
+  thisBinding: TemplateThisBinding;
+  /**
+   * Whether the template is the whole of an expression statement (the RFC 931
+   * implicit `export default` form), as opposed to an operand: a variable
+   * initializer, a call argument, an array element, and so on.
+   */
+  isExpressionStatement: boolean;
+};
+
+export type ScanResult = {
+  imports: ImportedBindings;
+  /** One entry per input template range, in the same order. */
+  templates: Array<TemplateContext>;
+};
+
+type Token =
+  | { kind: 'ident'; text: string; newlineBefore: boolean }
+  | { kind: 'string'; text: string; value: string; newlineBefore: boolean }
+  | { kind: 'number' | 'template' | 'regex' | 'embedded'; newlineBefore: boolean }
+  | { kind: 'punct'; text: string; newlineBefore: boolean };
+
+/**
+ * The context introduced by each still-open `{`. `class-header` is the span
+ * between the `class` keyword and its body's `{`; it holds the depth of any
+ * type-argument brackets so a `{` inside `class A<T = {}>` is not mistaken
+ * for the body.
+ */
+type Context =
+  | { kind: 'other' | 'class-body' | 'static-block' }
+  | { kind: 'class-header'; angleDepth: number };
+
+// Keywords after which a `/` starts a regular expression and after which a
+// template is an operand rather than the start of a new statement.
+const EXPRESSION_KEYWORDS = new Set([
+  'as',
+  'await',
+  'case',
+  'default',
+  'delete',
+  'export',
+  'extends',
+  'implements',
+  'in',
+  'instanceof',
+  'new',
+  'of',
+  'satisfies',
+  'throw',
+  'typeof',
+  'void',
+  'yield',
+]);
+
+// Keywords that directly precede a statement body.
+const STATEMENT_KEYWORDS = new Set(['do', 'else']);
+
+const PUNCTUATORS = [
+  '>>>=',
+  '...',
+  '===',
+  '!==',
+  '**=',
+  '<<=',
+  '>>=',
+  '>>>',
+  '&&=',
+  '||=',
+  '??=',
+  '=>',
+  '==',
+  '!=',
+  '<=',
+  '>=',
+  '&&',
+  '||',
+  '??',
+  '?.',
+  '++',
+  '--',
+  '+=',
+  '-=',
+  '*=',
+  '/=',
+  '%=',
+  '&=',
+  '|=',
+  '^=',
+  '**',
+  '<<',
+  '>>',
+];
+
+/**
+ * Scans a .gts/.gjs script, treating each of the given `<template>` ranges as
+ * a single opaque token, and reports the import bindings it declares along
+ * with the syntactic context of every template.
+ *
+ * This is a tokenizer, not a parser: it tracks strings, comments, template
+ * literals, regular expressions and bracket nesting so that it can tell
+ * where class bodies, static blocks and statements begin, which is all the
+ * template transform needs. See `rewriteModuleStandalone`.
+ */
+export function scanScript(
+  contents: string,
+  templateRanges: ReadonlyArray<{ start: number; end: number }>,
+): ScanResult {
+  let scanner = new Scanner(contents, templateRanges);
+  scanner.run();
+  return { imports: scanner.imports, templates: scanner.templates };
+}
+
+class Scanner {
+  imports: ImportedBindings = {};
+  templates: Array<TemplateContext> = [];
+
+  private pos = 0;
+  private previous: Token | undefined;
+  private newlineBefore = false;
+  private contexts: Array<Context> = [];
+  private nextTemplate = 0;
+  // Tokens of an import declaration currently being read, up to its
+  // module specifier.
+  private pendingImport: Array<Token> | undefined;
+
+  constructor(
+    private contents: string,
+    private templateRanges: ReadonlyArray<{ start: number; end: number }>,
+  ) {}
+
+  run(): void {
+    while (this.pos < this.contents.length) {
+      this.step();
+    }
+  }
+
+  // Consumes one token (or one run of whitespace / one comment).
+  private step(): void {
+    let { contents } = this;
+    let template = this.templateRanges[this.nextTemplate];
+    if (template && this.pos >= template.start) {
+      this.templates.push({
+        thisBinding: this.thisBindingHere(),
+        isExpressionStatement: this.startsStatement(),
+      });
+      this.nextTemplate++;
+      this.pos = Math.max(template.end, this.pos + 1);
+      this.emit({ kind: 'embedded', newlineBefore: this.newlineBefore });
+      return;
+    }
+
+    let ch = contents[this.pos];
+    let next = contents[this.pos + 1];
+
+    if (ch === '\n' || ch === '\r' || ch === '\u2028' || ch === '\u2029') {
+      this.newlineBefore = true;
+      this.pos++;
+    } else if (/\s/.test(ch)) {
+      this.pos++;
+    } else if (ch === '/' && next === '/') {
+      let end = contents.indexOf('\n', this.pos);
+      this.pos = end === -1 ? contents.length : end;
+    } else if (ch === '/' && next === '*') {
+      let end = contents.indexOf('*/', this.pos + 2);
+      let stop = end === -1 ? contents.length : end + 2;
+      if (/[\n\r\u2028\u2029]/.test(contents.slice(this.pos, stop))) this.newlineBefore = true;
+      this.pos = stop;
+    } else if (ch === '"' || ch === "'") {
+      this.readString(ch);
+    } else if (ch === '`') {
+      this.readTemplateLiteral();
+    } else if (ch === '/' && this.regexAllowed()) {
+      this.readRegex();
+    } else if (isIdentifierStart(ch)) {
+      this.readIdentifier();
+    } else if (isDigit(ch) || (ch === '.' && isDigit(next))) {
+      this.readNumber();
+    } else {
+      this.readPunctuator();
+    }
+  }
+
+  private emit(token: Token): void {
+    this.previous = token;
+    this.newlineBefore = false;
+
+    if (this.pendingImport) {
+      let last = this.pendingImport[this.pendingImport.length - 1];
+      let expectsSource = last === undefined || (last.kind === 'ident' && last.text === 'from');
+      if (token.kind === 'string' && expectsSource) {
+        // `import 'source'` / `... from 'source'`. Any other string is a
+        // string-named binding: `import { "a-b" as ab } from 'source'`.
+        this.recordImport(this.pendingImport, token.value);
+        this.pendingImport = undefined;
+      } else if (token.kind === 'punct' && (token.text === ';' || token.text === '=')) {
+        // `import x = require(...)` / `import x = ns.y` are not import
+        // declarations; a stray `;` means the statement never had a source.
+        this.pendingImport = undefined;
+      } else {
+        this.pendingImport.push(token);
+      }
+    }
+  }
+
+  private readString(quote: string): void {
+    let { contents } = this;
+    let start = this.pos;
+    let i = start + 1;
+    let value = '';
+    while (i < contents.length && contents[i] !== quote) {
+      if (contents[i] === '\\') {
+        value += contents[i + 1] ?? '';
+        i += 2;
+      } else {
+        value += contents[i];
+        i++;
+      }
+    }
+    this.pos = Math.min(i + 1, contents.length);
+    this.emit({
+      kind: 'string',
+      text: contents.slice(start, this.pos),
+      value,
+      newlineBefore: this.newlineBefore,
+    });
+  }
+
+  private readTemplateLiteral(): void {
+    let { contents } = this;
+    let newlineBefore = this.newlineBefore;
+    // Consumes from the opening backtick through the closing one, scanning
+    // each `${ ... }` substitution with the regular tokenizer so the braces
+    // inside it balance.
+    let i = this.pos + 1;
+    while (i < contents.length && contents[i] !== '`') {
+      if (contents[i] === '\\') {
+        i += 2;
+      } else if (contents[i] === '$' && contents[i + 1] === '{') {
+        this.pos = i + 2;
+        this.readSubstitution();
+        i = this.pos;
+      } else {
+        i++;
+      }
+    }
+    this.pos = Math.min(i + 1, contents.length);
+    this.emit({ kind: 'template', newlineBefore });
+  }
+
+  // Tokenizes one `${ ... }` substitution, stopping after its closing `}`.
+  private readSubstitution(): void {
+    let depth = this.contexts.length;
+    this.contexts.push({ kind: 'other' });
+    this.previous = undefined;
+    while (this.pos < this.contents.length && this.contexts.length > depth) {
+      this.step();
+    }
+  }
+
+  private readRegex(): void {
+    let { contents } = this;
+    let i = this.pos + 1;
+    let inClass = false;
+    while (i < contents.length && contents[i] !== '\n') {
+      let c = contents[i];
+      if (c === '\\') {
+        i += 2;
+        continue;
+      }
+      if (c === '[') inClass = true;
+      else if (c === ']') inClass = false;
+      else if (c === '/' && !inClass) break;
+      i++;
+    }
+    i++;
+    while (i < contents.length && isIdentifierPart(contents[i])) i++;
+    this.pos = Math.min(i, contents.length);
+    this.emit({ kind: 'regex', newlineBefore: this.newlineBefore });
+  }
+
+  private regexAllowed(): boolean {
+    let prev = this.previous;
+    if (!prev) return true;
+    switch (prev.kind) {
+      case 'ident':
+        return EXPRESSION_KEYWORDS.has(prev.text) || STATEMENT_KEYWORDS.has(prev.text);
+      case 'punct':
+        // After `)` or `]` a slash divides; after `}` it is far more likely
+        // to start a regex at the beginning of a statement than to divide an
+        // object literal.
+        return prev.text !== ')' && prev.text !== ']';
+      default:
+        return false;
+    }
+  }
+
+  private readIdentifier(): void {
+    let { contents } = this;
+    let start = this.pos;
+    let i = start;
+    while (i < contents.length && isIdentifierPart(contents[i])) i++;
+    this.pos = i;
+    let text = contents.slice(start, i);
+    let afterDot =
+      this.previous?.kind === 'punct' &&
+      (this.previous.text === '.' || this.previous.text === '?.');
+    let startsStatement = this.startsStatement();
+
+    this.emit({ kind: 'ident', text, newlineBefore: this.newlineBefore });
+
+    if (afterDot) return;
+
+    let following = this.peekNonSpace();
+    if (text === 'class' && !(following !== undefined && /[:,)}=.?]/.test(following))) {
+      // A `class` keyword (not a `class:` object key or `.class` access). The
+      // header context becomes the class body at its `{`.
+      this.contexts.push({ kind: 'class-header', angleDepth: 0 });
+    } else if (
+      text === 'import' &&
+      startsStatement &&
+      !this.pendingImport &&
+      following !== '(' &&
+      following !== '.'
+    ) {
+      // An import declaration; its tokens are gathered up to the module
+      // specifier string and interpreted in `recordImport`.
+      this.pendingImport = [];
+    }
+  }
+
+  private peekNonSpace(): string | undefined {
+    let { contents } = this;
+    let i = this.pos;
+    while (i < contents.length && /\s/.test(contents[i])) i++;
+    return contents[i];
+  }
+
+  private readNumber(): void {
+    let { contents } = this;
+    let i = this.pos;
+    while (i < contents.length && (isIdentifierPart(contents[i]) || contents[i] === '.')) i++;
+    this.pos = i;
+    this.emit({ kind: 'number', newlineBefore: this.newlineBefore });
+  }
+
+  private readPunctuator(): void {
+    let { contents } = this;
+    let text = PUNCTUATORS.find((p) => contents.startsWith(p, this.pos)) ?? contents[this.pos];
+    this.pos += text.length;
+    let newlineBefore = this.newlineBefore;
+    let top = this.contexts[this.contexts.length - 1];
+
+    if (text === '{') {
+      if (top?.kind === 'class-header' && top.angleDepth === 0) {
+        this.contexts[this.contexts.length - 1] = { kind: 'class-body' };
+      } else if (
+        top?.kind === 'class-body' &&
+        this.previous?.kind === 'ident' &&
+        this.previous.text === 'static'
+      ) {
+        this.contexts.push({ kind: 'static-block' });
+      } else {
+        this.contexts.push({ kind: 'other' });
+      }
+    } else if (text === '}') {
+      this.contexts.pop();
+    } else if (text === '(' || text === '[') {
+      this.contexts.push({ kind: 'other' });
+    } else if (text === ')' || text === ']') {
+      if (top?.kind === 'other') this.contexts.pop();
+    } else if (top?.kind === 'class-header') {
+      if (text === '<') top.angleDepth++;
+      else if (text === '>') top.angleDepth = Math.max(0, top.angleDepth - 1);
+      else if (text === '>>') top.angleDepth = Math.max(0, top.angleDepth - 2);
+    }
+
+    this.emit({ kind: 'punct', text, newlineBefore });
+  }
+
+  private thisBindingHere(): TemplateThisBinding {
+    // Mirrors `templateThisBinding`, which walks up the TS AST and stops at
+    // the first static block, heritage clause or class it meets.
+    for (let i = this.contexts.length - 1; i >= 0; i--) {
+      let context = this.contexts[i];
+      switch (context.kind) {
+        case 'static-block':
+          return 'backing-class';
+        case 'class-header':
+          return 'context';
+        case 'class-body':
+          return 'lexical';
+      }
+    }
+    return 'context';
+  }
+
+  // Whether a token at the current position begins a statement, accounting
+  // for automatic semicolon insertion after a line break.
+  private startsStatement(): boolean {
+    let prev = this.previous;
+    if (!prev) return true;
+    let { newlineBefore } = this;
+    switch (prev.kind) {
+      case 'punct':
+        if (prev.text === ';' || prev.text === '{' || prev.text === '}') return true;
+        if (prev.text === ')') return true;
+        if (prev.text === ']') return newlineBefore;
+        return false;
+      case 'ident':
+        if (STATEMENT_KEYWORDS.has(prev.text)) return true;
+        if (EXPRESSION_KEYWORDS.has(prev.text)) return false;
+        return newlineBefore;
+      default:
+        return newlineBefore;
+    }
+  }
+
+  private recordImport(tokens: Array<Token>, source: string): void {
+    let i = 0;
+    let at = (index: number): Token | undefined => tokens[index];
+    let isIdent = (token: Token | undefined, text?: string): token is Token & { kind: 'ident' } =>
+      token?.kind === 'ident' && (text === undefined || token.text === text);
+    let isPunct = (token: Token | undefined, text: string): boolean =>
+      token?.kind === 'punct' && token.text === text;
+    let nameOf = (token: Token | undefined): string | undefined =>
+      token?.kind === 'ident' ? token.text : token?.kind === 'string' ? token.value : undefined;
+
+    // `import type X from` / `import type { X } from` — but `import type from`
+    // is a default import named `type`.
+    if (isIdent(at(i), 'type') && at(i + 1) && !isIdent(at(i + 1), 'from')) i++;
+
+    if (isIdent(at(i)) && !isPunct(at(i + 1), '{') && !isIdent(at(i), 'from')) {
+      this.imports[(at(i) as { text: string }).text] = {
+        specifier: 'default',
+        source,
+        synthetic: false,
+      };
+      i++;
+      if (isPunct(at(i), ',')) i++;
+    }
+
+    if (isPunct(at(i), '*')) {
+      // Namespace imports carry no individual bindings.
+      return;
+    }
+
+    if (isPunct(at(i), '{')) {
+      i++;
+      while (i < tokens.length && !isPunct(at(i), '}')) {
+        let entry: Array<Token> = [];
+        while (i < tokens.length && !isPunct(at(i), ',') && !isPunct(at(i), '}')) {
+          entry.push(tokens[i]);
+          i++;
+        }
+        if (isPunct(at(i), ',')) i++;
+
+        let j = 0;
+        // Inline `type` modifier: `{ type X }` / `{ type X as Y }`, but
+        // `{ type }` and `{ type as t }` import a binding named `type`.
+        if (isIdent(entry[j], 'type') && entry[j + 1] && !isIdent(entry[j + 1], 'as')) j++;
+        let specifier = nameOf(entry[j]);
+        if (specifier === undefined) continue;
+        let name = isIdent(entry[j + 1], 'as') ? nameOf(entry[j + 2]) : specifier;
+        if (name === undefined) continue;
+        this.imports[name] = { specifier, source, synthetic: false };
+      }
+    }
+  }
+}
+
+function isIdentifierStart(ch: string | undefined): boolean {
+  return ch !== undefined && /[\p{ID_Start}$_\\]/u.test(ch);
+}
+
+function isIdentifierPart(ch: string | undefined): boolean {
+  return ch !== undefined && /[\p{ID_Continue}$\\]/u.test(ch);
+}
+
+function isDigit(ch: string | undefined): boolean {
+  return ch !== undefined && ch >= '0' && ch <= '9';
+}
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..4187fad03 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,156 @@ 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',
+  );
+
+  // 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,
+  };
+
+  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),
+  };
 
-    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,
+  // 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, 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 +228,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..806bc34bc
--- /dev/null
+++ b/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts
@@ -0,0 +1,113 @@
+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, PartialCorrelatedSpan } from './inlining/index.js';
+import { scanScript } from './inlining/script-scanner.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';
+
+/**
+ * Like `rewriteModule`, but without a TypeScript compiler API.
+ *
+ * `rewriteModule` parses the content-tag-preprocessed script with the
+ * `TSLib` it is given and reads three things off the AST: where each
+ * template sits, how its `{{this}}` binds, and which names the module imports.
+ * Here those come from content-tag's own parse output (template ranges and
+ * whether a template is a class member) and a lightweight scan of the script
+ * (`script-scanner.ts`), 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; the
+ * language server, tsserver plugin and `ember-tsc` keep using `rewriteModule`.
+ */
+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 });
+  }
+
+  let templates = data.templateLocations.map((location) => ({
+    location,
+    // The `<template>` tags themselves, matching `templateLocation` in
+    // `environment-ember-template-imports/-private/environment/transform.ts`.
+    start: location.startTagOffset,
+    end: location.endTagOffset + location.endTagLength,
+    contentStart: location.startTagOffset + location.startTagLength,
+    contentEnd: location.endTagOffset,
+  }));
+
+  let { imports, templates: contexts } = scanScript(contents, templates);
+
+  for (let [index, template] of templates.entries()) {
+    let embedded = toEmbeddedTemplate(template, contexts[index], contents);
+    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 });
+}
+
+function toEmbeddedTemplate(
+  template: {
+    location: PreprocessData['templateLocations'][number];
+    start: number;
+    end: number;
+    contentStart: number;
+    contentEnd: number;
+  },
+  context: ReturnType<typeof scanScript>['templates'][number],
+  contents: string,
+): EmbeddedTemplate {
+  let { start, end, contentStart, contentEnd } = template;
+  let templateLocation = { start, end, contentStart, contentEnd };
+  let text = contents.slice(contentStart, contentEnd);
+
+  if (template.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.
+    return {
+      template: text,
+      templateLocation,
+      thisBinding: 'backing-class',
+      prepend: 'static { ',
+      append: ' }',
+    };
+  }
+
+  return {
+    template: text,
+    templateLocation,
+    thisBinding: context.thisBinding,
+    // 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.
+    prepend: context.isExpressionStatement ? 'export default ' : undefined,
+  };
+}
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/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..08c0da7a5
--- /dev/null
+++ b/test-packages/package-test-core/__tests__/transform/rewrite-standalone.test.ts
@@ -0,0 +1,326 @@
+import { GlintEnvironment } from '@glint/ember-tsc/config/index';
+import { rewriteModule, rewriteModuleStandalone } from '@glint/ember-tsc/transform/index';
+import { scanScript } from '@glint/ember-tsc/transform/template/inlining/script-scanner';
+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('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>
+        `,
+      );
+    });
+  });
+});
+
+describe('Transform: scanScript', () => {
+  function scan(source: string): ReturnType<typeof scanScript> {
+    // `<template>...</template>` ranges are located by hand here; the real
+    // caller gets them from content-tag.
+    let ranges: Array<{ start: number; end: number }> = [];
+    let re = /<template>[\s\S]*?<\/template>/g;
+    let match: RegExpExecArray | null;
+    while ((match = re.exec(source))) {
+      ranges.push({ start: match.index, end: match.index + match[0].length });
+    }
+    return scanScript(source, ranges);
+  }
+
+  test('reads default, named, aliased and type-only import bindings', () => {
+    let { imports } = scan(stripIndent`
+      import Component from '@glimmer/component';
+      import { hash as h, array, type Foo } from '@ember/helper';
+      import type { TOC } from '@ember/component/template-only';
+      import type from './type';
+      import { type } from './type-binding';
+      import * as ns from './ns';
+      import Both, * as both from './both';
+      import './side-effect';
+      import { "string-name" as stringName } from './strings';
+      import json from './data.json' with { type: 'json' };
+      import fs = require('node:fs');
+      const lazy = import('./lazy');
+      const url = import.meta.url;
+      const obj = { import: 1 };
+      obj.import;
+    `);
+
+    expect(imports).toEqual({
+      Component: { specifier: 'default', source: '@glimmer/component', synthetic: false },
+      h: { specifier: 'hash', source: '@ember/helper', synthetic: false },
+      array: { specifier: 'array', source: '@ember/helper', synthetic: false },
+      Foo: { specifier: 'Foo', source: '@ember/helper', synthetic: false },
+      TOC: { specifier: 'TOC', source: '@ember/component/template-only', synthetic: false },
+      type: { specifier: 'type', source: './type-binding', synthetic: false },
+      Both: { specifier: 'default', source: './both', synthetic: false },
+      stringName: { specifier: 'string-name', source: './strings', synthetic: false },
+      json: { specifier: 'default', source: './data.json', synthetic: false },
+    });
+  });
+
+  test('classifies template positions', () => {
+    let { templates } = scan(stripIndent`
+      <template>module</template>
+      const a = <template>operand</template>;
+      class A extends mixin(<template>heritage</template>) {
+        field = <template>lexical</template>;
+        static {
+          <template>static</template>
+        }
+        method() {
+          <template>statement-in-method</template>
+        }
+      }
+      <template>trailing</template>
+    `);
+
+    expect(templates).toEqual([
+      { thisBinding: 'context', isExpressionStatement: true },
+      { thisBinding: 'context', isExpressionStatement: false },
+      { thisBinding: 'context', isExpressionStatement: false },
+      { thisBinding: 'lexical', isExpressionStatement: false },
+      { thisBinding: 'backing-class', isExpressionStatement: true },
+      { thisBinding: 'lexical', isExpressionStatement: true },
+      { thisBinding: 'context', isExpressionStatement: true },
+    ]);
+  });
+});
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..a64e7406e 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,10 +443,12 @@ 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
+            .members[1] as ts.ClassStaticBlockDeclaration
         ).body.statements[0] as ts.ExpressionStatement
       ).expression;
 
@@ -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;
 

From 02edf119ded7c8691fced0c91ca380a93a43ddda Mon Sep 17 00:00:00 2001
From: NullVoxPopuli-ai-agent
 <268630448+NullVoxPopuli-ai-agent@users.noreply.github.com>
Date: Mon, 24 Aug 2026 11:47:15 -0400
Subject: [PATCH 02/13] Format template-tag-transformation test

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FsXgxh6vNRWMCNcAQ3g6TN
---
 .../transform/template-tag-transformation.test.ts    | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

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 a64e7406e..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
@@ -444,13 +444,13 @@ describe('Environment: ETI', () => {
       let { meta, sourceFile } = applyTransform(source);
       let firstTemplate = (sourceFile.statements[1] as ts.ExpressionStatement).expression;
       let secondTemplate = // `members[0]` is the empty `;` element preprocess emits ahead of
-      // the template member.
-      (
+        // the template member.
         (
-          (sourceFile.statements[2] as ts.ClassDeclaration)
-            .members[1] 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;

From 1ce660093f23c10a4dbc8189ba06af128bbd6e6b Mon Sep 17 00:00:00 2001
From: NullVoxPopuli-ai-agent
 <268630448+NullVoxPopuli-ai-agent@users.noreply.github.com>
Date: Mon, 24 Aug 2026 19:24:31 -0400
Subject: [PATCH 03/13] Derive the standalone analysis from ember-estree
 instead of a scanner

ember-estree (content-tag + oxc-parser) gives a real ESTree for the
file. Walking its outer tree, with an ancestor stack, before templates
are spliced in reproduces `templateThisBinding` and
`collectImportedBindings` directly, so the hand-written tokenizer goes.

Known divergence: oxc yields an empty program on an unrecoverable
script syntax error, where TypeScript's parser keeps going. Such a file
is emitted without import bindings or placement (bare identifiers still
resolve lexically); the checker reports the syntax error either way.

Two parity cases depend on ember-estree fixes (NullVoxPopuli/ember-estree#77
and #78) and are marked `test.fails` until those ship.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FsXgxh6vNRWMCNcAQ3g6TN
---
 packages/ember-tsc/package.json               |   1 +
 packages/ember-tsc/src/index.ts               |   2 -
 .../template/inlining/script-scanner.ts       | 488 ------------------
 .../template/rewrite-module-standalone.ts     | 237 +++++++--
 pnpm-lock.yaml                                | 277 ++++++++++
 .../transform/rewrite-standalone.test.ts      | 110 ++--
 6 files changed, 495 insertions(+), 620 deletions(-)
 delete mode 100644 packages/ember-tsc/src/transform/template/inlining/script-scanner.ts

diff --git a/packages/ember-tsc/package.json b/packages/ember-tsc/package.json
index 4f8c5f799..37943a524 100644
--- a/packages/ember-tsc/package.json
+++ b/packages/ember-tsc/package.json
@@ -87,6 +87,7 @@
     "@volar/test-utils": "~2.4.28",
     "@volar/typescript": "~2.4.28",
     "content-tag": "^4.2.0",
+    "ember-estree": "^0.7.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/index.ts b/packages/ember-tsc/src/index.ts
index b4f50602b..7fd8dcee1 100644
--- a/packages/ember-tsc/src/index.ts
+++ b/packages/ember-tsc/src/index.ts
@@ -4,7 +4,6 @@ import { createEmberLanguagePlugin } from './volar/ember-language-plugin.js';
 import { VirtualGtsCode } from './volar/gts-virtual-code.js';
 import { augmentDiagnostics } from './transform/diagnostics/augmentation.js';
 import { getTransformErrorDiagnostics } from './transform/diagnostics/transform-errors.js';
-import { rewriteModuleStandalone } from './transform/template/rewrite-module-standalone.js';
 
 export {
   loadConfig,
@@ -14,7 +13,6 @@ export {
   VirtualGtsCode,
   augmentDiagnostics,
   getTransformErrorDiagnostics,
-  rewriteModuleStandalone,
 };
 
 export type { GlintConfig };
diff --git a/packages/ember-tsc/src/transform/template/inlining/script-scanner.ts b/packages/ember-tsc/src/transform/template/inlining/script-scanner.ts
deleted file mode 100644
index 7764c5752..000000000
--- a/packages/ember-tsc/src/transform/template/inlining/script-scanner.ts
+++ /dev/null
@@ -1,488 +0,0 @@
-import { ImportedBindings, TemplateThisBinding } from './index.js';
-
-/**
- * What the transform needs to know about the position of one embedded
- * template within its script.
- */
-export type TemplateContext = {
-  /** How `{{this}}` binds at this position; see {@link TemplateThisBinding}. */
-  thisBinding: TemplateThisBinding;
-  /**
-   * Whether the template is the whole of an expression statement (the RFC 931
-   * implicit `export default` form), as opposed to an operand: a variable
-   * initializer, a call argument, an array element, and so on.
-   */
-  isExpressionStatement: boolean;
-};
-
-export type ScanResult = {
-  imports: ImportedBindings;
-  /** One entry per input template range, in the same order. */
-  templates: Array<TemplateContext>;
-};
-
-type Token =
-  | { kind: 'ident'; text: string; newlineBefore: boolean }
-  | { kind: 'string'; text: string; value: string; newlineBefore: boolean }
-  | { kind: 'number' | 'template' | 'regex' | 'embedded'; newlineBefore: boolean }
-  | { kind: 'punct'; text: string; newlineBefore: boolean };
-
-/**
- * The context introduced by each still-open `{`. `class-header` is the span
- * between the `class` keyword and its body's `{`; it holds the depth of any
- * type-argument brackets so a `{` inside `class A<T = {}>` is not mistaken
- * for the body.
- */
-type Context =
-  | { kind: 'other' | 'class-body' | 'static-block' }
-  | { kind: 'class-header'; angleDepth: number };
-
-// Keywords after which a `/` starts a regular expression and after which a
-// template is an operand rather than the start of a new statement.
-const EXPRESSION_KEYWORDS = new Set([
-  'as',
-  'await',
-  'case',
-  'default',
-  'delete',
-  'export',
-  'extends',
-  'implements',
-  'in',
-  'instanceof',
-  'new',
-  'of',
-  'satisfies',
-  'throw',
-  'typeof',
-  'void',
-  'yield',
-]);
-
-// Keywords that directly precede a statement body.
-const STATEMENT_KEYWORDS = new Set(['do', 'else']);
-
-const PUNCTUATORS = [
-  '>>>=',
-  '...',
-  '===',
-  '!==',
-  '**=',
-  '<<=',
-  '>>=',
-  '>>>',
-  '&&=',
-  '||=',
-  '??=',
-  '=>',
-  '==',
-  '!=',
-  '<=',
-  '>=',
-  '&&',
-  '||',
-  '??',
-  '?.',
-  '++',
-  '--',
-  '+=',
-  '-=',
-  '*=',
-  '/=',
-  '%=',
-  '&=',
-  '|=',
-  '^=',
-  '**',
-  '<<',
-  '>>',
-];
-
-/**
- * Scans a .gts/.gjs script, treating each of the given `<template>` ranges as
- * a single opaque token, and reports the import bindings it declares along
- * with the syntactic context of every template.
- *
- * This is a tokenizer, not a parser: it tracks strings, comments, template
- * literals, regular expressions and bracket nesting so that it can tell
- * where class bodies, static blocks and statements begin, which is all the
- * template transform needs. See `rewriteModuleStandalone`.
- */
-export function scanScript(
-  contents: string,
-  templateRanges: ReadonlyArray<{ start: number; end: number }>,
-): ScanResult {
-  let scanner = new Scanner(contents, templateRanges);
-  scanner.run();
-  return { imports: scanner.imports, templates: scanner.templates };
-}
-
-class Scanner {
-  imports: ImportedBindings = {};
-  templates: Array<TemplateContext> = [];
-
-  private pos = 0;
-  private previous: Token | undefined;
-  private newlineBefore = false;
-  private contexts: Array<Context> = [];
-  private nextTemplate = 0;
-  // Tokens of an import declaration currently being read, up to its
-  // module specifier.
-  private pendingImport: Array<Token> | undefined;
-
-  constructor(
-    private contents: string,
-    private templateRanges: ReadonlyArray<{ start: number; end: number }>,
-  ) {}
-
-  run(): void {
-    while (this.pos < this.contents.length) {
-      this.step();
-    }
-  }
-
-  // Consumes one token (or one run of whitespace / one comment).
-  private step(): void {
-    let { contents } = this;
-    let template = this.templateRanges[this.nextTemplate];
-    if (template && this.pos >= template.start) {
-      this.templates.push({
-        thisBinding: this.thisBindingHere(),
-        isExpressionStatement: this.startsStatement(),
-      });
-      this.nextTemplate++;
-      this.pos = Math.max(template.end, this.pos + 1);
-      this.emit({ kind: 'embedded', newlineBefore: this.newlineBefore });
-      return;
-    }
-
-    let ch = contents[this.pos];
-    let next = contents[this.pos + 1];
-
-    if (ch === '\n' || ch === '\r' || ch === '\u2028' || ch === '\u2029') {
-      this.newlineBefore = true;
-      this.pos++;
-    } else if (/\s/.test(ch)) {
-      this.pos++;
-    } else if (ch === '/' && next === '/') {
-      let end = contents.indexOf('\n', this.pos);
-      this.pos = end === -1 ? contents.length : end;
-    } else if (ch === '/' && next === '*') {
-      let end = contents.indexOf('*/', this.pos + 2);
-      let stop = end === -1 ? contents.length : end + 2;
-      if (/[\n\r\u2028\u2029]/.test(contents.slice(this.pos, stop))) this.newlineBefore = true;
-      this.pos = stop;
-    } else if (ch === '"' || ch === "'") {
-      this.readString(ch);
-    } else if (ch === '`') {
-      this.readTemplateLiteral();
-    } else if (ch === '/' && this.regexAllowed()) {
-      this.readRegex();
-    } else if (isIdentifierStart(ch)) {
-      this.readIdentifier();
-    } else if (isDigit(ch) || (ch === '.' && isDigit(next))) {
-      this.readNumber();
-    } else {
-      this.readPunctuator();
-    }
-  }
-
-  private emit(token: Token): void {
-    this.previous = token;
-    this.newlineBefore = false;
-
-    if (this.pendingImport) {
-      let last = this.pendingImport[this.pendingImport.length - 1];
-      let expectsSource = last === undefined || (last.kind === 'ident' && last.text === 'from');
-      if (token.kind === 'string' && expectsSource) {
-        // `import 'source'` / `... from 'source'`. Any other string is a
-        // string-named binding: `import { "a-b" as ab } from 'source'`.
-        this.recordImport(this.pendingImport, token.value);
-        this.pendingImport = undefined;
-      } else if (token.kind === 'punct' && (token.text === ';' || token.text === '=')) {
-        // `import x = require(...)` / `import x = ns.y` are not import
-        // declarations; a stray `;` means the statement never had a source.
-        this.pendingImport = undefined;
-      } else {
-        this.pendingImport.push(token);
-      }
-    }
-  }
-
-  private readString(quote: string): void {
-    let { contents } = this;
-    let start = this.pos;
-    let i = start + 1;
-    let value = '';
-    while (i < contents.length && contents[i] !== quote) {
-      if (contents[i] === '\\') {
-        value += contents[i + 1] ?? '';
-        i += 2;
-      } else {
-        value += contents[i];
-        i++;
-      }
-    }
-    this.pos = Math.min(i + 1, contents.length);
-    this.emit({
-      kind: 'string',
-      text: contents.slice(start, this.pos),
-      value,
-      newlineBefore: this.newlineBefore,
-    });
-  }
-
-  private readTemplateLiteral(): void {
-    let { contents } = this;
-    let newlineBefore = this.newlineBefore;
-    // Consumes from the opening backtick through the closing one, scanning
-    // each `${ ... }` substitution with the regular tokenizer so the braces
-    // inside it balance.
-    let i = this.pos + 1;
-    while (i < contents.length && contents[i] !== '`') {
-      if (contents[i] === '\\') {
-        i += 2;
-      } else if (contents[i] === '$' && contents[i + 1] === '{') {
-        this.pos = i + 2;
-        this.readSubstitution();
-        i = this.pos;
-      } else {
-        i++;
-      }
-    }
-    this.pos = Math.min(i + 1, contents.length);
-    this.emit({ kind: 'template', newlineBefore });
-  }
-
-  // Tokenizes one `${ ... }` substitution, stopping after its closing `}`.
-  private readSubstitution(): void {
-    let depth = this.contexts.length;
-    this.contexts.push({ kind: 'other' });
-    this.previous = undefined;
-    while (this.pos < this.contents.length && this.contexts.length > depth) {
-      this.step();
-    }
-  }
-
-  private readRegex(): void {
-    let { contents } = this;
-    let i = this.pos + 1;
-    let inClass = false;
-    while (i < contents.length && contents[i] !== '\n') {
-      let c = contents[i];
-      if (c === '\\') {
-        i += 2;
-        continue;
-      }
-      if (c === '[') inClass = true;
-      else if (c === ']') inClass = false;
-      else if (c === '/' && !inClass) break;
-      i++;
-    }
-    i++;
-    while (i < contents.length && isIdentifierPart(contents[i])) i++;
-    this.pos = Math.min(i, contents.length);
-    this.emit({ kind: 'regex', newlineBefore: this.newlineBefore });
-  }
-
-  private regexAllowed(): boolean {
-    let prev = this.previous;
-    if (!prev) return true;
-    switch (prev.kind) {
-      case 'ident':
-        return EXPRESSION_KEYWORDS.has(prev.text) || STATEMENT_KEYWORDS.has(prev.text);
-      case 'punct':
-        // After `)` or `]` a slash divides; after `}` it is far more likely
-        // to start a regex at the beginning of a statement than to divide an
-        // object literal.
-        return prev.text !== ')' && prev.text !== ']';
-      default:
-        return false;
-    }
-  }
-
-  private readIdentifier(): void {
-    let { contents } = this;
-    let start = this.pos;
-    let i = start;
-    while (i < contents.length && isIdentifierPart(contents[i])) i++;
-    this.pos = i;
-    let text = contents.slice(start, i);
-    let afterDot =
-      this.previous?.kind === 'punct' &&
-      (this.previous.text === '.' || this.previous.text === '?.');
-    let startsStatement = this.startsStatement();
-
-    this.emit({ kind: 'ident', text, newlineBefore: this.newlineBefore });
-
-    if (afterDot) return;
-
-    let following = this.peekNonSpace();
-    if (text === 'class' && !(following !== undefined && /[:,)}=.?]/.test(following))) {
-      // A `class` keyword (not a `class:` object key or `.class` access). The
-      // header context becomes the class body at its `{`.
-      this.contexts.push({ kind: 'class-header', angleDepth: 0 });
-    } else if (
-      text === 'import' &&
-      startsStatement &&
-      !this.pendingImport &&
-      following !== '(' &&
-      following !== '.'
-    ) {
-      // An import declaration; its tokens are gathered up to the module
-      // specifier string and interpreted in `recordImport`.
-      this.pendingImport = [];
-    }
-  }
-
-  private peekNonSpace(): string | undefined {
-    let { contents } = this;
-    let i = this.pos;
-    while (i < contents.length && /\s/.test(contents[i])) i++;
-    return contents[i];
-  }
-
-  private readNumber(): void {
-    let { contents } = this;
-    let i = this.pos;
-    while (i < contents.length && (isIdentifierPart(contents[i]) || contents[i] === '.')) i++;
-    this.pos = i;
-    this.emit({ kind: 'number', newlineBefore: this.newlineBefore });
-  }
-
-  private readPunctuator(): void {
-    let { contents } = this;
-    let text = PUNCTUATORS.find((p) => contents.startsWith(p, this.pos)) ?? contents[this.pos];
-    this.pos += text.length;
-    let newlineBefore = this.newlineBefore;
-    let top = this.contexts[this.contexts.length - 1];
-
-    if (text === '{') {
-      if (top?.kind === 'class-header' && top.angleDepth === 0) {
-        this.contexts[this.contexts.length - 1] = { kind: 'class-body' };
-      } else if (
-        top?.kind === 'class-body' &&
-        this.previous?.kind === 'ident' &&
-        this.previous.text === 'static'
-      ) {
-        this.contexts.push({ kind: 'static-block' });
-      } else {
-        this.contexts.push({ kind: 'other' });
-      }
-    } else if (text === '}') {
-      this.contexts.pop();
-    } else if (text === '(' || text === '[') {
-      this.contexts.push({ kind: 'other' });
-    } else if (text === ')' || text === ']') {
-      if (top?.kind === 'other') this.contexts.pop();
-    } else if (top?.kind === 'class-header') {
-      if (text === '<') top.angleDepth++;
-      else if (text === '>') top.angleDepth = Math.max(0, top.angleDepth - 1);
-      else if (text === '>>') top.angleDepth = Math.max(0, top.angleDepth - 2);
-    }
-
-    this.emit({ kind: 'punct', text, newlineBefore });
-  }
-
-  private thisBindingHere(): TemplateThisBinding {
-    // Mirrors `templateThisBinding`, which walks up the TS AST and stops at
-    // the first static block, heritage clause or class it meets.
-    for (let i = this.contexts.length - 1; i >= 0; i--) {
-      let context = this.contexts[i];
-      switch (context.kind) {
-        case 'static-block':
-          return 'backing-class';
-        case 'class-header':
-          return 'context';
-        case 'class-body':
-          return 'lexical';
-      }
-    }
-    return 'context';
-  }
-
-  // Whether a token at the current position begins a statement, accounting
-  // for automatic semicolon insertion after a line break.
-  private startsStatement(): boolean {
-    let prev = this.previous;
-    if (!prev) return true;
-    let { newlineBefore } = this;
-    switch (prev.kind) {
-      case 'punct':
-        if (prev.text === ';' || prev.text === '{' || prev.text === '}') return true;
-        if (prev.text === ')') return true;
-        if (prev.text === ']') return newlineBefore;
-        return false;
-      case 'ident':
-        if (STATEMENT_KEYWORDS.has(prev.text)) return true;
-        if (EXPRESSION_KEYWORDS.has(prev.text)) return false;
-        return newlineBefore;
-      default:
-        return newlineBefore;
-    }
-  }
-
-  private recordImport(tokens: Array<Token>, source: string): void {
-    let i = 0;
-    let at = (index: number): Token | undefined => tokens[index];
-    let isIdent = (token: Token | undefined, text?: string): token is Token & { kind: 'ident' } =>
-      token?.kind === 'ident' && (text === undefined || token.text === text);
-    let isPunct = (token: Token | undefined, text: string): boolean =>
-      token?.kind === 'punct' && token.text === text;
-    let nameOf = (token: Token | undefined): string | undefined =>
-      token?.kind === 'ident' ? token.text : token?.kind === 'string' ? token.value : undefined;
-
-    // `import type X from` / `import type { X } from` — but `import type from`
-    // is a default import named `type`.
-    if (isIdent(at(i), 'type') && at(i + 1) && !isIdent(at(i + 1), 'from')) i++;
-
-    if (isIdent(at(i)) && !isPunct(at(i + 1), '{') && !isIdent(at(i), 'from')) {
-      this.imports[(at(i) as { text: string }).text] = {
-        specifier: 'default',
-        source,
-        synthetic: false,
-      };
-      i++;
-      if (isPunct(at(i), ',')) i++;
-    }
-
-    if (isPunct(at(i), '*')) {
-      // Namespace imports carry no individual bindings.
-      return;
-    }
-
-    if (isPunct(at(i), '{')) {
-      i++;
-      while (i < tokens.length && !isPunct(at(i), '}')) {
-        let entry: Array<Token> = [];
-        while (i < tokens.length && !isPunct(at(i), ',') && !isPunct(at(i), '}')) {
-          entry.push(tokens[i]);
-          i++;
-        }
-        if (isPunct(at(i), ',')) i++;
-
-        let j = 0;
-        // Inline `type` modifier: `{ type X }` / `{ type X as Y }`, but
-        // `{ type }` and `{ type as t }` import a binding named `type`.
-        if (isIdent(entry[j], 'type') && entry[j + 1] && !isIdent(entry[j + 1], 'as')) j++;
-        let specifier = nameOf(entry[j]);
-        if (specifier === undefined) continue;
-        let name = isIdent(entry[j + 1], 'as') ? nameOf(entry[j + 2]) : specifier;
-        if (name === undefined) continue;
-        this.imports[name] = { specifier, source, synthetic: false };
-      }
-    }
-  }
-}
-
-function isIdentifierStart(ch: string | undefined): boolean {
-  return ch !== undefined && /[\p{ID_Start}$_\\]/u.test(ch);
-}
-
-function isIdentifierPart(ch: string | undefined): boolean {
-  return ch !== undefined && /[\p{ID_Continue}$\\]/u.test(ch);
-}
-
-function isDigit(ch: string | undefined): boolean {
-  return ch !== undefined && ch >= '0' && ch <= '9';
-}
diff --git a/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts b/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts
index 806bc34bc..2fd597e27 100644
--- a/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts
+++ b/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts
@@ -1,8 +1,13 @@
+import { toTree } 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, PartialCorrelatedSpan } from './inlining/index.js';
-import { scanScript } from './inlining/script-scanner.js';
+import {
+  EmbeddedTemplate,
+  ImportedBindings,
+  PartialCorrelatedSpan,
+  TemplateThisBinding,
+} from './inlining/index.js';
 import { calculateTemplateSpans } from './inlining/tagged-strings.js';
 import {
   buildTransformedModule,
@@ -18,11 +23,10 @@ import TransformedModule, { Directive, TransformError } from './transformed-modu
  * `rewriteModule` parses the content-tag-preprocessed script with the
  * `TSLib` it is given and reads three things off the AST: where each
  * template sits, how its `{{this}}` binds, and which names the module imports.
- * Here those come from content-tag's own parse output (template ranges and
- * whether a template is a class member) and a lightweight scan of the script
- * (`script-scanner.ts`), 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.
+ * Here the same facts come from the ESTree that `ember-estree` (content-tag +
+ * oxc-parser) produces for the file, 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; the
  * language server, tsserver plugin and `ember-tsc` keep using `rewriteModule`.
@@ -50,20 +54,35 @@ export function rewriteModuleStandalone(
     return buildTransformedModule(script, { errors, directives, partialSpans });
   }
 
-  let templates = data.templateLocations.map((location) => ({
-    location,
-    // The `<template>` tags themselves, matching `templateLocation` in
-    // `environment-ember-template-imports/-private/environment/transform.ts`.
-    start: location.startTagOffset,
-    end: location.endTagOffset + location.endTagLength,
-    contentStart: location.startTagOffset + location.startTagLength,
-    contentEnd: location.endTagOffset,
-  }));
+  let { imports, placements } = analyzeScript(contents, filename);
+
+  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 { imports, templates: contexts } = scanScript(contents, templates);
+    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 ';
+    }
 
-  for (let [index, template] of templates.entries()) {
-    let embedded = toEmbeddedTemplate(template, contexts[index], contents);
     let result = calculateTemplateSpans(embedded, imports, script, environment);
     errors.push(...result.errors);
     directives.push(...result.directives);
@@ -73,41 +92,151 @@ export function rewriteModuleStandalone(
   return buildTransformedModule(script, { errors, directives, partialSpans });
 }
 
-function toEmbeddedTemplate(
-  template: {
-    location: PreprocessData['templateLocations'][number];
-    start: number;
-    end: number;
-    contentStart: number;
-    contentEnd: number;
-  },
-  context: ReturnType<typeof scanScript>['templates'][number],
-  contents: string,
-): EmbeddedTemplate {
-  let { start, end, contentStart, contentEnd } = template;
-  let templateLocation = { start, end, contentStart, contentEnd };
-  let text = contents.slice(contentStart, contentEnd);
-
-  if (template.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.
-    return {
-      template: text,
-      templateLocation,
-      thisBinding: 'backing-class',
-      prepend: 'static { ',
-      append: ' }',
-    };
+type Node = { type: string; start?: number; end?: number };
+type Ancestor = { node: Node; key: string };
+
+type Program = Node & { body: Array<Node> };
+type ImportDeclaration = Node & {
+  source: { value: string };
+  specifiers: Array<
+    Node & { local: { name: string }; imported?: { name?: string; value?: string } }
+  >;
+};
+
+type Placement = {
+  thisBinding: TemplateThisBinding;
+  isExpressionStatement: boolean;
+};
+
+type ScriptAnalysis = {
+  imports: ImportedBindings;
+  /** Keyed by the offset of each template's `<template>` tag. */
+  placements: Map<number, Placement>;
+};
+
+/**
+ * Reads import bindings and the syntactic placement of every template from
+ * the module's ESTree. The walk runs over ember-estree's outer JS/TS tree
+ * before the templates are spliced in, where each `<template>` is still a
+ * same-length placeholder starting at the tag's offset, so the placeholder's
+ * ancestors are exactly the template's.
+ */
+function analyzeScript(contents: string, filename: string): ScriptAnalysis {
+  let analysis: ScriptAnalysis = { imports: {}, placements: new Map() };
+  let analyzed = false;
+
+  try {
+    toTree(contents, {
+      filePath: filename,
+      visitors: (file) => {
+        let program = (file as unknown as { program: Program }).program;
+        collectImportedBindings(program, analysis.imports);
+        walk(program, [], analysis.placements);
+        analyzed = true;
+        return null;
+      },
+    });
+  } catch (error) {
+    // After the visitor factory has run, ember-estree parses each template's
+    // handlebars to splice it into the tree and throws on a syntax error.
+    // Everything needed here was gathered before that point, and the template
+    // error itself is reported by `calculateTemplateSpans`.
+    if (!analyzed) throw error;
   }
 
-  return {
-    template: text,
-    templateLocation,
-    thisBinding: context.thisBinding,
-    // 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.
-    prepend: context.isExpressionStatement ? 'export default ' : undefined,
-  };
+  return analysis;
+}
+
+const SKIPPED_KEYS = new Set(['parent', 'loc', 'range', 'tokens', 'comments']);
+
+function walk(node: Node, ancestors: Array<Ancestor>, placements: Map<number, Placement>): void {
+  if (isPlaceholderShape(node) && typeof node.start === 'number' && !placements.has(node.start)) {
+    // Only the placeholders start exactly at a template's tag; the offsets
+    // that miss are user-authored expressions and static blocks, and their
+    // entries are simply never looked up.
+    placements.set(node.start, {
+      thisBinding: templateThisBinding(ancestors),
+      isExpressionStatement: isExpressionStatement(ancestors),
+    });
+  }
+
+  for (let [key, child] of Object.entries(node)) {
+    if (SKIPPED_KEYS.has(key)) continue;
+    if (Array.isArray(child)) {
+      for (let item of child) {
+        if (isNode(item)) walk(item, ancestors.concat({ node, key }), placements);
+      }
+    } else if (isNode(child)) {
+      walk(child, ancestors.concat({ node, key }), placements);
+    }
+  }
+}
+
+// ember-estree stands each expression template in with a same-length
+// template literal (`void `...`` from 0.8, a bare backtick literal before) and
+// each class member with a `static{`...`}` block.
+function isPlaceholderShape(node: Node): boolean {
+  return (
+    node.type === 'TemplateLiteral' ||
+    node.type === 'UnaryExpression' ||
+    node.type === 'StaticBlock'
+  );
+}
+
+function isNode(value: unknown): value is Node {
+  return typeof value === 'object' && value !== null && typeof (value as Node).type === 'string';
+}
+
+// Mirrors `templateThisBinding` in `inlining/index.ts`, which walks up the TS
+// AST and stops at the first static block, heritage clause or class it meets.
+function templateThisBinding(ancestors: Array<Ancestor>): TemplateThisBinding {
+  for (let i = ancestors.length - 1; i >= 0; i--) {
+    let { node, key } = ancestors[i];
+    switch (node.type) {
+      case 'StaticBlock':
+        return 'backing-class';
+      case 'ClassDeclaration':
+      case 'ClassExpression':
+        if (key === 'superClass' || key === 'implements') return 'context';
+        break;
+      case 'ClassBody':
+        return 'lexical';
+    }
+  }
+  return 'context';
+}
+
+// Mirrors `isETIDefaultTemplate` / `isETIDefaultSatisfiesTemplate` in the
+// environment transform: the template is the whole expression of an
+// expression statement, optionally through a `satisfies`.
+function isExpressionStatement(ancestors: Array<Ancestor>): boolean {
+  let parent = ancestors[ancestors.length - 1]?.node;
+  if (parent?.type === 'TSSatisfiesExpression') {
+    parent = ancestors[ancestors.length - 2]?.node;
+  }
+  return parent?.type === 'ExpressionStatement';
+}
+
+// Mirrors `collectImportedBindings` in `inlining/tagged-strings.ts`.
+function collectImportedBindings(program: Program, result: ImportedBindings): void {
+  for (let statement of program.body) {
+    if (statement.type !== 'ImportDeclaration') continue;
+
+    let { source, specifiers } = statement as ImportDeclaration;
+    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/pnpm-lock.yaml b/pnpm-lock.yaml
index 41fd0b827..bb1e0d238 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.7.0
+        version: 0.7.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.7.0:
+    resolution: {integrity: sha512-wtP9xJzDrHV0+2/FmgF8jCC2mXO6Igf3edxi37+RZVWWbQZfabkAMyVV6mr7tntCI2dpaw3W32sBvnYF87f+Bw==}
+
   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.7.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
index 08c0da7a5..acf8712a4 100644
--- a/test-packages/package-test-core/__tests__/transform/rewrite-standalone.test.ts
+++ b/test-packages/package-test-core/__tests__/transform/rewrite-standalone.test.ts
@@ -1,6 +1,5 @@
 import { GlintEnvironment } from '@glint/ember-tsc/config/index';
 import { rewriteModule, rewriteModuleStandalone } from '@glint/ember-tsc/transform/index';
-import { scanScript } from '@glint/ember-tsc/transform/template/inlining/script-scanner';
 import { stripIndent } from 'common-tags';
 import { readdirSync, readFileSync, statSync } from 'node:fs';
 import { join, relative, resolve } from 'node:path';
@@ -90,7 +89,11 @@ describe('Transform: rewriteModuleStandalone', () => {
       );
     });
 
-    test('static block and heritage clause', () => {
+    // ember-estree 0.7.0 builds its placeholder JS from content-tag's results
+    // in content-tag order, which puts a heritage-clause template after the
+    // class body template; NullVoxPopuli/ember-estree#77 sorts them. Flip to
+    // `test` once that ships.
+    test.fails('static block and heritage clause', () => {
       expectParity(
         'test.gts',
         stripIndent`
@@ -153,7 +156,10 @@ describe('Transform: rewriteModuleStandalone', () => {
       );
     });
 
-    test('templates after statements that rely on automatic semicolon insertion', () => {
+    // ember-estree 0.7.0's bare-backtick placeholder reads as a tagged
+    // template after `x`; NullVoxPopuli/ember-estree#78 switches it to
+    // `void `...``. Flip to `test` once that ships.
+    test.fails('templates after statements that rely on automatic semicolon insertion', () => {
       expectParity(
         'test.gts',
         stripIndent`
@@ -227,6 +233,31 @@ describe('Transform: rewriteModuleStandalone', () => {
       );
     });
 
+    test('script syntax error still emits the template', () => {
+      // oxc-parser yields an empty program on an unrecoverable script error
+      // (TypeScript's parser is more tolerant), so import bindings and
+      // template placement are unavailable: content-tag still classifies the
+      // class member, and `fn` is emitted as a bare identifier, which
+      // resolves lexically to the import. The syntax error itself is
+      // reported by whichever type-checker consumes the output.
+      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?.errors).toEqual([]);
+      expect(standalone?.transformedContents).toContain('templateForBackingValue(this');
+      expect(standalone?.transformedContents).toContain('__glintDSL__.resolve(fn)(');
+    });
+
     test('no templates', () => {
       expectParity('test.gts', `export const x = 1;\n`);
       expectParity('test.ts', `export const x = 1;\n`);
@@ -251,76 +282,3 @@ describe('Transform: rewriteModuleStandalone', () => {
     });
   });
 });
-
-describe('Transform: scanScript', () => {
-  function scan(source: string): ReturnType<typeof scanScript> {
-    // `<template>...</template>` ranges are located by hand here; the real
-    // caller gets them from content-tag.
-    let ranges: Array<{ start: number; end: number }> = [];
-    let re = /<template>[\s\S]*?<\/template>/g;
-    let match: RegExpExecArray | null;
-    while ((match = re.exec(source))) {
-      ranges.push({ start: match.index, end: match.index + match[0].length });
-    }
-    return scanScript(source, ranges);
-  }
-
-  test('reads default, named, aliased and type-only import bindings', () => {
-    let { imports } = scan(stripIndent`
-      import Component from '@glimmer/component';
-      import { hash as h, array, type Foo } from '@ember/helper';
-      import type { TOC } from '@ember/component/template-only';
-      import type from './type';
-      import { type } from './type-binding';
-      import * as ns from './ns';
-      import Both, * as both from './both';
-      import './side-effect';
-      import { "string-name" as stringName } from './strings';
-      import json from './data.json' with { type: 'json' };
-      import fs = require('node:fs');
-      const lazy = import('./lazy');
-      const url = import.meta.url;
-      const obj = { import: 1 };
-      obj.import;
-    `);
-
-    expect(imports).toEqual({
-      Component: { specifier: 'default', source: '@glimmer/component', synthetic: false },
-      h: { specifier: 'hash', source: '@ember/helper', synthetic: false },
-      array: { specifier: 'array', source: '@ember/helper', synthetic: false },
-      Foo: { specifier: 'Foo', source: '@ember/helper', synthetic: false },
-      TOC: { specifier: 'TOC', source: '@ember/component/template-only', synthetic: false },
-      type: { specifier: 'type', source: './type-binding', synthetic: false },
-      Both: { specifier: 'default', source: './both', synthetic: false },
-      stringName: { specifier: 'string-name', source: './strings', synthetic: false },
-      json: { specifier: 'default', source: './data.json', synthetic: false },
-    });
-  });
-
-  test('classifies template positions', () => {
-    let { templates } = scan(stripIndent`
-      <template>module</template>
-      const a = <template>operand</template>;
-      class A extends mixin(<template>heritage</template>) {
-        field = <template>lexical</template>;
-        static {
-          <template>static</template>
-        }
-        method() {
-          <template>statement-in-method</template>
-        }
-      }
-      <template>trailing</template>
-    `);
-
-    expect(templates).toEqual([
-      { thisBinding: 'context', isExpressionStatement: true },
-      { thisBinding: 'context', isExpressionStatement: false },
-      { thisBinding: 'context', isExpressionStatement: false },
-      { thisBinding: 'lexical', isExpressionStatement: false },
-      { thisBinding: 'backing-class', isExpressionStatement: true },
-      { thisBinding: 'lexical', isExpressionStatement: true },
-      { thisBinding: 'context', isExpressionStatement: true },
-    ]);
-  });
-});

From f0417dee2c7ec2f394c383b8810273445ccab2d7 Mon Sep 17 00:00:00 2001
From: NullVoxPopuli-ai-agent
 <268630448+NullVoxPopuli-ai-agent@users.noreply.github.com>
Date: Mon, 24 Aug 2026 19:30:33 -0400
Subject: [PATCH 04/13] Retrigger CI (tsserver socket write-after-end during
 vitest teardown)

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FsXgxh6vNRWMCNcAQ3g6TN

From b65c7f4aa0c13e0f8861a687ca9246d4b27764b7 Mon Sep 17 00:00:00 2001
From: NullVoxPopuli-ai-agent
 <268630448+NullVoxPopuli-ai-agent@users.noreply.github.com>
Date: Mon, 24 Aug 2026 19:36:54 -0400
Subject: [PATCH 05/13] Expose rewriteModuleStandalone as
 @glint/ember-tsc/transform/standalone

`gts-virtual-code.ts` imports `transform/index.js`, so re-exporting the
standalone entry there made tsserver load ember-estree and oxc-parser's
native binary at plugin activation. A dedicated entrypoint keeps the
language server, tsserver plugin and `ember-tsc` free of it.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FsXgxh6vNRWMCNcAQ3g6TN
---
 packages/ember-tsc/package.json                               | 4 ++++
 packages/ember-tsc/src/transform/index.ts                     | 1 -
 .../src/transform/template/rewrite-module-standalone.ts       | 2 ++
 .../__tests__/transform/rewrite-standalone.test.ts            | 3 ++-
 4 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/packages/ember-tsc/package.json b/packages/ember-tsc/package.json
index 37943a524..02b4b56de 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": {
diff --git a/packages/ember-tsc/src/transform/index.ts b/packages/ember-tsc/src/transform/index.ts
index d655e70cb..3577bf97d 100644
--- a/packages/ember-tsc/src/transform/index.ts
+++ b/packages/ember-tsc/src/transform/index.ts
@@ -2,4 +2,3 @@ export type { Directive, default as TransformedModule } from './template/transfo
 export type { Diagnostic } from './diagnostics/index.js';
 
 export { rewriteModule } from './template/rewrite-module.js';
-export { rewriteModuleStandalone } from './template/rewrite-module-standalone.js';
diff --git a/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts b/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts
index 2fd597e27..1b2576323 100644
--- a/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts
+++ b/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts
@@ -30,6 +30,8 @@ import TransformedModule, { Directive, TransformError } from './transformed-modu
  *
  * The output is identical to `rewriteModule`'s for the same input; the
  * language server, tsserver plugin and `ember-tsc` keep using `rewriteModule`.
+ * Exposed only as `@glint/ember-tsc/transform/standalone` so that those paths
+ * never load ember-estree (and oxc-parser's native binary).
  */
 export function rewriteModuleStandalone(
   { script }: RewriteInput,
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
index acf8712a4..03cecfaeb 100644
--- a/test-packages/package-test-core/__tests__/transform/rewrite-standalone.test.ts
+++ b/test-packages/package-test-core/__tests__/transform/rewrite-standalone.test.ts
@@ -1,5 +1,6 @@
 import { GlintEnvironment } from '@glint/ember-tsc/config/index';
-import { rewriteModule, rewriteModuleStandalone } from '@glint/ember-tsc/transform/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';

From da8bb2dc162c2ede856391e5ceaafa9ba4b5f1d3 Mon Sep 17 00:00:00 2001
From: NullVoxPopuli-ai-agent
 <268630448+NullVoxPopuli-ai-agent@users.noreply.github.com>
Date: Mon, 24 Aug 2026 19:56:46 -0400
Subject: [PATCH 06/13] Bump ember-estree to 0.7.1 and enable the two pending
 parity tests

0.7.1 sorts content-tag results into source order and uses `void`
placeholders, so heritage-clause templates and statement-start templates
after an unterminated statement now match `rewriteModule`.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FsXgxh6vNRWMCNcAQ3g6TN
---
 packages/ember-tsc/package.json                       |  2 +-
 .../transform/template/rewrite-module-standalone.ts   |  2 +-
 pnpm-lock.yaml                                        | 10 +++++-----
 .../__tests__/transform/rewrite-standalone.test.ts    | 11 ++---------
 4 files changed, 9 insertions(+), 16 deletions(-)

diff --git a/packages/ember-tsc/package.json b/packages/ember-tsc/package.json
index 02b4b56de..cf65016a2 100644
--- a/packages/ember-tsc/package.json
+++ b/packages/ember-tsc/package.json
@@ -91,7 +91,7 @@
     "@volar/test-utils": "~2.4.28",
     "@volar/typescript": "~2.4.28",
     "content-tag": "^4.2.0",
-    "ember-estree": "^0.7.0",
+    "ember-estree": "^0.7.1",
     "silent-error": "^1.1.1",
     "volar-service-html": "~0.0.71",
     "volar-service-typescript": "~0.0.71",
diff --git a/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts b/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts
index 1b2576323..958ddaecc 100644
--- a/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts
+++ b/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts
@@ -175,7 +175,7 @@ function walk(node: Node, ancestors: Array<Ancestor>, placements: Map<number, Pl
 }
 
 // ember-estree stands each expression template in with a same-length
-// template literal (`void `...`` from 0.8, a bare backtick literal before) and
+// template literal (`void `...`` from 0.7.1, a bare backtick literal before) and
 // each class member with a `static{`...`}` block.
 function isPlaceholderShape(node: Node): boolean {
   return (
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index bb1e0d238..fa14d768a 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -117,8 +117,8 @@ importers:
         specifier: ^4.2.0
         version: 4.2.0
       ember-estree:
-        specifier: ^0.7.0
-        version: 0.7.0
+        specifier: ^0.7.1
+        version: 0.7.1
       silent-error:
         specifier: ^1.1.1
         version: 1.1.1
@@ -4528,8 +4528,8 @@ packages:
       '@typescript-eslint/parser':
         optional: true
 
-  ember-estree@0.7.0:
-    resolution: {integrity: sha512-wtP9xJzDrHV0+2/FmgF8jCC2mXO6Igf3edxi37+RZVWWbQZfabkAMyVV6mr7tntCI2dpaw3W32sBvnYF87f+Bw==}
+  ember-estree@0.7.1:
+    resolution: {integrity: sha512-5BRJbX2bL9YE+SPsRLWxYNzIZ7VtRAuj/50g5N28Ig93RFkbxySlUKsdDZUj0ZYwCrGUljSNzr4BPdaJEoiGkA==}
 
   ember-modifier@4.2.0:
     resolution: {integrity: sha512-BJ48eTEGxD8J7+lofwVmee7xDgNDgpr5dd6+MSu4gk+I6xb35099RMNorXY5hjjwMJEyi/IRR6Yn3M7iJMz8Zw==}
@@ -13892,7 +13892,7 @@ snapshots:
       - eslint
       - typescript
 
-  ember-estree@0.7.0:
+  ember-estree@0.7.1:
     dependencies:
       '@glimmer/env': 0.1.7
       '@glimmer/syntax': 0.95.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
index 03cecfaeb..166266308 100644
--- a/test-packages/package-test-core/__tests__/transform/rewrite-standalone.test.ts
+++ b/test-packages/package-test-core/__tests__/transform/rewrite-standalone.test.ts
@@ -90,11 +90,7 @@ describe('Transform: rewriteModuleStandalone', () => {
       );
     });
 
-    // ember-estree 0.7.0 builds its placeholder JS from content-tag's results
-    // in content-tag order, which puts a heritage-clause template after the
-    // class body template; NullVoxPopuli/ember-estree#77 sorts them. Flip to
-    // `test` once that ships.
-    test.fails('static block and heritage clause', () => {
+    test('static block and heritage clause', () => {
       expectParity(
         'test.gts',
         stripIndent`
@@ -157,10 +153,7 @@ describe('Transform: rewriteModuleStandalone', () => {
       );
     });
 
-    // ember-estree 0.7.0's bare-backtick placeholder reads as a tagged
-    // template after `x`; NullVoxPopuli/ember-estree#78 switches it to
-    // `void `...``. Flip to `test` once that ships.
-    test.fails('templates after statements that rely on automatic semicolon insertion', () => {
+    test('templates after statements that rely on automatic semicolon insertion', () => {
       expectParity(
         'test.gts',
         stripIndent`

From be745d1d39e03b6507f290c6aa30da05405d4967 Mon Sep 17 00:00:00 2001
From: NullVoxPopuli-ai-agent
 <268630448+NullVoxPopuli-ai-agent@users.noreply.github.com>
Date: Tue, 25 Aug 2026 01:39:22 -0400
Subject: [PATCH 07/13] Drive the standalone analysis through ember-estree's
 visitors

Address review: no hand-rolled tree walk. Import bindings and template
placement come from `ImportDeclaration` / `GlimmerTemplate` visitor
callbacks, with `onTemplateError` (NullVoxPopuli/ember-estree#80)
supplying the path of a template that fails to parse so it is placed
like any other. The `this`-binding resolution is shared with the TS path
(`thisBindingFromAncestors`); each path only maps its own AST to the
ancestor kinds.

Also drop the generic `templateLocation` fallback in
`calculateTaggedTemplateSpans`: the only environment transform always
records it, so assert instead.

Needs ember-estree with #80 (export default wrapper kept; onTemplateError).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FsXgxh6vNRWMCNcAQ3g6TN
---
 .../src/transform/template/inlining/index.ts  |  51 +++--
 .../template/inlining/tagged-strings.ts       |  14 +-
 .../template/rewrite-module-standalone.ts     | 178 +++++++-----------
 3 files changed, 113 insertions(+), 130 deletions(-)

diff --git a/packages/ember-tsc/src/transform/template/inlining/index.ts b/packages/ember-tsc/src/transform/template/inlining/index.ts
index 0f3b75048..1bb0dc304 100644
--- a/packages/ember-tsc/src/transform/template/inlining/index.ts
+++ b/packages/ember-tsc/src/transform/template/inlining/index.ts
@@ -61,22 +61,43 @@ export type EmbeddedTemplate = {
 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 4187fad03..6f2bbdf7a 100644
--- a/packages/ember-tsc/src/transform/template/inlining/tagged-strings.ts
+++ b/packages/ember-tsc/src/transform/template/inlining/tagged-strings.ts
@@ -41,16 +41,10 @@ export function calculateTaggedTemplateSpans(
     'No interpolated values in template strings',
   );
 
-  // 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,
-  };
+  // 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(
     {
diff --git a/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts b/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts
index 958ddaecc..bb763f717 100644
--- a/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts
+++ b/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts
@@ -1,4 +1,4 @@
-import { toTree } from 'ember-estree';
+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';
@@ -7,6 +7,8 @@ import {
   ImportedBindings,
   PartialCorrelatedSpan,
   TemplateThisBinding,
+  ThisBindingAncestor,
+  thisBindingFromAncestors,
 } from './inlining/index.js';
 import { calculateTemplateSpans } from './inlining/tagged-strings.js';
 import {
@@ -95,9 +97,7 @@ export function rewriteModuleStandalone(
 }
 
 type Node = { type: string; start?: number; end?: number };
-type Ancestor = { node: Node; key: string };
 
-type Program = Node & { body: Array<Node> };
 type ImportDeclaration = Node & {
   source: { value: string };
   specifiers: Array<
@@ -105,6 +105,8 @@ type ImportDeclaration = Node & {
   >;
 };
 
+type ClassNode = Node & { superClass?: Node | null; implements?: Array<Node> };
+
 type Placement = {
   thisBinding: TemplateThisBinding;
   isExpressionStatement: boolean;
@@ -116,129 +118,95 @@ type ScriptAnalysis = {
   placements: Map<number, Placement>;
 };
 
+// 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']);
+
 /**
- * Reads import bindings and the syntactic placement of every template from
- * the module's ESTree. The walk runs over ember-estree's outer JS/TS tree
- * before the templates are spliced in, where each `<template>` is still a
- * same-length placeholder starting at the tag's offset, so the placeholder's
- * ancestors are exactly the template's.
+ * Reads import bindings and the syntactic placement of every template off
+ * ember-estree's traversal of the module.
  */
 function analyzeScript(contents: string, filename: string): ScriptAnalysis {
-  let analysis: ScriptAnalysis = { imports: {}, placements: new Map() };
-  let analyzed = false;
-
-  try {
-    toTree(contents, {
-      filePath: filename,
-      visitors: (file) => {
-        let program = (file as unknown as { program: Program }).program;
-        collectImportedBindings(program, analysis.imports);
-        walk(program, [], analysis.placements);
-        analyzed = true;
-        return null;
-      },
-    });
-  } catch (error) {
-    // After the visitor factory has run, ember-estree parses each template's
-    // handlebars to splice it into the tree and throws on a syntax error.
-    // Everything needed here was gathered before that point, and the template
-    // error itself is reported by `calculateTemplateSpans`.
-    if (!analyzed) throw error;
-  }
+  let imports: ImportedBindings = {};
+  let placements = new Map<number, Placement>();
 
-  return analysis;
-}
-
-const SKIPPED_KEYS = new Set(['parent', 'loc', 'range', 'tokens', 'comments']);
-
-function walk(node: Node, ancestors: Array<Ancestor>, placements: Map<number, Placement>): void {
-  if (isPlaceholderShape(node) && typeof node.start === 'number' && !placements.has(node.start)) {
-    // Only the placeholders start exactly at a template's tag; the offsets
-    // that miss are user-authored expressions and static blocks, and their
-    // entries are simply never looked up.
-    placements.set(node.start, {
-      thisBinding: templateThisBinding(ancestors),
-      isExpressionStatement: isExpressionStatement(ancestors),
+  let place = (start: number, path: VisitorPath): void => {
+    placements.set(start, {
+      thisBinding: thisBindingFromAncestors(ancestorsOf(path)),
+      isExpressionStatement: isExpressionStatement(path),
     });
-  }
-
-  for (let [key, child] of Object.entries(node)) {
-    if (SKIPPED_KEYS.has(key)) continue;
-    if (Array.isArray(child)) {
-      for (let item of child) {
-        if (isNode(item)) walk(item, ancestors.concat({ node, key }), placements);
-      }
-    } else if (isNode(child)) {
-      walk(child, ancestors.concat({ node, key }), placements);
-    }
-  }
-}
+  };
 
-// ember-estree stands each expression template in with a same-length
-// template literal (`void `...`` from 0.7.1, a bare backtick literal before) and
-// each class member with a `static{`...`}` block.
-function isPlaceholderShape(node: Node): boolean {
-  return (
-    node.type === 'TemplateLiteral' ||
-    node.type === 'UnaryExpression' ||
-    node.type === 'StaticBlock'
-  );
-}
-
-function isNode(value: unknown): value is Node {
-  return typeof value === 'object' && value !== null && typeof (value as Node).type === 'string';
+  toTree(contents, {
+    filePath: filename,
+    visitors: {
+      ImportDeclaration(node) {
+        collectImportedBindings(node as ImportDeclaration, imports);
+      },
+      GlimmerTemplate(node, path) {
+        place(node.start as number, path);
+      },
+    },
+    // A template that fails to parse still sits somewhere; the error itself
+    // is reported by `calculateTemplateSpans`, which parses it again.
+    onTemplateError(_error, { range, path }) {
+      place(range[0], path);
+    },
+  });
+
+  return { imports, placements };
 }
 
-// Mirrors `templateThisBinding` in `inlining/index.ts`, which walks up the TS
-// AST and stops at the first static block, heritage clause or class it meets.
-function templateThisBinding(ancestors: Array<Ancestor>): TemplateThisBinding {
-  for (let i = ancestors.length - 1; i >= 0; i--) {
-    let { node, key } = ancestors[i];
+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':
-        return 'backing-class';
+        yield 'static-block';
+        break;
       case 'ClassDeclaration':
-      case 'ClassExpression':
-        if (key === 'superClass' || key === 'implements') return 'context';
+      case 'ClassExpression': {
+        let { superClass, implements: implemented } = node as ClassNode;
+        if (superClass === child.node || implemented?.includes(child.node)) yield 'heritage-clause';
         break;
+      }
       case 'ClassBody':
-        return 'lexical';
+        yield 'class';
+        break;
     }
   }
-  return 'context';
 }
 
-// Mirrors `isETIDefaultTemplate` / `isETIDefaultSatisfiesTemplate` in the
-// environment transform: the template is the whole expression of an
-// expression statement, optionally through a `satisfies`.
-function isExpressionStatement(ancestors: Array<Ancestor>): boolean {
-  let parent = ancestors[ancestors.length - 1]?.node;
+function isExpressionStatement(path: VisitorPath): boolean {
+  let parent = path.parent;
   if (parent?.type === 'TSSatisfiesExpression') {
-    parent = ancestors[ancestors.length - 2]?.node;
+    return path.parentPath?.parent?.type === 'ExpressionStatement';
   }
-  return parent?.type === 'ExpressionStatement';
+  return (
+    parent !== null && (parent.type === 'ExpressionStatement' || STATEMENT_LISTS.has(parent.type))
+  );
 }
 
-// Mirrors `collectImportedBindings` in `inlining/tagged-strings.ts`.
-function collectImportedBindings(program: Program, result: ImportedBindings): void {
-  for (let statement of program.body) {
-    if (statement.type !== 'ImportDeclaration') continue;
-
-    let { source, specifiers } = statement as ImportDeclaration;
-    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,
-        };
-      }
+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,
+      };
     }
   }
 }

From e7008f045e05542c82946624083f5eac20c56264 Mon Sep 17 00:00:00 2001
From: NullVoxPopuli-ai-agent
 <268630448+NullVoxPopuli-ai-agent@users.noreply.github.com>
Date: Tue, 25 Aug 2026 09:33:54 -0400
Subject: [PATCH 08/13] Add rewriteModuleWithAnalysis for hosts with their own
 parser

oxc has no error recovery, so `rewriteModuleStandalone` is a build-time
entry: a file with a script syntax error is emitted without import
bindings or placement and the type-checker reports the error. Say so.

An editor host (a content mapper on TypeScript 7's native compiler) has
a tolerant parse of the file already. `rewriteModuleWithAnalysis` takes
the same `ScriptAnalysis` (import bindings + template placements) from
the caller instead of from ember-estree; `rewriteModuleStandalone` is
now that with ember-estree's analysis plugged in. The analysis types are
exported from the standalone entrypoint, and a file content-tag finds no
templates in is not analyzed at all.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FsXgxh6vNRWMCNcAQ3g6TN
---
 .../template/rewrite-module-standalone.ts     | 94 ++++++++++++++-----
 .../transform/rewrite-standalone.test.ts      | 91 +++++++++++++++++-
 2 files changed, 159 insertions(+), 26 deletions(-)

diff --git a/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts b/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts
index bb763f717..5a71ae06d 100644
--- a/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts
+++ b/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts
@@ -4,6 +4,7 @@ import { GlintEnvironment } from '../../config/index.js';
 import type { PreprocessData } from '../../environment-ember-template-imports/-private/environment/common.js';
 import {
   EmbeddedTemplate,
+  ImportedBinding,
   ImportedBindings,
   PartialCorrelatedSpan,
   TemplateThisBinding,
@@ -19,25 +20,74 @@ import {
 } 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; `rewriteModuleStandalone` reads it off
+ * ember-estree's; a host with its own parser can supply it directly through
+ * `rewriteModuleWithAnalysis`.
+ */
+export type ScriptAnalysis = {
+  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>;
+};
+
+export type TemplatePlacement = {
+  thisBinding: TemplateThisBinding;
+  /**
+   * Whether the template is the whole of an expression statement: the RFC 931
+   * implicit `export default` form.
+   */
+  isExpressionStatement: boolean;
+};
+
+export type { EmbeddedTemplate, ImportedBinding, ImportedBindings, TemplateThisBinding };
+
 /**
  * Like `rewriteModule`, but without a TypeScript compiler API.
  *
- * `rewriteModule` parses the content-tag-preprocessed script with the
- * `TSLib` it is given and reads three things off the AST: where each
- * template sits, how its `{{this}}` binds, and which names the module imports.
- * Here the same facts come from the ESTree that `ember-estree` (content-tag +
- * oxc-parser) produces for the file, 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 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: on an unrecoverable error
+ * it yields an empty program (TypeScript's parser keeps going), and the
+ * templates in that file are then emitted without import bindings or
+ * placement. This entry is therefore meant for build-time use, where a file
+ * with a syntax error is reported by the type-checker and nothing else about
+ * it matters. An editor host that already has a tolerant parse of the file
+ * should feed its own analysis to `rewriteModuleWithAnalysis` instead.
  *
- * The output is identical to `rewriteModule`'s for the same input; the
- * language server, tsserver plugin and `ember-tsc` keep using `rewriteModule`.
- * Exposed only as `@glint/ember-tsc/transform/standalone` so that those paths
- * never load ember-estree (and oxc-parser's native binary).
+ * 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(
+  input: RewriteInput,
+  environment: GlintEnvironment,
+): TransformedModule | null {
+  return rewriteModuleWithAnalysis(input, environment, (contents, filename) =>
+    analyzeScript(contents, filename),
+  );
+}
+
+/**
+ * Like `rewriteModule`, with the script analysis supplied by the caller.
+ * content-tag still locates the templates; when it finds any, `analyze` is
+ * called once with the script's text and filename and returns the import
+ * bindings and template placements from whatever parse the host already has.
+ */
+export function rewriteModuleWithAnalysis(
   { script }: RewriteInput,
   environment: GlintEnvironment,
+  analyze: (contents: string, filename: string) => ScriptAnalysis,
 ): TransformedModule | null {
   let { filename, contents } = script;
   let { preprocess } = environment.getConfigForExtension(path.extname(filename)) ?? {};
@@ -58,7 +108,11 @@ export function rewriteModuleStandalone(
     return buildTransformedModule(script, { errors, directives, partialSpans });
   }
 
-  let { imports, placements } = analyzeScript(contents, filename);
+  if (!data.templateLocations.length) {
+    return null;
+  }
+
+  let { imports, placements } = analyze(contents, filename);
 
   for (let location of data.templateLocations) {
     let start = location.startTagOffset;
@@ -107,17 +161,6 @@ type ImportDeclaration = Node & {
 
 type ClassNode = Node & { superClass?: Node | null; implements?: Array<Node> };
 
-type Placement = {
-  thisBinding: TemplateThisBinding;
-  isExpressionStatement: boolean;
-};
-
-type ScriptAnalysis = {
-  imports: ImportedBindings;
-  /** Keyed by the offset of each template's `<template>` tag. */
-  placements: Map<number, Placement>;
-};
-
 // 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`.
@@ -125,11 +168,12 @@ const STATEMENT_LISTS = new Set(['Program', 'BlockStatement', 'StaticBlock', 'Sw
 
 /**
  * Reads import bindings and the syntactic placement of every template off
- * ember-estree's traversal of the module.
+ * 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, Placement>();
+  let placements = new Map<number, TemplatePlacement>();
 
   let place = (start: number, path: VisitorPath): void => {
     placements.set(start, {
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
index 166266308..8b637a89c 100644
--- a/test-packages/package-test-core/__tests__/transform/rewrite-standalone.test.ts
+++ b/test-packages/package-test-core/__tests__/transform/rewrite-standalone.test.ts
@@ -1,6 +1,11 @@
 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 {
+  rewriteModuleStandalone,
+  rewriteModuleWithAnalysis,
+  ScriptAnalysis,
+} from '@glint/ember-tsc/transform/standalone';
+import { templateThisBinding } from '@glint/ember-tsc/transform/template/inlining/index';
 import { stripIndent } from 'common-tags';
 import { readdirSync, readFileSync, statSync } from 'node:fs';
 import { join, relative, resolve } from 'node:path';
@@ -54,6 +59,90 @@ function collectTemplateFiles(dir: string, out: Array<string>): Array<string> {
   return out;
 }
 
+// A host with its own parser supplies the analysis. This one uses the
+// TypeScript AST of the raw .gts text (TS's parser recovers past the
+// `<template>` tags well enough to find imports and class bodies), which is
+// what an editor host on a TypeScript 7 native compiler would do with its
+// own tolerant parse.
+function analyzeWithTypescript(contents: string, filename: string): ScriptAnalysis {
+  let analysis: ScriptAnalysis = { imports: {}, placements: new Map() };
+  let sourceFile = ts.createSourceFile(filename, contents, ts.ScriptTarget.Latest, true);
+
+  for (let statement of sourceFile.statements) {
+    if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) {
+      continue;
+    }
+    let source = statement.moduleSpecifier.text;
+    let { importClause } = statement;
+    if (importClause?.name) {
+      analysis.imports[importClause.name.text] = { specifier: 'default', source, synthetic: false };
+    }
+    if (importClause?.namedBindings && ts.isNamedImports(importClause.namedBindings)) {
+      for (let binding of importClause.namedBindings.elements) {
+        analysis.imports[binding.name.text] = {
+          specifier: binding.propertyName?.text ?? binding.name.text,
+          source,
+          synthetic: false,
+        };
+      }
+    }
+  }
+
+  // `<template>` parses as a JSX-ish `<` expression; its node starts at the
+  // tag, which is all the placement map is keyed on.
+  let visit = (node: ts.Node): void => {
+    if (ts.isJsxElement(node) || ts.isJsxOpeningElement(node) || ts.isBinaryExpression(node)) {
+      let start = node.getStart(sourceFile);
+      if (contents.startsWith('<template>', start) && !analysis.placements.has(start)) {
+        analysis.placements.set(start, {
+          thisBinding: templateThisBinding(ts, node),
+          isExpressionStatement: ts.isExpressionStatement(node.parent),
+        });
+      }
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return analysis;
+}
+
+describe('Transform: rewriteModuleWithAnalysis', () => {
+  test('a host-supplied analysis drives the same emit', () => {
+    let script = {
+      filename: 'test.gts',
+      contents: stripIndent`
+        import Component from '@glimmer/component';
+        import { on } from '@ember/modifier';
+
+        export default class Example extends Component {
+          <template><button {{on "click" this.go}}>go</button></template>
+        }
+
+        export const Plain = <template>{{on}}</template>;
+      `,
+    };
+
+    let hosted = rewriteModuleWithAnalysis({ script }, env, analyzeWithTypescript);
+    let viaTypescript = rewriteModule(ts, { script }, env);
+
+    expect(hosted?.transformedContents).toEqual(viaTypescript?.transformedContents);
+    expect(hosted?.errors).toEqual([]);
+  });
+
+  test('a file without templates is not analyzed', () => {
+    let calls = 0;
+    let script = { filename: 'test.gts', contents: `export const x = 1;\n` };
+
+    let result = rewriteModuleWithAnalysis({ script }, env, () => {
+      calls++;
+      return { imports: {}, placements: new Map() };
+    });
+
+    expect(result).toBeNull();
+    expect(calls).toBe(0);
+  });
+});
+
 describe('Transform: rewriteModuleStandalone', () => {
   describe('matches rewriteModule on the test-packages corpus', () => {
     const root = resolve(__dirname, '..', '..', '..');

From 44f6089d0e1d34c04bd55858f28fd75d19174df2 Mon Sep 17 00:00:00 2001
From: NullVoxPopuli-ai-agent
 <268630448+NullVoxPopuli-ai-agent@users.noreply.github.com>
Date: Tue, 25 Aug 2026 09:50:55 -0400
Subject: [PATCH 09/13] Drop rewriteModuleWithAnalysis

The TypeScript content-mapper protocol hands a mapper only the file's
text, never the host's parse, so there is no caller with a tolerant
analysis to supply. Keep the seam internal and say plainly that an
editor still needs `rewriteModule` for mid-keystroke recovery.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FsXgxh6vNRWMCNcAQ3g6TN
---
 .../template/rewrite-module-standalone.ts     | 33 ++-----
 .../transform/rewrite-standalone.test.ts      | 91 +------------------
 2 files changed, 7 insertions(+), 117 deletions(-)

diff --git a/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts b/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts
index 5a71ae06d..b4eb6b588 100644
--- a/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts
+++ b/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts
@@ -4,7 +4,6 @@ import { GlintEnvironment } from '../../config/index.js';
 import type { PreprocessData } from '../../environment-ember-template-imports/-private/environment/common.js';
 import {
   EmbeddedTemplate,
-  ImportedBinding,
   ImportedBindings,
   PartialCorrelatedSpan,
   TemplateThisBinding,
@@ -23,11 +22,9 @@ import TransformedModule, { Directive, TransformError } from './transformed-modu
 /**
  * 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; `rewriteModuleStandalone` reads it off
- * ember-estree's; a host with its own parser can supply it directly through
- * `rewriteModuleWithAnalysis`.
+ * this off the TypeScript AST; this entry reads it off ember-estree's.
  */
-export type ScriptAnalysis = {
+type ScriptAnalysis = {
   imports: ImportedBindings;
   /**
    * Keyed by the offset of each template's `<template>` tag. A template with
@@ -37,7 +34,7 @@ export type ScriptAnalysis = {
   placements: Map<number, TemplatePlacement>;
 };
 
-export type TemplatePlacement = {
+type TemplatePlacement = {
   thisBinding: TemplateThisBinding;
   /**
    * Whether the template is the whole of an expression statement: the RFC 931
@@ -46,8 +43,6 @@ export type TemplatePlacement = {
   isExpressionStatement: boolean;
 };
 
-export type { EmbeddedTemplate, ImportedBinding, ImportedBindings, TemplateThisBinding };
-
 /**
  * Like `rewriteModule`, but without a TypeScript compiler API.
  *
@@ -62,32 +57,16 @@ export type { EmbeddedTemplate, ImportedBinding, ImportedBindings, TemplateThisB
  * templates in that file are then emitted without import bindings or
  * placement. This entry is therefore meant for build-time use, where a file
  * with a syntax error is reported by the type-checker and nothing else about
- * it matters. An editor host that already has a tolerant parse of the file
- * should feed its own analysis to `rewriteModuleWithAnalysis` instead.
+ * it matters. An editor that needs the transform to keep up mid-keystroke
+ * still needs TypeScript's recovering parser, i.e. `rewriteModule`.
  *
  * 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(
-  input: RewriteInput,
-  environment: GlintEnvironment,
-): TransformedModule | null {
-  return rewriteModuleWithAnalysis(input, environment, (contents, filename) =>
-    analyzeScript(contents, filename),
-  );
-}
-
-/**
- * Like `rewriteModule`, with the script analysis supplied by the caller.
- * content-tag still locates the templates; when it finds any, `analyze` is
- * called once with the script's text and filename and returns the import
- * bindings and template placements from whatever parse the host already has.
- */
-export function rewriteModuleWithAnalysis(
   { script }: RewriteInput,
   environment: GlintEnvironment,
-  analyze: (contents: string, filename: string) => ScriptAnalysis,
 ): TransformedModule | null {
   let { filename, contents } = script;
   let { preprocess } = environment.getConfigForExtension(path.extname(filename)) ?? {};
@@ -112,7 +91,7 @@ export function rewriteModuleWithAnalysis(
     return null;
   }
 
-  let { imports, placements } = analyze(contents, filename);
+  let { imports, placements } = analyzeScript(contents, filename);
 
   for (let location of data.templateLocations) {
     let start = location.startTagOffset;
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
index 8b637a89c..166266308 100644
--- a/test-packages/package-test-core/__tests__/transform/rewrite-standalone.test.ts
+++ b/test-packages/package-test-core/__tests__/transform/rewrite-standalone.test.ts
@@ -1,11 +1,6 @@
 import { GlintEnvironment } from '@glint/ember-tsc/config/index';
 import { rewriteModule } from '@glint/ember-tsc/transform/index';
-import {
-  rewriteModuleStandalone,
-  rewriteModuleWithAnalysis,
-  ScriptAnalysis,
-} from '@glint/ember-tsc/transform/standalone';
-import { templateThisBinding } from '@glint/ember-tsc/transform/template/inlining/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';
@@ -59,90 +54,6 @@ function collectTemplateFiles(dir: string, out: Array<string>): Array<string> {
   return out;
 }
 
-// A host with its own parser supplies the analysis. This one uses the
-// TypeScript AST of the raw .gts text (TS's parser recovers past the
-// `<template>` tags well enough to find imports and class bodies), which is
-// what an editor host on a TypeScript 7 native compiler would do with its
-// own tolerant parse.
-function analyzeWithTypescript(contents: string, filename: string): ScriptAnalysis {
-  let analysis: ScriptAnalysis = { imports: {}, placements: new Map() };
-  let sourceFile = ts.createSourceFile(filename, contents, ts.ScriptTarget.Latest, true);
-
-  for (let statement of sourceFile.statements) {
-    if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) {
-      continue;
-    }
-    let source = statement.moduleSpecifier.text;
-    let { importClause } = statement;
-    if (importClause?.name) {
-      analysis.imports[importClause.name.text] = { specifier: 'default', source, synthetic: false };
-    }
-    if (importClause?.namedBindings && ts.isNamedImports(importClause.namedBindings)) {
-      for (let binding of importClause.namedBindings.elements) {
-        analysis.imports[binding.name.text] = {
-          specifier: binding.propertyName?.text ?? binding.name.text,
-          source,
-          synthetic: false,
-        };
-      }
-    }
-  }
-
-  // `<template>` parses as a JSX-ish `<` expression; its node starts at the
-  // tag, which is all the placement map is keyed on.
-  let visit = (node: ts.Node): void => {
-    if (ts.isJsxElement(node) || ts.isJsxOpeningElement(node) || ts.isBinaryExpression(node)) {
-      let start = node.getStart(sourceFile);
-      if (contents.startsWith('<template>', start) && !analysis.placements.has(start)) {
-        analysis.placements.set(start, {
-          thisBinding: templateThisBinding(ts, node),
-          isExpressionStatement: ts.isExpressionStatement(node.parent),
-        });
-      }
-    }
-    ts.forEachChild(node, visit);
-  };
-  visit(sourceFile);
-  return analysis;
-}
-
-describe('Transform: rewriteModuleWithAnalysis', () => {
-  test('a host-supplied analysis drives the same emit', () => {
-    let script = {
-      filename: 'test.gts',
-      contents: stripIndent`
-        import Component from '@glimmer/component';
-        import { on } from '@ember/modifier';
-
-        export default class Example extends Component {
-          <template><button {{on "click" this.go}}>go</button></template>
-        }
-
-        export const Plain = <template>{{on}}</template>;
-      `,
-    };
-
-    let hosted = rewriteModuleWithAnalysis({ script }, env, analyzeWithTypescript);
-    let viaTypescript = rewriteModule(ts, { script }, env);
-
-    expect(hosted?.transformedContents).toEqual(viaTypescript?.transformedContents);
-    expect(hosted?.errors).toEqual([]);
-  });
-
-  test('a file without templates is not analyzed', () => {
-    let calls = 0;
-    let script = { filename: 'test.gts', contents: `export const x = 1;\n` };
-
-    let result = rewriteModuleWithAnalysis({ script }, env, () => {
-      calls++;
-      return { imports: {}, placements: new Map() };
-    });
-
-    expect(result).toBeNull();
-    expect(calls).toBe(0);
-  });
-});
-
 describe('Transform: rewriteModuleStandalone', () => {
   describe('matches rewriteModule on the test-packages corpus', () => {
     const root = resolve(__dirname, '..', '..', '..');

From dfcdad81ced7b889acf708f4fdf7c62985f6fcd6 Mon Sep 17 00:00:00 2001
From: NullVoxPopuli-ai-agent
 <268630448+NullVoxPopuli-ai-agent@users.noreply.github.com>
Date: Tue, 25 Aug 2026 10:00:06 -0400
Subject: [PATCH 10/13] Clarify which editors get parser recovery

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FsXgxh6vNRWMCNcAQ3g6TN
---
 .../transform/template/rewrite-module-standalone.ts  | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts b/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts
index b4eb6b588..480172d5a 100644
--- a/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts
+++ b/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts
@@ -55,10 +55,14 @@ type TemplatePlacement = {
  * oxc does not recover from script syntax errors: on an unrecoverable error
  * it yields an empty program (TypeScript's parser keeps going), and the
  * templates in that file are then emitted without import bindings or
- * placement. This entry is therefore meant for build-time use, where a file
- * with a syntax error is reported by the type-checker and nothing else about
- * it matters. An editor that needs the transform to keep up mid-keystroke
- * still needs TypeScript's recovering parser, i.e. `rewriteModule`.
+ * placement. At build time that is fine: the type-checker reports the syntax
+ * error and nothing else about the file matters. In an editor it means the
+ * templates of a file lose their imports and `this` binding while the script
+ * is mid-edit. Glint's own editor paths (the Volar language server and the
+ * tsserver plugin) run inside TypeScript and use `rewriteModule`, whose
+ * parser recovers. A TypeScript 7 content mapper has no such parser and
+ * should treat a file with script errors as stale (ember-estree reports them
+ * on `ast.errors`) rather than serve a degraded transform for it.
  *
  * Exposed only as `@glint/ember-tsc/transform/standalone` so that the
  * language server, tsserver plugin and `ember-tsc` never load ember-estree

From 4d439d31df37bd4aafbc49f84fc57f14934d5184 Mon Sep 17 00:00:00 2001
From: NullVoxPopuli-ai-agent
 <268630448+NullVoxPopuli-ai-agent@users.noreply.github.com>
Date: Tue, 25 Aug 2026 12:55:46 -0400
Subject: [PATCH 11/13] Fall back to the raw source when oxc reports script
 errors

Mid-keystroke, a broken script already goes one of two ways on the TS
path: content-tag fails and the raw source is kept with verification
off so the type-checker's recovering parser powers completions, or swc
tolerates it and the templates are emitted normally. oxc tolerates less
than swc, so the standalone entry had a third mode in between: templates
emitted with no import bindings or placement. Collapse it into the
first: when ember-estree reports script errors (ast.errors,
NullVoxPopuli/ember-estree#81), record one as a content-tag-style error
and keep the raw source, exactly as on content-tag failure.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FsXgxh6vNRWMCNcAQ3g6TN
---
 .../template/rewrite-module-standalone.ts     | 46 +++++++++++++------
 .../transform/rewrite-standalone.test.ts      | 21 +++++----
 2 files changed, 43 insertions(+), 24 deletions(-)

diff --git a/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts b/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts
index 480172d5a..176e156fe 100644
--- a/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts
+++ b/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts
@@ -25,6 +25,8 @@ import TransformedModule, { Directive, TransformError } from './transformed-modu
  * 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
@@ -34,6 +36,8 @@ type ScriptAnalysis = {
   placements: Map<number, TemplatePlacement>;
 };
 
+type ScriptError = { message: string; labels?: Array<{ start: number; end: number }> };
+
 type TemplatePlacement = {
   thisBinding: TemplateThisBinding;
   /**
@@ -52,17 +56,13 @@ type TemplatePlacement = {
  * 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: on an unrecoverable error
- * it yields an empty program (TypeScript's parser keeps going), and the
- * templates in that file are then emitted without import bindings or
- * placement. At build time that is fine: the type-checker reports the syntax
- * error and nothing else about the file matters. In an editor it means the
- * templates of a file lose their imports and `this` binding while the script
- * is mid-edit. Glint's own editor paths (the Volar language server and the
- * tsserver plugin) run inside TypeScript and use `rewriteModule`, whose
- * parser recovers. A TypeScript 7 content mapper has no such parser and
- * should treat a file with script errors as stale (ember-estree reports them
- * on `ast.errors`) rather than serve a degraded transform for it.
+ * 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
@@ -95,7 +95,22 @@ export function rewriteModuleStandalone(
     return null;
   }
 
-  let { imports, placements } = analyzeScript(contents, filename);
+  let { errors: scriptErrors, imports, placements } = analyzeScript(contents, 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;
@@ -157,6 +172,7 @@ const STATEMENT_LISTS = new Set(['Program', 'BlockStatement', 'StaticBlock', 'Sw
 function analyzeScript(contents: string, filename: string): ScriptAnalysis {
   let imports: ImportedBindings = {};
   let placements = new Map<number, TemplatePlacement>();
+  let errors: Array<ScriptError> = [];
 
   let place = (start: number, path: VisitorPath): void => {
     placements.set(start, {
@@ -165,7 +181,7 @@ function analyzeScript(contents: string, filename: string): ScriptAnalysis {
     });
   };
 
-  toTree(contents, {
+  let file = toTree(contents, {
     filePath: filename,
     visitors: {
       ImportDeclaration(node) {
@@ -182,7 +198,9 @@ function analyzeScript(contents: string, filename: string): ScriptAnalysis {
     },
   });
 
-  return { imports, placements };
+  if ('errors' in file) errors = file.errors as Array<ScriptError>;
+
+  return { errors, imports, placements };
 }
 
 function* ancestorsOf(path: VisitorPath): Generator<ThisBindingAncestor> {
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
index 166266308..fe7ef4a15 100644
--- a/test-packages/package-test-core/__tests__/transform/rewrite-standalone.test.ts
+++ b/test-packages/package-test-core/__tests__/transform/rewrite-standalone.test.ts
@@ -227,13 +227,12 @@ describe('Transform: rewriteModuleStandalone', () => {
       );
     });
 
-    test('script syntax error still emits the template', () => {
-      // oxc-parser yields an empty program on an unrecoverable script error
-      // (TypeScript's parser is more tolerant), so import bindings and
-      // template placement are unavailable: content-tag still classifies the
-      // class member, and `fn` is emitted as a bare identifier, which
-      // resolves lexically to the import. The syntax error itself is
-      // reported by whichever type-checker consumes the output.
+    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`
@@ -247,9 +246,11 @@ describe('Transform: rewriteModuleStandalone', () => {
 
       let standalone = rewriteModuleStandalone({ script }, env);
 
-      expect(standalone?.errors).toEqual([]);
-      expect(standalone?.transformedContents).toContain('templateForBackingValue(this');
-      expect(standalone?.transformedContents).toContain('__glintDSL__.resolve(fn)(');
+      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', () => {

From 2d9caffb174cd4eac62338ea4425659a388f29d5 Mon Sep 17 00:00:00 2001
From: NullVoxPopuli-ai-agent
 <268630448+NullVoxPopuli-ai-agent@users.noreply.github.com>
Date: Tue, 25 Aug 2026 14:00:09 -0400
Subject: [PATCH 12/13] Blank template bodies before the ember-estree analysis

Only the script is analyzed there; the templates are parsed (and their
errors reported) by calculateTemplateSpans. Replacing each body with
same-length whitespace keeps every offset, spares ember-estree a second
handlebars parse per template, and means a template that does not parse
cannot abort the analysis, so the onTemplateError option is not needed.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FsXgxh6vNRWMCNcAQ3g6TN
---
 .../template/rewrite-module-standalone.ts     | 44 +++++++++++++------
 1 file changed, 30 insertions(+), 14 deletions(-)

diff --git a/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts b/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts
index 176e156fe..4cc06486c 100644
--- a/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts
+++ b/packages/ember-tsc/src/transform/template/rewrite-module-standalone.ts
@@ -95,7 +95,11 @@ export function rewriteModuleStandalone(
     return null;
   }
 
-  let { errors: scriptErrors, imports, placements } = analyzeScript(contents, filename);
+  let {
+    errors: scriptErrors,
+    imports,
+    placements,
+  } = analyzeScript(blankTemplateBodies(contents, data), filename);
 
   if (scriptErrors.length) {
     let [{ message, labels }] = scriptErrors;
@@ -164,6 +168,27 @@ type ClassNode = Node & { superClass?: Node | null; implements?: Array<Node> };
 // 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
@@ -174,13 +199,6 @@ function analyzeScript(contents: string, filename: string): ScriptAnalysis {
   let placements = new Map<number, TemplatePlacement>();
   let errors: Array<ScriptError> = [];
 
-  let place = (start: number, path: VisitorPath): void => {
-    placements.set(start, {
-      thisBinding: thisBindingFromAncestors(ancestorsOf(path)),
-      isExpressionStatement: isExpressionStatement(path),
-    });
-  };
-
   let file = toTree(contents, {
     filePath: filename,
     visitors: {
@@ -188,14 +206,12 @@ function analyzeScript(contents: string, filename: string): ScriptAnalysis {
         collectImportedBindings(node as ImportDeclaration, imports);
       },
       GlimmerTemplate(node, path) {
-        place(node.start as number, path);
+        placements.set(node.start as number, {
+          thisBinding: thisBindingFromAncestors(ancestorsOf(path)),
+          isExpressionStatement: isExpressionStatement(path),
+        });
       },
     },
-    // A template that fails to parse still sits somewhere; the error itself
-    // is reported by `calculateTemplateSpans`, which parses it again.
-    onTemplateError(_error, { range, path }) {
-      place(range[0], path);
-    },
   });
 
   if ('errors' in file) errors = file.errors as Array<ScriptError>;

From 0eefe8b0ddf193cd114f384d3b5a69a3e7d17e7d Mon Sep 17 00:00:00 2001
From: NullVoxPopuli-ai-agent
 <268630448+NullVoxPopuli-ai-agent@users.noreply.github.com>
Date: Tue, 25 Aug 2026 14:15:14 -0400
Subject: [PATCH 13/13] Bump ember-estree to 0.8.0

Released with the export default wrapper fix (#82) and ast.errors (#81).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FsXgxh6vNRWMCNcAQ3g6TN
---
 packages/ember-tsc/package.json |  2 +-
 pnpm-lock.yaml                  | 10 +++++-----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/packages/ember-tsc/package.json b/packages/ember-tsc/package.json
index cf65016a2..02160a8c1 100644
--- a/packages/ember-tsc/package.json
+++ b/packages/ember-tsc/package.json
@@ -91,7 +91,7 @@
     "@volar/test-utils": "~2.4.28",
     "@volar/typescript": "~2.4.28",
     "content-tag": "^4.2.0",
-    "ember-estree": "^0.7.1",
+    "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/pnpm-lock.yaml b/pnpm-lock.yaml
index fa14d768a..cdc6c8e4f 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -117,8 +117,8 @@ importers:
         specifier: ^4.2.0
         version: 4.2.0
       ember-estree:
-        specifier: ^0.7.1
-        version: 0.7.1
+        specifier: ^0.8.0
+        version: 0.8.0
       silent-error:
         specifier: ^1.1.1
         version: 1.1.1
@@ -4528,8 +4528,8 @@ packages:
       '@typescript-eslint/parser':
         optional: true
 
-  ember-estree@0.7.1:
-    resolution: {integrity: sha512-5BRJbX2bL9YE+SPsRLWxYNzIZ7VtRAuj/50g5N28Ig93RFkbxySlUKsdDZUj0ZYwCrGUljSNzr4BPdaJEoiGkA==}
+  ember-estree@0.8.0:
+    resolution: {integrity: sha512-FvH2jGEkcIMPDPgQLHFVSTyF5p7HscVIiJ36v6ce1C9q/6KXCcE0EB2idaGcDWlhB42I3PmLg+vLbUp2GIznBQ==}
 
   ember-modifier@4.2.0:
     resolution: {integrity: sha512-BJ48eTEGxD8J7+lofwVmee7xDgNDgpr5dd6+MSu4gk+I6xb35099RMNorXY5hjjwMJEyi/IRR6Yn3M7iJMz8Zw==}
@@ -13892,7 +13892,7 @@ snapshots:
       - eslint
       - typescript
 
-  ember-estree@0.7.1:
+  ember-estree@0.8.0:
     dependencies:
       '@glimmer/env': 0.1.7
       '@glimmer/syntax': 0.95.0