diff --git a/graph/test/javascript/cases/69-vue-sfc/src/Comp.vue b/graph/test/javascript/cases/69-vue-sfc/src/Comp.vue
new file mode 100644
index 000000000..b60f93be5
--- /dev/null
+++ b/graph/test/javascript/cases/69-vue-sfc/src/Comp.vue
@@ -0,0 +1,14 @@
+<script setup>
+import { Child, MyBadge } from './child.js';
+function sfcHelper() { return 1; }
+function onSave(value) { return value; }
+const total = 3;
+</script>
+
+<template>
+  <div>
+    <Child msg="from sfc" @ping="sfcHelper" />
+    <my-badge v-if="total" />
+    <button @click="onSave(total)">{{ sfcHelper() }}</button>
+  </div>
+</template>
diff --git a/graph/test/javascript/cases/69-vue-sfc/src/TemplateOnly.vue b/graph/test/javascript/cases/69-vue-sfc/src/TemplateOnly.vue
new file mode 100644
index 000000000..25d1e389b
--- /dev/null
+++ b/graph/test/javascript/cases/69-vue-sfc/src/TemplateOnly.vue
@@ -0,0 +1,3 @@
+<template>
+  <Child @ping="sfcHelper" />
+</template>
diff --git a/graph/test/javascript/cases/69-vue-sfc/src/Typed.vue b/graph/test/javascript/cases/69-vue-sfc/src/Typed.vue
new file mode 100644
index 000000000..ad39656cd
--- /dev/null
+++ b/graph/test/javascript/cases/69-vue-sfc/src/Typed.vue
@@ -0,0 +1,4 @@
+<script setup lang="ts">
+function typedHelper(): number { return 2; }
+</script>
+<template><button @click="typedHelper">x</button></template>
diff --git a/graph/test/javascript/cases/69-vue-sfc/src/child.js b/graph/test/javascript/cases/69-vue-sfc/src/child.js
new file mode 100644
index 000000000..83c1bf8e6
--- /dev/null
+++ b/graph/test/javascript/cases/69-vue-sfc/src/child.js
@@ -0,0 +1,7 @@
+export function Child(props) {
+  return props.msg;
+}
+
+export function MyBadge() {
+  return 'badge';
+}
diff --git a/graph/test/javascript/cases/69-vue-sfc/src/main.js b/graph/test/javascript/cases/69-vue-sfc/src/main.js
new file mode 100644
index 000000000..6d2103e88
--- /dev/null
+++ b/graph/test/javascript/cases/69-vue-sfc/src/main.js
@@ -0,0 +1,5 @@
+import Comp from './Comp.vue';
+
+export function mount() {
+  return Comp;
+}
diff --git a/graph/test/javascript/expected/69-vue-sfc.diag b/graph/test/javascript/expected/69-vue-sfc.diag
new file mode 100644
index 000000000..3ef2afad0
--- /dev/null
+++ b/graph/test/javascript/expected/69-vue-sfc.diag
@@ -0,0 +1 @@
+package_entry    @axiomcode/code-graph  .  []  MAIN  dist/reason.js  NOT_STAGED  -> -
diff --git a/graph/test/javascript/expected/69-vue-sfc.edges b/graph/test/javascript/expected/69-vue-sfc.edges
new file mode 100644
index 000000000..d7efd225a
--- /dev/null
+++ b/graph/test/javascript/expected/69-vue-sfc.edges
@@ -0,0 +1,5 @@
+Comp.vue:10:34 FUNCTION_CALL sfcHelper  ->  known_edge  Comp.vue:3:1 sfcHelper
+Comp.vue:10:6 FUNCTION_CALL Child  ->  known_edge  child.js:1:1 Child
+Comp.vue:11:6 FUNCTION_CALL MyBadge  ->  known_edge  child.js:5:1 MyBadge
+Comp.vue:12:21 FUNCTION_CALL onSave  ->  known_edge  Comp.vue:4:1 onSave
+Comp.vue:12:40 FUNCTION_CALL sfcHelper  ->  known_edge  Comp.vue:3:1 sfcHelper
diff --git a/graph/test/javascript/expected/69-vue-sfc.oracle b/graph/test/javascript/expected/69-vue-sfc.oracle
new file mode 100644
index 000000000..8675b52d3
--- /dev/null
+++ b/graph/test/javascript/expected/69-vue-sfc.oracle
@@ -0,0 +1 @@
+# defects: 0
diff --git a/graph/test/typescript/cases/80-vue-sfc/src/Comp.vue b/graph/test/typescript/cases/80-vue-sfc/src/Comp.vue
new file mode 100644
index 000000000..b4f89c5b6
--- /dev/null
+++ b/graph/test/typescript/cases/80-vue-sfc/src/Comp.vue
@@ -0,0 +1,17 @@
+<script setup lang="ts">
+import { Child, format } from './child';
+function sfcHelper(): number { return 1; }
+function onSave(value: number): void { void value; }
+const total = 3;
+</script>
+
+<template>
+  <div class="card">
+    <Child msg="from sfc" @ping="sfcHelper" />
+    <button @click="onSave(total)">{{ format(total) }}</button>
+  </div>
+</template>
+
+<style scoped>
+.card { color: red; }
+</style>
diff --git a/graph/test/typescript/cases/80-vue-sfc/src/Plain.vue b/graph/test/typescript/cases/80-vue-sfc/src/Plain.vue
new file mode 100644
index 000000000..a8b318cce
--- /dev/null
+++ b/graph/test/typescript/cases/80-vue-sfc/src/Plain.vue
@@ -0,0 +1,4 @@
+<script setup>
+function plainHelper() { return 2; }
+</script>
+<template><button @click="plainHelper">x</button></template>
diff --git a/graph/test/typescript/cases/80-vue-sfc/src/TemplateFirst.vue b/graph/test/typescript/cases/80-vue-sfc/src/TemplateFirst.vue
new file mode 100644
index 000000000..d4ab960c2
--- /dev/null
+++ b/graph/test/typescript/cases/80-vue-sfc/src/TemplateFirst.vue
@@ -0,0 +1,14 @@
+<template>
+  <section>
+    <my-badge v-if="shown()" />
+    <input @input="
+      onInput()
+    " />
+  </section>
+</template>
+
+<script setup lang="ts">
+import { MyBadge } from './child';
+function shown(): boolean { return true; }
+function onInput(): void {}
+</script>
diff --git a/graph/test/typescript/cases/80-vue-sfc/src/TemplateOnly.vue b/graph/test/typescript/cases/80-vue-sfc/src/TemplateOnly.vue
new file mode 100644
index 000000000..25d1e389b
--- /dev/null
+++ b/graph/test/typescript/cases/80-vue-sfc/src/TemplateOnly.vue
@@ -0,0 +1,3 @@
+<template>
+  <Child @ping="sfcHelper" />
+</template>
diff --git a/graph/test/typescript/cases/80-vue-sfc/src/child.ts b/graph/test/typescript/cases/80-vue-sfc/src/child.ts
new file mode 100644
index 000000000..157bb63e7
--- /dev/null
+++ b/graph/test/typescript/cases/80-vue-sfc/src/child.ts
@@ -0,0 +1,11 @@
+export function Child(props: { msg: string }): string {
+  return props.msg;
+}
+
+export function MyBadge(): string {
+  return 'badge';
+}
+
+export function format(n: number): string {
+  return n.toFixed(2);
+}
diff --git a/graph/test/typescript/cases/80-vue-sfc/src/main.ts b/graph/test/typescript/cases/80-vue-sfc/src/main.ts
new file mode 100644
index 000000000..c804793d3
--- /dev/null
+++ b/graph/test/typescript/cases/80-vue-sfc/src/main.ts
@@ -0,0 +1,5 @@
+import Comp from './Comp.vue';
+
+export function mount(): unknown {
+  return Comp;
+}
diff --git a/graph/test/typescript/cases/80-vue-sfc/src/shims-vue.d.ts b/graph/test/typescript/cases/80-vue-sfc/src/shims-vue.d.ts
new file mode 100644
index 000000000..821cca508
--- /dev/null
+++ b/graph/test/typescript/cases/80-vue-sfc/src/shims-vue.d.ts
@@ -0,0 +1,4 @@
+declare module '*.vue' {
+  const component: unknown;
+  export default component;
+}
diff --git a/graph/test/typescript/cases/80-vue-sfc/src/tsconfig.json b/graph/test/typescript/cases/80-vue-sfc/src/tsconfig.json
new file mode 100644
index 000000000..98ff2e003
--- /dev/null
+++ b/graph/test/typescript/cases/80-vue-sfc/src/tsconfig.json
@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "noEmit": true
+  },
+  "include": ["**/*.ts", "**/*.vue"]
+}
diff --git a/graph/test/typescript/expected/80-vue-sfc.edges b/graph/test/typescript/expected/80-vue-sfc.edges
new file mode 100644
index 000000000..716281dd0
--- /dev/null
+++ b/graph/test/typescript/expected/80-vue-sfc.edges
@@ -0,0 +1,8 @@
+ambiguous_unknown	METHOD_CALL	child#format(number) @L10 -> -
+known_edge	FUNCTION_CALL	Comp.vue#<module-init>() @L10 -> Comp.vue#sfcHelper()
+known_edge	FUNCTION_CALL	Comp.vue#<module-init>() @L10 -> child#Child({ msg: string })
+known_edge	FUNCTION_CALL	Comp.vue#<module-init>() @L11 -> Comp.vue#onSave(number)
+known_edge	FUNCTION_CALL	Comp.vue#<module-init>() @L11 -> child#format(number)
+known_edge	FUNCTION_CALL	TemplateFirst.vue#<module-init>() @L3 -> TemplateFirst.vue#shown()
+known_edge	FUNCTION_CALL	TemplateFirst.vue#<module-init>() @L3 -> child#MyBadge()
+known_edge	FUNCTION_CALL	TemplateFirst.vue#<module-init>() @L5 -> TemplateFirst.vue#onInput()
diff --git a/graph/test/typescript/expected/80-vue-sfc.entries b/graph/test/typescript/expected/80-vue-sfc.entries
new file mode 100644
index 000000000..3d43a8448
--- /dev/null
+++ b/graph/test/typescript/expected/80-vue-sfc.entries
@@ -0,0 +1,5 @@
+── entry_point (4) ──
+  exported_from_entry_module main#mount   main.ts:3
+  unimported_module TemplateFirst.vue#<module>   TemplateFirst.vue:1
+  unimported_module main#<module>   main.ts:1
+  unimported_module shims-vue#<module>   shims-vue.d.ts:1
diff --git a/graph/test/typescript/expected/80-vue-sfc.fields b/graph/test/typescript/expected/80-vue-sfc.fields
new file mode 100644
index 000000000..2c586263a
--- /dev/null
+++ b/graph/test/typescript/expected/80-vue-sfc.fields
@@ -0,0 +1 @@
+known_edge	read	child#Child({ msg: string }) -> { msg: string }#msg
diff --git a/graph/test/typescript/expected/80-vue-sfc.fields-oracle b/graph/test/typescript/expected/80-vue-sfc.fields-oracle
new file mode 100644
index 000000000..706b5d611
--- /dev/null
+++ b/graph/test/typescript/expected/80-vue-sfc.fields-oracle
@@ -0,0 +1,9 @@
+80-vue-sfc [fields]
+  precision 0.0000   (0 correct, 1 wrong)
+  recall    0.0000   (0 of 1 the compiler resolved)
+  sites 1   resolved 1 (100.0%)
+  tiers known_edge=1
+  access read=1
+  not scored: 0 rows whose target is not a client declaration
+    WRONG   child#Child({ msg: string }) READ { msg: string }#msg
+    MISSING child#Child({ msg: string }) READ child#msg
diff --git a/graph/test/typescript/expected/80-vue-sfc.oracle b/graph/test/typescript/expected/80-vue-sfc.oracle
new file mode 100644
index 000000000..8f740ea84
--- /dev/null
+++ b/graph/test/typescript/expected/80-vue-sfc.oracle
@@ -0,0 +1,8 @@
+oracle=0 engine=7 agree=0 missing=0 (known 0, NEW 0) extra=7
+  extra    Comp.vue#<module-init>() -> Comp.vue#onSave(number)
+  extra    Comp.vue#<module-init>() -> Comp.vue#sfcHelper()
+  extra    Comp.vue#<module-init>() -> child#Child({ msg: string })
+  extra    Comp.vue#<module-init>() -> child#format(number)
+  extra    TemplateFirst.vue#<module-init>() -> TemplateFirst.vue#onInput()
+  extra    TemplateFirst.vue#<module-init>() -> TemplateFirst.vue#shown()
+  extra    TemplateFirst.vue#<module-init>() -> child#MyBadge()
diff --git a/graph/test/typescript/expected/80-vue-sfc.type-use b/graph/test/typescript/expected/80-vue-sfc.type-use
new file mode 100644
index 000000000..e69de29bb
diff --git a/graph/test/typescript/expected/80-vue-sfc.types-oracle b/graph/test/typescript/expected/80-vue-sfc.types-oracle
new file mode 100644
index 000000000..01d62a428
--- /dev/null
+++ b/graph/test/typescript/expected/80-vue-sfc.types-oracle
@@ -0,0 +1,7 @@
+80-vue-sfc [types]
+  precision 0.0000   (0 correct, 0 wrong)
+  recall    0.0000   (0 of 0 the compiler resolved)
+  sites 0   resolved 0 
+  tiers 
+  contexts 
+  not scored: 0 rows whose target is not a client declaration
diff --git a/parser/src/parsers/javascript/extractors/js-fact-extractor.ts b/parser/src/parsers/javascript/extractors/js-fact-extractor.ts
index cea8168dc..639334369 100644
--- a/parser/src/parsers/javascript/extractors/js-fact-extractor.ts
+++ b/parser/src/parsers/javascript/extractors/js-fact-extractor.ts
@@ -111,6 +111,11 @@ export interface JsFileExtractionOptions {
   readonly projectModuleHashes: ReadonlyMap<string, string>;
   /** Absolute path -> project-relative path, extension stripped. */
   readonly toProjectRelative: (absolutePath: string) => string;
+  /**
+   * How `sourceText` parses, when the file's extension cannot say: a `.vue`
+   * component's virtual script is JS or JSX by its `lang`, not by its name.
+   */
+  readonly scriptKind?: ts.ScriptKind;
 }
 
 export interface JsFileFacts {
@@ -160,7 +165,7 @@ export function extractJavaScriptFile(options: JsFileExtractionOptions): JsFileF
     options.sourceText,
     ts.ScriptTarget.Latest,
     true,
-    scriptKindFor(options.absoluteFilePath)
+    options.scriptKind ?? scriptKindFor(options.absoluteFilePath)
   );
 
   const moduleResult = extractModule({
diff --git a/parser/src/parsers/javascript/extractors/js-module-edge-extractor.ts b/parser/src/parsers/javascript/extractors/js-module-edge-extractor.ts
index d6e2e89eb..2766c34b6 100644
--- a/parser/src/parsers/javascript/extractors/js-module-edge-extractor.ts
+++ b/parser/src/parsers/javascript/extractors/js-module-edge-extractor.ts
@@ -28,6 +28,7 @@ import {
   isRequireCall,
   pointOf,
 } from '@/utils/javascript';
+import { resolveVueSpecifier } from '@/utils/vue-sfc';
 
 /**
  * `js_import` and `js_export`, minted in a **second pass from expression rows**.
@@ -1199,7 +1200,10 @@ class JsModuleEdgeExtractor {
       undefined,
       m
     ).resolvedModule?.resolvedFileName;
-    const resolved = resolveIn(mode) ?? (mode === ts.ModuleKind.ESNext ? resolveIn(ts.ModuleKind.CommonJS) : undefined);
+    // tsc resolves no `.vue` import itself (its extensions are fixed), so a
+    // component in this program is looked up by path.
+    const resolved = resolveIn(mode) ?? (mode === ts.ModuleKind.ESNext ? resolveIn(ts.ModuleKind.CommonJS) : undefined)
+      ?? resolveVueSpecifier(specifier, this.options.absoluteFilePath);
     if (resolved === undefined) {
       return { filePath: '', outcome: JsImportResolutionOutcome.UNRESOLVED_MISSING };
     }
diff --git a/parser/src/parsers/typescript/extractors/ts-fact-extractor.ts b/parser/src/parsers/typescript/extractors/ts-fact-extractor.ts
index 6c07f5461..da67a6b4b 100644
--- a/parser/src/parsers/typescript/extractors/ts-fact-extractor.ts
+++ b/parser/src/parsers/typescript/extractors/ts-fact-extractor.ts
@@ -43,6 +43,7 @@ import {
   ResolutionStats,
   TsLocalResolver,
 } from '@/parsers/typescript/extractors/ts-resolution-linker';
+import { resolveVueSpecifier } from '@/utils/vue-sfc';
 
 /**
  * Extracts the whole fact spine for ONE TypeScript file.
@@ -91,6 +92,11 @@ export interface TsFileExtractionOptions {
   readonly projectModuleHashes: ReadonlyMap<string, string>;
   /** Absolute path -> project-relative path, extension stripped. */
   readonly toProjectRelative: (absolutePath: string) => string;
+  /**
+   * How `sourceText` parses, when the file's extension cannot say: a `.vue`
+   * component's virtual script is TS or TSX by its `lang`, not by its name.
+   */
+  readonly scriptKind?: ts.ScriptKind;
 }
 
 export interface TsFileFacts {
@@ -142,7 +148,7 @@ export function extractTypeScriptFile(options: TsFileExtractionOptions): TsFileF
     options.sourceText,
     ts.ScriptTarget.Latest,
     true,
-    scriptKindFor(options.absoluteFilePath)
+    options.scriptKind ?? scriptKindFor(options.absoluteFilePath)
   );
 
   const modules = extractModules({
@@ -173,7 +179,8 @@ export function extractTypeScriptFile(options: TsFileExtractionOptions): TsFileF
         options.compilerOptions,
         ts.sys
       );
-      const fileName = resolved.resolvedModule?.resolvedFileName;
+      const fileName = resolved.resolvedModule?.resolvedFileName
+        ?? resolveVueSpecifier(specifier, options.absoluteFilePath);
       if (!fileName) {
         return undefined;
       }
diff --git a/parser/src/parsers/typescript/extractors/ts-import-extractor.ts b/parser/src/parsers/typescript/extractors/ts-import-extractor.ts
index 27c96967b..8c7e89525 100644
--- a/parser/src/parsers/typescript/extractors/ts-import-extractor.ts
+++ b/parser/src/parsers/typescript/extractors/ts-import-extractor.ts
@@ -5,6 +5,7 @@ import * as ts from 'typescript';
 import { TsImportRegistry } from '@/analysis-types/typescript/TsImportRegistry';
 import { TsImportKind, TsImportResolutionKind } from '@/enums/typescript/imports';
 import { nodeId } from '@/parsers/typescript/extractors/ts-binder';
+import { resolveVueSpecifier, VUE_EXTENSION } from '@/utils/vue-sfc';
 
 /**
  * Emits `ts_import` rows — schema §4.12.
@@ -442,6 +443,18 @@ export class TsImportExtractor {
       ts.sys
     );
     const module = resolved.resolvedModule;
+    const vueFile = module ? undefined : resolveVueSpecifier(specifier, this.options.absoluteFilePath);
+    if (vueFile !== undefined && this.options.projectModuleHashes.has(vueFile)) {
+      // A component in this program; tsc resolves no `.vue` import itself.
+      return {
+        absolutePath: vueFile,
+        relativePath: this.options.toProjectRelative(vueFile),
+        moduleHash: this.options.projectModuleHashes.get(vueFile)!,
+        kind: TsImportResolutionKind.RELATIVE_FILE,
+        extension: VUE_EXTENSION,
+        packageName: '',
+      };
+    }
     if (!module) {
       // `undefined` is an honest answer, not a failure to try. It is also the
       // right answer for a wildcard ambient specifier like `"*.svg"`, which
diff --git a/parser/src/parsers/typescript/tsconfig-resolver.ts b/parser/src/parsers/typescript/tsconfig-resolver.ts
index 0363f3c8f..f36937469 100644
--- a/parser/src/parsers/typescript/tsconfig-resolver.ts
+++ b/parser/src/parsers/typescript/tsconfig-resolver.ts
@@ -243,7 +243,11 @@ export class TsConfigResolver {
         ts.sys,
         path.dirname(configPath),
         undefined,
-        configPath
+        configPath,
+        undefined,
+        // `.vue` components are the program's files too, as vue-tsc reads it:
+        // without this `include: ["src/**/*.vue"]` claims nothing.
+        [{ extension: '.vue', isMixedContent: true, scriptKind: ts.ScriptKind.Deferred }]
       );
       result = {
         configPath,
diff --git a/parser/src/utils/vue-sfc.ts b/parser/src/utils/vue-sfc.ts
new file mode 100644
index 000000000..151e09f35
--- /dev/null
+++ b/parser/src/utils/vue-sfc.ts
@@ -0,0 +1,454 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+import * as ts from 'typescript';
+
+/**
+ * A Vue single-file component read as the script it compiles to.
+ *
+ * ## Why a virtual script, and why it keeps every line
+ *
+ * A `.vue` file is three languages in one file: `<script>` / `<script setup>` is
+ * TypeScript or JavaScript, `<template>` is HTML whose attribute values and
+ * `{{ }}` interpolations are expressions in that script's scope, and `<style>` is
+ * CSS. Parsed as a whole it is nothing; skipped, every helper a template calls
+ * has no caller and every component it renders has no use.
+ *
+ * The virtual script is the file with everything BLANKED except:
+ *
+ *   - each inline `<script>` block's body, verbatim, at its own line and column;
+ *   - one top-level statement per template reference, on the line it is written:
+ *       `<Child/>` and `<my-child>`  -> `Child();` / `MyChild();`  (a JSX tag is a call too)
+ *       `@ping="onPing"`             -> `onPing();`   (Vue calls a bare handler)
+ *       `@ping="count++; log(x)"`    -> `count++; log(x);`
+ *       `:x="fmt(y)"`, `v-if="ok"`   -> `(fmt(y));`
+ *       `{{ total(items) }}`          -> `(total(items));`
+ *
+ * Line numbers are never moved: every row the extractors emit points at the
+ * line of the `.vue` file it came from. A column can drift only when two
+ * references share a line and the first one's statement is longer than the
+ * text it replaced.
+ *
+ * A template expression that does not parse on its own is dropped rather than
+ * written, so one odd attribute cannot swallow the statements after it. A
+ * component with no inline script is not a script at all: {@link vueScriptLanguage}
+ * answers `undefined` and the file is not analysed.
+ */
+
+/** The language of a component's inline script, or `undefined` when it has none. */
+export type VueScriptLanguage = 'ts' | 'tsx' | 'js' | 'jsx';
+
+export const VUE_EXTENSION = '.vue';
+
+export function isVueFile(fileName: string): boolean {
+  return fileName.endsWith(VUE_EXTENSION);
+}
+
+interface SfcBlock {
+  readonly tag: string;
+  readonly attributes: string;
+  /** Offset of the first character of the body, after the opening tag. */
+  readonly bodyStart: number;
+  /** Offset of the closing tag's `<`. */
+  readonly bodyEnd: number;
+}
+
+/** A piece of text to write at an offset of the original file. */
+interface Placement {
+  readonly offset: number;
+  readonly text: string;
+}
+
+export function vueScriptLanguage(sourceText: string): VueScriptLanguage | undefined {
+  const scripts = topLevelBlocks(sourceText).filter((b) => b.tag === 'script' && !hasSrc(b));
+  if (scripts.length === 0) {
+    return undefined;
+  }
+  const langs = scripts.map((b) => attributeValue(b.attributes, 'lang')?.toLowerCase() ?? 'js');
+  if (langs.includes('tsx')) {
+    return 'tsx';
+  }
+  if (langs.includes('ts')) {
+    return 'ts';
+  }
+  return langs.includes('jsx') ? 'jsx' : 'js';
+}
+
+/** The `ts.ScriptKind` a component's virtual script parses under. */
+export function vueScriptKind(language: VueScriptLanguage): ts.ScriptKind {
+  switch (language) {
+    case 'ts': return ts.ScriptKind.TS;
+    case 'tsx': return ts.ScriptKind.TSX;
+    case 'jsx': return ts.ScriptKind.JSX;
+    default: return ts.ScriptKind.JS;
+  }
+}
+
+/** The component as a script, line for line. `undefined` when it has no inline script. */
+export function vueVirtualScript(sourceText: string): string | undefined {
+  const language = vueScriptLanguage(sourceText);
+  if (language === undefined) {
+    return undefined;
+  }
+  const kind = vueScriptKind(language);
+  const placements: Placement[] = [];
+  const blocks = topLevelBlocks(sourceText);
+  for (const block of blocks) {
+    if (block.tag === 'script' && !hasSrc(block)) {
+      placements.push({ offset: block.bodyStart, text: sourceText.slice(block.bodyStart, block.bodyEnd) });
+    }
+  }
+  const template = blocks.find((b) => b.tag === 'template');
+  const templateLang = template === undefined ? undefined : attributeValue(template.attributes, 'lang');
+  if (template !== undefined && (templateLang === undefined || templateLang === 'html')) {
+    placements.push(...templateReferences(sourceText, template.bodyStart, template.bodyEnd, kind));
+  }
+  return layOut(sourceText, placements);
+}
+
+/**
+ * The language of the component at `file`, read from disk; `undefined` when it
+ * has no inline script or cannot be read. Decides which analyzer claims it: the
+ * TypeScript one for `ts`/`tsx`, the JavaScript one otherwise.
+ */
+export function vueComponentLanguage(file: string): VueScriptLanguage | undefined {
+  try {
+    return vueScriptLanguage(fs.readFileSync(file, 'utf-8'));
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * A source file's text as a script parser reads it, and how it parses: a `.vue`
+ * component becomes its virtual script; every other file is itself.
+ */
+export function scriptTextOf(file: string, text: string): { text: string; scriptKind?: ts.ScriptKind } {
+  if (!isVueFile(file)) {
+    return { text };
+  }
+  const language = vueScriptLanguage(text);
+  return {
+    text: vueVirtualScript(text) ?? '',
+    scriptKind: vueScriptKind(language ?? 'js'),
+  };
+}
+
+/**
+ * The file a `.vue` specifier names, when it is relative. tsc resolves no `.vue`
+ * import itself (its extensions are fixed), so without this every
+ * `import Comp from './Comp.vue'` would read as unresolved.
+ */
+export function resolveVueSpecifier(specifier: string, fromFile: string): string | undefined {
+  if (!isVueFile(specifier) || !(specifier.startsWith('./') || specifier.startsWith('../'))) {
+    return undefined;
+  }
+  const file = path.normalize(path.resolve(path.dirname(fromFile), specifier));
+  return fs.existsSync(file) ? file : undefined;
+}
+
+// ── the file's top-level blocks ────────────────────────────────────────────
+
+function topLevelBlocks(sourceText: string): SfcBlock[] {
+  const scan = blankComments(sourceText);
+  const blocks: SfcBlock[] = [];
+  const open = /<(script|template|style)\b([^>]*)>/gi;
+  let at = 0;
+  while (at < scan.length) {
+    open.lastIndex = at;
+    const match = open.exec(scan);
+    if (match === null) {
+      break;
+    }
+    const tag = match[1]!.toLowerCase();
+    const attributes = match[2] ?? '';
+    const bodyStart = match.index + match[0].length;
+    if (attributes.trimEnd().endsWith('/')) {
+      at = bodyStart;
+      continue;
+    }
+    const bodyEnd = tag === 'template'
+      ? matchingTemplateClose(scan, bodyStart)
+      : scan.toLowerCase().indexOf(`</${tag}`, bodyStart);
+    if (bodyEnd < 0) {
+      break;
+    }
+    blocks.push({ tag, attributes, bodyStart, bodyEnd });
+    const close = scan.indexOf('>', bodyEnd);
+    at = close < 0 ? scan.length : close + 1;
+  }
+  return blocks;
+}
+
+/** The `</template>` that closes the root one, counting the nested `<template v-slot>`s. */
+function matchingTemplateClose(scan: string, from: number): number {
+  const tags = /<(\/?)template\b[^>]*?(\/?)>/gi;
+  tags.lastIndex = from;
+  let depth = 1;
+  for (let m = tags.exec(scan); m !== null; m = tags.exec(scan)) {
+    if (m[1] === '/') {
+      depth -= 1;
+      if (depth === 0) {
+        return m.index;
+      }
+    } else if (m[2] !== '/') {
+      depth += 1;
+    }
+  }
+  return -1;
+}
+
+function blankComments(text: string): string {
+  return text.replace(/<!--[\s\S]*?-->/g, (c) => c.replace(/[^\n]/g, ' '));
+}
+
+function hasSrc(block: SfcBlock): boolean {
+  return attributeValue(block.attributes, 'src') !== undefined;
+}
+
+function attributeValue(attributes: string, name: string): string | undefined {
+  const m = new RegExp(String.raw`(?:^|\s)${name}\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))`, 'i')
+    .exec(attributes);
+  return m === null ? undefined : (m[1] ?? m[2] ?? m[3]);
+}
+
+// ── the template's references ──────────────────────────────────────────────
+
+/** Tags Vue itself renders; none of them is a binding in the component's scope. */
+const VUE_BUILT_IN_TAGS = new Set([
+  'component', 'transition', 'transition-group', 'keep-alive', 'teleport', 'suspense', 'slot',
+  'template', 'Component', 'Transition', 'TransitionGroup', 'KeepAlive', 'Teleport', 'Suspense',
+]);
+
+/** Directives whose value is not an expression, or introduces names rather than using them. */
+const NON_EXPRESSION_DIRECTIVES = new Set(['v-slot', 'v-else', 'v-pre', 'v-once', 'v-cloak', 'v-memo']);
+
+const MEMBER_PATH = /^\s*[A-Za-z_$][\w$]*(?:\s*\.\s*[A-Za-z_$][\w$]*)*\s*$/;
+
+function templateReferences(
+  sourceText: string,
+  start: number,
+  end: number,
+  kind: ts.ScriptKind
+): Placement[] {
+  const scan = blankComments(sourceText);
+  const out: Placement[] = [];
+  const emit = (offset: number, text: string): void => {
+    if (parsesAlone(text, kind)) {
+      out.push({ offset, text });
+    }
+  };
+  let i = start;
+  while (i < end) {
+    const lt = scan.indexOf('<', i);
+    const textEnd = lt < 0 || lt > end ? end : lt;
+    interpolations(scan, i, textEnd, emit);
+    if (textEnd === end) {
+      break;
+    }
+    i = readTag(scan, lt, end, emit);
+  }
+  return out;
+}
+
+function interpolations(
+  scan: string,
+  from: number,
+  to: number,
+  emit: (offset: number, text: string) => void
+): void {
+  let i = scan.indexOf('{{', from);
+  while (i >= 0 && i < to) {
+    const close = scan.indexOf('}}', i + 2);
+    if (close < 0 || close > to) {
+      return;
+    }
+    const expression = scan.slice(i + 2, close);
+    if (expression.trim() !== '') {
+      emit(i + 2, `(${expression});`);
+    }
+    i = scan.indexOf('{{', close + 2);
+  }
+}
+
+/** Reads the tag at `lt`, emits what it references, and returns the offset after it. */
+function readTag(
+  scan: string,
+  lt: number,
+  end: number,
+  emit: (offset: number, text: string) => void
+): number {
+  const nameMatch = /^<([A-Za-z][\w.:-]*)/.exec(scan.slice(lt, lt + 256));
+  if (nameMatch === null) {
+    // A closing tag, a doctype, or a stray `<` in text.
+    const gt = scan.indexOf('>', lt + 1);
+    return gt < 0 || gt > end ? end : gt + 1;
+  }
+  const tagName = nameMatch[1]!;
+  const component = componentBinding(tagName);
+  if (component !== undefined) {
+    emit(lt + 1, `${component}();`);
+  }
+  let i = lt + nameMatch[0].length;
+  while (i < end) {
+    while (i < end && /\s/.test(scan[i]!)) {
+      i += 1;
+    }
+    if (scan[i] === '>') {
+      return i + 1;
+    }
+    if (scan.startsWith('/>', i)) {
+      return i + 2;
+    }
+    const nameStart = i;
+    while (i < end && !/[\s=>]/.test(scan[i]!) && !scan.startsWith('/>', i)) {
+      i += 1;
+    }
+    const attribute = scan.slice(nameStart, i);
+    let j = i;
+    while (j < end && /\s/.test(scan[j]!)) {
+      j += 1;
+    }
+    if (scan[j] !== '=') {
+      if (attribute === '') {
+        i += 1;
+      }
+      continue;
+    }
+    j += 1;
+    while (j < end && /\s/.test(scan[j]!)) {
+      j += 1;
+    }
+    let valueStart: number;
+    let valueEnd: number;
+    if (scan[j] === '"' || scan[j] === '\'') {
+      valueStart = j + 1;
+      valueEnd = scan.indexOf(scan[j]!, valueStart);
+      if (valueEnd < 0 || valueEnd > end) {
+        return end;
+      }
+      i = valueEnd + 1;
+    } else {
+      valueStart = j;
+      valueEnd = j;
+      while (valueEnd < end && !/[\s>]/.test(scan[valueEnd]!)) {
+        valueEnd += 1;
+      }
+      i = valueEnd;
+    }
+    attributeReference(attribute, scan.slice(valueStart, valueEnd), valueStart, emit);
+  }
+  return end;
+}
+
+function attributeReference(
+  attribute: string,
+  value: string,
+  valueStart: number,
+  emit: (offset: number, text: string) => void
+): void {
+  if (value.trim() === '') {
+    return;
+  }
+  const directive = attribute.startsWith('@') ? 'v-on'
+    : attribute.startsWith(':') || attribute.startsWith('.') ? 'v-bind'
+      : attribute.startsWith('#') ? 'v-slot'
+        : attribute.startsWith('v-') ? attribute.split(/[:.]/)[0]!
+          : undefined;
+  if (directive === undefined || NON_EXPRESSION_DIRECTIVES.has(directive)) {
+    return;
+  }
+  if (directive === 'v-on') {
+    // A bare name or member path is the HANDLER, which Vue calls; anything else
+    // is the statement Vue runs, written as it stands.
+    emit(valueStart, MEMBER_PATH.test(value) ? `${value}();` : `${value};`);
+    return;
+  }
+  if (directive === 'v-for') {
+    const source = /^([\s\S]*?\s)(?:in|of)(\s[\s\S]*)$/.exec(value);
+    if (source !== null) {
+      emit(valueStart + source[1]!.length + 2, `(${source[2]!});`);
+    }
+    return;
+  }
+  emit(valueStart, `(${value});`);
+}
+
+/** The binding a tag names, or `undefined` for an HTML element or a Vue built-in. */
+function componentBinding(tagName: string): string | undefined {
+  if (VUE_BUILT_IN_TAGS.has(tagName)) {
+    return undefined;
+  }
+  if (/^[A-Z][\w$]*(?:\.[A-Za-z_$][\w$]*)*$/.test(tagName)) {
+    return tagName;
+  }
+  // `<my-child>` resolves to `MyChild` (or `myChild`) in the component's scope.
+  if (/^[a-z][a-z0-9]*(?:-[a-z0-9]+)+$/.test(tagName)) {
+    return tagName.split('-').map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join('');
+  }
+  return undefined;
+}
+
+function parsesAlone(text: string, kind: ts.ScriptKind): boolean {
+  const sf = ts.createSourceFile('template.ts', text, ts.ScriptTarget.Latest, false, kind);
+  const diagnostics = (sf as unknown as { parseDiagnostics?: readonly ts.Diagnostic[] })
+    .parseDiagnostics ?? [];
+  return diagnostics.length === 0;
+}
+
+// ── writing it out, line for line ──────────────────────────────────────────
+
+/**
+ * Every placement written at its own line; everything else blank.
+ *
+ * A placement's first line goes at its column (or after the previous text on
+ * that line, when that already reaches past it); each further line of it is
+ * written whole at the start of its line, which is where its text began in the
+ * original. No newline is added or removed, so every line keeps its number.
+ */
+function layOut(sourceText: string, placements: readonly Placement[]): string {
+  const lineStarts = [0];
+  for (let i = 0; i < sourceText.length; i += 1) {
+    if (sourceText[i] === '\n') {
+      lineStarts.push(i + 1);
+    }
+  }
+  const lineOf = (offset: number): number => {
+    let lo = 0;
+    let hi = lineStarts.length - 1;
+    while (lo < hi) {
+      const mid = (lo + hi + 1) >> 1;
+      if (lineStarts[mid]! <= offset) {
+        lo = mid;
+      } else {
+        hi = mid - 1;
+      }
+    }
+    return lo;
+  };
+  const pieces: Array<Array<{ column: number; order: number; text: string }>> =
+    lineStarts.map(() => []);
+  let order = 0;
+  for (const placement of [...placements].sort((a, b) => a.offset - b.offset)) {
+    const line = lineOf(placement.offset);
+    const segments = placement.text.split('\n');
+    segments.forEach((segment, k) => {
+      if (line + k < pieces.length) {
+        const column = k === 0 ? placement.offset - lineStarts[line]! : 0;
+        pieces[line + k]!.push({ column, order: order++, text: segment });
+      }
+    });
+  }
+  return pieces.map((onLine) => {
+    let text = '';
+    for (const piece of onLine.sort((a, b) => a.column - b.column || a.order - b.order)) {
+      if (text.length < piece.column) {
+        text += ' '.repeat(piece.column - text.length);
+      } else if (text.length > 0 && !/\s$/.test(text) && piece.text !== '') {
+        text += ' ';
+      }
+      text += piece.text;
+    }
+    return text;
+  }).join('\n');
+}
diff --git a/parser/src/workflows/javascript/javascript-project-analyzer.ts b/parser/src/workflows/javascript/javascript-project-analyzer.ts
index 5ee34e3fe..36e749ae7 100644
--- a/parser/src/workflows/javascript/javascript-project-analyzer.ts
+++ b/parser/src/workflows/javascript/javascript-project-analyzer.ts
@@ -48,6 +48,7 @@ import { JsTypeReferenceRegistry } from '@/analysis-types/javascript/JsTypeRefer
 import { JsTypeRegistry } from '@/analysis-types/javascript/JsTypeRegistry';
 import { JsVariableRegistry } from '@/analysis-types/javascript/JsVariableRegistry';
 import { isGitIgnoredDir } from '@/utils/git-ignored';
+import { isVueFile, scriptTextOf, vueComponentLanguage } from '@/utils/vue-sfc';
 
 /**
  * Each relation's header, from its registry, so an EMPTY relation still writes
@@ -431,12 +432,14 @@ export class JavaScriptProjectAnalyzer {
         const governing = governingByFile.get(file)!;
         let facts: JsFileFacts;
         try {
+          const script = scriptTextOf(file, sourceText);
           facts = extractJavaScriptFile({
             absoluteFilePath: file,
             filePath: toRelative(pathAnchor, file),
             baseMservPath: baseMservPath,
             moduleQualifiedName: toProjectRelative(file),
-            sourceText,
+            sourceText: script.text,
+            scriptKind: script.scriptKind,
             serviceVersionLinkHash,
             moduleSystem: governing.moduleSystem,
             moduleSystemSource: governing.moduleSystemSource,
@@ -648,6 +651,16 @@ function toRelative(anchor: string, absolutePath: string): string {
   return path.relative(anchor, absolutePath).split(path.sep).join('/');
 }
 
+/**
+ * A `.vue` component whose inline script is JavaScript (a missing `lang` is
+ * JavaScript). One with a TypeScript script is the TypeScript analyzer's, and
+ * one with no script has nothing to read.
+ */
+function isJavaScriptVueComponent(file: string): boolean {
+  const language = vueComponentLanguage(file);
+  return language === 'js' || language === 'jsx';
+}
+
 /**
  * A module's qualified name: the relative path with its extension removed.
  *
@@ -760,7 +773,8 @@ function collectJavaScriptFiles(
       if (entry.name === 'package.json') {
         packageJsonsSeen.add(full);
       }
-      if (isJavaScriptSourceFile(entry.name)) {
+      if (isJavaScriptSourceFile(entry.name)
+        || (isVueFile(entry.name) && isJavaScriptVueComponent(full))) {
         out.push(full);
       }
     }
diff --git a/parser/src/workflows/typescript/typescript-project-analyzer.ts b/parser/src/workflows/typescript/typescript-project-analyzer.ts
index 784287b79..ea62a178d 100644
--- a/parser/src/workflows/typescript/typescript-project-analyzer.ts
+++ b/parser/src/workflows/typescript/typescript-project-analyzer.ts
@@ -33,6 +33,12 @@ import { EntityUtils } from '@/utils/entity-utils';
 import { isGeneratedOutputDirectory } from '@/utils/generated-output';
 import { stripTsExtension } from '@/parsers/typescript/ts-module-paths';
 import { isGitIgnoredDir } from '@/utils/git-ignored';
+import {
+  isVueFile,
+  resolveVueSpecifier,
+  scriptTextOf,
+  vueComponentLanguage,
+} from '@/utils/vue-sfc';
 
 /**
  * Walks a TypeScript repository, extracts the fact spine, and exports it as TSV.
@@ -303,6 +309,7 @@ export class TypeScriptProjectAnalyzer {
         continue;
       }
       const governing = configResolver.resolve(file);
+      const script = scriptTextOf(file, sourceText);
       let facts: TsFileFacts;
       try {
         facts = extractTypeScriptFile({
@@ -310,7 +317,8 @@ export class TypeScriptProjectAnalyzer {
           filePath: toRelative(pathAnchor, file),
           baseMservPath: options.baseMservPath,
           moduleQualifiedName: toProjectRelative(file),
-          sourceText,
+          sourceText: script.text,
+          scriptKind: script.scriptKind,
           serviceVersionLinkHash,
           tsConfigPath: governing.configPath === ''
             ? ''
@@ -622,11 +630,12 @@ function filesOfRootProgram(
     }
     // No parent pointers and no type nodes needed: this pass only reads
     // specifiers, so the cheapest possible parse is the right one.
-    const sf = ts.createSourceFile(current, text, ts.ScriptTarget.Latest, false,
-      current.endsWith('.tsx') ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+    const script = scriptTextOf(current, text);
+    const sf = ts.createSourceFile(current, script.text, ts.ScriptTarget.Latest, false,
+      script.scriptKind ?? (current.endsWith('.tsx') ? ts.ScriptKind.TSX : ts.ScriptKind.TS));
     for (const specifier of importSpecifiersOf(sf)) {
       const resolved = ts.resolveModuleName(specifier, current, rootOptions, ts.sys)
-        .resolvedModule?.resolvedFileName;
+        .resolvedModule?.resolvedFileName ?? resolveVueSpecifier(specifier, current);
       if (resolved === undefined) {
         continue;
       }
@@ -763,7 +772,8 @@ function collectTypeScriptFiles(dir: string, excludes: ReadonlySet<string>): str
         }
         continue;
       }
-      if (TS_SOURCE_EXTENSIONS.some((extension) => entry.name.endsWith(extension))) {
+      if (TS_SOURCE_EXTENSIONS.some((extension) => entry.name.endsWith(extension))
+        || (isVueFile(entry.name) && isTypeScriptVueComponent(full))) {
         out.push(full);
       }
     }
@@ -772,6 +782,16 @@ function collectTypeScriptFiles(dir: string, excludes: ReadonlySet<string>): str
   return out;
 }
 
+/**
+ * A `.vue` component whose inline script is TypeScript. One with a JavaScript
+ * script (or none) is not this program's: the JavaScript analyzer reads the
+ * former, and the latter has nothing to read.
+ */
+function isTypeScriptVueComponent(file: string): boolean {
+  const language = vueComponentLanguage(file);
+  return language === 'ts' || language === 'tsx';
+}
+
 function toRelative(rootDir: string, file: string): string {
   return path.relative(rootDir, file).split(path.sep).join('/') || path.basename(file);
 }