gitnexus 1.6.6-rc.103 → 1.6.6-rc.105

package/dist/core/ingestion/call-processor.js

@@ -28,7 +28,7 @@ import { generateId } from '../../lib/utils.js';
 import { getLanguageFromFilename, SupportedLanguages } from '../../_shared/index.js';
 import { isRegistryPrimary } from './registry-primary-flag.js';
 import { isVerboseIngestionEnabled } from './utils/verbose.js';
-import { deferredCallFileSlowMs, deferredCallLogEveryN, getDeferredProfileDroppedCount, isDeferredResolutionProfileEnabled, logDeferredProfile, profileElapsedMs, resetDeferredProfileDroppedCount, startTimer, } from './utils/deferred-resolution-profile.js';
+import { ALWAYS_ON_SLOW_FILE_WARN_THROTTLE_MS, alwaysOnSlowFileWarnMs, deferredCallFileSlowMs, deferredCallLogEveryN, getDeferredProfileDroppedCount, isDeferredResolutionProfileEnabled, logDeferredProfile, profileElapsedMs, resetDeferredProfileDroppedCount, startTimer, } from './utils/deferred-resolution-profile.js';
 import { yieldToEventLoop } from './utils/event-loop.js';
 import { parseSourceSafe } from '../tree-sitter/safe-parse.js';
 import { CLASS_CONTAINER_TYPES, FUNCTION_NODE_TYPES, findEnclosingClassInfo, genericFuncName, inferFunctionLabel, } from './utils/ast-helpers.js';
