gitnexus 1.6.10-rc.21 → 1.6.10-rc.211

package/dist/core/ingestion/languages/typescript/simple-hooks.js

@@ -4,6 +4,7 @@
  * the provider's choice explicit rather than relying on "absence ==
  * default" so reviewers don't have to re-derive the analysis.
  */
+import { walkToScope } from '../../utils/scope-tree-walk.js';
 // ─── bindingScopeFor ──────────────────────────────────────────────────────
 /**
  * TypeScript/JavaScript has block-scoped `let`/`const` (the innermost
@@ -38,6 +39,27 @@ export function tsBindingScopeFor(decl, innermost, tree) {
     if (decl['@type-binding.parameter-property'] !== undefined) {
         return walkToScope(innermost, tree, 'Class');
     }
+    // `this.p = new Outer()` binds the FIELD, not a method-local, so the binding
+    // belongs on the class the way an annotated field's does — that is the only
+    // place `typeOfMemberOnClass` reads. Left on the innermost scope it would sit
+    // on the method's own Function scope and never be found (#2807). Same shape
+    // as the parameter-property branch above.
+    //
+    // Gated on the marker the `this.<field> = new …` pattern emits, never on
+    // `@type-binding.constructor` at large: that capture also fires for
+    // `const o = new Outer()` inside a method, and hoisting THOSE to the class
+    // would take method locals out of their own scope and mistype them.
+    //
+    // This walk is UNCONDITIONAL by design, and stays correct only because the
+    // marker's producers are bounded: the query nests the pattern under
+    // `class_body → method_definition → statement_block`, and `emitTsScopeCaptures`
+    // drops the static-method case. So `this` here provably IS an instance of the
+    // class this lands on, and a Class ancestor always exists — no `walkToScope`
+    // null-fallback onto some unrelated innermost scope. Anything that widens the
+    // marker's producers has to re-establish both, or restore the guard here.
+    if (decl['@type-binding.this-field'] !== undefined) {
+        return walkToScope(innermost, tree, 'Class');
+    }
     // `var` declarations: hoist to nearest enclosing Function or Module.
     const variable = decl['@declaration.variable'];
     if (variable !== undefined && isVarDeclaration(variable.text)) {
@@ -51,28 +73,6 @@ export function tsBindingScopeFor(decl, innermost, tree) {
     // needed.
     return null;
 }
-/**
- * Walk up the scope chain to find the first scope whose `kind` matches
- * any of `kinds`. Returns the matching scope's id or `null` when no
- * ancestor matches (e.g., a return type binding emitted outside any
- * Module scope — shouldn't happen in well-formed input).
- *
- * Exported so language-specific hook wrappers (e.g. `jsBindingScopeFor`)
- * can reuse it without duplicating the traversal logic.
- */
-export function walkToScope(from, tree, ...kinds) {
-    let cur = from;
-    const kindSet = new Set(kinds);
-    while (cur !== undefined) {
-        if (kindSet.has(cur.kind))
-            return cur.id;
-        const parentId = cur.parent ?? null;
-        if (parentId === null)
-            break;
-        cur = tree.getScope(parentId);
-    }
-    return null;
-}
 /** `var x = 1;` vs `let x = 1;` / `const x = 1;`. The capture's text
  *  starts at the outer declaration's `startIndex` in source, which is
  *  the keyword's first character — no leading whitespace possible. */

