gitnexus 1.6.6-rc.99 → 1.6.6

package/dist/core/ingestion/languages/typescript.js

@@ -1,9 +1,8 @@
 /**
  * TypeScript and JavaScript language providers.
  *
- * Both languages share the same type extraction config (typescriptConfig),
- * export checker (tsExportChecker), and named binding extractor
- * (extractTsNamedBindings). They differ in file extensions, tree-sitter
+ * Both languages share the same type extraction config (typescriptConfig)
+ * and export checker (tsExportChecker). They differ in file extensions, tree-sitter
  * queries (TypeScript grammar has interface/type nodes), and language ID.
  */
 import { SupportedLanguages } from '../../../_shared/index.js';
@@ -14,7 +13,6 @@ import { typeConfig as typescriptConfig } from '../type-extractors/typescript.js
 import { tsExportChecker } from '../export-detection.js';
 import { createImportResolver } from '../import-resolvers/resolver-factory.js';
 import { typescriptImportConfig, javascriptImportConfig, } from '../import-resolvers/configs/typescript-javascript.js';
-import { extractTsNamedBindings } from '../named-bindings/typescript.js';
 import { TYPESCRIPT_QUERIES, JAVASCRIPT_QUERIES } from '../tree-sitter-queries.js';
 import { typescriptFieldExtractor } from '../field-extractors/typescript.js';
 import { createFieldExtractor } from '../field-extractors/generic.js';
@@ -25,7 +23,7 @@ import { createVariableExtractor } from '../variable-extractors/generic.js';
 import { typescriptVariableConfig, javascriptVariableConfig, } from '../variable-extractors/configs/typescript-javascript.js';
 import { createCallExtractor } from '../call-extractors/generic.js';
 import { typescriptCallConfig, javascriptCallConfig, } from '../call-extractors/configs/typescript-javascript.js';
-import { createHeritageExtractor } from '../heritage-extractors/generic.js';
+import { ARRAY_METHOD_HOC_BLOCKLIST_SET, DEFAULT_EXPORT_IDENTIFIER_BLOCKLIST_SET, deriveDefaultExportHocName, } from '../ts-js-hoc-utils.js';
 import { emitTsScopeCaptures, interpretTsImport, interpretTsTypeBinding, tsBindingScopeFor, tsImportOwningScope, tsReceiverBinding, typescriptMergeBindings, typescriptArityCompatibility, resolveTsImportTarget, } from './typescript/index.js';
 import { emitJsScopeCaptures, interpretJsImport, interpretJsTypeBinding, jsBindingScopeFor, jsImportOwningScope, jsReceiverBinding, jsMergeBindings, jsArityCompatibility, } from './javascript/index.js';
 /**
@@ -54,7 +52,7 @@ import { emitJsScopeCaptures, interpretJsImport, interpretJsTypeBinding, jsBindi
  * findEnclosingFunctionId then continues up to the next named ancestor
  * (or to the file).
  */