@@ -311,7 +311,7 @@ const findEnclosingFunction = (node, filePath, ctx, provider) => {
     let current = node.parent;
     while (current) {
         if (FUNCTION_NODE_TYPES.has(current.type)) {
-            const efnResult = provider.methodExtractor?.extractFunctionName?.(current);
+            const efnResult = provider.methodExtractor?.extractFunctionName?.(current, filePath);
             const funcName = efnResult?.funcName ?? genericFuncName(current);
             const label = efnResult?.label ?? inferFunctionLabel(current.type);
             if (funcName) {
@@ -749,6 +749,7 @@ compiledQueryCache) => {
         const importedReturnTypes = importedReturnTypesMap?.get(file.path);
         const importedRawReturnTypes = importedRawReturnTypesMap?.get(file.path);
         const typeEnv = buildTypeEnv(tree, language, {
+            filePath: file.path,
             model: ctx.model,
             parentMap,
             importedBindings,
@@ -1050,7 +1051,8 @@ compiledQueryCache) => {
                 let p = callNode.parent;
                 while (p) {
                     if (FUNCTION_NODE_TYPES.has(p.type)) {
-                        const funcName = provider.methodExtractor?.extractFunctionName?.(p)?.funcName ?? genericFuncName(p);
+                        const funcName = provider.methodExtractor?.extractFunctionName?.(p, file.path)?.funcName ??
+                            genericFuncName(p);
                         if (funcName) {
                             scope = `${funcName}@${p.startIndex}`;
                             break;
@@ -2303,6 +2305,14 @@ export const processCallsFromExtracted = async (graph, extractedCalls, ctx, onPr
     const slowFileMs = profileCalls ? deferredCallFileSlowMs() : 0;
     const logEveryN = profileCalls ? deferredCallLogEveryN() : 0;
     let skippedRegistryPrimaryFiles = 0;
+    // Always-on slow-file watchdog (#1741). Independent of the verbose/profile
+    // gate above: even a plain `analyze` run surfaces ONE actionable warning
+    // when a single file's call resolution is pathologically slow — turning the
+    // silent "stuck at Resolving calls (N/M)" symptom into a named culprit.
+    // Throttled so a genuinely slow repo can't produce a warn storm.
+    const alwaysSlowFileMs = alwaysOnSlowFileWarnMs();
+    let lastSlowFileWarnAt = 0;
+    let suppressedSlowFileWarnings = 0;
     // Fresh dropped-log counter per analyze run — the module-private counter
     // in deferred-resolution-profile.ts is process-lived, so without a reset
     // here it would accumulate across consecutive analyze invocations in the
@@ -2314,12 +2324,16 @@ export const processCallsFromExtracted = async (graph, extractedCalls, ctx, onPr
     // denominator stays stable as the loop iterates. Otherwise `${totalFiles -
     // skippedRegistryPrimaryFiles}` drifts upward — files iterated before later
     // registry-primary skips have been seen carry an inflated denominator, and
-    // the ratio only self-corrects after every file has been classified. Pre-
-    // count runs only on the enabled path so the disabled path stays free of
-    // the extra Map iteration. Defaults to 0 on the disabled path; the live log
-    // gate is also disabled there, so the value is never read.
+    // the ratio only self-corrects after every file has been classified.
+    //
+    // Runs whenever its result will actually be read: on the profile path (the
+    // live deferred-profile log) OR when the always-on slow-file watchdog is
+    // active (#1741) — the watchdog's warning prints `${resolvedFiles}/${resolvedTotal}`
+    // unconditionally, so leaving resolvedTotal at 0 on a plain run produced a
+    // bogus "Resolved N/0 files" denominator on exactly the unprofiled runs the
+    // watchdog exists for. When both gates are off, skip the extra Map pass.
     let resolvedTotal = 0;
-    if (profileCalls) {
+    if (profileCalls || alwaysSlowFileMs > 0) {
         for (const filePath of byFile.keys()) {
             const lang = getLanguageFromFilename(filePath);
             if (!lang || !isRegistryPrimary(lang))
@@ -2341,6 +2355,9 @@ export const processCallsFromExtracted = async (graph, extractedCalls, ctx, onPr
         }
         resolvedFiles++;
         const tFile = startTimer(profileCalls);
+        // Always-on timer (cheap: one hrtime read) feeding the slow-file watchdog
+        // below. Distinct from `tFile`, which is null unless profiling is on.
+        const tFileAlways = alwaysSlowFileMs > 0 ? process.hrtime.bigint() : null;
         if (profileCalls && (resolvedFiles === 1 || resolvedFiles % logEveryN === 0)) {
             logDeferredProfile(`calls ${resolvedFiles}/${resolvedTotal} file=${filePath} sites=${calls.length}`);
         }
@@ -2455,6 +2472,27 @@ export const processCallsFromExtracted = async (graph, extractedCalls, ctx, onPr
                 logDeferredProfile(`slow file ${elapsed.toFixed(0)}ms path=${filePath} calls=${calls.length} lang=${fileLanguage ?? 'unknown'}`);
             }
         }
+        // Always-on slow-file watchdog (#1741) — fires regardless of verbose.
+        if (tFileAlways !== null) {
+            const elapsedAlways = profileElapsedMs(tFileAlways);
+            if (elapsedAlways >= alwaysSlowFileMs) {
+                const now = Date.now();
+                if (now - lastSlowFileWarnAt >= ALWAYS_ON_SLOW_FILE_WARN_THROTTLE_MS) {
+                    lastSlowFileWarnAt = now;
+                    const suppressedNote = suppressedSlowFileWarnings > 0
+                        ? ` (+${suppressedSlowFileWarnings} more slow files since the last warning)`
+                        : '';
+                    logger.warn(`⏳ Call resolution for ${filePath} took ${(elapsedAlways / 1000).toFixed(1)}s ` +
+                        `(${calls.length} call sites, ${fileLanguage ?? 'unknown'}). The run is not frozen — ` +
+                        `this file is unusually expensive to resolve. Resolved ${resolvedFiles}/${resolvedTotal} ` +
+                        `files so far.${suppressedNote} Pass -v for per-file deferred-resolution timing.`);
+                    suppressedSlowFileWarnings = 0;
+                }
+                else {
+                    suppressedSlowFileWarnings++;
+                }
+            }
+        }
     }
     if (profileCalls) {
         logDeferredProfile(`processCallsFromExtracted done: ${totalFiles} files, ${extractedCalls.length} call sites, skipped registry-primary files=${skippedRegistryPrimaryFiles}`);

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 = [
@@ -615,6 +616,15 @@ export function emitJsScopeCaptures(sourceText, filePath, cachedTree) {
             if (arrowNode !== null && isArrayMethodCallbackArrow(arrowNode)) {
                 continue;
             }
+            if (arrowNode !== null && isBlockedDefaultExportHoc(arrowNode)) {
+                continue;
+            }
+        }
+        if (fnDeclAnchor !== undefined) {
+            const fnNode = findFunctionNode(tree.rootNode, fnDeclAnchor.range);
+            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);

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

package/dist/core/ingestion/languages/typescript/array-callback.d.ts

@@ -23,32 +23,6 @@
  * Pure given the input node. No I/O, no globals.
  */
 import type { SyntaxNode } from '../../utils/ast-helpers.js';
-/**
- * Array prototype higher-order methods whose result is a value, not a
- * function. A callback passed to one of these is an anonymous callback,
- * never a top-level function definition. Identifier-callee HOCs
- * (`forwardRef(...)`, `useCallback(...)`, custom factories) are
- * deliberately NOT listed — they keep their `Function` classification.
- *
- * Trade-off (unchanged from before #1876): a custom *fluent-API* member
- * call with a callback whose method name is not in this set
- * (`qb.where(x => …)`) still classifies as `Function`. There is no clean
- * syntactic line beyond the well-known Array surface, so the set is
- * intentionally closed and easy to extend.
- *
- * Receiver-blind, by design: the match keys on the method NAME only, never
- * the receiver type (tree-sitter has no type information here). So an in-set
- * name on a NON-array receiver — `Map`/`Set` `.forEach`, an RxJS
- * `observable.map(…)`, a query builder `.sort(…)`, a lodash chain
- * `.filter(…)` — is ALSO treated as a callback and has its
- * `@declaration.function` dropped. This is an accepted limitation, not a
- * regression: those bindings hold the call's *result value*, not a callable,
- * so a value def is the correct classification anyway. The only genuine loss
- * is a bespoke DSL whose in-set-named method returns something callable —
- * rare enough to accept rather than guard with type inference. Pinned by the
- * "in-set method on a non-array receiver" case in `*-captures.test.ts`.
- */
-export declare const ARRAY_CALLBACK_METHODS: ReadonlySet<string>;
 /**
  * True when `node` (an `arrow_function` / `function_expression`) is the
  * callback argument of an array higher-order-method call, i.e. the
@@ -60,8 +34,8 @@ export declare const ARRAY_CALLBACK_METHODS: ReadonlySet<string>;
  * (`forwardRef(() => …)` — callee is an `identifier`, not a
  * `member_expression`), so neither is ever suppressed.
  *
- * Intentional non-suppressing gaps (preserve current behavior, no
- * regression): parenthesized callee `(arr.map)(cb)` (`parenthesized_expression`)
- * and computed callee `arr['map'](cb)` (`subscript_expression`).
+ * The helper itself only handles direct `member_expression` callees. Broader
+ * shapes like `(arr.map)(cb)` and `arr['map'](cb)` are now filtered at the
+ * query layer, so this emit-side check stays focused on the direct fallback.
  */
 export declare function isArrayMethodCallbackArrow(node: SyntaxNode): boolean;

package/dist/core/ingestion/languages/typescript/array-callback.js

@@ -22,46 +22,7 @@
  *
  * Pure given the input node. No I/O, no globals.
  */
-/**
- * Array prototype higher-order methods whose result is a value, not a
- * function. A callback passed to one of these is an anonymous callback,
- * never a top-level function definition. Identifier-callee HOCs
- * (`forwardRef(...)`, `useCallback(...)`, custom factories) are
- * deliberately NOT listed — they keep their `Function` classification.
- *
- * Trade-off (unchanged from before #1876): a custom *fluent-API* member
- * call with a callback whose method name is not in this set
- * (`qb.where(x => …)`) still classifies as `Function`. There is no clean
- * syntactic line beyond the well-known Array surface, so the set is
- * intentionally closed and easy to extend.
- *
- * Receiver-blind, by design: the match keys on the method NAME only, never
- * the receiver type (tree-sitter has no type information here). So an in-set
- * name on a NON-array receiver — `Map`/`Set` `.forEach`, an RxJS
- * `observable.map(…)`, a query builder `.sort(…)`, a lodash chain
- * `.filter(…)` — is ALSO treated as a callback and has its
- * `@declaration.function` dropped. This is an accepted limitation, not a
- * regression: those bindings hold the call's *result value*, not a callable,
- * so a value def is the correct classification anyway. The only genuine loss
- * is a bespoke DSL whose in-set-named method returns something callable —
- * rare enough to accept rather than guard with type inference. Pinned by the
- * "in-set method on a non-array receiver" case in `*-captures.test.ts`.
- */
-export const ARRAY_CALLBACK_METHODS = new Set([
-    'map',
-    'filter',
-    'find',
-    'findIndex',
-    'findLast',
-    'findLastIndex',
-    'forEach',
-    'reduce',
-    'reduceRight',
-    'some',
-    'every',
-    'flatMap',
-    'sort',
-]);
+import { ARRAY_CALLBACK_METHODS } from '../../ts-js-hoc-utils.js';
 /**
  * True when `node` (an `arrow_function` / `function_expression`) is the
  * callback argument of an array higher-order-method call, i.e. the
@@ -73,9 +34,9 @@ export const ARRAY_CALLBACK_METHODS = new Set([
  * (`forwardRef(() => …)` — callee is an `identifier`, not a
  * `member_expression`), so neither is ever suppressed.
  *
- * Intentional non-suppressing gaps (preserve current behavior, no
- * regression): parenthesized callee `(arr.map)(cb)` (`parenthesized_expression`)
- * and computed callee `arr['map'](cb)` (`subscript_expression`).
+ * The helper itself only handles direct `member_expression` callees. Broader
+ * shapes like `(arr.map)(cb)` and `arr['map'](cb)` are now filtered at the
+ * query layer, so this emit-side check stays focused on the direct fallback.
  */
 export function isArrayMethodCallbackArrow(node) {
     const args = node.parent;

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

@@ -33,6 +33,7 @@ import { computeTsArityMetadata } from './arity-metadata.js';
 import { isArrayMethodCallbackArrow } from './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';
 /** tree-sitter-typescript node types for function-like scopes that may
  *  carry a synthesized `this` binding. Kept in sync with the
  *  `@scope.function` patterns in `query.ts`. */
@@ -242,6 +243,15 @@ export function emitTsScopeCaptures(sourceText, filePath, cachedTree) {
             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 declaration anchors
         // before pushing the match. The registry uses these to narrow

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

@@ -52,6 +52,7 @@
  */
 import Parser from 'tree-sitter';
 import TS from 'tree-sitter-typescript';
+import { ARRAY_METHOD_NOT_ANY_OF_PREDICATE, DEFAULT_EXPORT_IDENTIFIER_NOT_ANY_OF_PREDICATE, } from '../../ts-js-hoc-utils.js';
 // tree-sitter-typescript exports both `typescript` and `tsx` grammars on
 // the default export. The package's `.d.ts` types the default export
 // loosely; we narrow at the use site. The two grammars are NOT
@@ -273,10 +274,16 @@ const TYPESCRIPT_SCOPE_QUERY = `
 ;; via \`(filePath, type, qualifiedName)\` — second wins. Acceptable;
 ;; multi-arrow-callback APIs are rare (\`new Promise(executor)\` is the
 ;; main one and takes a single executor).
+;;
+;; NOTE: Split into identifier vs member_expression patterns. Member
+;; expressions are filtered with a blocklist of common array methods
+;; (map, filter, reduce, etc.) to avoid false positives like
+;; \`const x = arr.map(a => ...)\` being classified as Function.
 (lexical_declaration
   (variable_declarator
     name: (identifier) @declaration.name
     value: (call_expression
+      function: (identifier)
       arguments: (arguments
         (arrow_function) @declaration.function))))
 
@@ -284,13 +291,35 @@ const TYPESCRIPT_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})
+
 (variable_declaration
   (variable_declarator
     name: (identifier) @declaration.name
     value: (call_expression
+      function: (identifier)
       arguments: (arguments
         (arrow_function) @declaration.function))))
 
@@ -298,9 +327,64 @@ const TYPESCRIPT_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: \`export default defineEventHandler(async (e) => { ... })\`.
+;; The emit phase rewrites @declaration.name to a file-derived name so
+;; wrappers like \`defineEventHandler\` / \`React.memo\` do not collapse
+;; unrelated modules onto the same 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})
+
 ;; Method definitions — regular + private (#field) methods.
 (method_definition
   name: (property_identifier) @declaration.name) @declaration.method

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

@@ -26,6 +26,7 @@ import { typescriptVariableConfig, javascriptVariableConfig, } from '../variable
 import { createCallExtractor } from '../call-extractors/generic.js';
 import { typescriptCallConfig, javascriptCallConfig, } from '../call-extractors/configs/typescript-javascript.js';
 import { createHeritageExtractor } from '../heritage-extractors/generic.js';
+import { ARRAY_METHOD_HOC_BLOCKLIST_SET, DEFAULT_EXPORT_IDENTIFIER_BLOCKLIST_SET, deriveDefaultExportHocName, } from '../ts-js-hoc-utils.js';
 import { emitTsScopeCaptures, interpretTsImport, interpretTsTypeBinding, tsBindingScopeFor, tsImportOwningScope, tsReceiverBinding, typescriptMergeBindings, typescriptArityCompatibility, resolveTsImportTarget, } from './typescript/index.js';
 import { emitJsScopeCaptures, interpretJsImport, interpretJsTypeBinding, jsBindingScopeFor, jsImportOwningScope, jsReceiverBinding, jsMergeBindings, jsArityCompatibility, } from './javascript/index.js';
 /**
@@ -54,7 +55,7 @@ import { emitJsScopeCaptures, interpretJsImport, interpretJsTypeBinding, jsBindi
  * findEnclosingFunctionId then continues up to the next named ancestor
  * (or to the file).
  */
-const tsExtractFunctionName = (node) => {
+const tsExtractFunctionName = (node, filePath) => {
     if (node.type !== 'arrow_function' && node.type !== 'function_expression')
         return null;
     const parent = node.parent;
@@ -99,27 +100,56 @@ const tsExtractFunctionName = (node) => {
     // `arguments`, grandparent is `call_expression`, great-grandparent is
     // `variable_declarator`. Walk the chain up and take the variable's name
     // — the meaningful identifier the developer wrote on the LHS. Mirrors
-    // the four registry-primary patterns in `typescript/query.ts`. The
-    // wrapping callee (`forwardRef`, `memo`, `React.memo`, `useCallback`,
-    // user-defined HOCs) is intentionally NOT constrained: any function
-    // call whose result is bound to a const and whose first/positional
-    // argument is an arrow takes the const's name. Chained array-method
-    // calls (`const x = arr.find((y) => p(y))`) match too and produce a
-    // mostly-harmless `Function:x` (consumed as a value, never invoked),
-    // accepted as a small false-positive cost vs. the much larger gain of
-    // capturing the React UI-component idiom.
+    // the four registry-primary patterns in `typescript/query.ts`.
+    //
+    // NOTE: Excludes common array methods (map, filter, reduce, etc.) to avoid
+    // false positives like `const x = arr.map(a => ...)` being classified as
+    // Function when it's actually a Const holding an array.
     if (parent.type === 'arguments') {
         const callExpr = parent.parent;
         if (!callExpr || callExpr.type !== 'call_expression') {
             return { funcName: null, label: 'Function' };
         }
+        // Check if callee is a member_expression calling an array method
+        const callee = callExpr.childForFieldName?.('function');
+        if (callee?.type === 'member_expression') {
+            const property = callee.childForFieldName?.('property');
+            if (property?.type === 'property_identifier' &&
+                ARRAY_METHOD_HOC_BLOCKLIST_SET.has(property.text)) {
+                return { funcName: null, label: 'Function' };
+            }
+        }
         const declarator = callExpr.parent;
-        if (!declarator || declarator.type !== 'variable_declarator') {
+        // Existing path: const X = HOC(arrow)
+        if (declarator?.type === 'variable_declarator') {
+            const nameNode = declarator.childForFieldName?.('name');
+            if (nameNode?.type === 'identifier') {
+                return { funcName: nameNode.text, label: 'Function' };
+            }
             return { funcName: null, label: 'Function' };
         }
-        const nameNode = declarator.childForFieldName?.('name');
-        if (nameNode?.type === 'identifier') {
-            return { funcName: nameNode.text, label: 'Function' };
+        // export default HOC(arrow) — name it from the file, not the wrapper.
+        // This keeps route handlers and wrapped defaults navigable without
+        // collapsing every file onto names like `memo` or `defineEventHandler`.
+        if (declarator?.type === 'export_statement') {
+            if (callee?.type === 'identifier') {
+                if (DEFAULT_EXPORT_IDENTIFIER_BLOCKLIST_SET.has(callee.text)) {
+                    return { funcName: null, label: 'Function' };
+                }
+                return {
+                    funcName: filePath ? deriveDefaultExportHocName(filePath) : null,
+                    label: 'Function',
+                };
+            }
+            // Member-expression callees like React.memo keep the same file-derived
+            // name, with array-like helpers excluded above.
+            if (callee?.type === 'member_expression') {
+                return {
+                    funcName: filePath ? deriveDefaultExportHocName(filePath) : null,
+                    label: 'Function',
+                };
+            }
+            return { funcName: null, label: 'Function' };
         }
         return { funcName: null, label: 'Function' };
     }

package/dist/core/ingestion/method-types.d.ts

@@ -50,7 +50,7 @@ export interface MethodExtractor {
      *  unwrapping, Swift init/deinit, Rust impl_item) provide this hook
      *  to replace the generic name-field lookup.
      *  Return null to fall through to the generic extractor. */
-    extractFunctionName?(node: SyntaxNode): {
+    extractFunctionName?(node: SyntaxNode, filePath?: string): {
         funcName: string | null;
         label: import('../../_shared/index.js').NodeLabel;
     } | null;
@@ -84,7 +84,7 @@ export interface MethodExtractionConfig {
     extractPrimaryConstructor?: (ownerNode: SyntaxNode, context: MethodExtractorContext) => MethodInfo | null;
     /** Extract function name + label from an AST node during parent-walk.
      *  Passed through to the MethodExtractor by createMethodExtractor. */
-    extractFunctionName?: (node: SyntaxNode) => {
+    extractFunctionName?: (node: SyntaxNode, filePath?: string) => {
         funcName: string | null;
         label: import('../../_shared/index.js').NodeLabel;
     } | null;