gitnexus 1.6.10-rc.99 → 1.6.10

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

@@ -18,7 +18,9 @@
  *      inferred from leading JSDoc comments. A lightweight regex scanner
  *      (`parseJsDocParams` / `parseJsDocReturn`) extracts `@param {T} n`
  *      and `@returns {T}` tags and emits synthetic captures positioned on
- *      the annotated function node.
+ *      the annotated function node. `@type {T}` on a class FIELD is the same
+ *      story one level down — it is the only way JavaScript can declare a
+ *      field's type at all — and emits `@type-binding.class-field` (#2833).
  *
  *   4. **Shared synthesis passes** — destructuring, for-of map-tuple, and
  *      instanceof narrowing passes are duplicated from `typescript/captures.ts`
@@ -32,19 +34,58 @@ import { getJsParser, getJsScopeQuery, jsCachedTreeMatchesGrammar } from './quer
 import { computeTsArityMetadata } from '../typescript/arity-metadata.js';
 import { synthesizeTsReceiverBinding } from '../typescript/receiver-binding.js';
 import { isArrayMethodCallbackArrow } from '../typescript/array-callback.js';
+import { isStaticClassFieldBinding } from '../typescript/captures.js';
+import { reducesToContainedType } from '../typescript/interpret.js';
+/** JavaScript's spelling of a class-field declaration — the TypeScript grammar
+ *  calls the same construct `public_field_definition`. Named here, not in the
+ *  shared predicate, so each literal is checked against the grammar of the file
+ *  it lives in (`grammar-literal-validation`). */
+const JS_CLASS_FIELD_DEFINITION_TYPES = new Set(['field_definition']);
+import { hasKeyword } from '../../field-extractors/configs/helpers.js';
+import { synthesizeCjsModuleExports } from '../typescript/cjs-module-exports.js';
+import { isShadowedCjsExportAssignment, isUnexportedMemberAssignmentValue, isUndeclarableThisMemberValue, } from '../typescript/cjs-export-assignment.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
 import { synthesizeCallableFlowCaptures } from '../../utils/callable-flow-captures.js';
+import { synthesizeReceiverChainCapture } from '../../utils/receiver-chain-captures.js';
 import { deriveDefaultExportHocName, isBlockedDefaultExportHoc, isDefaultExportHocFunctionNode, } from '../../ts-js-hoc-utils.js';
 /** JS function-like node types that may carry a synthesized `this` binding.
  *  Kept in sync with the `@scope.function` patterns in `query.ts`. */
-const FUNCTION_NODE_TYPES = [
+export const FUNCTION_NODE_TYPES = [
     'method_definition',
     'arrow_function',
     'function_expression',
     'function_declaration',
     'generator_function_declaration',
+    // The EXPRESSION form (`const g = function* () {}`) — see the matching note
+    // in `typescript/captures.ts`.
+    'generator_function',
 ];
+/** Nodes whose `statement_block` child is their BODY, not a nested block. */
+const JS_FUNCTION_BODY_OWNER_TYPES = new Set(FUNCTION_NODE_TYPES);
+/** Direct-child node types that create a BINDING in their enclosing block.
+ *  `variable_declaration` (`var`) is deliberately absent: it hoists past the
+ *  block to the function, so a block containing only `var` binds nothing. */
+const BLOCK_BINDING_CHILD_TYPES = new Set([
+    'lexical_declaration',
+    'class_declaration',
+    'function_declaration',
+    'generator_function_declaration',
+]);
+/** True when `block` directly declares a name, i.e. it is a real environment
+ *  record rather than punctuation. A block that binds nothing is transparent to
+ *  every scope-chain walk — a lookup finds nothing in it and continues to the
+ *  parent — so emitting a scope for it costs tree size and walk depth and buys
+ *  exactly nothing. Only DIRECT children count: a declaration in a nested block
+ *  belongs to that block, which gets its own scope by the same rule. */
+const blockDeclaresBinding = (block) => {
+    for (let i = 0; i < block.namedChildCount; i++) {
+        const child = block.namedChild(i);
+        if (child !== null && BLOCK_BINDING_CHILD_TYPES.has(child.type))
+            return true;
+    }
+    return false;
+};
 /** Declaration anchors that carry function-like arity metadata. */
 const FUNCTION_DECL_TAGS = ['@declaration.method', '@declaration.function'];
 /** Callsite anchors that should carry `@reference.arity` + param types. */
@@ -294,9 +335,133 @@ function parseJsDocType(text) {
     const m = /@type\s+\{([^}]+)\}/.exec(text);
     return m ? m[1].trim() : null;
 }
