cgraphx 2.0.2 → 2.0.3

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

@@ -0,0 +1,455 @@
+"use strict";
+/**
+ * TypeScript and JavaScript language providers.
+ *
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.javascriptProvider = exports.typescriptProvider = exports.BUILT_INS = void 0;
+const index_js_1 = require("../../../../shared/index.js");
+const language_provider_js_1 = require("../language-provider.js");
+const generic_js_1 = require("../class-extractors/generic.js");
+const typescript_javascript_js_1 = require("../class-extractors/configs/typescript-javascript.js");
+const ast_helpers_js_1 = require("../utils/ast-helpers.js");
+const cjs_export_assignment_js_1 = require("./typescript/cjs-export-assignment.js");
+const rootOf = (node) => node.tree?.rootNode;
+/** `exports.X = fn` where the module already declares `X` — see #2723. */
+const isShadowedCjsExportNode = (node) => {
+    const root = rootOf(node);
+    return root !== undefined && (0, cjs_export_assignment_js_1.isShadowedCjsExportAssignmentNode)(node, root);
+};
+/**
+ * Label for a `<receiver>.<member> = <function>` capture (#2723 follow-up).
+ *
+ * The member-assignment queries match ANY identifier receiver, because an
+ * `exports` alias (`const e = exports; e.foo = fn`) cannot be pinned in the
+ * query. Everything that is not a recognised shape is dropped HERE — without
+ * that, every `obj.handler = function () {}` in every JS/TS file would emit a
+ * spurious top-level `Function` named `handler`.
+ *
+ * Recognised: a CJS export (direct, `module.exports`, or via a module-scope
+ * alias) stays a Function; a prototype or `this` member becomes a Method; a
+ * CJS export shadowing a name the module already declares emits nothing.
+ */
+const memberAssignmentLabel = (node) => {
+    const root = rootOf(node);
+    // Module-level `this.X = fn` in CommonJS IS `module.exports.X = fn`, so it
+    // is an exported Function, not an instance member. Checked before the
+    // Method branch, which would otherwise claim every `this` receiver.
+    if (root !== undefined && (0, cjs_export_assignment_js_1.isModuleLevelThisExport)(node, root))
+        return 'Function';
+    // `module.exports = fn` — the module itself is the callable.
+    if ((0, ast_helpers_js_1.isCjsDefaultExportAssignment)(node))
+        return 'Function';
+    // A module-level `this` member in ESM or a no-signal file is neither an
+    // export (top-level `this` is undefined) nor an instance member. Emitting a
+    // Method there minted an ownerless node (#2729 review F13).
+    if ((0, cjs_export_assignment_js_1.isModuleLevelThisAssignment)(node))
+        return null;
+    if ((0, ast_helpers_js_1.isPrototypeMemberAssignmentNode)(node))
+        return 'Method';
+    if (isShadowedCjsExportNode(node))
+        return null;
+    const value = node.childForFieldName('right');
+    if (root === undefined || value === null)
+        return null;
+    return (0, cjs_export_assignment_js_1.cjsExportedNameFor)(value, root) !== null ? 'Function' : null;
+};
+const typescript_js_1 = require("../cfg/visitors/typescript.js");
+const typescript_js_2 = require("../type-extractors/typescript.js");
+const export_detection_js_1 = require("../export-detection.js");
+const resolver_factory_js_1 = require("../import-resolvers/resolver-factory.js");
+const typescript_javascript_js_2 = require("../import-resolvers/configs/typescript-javascript.js");
+const tree_sitter_queries_js_1 = require("../tree-sitter-queries.js");
+const typescript_js_3 = require("../field-extractors/typescript.js");
+const generic_js_2 = require("../field-extractors/generic.js");
+const typescript_javascript_js_3 = require("../field-extractors/configs/typescript-javascript.js");
+const generic_js_3 = require("../method-extractors/generic.js");
+const typescript_javascript_js_4 = require("../method-extractors/configs/typescript-javascript.js");
+const generic_js_4 = require("../variable-extractors/generic.js");
+const typescript_javascript_js_5 = require("../variable-extractors/configs/typescript-javascript.js");
+const generic_js_5 = require("../call-extractors/generic.js");
+const typescript_javascript_js_6 = require("../call-extractors/configs/typescript-javascript.js");
+const ts_js_hoc_utils_js_1 = require("../ts-js-hoc-utils.js");
+const index_js_2 = require("./typescript/index.js");
+const index_js_3 = require("./javascript/index.js");
+/**
+ * TypeScript/JavaScript: arrow_function and function_expression are
+ * anonymous AST nodes — they take their name from the surrounding
+ * declarative context.
+ *
+ * Recognised contexts:
+ *   - `const foo = () => {}` (variable_declarator) → "foo"
+ *   - `{ addItem: (item) => ... }` (pair / property_assignment) → "addItem"
+ *     Covers Zustand stores, TanStack Query factories, React Context
+ *     providers, and most other HOF-heavy idioms (issue #1166).
+ *   - `const X = HOC((args) => { ... })` (arguments → call_expression →
+ *     variable_declarator) → "X". Covers `React.forwardRef`, `memo`,
+ *     `useCallback`, `useMemo`, `observer`, `debounce`, and other HOC
+ *     factories that wrap their behaviour-defining arrow. Without this
+ *     branch, every shadcn/Radix UI component (`const Button =
+ *     React.forwardRef(...)`) registered as an anonymous arrow with
+ *     calls inside falling back to File-level attribution. The same
+ *     applied to all `useCallback` / `useMemo` callbacks bound to a
+ *     const — the sole way to give them a named caller anchor.
+ *
+ * Returns `null` for funcName when the arrow lives in a context that has
+ * no static name — bare call arguments (not bound to a const), computed
+ * keys, return-from-arrow positions. The parent walk in
+ * findEnclosingFunctionId then continues up to the next named ancestor
+ * (or to the file).
+ */
+const tsExtractFunctionName = (node, filePath) => {
+    if (node.type !== 'arrow_function' && node.type !== 'function_expression')
+        return null;
+    const parent = node.parent;
+    if (!parent)
+        return null;
+    if (parent.type === 'variable_declarator') {
+        let nameNode = parent.childForFieldName?.('name');
+        if (!nameNode) {
+            for (let i = 0; i < parent.childCount; i++) {
+                const c = parent.child(i);
+                if (c?.type === 'identifier') {
+                    nameNode = c;
+                    break;
+                }
+            }
+        }
+        return { funcName: nameNode?.text ?? null, label: 'Function' };
+    }
+    // Object property pair: `{ addItem: (item) => ... }`.
+    // tree-sitter-typescript uses `pair`; tree-sitter-javascript also exposes
+    // `pair`. (Older grammars used `property_assignment`; we accept both.)
+    if (parent.type === 'pair' || parent.type === 'property_assignment') {
+        const keyNode = parent.childForFieldName?.('key');
+        if (!keyNode)
+            return { funcName: null, label: 'Function' };
+        if (keyNode.type === 'property_identifier' || keyNode.type === 'identifier') {
+            return { funcName: keyNode.text, label: 'Function' };
+        }
+        if (keyNode.type === 'string') {
+            // `"add-item": () => ...` — the literal text inside the quotes.
+            const fragment = keyNode.children?.find((c) => c.type === 'string_fragment');
+            const text = fragment?.text ?? null;
+            return { funcName: text, label: 'Function' };
+        }
+        // computed_property_name (`[ACTION_KEY]`) and other dynamic keys have
+        // no static name — fall through anonymous.
+        return { funcName: null, label: 'Function' };
+    }
+    // HOC-wrapped variable declarations: `const Button = forwardRef((p, r) => { ... })`,
+    // `const handleClick = useCallback(() => doStuff(), [deps])`,
+    // `const Card = React.memo((props) => { ... })`. The arrow's `parent` is
+    // `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`.
+    //
+    // 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' &&
+                ts_js_hoc_utils_js_1.ARRAY_METHOD_HOC_BLOCKLIST_SET.has(property.text)) {
+                return { funcName: null, label: 'Function' };
+            }
+        }
+        const declarator = callExpr.parent;
+        // 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' };
+        }
+        // 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 (ts_js_hoc_utils_js_1.DEFAULT_EXPORT_IDENTIFIER_BLOCKLIST_SET.has(callee.text)) {
+                    return { funcName: null, label: 'Function' };
+                }
+                return {
+                    funcName: filePath ? (0, ts_js_hoc_utils_js_1.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 ? (0, ts_js_hoc_utils_js_1.deriveDefaultExportHocName)(filePath) : null,
+                    label: 'Function',
+                };
+            }
+            return { funcName: null, label: 'Function' };
+        }
+        return { funcName: null, label: 'Function' };
+    }
+    return { funcName: null, label: 'Function' };
+};
+exports.BUILT_INS = new Set([
+    'console',
+    'log',
+    'warn',
+    'error',
+    'info',
+    'debug',
+    'setTimeout',
+    'setInterval',
+    'clearTimeout',
+    'clearInterval',
+    'parseInt',
+    'parseFloat',
+    'isNaN',
+    'isFinite',
+    'encodeURI',
+    'decodeURI',
+    'encodeURIComponent',
+    'decodeURIComponent',
+    'JSON',
+    'parse',
+    'stringify',
+    'Object',
+    'Array',
+    'String',
+    'Number',
+    'Boolean',
+    'Symbol',
+    'BigInt',
+    'Map',
+    'Set',
+    'WeakMap',
+    'WeakSet',
+    'Promise',
+    'resolve',
+    'reject',
+    'then',
+    'catch',
+    'finally',
+    'Math',
+    'Date',
+    'RegExp',
+    'Error',
+    'require',
+    'import',
+    'export',
+    'fetch',
+    'Response',
+    'Request',
+    'useState',
+    'useEffect',
+    'useCallback',
+    'useMemo',
+    'useRef',
+    'useContext',
+    'useReducer',
+    'useLayoutEffect',
+    'useImperativeHandle',
+    'useDebugValue',
+    'createElement',
+    'createContext',
+    'createRef',
+    'forwardRef',
+    'memo',
+    'lazy',
+    'map',
+    'filter',
+    'reduce',
+    'forEach',
+    'find',
+    'findIndex',
+    'some',
+    'every',
+    'includes',
+    'indexOf',
+    'slice',
+    'splice',
+    'concat',
+    'join',
+    'split',
+    'push',
+    'pop',
+    'shift',
+    'unshift',
+    'sort',
+    'reverse',
+    'keys',
+    'values',
+    'entries',
+    'assign',
+    'freeze',
+    'seal',
+    'hasOwnProperty',
+    'toString',
+    'valueOf',
+]);
+/**
+ * `this` is the only receiver keyword JavaScript and TypeScript bind, and it
+ * is bound by every function form except an arrow (#2701). The query files
+ * tag those forms with `@receiver-owner.this`; this hook just reads the tag,
+ * so the node-type list stays in the one place that already names grammar
+ * nodes. See `Scope.ownsReceivers` for what the marker does to the walk.
+ */
+const TS_OWNED_RECEIVERS = new Set(['this']);
+const tsScopeOwnsReceivers = (match) => match['@receiver-owner.this'] === undefined ? undefined : TS_OWNED_RECEIVERS;
+exports.typescriptProvider = (0, language_provider_js_1.defineLanguage)({
+    id: index_js_1.SupportedLanguages.TypeScript,
+    extensions: ['.ts', '.tsx'],
+    entryPointPatterns: [/^use[A-Z]/],
+    astFrameworkPatterns: [
+        {
+            framework: 'nestjs',
+            entryPointMultiplier: 3.2,
+            reason: 'nestjs-decorator',
+            patterns: ['@Controller', '@Get', '@Post', '@Put', '@Delete', '@Patch'],
+        },
+        {
+            framework: 'expo-router',
+            entryPointMultiplier: 2.5,
+            reason: 'expo-router-navigation',
+            patterns: [
+                'router.push',
+                'router.replace',
+                'router.navigate',
+                'useRouter',
+                'useLocalSearchParams',
+                'useSegments',
+                'expo-router',
+            ],
+        },
+    ],
+    treeSitterQueries: tree_sitter_queries_js_1.TYPESCRIPT_QUERIES,
+    typeConfig: typescript_js_2.typeConfig,
+    scopeOwnsReceivers: tsScopeOwnsReceivers,
+    exportChecker: export_detection_js_1.tsExportChecker,
+    importResolver: (0, resolver_factory_js_1.createImportResolver)(typescript_javascript_js_2.typescriptImportConfig),
+    callExtractor: (0, generic_js_5.createCallExtractor)(typescript_javascript_js_6.typescriptCallConfig),
+    fieldExtractor: typescript_js_3.typescriptFieldExtractor,
+    methodExtractor: (0, generic_js_3.createMethodExtractor)({
+        ...typescript_javascript_js_4.typescriptMethodConfig,
+        extractFunctionName: tsExtractFunctionName,
+    }),
+    variableExtractor: (0, generic_js_4.createVariableExtractor)(typescript_javascript_js_5.typescriptVariableConfig),
+    classExtractor: (0, generic_js_1.createClassExtractor)(typescript_javascript_js_1.typescriptClassConfig),
+    // ── JSDoc → description (issue #2270). An exported decl is captured as the
+    //    inner declaration; its JSDoc precedes the wrapping `export_statement`. ──
+    descriptionExtractor: (0, ast_helpers_js_1.createLeadingDocDescriptionExtractor)({
+        wrapperNodeTypes: ['export_statement'],
+    }),
+    builtInNames: exports.BUILT_INS,
+    // Member-assignment shapes are not free functions (#2723 follow-up). The
+    // capture arrives anchored on the assignment, so the shape is decided from
+    // the left-hand side:
+    //   - `Foo.prototype.bar = fn` / `this.bar = fn` -> a Method
+    //   - a CJS export shadowing a name the module already declares -> no node
+    //     at all, since the scope declaration that would reach it is suppressed
+    //     too (an orphan `Function` twin beside `class Dup {}` otherwise).
+    // Every other `definition.function` capture keeps its default label.
+    labelOverride: (functionNode, defaultLabel) => defaultLabel !== 'Function'
+        ? defaultLabel
+        : functionNode.type === 'assignment_expression'
+            ? memberAssignmentLabel(functionNode)
+            : defaultLabel,
+    // ── RFC #909 Ring 3: scope-based resolution hooks (RFC §5) ──────────
+    // TypeScript is the third migration after Python and C#. See
+    // ./typescript/index.ts for the full per-hook rationale and the
+    // canonical capture vocabulary in ./typescript/query.ts
+    // (TYPESCRIPT_SCOPE_QUERY constant).
+    emitScopeCaptures: index_js_2.emitTsScopeCaptures,
+    // CFG/PDG substrate (#2081 M1) — runs in the worker on a --pdg run.
+    cfgVisitor: (0, typescript_js_1.createTypeScriptCfgVisitor)(),
+    interpretImport: index_js_2.interpretTsImport,
+    interpretTypeBinding: index_js_2.interpretTsTypeBinding,
+    bindingScopeFor: index_js_2.tsBindingScopeFor,
+    importOwningScope: index_js_2.tsImportOwningScope,
+    // Merge precedence is decided from BindingRef origin + declaration
+    // space only. The central finalizer already calls this per (scope,
+    // name), so the Scope object itself intentionally does not affect
+    // TypeScript declaration merging.
+    mergeBindings: (_scope, bindings) => (0, index_js_2.typescriptMergeBindings)(bindings),
+    receiverBinding: index_js_2.tsReceiverBinding,
+    arityCompatibility: index_js_2.typescriptArityCompatibility,
+    resolveImportTarget: index_js_2.resolveTsImportTarget,
+});
+exports.javascriptProvider = (0, language_provider_js_1.defineLanguage)({
+    id: index_js_1.SupportedLanguages.JavaScript,
+    extensions: ['.js', '.jsx'],
+    entryPointPatterns: [/^use[A-Z]/],
+    astFrameworkPatterns: [
+        {
+            framework: 'nestjs',
+            entryPointMultiplier: 3.2,
+            reason: 'nestjs-decorator',
+            patterns: ['@Controller', '@Get', '@Post', '@Put', '@Delete', '@Patch'],
+        },
+        {
+            framework: 'expo-router',
+            entryPointMultiplier: 2.5,
+            reason: 'expo-router-navigation',
+            patterns: [
+                'router.push',
+                'router.replace',
+                'router.navigate',
+                'useRouter',
+                'useLocalSearchParams',
+                'useSegments',
+                'expo-router',
+            ],
+        },
+    ],
+    treeSitterQueries: tree_sitter_queries_js_1.JAVASCRIPT_QUERIES,
+    typeConfig: typescript_js_2.typeConfig,
+    scopeOwnsReceivers: tsScopeOwnsReceivers,
+    exportChecker: export_detection_js_1.tsExportChecker,
+    importResolver: (0, resolver_factory_js_1.createImportResolver)(typescript_javascript_js_2.javascriptImportConfig),
+    callExtractor: (0, generic_js_5.createCallExtractor)(typescript_javascript_js_6.javascriptCallConfig),
+    fieldExtractor: (0, generic_js_2.createFieldExtractor)(typescript_javascript_js_3.javascriptConfig),
+    methodExtractor: (0, generic_js_3.createMethodExtractor)({
+        ...typescript_javascript_js_4.javascriptMethodConfig,
+        extractFunctionName: tsExtractFunctionName,
+    }),
+    variableExtractor: (0, generic_js_4.createVariableExtractor)(typescript_javascript_js_5.javascriptVariableConfig),
+    classExtractor: (0, generic_js_1.createClassExtractor)(typescript_javascript_js_1.javascriptClassConfig),
+    // ── JSDoc → description (issue #2270). An exported decl is captured as the
+    //    inner declaration; its JSDoc precedes the wrapping `export_statement`. ──
+    descriptionExtractor: (0, ast_helpers_js_1.createLeadingDocDescriptionExtractor)({
+        wrapperNodeTypes: ['export_statement'],
+    }),
+    builtInNames: exports.BUILT_INS,
+    // Member-assignment shapes — see the TypeScript provider above.
+    labelOverride: (functionNode, defaultLabel) => defaultLabel !== 'Function'
+        ? defaultLabel
+        : functionNode.type === 'assignment_expression'
+            ? memberAssignmentLabel(functionNode)
+            : defaultLabel,
+    // ── RFC #909 Ring 3: scope-based resolution hooks (RFC §5) ──────────
+    // JavaScript is the fourth migration after Python, C#, and TypeScript.
+    // Hooks are thin wrappers over the TypeScript implementations where
+    // semantics are identical; JS-specific additions (CJS require(),
+    // JSDoc type bindings) live in ./javascript/captures.ts.
+    // See ./javascript/index.ts for the full per-module rationale.
+    emitScopeCaptures: index_js_3.emitJsScopeCaptures,
+    // CFG/PDG substrate (#2081 M1) — TS and JS share the same grammar family.
+    cfgVisitor: (0, typescript_js_1.createTypeScriptCfgVisitor)(),
+    interpretImport: index_js_3.interpretJsImport,
+    interpretTypeBinding: index_js_3.interpretJsTypeBinding,
+    bindingScopeFor: index_js_3.jsBindingScopeFor,
+    importOwningScope: index_js_3.jsImportOwningScope,
+    mergeBindings: (_scope, bindings) => (0, index_js_3.jsMergeBindings)(bindings),
+    receiverBinding: index_js_3.jsReceiverBinding,
+    arityCompatibility: index_js_3.jsArityCompatibility,
+});

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

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitVueScopeCaptures = emitVueScopeCaptures;
+const vue_sfc_extractor_js_1 = require("../../vue-sfc-extractor.js");
+const captures_js_1 = require("../typescript/captures.js");
+const captures_js_2 = require("../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).
+ */
+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 (0, captures_js_1.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 (0, captures_js_1.emitTsScopeCaptures)(sourceText, filePath, cachedTree);
+    }
+    const extracted = (0, vue_sfc_extractor_js_1.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 (0, captures_js_2.emitJsScopeCaptures)(extracted.scriptContent, filePath, cachedTree);
+    }
+    return (0, captures_js_1.emitTsScopeCaptures)(extracted.scriptContent, filePath, cachedTree);
+}

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

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * 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).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeVueResolveImportTarget = makeVueResolveImportTarget;
+const index_js_1 = require("../../../../../shared/index.js");
+const import_target_js_1 = require("../typescript/import-target.js");
+const utils_js_1 = require("../../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.
+ */
+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: (0, utils_js_1.buildSuffixIndex)(normalizedFileList, allFileList),
+                resolveCache: new Map(),
+            };
+        }
+        const cfg = resolutionConfig;
+        const ws = {
+            fromFile,
+            language: index_js_1.SupportedLanguages.TypeScript,
+            allFilePaths: cached.allFilePaths,
+            allFileList: cached.allFileList,
+            normalizedFileList: cached.normalizedFileList,
+            index: cached.index,
+            resolveCache: cached.resolveCache,
+            tsconfigPaths: cfg?.tsconfigPaths ?? null,
+        };
+        return (0, import_target_js_1.resolveTsTarget)(targetRaw, ws);
+    };
+}

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

@@ -0,0 +1,55 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vueScopeResolver = exports.makeVueResolveImportTarget = exports.emitVueScopeCaptures = void 0;
+var captures_js_1 = require("./captures.js");
+Object.defineProperty(exports, "emitVueScopeCaptures", { enumerable: true, get: function () { return captures_js_1.emitVueScopeCaptures; } });
+var import_target_js_1 = require("./import-target.js");
+Object.defineProperty(exports, "makeVueResolveImportTarget", { enumerable: true, get: function () { return import_target_js_1.makeVueResolveImportTarget; } });
+var scope_resolver_js_1 = require("./scope-resolver.js");
+Object.defineProperty(exports, "vueScopeResolver", { enumerable: true, get: function () { return scope_resolver_js_1.vueScopeResolver; } });