-const tsExtractFunctionName = (node) => {
+const tsExtractFunctionName = (node, filePath) => {
     if (node.type !== 'arrow_function' && node.type !== 'function_expression')
         return null;
     const parent = node.parent;
@@ -99,27 +97,56 @@ const tsExtractFunctionName = (node) => {
     // `arguments`, grandparent is `call_expression`, great-grandparent is
     // `variable_declarator`. Walk the chain up and take the variable's name
     // — the meaningful identifier the developer wrote on the LHS. Mirrors
-    // the four registry-primary patterns in `typescript/query.ts`. The
-    // wrapping callee (`forwardRef`, `memo`, `React.memo`, `useCallback`,
-    // user-defined HOCs) is intentionally NOT constrained: any function
-    // call whose result is bound to a const and whose first/positional
-    // argument is an arrow takes the const's name. Chained array-method
-    // calls (`const x = arr.find((y) => p(y))`) match too and produce a
-    // mostly-harmless `Function:x` (consumed as a value, never invoked),
-    // accepted as a small false-positive cost vs. the much larger gain of
-    // capturing the React UI-component idiom.
+    // the four registry-primary patterns in `typescript/query.ts`.
+    //
+    // NOTE: Excludes common array methods (map, filter, reduce, etc.) to avoid
+    // false positives like `const x = arr.map(a => ...)` being classified as
+    // Function when it's actually a Const holding an array.
     if (parent.type === 'arguments') {
         const callExpr = parent.parent;
         if (!callExpr || callExpr.type !== 'call_expression') {
             return { funcName: null, label: 'Function' };
         }
+        // Check if callee is a member_expression calling an array method
+        const callee = callExpr.childForFieldName?.('function');
+        if (callee?.type === 'member_expression') {
+            const property = callee.childForFieldName?.('property');
+            if (property?.type === 'property_identifier' &&
+                ARRAY_METHOD_HOC_BLOCKLIST_SET.has(property.text)) {
+                return { funcName: null, label: 'Function' };
+            }
+        }
         const declarator = callExpr.parent;
-        if (!declarator || declarator.type !== 'variable_declarator') {
+        // Existing path: const X = HOC(arrow)
+        if (declarator?.type === 'variable_declarator') {
+            const nameNode = declarator.childForFieldName?.('name');
+            if (nameNode?.type === 'identifier') {
+                return { funcName: nameNode.text, label: 'Function' };
+            }
             return { funcName: null, label: 'Function' };
         }
-        const nameNode = declarator.childForFieldName?.('name');
-        if (nameNode?.type === 'identifier') {
-            return { funcName: nameNode.text, label: 'Function' };
+        // export default HOC(arrow) — name it from the file, not the wrapper.
+        // This keeps route handlers and wrapped defaults navigable without
+        // collapsing every file onto names like `memo` or `defineEventHandler`.
+        if (declarator?.type === 'export_statement') {
+            if (callee?.type === 'identifier') {
+                if (DEFAULT_EXPORT_IDENTIFIER_BLOCKLIST_SET.has(callee.text)) {
+                    return { funcName: null, label: 'Function' };
+                }
+                return {
+                    funcName: filePath ? deriveDefaultExportHocName(filePath) : null,
+                    label: 'Function',
+                };
+            }
+            // Member-expression callees like React.memo keep the same file-derived
+            // name, with array-like helpers excluded above.
+            if (callee?.type === 'member_expression') {
+                return {
+                    funcName: filePath ? deriveDefaultExportHocName(filePath) : null,
+                    label: 'Function',
+                };
+            }
+            return { funcName: null, label: 'Function' };
         }
         return { funcName: null, label: 'Function' };
     }
@@ -251,7 +278,6 @@ export const typescriptProvider = defineLanguage({
     typeConfig: typescriptConfig,
     exportChecker: tsExportChecker,
     importResolver: createImportResolver(typescriptImportConfig),
-    namedBindingExtractor: extractTsNamedBindings,
     callExtractor: createCallExtractor(typescriptCallConfig),
     fieldExtractor: typescriptFieldExtractor,
     methodExtractor: createMethodExtractor({
@@ -260,7 +286,6 @@ export const typescriptProvider = defineLanguage({
     }),
     variableExtractor: createVariableExtractor(typescriptVariableConfig),
     classExtractor: createClassExtractor(typescriptClassConfig),
-    heritageExtractor: createHeritageExtractor(SupportedLanguages.TypeScript),
     builtInNames: BUILT_INS,
     // ── RFC #909 Ring 3: scope-based resolution hooks (RFC §5) ──────────
     // TypeScript is the third migration after Python and C#. See
@@ -311,7 +336,6 @@ export const javascriptProvider = defineLanguage({
     typeConfig: typescriptConfig,
     exportChecker: tsExportChecker,
     importResolver: createImportResolver(javascriptImportConfig),
-    namedBindingExtractor: extractTsNamedBindings,
     callExtractor: createCallExtractor(javascriptCallConfig),
     fieldExtractor: createFieldExtractor(javascriptConfig),
     methodExtractor: createMethodExtractor({
@@ -320,7 +344,6 @@ export const javascriptProvider = defineLanguage({
     }),
     variableExtractor: createVariableExtractor(javascriptVariableConfig),
     classExtractor: createClassExtractor(javascriptClassConfig),
-    heritageExtractor: createHeritageExtractor(SupportedLanguages.JavaScript),
     builtInNames: BUILT_INS,
     // ── RFC #909 Ring 3: scope-based resolution hooks (RFC §5) ──────────
     // JavaScript is the fourth migration after Python, C#, and TypeScript.

package/dist/core/ingestion/languages/vue/captures.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Vue SFC scope captures (RFC #909 Ring 3, issue #940).
+ *
+ * Extracts the `<script>` / `<script setup>` block from the SFC source
+ * and delegates to `emitTsScopeCaptures`.  The parse-worker builds the
+ * cached tree from the extracted script content using the TypeScript
+ * grammar (see `[SupportedLanguages.Vue]: TypeScript.typescript` in
+ * `parse-worker.ts`), so passing that tree here keeps grammar identity
+ * consistent and avoids a redundant re-parse.
+ *
+ * Template expressions are intentionally out-of-scope: component-
+ * reference CALLS edges are already emitted by the legacy template
+ * extractor in the parse worker and would be double-counted here.
+ *
+ * Position note: all capture positions are relative to the *extracted*
+ * script block, not the full .vue file.  This is consistent with the
+ * cached tree and with how the scope model uses positions (only for
+ * scope-containment walks within a single file), so no offset
+ * translation is required for graph-edge correctness.
+ */
+import type { CaptureMatch } from '../../../../_shared/index.js';
+/**
+ * Emit scope captures for a Vue SFC.
+ *
+ * Handles three call-site shapes:
+ *
+ *   1. **Full SFC content** (sequential path, <15 files): `sourceText`
+ *      contains the whole `.vue` file with `<template>`, `<script>`, etc.
+ *      `extractVueScript` extracts the script block and we delegate to
+ *      `emitTsScopeCaptures` or `emitJsScopeCaptures` based on `lang`.
+ *
+ *   2. **Already-extracted script content** (worker-mode path, ≥15 files):
+ *      the parse worker calls `extractVueScript` itself before calling
+ *      `extractParsedFile`, so `sourceText` is already the bare script
+ *      text with no `<script>` tags. The caller marks this explicitly via
+ *      `sourceMeta.sourceKind === 'pre-extracted-script'`.
+ *
+ *   3. **Supporting TS/JS files** included in Vue scope-resolution runs:
+ *      when `filePath` is not `.vue`, delegate straight to TypeScript captures.
+ *
+ * Returns an empty array for render-function-only SFCs (no `<script>` block).
+ */
+export declare function emitVueScopeCaptures(sourceText: string, filePath: string, cachedTree?: unknown, sourceMeta?: {
+    sourceKind?: 'full-file' | 'pre-extracted-script';
+    setupLang?: string;
+}): readonly CaptureMatch[];

package/dist/core/ingestion/languages/vue/captures.js

@@ -0,0 +1,67 @@
+/**
+ * Vue SFC scope captures (RFC #909 Ring 3, issue #940).
+ *
+ * Extracts the `<script>` / `<script setup>` block from the SFC source
+ * and delegates to `emitTsScopeCaptures`.  The parse-worker builds the
+ * cached tree from the extracted script content using the TypeScript
+ * grammar (see `[SupportedLanguages.Vue]: TypeScript.typescript` in
+ * `parse-worker.ts`), so passing that tree here keeps grammar identity
+ * consistent and avoids a redundant re-parse.
+ *
+ * Template expressions are intentionally out-of-scope: component-
+ * reference CALLS edges are already emitted by the legacy template
+ * extractor in the parse worker and would be double-counted here.
+ *
+ * Position note: all capture positions are relative to the *extracted*
+ * script block, not the full .vue file.  This is consistent with the
+ * cached tree and with how the scope model uses positions (only for
+ * scope-containment walks within a single file), so no offset
+ * translation is required for graph-edge correctness.
+ */
+import { extractVueScript } from '../../vue-sfc-extractor.js';
+import { emitTsScopeCaptures } from '../typescript/captures.js';
+import { emitJsScopeCaptures } from '../javascript/captures.js';
+/**
+ * Emit scope captures for a Vue SFC.
+ *
+ * Handles three call-site shapes:
+ *
+ *   1. **Full SFC content** (sequential path, <15 files): `sourceText`
+ *      contains the whole `.vue` file with `<template>`, `<script>`, etc.
+ *      `extractVueScript` extracts the script block and we delegate to
+ *      `emitTsScopeCaptures` or `emitJsScopeCaptures` based on `lang`.
+ *
+ *   2. **Already-extracted script content** (worker-mode path, ≥15 files):
+ *      the parse worker calls `extractVueScript` itself before calling
+ *      `extractParsedFile`, so `sourceText` is already the bare script
+ *      text with no `<script>` tags. The caller marks this explicitly via
+ *      `sourceMeta.sourceKind === 'pre-extracted-script'`.
+ *
+ *   3. **Supporting TS/JS files** included in Vue scope-resolution runs:
+ *      when `filePath` is not `.vue`, delegate straight to TypeScript captures.
+ *
+ * Returns an empty array for render-function-only SFCs (no `<script>` block).
+ */
+export function emitVueScopeCaptures(sourceText, filePath, cachedTree, sourceMeta) {
+    // Vue resolver may include supporting TS/JS files in the same run to
+    // preserve cross-file import/type context for `.vue` callers. These are
+    // already plain script files, so no SFC extraction is needed.
+    if (!filePath.endsWith('.vue')) {
+        return emitTsScopeCaptures(sourceText, filePath, cachedTree);
+    }
+    if (sourceMeta?.sourceKind === 'pre-extracted-script') {
+        // Worker-mode path: the parse worker always uses TypeScript grammar for
+        // .vue files. Lang-based grammar selection is a sequential-path feature.
+        return emitTsScopeCaptures(sourceText, filePath, cachedTree);
+    }
+    const extracted = extractVueScript(sourceText);
+    if (extracted === null)
+        return [];
+    // Select captures based on script lang attribute.
+    // Use TS grammar unless ALL blocks explicitly request JS/JSX.
+    // Mixed-lang: TS handles JS natively; JS grammar chokes on TS syntax.
+    if (extracted.lang === 'js' || extracted.lang === 'jsx') {
+        return emitJsScopeCaptures(extracted.scriptContent, filePath, cachedTree);
+    }
+    return emitTsScopeCaptures(extracted.scriptContent, filePath, cachedTree);
+}

package/dist/core/ingestion/languages/vue/import-target.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Import-target resolver for Vue SFCs (RFC #909 Ring 3, issue #940).
+ *
+ * Vue `<script>` / `<script setup>` blocks are TypeScript (or plain
+ * JavaScript), so the resolver delegates to `resolveTsTarget` with
+ * `language: SupportedLanguages.TypeScript` to get:
+ *
+ *   - tsconfig path-alias rewriting (Vue projects universally use TS)
+ *   - `.ts` / `.tsx` / `.js` / `.jsx` extension-suffix fallback
+ *
+ * `.vue` imports are written with explicit extensions (`'./Button.vue'`),
+ * so no Vue-specific suffix guessing is required: the standard
+ * resolver finds them via the exact-path branch before any extension
+ * logic fires.
+ *
+ * Memoization mirrors the TypeScript adapter: workspace file-list
+ * arrays, the suffix index, and the per-pass resolve cache are rebuilt
+ * lazily when `allFilePaths` reference changes (once per workspace pass).
+ */
+/**
+ * Build a memoized `resolveImportTarget` adapter for Vue SFCs.
+ *
+ * Uses `SupportedLanguages.TypeScript` so tsconfig path-alias resolution
+ * and `.ts`/`.tsx` extension guessing fire for relative and bare-specifier
+ * imports inside `<script>` blocks.
+ */
+export declare function makeVueResolveImportTarget(): (targetRaw: string, fromFile: string, allFilePaths: ReadonlySet<string>, resolutionConfig?: unknown) => string | readonly string[] | null;

package/dist/core/ingestion/languages/vue/import-target.js

@@ -0,0 +1,58 @@
+/**
+ * Import-target resolver for Vue SFCs (RFC #909 Ring 3, issue #940).
+ *
+ * Vue `<script>` / `<script setup>` blocks are TypeScript (or plain
+ * JavaScript), so the resolver delegates to `resolveTsTarget` with
+ * `language: SupportedLanguages.TypeScript` to get:
+ *
+ *   - tsconfig path-alias rewriting (Vue projects universally use TS)
+ *   - `.ts` / `.tsx` / `.js` / `.jsx` extension-suffix fallback
+ *
+ * `.vue` imports are written with explicit extensions (`'./Button.vue'`),
+ * so no Vue-specific suffix guessing is required: the standard
+ * resolver finds them via the exact-path branch before any extension
+ * logic fires.
+ *
+ * Memoization mirrors the TypeScript adapter: workspace file-list
+ * arrays, the suffix index, and the per-pass resolve cache are rebuilt
+ * lazily when `allFilePaths` reference changes (once per workspace pass).
+ */
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { resolveTsTarget } from '../typescript/import-target.js';
+import { buildSuffixIndex } from '../../import-resolvers/utils.js';
+/**
+ * Build a memoized `resolveImportTarget` adapter for Vue SFCs.
+ *
+ * Uses `SupportedLanguages.TypeScript` so tsconfig path-alias resolution
+ * and `.ts`/`.tsx` extension guessing fire for relative and bare-specifier
+ * imports inside `<script>` blocks.
+ */
+export function makeVueResolveImportTarget() {
+    let cached = null;
+    return (targetRaw, fromFile, allFilePaths, resolutionConfig) => {
+        if (cached === null || cached.key !== allFilePaths) {
+            const allFileList = Array.from(allFilePaths);
+            const normalizedFileList = allFileList.map((f) => f.toLowerCase());
+            cached = {
+                key: allFilePaths,
+                allFilePaths: new Set(allFilePaths),
+                allFileList,
+                normalizedFileList,
+                index: buildSuffixIndex(normalizedFileList, allFileList),
+                resolveCache: new Map(),
+            };
+        }
+        const cfg = resolutionConfig;
+        const ws = {
+            fromFile,
+            language: SupportedLanguages.TypeScript,
+            allFilePaths: cached.allFilePaths,
+            allFileList: cached.allFileList,
+            normalizedFileList: cached.normalizedFileList,
+            index: cached.index,
+            resolveCache: cached.resolveCache,
+            tsconfigPaths: cfg?.tsconfigPaths ?? null,
+        };
+        return resolveTsTarget(targetRaw, ws);
+    };
+}

package/dist/core/ingestion/languages/vue/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Vue SFC scope-resolution hooks (RFC #909 Ring 3, issue #940).
+ *
+ * Public API barrel. Consumers should import from this file rather
+ * than the individual modules.
+ *
+ * Module layout (each file is a single concern):
+ *
+ *   - `captures.ts`       — `emitVueScopeCaptures` — extracts the
+ *                           `<script>` / `<script setup>` block and
+ *                           delegates to `emitTsScopeCaptures` (TypeScript
+ *                           grammar, same grammar the parse-worker uses).
+ *   - `import-target.ts`  — `makeVueResolveImportTarget` — memoized
+ *                           adapter using the TypeScript resolver with
+ *                           tsconfig path-alias support.
+ *   - `scope-resolver.ts` — `vueScopeResolver` wiring object.
+ *
+ * ## Known limitations
+ *
+ *   1. **Template expressions** — Full template AST parsing is not performed.
+ *      `vueScopeResolver.emitPostResolutionEdges` extracts five categories of
+ *      template-derived edges via lightweight regex, all emitted after standard
+ *      scope-resolution passes complete:
+ *        - PascalCase/kebab-case component references → `vue-template-component` `CALLS`
+ *        - `@event="handler"` on **native** elements → `vue-template-callback` `CALLS`
+ *        - `@event="handler"` on **component** elements → `vue-event: @<name>` `BINDS_EVENT_HANDLER`
+ *        - `emit(...)` / `this.$emit(...)` in script → `vue-emit: <name>` `EMITS_EVENT`
+ *        - `:prop="varName"` single-identifier bindings → `vue-template-attribute` `ACCESSES`
+ *      `BINDS_EVENT_HANDLER` and `EMITS_EVENT` are complementary "hanging" edges:
+ *      a Cypher query joining on the shared component File node reveals which
+ *      handlers receive which component's emitted events.
+ *      Complex inline expressions (`@click="toggle(item)"`, `{{ a + b }}`,
+ *      member-access bindings `:key="post.id"`) are intentionally excluded
+ *      because they cannot be resolved to a single call/access target without
+ *      a full template AST. Tracked in #1647.
+ *   2. **Options API `this` resolution** — `this.X()` in Options API
+ *      components does not resolve through type-binding when the component
+ *      uses a plain object literal rather than a class. `fieldFallbackOnMethodLookup`
+ *      recovers common cases via field-name matching.
+ *   3. **`<script setup>` + `<script>` dual-block** — When both blocks are
+ *      present, only `<script setup>` is processed (per `extractVueScript`
+ *      priority). The non-setup block is skipped.
+ *   4. **JSX in `<template>`** — Vue's template compiler is not a
+ *      tree-sitter grammar; JSX-style bindings inside templates are not
+ *      processed by the scope-resolution pipeline.
+ */
+export { emitVueScopeCaptures } from './captures.js';
+export { makeVueResolveImportTarget } from './import-target.js';
+export { vueScopeResolver } from './scope-resolver.js';

package/dist/core/ingestion/languages/vue/index.js

@@ -0,0 +1,49 @@
+/**
+ * Vue SFC scope-resolution hooks (RFC #909 Ring 3, issue #940).
+ *
+ * Public API barrel. Consumers should import from this file rather
+ * than the individual modules.
+ *
+ * Module layout (each file is a single concern):
+ *
+ *   - `captures.ts`       — `emitVueScopeCaptures` — extracts the
+ *                           `<script>` / `<script setup>` block and
+ *                           delegates to `emitTsScopeCaptures` (TypeScript
+ *                           grammar, same grammar the parse-worker uses).
+ *   - `import-target.ts`  — `makeVueResolveImportTarget` — memoized
+ *                           adapter using the TypeScript resolver with
+ *                           tsconfig path-alias support.
+ *   - `scope-resolver.ts` — `vueScopeResolver` wiring object.
+ *
+ * ## Known limitations
+ *
+ *   1. **Template expressions** — Full template AST parsing is not performed.
+ *      `vueScopeResolver.emitPostResolutionEdges` extracts five categories of
+ *      template-derived edges via lightweight regex, all emitted after standard
+ *      scope-resolution passes complete:
+ *        - PascalCase/kebab-case component references → `vue-template-component` `CALLS`
+ *        - `@event="handler"` on **native** elements → `vue-template-callback` `CALLS`
+ *        - `@event="handler"` on **component** elements → `vue-event: @<name>` `BINDS_EVENT_HANDLER`
+ *        - `emit(...)` / `this.$emit(...)` in script → `vue-emit: <name>` `EMITS_EVENT`
+ *        - `:prop="varName"` single-identifier bindings → `vue-template-attribute` `ACCESSES`
+ *      `BINDS_EVENT_HANDLER` and `EMITS_EVENT` are complementary "hanging" edges:
+ *      a Cypher query joining on the shared component File node reveals which
+ *      handlers receive which component's emitted events.
+ *      Complex inline expressions (`@click="toggle(item)"`, `{{ a + b }}`,
+ *      member-access bindings `:key="post.id"`) are intentionally excluded
+ *      because they cannot be resolved to a single call/access target without
+ *      a full template AST. Tracked in #1647.
+ *   2. **Options API `this` resolution** — `this.X()` in Options API
+ *      components does not resolve through type-binding when the component
+ *      uses a plain object literal rather than a class. `fieldFallbackOnMethodLookup`
+ *      recovers common cases via field-name matching.
+ *   3. **`<script setup>` + `<script>` dual-block** — When both blocks are
+ *      present, only `<script setup>` is processed (per `extractVueScript`
+ *      priority). The non-setup block is skipped.
+ *   4. **JSX in `<template>`** — Vue's template compiler is not a
+ *      tree-sitter grammar; JSX-style bindings inside templates are not
+ *      processed by the scope-resolution pipeline.
+ */
+export { emitVueScopeCaptures } from './captures.js';
+export { makeVueResolveImportTarget } from './import-target.js';
+export { vueScopeResolver } from './scope-resolver.js';

package/dist/core/ingestion/languages/vue/scope-resolver.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Vue `ScopeResolver` registered in `SCOPE_RESOLVERS` and consumed by
+ * the generic `runScopeResolution` orchestrator (RFC #909 Ring 3, issue #940).
+ *
+ * ## Design rationale
+ *
+ * Vue SFCs compile down to TypeScript/JavaScript — the `<script>` /
+ * `<script setup>` block is pure TS/JS, parsed with the TypeScript
+ * grammar and captured by `emitVueScopeCaptures` (which delegates
+ * to `emitTsScopeCaptures`).  Because of this, nearly all hooks are
+ * identical to the TypeScript resolver:
+ *
+ *   - `mergeBindings` — TypeScript LEGB semantics apply in script blocks.
+ *   - `arityCompatibility` — same positional + rest rules.
+ *   - `buildMro` / `populateOwners` — shared with TypeScript.
+ *   - `isSuperReceiver` — `super(...)` / `super.foo` / `super[x]` pattern.
+ *   - `resolveImportTarget` — TypeScript resolver with `.vue` explicit-
+ *                             extension support; tsconfig paths loaded via
+ *                             `loadResolutionConfig`.
+ *
+ * ## Key differences from TypeScript
+ *
+ *   - `language: SupportedLanguages.Vue` — routes the resolver to Vue
+ *     files only; TypeScript files use the TypeScript resolver.
+ *   - `languageProvider: vueProvider` — the Vue-specific language
+ *     provider supplies the right built-ins and export checker for
+ *     `<script setup>` (all top-level bindings implicitly exported).
+ *   - `importEdgeReason: 'vue-scope: import'` — distinct tag for
+ *     debugging / edge provenance.
+ *   - `allowGlobalFreeCallFallback: false` — Vue uses explicit imports;
+ *     workspace-wide unique-name fallback is unnecessary and would
+ *     produce spurious edges for Vue built-ins (ref, reactive, …).
+ *
+ * ## Options API / this-binding
+ *
+ * Options API (`defineComponent({ methods: { … } })`) stores methods
+ * on the component instance, which tree-sitter sees as object property
+ * values.  `this.X()` inside a method resolves via the existing
+ * `tsReceiverBinding` hook (inherited from TypeScript), which walks to
+ * the enclosing Class scope.  For Options API the enclosing "class" is
+ * the `defineComponent({…})` object — not a true class — so `this`
+ * calls may not resolve through the type-binding layer.  `fieldFallbackOnMethodLookup`
+ * is therefore set to `true` so the field-name fallback catches common
+ * patterns even without an explicit type annotation.
+ *
+ * ## `<script setup>` macro calls
+ *
+ * `defineProps`, `defineEmits`, `defineExpose`, `withDefaults`, etc.
+ * are compiler macros available as globals inside `<script setup>`.
+ * They are listed in `vueProvider.builtInNames` and therefore treated
+ * as resolved without requiring an import edge.
+ */
+import type { ScopeResolver } from '../../scope-resolution/contract/scope-resolver.js';
+declare const vueScopeResolver: ScopeResolver;
+export { vueScopeResolver };