package/dist/core/ingestion/languages/typescript/tsconfig.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Real `tsconfig.json` loading for module resolution (#2953).
+ *
+ * The previous loader (`language-config.ts:loadTsconfigPaths`) was built to feed
+ * a heuristic, and it shows: it reads three filenames at the repo ROOT only,
+ * gives up unless `compilerOptions.paths` exists, keeps only `targets[0]` of
+ * each mapping, and treats a pattern as a plain prefix. That is enough to make
+ * a guess look plausible and not enough to resolve anything correctly:
+ *
+ *   - a monorepo has one tsconfig PER PACKAGE, and `apps/web/tsconfig.json` is
+ *     what governs `apps/web/src/main.ts` — the root config governs nothing;
+ *   - `extends` is how essentially every real config is written, and the
+ *     `baseUrl` / `paths` almost always live in the extended base;
+ *   - `baseUrl` alone (no `paths`) is a complete resolution rule on its own, and
+ *     it is exactly the rule that makes `import 'src/utils/foo'` legal — the
+ *     case the old suffix matcher was really standing in for;
+ *   - `paths` maps a pattern to an ORDERED LIST of targets, tried in order.
+ *
+ * So this module answers the question TypeScript actually asks: for THIS file,
+ * what are `baseUrl` and `paths`?
+ */
+/** One `paths` entry, pattern and targets kept in declaration order. */
+export interface TsPathMapping {
+    /** The pattern as written, e.g. `@/*`, `@app/*`, `exact`. */
+    readonly pattern: string;
+    /** Targets as written, relative to `baseUrl`. Tried in order. */
+    readonly targets: readonly string[];
+}
+/** The resolution-relevant part of one resolved tsconfig. */
+export interface TsconfigScope {
+    /** Repo-relative directory the config governs (the tsconfig's own directory). */
+    readonly dir: string;
+    /**
+     * Repo-relative `baseUrl`, or `null` when the config declares none.
+     *
+     * `null` is not the same as `'.'`: without `baseUrl`, TypeScript does NOT
+     * resolve non-relative specifiers against the project at all (they are
+     * package lookups), and `paths` targets are resolved against the tsconfig's
+     * own directory instead.
+     */
+    readonly baseUrl: string | null;
+    readonly paths: readonly TsPathMapping[];
+}
+/** Every tsconfig in the repo, indexed so the nearest one to a file wins. */
+export interface TsconfigIndex {
+    /** Deepest-first, so the first `dir` that prefixes a file path governs it. */
+    readonly scopes: readonly TsconfigScope[];
+}
+/**
+ * The config governing `filePath` — the nearest tsconfig at or above it.
+ *
+ * TypeScript resolves a file against the project that includes it; the nearest
+ * enclosing tsconfig is the faithful approximation of that without evaluating
+ * `include`/`exclude` globs, and it is what makes a monorepo's per-package
+ * `baseUrl` apply to that package's files instead of the root's.
+ */
+export declare function tsconfigFor(index: TsconfigIndex | null, filePath: string): TsconfigScope | null;
+/** Load every tsconfig in the repo, resolving `extends` chains. */
+export declare function loadTsconfigIndex(repoRoot: string): Promise<TsconfigIndex | null>;

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

@@ -0,0 +1,291 @@
+/**
+ * Real `tsconfig.json` loading for module resolution (#2953).
+ *
+ * The previous loader (`language-config.ts:loadTsconfigPaths`) was built to feed
+ * a heuristic, and it shows: it reads three filenames at the repo ROOT only,
+ * gives up unless `compilerOptions.paths` exists, keeps only `targets[0]` of
+ * each mapping, and treats a pattern as a plain prefix. That is enough to make
+ * a guess look plausible and not enough to resolve anything correctly:
+ *
+ *   - a monorepo has one tsconfig PER PACKAGE, and `apps/web/tsconfig.json` is
+ *     what governs `apps/web/src/main.ts` — the root config governs nothing;
+ *   - `extends` is how essentially every real config is written, and the
+ *     `baseUrl` / `paths` almost always live in the extended base;
+ *   - `baseUrl` alone (no `paths`) is a complete resolution rule on its own, and
+ *     it is exactly the rule that makes `import 'src/utils/foo'` legal — the
+ *     case the old suffix matcher was really standing in for;
+ *   - `paths` maps a pattern to an ORDERED LIST of targets, tried in order.
+ *
+ * So this module answers the question TypeScript actually asks: for THIS file,
+ * what are `baseUrl` and `paths`?
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import { isHardcodedIgnoredDirectory } from '../../../../config/ignore-service.js';
+import { logger } from '../../../logger.js';
+const SCAN_MAX_DIRS = 20_000;
+const SCAN_MAX_DEPTH = 24;
+/** Guard against an `extends` cycle or a pathological chain. */
+const MAX_EXTENDS_DEPTH = 16;
+/**
+ * The config governing `filePath` — the nearest tsconfig at or above it.
+ *
+ * TypeScript resolves a file against the project that includes it; the nearest
+ * enclosing tsconfig is the faithful approximation of that without evaluating
+ * `include`/`exclude` globs, and it is what makes a monorepo's per-package
+ * `baseUrl` apply to that package's files instead of the root's.
+ */
+export function tsconfigFor(index, filePath) {
+    if (index === null)
+        return null;
+    for (const scope of index.scopes) {
+        if (scope.dir === '')
+            return scope;
+        if (filePath.startsWith(`${scope.dir}/`))
+            return scope;
+    }
+    return null;
+}
+/** Load every tsconfig in the repo, resolving `extends` chains. */
+export async function loadTsconfigIndex(repoRoot) {
+    const files = await findTsconfigFiles(repoRoot);
+    if (files.length === 0)
+        return null;
+    const ranked = [];
+    for (const absPath of files) {
+        const options = await readCompilerOptions(absPath, 0);
+        if (options === null)
+            continue;
+        // `readCompilerOptions` resolves both to ABSOLUTE paths against whichever
+        // config in the `extends` chain declared them, which is the only way the
+        // chain stays unambiguous. Rebasing to repo-relative happens once, here.
+        const baseUrl = options.baseUrl === undefined ? null : repoRelative(repoRoot, options.baseUrl);
+        const paths = (options.paths ?? []).map((mapping) => ({
+            pattern: mapping.pattern,
+            targets: mapping.targets.map((t) => rebaseTarget(repoRoot, t)),
+        }));
+        // A config declaring NEITHER is kept, not skipped. Dropping it let
+        // `tsconfigFor` fall through to an enclosing config, so a package whose own
+        // tsconfig declares no `baseUrl` — meaning its non-relative specifiers are
+        // package lookups — silently inherited the repo root's aliases instead.
+        // An empty scope is the accurate answer for such a file, and only a scope
+        // can express it.
+        ranked.push({
+            scope: { dir: repoRelative(repoRoot, path.dirname(absPath)), baseUrl, paths },
+            rank: configRank(path.basename(absPath)),
+        });
+    }
+    if (ranked.length === 0)
+        return null;
+    // Deepest first, because `tsconfigFor` takes the first match and it must be
+    // the most specific config rather than whichever the walk reached first.
+    //
+    // Then by filename rank WITHIN a directory, which is the half that is easy to
+    // miss: `tsconfig.json` and `tsconfig.base.json` routinely sit side by side,
+    // and the base exists to be extended, not to govern. Reading whichever the
+    // directory listing returned first made a config's own `paths` invisible
+    // whenever its base happened to be listed earlier.
+    ranked.sort((a, b) => b.scope.dir.length - a.scope.dir.length || a.rank - b.rank);
+    return { scopes: ranked.map((entry) => entry.scope) };
+}
+/**
+ * Precedence among configs sharing a directory: the project config governs, and
+ * everything else is a base or a variant that exists to be extended.
+ */
+function configRank(fileName) {
+    if (fileName === 'tsconfig.json')
+        return 0;
+    if (fileName === 'jsconfig.json')
+        return 1;
+    return 2;
+}
+/**
+ * Read one tsconfig and merge in whatever it `extends`.
+ *
+ * Rebasing happens per FILE, before merging, because `extends` does not rebase
+ * `baseUrl`: a base config at `configs/tsconfig.base.json` declaring
+ * `"baseUrl": "."` means `configs/`, even when extended from `apps/web`. Doing
+ * the rebase at read time is what keeps that true through the chain.
+ */
+async function readCompilerOptions(absPath, depth, repoRootHint) {
+    if (depth > MAX_EXTENDS_DEPTH) {
+        logger.warn(`[typescript] tsconfig extends chain too deep at ${absPath}; ignoring the rest`);
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = parseJsonc(await fs.readFile(absPath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+    const dir = path.dirname(absPath);
+    // Read what this config extends FIRST: `paths` targets resolve against the
+    // EFFECTIVE `baseUrl`, which a config declaring `paths` alone inherits from
+    // its base. Resolving them against this config's own directory instead would
+    // load the right alias pattern and point every target at the wrong place.
+    const inherited = await readExtended(parsed.extends, dir, depth, repoRootHint);
+    const own = {};
+    const compilerOptions = parsed.compilerOptions;
+    if (compilerOptions !== null && typeof compilerOptions === 'object') {
+        const opts = compilerOptions;
+        if (typeof opts.baseUrl === 'string') {
+            own.baseUrl = path.resolve(dir, opts.baseUrl);
+        }
+        if (opts.paths !== null && typeof opts.paths === 'object' && !Array.isArray(opts.paths)) {
+            // tsc resolves `paths` targets against the effective `baseUrl` — this
+            // config's own if it declares one, otherwise the inherited one — and
+            // against the config's own directory only when neither exists. Doing it
+            // here, per file, is what keeps an `extends` chain unambiguous: by the
+            // time these merge, every target is already absolute.
+            const pathsBase = own.baseUrl ?? inherited?.baseUrl ?? dir;
+            own.paths = [];
+            for (const [pattern, targets] of Object.entries(opts.paths)) {
+                if (!Array.isArray(targets))
+                    continue;
+                const asStrings = targets
+                    .filter((t) => typeof t === 'string')
+                    .map((t) => path.resolve(pathsBase, t));
+                if (asStrings.length > 0)
+                    own.paths.push({ pattern, targets: asStrings });
+            }
+        }
+    }
+    // Own options win over inherited ones — that is what `extends` means. `paths`
+    // is replaced wholesale rather than merged, matching tsc.
+    return {
+        ...(inherited ?? {}),
+        ...own,
+    };
+}
+/** Follow `extends`, which may be a string or (TS 5+) an array, base-first. */
+async function readExtended(value, fromDir, depth, repoRootHint) {
+    const specs = typeof value === 'string' ? [value] : Array.isArray(value) ? value : [];
+    let merged = null;
+    for (const spec of specs) {
+        if (typeof spec !== 'string')
+            continue;
+        const resolved = await resolveExtendsTarget(spec, fromDir);
+        if (resolved === null)
+            continue;
+        const options = await readCompilerOptions(resolved, depth + 1, repoRootHint);
+        if (options === null)
+            continue;
+        // Later entries win over earlier ones, per tsc's array semantics.
+        merged = { ...(merged ?? {}), ...options };
+    }
+    return merged;
+}
+/**
+ * An `extends` value is either a path or a package name.
+ *
+ * The package form (`"extends": "@tsconfig/node20/tsconfig.json"`,
+ * `"@acme/tsconfig"`) lives in `node_modules`, which this tool deliberately
+ * does NOT index — it is dependency code, not the repository's own. But not
+ * indexing it is different from not READING it, and the distinction matters
+ * here: a shared internal base config is exactly where a monorepo puts the
+ * `paths` its packages import through, so refusing to open it loses aliases
+ * that the repository genuinely declares.
+ *
+ * So the file is read from disk when it is there, walking `node_modules` up
+ * from the extending config the way Node does. When it is absent — an
+ * un-installed checkout, which is a shape a static analyser must expect and a
+ * compiler may refuse — the answer is `null`, and the caller keeps whatever the
+ * extending config declared itself. That degrades to fewer resolutions, never
+ * to invented ones.
+ */
+async function resolveExtendsTarget(spec, fromDir) {
+    if (spec.startsWith('.') || path.isAbsolute(spec)) {
+        return firstReadableConfig(path.resolve(fromDir, spec));
+    }
+    for (const modulesDir of nodeModulesChain(fromDir)) {
+        const found = await firstReadableConfig(path.join(modulesDir, spec));
+        if (found !== null)
+            return found;
+    }
+    return null;
+}
+/** `<dir>/node_modules`, then each ancestor's, the way Node resolves. */
+function* nodeModulesChain(fromDir) {
+    let dir = fromDir;
+    for (;;) {
+        if (path.basename(dir) !== 'node_modules')
+            yield path.join(dir, 'node_modules');
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return;
+        dir = parent;
+    }
+}
+/** The first spelling of `base` that is a readable file. */
+async function firstReadableConfig(base) {
+    for (const candidate of [base, `${base}.json`, path.join(base, 'tsconfig.json')]) {
+        try {
+            const stat = await fs.stat(candidate);
+            if (stat.isFile())
+                return candidate;
+        }
+        catch {
+            // try the next spelling
+        }
+    }
+    return null;
+}
+async function findTsconfigFiles(repoRoot) {
+    const found = [];
+    const queue = [{ dir: repoRoot, depth: 0 }];
+    let dirsScanned = 0;
+    while (queue.length > 0 && dirsScanned < SCAN_MAX_DIRS) {
+        const { dir, depth } = queue.shift();
+        dirsScanned++;
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                if (isHardcodedIgnoredDirectory(entry.name))
+                    continue;
+                if (depth < SCAN_MAX_DEPTH)
+                    queue.push({ dir: path.join(dir, entry.name), depth: depth + 1 });
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            // `tsconfig.json`, `tsconfig.app.json`, `jsconfig.json`, … — any of them
+            // can carry the `baseUrl`/`paths` that governs its directory.
+            if (/^(ts|js)config(\..+)?\.json$/.test(entry.name)) {
+                found.push(path.join(dir, entry.name));
+            }
+        }
+    }
+    return found;
+}
+/** Strip comments and trailing commas — tsconfig is JSONC, not JSON. */
+function parseJsonc(raw) {
+    const withoutComments = raw
+        .replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*$)|(\/\*[\s\S]*?\*\/)/gm, (match, line, block) => line !== undefined || block !== undefined ? '' : match)
+        .replace(/,(\s*[}\]])/g, '$1');
+    return JSON.parse(withoutComments);
+}
+function repoRelative(repoRoot, absDir) {
+    const rel = path.relative(repoRoot, absDir).split(path.sep).join('/');
+    return rel === '.' || rel === '' ? '' : rel;
+}
+/**
+ * A `paths` target rebased to repo-relative, keeping any trailing `*`.
+ *
+ * `path.resolve` swallows the wildcard into a path segment, so it is stripped
+ * before resolving and re-appended after — the `*` is a substitution marker,
+ * not a directory named `*`.
+ */
+function rebaseTarget(repoRoot, absTarget) {
+    // `/repo/src/*` must come back as `src/*`, not `src*`: stripping only the
+    // star leaves a trailing slash that `path.relative` then eats.
+    const suffix = absTarget.endsWith('/*') ? '/*' : absTarget.endsWith('*') ? '*' : '';
+    const base = suffix === '' ? absTarget : absTarget.slice(0, -suffix.length);
+    return `${repoRelative(repoRoot, base)}${suffix}`;
+}

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

