diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
index fa45db80f..c4bf68164 100644
--- a/ARCHITECTURE.md
+++ b/ARCHITECTURE.md
@@ -57,12 +57,13 @@ Glint implements two VirtualCodes in order to provide Language Tooling for moder
     - Ideally every Ember app will migrate to .gts but we still need to support classic components until that time comes
   - The backing .ts file is already type-checkable on its own, but for type-checking an .hbs file:
     - This Virtual Code will combine the .hbs+.ts and generate a singular type-checkable TS file in a similar mapping structure as `VirtualGtsCode` mentioned above
+Any VirtualCode, whether implemented by Glint or Vue tooling, essentially takes a language that embeds other languages (.gts is TS with embedded Glimmer, .vue has `<script>` + `<template>` + `<style>` tags, etc.) and produces a tree of embedded codes where the "leaves" of that tree are simpler, single-language codes (that don't include any other embedded languages). These single-language "leaves" can then be used as inputs for a variety of Language Services (see below), either ones already provided by Volar or custom ones implemented by Glint.
 
-Any VirtualCode, whether implemented by Glint or Vue tooling, essentially takes a language that embeds other languages (.gts is TS with embedded Glimmer, .vue has `<script>` +`<template>`+`<style>` tags, etc), and produces a tree of embedded codes where the "leaves" of that tree are simpler, single-language codes (that don't include any other embedded languages). These single-language "leaves" can then be used as inputs for a variety of Language Services, either ones already provided by Volar or custom ones implemented by Glint.
+## Core Primitive: Language Service
 
-Language Services operate on singular languages, e.g. a Language Service could be used to implement code completions in HTML, or to provide formatting in CSS, etc. Volar makes it possible/easy for Language Services to operate on the single-language "leaves" of your VirtualCode tree, and then, using the source maps that were built up as part of the VirtualCode implementation, reverse-source map those transformations, diagnostics, code hints, etc, back to the source file.
+Language Services operate on singular languages; for example, a Language Service could be used to implement code completions in HTML or provide formatting in CSS. Volar makes it possible and easy for Language Services to operate on the single-language "leaves" of your VirtualCode tree, and then, using the source maps that were built up as part of the VirtualCode implementation, reverse-source map those transformations, diagnostics, code hints, etc., back to the source file.
 
-NOTE: at the time of writing, I don't believe Glint is currently making use of Language Services due to the fact that Glint primarily has been concerned with providing TS functionality to Ember/Glimmer templates, and most of that logic has been shifted towards the Glint TS Plugin (described below). If it is decided to enhance Glint functionality, or perhaps merge it into Ember Language Server (something that has been discussed), then likely more of the Language Service framework/infrastructure will be used.
+Volar.js maintains a number of [shared Language Plugins](https://github.com/volarjs/services/tree/master/packages) that can be consumed by many different language tooling systems (Vue, MDX, Astro, Glint, etc.). For example, while Glint uses a TS Plugin for diagnostics, there are some TS features that still require using the Volar TS LanguageService. For instance, to provide Symbols (which drive the Outline panel in VSCode, among other things), Glint uses a lightweight syntax-only TS Language Service provided by Volar.
 
 ## Glint V2 Moves Type-Checking Features out from Language Server and into TS Plugin
 
diff --git a/packages/core/package.json b/packages/core/package.json
index bd1ec0328..efc653542 100644
--- a/packages/core/package.json
+++ b/packages/core/package.json
@@ -54,6 +54,7 @@
     "silent-error": "^1.1.1",
     "uuid": "^8.3.2",
     "volar-service-typescript": "volar-2.4",
+    "volar-service-html": "volar-2.4",
     "vscode-languageserver-protocol": "^3.17.5",
     "vscode-languageserver-textdocument": "^1.0.5",
     "vscode-uri": "^3.0.8",
diff --git a/packages/core/src/plugins/gts-gjs-plugin.ts b/packages/core/src/plugins/gts-gjs-plugin.ts
new file mode 100644
index 000000000..216d7822d
--- /dev/null
+++ b/packages/core/src/plugins/gts-gjs-plugin.ts
@@ -0,0 +1,197 @@
+import type { LanguageServiceContext, LanguageServicePlugin } from '@volar/language-service';
+import { VirtualGtsCode } from '../volar/gts-virtual-code.js';
+import type * as vscode from 'vscode-languageserver-protocol';
+import type { TextDocument } from 'vscode-languageserver-textdocument';
+import { URI } from 'vscode-uri';
+
+/**
+ * This is a LanguageServicePlugin that provides language features for the top-level .gts/.gjs files.
+ * For now, this just provides document symbols for `<template>` tags, which are a language
+ * construct specific to .gts/.gjs files. Note that .gts/.gjs files will have TypeScript symbols
+ * provided by our syntactic TS LanguageServicePlugin configured elsewhere, and these will be
+ * combined with the symbols provided here.
+ */
+export function create(): LanguageServicePlugin {
+  return {
+    name: 'gts-gjs',
+    capabilities: {
+      documentSymbolProvider: true,
+    },
+    create(context) {
+      return {
+        provideDocumentSymbols(document) {
+          return worker(document, context, (root) => {
+            const result: vscode.DocumentSymbol[] = [];
+            const { transformedModule } = root;
+
+            if (transformedModule) {
+              const templateSymbols = transformedModule.templateSymbols();
+              for (const templateSymbol of templateSymbols) {
+                result.push({
+                  name: 'template',
+                  kind: 2 satisfies typeof vscode.SymbolKind.Module,
+                  range: {
+                    start: document.positionAt(templateSymbol.start),
+                    end: document.positionAt(templateSymbol.end),
+                  },
+                  selectionRange: {
+                    start: document.positionAt(templateSymbol.start),
+                    end: document.positionAt(templateSymbol.startTagEnd),
+                  },
+                });
+              }
+            }
+
+            return result;
+          });
+        },
+
+        // TODO: this is copied from Vue; this might be the proper way for surfacing Glimmer syntax parsing errors to the top-level .gts file.
+        // provideDiagnostics(document, token) {
+        //   return worker(document, context, async (root) => {
+        //     const { vueSfc, sfc } = root;
+        //     if (!vueSfc) {
+        //       return;
+        //     }
+
+        //     const originalResult = await htmlServiceInstance.provideDiagnostics?.(document, token);
+        //     const sfcErrors: vscode.Diagnostic[] = [];
+        //     const { template } = sfc;
+
+        //     const { startTagEnd = Infinity, endTagStart = -Infinity } = template ?? {};
+
+        //     for (const error of vueSfc.errors) {
+        //       if ('code' in error) {
+        //         const start = error.loc?.start.offset ?? 0;
+        //         const end = error.loc?.end.offset ?? 0;
+        //         if (end < startTagEnd || start >= endTagStart) {
+        //           sfcErrors.push({
+        //             range: {
+        //               start: document.positionAt(start),
+        //               end: document.positionAt(end),
+        //             },
+        //             severity: 1 satisfies typeof vscode.DiagnosticSeverity.Error,
+        //             code: error.code,
+        //             source: 'vue',
+        //             message: error.message,
+        //           });
+        //         }
+        //       }
+        //     }
+
+        //     return [...(originalResult ?? []), ...sfcErrors];
+        //   });
+        // },
+
+        // TODO: this is copied from Vue; this might be a good place to implement auto-completing
+        // the `<template>` tag and other top-level concerns for .gts files
+
+        // async provideCompletionItems(document, position, context, token) {
+        //   const result = await htmlServiceInstance.provideCompletionItems?.(
+        //     document,
+        //     position,
+        //     context,
+        //     token,
+        //   );
+        //   if (!result) {
+        //     return;
+        //   }
+        //   result.items = result.items.filter(
+        //     (item) =>
+        //       item.label !== '!DOCTYPE' && item.label !== 'Custom Blocks' && item.label !== 'data-',
+        //   );
+
+        //   const tags = sfcDataProvider?.provideTags();
+
+        //   const scriptLangs = getLangs('script');
+        //   const scriptItems = result.items.filter(
+        //     (item) => item.label === 'script' || item.label === 'script setup',
+        //   );
+        //   for (const scriptItem of scriptItems) {
+        //     scriptItem.kind = 17 satisfies typeof vscode.CompletionItemKind.File;
+        //     scriptItem.detail = '.js';
+        //     for (const lang of scriptLangs) {
+        //       result.items.push({
+        //         ...scriptItem,
+        //         detail: `.${lang}`,
+        //         kind: 17 satisfies typeof vscode.CompletionItemKind.File,
+        //         label: scriptItem.label + ' lang="' + lang + '"',
+        //         textEdit: scriptItem.textEdit
+        //           ? {
+        //               ...scriptItem.textEdit,
+        //               newText: scriptItem.textEdit.newText + ' lang="' + lang + '"',
+        //             }
+        //           : undefined,
+        //       });
+        //     }
+        //   }
+
+        //   const styleLangs = getLangs('style');
+        //   const styleItem = result.items.find((item) => item.label === 'style');
+        //   if (styleItem) {
+        //     styleItem.kind = 17 satisfies typeof vscode.CompletionItemKind.File;
+        //     styleItem.detail = '.css';
+        //     for (const lang of styleLangs) {
+        //       result.items.push(
+        //         getStyleCompletionItem(styleItem, lang),
+        //         getStyleCompletionItem(styleItem, lang, 'scoped'),
+        //         getStyleCompletionItem(styleItem, lang, 'module'),
+        //       );
+        //     }
+        //   }
+
+        //   const templateLangs = getLangs('template');
+        //   const templateItem = result.items.find((item) => item.label === 'template');
+        //   if (templateItem) {
+        //     templateItem.kind = 17 satisfies typeof vscode.CompletionItemKind.File;
+        //     templateItem.detail = '.html';
+        //     for (const lang of templateLangs) {
+        //       if (lang === 'html') {
+        //         continue;
+        //       }
+        //       result.items.push({
+        //         ...templateItem,
+        //         kind: 17 satisfies typeof vscode.CompletionItemKind.File,
+        //         detail: `.${lang}`,
+        //         label: templateItem.label + ' lang="' + lang + '"',
+        //         textEdit: templateItem.textEdit
+        //           ? {
+        //               ...templateItem.textEdit,
+        //               newText: templateItem.textEdit.newText + ' lang="' + lang + '"',
+        //             }
+        //           : undefined,
+        //       });
+        //     }
+        //   }
+        //   return result;
+
+        //   function getLangs(label: string) {
+        //     return (
+        //       tags
+        //         ?.find((tag) => tag.name === label)
+        //         ?.attributes.find((attr) => attr.name === 'lang')
+        //         ?.values?.map(({ name }) => name) ?? []
+        //     );
+        //   }
+        // },
+      };
+    },
+  };
+
+  function worker<T>(
+    document: TextDocument,
+    context: LanguageServiceContext,
+    callback: (root: VirtualGtsCode) => T,
+  ): T | undefined {
+    if (document.languageId !== 'glimmer-ts' && document.languageId !== 'glimmer-js') {
+      return;
+    }
+    const uri = URI.parse(document.uri);
+    const decoded = context.decodeEmbeddedDocumentUri(uri);
+    const sourceScript = decoded && context.language.scripts.get(decoded[0]);
+    const root = sourceScript?.generated?.root;
+    if (root instanceof VirtualGtsCode) {
+      return callback(root);
+    }
+  }
+}
diff --git a/packages/core/src/transform/template/transformed-module.ts b/packages/core/src/transform/template/transformed-module.ts
index 663c19f69..9c89a7b51 100644
--- a/packages/core/src/transform/template/transformed-module.ts
+++ b/packages/core/src/transform/template/transformed-module.ts
@@ -44,6 +44,12 @@ export type SourceFile = {
   contents: string;
 };
 
+export type TemplateSymbol = {
+  start: number;
+  end: number;
+  startTagEnd: number;
+};
+
 /**
  * This class represents the result of transforming a TypeScript
  * module with one or more embedded HBS templates. It contains
@@ -61,7 +67,7 @@ export default class TransformedModule {
     public readonly transformedContents: string,
     public readonly errors: ReadonlyArray<TransformError>,
     public readonly directives: ReadonlyArray<Directive>,
-    private readonly correlatedSpans: Array<CorrelatedSpan>,
+    public readonly correlatedSpans: Array<CorrelatedSpan>,
   ) {}
 
   public toDebugString(): string {
@@ -334,11 +340,31 @@ export default class TransformedModule {
           // TODO: audit usage of `codeFeatures.all` here: https://github.com/typed-ember/glint/issues/769
           // There are cases where we need to be disabling certain features to prevent, e.g., navigation
           // that targets an "in-between" piece of generated code.
-          push(span.originalStart, span.transformedStart, span.originalLength, codeFeatures.all);
+          push(span.originalStart, span.transformedStart, span.originalLength, {
+            ...codeFeatures.all,
+
+            // This enables symbol/outline info for the transformed TS to appear in for the .gts file.
+            structure: true,
+          });
         }
       }
     });
 
     return codeMappings;
   }
+
+  templateSymbols(): Array<TemplateSymbol> {
+    const result: Array<TemplateSymbol> = [];
+    this.correlatedSpans.forEach((span) => {
+      if (span.glimmerAstMapping) {
+        // This is a template span
+        result.push({
+          start: span.originalStart,
+          end: span.originalStart + span.originalLength,
+          startTagEnd: span.originalStart + span.originalLength,
+        });
+      }
+    });
+    return result;
+  }
 }
diff --git a/packages/core/src/volar/gts-virtual-code.ts b/packages/core/src/volar/gts-virtual-code.ts
index d39f7cbdb..2fa4c049f 100644
--- a/packages/core/src/volar/gts-virtual-code.ts
+++ b/packages/core/src/volar/gts-virtual-code.ts
@@ -145,7 +145,7 @@ export class VirtualGtsCode implements VirtualCode {
       // .gts file has embedded templates, so lets generate a new embedded code
       // that contains the transformed TS code.
       const mappings = transformedModule.toVolarMappings();
-      this.embeddedCodes = [
+      const embeddedCodes = [
         {
           embeddedCodes: [],
           id: 'ts',
@@ -155,6 +155,49 @@ export class VirtualGtsCode implements VirtualCode {
           directives: transformedModule.directives,
         },
       ];
+
+      // Add an embedded code for each <template> tag in the .gts file
+      // so that the HTML Language Service can kick in and provide symbols
+      // and other functionality.
+      transformedModule.correlatedSpans.forEach((span, index) => {
+        if (!span.glimmerAstMapping) {
+          return;
+        }
+
+        const openTemplateTagLength = 10; // "<template>"
+        const closeTemplateTagLength = 11; // "</template>"
+
+        embeddedCodes.push({
+          embeddedCodes: [],
+          id: `template_html_${index}`,
+          languageId: 'html', // technically this is 'handlebars' but 'html' causes the HTML Language Service to kick in
+          mappings: [
+            {
+              sourceOffsets: [span.originalStart + openTemplateTagLength],
+              generatedOffsets: [0],
+              lengths: [span.originalLength - openTemplateTagLength - closeTemplateTagLength],
+
+              data: {
+                completion: true,
+                format: true,
+                navigation: true,
+                semantic: true,
+                structure: true,
+                verification: false,
+              } satisfies CodeInformation,
+            },
+          ],
+          snapshot: new ScriptSnapshot(
+            contents.slice(
+              span.originalStart + openTemplateTagLength,
+              span.originalStart + span.originalLength - closeTemplateTagLength,
+            ),
+          ),
+          directives: [],
+        });
+      });
+
+      this.embeddedCodes = embeddedCodes;
     } else {
       // Null transformed module means there's no embedded HBS templates,
       // so just return a full "no-op" mapping from source to transformed.
diff --git a/packages/core/src/volar/language-server.ts b/packages/core/src/volar/language-server.ts
index ffab5a5bb..d81fd0b62 100644
--- a/packages/core/src/volar/language-server.ts
+++ b/packages/core/src/volar/language-server.ts
@@ -1,4 +1,4 @@
-import type { LanguageServer } from '@volar/language-server';
+import type { LanguagePlugin, LanguageServer } from '@volar/language-server';
 import { createLanguageServiceEnvironment } from '@volar/language-server/lib/project/simpleProject.js';
 import { createConnection, createServer, loadTsdkByPath } from '@volar/language-server/node.js';
 import { createLanguage } from '@volar/language-core';
@@ -8,6 +8,9 @@ import { URI } from 'vscode-uri';
 import { createEmberLanguagePlugin } from './ember-language-plugin.js';
 import { ConfigLoader } from '../config/loader.js';
 import type { LanguageServiceContext, LanguageServicePlugin } from '@volar/language-service';
+import { create as createGtsGjsPlugin } from '../plugins/gts-gjs-plugin.js';
+import { create as createTypeScriptSyntacticPlugin } from 'volar-service-typescript/lib/plugins/syntactic.js';
+import { create as createHtmlSyntacticPlugin } from 'volar-service-html';
 
 type GlintInitializationOptions = any; // TODO rm hackiness
 
@@ -28,13 +31,11 @@ connection.onInitialize((params) => {
     throw new Error('typescript.tsdk is required');
   }
 
-  // TODO: Perform Vue-style proxying to tsserver instance
-  // See: https://github.com/vuejs/language-tools/pull/5252
-  // if (!options.typescript?.requestForwardingCommand) {
-  //   connection.console.warn(
-  //     'typescript.requestForwardingCommand is required since >= 3.0 for complete TS features',
-  //   );
-  // }
+  if (!options.typescript?.tsserverRequestCommand) {
+    connection.console.warn(
+      'typescript.tsserverRequestCommand is required since Glint V2 for complete TS features',
+    );
+  }
 
   const { typescript: ts } = loadTsdkByPath(options.typescript.tsdk, params.locale);
   const tsconfigProjects = createUriMap<LanguageService>();
@@ -56,7 +57,8 @@ connection.onInitialize((params) => {
     {
       setup() {},
       async getLanguageService(uri) {
-        if (uri.scheme === 'file' && options.typescript.requestForwardingCommand) {
+        if (uri.scheme === 'file' && options.typescript.tsserverRequestCommand) {
+          // Use tsserver to find the tsconfig governing this file.
           const fileName = uri.fsPath.replace(/\\/g, '/');
           const projectInfo = await sendTsRequest<ts.server.protocol.ProjectInfo>(
             ts.server.protocol.CommandTypes.ProjectInfo,
@@ -69,7 +71,7 @@ connection.onInitialize((params) => {
             const { configFileName } = projectInfo;
             let ls = tsconfigProjects.get(URI.file(configFileName));
             if (!ls) {
-              ls = createLs(server, configFileName);
+              ls = createLanguageServiceHelper(server, configFileName);
               tsconfigProjects.set(URI.file(configFileName), ls);
             }
             return ls;
@@ -77,7 +79,7 @@ connection.onInitialize((params) => {
         }
         // TODO: this branch is hit when running Volar Labs and currently breaks. Figure out
         // how to reinstate a "simple" LS without a tsconfig.
-        return (simpleLs ??= createLs(server, undefined));
+        return (simpleLs ??= createLanguageServiceHelper(server, undefined));
       },
       getExistingLanguageServices() {
         return Promise.all([...tsconfigProjects.values(), simpleLs].filter((promise) => !!promise));
@@ -92,7 +94,7 @@ connection.onInitialize((params) => {
     },
     getHybridModeLanguageServicePluginsForLanguageServer(
       ts,
-      options.typescript.requestForwardingCommand
+      options.typescript.tsserverRequestCommand
         ? {
             // TODO: Perform Vue-style proxying to tsserver instance
             // See: https://github.com/vuejs/language-tools/pull/5252
@@ -133,45 +135,41 @@ connection.onInitialize((params) => {
   );
 
   function sendTsRequest<T>(command: string, args: any): Promise<T | null> {
-    return connection.sendRequest<T>(options.typescript.requestForwardingCommand!, [command, args]);
+    return connection.sendRequest<T>(options.typescript.tsserverRequestCommand!, [command, args]);
   }
 
-  function createLs(server: LanguageServer, tsconfigFileName: string | undefined): LanguageService {
-    if (!tsconfigFileName) {
-      throw new Error('tsconfigFileName is required');
-    }
-
-    const configLoader = new ConfigLoader();
-    const glintConfig = configLoader.configForFile(tsconfigFileName);
+  function createLanguageServiceHelper(
+    server: LanguageServer,
+    tsconfigFileName: string | undefined,
+  ): LanguageService {
+    const languagePlugins: LanguagePlugin<URI>[] = [
+      {
+        getLanguageId: (uri) => server.documents.get(uri)?.languageId,
+      },
+    ];
 
-    if (!glintConfig) {
-      throw new Error('glintConfig is required');
+    if (tsconfigFileName) {
+      const configLoader = new ConfigLoader();
+      const glintConfig = configLoader.configForFile(tsconfigFileName);
+      if (glintConfig) {
+        const emberLanguagePlugin = createEmberLanguagePlugin(glintConfig);
+        languagePlugins.push(emberLanguagePlugin);
+      }
     }
 
-    const emberLanguagePlugin = createEmberLanguagePlugin(glintConfig);
-    const language = createLanguage<URI>(
-      [
-        {
-          getLanguageId: (uri) => server.documents.get(uri)?.languageId,
-        },
-        emberLanguagePlugin,
-      ],
-      createUriMap(),
-      (uri) => {
-        const document = server.documents.get(uri);
-        if (document) {
-          language.scripts.set(uri, document.getSnapshot(), document.languageId);
-        } else {
-          language.scripts.delete(uri);
-        }
-      },
-    );
+    const language = createLanguage<URI>(languagePlugins, createUriMap(), (uri) => {
+      const document = server.documents.get(uri);
+      if (document) {
+        language.scripts.set(uri, document.getSnapshot(), document.languageId);
+      } else {
+        language.scripts.delete(uri);
+      }
+    });
     return createLanguageService(
       language,
       server.languageServicePlugins,
       createLanguageServiceEnvironment(server, [...server.workspaceFolders.all]),
       {},
-      // { vue: { compilerOptions: commonLine.vueOptions } },
     );
   }
 });
@@ -186,8 +184,9 @@ function getHybridModeLanguageServicePluginsForLanguageServer(
   // getTsPluginClient: import('@glint/tsserver/lib/requests').Requests | undefined,
 ): LanguageServicePlugin<any>[] {
   const plugins = [
-    // createTypeScriptSyntacticPlugin(ts),
-    // createTypeScriptDocCommentTemplatePlugin(ts),
+    // Lightweight syntax-only TS Language Service. Provides Symbols (e.g. Outline view) and other features.
+    createTypeScriptSyntacticPlugin(ts),
+    createHtmlSyntacticPlugin(),
     ...getCommonLanguageServicePluginsForLanguageServer(ts, () => getTsPluginClient),
   ];
   for (const plugin of plugins) {
@@ -203,6 +202,7 @@ function getCommonLanguageServicePluginsForLanguageServer(
   // ) => import('@glint/tsserver/lib/requests').Requests | undefined,
 ): LanguageServicePlugin[] {
   return [
+    createGtsGjsPlugin(),
     // createTypeScriptTwoslashQueriesPlugin(ts),
     // createCssPlugin(),
     // createPugFormatPlugin(),
diff --git a/packages/vscode/src/extension.ts b/packages/vscode/src/extension.ts
index 0024c0b15..33c8122cf 100644
--- a/packages/vscode/src/extension.ts
+++ b/packages/vscode/src/extension.ts
@@ -9,6 +9,7 @@ import { config } from './config';
 
 import {
   defineExtension,
+  executeCommand,
   extensionContext,
   onDeactivate,
   useWorkspaceFolders,
@@ -31,21 +32,16 @@ export const { activate, deactivate } = defineExtension(async () => {
 
     await tsExtension.activate();
   } else {
-    // TODO: we may decide to commit fully to TS Plugin mode, in which case it might be nice
-    // to have the message displayed below to guide the user.
-    // NOTE: Vue language tooling will continue to display this message even when willfully
-    // setting hybrid mode to false (i.e. using old LS approach). If we want to continue to support
-    // LS mode then we should leave this message commented out.
-    // vscode.window
-    //   .showWarningMessage(
-    //     'Takeover mode is no longer needed since v2. Please enable the "TypeScript and JavaScript Language Features" extension.',
-    //     'Show Extension',
-    //   )
-    //   .then((selected) => {
-    //     if (selected) {
-    //       executeCommand('workbench.extensions.search', '@builtin typescript-language-features');
-    //     }
-    //   });
+    vscode.window
+      .showWarningMessage(
+        'Glint V2 requires the "TypeScript and JavaScript Language Features" extension to be enabled.',
+        'Show Extension',
+      )
+      .then((selected) => {
+        if (selected) {
+          executeCommand('workbench.extensions.search', '@builtin typescript-language-features');
+        }
+      });
   }
 
   const context = extensionContext.value!;
@@ -140,6 +136,30 @@ export const { activate, deactivate } = defineExtension(async () => {
 
             updateProviders(client);
 
+            // Similarly to Vue, we implement a handler to receive requests from the LanguageServer,
+            // and then forward them to the same tsserver instance used/provided by the default
+            // VSCode TypeScript extension.
+            //
+            // This technique is described in the originating Vue PR:
+            // https://github.com/vuejs/language-tools/pull/5252
+            client.onRequest('tsserverRequest', async ([command, args]) => {
+              const tsserver = (globalThis as any).__TSSERVER__?.semantic;
+              if (!tsserver) {
+                return;
+              }
+              try {
+                const res = await tsserver.executeImpl(command, args, {
+                  isAsync: true,
+                  expectsResult: true,
+                  lowPriority: true,
+                  requireSemantic: true,
+                })[0];
+                return res.body;
+              } catch {
+                // noop
+              }
+            });
+
             return client;
           },
         );
diff --git a/packages/vscode/src/language-client.ts b/packages/vscode/src/language-client.ts
index 3c30aa423..ac5988834 100644
--- a/packages/vscode/src/language-client.ts
+++ b/packages/vscode/src/language-client.ts
@@ -153,7 +153,10 @@ async function getInitializationOptions(
   context: vscode.ExtensionContext,
 ): Promise<GlintInitializationOptions> {
   return {
-    typescript: { tsdk: (await lsp.getTsdk(context))!.tsdk },
+    typescript: {
+      tsdk: (await lsp.getTsdk(context))!.tsdk,
+      tsserverRequestCommand: 'tsserverRequest',
+    },
     glint: {},
   };
 }
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index d36bbb28e..9a3212dc3 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -108,6 +108,9 @@ importers:
       uuid:
         specifier: ^8.3.2
         version: 8.3.2
+      volar-service-html:
+        specifier: volar-2.4
+        version: 0.0.64(@volar/language-service@2.4.12)
       volar-service-typescript:
         specifier: volar-2.4
         version: 0.0.64(@volar/language-service@2.4.12)
@@ -2545,6 +2548,9 @@ packages:
   '@volar/vscode@2.4.12':
     resolution: {integrity: sha512-HPXqDszB0tGuxjF2CF1oma51ddeqoWJ58TynF1SGv+T6E07h9wcfIxvDhDCT2QdSt9hLAgJNR61OFi4ZR7lerA==}
 
+  '@vscode/l10n@0.0.18':
+    resolution: {integrity: sha512-KYSIHVmslkaCDyw013pphY+d7x1qV8IZupYfeIfzNA+nsaWHbn5uPuQRvdRFsa9zFzGeudPuoGoZ1Op4jrJXIQ==}
+
   '@vscode/test-electron@2.4.1':
     resolution: {integrity: sha512-Gc6EdaLANdktQ1t+zozoBVRynfIsMKMc94Svu1QreOBC8y76x4tvaK32TljrLi1LI2+PK58sDVbL7ALdqf3VRQ==}
     engines: {node: '>=16'}
@@ -8067,6 +8073,14 @@ packages:
       jsdom:
         optional: true
 
+  volar-service-html@0.0.64:
+    resolution: {integrity: sha512-5xknMYKmZBFzp2399RlsnGce25PfNu9ViXa1s63Q8NP6xeXcF3lInFsV+1o2DWBoXZdnXcuRvWOA+K+JIZLEcA==}
+    peerDependencies:
+      '@volar/language-service': ~2.4.0
+    peerDependenciesMeta:
+      '@volar/language-service':
+        optional: true
+
   volar-service-typescript@0.0.64:
     resolution: {integrity: sha512-FN2H97iqjR1id8AM4fH7lTXuTx2on9zD6QlUFllaiHKqgNrEITlQwm/9Ujrd9ST7MUzhgIKyUsa2WlanX9kkMg==}
     peerDependencies:
@@ -8079,6 +8093,9 @@ packages:
     resolution: {integrity: sha512-wTwcPvGF9xZ0fN7sPgdUPESH+Aw20Tk1vvgbYnKzWT4sFOqRP54qcpxjPUMdDoDGfiVIoXW87TNxn0yKXq3djw==}
     hasBin: true
 
+  vscode-html-languageservice@5.3.3:
+    resolution: {integrity: sha512-AK/jJM0VIWRrlfqkDBMZxNMnxYT5I2uoMVRoNJ5ePSplnSaT9mbYjqJlxxeLvUrOW7MEH0vVIDzU48u44QZE0w==}
+
   vscode-jsonrpc@8.2.0:
     resolution: {integrity: sha512-C+r0eKJUIfiDIfwJhria30+TYWPtuHJXHtI7J0YlOmKAo7ogxP20T0zxB7HZQIFhIyvoBPwWskjxrvAtfjyZfA==}
     engines: {node: '>=14.0.0'}
@@ -9783,6 +9800,7 @@ snapshots:
       silent-error: 1.1.1
       typescript: 5.8.2
       uuid: 8.3.2
+      volar-service-html: 0.0.64(@volar/language-service@2.4.12)
       volar-service-typescript: 0.0.64(@volar/language-service@2.4.12)
       vscode-languageserver-protocol: 3.17.5
       vscode-languageserver-textdocument: 1.0.12
@@ -10510,6 +10528,8 @@ snapshots:
       vscode-languageclient: 9.0.1
       vscode-nls: 5.2.0
 
+  '@vscode/l10n@0.0.18': {}
+
   '@vscode/test-electron@2.4.1':
     dependencies:
       http-proxy-agent: 7.0.2
@@ -17800,6 +17820,14 @@ snapshots:
       - tsx
       - yaml
 
+  volar-service-html@0.0.64(@volar/language-service@2.4.12):
+    dependencies:
+      vscode-html-languageservice: 5.3.3
+      vscode-languageserver-textdocument: 1.0.12
+      vscode-uri: 3.1.0
+    optionalDependencies:
+      '@volar/language-service': 2.4.12
+
   volar-service-typescript@0.0.64(@volar/language-service@2.4.12):
     dependencies:
       path-browserify: 1.0.1
@@ -17817,6 +17845,13 @@ snapshots:
       scule: 1.3.0
       yargs: 17.7.2
 
+  vscode-html-languageservice@5.3.3:
+    dependencies:
+      '@vscode/l10n': 0.0.18
+      vscode-languageserver-textdocument: 1.0.12
+      vscode-languageserver-types: 3.17.5
+      vscode-uri: 3.1.0
+
   vscode-jsonrpc@8.2.0: {}
 
   vscode-languageclient@9.0.1:
diff --git a/test-packages/package-test-core/__tests__/language-server/document-symbols.test.ts b/test-packages/package-test-core/__tests__/language-server/document-symbols.test.ts
new file mode 100644
index 000000000..87bccfca6
--- /dev/null
+++ b/test-packages/package-test-core/__tests__/language-server/document-symbols.test.ts
@@ -0,0 +1,119 @@
+import {
+  getSharedTestWorkspaceHelper,
+  teardownSharedTestWorkspaceAfterEach,
+  prepareDocument,
+} from 'glint-monorepo-test-utils';
+import { describe, beforeEach, afterEach, test, expect } from 'vitest';
+import { stripIndent } from 'common-tags';
+import { URI } from 'vscode-uri';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+
+describe('Language Server: Document Symbols (language server)', () => {
+  afterEach(teardownSharedTestWorkspaceAfterEach);
+
+  test('component invocation', async () => {
+    const document = await prepareDocument(
+      'ts-template-imports-app/src/empty-fixture.gts',
+      'glimmer-ts',
+      stripIndent`
+        import Component from '@glimmer/component';
+        import Greeting from './Greeting.gts';
+
+        export default class Application extends Component {
+          <template>
+            <Greeting @message="hello" />
+          </template>
+        }
+      `,
+    );
+
+    const symbols = await performDocumentSymbolsRequest(document);
+
+    expect(symbols).toMatchInlineSnapshot(`
+      [
+        {
+          "children": [
+            {
+              "kind": 8,
+              "name": "Greeting",
+              "range": {
+                "end": {
+                  "character": 33,
+                  "line": 5,
+                },
+                "start": {
+                  "character": 4,
+                  "line": 5,
+                },
+              },
+              "selectionRange": {
+                "end": {
+                  "character": 33,
+                  "line": 5,
+                },
+                "start": {
+                  "character": 4,
+                  "line": 5,
+                },
+              },
+            },
+            {
+              "kind": 2,
+              "name": "template",
+              "range": {
+                "end": {
+                  "character": 13,
+                  "line": 6,
+                },
+                "start": {
+                  "character": 2,
+                  "line": 4,
+                },
+              },
+              "selectionRange": {
+                "end": {
+                  "character": 13,
+                  "line": 6,
+                },
+                "start": {
+                  "character": 2,
+                  "line": 4,
+                },
+              },
+            },
+          ],
+          "kind": 5,
+          "name": "Application",
+          "range": {
+            "end": {
+              "character": 1,
+              "line": 7,
+            },
+            "start": {
+              "character": 0,
+              "line": 3,
+            },
+          },
+          "selectionRange": {
+            "end": {
+              "character": 32,
+              "line": 3,
+            },
+            "start": {
+              "character": 21,
+              "line": 3,
+            },
+          },
+        },
+      ]
+    `);
+  });
+});
+
+async function performDocumentSymbolsRequest(document: TextDocument): Promise<any> {
+  const workspaceHelper = await getSharedTestWorkspaceHelper();
+
+  const res = await workspaceHelper.glintserver.sendDocumentSymbolRequest(document.uri);
+
+  return res;
+}
diff --git a/test-packages/test-utils/src/shared-test-workspace.ts b/test-packages/test-utils/src/shared-test-workspace.ts
index b8760c6a6..8a73d7d6b 100644
--- a/test-packages/test-utils/src/shared-test-workspace.ts
+++ b/test-packages/test-utils/src/shared-test-workspace.ts
@@ -70,7 +70,7 @@ export async function getSharedTestWorkspaceHelper(): Promise<{
         return null;
       });
     });
-    serverHandle.connection.onRequest('forwardingTsRequest', async ([command, args]) => {
+    serverHandle.connection.onRequest('tsserverRequest', async ([command, args]) => {
       const res = await tsserver.message({
         seq: seq++,
         command: command,
@@ -85,9 +85,8 @@ export async function getSharedTestWorkspaceHelper(): Promise<{
       {
         typescript: {
           tsdk: tsdkPath,
-          // requestForwardingCommand: 'forwardingTsRequest',
+          tsserverRequestCommand: 'tsserverRequest',
         },
-        // } satisfies VueInitializationOptions,
       },
       {
         workspace: {