+/**
+ * A type REFERENCE, possibly qualified, generic, or unioned:
+ * `Repo`, `Repo<User>`, `models.Repo`, `Handler<Req, Res>`, `Repo|null`,
+ * `Repo<User> | null`.
+ *
+ * Applied only to a string already capped by {@link JSDOC_TYPE_MAX_LENGTH}:
+ * the union and generic groups both nest quantifiers, so an unbounded
+ * non-matching input is a backtracking hazard, and a docblock's `{…}` payload
+ * is attacker-shaped text (it is whatever the file says).
+ *
+ * JSDoc's `{…}` payload is free text and carries shapes that are not
+ * references at all — record types (`{{a: number}}`), function types
+ * (`{function(string): void}`), the any-type `{*}`, parenthesized unions
+ * (`{(Repo|Other)}`). None of those name a class, so a field annotated with
+ * one is DECLINED rather than bound to whatever substring survives
+ * normalization. (`parseJsDocType`'s `[^}]+` also truncates a record type at
+ * its first `}`, which this rejects too.)
+ */
+/** Longest `@type {…}` payload considered. A type REFERENCE that names a class
+ *  is far shorter; past this the string is a structural type or generated
+ *  noise, which this pass declines anyway, and the cap is what keeps
+ *  {@link JSDOC_TYPE_REFERENCE_RE}'s nested quantifiers off an unbounded
+ *  input. */
+const JSDOC_TYPE_MAX_LENGTH = 200;
+const JSDOC_TYPE_REFERENCE_RE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*(?:\s*<[\w$.,<>\s]*>)?(?:\s*\|\s*[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*(?:\s*<[\w$.,<>\s]*>)?)*$/;
+/**
+ * The spelling a JSDoc `@type` should bind a class FIELD to, or `null` to
+ * decline.
+ *
+ * The as-written spelling is returned, NOT a reduced one: `interpretJsTypeBinding`
+ * carries `Repo<User>` through to `TypeRef.rawName` untouched (user generics are
+ * not on `stripGeneric`'s wrapper list), and `resolveClassBindingForName` erases
+ * the arguments to `Repo` at lookup time. That is the same erasure every other
+ * language in #2833 relies on, so generics need no code here — verified, not
+ * assumed, by the capture probe in that issue.
+ *
+ * Two declines:
+ *   - `reducesToContainedType` — the container spellings whose interpretation
+ *     would yield the ELEMENT (`Repo[]`, `Array<Repo>`, `Promise<Repo>`). See
+ *     that predicate for why a field must not take its element's type.
+ *   - anything that is not a type reference (see JSDOC_TYPE_REFERENCE_RE).
+ *
+ * The leading `?` / `!` nullability sigils are JSDoc-specific decoration with no
+ * bearing on which class is named, so they are peeled first — `{?Repo}` binds
+ * `Repo` exactly as `{Repo|null}` does.
+ */
+function jsDocFieldTypeSpelling(rawType) {
+    const spelling = rawType
+        .trim()
+        .replace(/^[?!]+/, '')
+        .trim();
+    if (spelling === '' || spelling.length > JSDOC_TYPE_MAX_LENGTH)
+        return null;
+    if (reducesToContainedType(spelling))
+        return null;
+    if (!JSDOC_TYPE_REFERENCE_RE.test(spelling))
+        return null;
+    return spelling;
+}
+/**
+ * The identifier a JSDoc `@type` may bind a `field_definition` to, or `null` if
+ * this field takes no docblock binding at all (#2833).
+ *
+ * Two refusals, and both are cheaper to answer than the docblock search they
+ * gate, which is why they run before it:
+ *
+ *   - `static` fields are dropped, exactly as the query-driven annotation path
+ *     drops them in `emitJsScopeCaptures` — a static member belongs to the class
+ *     object and would silently RETYPE an instance field of the same name. The
+ *     full cost of that trade, measured, is in `isStaticClassFieldBinding`
+ *     (#2807). Re-checked here because the synthesis pass runs outside the
+ *     match loop that applies it.
+ *   - a name that is not a plain identifier (a computed key, a string key)
+ *     names nothing `this.x` could look up.
+ *
+ * The JavaScript grammar names a field's name `property:`, not `name:`. `#priv`
+ * arrives as `private_property_identifier`; TypeScript binds those under their
+ * `#`-prefixed spelling, which is how `this.#priv` looks it up.
+ */
+function jsDocBindableFieldName(node) {
+    if (isStaticClassFieldBinding(node, JS_CLASS_FIELD_DEFINITION_TYPES))
+        return null;
+    const nameNode = node.childForFieldName('property');
+    if (nameNode === null ||
+        (nameNode.type !== 'property_identifier' && nameNode.type !== 'private_property_identifier')) {
+        return null;
+    }
+    return nameNode;
+}
+/**
+ * Emit the class-FIELD type binding a JSDoc `@type {T}` block declares (#2833).
+ *
+ * JavaScript has no type annotations, so a docblock is the only way a field
+ * can declare one — and measured before this branch, `/** @type {Repo<User>} *​/
+ * repo;` bound NOTHING, taking down the non-generic control (`{Plain}`) with
+ * it. TypeScript's equivalent `repo: Repo<User>` has always bound, via the
+ * `@type-binding.annotation` rule on `public_field_definition`; this reaches the
+ * same DESTINATION from the docblock — an annotation-strength binding on the
+ * enclosing Class scope, which is the only place `typeOfMemberOnClass` reads a
+ * field's type — so the compound-receiver resolver finds it the way it always
+ * has. No resolution-side change. See the tag note on the emit below for why
+ * the marker is `class-field` rather than `annotation`.
+ */
+function emitJsDocFieldBinding(docComment, nameNode, out) {
+    const rawType = parseJsDocType(docComment);
+    const spelling = rawType === null ? null : jsDocFieldTypeSpelling(rawType);
+    if (spelling === null)
+        return;
+    out.push({
+        '@type-binding.name': syntheticCapture('@type-binding.name', nameNode, nameNode.text),
+        '@type-binding.type': syntheticCapture('@type-binding.type', nameNode, spelling),
+        // `class-field`, not `annotation`: this is the JS provider's own
+        // marker for a binding that must be HOISTED to the enclosing Class
+        // scope, which is where `typeOfMemberOnClass` reads a field's type.
+        // `jsBindingScopeFor` does that walk; `interpretJsTypeBinding` then
+        // remaps the tag to `annotation` so the source strength is the same
+        // as TypeScript's `repo: Repo<User>`. Measured: with `annotation`
+        // the binding lands on the innermost scope and the field never
+        // types — the same shape `synthesizeConstructorFieldBindings` needs
+        // for `this.p = new Outer()`.
+        '@type-binding.class-field': syntheticCapture('@type-binding.class-field', nameNode, '1'),
+    });
+}
 /**
  * Walk the AST and synthesize `@type-binding.*` captures from JSDoc
- * comments immediately preceding function declarations / expressions.
+ * comments immediately preceding function declarations / expressions and class
+ * field definitions.
  *
  * Only `/** … *​/` block comments are scanned. Line comments (`//`) are
  * intentionally excluded — JSDoc lives in block comments.
@@ -307,10 +472,23 @@ function parseJsDocType(text) {
  *   - `@type-binding.annotation` for `@type {T}` on `let`/`const`/`var`
  *     declarations — covers the common `/** @type {User} *​/ const u = …`
  *     pattern (ECMA-262 §14.3.1/§14.3.2 variable declarations).
+ *   - `@type-binding.class-field` for `@type {T}` on a `field_definition`
+ *     (#2833) — see {@link emitJsDocFieldBinding}.
  *
  * The binding is anchored on the function node so `tsBindingScopeFor`
  * can hoist method return-type bindings to Module scope (matching the
  * TypeScript path where `hoistTypeBindingsToModule: true`).
+ *
+ * `field_definition` is a node kind of THIS walk rather than a pass of its own,
+ * even though a field's anchor and name are the field itself while every other
+ * branch keys off a function-like anchor. A separate pass would be a ninth
+ * full-tree traversal of `emitJsScopeCaptures`, and measured on
+ * `dist/core/ingestion/workers/parse-worker.js` (2.4k lines, 17.3k nodes) one
+ * `namedChildren` walk costs 14.3 ms against 7.5 ms to PARSE the whole file —
+ * `node.namedChildren` materializes a fresh array of node wrappers across the
+ * N-API boundary at every node. The two node kinds share this walk's preceding-
+ * comment search and nothing else, so the branch below returns as soon as it
+ * has emitted.
  */
 function synthesizeJsDocBindings(root, out) {
     const stack = [root];
@@ -326,7 +504,14 @@ function synthesizeJsDocBindings(root, out) {
         const isMethodDef = node.type === 'method_definition';
         // Also check lexical_declaration containing an arrow/fn-expression
         const isLexDecl = node.type === 'lexical_declaration' || node.type === 'variable_declaration';
-        if (!isFnDecl && !isMethodDef && !isLexDecl)
+        const isFieldDef = node.type === 'field_definition';
+        if (!isFnDecl && !isMethodDef && !isLexDecl && !isFieldDef)
+            continue;
+        // Non-null exactly for a field that can carry a binding, so it doubles as
+        // the branch selector inside the comment search below. Answered before that
+        // search because an unbindable field has no reason to look for a docblock.
+        const fieldNameNode = isFieldDef ? jsDocBindableFieldName(node) : null;
+        if (isFieldDef && fieldNameNode === null)
             continue;
         // For `export function foo() { ... }`, the JSDoc comment precedes the
         // wrapping export_statement, not the inner function_declaration.
@@ -337,6 +522,13 @@ function synthesizeJsDocBindings(root, out) {
         while (sibling !== null && sibling.type === 'comment') {
             const text = sibling.text;
             if (text.startsWith('/**')) {
+                // A field's docblock declares its own type and nothing else — `@param` /
+                // `@returns` on a field name no callable — so this branch does not fall
+                // through to the function-like tags below.
+                if (fieldNameNode !== null) {
+                    emitJsDocFieldBinding(text, fieldNameNode, out);
+                    break;
+                }
                 // Found a JSDoc block.
                 const params = parseJsDocParams(text);
                 const retType = parseJsDocReturn(text);
@@ -556,9 +748,26 @@ function synthesizeConstructorFieldBindings(root, out) {
         // Only process constructor method definitions
         if (node.type !== 'method_definition')
             continue;
+        // …and only a CLASS's. An object literal's members are `method_definition`
+        // too, so `{ constructor() { this.p = new Alien(); } }` reached here and
+        // typed a field on whatever class the hoist walked up to — an object
+        // literal's `this` is the literal, never that class's instance (#2807).
+        // TypeScript's sibling pattern carries the same constraint in its query
+        // nesting; the two must not read one source differently.
+        if (node.parent?.type !== 'class_body')
+            continue;
         const nameNode = node.childForFieldName('name');
         if (nameNode?.text !== 'constructor')
             continue;
+        // `static constructor() {}` is legal JavaScript — the reserved-name rule
+        // applies to instance methods only — and its `this` is the CLASS object, so
+        // `this.p = new Alien()` there writes a static property and must not type
+        // the instance field `p`. TypeScript's sibling guard (`isStaticMethodThis`)
+        // already drops this shape; without the same test here `.js` and `.ts` read
+        // one source differently. `hasKeyword` skips the `name` field, so a method
+        // named `static` cannot false-positive.
+        if (hasKeyword(node, 'static'))
+            continue;
         const body = node.childForFieldName('body');
         if (body === null)
             continue;
@@ -759,6 +968,18 @@ export function emitJsScopeCaptures(sourceText, filePath, cachedTree) {
             continue;
         }
         // Filter @reference.read.member false-positives.
+        // See the matching filter in typescript/captures.ts: a `statement_block`
+        // that IS a function body duplicates the enclosing Function scope, and
+        // keeping it puts a redundant level inside every function for every
+        // scope-chain walk to step through (~6% of analyze wall time, measured).
+        if (grouped['@scope.block'] !== undefined) {
+            const blockNode = groupedNodes['@scope.block'];
+            const parentType = blockNode?.parent?.type;
+            if (parentType !== undefined && JS_FUNCTION_BODY_OWNER_TYPES.has(parentType))
+                continue;
+            if (blockNode === undefined || !blockDeclaresBinding(blockNode))
+                continue;
+        }
         if (grouped['@reference.read.member'] !== undefined) {
             const anchor = grouped['@reference.read.member'];
             const memberNode = findSelfOrAncestorOfType(groupedNodes['@reference.read.member'], 'member_expression') ??
@@ -767,6 +988,18 @@ export function emitJsScopeCaptures(sourceText, filePath, cachedTree) {
                 continue;
             }
         }
+        // A `static` class field is a member of the class object, not of instances,
+        // so `static p = new Wrong()` must not retype the `p = new Right()` beside
+        // it — the two land on one Class scope and the later match wins the `>=`
+        // tie-break. Shared with TypeScript (`isStaticClassFieldBinding`), which is
+        // where the reasoning and the grammar evidence live; the two languages read
+        // the same source and must not read it differently. JavaScript has no type
+        // annotations, so `field_definition` initializers are the only class-field
+        // type binding its query emits and `@type-binding.constructor` is the only
+        // anchor that can carry the modifier.
+        if (isStaticClassFieldBinding(groupedNodes['@type-binding.constructor'], JS_CLASS_FIELD_DEFINITION_TYPES)) {
+            continue;
+        }
         // #1876: drop @declaration.function for array higher-order-method
         // callbacks (`const x = arr.map(a => …)`). The HOC-wrapped-arrow
         // pattern matches them, but the binding holds a value, not a callable.
@@ -783,6 +1016,24 @@ export function emitJsScopeCaptures(sourceText, filePath, cachedTree) {
             if (arrowNode !== null && isBlockedDefaultExportHoc(arrowNode)) {
                 continue;
             }
+            // #2723 — see the matching filter in `typescript/captures.ts`.
+            if (arrowNode !== null && isShadowedCjsExportAssignment(arrowNode, tree.rootNode)) {
+                continue;
+            }
+            // #2723 follow-up: the member-assignment rule matches ANY identifier
+            // receiver so an `exports` alias can be recognised. A receiver that is
+            // not the exports object declares nothing at module scope — drop it, or
+            // every `obj.handler = fn` would bind `handler` as a module symbol.
+            if (arrowNode !== null && isUnexportedMemberAssignmentValue(arrowNode, tree.rootNode)) {
+                continue;
+            }
+            // A `this.X = fn` declares a module symbol ONLY at the top level of a
+            // CommonJS file, where `this` is `module.exports`. Inside a function it
+            // is an instance member (a Method with an owner, no module binding), and
+            // in ESM top-level `this` is undefined and exports nothing.
+            if (arrowNode !== null && isUndeclarableThisMemberValue(arrowNode, tree.rootNode)) {
+                continue;
+            }
         }
         if (fnDeclAnchor !== undefined) {
             const fnNode = findFunctionNode(tree.rootNode, fnDeclAnchor.range, groupedNodes['@declaration.function']);
@@ -835,6 +1086,12 @@ export function emitJsScopeCaptures(sourceText, filePath, cachedTree) {
                 grouped['@reference.parameter-types'] = syntheticCapture('@reference.parameter-types', callNode, JSON.stringify(args.map(inferArgType)));
             }
         }
+        // Structural receiver chain for a call whose receiver is itself an
+        // expression, so resolution can type it by folding over structure
+        // instead of re-parsing the receiver's source text. Self-gating: a
+        // non-call match, an absent receiver, or a chain with no nameable base
+        // all leave `grouped` untouched.
+        synthesizeReceiverChainCapture(grouped, groupedNodes['@reference.receiver']);
         out.push(grouped);
         // Synthesize `this` receiver type-bindings on class member functions.
         const scopeFnAnchor = grouped['@scope.function'];
@@ -849,6 +1106,7 @@ export function emitJsScopeCaptures(sourceText, filePath, cachedTree) {
     }
     // Post-query synthesis passes.
     synthesizeCjsImports(tree.rootNode, out);
+    synthesizeCjsModuleExports(tree.rootNode, filePath, out);
     synthesizeJsDocBindings(tree.rootNode, out);
     synthesizeConstructorFieldBindings(tree.rootNode, out);
     synthesizeDestructuringBindings(tree.rootNode, out);

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

@@ -1,29 +1,25 @@
 /**
  * Import-target resolver for JavaScript.
  *
- * Delegates to the TypeScript `resolveTsTarget` standard-strategy resolver
- * with `language: SupportedLanguages.JavaScript` so the resolver tries
- * `.js` / `.jsx` extensions in addition to (or instead of) `.ts` / `.tsx`.
+ * Delegates to the TypeScript resolver, which is correct rather than merely
+ * convenient: `jsconfig.json` is a tsconfig by another name, `package.json`
+ * governs both languages identically, and Node's algorithm does not branch on
+ * which of the two wrote the file. The extension list already carries the JS
+ * family, so a `.js`/`.jsx`/`.mjs`/`.cjs` source resolves the same way.
  *
- * The `TsResolveContext.language` flag already exists in `import-target.ts`
- * and the resolver (`resolveImportPath`) already branches on it — this
- * adapter just wires the right value in.
+ * CJS `require()` calls reference the same module-path strings as ESM `import`
+ * statements, so the resolver handles them uniformly with no CJS-specific
+ * logic here.
  *
- * CJS `require()` calls reference the same module-path strings as ESM
- * `import` statements, so the resolver handles them uniformly without any
- * CJS-specific logic here.
+ * ## What #2953 removed
  *
- * No `tsconfig.json` path-alias support (JavaScript projects don't use
- * `tsconfig.json` compilerOptions.paths in general). Projects that DO use
- * tsconfig-based aliases alongside JavaScript can still resolve via the
- * standard extension-suffix fallback; the alias branch is a no-op when
- * `tsconfigPaths` is null.
- */
-import { type TsResolveContext } from '../typescript/import-target.js';
-export type JsResolveContext = TsResolveContext;
-/**
- * Build a memoized `resolveImportTarget` adapter for JavaScript.
- * Caches the derived arrays and per-pass resolve cache across
- * `resolveImportTarget` calls within a single workspace pass.
+ * This adapter used to reach `resolveImportPath`, whose last step was
+ * `suffixResolve` — a search for any repo file whose path ends in the
+ * specifier, retried with each leading segment dropped. The header this
+ * replaces recorded the symptom without naming it a defect: `import 'app/main'`
+ * resolving to `node_modules/dep/lib/main.js`, "the first `/main.js` in file
+ * order". A bare specifier now resolves only through a declared tsconfig
+ * mapping or a package manifest, and otherwise not at all.
  */
+/** Build the JavaScript `resolveImportTarget` adapter. */
 export declare function makeJsResolveImportTarget(): (targetRaw: string, fromFile: string, allFilePaths: ReadonlySet<string>, resolutionConfig?: unknown) => string | readonly string[] | null;

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

@@ -1,53 +1,36 @@
 /**
  * Import-target resolver for JavaScript.
  *
- * Delegates to the TypeScript `resolveTsTarget` standard-strategy resolver
- * with `language: SupportedLanguages.JavaScript` so the resolver tries
- * `.js` / `.jsx` extensions in addition to (or instead of) `.ts` / `.tsx`.
+ * Delegates to the TypeScript resolver, which is correct rather than merely
+ * convenient: `jsconfig.json` is a tsconfig by another name, `package.json`
+ * governs both languages identically, and Node's algorithm does not branch on
+ * which of the two wrote the file. The extension list already carries the JS
+ * family, so a `.js`/`.jsx`/`.mjs`/`.cjs` source resolves the same way.
  *
- * The `TsResolveContext.language` flag already exists in `import-target.ts`
- * and the resolver (`resolveImportPath`) already branches on it — this
- * adapter just wires the right value in.
+ * CJS `require()` calls reference the same module-path strings as ESM `import`
+ * statements, so the resolver handles them uniformly with no CJS-specific
+ * logic here.
  *
- * CJS `require()` calls reference the same module-path strings as ESM
- * `import` statements, so the resolver handles them uniformly without any
- * CJS-specific logic here.
+ * ## What #2953 removed
  *
- * No `tsconfig.json` path-alias support (JavaScript projects don't use
- * `tsconfig.json` compilerOptions.paths in general). Projects that DO use
- * tsconfig-based aliases alongside JavaScript can still resolve via the
- * standard extension-suffix fallback; the alias branch is a no-op when
- * `tsconfigPaths` is null.
+ * This adapter used to reach `resolveImportPath`, whose last step was
+ * `suffixResolve` — a search for any repo file whose path ends in the
+ * specifier, retried with each leading segment dropped. The header this
+ * replaces recorded the symptom without naming it a defect: `import 'app/main'`
+ * resolving to `node_modules/dep/lib/main.js`, "the first `/main.js` in file
+ * order". A bare specifier now resolves only through a declared tsconfig
+ * mapping or a package manifest, and otherwise not at all.
  */
-import { SupportedLanguages } from '../../../../_shared/index.js';
 import { resolveTsTarget } from '../typescript/import-target.js';
-/**
- * Build a memoized `resolveImportTarget` adapter for JavaScript.
- * Caches the derived arrays and per-pass resolve cache across
- * `resolveImportTarget` calls within a single workspace pass.
- */
+/** Build the JavaScript `resolveImportTarget` adapter. */
 export function makeJsResolveImportTarget() {
-    let cached = null;
-    return (targetRaw, fromFile, allFilePaths) => {
-        if (cached === null || cached.key !== allFilePaths) {
-            const allFileList = Array.from(allFilePaths);
-            cached = {
-                key: allFilePaths,
-                allFilePaths: new Set(allFilePaths),
-                allFileList,
-                normalizedFileList: allFileList.map((f) => f.toLowerCase()),
-                resolveCache: new Map(),
-            };
-        }
-        const ws = {
+    return (targetRaw, fromFile, allFilePaths, resolutionConfig) => {
+        const cfg = resolutionConfig;
+        return resolveTsTarget(targetRaw, {
             fromFile,
-            language: SupportedLanguages.JavaScript,
-            allFilePaths: cached.allFilePaths,
-            allFileList: cached.allFileList,
-            normalizedFileList: cached.normalizedFileList,
-            resolveCache: cached.resolveCache,
-            tsconfigPaths: null,
-        };
-        return resolveTsTarget(targetRaw, ws);
+            allFilePaths,
+            tsconfigs: cfg?.tsconfigs ?? null,
+            nodeWorkspacePackages: cfg?.nodeWorkspacePackages ?? null,
+        });
     };
 }

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

@@ -34,11 +34,60 @@
  *      resolved.
  *   3. **Dynamic require** — `require(computedPath)` is skipped (non-literal
  *      argument — cannot statically resolve the target).
- *   4. **`module.exports` / `exports.X`** — CJS export forms are not yet
- *      modeled as re-exports. The finalize algorithm treats the exporting
- *      module as a namespace; importers that do `const X = require('./m')`
- *      bind the module namespace, and member-call resolution walks the
- *      class graph from there.
+ *   4. **CommonJS `require()` in TypeScript** — `require()` decomposition is a
+ *      JavaScript-emitter concern, so a `.ts` file's `const m = require('./m')`
+ *      is not decomposed into an import. The EXPORT side of a `.ts` CommonJS
+ *      module is now declared (shared with the JS emitter), but an importer
+ *      written in TypeScript still cannot resolve through it.
+ *   5. **`.cjs` module-level `this`** — the CommonJS/ESM gate consults the file
+ *      extension where it can, but `provider.labelOverride` receives no file
+ *      path, so a `.cjs` file whose only export is a module-level `this.X = fn`
+ *      is not labelled. It now emits nothing rather than an ownerless `Method`.
+ *   6. **Calling a renamed default-export binding** — `module.exports = fn` IS
+ *      indexed (#2723, named after the file), but resolving a CALL through a
+ *      renamed local binding (`const renamed = require('./mod'); renamed()`)
+ *      needs the finalize layer to treat a called namespace binding as the
+ *      target module's default export. `const mod = require('./mod'); mod()`
+ *      happens to resolve because the names coincide.
+ *   7. **Anonymous ESM default** — `export default function () {}` (no name)
+ *      is not indexed either. Same class as the CJS default above, different
+ *      construct; not addressed by #2723.
+ *
+ * ## CommonJS export forms (#2723)
+ *
+ * Each of these declares its name in the module scope, so importers resolve to
+ * it by name — `const { foo } = require('./m')` matches directly and a
+ * namespace `m.foo()` walks the module's defs:
+ *
+ *   - `exports.foo = function () {}` / `module.exports.foo = (a) => a`, in
+ *     every value form (function, async, arrow, async arrow, generator).
+ *   - `const e = exports; e.foo = fn` — an alias bound at module scope. The
+ *     receiver cannot be pinned in a query, so the member-assignment rules
+ *     match any identifier receiver and the emitters prune anything that is
+ *     not the exports object.
+ *   - `this.foo = fn` at MODULE level of a CommonJS file, where `this` is
+ *     `module.exports`. Gated on the file being CommonJS — in ESM top-level
+ *     `this` is undefined and the same line exports nothing.
+ *   - `exports.foo = lib.imported` / `exports.foo = importedName` — forwarded
+ *     as a re-export (`reexport-alias`), so callers reach the ORIGINAL
+ *     definition. A plain import binding would not do: it is private to its
+ *     module, exactly as in ESM.
+ *   - `module.exports = fn` — the whole module is the callable, so it is named
+ *     after the file (`index.js` takes its parent directory). A named function
+ *     expression keeps its own name. `exports = fn` is NOT indexed: rebinding
+ *     `exports` exports nothing in CommonJS, it only breaks the alias.
+ *
+ * Two deliberate non-cases. `exports.foo = localFn`, where the value is a
+ * locally declared function, needs nothing — the module scope already binds
+ * `localFn` and importers already resolve through it. And a CJS export whose
+ * name the module ALSO declares lexically is suppressed rather than declared
+ * twice: two declarations of one name are ambiguous, and the resolver would
+ * drop the intra-module edge entirely.
+ *
+ * Callable members assigned through a receiver are Methods with an owner edge
+ * rather than free functions: `Foo.prototype.bar = fn` and `this.bar = fn`
+ * inside a constructor. Ownership resolves to what the file declares, so an
+ * owner it cannot see (`External.prototype.x = fn`) claims no edge.
  */
 export { emitJsScopeCaptures } from './captures.js';
 export { interpretJsImport, interpretJsTypeBinding } from './interpret.js';

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

@@ -34,11 +34,60 @@
  *      resolved.
  *   3. **Dynamic require** — `require(computedPath)` is skipped (non-literal
  *      argument — cannot statically resolve the target).
- *   4. **`module.exports` / `exports.X`** — CJS export forms are not yet
- *      modeled as re-exports. The finalize algorithm treats the exporting
- *      module as a namespace; importers that do `const X = require('./m')`
- *      bind the module namespace, and member-call resolution walks the
- *      class graph from there.
+ *   4. **CommonJS `require()` in TypeScript** — `require()` decomposition is a
+ *      JavaScript-emitter concern, so a `.ts` file's `const m = require('./m')`
+ *      is not decomposed into an import. The EXPORT side of a `.ts` CommonJS
+ *      module is now declared (shared with the JS emitter), but an importer
+ *      written in TypeScript still cannot resolve through it.
+ *   5. **`.cjs` module-level `this`** — the CommonJS/ESM gate consults the file
+ *      extension where it can, but `provider.labelOverride` receives no file
+ *      path, so a `.cjs` file whose only export is a module-level `this.X = fn`
+ *      is not labelled. It now emits nothing rather than an ownerless `Method`.
+ *   6. **Calling a renamed default-export binding** — `module.exports = fn` IS
+ *      indexed (#2723, named after the file), but resolving a CALL through a
+ *      renamed local binding (`const renamed = require('./mod'); renamed()`)
+ *      needs the finalize layer to treat a called namespace binding as the
+ *      target module's default export. `const mod = require('./mod'); mod()`
+ *      happens to resolve because the names coincide.
+ *   7. **Anonymous ESM default** — `export default function () {}` (no name)
+ *      is not indexed either. Same class as the CJS default above, different
+ *      construct; not addressed by #2723.
+ *
+ * ## CommonJS export forms (#2723)
+ *
+ * Each of these declares its name in the module scope, so importers resolve to
+ * it by name — `const { foo } = require('./m')` matches directly and a
+ * namespace `m.foo()` walks the module's defs:
+ *
+ *   - `exports.foo = function () {}` / `module.exports.foo = (a) => a`, in
+ *     every value form (function, async, arrow, async arrow, generator).
+ *   - `const e = exports; e.foo = fn` — an alias bound at module scope. The
+ *     receiver cannot be pinned in a query, so the member-assignment rules
+ *     match any identifier receiver and the emitters prune anything that is
+ *     not the exports object.
+ *   - `this.foo = fn` at MODULE level of a CommonJS file, where `this` is
+ *     `module.exports`. Gated on the file being CommonJS — in ESM top-level
+ *     `this` is undefined and the same line exports nothing.
+ *   - `exports.foo = lib.imported` / `exports.foo = importedName` — forwarded
+ *     as a re-export (`reexport-alias`), so callers reach the ORIGINAL
+ *     definition. A plain import binding would not do: it is private to its
+ *     module, exactly as in ESM.
+ *   - `module.exports = fn` — the whole module is the callable, so it is named
+ *     after the file (`index.js` takes its parent directory). A named function
+ *     expression keeps its own name. `exports = fn` is NOT indexed: rebinding
+ *     `exports` exports nothing in CommonJS, it only breaks the alias.
+ *
+ * Two deliberate non-cases. `exports.foo = localFn`, where the value is a
+ * locally declared function, needs nothing — the module scope already binds
+ * `localFn` and importers already resolve through it. And a CJS export whose
+ * name the module ALSO declares lexically is suppressed rather than declared
+ * twice: two declarations of one name are ambiguous, and the resolver would
+ * drop the intra-module edge entirely.
+ *
+ * Callable members assigned through a receiver are Methods with an owner edge
+ * rather than free functions: `Foo.prototype.bar = fn` and `this.bar = fn`
+ * inside a constructor. Ownership resolves to what the file declares, so an
+ * owner it cannot see (`External.prototype.x = fn`) claims no edge.
  */
 export { emitJsScopeCaptures } from './captures.js';
 export { interpretJsImport, interpretJsTypeBinding } from './interpret.js';

package/dist/core/ingestion/languages/javascript/query.d.ts

@@ -46,6 +46,7 @@
  * tree-sitter init cost per file.
  */
 import Parser from 'tree-sitter';
+export declare const JAVASCRIPT_SCOPE_QUERY: string;
 export declare function getJsParser(filePath?: string): Parser;
 export declare function getJsScopeQuery(filePath?: string): Parser.Query;
 /** Validate that a cached Tree was produced by the JS grammar. */