@@ -9,7 +9,51 @@ import { SupportedLanguages } from '../../../_shared/index.js';
 import { defineLanguage } from '../language-provider.js';
 import { createClassExtractor } from '../class-extractors/generic.js';
 import { typescriptClassConfig, javascriptClassConfig, } from '../class-extractors/configs/typescript-javascript.js';
-import { createLeadingDocDescriptionExtractor } from '../utils/ast-helpers.js';
+import { createLeadingDocDescriptionExtractor, isCjsDefaultExportAssignment, isPrototypeMemberAssignmentNode, } from '../utils/ast-helpers.js';
+import { cjsExportedNameFor, isModuleLevelThisAssignment, isModuleLevelThisExport, isShadowedCjsExportAssignmentNode, } from './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 && 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 && isModuleLevelThisExport(node, root))
+        return 'Function';
+    // `module.exports = fn` — the module itself is the callable.
+    if (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 (isModuleLevelThisAssignment(node))
+        return null;
+    if (isPrototypeMemberAssignmentNode(node))
+        return 'Method';
+    if (isShadowedCjsExportNode(node))
+        return null;
+    const value = node.childForFieldName('right');
+    if (root === undefined || value === null)
+        return null;
+    return cjsExportedNameFor(value, root) !== null ? 'Function' : null;
+};
 import { createTypeScriptCfgVisitor } from '../cfg/visitors/typescript.js';
 import { typeConfig as typescriptConfig } from '../type-extractors/typescript.js';
 import { tsExportChecker } from '../export-detection.js';
