gitnexus 1.6.6-rc.99 → 1.6.6

package/dist/core/ingestion/languages/java/interpret.js

@@ -67,10 +67,14 @@ export function interpretJavaTypeBinding(captures) {
     const typeCap = captures['@type-binding.type'];
     if (nameCap === undefined || typeCap === undefined)
         return null;
-    // Strip qualifier first so that `com.example.BaseModel<T>` becomes
-    // `BaseModel<T>` before stripGeneric — the JVM-erasure fallback pattern
-    // requires an unqualified identifier at the start of the string.
-    const rawType = stripGeneric(stripQualifier(typeCap.text.trim()));
+    // Strip generics BEFORE the qualifier (F41 #1928). Stripping the qualifier
+    // first uses `lastIndexOf('.')`, which for a qualified *type argument*
+    // (`Map<String, com.example.User>`) cuts inside the generic and yields a
+    // corrupted `User>`. Unwrapping generics first reduces the string to a single
+    // (possibly qualified) class name, then the qualifier strip leaves the bare
+    // simple name. `stripGeneric`'s erasure fallback is qualifier-tolerant so a
+    // qualified generic base (`com.example.BaseModel<T>`) still reduces correctly.
+    const rawType = stripQualifier(stripGeneric(typeCap.text.trim()));
     // Skip `var` — tree-sitter-java parses `var` as type_identifier with
     // text "var". When used without a constructor initializer, there's no
     // concrete type to bind.
@@ -120,8 +124,10 @@ function stripGeneric(text) {
     // `BaseModel<T>` → `BaseModel`, `Builder<Self>` → `Builder`.
     // This mirrors JVM type erasure — the raw class name is the resolvable symbol.
     // The pattern matches up to the first `<` to handle nested generics safely
-    // (e.g. `BaseModel<List<String>>` → `BaseModel`).
-    const fallback = text.match(/^([A-Za-z_$][A-Za-z0-9_$]*)<.+>$/s);
+    // (e.g. `BaseModel<List<String>>` → `BaseModel`). The base is allowed to be
+    // qualified (`com.example.BaseModel<T>` → `com.example.BaseModel`) since the
+    // caller strips the qualifier afterwards (F41 #1928).
+    const fallback = text.match(/^((?:[A-Za-z_$][A-Za-z0-9_$]*\.)*[A-Za-z_$][A-Za-z0-9_$]*)<.+>$/s);
     if (fallback !== null)
         return fallback[1].trim();
     return text;

package/dist/core/ingestion/languages/java/package-siblings.js

@@ -9,11 +9,24 @@
  */
 import { isClassLike } from '../../scope-resolution/scope/walkers.js';
 import { getJavaParser } from './query.js';
-import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
+import { parseSourceSafe, ParseTimeoutError } from '../../../tree-sitter/safe-parse.js';
 import { logger } from '../../../logger.js';
-function extractPackageName(content, cachedTree) {
-    const tree = cachedTree ??
-        parseSourceSafe(getJavaParser(), content);
+function extractPackageName(content, filePath, cachedTree) {
+    let tree = cachedTree;
+    if (tree === undefined) {
+        try {
+            tree = parseSourceSafe(getJavaParser(), content);
+        }
+        catch (err) {
+            if (err instanceof ParseTimeoutError) {
+                // Degrade to "no package" so a single pathological file doesn't abort
+                // same-package sibling injection for the whole run.
+                logger.warn({ file: filePath }, 'java package-siblings: parse timed out, treating as no package');
+                return '';
+            }
+            throw err;
+        }
+    }
     for (const child of tree.rootNode.namedChildren) {
         if (child.type === 'package_declaration') {
             const scoped = child.namedChildren.find((c) => c.type === 'scoped_identifier' || c.type === 'identifier');
@@ -28,7 +41,7 @@ export function populateJavaPackageSiblings(parsedFiles, indexes, ctx) {
         const content = ctx.fileContents.get(parsed.filePath);
         if (content === undefined)
             continue;
-        const pkg = extractPackageName(content, ctx.treeCache?.get(parsed.filePath));
+        const pkg = extractPackageName(content, parsed.filePath, ctx.treeCache?.get(parsed.filePath));
         let bucket = buckets.get(pkg);
         if (bucket === undefined) {
             bucket = { parsed: [], moduleScopes: [] };

package/dist/core/ingestion/languages/java/query.js

@@ -212,8 +212,23 @@ const JAVA_SCOPE_QUERY = `
   type: (generic_type
     (type_identifier) @reference.name)) @reference.call.constructor
 
+;; References — qualified constructor calls: new pkg.Foo(), new a.b.Foo() (F35 #1928)
+;; tree-sitter-java parses \`pkg.Foo\` as a scoped_type_identifier whose final
+;; child is the simple type. Bind that tail as @reference.name (trailing \`.\`
+;; anchor = last child) so resolution targets \`Foo\`, not the raw \`pkg.Foo\` text.
+;; Mirrors the TS/JS new-expression qualified-constructor capture.
 (object_creation_expression
-  type: (scoped_type_identifier) @reference.call.constructor.qualified) @reference.call.constructor
+  type: (scoped_type_identifier
+    (type_identifier) @reference.name .) @reference.call.constructor.qualified) @reference.call.constructor
+
+;; References — qualified + generic constructor calls: new pkg.Box<T>() (F35 #1928)
+;; The base is a generic_type whose first child is a scoped_type_identifier, so
+;; neither the simple-generic nor the plain-scoped arm above matches it. Bind the
+;; scoped tail as @reference.name.
+(object_creation_expression
+  type: (generic_type
+    (scoped_type_identifier
+      (type_identifier) @reference.name .) @reference.call.constructor.qualified)) @reference.call.constructor
 
 ;; References — method references: User::getName, obj::method
 (method_reference

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

@@ -2,14 +2,8 @@
  * Java `ScopeResolver` registered in `SCOPE_RESOLVERS` and consumed by
  * the generic `runScopeResolution` orchestrator (RFC #909 Ring 3).
  *
- * ## Registry-primary parity status
- *
- * Java is in `MIGRATED_LANGUAGES` — the scope-resolution registry is
- * the primary call-resolution path.  Parity: 178/178 (100%).
- *
- * **CI visibility:** The parity CI workflow (`ci-scope-parity.yml`)
- * runs Java tests in both `REGISTRY_PRIMARY_JAVA=0` and `=1` modes
- * automatically.
+ * Java resolves via the scope-resolution registry — the sole
+ * call-resolution path.
  */
 import type { ScopeResolver } from '../../scope-resolution/contract/scope-resolver.js';
 declare const javaScopeResolver: ScopeResolver;

package/dist/core/ingestion/languages/java/scope-resolver.js

@@ -2,14 +2,8 @@
  * Java `ScopeResolver` registered in `SCOPE_RESOLVERS` and consumed by
  * the generic `runScopeResolution` orchestrator (RFC #909 Ring 3).
  *
- * ## Registry-primary parity status
- *
- * Java is in `MIGRATED_LANGUAGES` — the scope-resolution registry is
- * the primary call-resolution path.  Parity: 178/178 (100%).
- *
- * **CI visibility:** The parity CI workflow (`ci-scope-parity.yml`)
- * runs Java tests in both `REGISTRY_PRIMARY_JAVA=0` and `=1` modes
- * automatically.
+ * Java resolves via the scope-resolution registry — the sole
+ * call-resolution path.
  */
 import { SupportedLanguages } from '../../../../_shared/index.js';
 import { buildMro, defaultLinearize } from '../../scope-resolution/passes/mro.js';

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

@@ -14,7 +14,6 @@ import { javaTypeConfig } from '../type-extractors/jvm.js';
 import { javaExportChecker } from '../export-detection.js';
 import { createImportResolver } from '../import-resolvers/resolver-factory.js';
 import { javaImportConfig } from '../import-resolvers/configs/jvm.js';
-import { extractJavaNamedBindings } from '../named-bindings/java.js';
 import { JAVA_QUERIES } from '../tree-sitter-queries.js';
 import { createCallExtractor } from '../call-extractors/generic.js';
 import { javaCallConfig } from '../call-extractors/configs/jvm.js';
@@ -24,7 +23,6 @@ import { createMethodExtractor } from '../method-extractors/generic.js';
 import { javaMethodConfig } from '../method-extractors/configs/jvm.js';
 import { createVariableExtractor } from '../variable-extractors/generic.js';
 import { javaVariableConfig } from '../variable-extractors/configs/jvm.js';
-import { createHeritageExtractor } from '../heritage-extractors/generic.js';
 import { emitJavaScopeCaptures, interpretJavaImport, interpretJavaTypeBinding, javaBindingScopeFor, javaImportOwningScope, javaMergeBindings, javaReceiverBinding, javaArityCompatibility, resolveJavaImportTarget, } from './java/index.js';
 const orderJavaSameNameTypeCandidates = ({ callSiteFilePath, candidates, }) => {
     if (!callSiteFilePath.endsWith('.java'))
@@ -88,15 +86,12 @@ export const javaProvider = defineLanguage({
     typeConfig: javaTypeConfig,
     exportChecker: javaExportChecker,
     importResolver: createImportResolver(javaImportConfig),
-    namedBindingExtractor: extractJavaNamedBindings,
-    interfaceNamePattern: /^I[A-Z]/,
     mroStrategy: 'implements-split',
     callExtractor: createCallExtractor(javaCallConfig),
     fieldExtractor: createFieldExtractor(javaConfig),
     methodExtractor: createMethodExtractor(javaMethodConfig),
     variableExtractor: createVariableExtractor(javaVariableConfig),
     classExtractor: createClassExtractor(javaClassConfig),
-    heritageExtractor: createHeritageExtractor(SupportedLanguages.Java),
     // ── RFC #909 Ring 3: scope-based resolution hooks ──
     emitScopeCaptures: emitJavaScopeCaptures,
     interpretImport: interpretJavaImport,

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

@@ -34,6 +34,7 @@ import { synthesizeTsReceiverBinding } from '../typescript/receiver-binding.js';
 import { isArrayMethodCallbackArrow } from '../typescript/array-callback.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.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 = [
@@ -59,6 +60,41 @@ function pickFirstDefined(grouped, tags) {
     }
     return undefined;
 }
+function pickFirstNode(groupedNodes, tags) {
+    for (const tag of tags) {
+        const node = groupedNodes[tag];
+        if (node !== undefined)
+            return node;
+    }
+    return undefined;
+}
+/** Walks the parent chain from `node` (inclusive), returning the first node
+ *  whose type matches, or null. Faster than `findNodeAtRange` when the caller
+ *  already holds the anchor node — avoids re-scanning the tree from the root. */
+function findSelfOrAncestorOfType(node, type) {
+    if (node === undefined)
+        return null;
+    let current = node;
+    while (current !== null) {
+        if (current.type === type)
+            return current;
+        current = current.parent;
+    }
+    return null;
+}
+/** Walks the parent chain from `node` (inclusive), returning the first node
+ *  whose type is in the set, or null. Plural form of {@link findSelfOrAncestorOfType}. */
+function findSelfOrAncestorOfTypes(node, types) {
+    if (node === undefined)
+        return null;
+    let current = node;
+    while (current !== null) {
+        if (types.includes(current.type))
+            return current;
+        current = current.parent;
+    }
+    return null;
+}
 /** Filter `@reference.read.member` in non-read contexts (same logic as TS). */
 function shouldEmitReadMember(memberNode) {
     const parent = memberNode.parent;
@@ -79,8 +115,14 @@ function shouldEmitReadMember(memberNode) {
             return true;
     }
 }
-/** Find the first JS function-like node at the given range. */
-function findFunctionNode(rootNode, range) {
+/** Find the first JS function-like node at the given range.
+ *  Prefers the threaded anchor node (walk up its parent chain) so the common
+ *  case avoids a root re-scan; falls back to a range scan from root only when
+ *  the anchor isn't a function-like (or isn't supplied). */
+function findFunctionNode(rootNode, range, anchorNode) {
+    const fromAnchor = findSelfOrAncestorOfTypes(anchorNode, FUNCTION_NODE_TYPES);
+    if (fromAnchor !== null)
+        return fromAnchor;
     for (const nodeType of FUNCTION_NODE_TYPES) {
         const n = findNodeAtRange(rootNode, range, nodeType);
         if (n !== null)
@@ -550,6 +592,100 @@ function synthesizeConstructorFieldBindings(root, out) {
         }
     }
 }
+// ─── Inheritance references (EXTENDS) ────────────────────────────────────
+/**
+ * Synthesize `@reference.inherits` captures from JavaScript class heritage so
+ * the registry-primary scope-resolution path emits EXTENDS edges (mirrors C#
+ * `synthesizeCsharpInheritanceReferences` / C++ `emitCppInheritanceCaptures`).
+ * Without this, JS inheritance edges came only from the legacy heritage-capture
+ * leg (removed in #942), which the worker pipeline drops for registry-primary
+ * languages, yielding 0 inheritance edges in worker mode (issue #1951).
+ *
+ * Scope is intentionally limited to a `class_declaration`'s `class_heritage`
+ * base, matching the legacy JavaScript heritage query's class scope and its
+ * supertype shape descriptor (`javascriptHeritageShapes`:
+ * `['identifier', 'member_expression']`). JavaScript classes have a single
+ * `extends` base and no `implements`, so every emission is an EXTENDS (decided
+ * downstream from the resolved target's symbol kind in
+ * `preEmitInheritanceEdges`).
+ *
+ * Bases handled (at parity with the legacy heritage leg, #1951):
+ *   - `(identifier)` base (`extends Base`) — bare simple name.
+ *   - `(member_expression)` base (`extends ns.Base`, `extends a.b.Base`) —
+ *     qualified; reduced to its trailing `property_identifier` (`Base`) so the
+ *     V1 `findClassBindingInScope` simple-name contract holds. This mirrors the
+ *     TypeScript `terminalTsTypeNameNode` member_expression arm.
+ *
+ * Deliberately NOT emitted (preserving parity with the legacy query, incl. the
+ * #1943 HOC behavior):
+ *   - `class` EXPRESSION nodes (legacy captures `class_declaration` only).
+ *   - `call_expression` / HOC bases (`extends withFoo(Bar)`) — not a legacy
+ *     heritage shape; left to the normal call-resolution path.
+ *
+ * The `@reference.name` bare-name text emitted for each base equals
+ * `normalizeSupertypeName(base)` (the legacy leg's reduction): `Base` → `Base`,
+ * `ns.Base` → `Base`, `a.b.Base` → `Base` — keeping the two legs at parity.
+ */
+function synthesizeJsInheritanceReferences(root, out) {
+    const stack = [root];
+    for (;;) {
+        const node = stack.pop();
+        if (node === undefined)
+            break;
+        for (const child of node.namedChildren) {
+            if (child !== null)
+                stack.push(child);
+        }
+        if (node.type !== 'class_declaration')
+            continue;
+        // Find the `class_heritage` child (holds the single `extends` base).
+        let heritage = null;
+        for (const child of node.namedChildren) {
+            if (child !== null && child.type === 'class_heritage') {
+                heritage = child;
+                break;
+            }
+        }
+        if (heritage === null)
+            continue;
+        // Emit for `(identifier)` and `(member_expression)` bases — matching the
+        // legacy heritage shape descriptor (`call_expression` HOC bases excluded).
+        for (const base of heritage.namedChildren) {
+            if (base === null)
+                continue;
+            const nameNode = terminalJsHeritageNameNode(base);
+            if (nameNode === null)
+                continue;
+            out.push({
+                '@reference.inherits': nodeToCapture('@reference.inherits', base),
+                '@reference.name': nodeToCapture('@reference.name', nameNode),
+            });
+        }
+    }
+}
+/** Resolve a JavaScript heritage base node to its bare simple-identifier node.
+ *  `Base` (identifier) → `Base`, `ns.Base` / `a.b.Base` (member_expression) →
+ *  the trailing `property_identifier` `Base`. Mirrors the TypeScript
+ *  `terminalTsTypeNameNode` member_expression arm. Returns null for any other
+ *  shape (e.g. `call_expression` HOC bases), which is then skipped — keeping
+ *  parity with the legacy `javascriptHeritageShapes` descriptor and
+ *  `normalizeSupertypeName`'s reduction of each shape. */
+function terminalJsHeritageNameNode(node) {
+    switch (node.type) {
+        case 'identifier':
+        // `extends ns.Base` parses as a member_expression whose tail is a
+        // `property_identifier` (not an identifier) — treat it as a leaf name.
+        case 'property_identifier':
+            return node;
+        case 'member_expression': {
+            // Qualified `ns.Base` / `a.b.Base` → tail identifier `Base`.
+            const tail = node.lastNamedChild;
+            return tail === null ? null : terminalJsHeritageNameNode(tail);
+        }
+        default:
+            return null;
+    }
+}
 // ─── Main emitter ──────────────────────────────────────────────────────────
 export function emitJsScopeCaptures(sourceText, filePath, cachedTree) {
     let tree = cachedTree;
@@ -565,16 +701,28 @@ export function emitJsScopeCaptures(sourceText, filePath, cachedTree) {
     const out = [];
     for (const m of rawMatches) {
         const grouped = {};
+        // Parallel tag -> captured SyntaxNode map. The query hands us each matched
+        // node as c.node, so anchors resolve by walking up from the captured node
+        // (findSelfOrAncestorOfType[s]) instead of re-deriving them with
+        // findNodeAtRange(tree.rootNode, ...) per match — the O(matches x N)
+        // root-walk fixed for go #1915 / python #1918 / csharp, mirrored here
+        // (mirrors typescript/captures.ts groupedNodes).
+        const groupedNodes = {};
         for (const c of m.captures) {
             const tag = '@' + c.name;
             grouped[tag] = nodeToCapture(tag, c.node);
+            groupedNodes[tag] = c.node;
         }
         if (Object.keys(grouped).length === 0)
             continue;
         // Decompose ESM import_statement / re-export export_statement.
         if (grouped['@import.statement'] !== undefined) {
             const stmtCapture = grouped['@import.statement'];
-            const stmtNode = findNodeAtRange(tree.rootNode, stmtCapture.range, 'import_statement') ??
+            const stmtNode = findSelfOrAncestorOfTypes(groupedNodes['@import.statement'], [
+                'import_statement',
+                'export_statement',
+            ]) ??
+                findNodeAtRange(tree.rootNode, stmtCapture.range, 'import_statement') ??
                 findNodeAtRange(tree.rootNode, stmtCapture.range, 'export_statement');
             if (stmtNode !== null) {
                 const decomposed = splitImportStatement(stmtNode);
@@ -586,7 +734,8 @@ export function emitJsScopeCaptures(sourceText, filePath, cachedTree) {
         // Decompose dynamic import() calls.
         if (grouped['@import.dynamic'] !== undefined) {
             const dynCapture = grouped['@import.dynamic'];
-            const callNode = findNodeAtRange(tree.rootNode, dynCapture.range, 'call_expression');
+            const callNode = findSelfOrAncestorOfType(groupedNodes['@import.dynamic'], 'call_expression') ??
+                findNodeAtRange(tree.rootNode, dynCapture.range, 'call_expression');
             if (callNode !== null) {
                 const decomposed = splitImportStatement(callNode);
                 for (const d of decomposed)
@@ -597,7 +746,8 @@ export function emitJsScopeCaptures(sourceText, filePath, cachedTree) {
         // Filter @reference.read.member false-positives.
         if (grouped['@reference.read.member'] !== undefined) {
             const anchor = grouped['@reference.read.member'];
-            const memberNode = findNodeAtRange(tree.rootNode, anchor.range, 'member_expression');
+            const memberNode = findSelfOrAncestorOfType(groupedNodes['@reference.read.member'], 'member_expression') ??
+                findNodeAtRange(tree.rootNode, anchor.range, 'member_expression');
             if (memberNode === null || !shouldEmitReadMember(memberNode)) {
                 continue;
             }
@@ -611,15 +761,25 @@ export function emitJsScopeCaptures(sourceText, filePath, cachedTree) {
         // scope instead of a phantom Function.
         const fnDeclAnchor = grouped['@declaration.function'];
         if (fnDeclAnchor !== undefined) {
-            const arrowNode = findFunctionNode(tree.rootNode, fnDeclAnchor.range);
+            const arrowNode = findFunctionNode(tree.rootNode, fnDeclAnchor.range, groupedNodes['@declaration.function']);
             if (arrowNode !== null && isArrayMethodCallbackArrow(arrowNode)) {
                 continue;
             }
+            if (arrowNode !== null && isBlockedDefaultExportHoc(arrowNode)) {
+                continue;
+            }
+        }
+        if (fnDeclAnchor !== undefined) {
+            const fnNode = findFunctionNode(tree.rootNode, fnDeclAnchor.range, groupedNodes['@declaration.function']);
+            if (fnNode !== null && isDefaultExportHocFunctionNode(fnNode)) {
+                grouped['@declaration.name'] = syntheticCapture('@declaration.name', fnNode, deriveDefaultExportHocName(filePath));
+            }
         }
         // Synthesize arity metadata on function-like declarations.
         const declAnchor = pickFirstDefined(grouped, FUNCTION_DECL_TAGS);
+        const declAnchorNode = pickFirstNode(groupedNodes, FUNCTION_DECL_TAGS);
         if (declAnchor !== undefined) {
-            const fnNode = findFunctionNode(tree.rootNode, declAnchor.range);
+            const fnNode = findFunctionNode(tree.rootNode, declAnchor.range, declAnchorNode);
             if (fnNode !== null) {
                 const arity = computeTsArityMetadata(fnNode);
                 if (arity.parameterCount !== undefined) {
@@ -633,10 +793,23 @@ export function emitJsScopeCaptures(sourceText, filePath, cachedTree) {
                 }
             }
         }
-        // Synthesize @reference.arity on callsites.
+        // Synthesize @reference.arity on callsites. Skip JSX element anchors: a JSX
+        // component used as a call argument (e.g. `render(<Foo .../>)`) is itself a
+        // @reference.call.* anchor, and the ascent below would climb into the
+        // enclosing call_expression and mis-attribute that call's arity to the
+        // component. A JSX component reference has no call arity here — this restores
+        // the pre-#1951 range-based behavior (no call_expression at the JSX range).
+        // The guard lives at this call site, not inside findSelfOrAncestorOfTypes,
+        // which is also used by the import-statement and function-scope ascents.
         const callAnchor = pickFirstDefined(grouped, CALL_TAGS);
-        if (callAnchor !== undefined && grouped['@reference.arity'] === undefined) {
-            const callNode = findNodeAtRange(tree.rootNode, callAnchor.range, 'call_expression') ??
+        const callAnchorNode = pickFirstNode(groupedNodes, CALL_TAGS);
+        const anchorIsJsxElement = callAnchorNode?.type === 'jsx_self_closing_element' ||
+            callAnchorNode?.type === 'jsx_opening_element';
+        if (callAnchor !== undefined &&
+            grouped['@reference.arity'] === undefined &&
+            !anchorIsJsxElement) {
+            const callNode = findSelfOrAncestorOfTypes(callAnchorNode, ['call_expression', 'new_expression']) ??
+                findNodeAtRange(tree.rootNode, callAnchor.range, 'call_expression') ??
                 findNodeAtRange(tree.rootNode, callAnchor.range, 'new_expression');
             if (callNode !== null) {
                 const argList = callNode.childForFieldName('arguments');
@@ -651,7 +824,7 @@ export function emitJsScopeCaptures(sourceText, filePath, cachedTree) {
         // Synthesize `this` receiver type-bindings on class member functions.
         const scopeFnAnchor = grouped['@scope.function'];
         if (scopeFnAnchor !== undefined) {
-            const fnNode = findFunctionNode(tree.rootNode, scopeFnAnchor.range);
+            const fnNode = findFunctionNode(tree.rootNode, scopeFnAnchor.range, groupedNodes['@scope.function']);
             if (fnNode !== null) {
                 const synth = synthesizeTsReceiverBinding(fnNode);
                 if (synth !== null)
@@ -666,5 +839,6 @@ export function emitJsScopeCaptures(sourceText, filePath, cachedTree) {
     synthesizeDestructuringBindings(tree.rootNode, out);
     synthesizeForOfMapTupleBindings(tree.rootNode, out);
     synthesizeInstanceofNarrowings(tree.rootNode, out);
+    synthesizeJsInheritanceReferences(tree.rootNode, out);
     return out;
 }

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

@@ -47,6 +47,7 @@
  */
 import Parser from 'tree-sitter';
 import JS from 'tree-sitter-javascript';
+import { ARRAY_METHOD_NOT_ANY_OF_PREDICATE, DEFAULT_EXPORT_IDENTIFIER_NOT_ANY_OF_PREDICATE, } from '../../ts-js-hoc-utils.js';
 const JS_GRAMMAR = JS;
 /** True when the file should be parsed with the JSX-extended query. */
 function isJsxFile(filePath) {
@@ -150,10 +151,13 @@ const JAVASCRIPT_SCOPE_QUERY = `
 ;; Those are filtered out emit-side in captures.ts via
 ;; isArrayMethodCallbackArrow (member-expression callee whose property
 ;; is a known Array method), so only the @declaration.const survives.
+;; Excludes common array methods (map, filter, reduce, etc.) to avoid
+;; false positives like \`const x = arr.map(a => ...)\`.
 (lexical_declaration
   (variable_declarator
     name: (identifier) @declaration.name
     value: (call_expression
+      function: (identifier)
       arguments: (arguments
         (arrow_function) @declaration.function))))
 
@@ -161,14 +165,36 @@ const JAVASCRIPT_SCOPE_QUERY = `
   (variable_declarator
     name: (identifier) @declaration.name
     value: (call_expression
+      function: (identifier)
       arguments: (arguments
         (function_expression) @declaration.function))))
 
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @declaration.name
+    value: (call_expression
+      function: (member_expression
+        property: (property_identifier) @callee)
+      arguments: (arguments
+        (arrow_function) @declaration.function)))
+  ${ARRAY_METHOD_NOT_ANY_OF_PREDICATE})
+
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @declaration.name
+    value: (call_expression
+      function: (member_expression
+        property: (property_identifier) @callee)
+      arguments: (arguments
+        (function_expression) @declaration.function)))
+  ${ARRAY_METHOD_NOT_ANY_OF_PREDICATE})
+
 (export_statement
   declaration: (lexical_declaration
     (variable_declarator
       name: (identifier) @declaration.name
       value: (call_expression
+        function: (identifier)
         arguments: (arguments
           (arrow_function) @declaration.function)))))
 
@@ -177,13 +203,37 @@ const JAVASCRIPT_SCOPE_QUERY = `
     (variable_declarator
       name: (identifier) @declaration.name
       value: (call_expression
+        function: (identifier)
         arguments: (arguments
           (function_expression) @declaration.function)))))
 
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @declaration.name
+      value: (call_expression
+        function: (member_expression
+          property: (property_identifier) @callee)
+        arguments: (arguments
+          (arrow_function) @declaration.function))))
+  ${ARRAY_METHOD_NOT_ANY_OF_PREDICATE})
+
+(export_statement
+  declaration: (lexical_declaration
+    (variable_declarator
+      name: (identifier) @declaration.name
+      value: (call_expression
+        function: (member_expression
+          property: (property_identifier) @callee)
+        arguments: (arguments
+          (function_expression) @declaration.function))))
+  ${ARRAY_METHOD_NOT_ANY_OF_PREDICATE})
+
 (variable_declaration
   (variable_declarator
     name: (identifier) @declaration.name
     value: (call_expression
+      function: (identifier)
       arguments: (arguments
         (arrow_function) @declaration.function))))
 
@@ -191,9 +241,64 @@ const JAVASCRIPT_SCOPE_QUERY = `
   (variable_declarator
     name: (identifier) @declaration.name
     value: (call_expression
+      function: (identifier)
       arguments: (arguments
         (function_expression) @declaration.function))))
 
+(variable_declaration
+  (variable_declarator
+    name: (identifier) @declaration.name
+    value: (call_expression
+      function: (member_expression
+        property: (property_identifier) @callee)
+      arguments: (arguments
+        (arrow_function) @declaration.function)))
+  ${ARRAY_METHOD_NOT_ANY_OF_PREDICATE})
+
+(variable_declaration
+  (variable_declarator
+    name: (identifier) @declaration.name
+    value: (call_expression
+      function: (member_expression
+        property: (property_identifier) @callee)
+      arguments: (arguments
+        (function_expression) @declaration.function)))
+  ${ARRAY_METHOD_NOT_ANY_OF_PREDICATE})
+
+;; HOC-wrapped default exports (JS parity with TS patterns in
+;; languages/typescript/query.ts). The emit phase rewrites
+;; @declaration.name to a file-derived name so wrapper helpers do not
+;; become the graph-visible symbol name.
+((export_statement
+  value: (call_expression
+    function: (identifier) @hoc
+    arguments: (arguments
+      (arrow_function) @declaration.function)))
+  ${DEFAULT_EXPORT_IDENTIFIER_NOT_ANY_OF_PREDICATE})
+
+((export_statement
+  value: (call_expression
+    function: (identifier) @hoc
+    arguments: (arguments
+      (function_expression) @declaration.function)))
+  ${DEFAULT_EXPORT_IDENTIFIER_NOT_ANY_OF_PREDICATE})
+
+((export_statement
+  value: (call_expression
+    function: (member_expression
+      property: (property_identifier) @callee)
+    arguments: (arguments
+      (arrow_function) @declaration.function)))
+  ${ARRAY_METHOD_NOT_ANY_OF_PREDICATE})
+
+((export_statement
+  value: (call_expression
+    function: (member_expression
+      property: (property_identifier) @callee)
+    arguments: (arguments
+      (function_expression) @declaration.function)))
+  ${ARRAY_METHOD_NOT_ANY_OF_PREDICATE})
+
 ;; Variable / constant declarations (non-function values).
 (lexical_declaration
   (variable_declarator
@@ -334,7 +439,8 @@ const JAVASCRIPT_SCOPE_QUERY = `
   constructor: (identifier) @reference.name) @reference.call.constructor
 
 (new_expression
-  constructor: (member_expression) @reference.call.constructor.qualified) @reference.call.constructor
+  constructor: (member_expression
+    property: (property_identifier) @reference.name) @reference.call.constructor.qualified) @reference.call.constructor
 
 ;; Write access: obj.field = value
 (assignment_expression