@@ -28,6 +72,12 @@ import { typescriptCallConfig, javascriptCallConfig, } from '../call-extractors/
 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';
+import { extractDispatchGuardRoutes } from '../route-extractors/dispatch-guard.js';
+import { extractDataRouteTableRoutes } from '../route-extractors/data-route-table.js';
+const extractJsTsRoutes = (...args) => [
+    ...extractDispatchGuardRoutes(...args),
+    ...extractDataRouteTableRoutes(...args),
+];
 /**
  * TypeScript/JavaScript: arrow_function and function_expression are
  * anonymous AST nodes — they take their name from the surrounding
@@ -250,6 +300,15 @@ export const BUILT_INS = new Set([
     '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;
 export const typescriptProvider = defineLanguage({
     id: SupportedLanguages.TypeScript,
     extensions: ['.ts', '.tsx'],
@@ -278,6 +337,7 @@ export const typescriptProvider = defineLanguage({
     ],
     treeSitterQueries: TYPESCRIPT_QUERIES,
     typeConfig: typescriptConfig,
+    scopeOwnsReceivers: tsScopeOwnsReceivers,
     exportChecker: tsExportChecker,
     importResolver: createImportResolver(typescriptImportConfig),
     callExtractor: createCallExtractor(typescriptCallConfig),
@@ -294,6 +354,19 @@ export const typescriptProvider = defineLanguage({
         wrapperNodeTypes: ['export_statement'],
     }),
     builtInNames: 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
@@ -314,6 +387,10 @@ export const typescriptProvider = defineLanguage({
     receiverBinding: tsReceiverBinding,
     arityCompatibility: typescriptArityCompatibility,
     resolveImportTarget: resolveTsImportTarget,
+    // A raw `node:http` server declares its routes by comparing the request path
+    // to a literal; nothing else in this pipeline can see that shape. TS and JS
+    // share the grammar, so they share the extractor.
+    extractDecoratorRoutes: extractJsTsRoutes,
 });
 export const javascriptProvider = defineLanguage({
     id: SupportedLanguages.JavaScript,
@@ -343,6 +420,7 @@ export const javascriptProvider = defineLanguage({
     ],
     treeSitterQueries: JAVASCRIPT_QUERIES,
     typeConfig: typescriptConfig,
+    scopeOwnsReceivers: tsScopeOwnsReceivers,
     exportChecker: tsExportChecker,
     importResolver: createImportResolver(javascriptImportConfig),
     callExtractor: createCallExtractor(javascriptCallConfig),
@@ -359,6 +437,12 @@ export const javascriptProvider = defineLanguage({
         wrapperNodeTypes: ['export_statement'],
     }),
     builtInNames: 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
@@ -375,4 +459,6 @@ export const javascriptProvider = defineLanguage({
     mergeBindings: (_scope, bindings) => jsMergeBindings(bindings),
     receiverBinding: jsReceiverBinding,
     arityCompatibility: jsArityCompatibility,
+    // See the TypeScript provider above.
+    extractDecoratorRoutes: extractJsTsRoutes,
 });

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

@@ -1,27 +1,11 @@
 /**
  * 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.
+ * `<script>` / `<script setup>` blocks are TypeScript or plain JavaScript, so
+ * resolution is TypeScript's: the same tsconfig `paths`/`baseUrl` rules and the
+ * same `package.json` manifests. `.vue` imports are written with an explicit
+ * extension (`'./Button.vue'`) and `.vue` is in the candidate list, so no
+ * Vue-specific guessing is required — the exact-path branch finds them first.
  */
+/** Build the Vue `resolveImportTarget` adapter. */
 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

@@ -1,58 +1,22 @@
 /**
  * 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).
+ * `<script>` / `<script setup>` blocks are TypeScript or plain JavaScript, so
+ * resolution is TypeScript's: the same tsconfig `paths`/`baseUrl` rules and the
+ * same `package.json` manifests. `.vue` imports are written with an explicit
+ * extension (`'./Button.vue'`) and `.vue` is in the candidate list, so no
+ * Vue-specific guessing is required — the exact-path branch finds them first.
  */
-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.
- */
+/** Build the Vue `resolveImportTarget` adapter. */
 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 = {
+        return resolveTsTarget(targetRaw, {
             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);
+            allFilePaths,
+            tsconfigs: cfg?.tsconfigs ?? null,
+            nodeWorkspacePackages: cfg?.nodeWorkspacePackages ?? null,
+        });
     };
 }