@optave/codegraph 3.8.1 → 3.9.1

package/src/domain/parser.ts

@@ -102,6 +102,12 @@ let _cachedLanguages: Map<string, Language> | null = null;
 // Query cache for JS/TS/TSX extractors (populated during createParsers)
 const _queryCache: Map<string, Query> = new Map();
 
+// Tracks whether ALL grammars have been loaded (vs. a lazy subset)
+let _allParsersLoaded: boolean = false;
+
+// In-flight grammar loads keyed by language id — prevents concurrent duplicate loads
+const _loadingPromises: Map<string, Promise<void>> = new Map();
+
 // Extensions that need typeMap backfill (type annotations only exist in TS/TSX)
 const TS_BACKFILL_EXTS = new Set(['.ts', '.tsx']);
 
@@ -137,6 +143,8 @@ const COMMON_QUERY_PATTERNS: string[] = [
   '(call_expression function: (identifier) @callfn_name) @callfn_node',
   '(call_expression function: (member_expression) @callmem_fn) @callmem_node',
   '(call_expression function: (subscript_expression) @callsub_fn) @callsub_node',
+  '(new_expression constructor: (identifier) @newfn_name) @newfn_node',
+  '(new_expression constructor: (member_expression) @newmem_fn) @newmem_node',
   '(expression_statement (assignment_expression left: (member_expression) @assign_left right: (_) @assign_right)) @assign_node',
 ];
 
@@ -150,42 +158,87 @@ const TS_EXTRA_PATTERNS: string[] = [
   '(type_alias_declaration name: (type_identifier) @type_name) @type_node',
 ];
 
-export async function createParsers(): Promise<Map<string, Parser | null>> {
-  if (_cachedParsers) return _cachedParsers;
+/**
+ * Load a single language grammar and cache the parser + language + query.
+ * Uses in-flight deduplication so concurrent callers awaiting the same grammar
+ * share a single load rather than producing orphaned WASM instances.
+ * Assumes Parser.init() has already been called and _cachedParsers/_cachedLanguages exist.
+ */
+async function loadLanguage(entry: LanguageRegistryEntry): Promise<void> {
+  if (_cachedParsers!.has(entry.id)) return;
+  const inflight = _loadingPromises.get(entry.id);
+  if (inflight) return inflight;
+  const p = doLoadLanguage(entry).finally(() => _loadingPromises.delete(entry.id));
+  _loadingPromises.set(entry.id, p);
+  return p;
+}
+
+async function doLoadLanguage(entry: LanguageRegistryEntry): Promise<void> {
+  try {
+    const lang = await Language.load(grammarPath(entry.grammarFile));
+    const parser = new Parser();
+    parser.setLanguage(lang);
+    _cachedParsers!.set(entry.id, parser);
+    _cachedLanguages!.set(entry.id, lang);
+    if (entry.extractor === extractSymbols && !_queryCache.has(entry.id)) {
+      const isTS = entry.id === 'typescript' || entry.id === 'tsx';
+      const patterns = isTS
+        ? [...COMMON_QUERY_PATTERNS, ...TS_EXTRA_PATTERNS]
+        : [...COMMON_QUERY_PATTERNS, JS_CLASS_PATTERN];
+      _queryCache.set(entry.id, new Query(lang, patterns.join('\n')));
+    }
+  } catch (e: unknown) {
+    if (entry.required) throw e;
+    warn(
+      `${entry.id} parser failed to initialize: ${(e as Error).message}. ${entry.id} files will be skipped.`,
+    );
+    _cachedParsers!.set(entry.id, null);
+  }
+}
 
+async function initParserRuntime(): Promise<void> {
   if (!_initialized) {
     await Parser.init();
     _initialized = true;
   }
+  if (!_cachedParsers) _cachedParsers = new Map();
+  if (!_cachedLanguages) _cachedLanguages = new Map();
+}
 
-  const parsers = new Map<string, Parser | null>();
-  const languages = new Map<string, Language>();
+/**
+ * Load only the WASM grammars needed for the given file paths.
+ * Grammars already in cache are reused. This avoids the ~500ms cold-start
+ * penalty of loading all 23+ grammars when only 1-2 are needed (e.g. incremental rebuilds).
+ */
+async function ensureParsersForFiles(filePaths: string[]): Promise<Map<string, Parser | null>> {
+  await initParserRuntime();
+  const needed = new Set<LanguageRegistryEntry>();
+  for (const fp of filePaths) {
+    const ext = path.extname(fp).toLowerCase();
+    const entry = _extToLang.get(ext);
+    if (entry && !_cachedParsers!.has(entry.id)) needed.add(entry);
+  }
+  for (const entry of needed) {
+    await loadLanguage(entry);
+  }
+  return _cachedParsers!;
+}
+
+/**
+ * Load ALL WASM grammars. Used by full builds and feature modules (CFG, dataflow, complexity)
+ * that may process files of any language.
+ */
+export async function createParsers(): Promise<Map<string, Parser | null>> {
+  if (_cachedParsers && _allParsersLoaded) return _cachedParsers;
+
+  await initParserRuntime();
   for (const entry of LANGUAGE_REGISTRY) {
-    try {
-      const lang = await Language.load(grammarPath(entry.grammarFile));
-      const parser = new Parser();
-      parser.setLanguage(lang);
-      parsers.set(entry.id, parser);
-      languages.set(entry.id, lang);
-      // Compile and cache tree-sitter Query for JS/TS/TSX extractors
-      if (entry.extractor === extractSymbols && !_queryCache.has(entry.id)) {
-        const isTS = entry.id === 'typescript' || entry.id === 'tsx';
-        const patterns = isTS
-          ? [...COMMON_QUERY_PATTERNS, ...TS_EXTRA_PATTERNS]
-          : [...COMMON_QUERY_PATTERNS, JS_CLASS_PATTERN];
-        _queryCache.set(entry.id, new Query(lang, patterns.join('\n')));
-      }
-    } catch (e: unknown) {
-      if (entry.required) throw e;
-      warn(
-        `${entry.id} parser failed to initialize: ${(e as Error).message}. ${entry.id} files will be skipped.`,
-      );
-      parsers.set(entry.id, null);
+    if (!_cachedParsers!.has(entry.id)) {
+      await loadLanguage(entry);
     }
   }
-  _cachedParsers = parsers;
-  _cachedLanguages = languages;
-  return parsers;
+  _allParsersLoaded = true;
+  return _cachedParsers!;
 }
 
 /**
@@ -217,6 +270,8 @@ export function disposeParsers(): void {
     _cachedLanguages = null;
   }
   _initialized = false;
+  _allParsersLoaded = false;
+  _loadingPromises.clear();
 }
 
 export function getParser(parsers: Map<string, Parser | null>, filePath: string): Parser | null {
@@ -235,20 +290,15 @@ export async function ensureWasmTrees(
   fileSymbols: Map<string, any>,
   rootDir: string,
 ): Promise<void> {
-  // Check if any file needs a tree
-  let needsParse = false;
+  // Single pass: collect absolute paths for files that need parsing
+  const filePaths: string[] = [];
   for (const [relPath, symbols] of fileSymbols) {
-    if (!symbols._tree) {
-      const ext = path.extname(relPath).toLowerCase();
-      if (_extToLang.has(ext)) {
-        needsParse = true;
-        break;
-      }
+    if (!symbols._tree && _extToLang.has(path.extname(relPath).toLowerCase())) {
+      filePaths.push(path.join(rootDir, relPath));
     }
   }
-  if (!needsParse) return;
-
-  const parsers = await createParsers();
+  if (filePaths.length === 0) return;
+  const parsers = await ensureParsersForFiles(filePaths);
 
   for (const [relPath, symbols] of fileSymbols) {
     if (symbols._tree) continue;
@@ -337,17 +387,19 @@ function patchImports(imports: any[]): void {
   }
 }
 
-/** Normalize native typeMap array to a Map instance. */
+/** Normalize native typeMap array to a Map instance.
+ *  Uses first-wins semantics at equal confidence to match the WASM/JS extractor. */
 function patchTypeMap(r: any): void {
   if (!r.typeMap) {
     r.typeMap = new Map();
   } else if (!(r.typeMap instanceof Map)) {
-    r.typeMap = new Map(
-      r.typeMap.map((e: { name: string; typeName: string }) => [
-        e.name,
-        { type: e.typeName, confidence: 0.9 } as TypeMapEntry,
-      ]),
-    );
+    const map = new Map<string, TypeMapEntry>();
+    for (const e of r.typeMap as Array<{ name: string; typeName: string }>) {
+      if (!map.has(e.name)) {
+        map.set(e.name, { type: e.typeName, confidence: (e as any).confidence ?? 0.9 });
+      }
+    }
+    r.typeMap = map;
   }
 }
 
@@ -640,10 +692,17 @@ for (const entry of LANGUAGE_REGISTRY) {
 export const SUPPORTED_EXTENSIONS: Set<string> = new Set(_extToLang.keys());
 
 /**
- * WASM-based typeMap backfill for older native binaries that don't emit typeMap.
+ * WASM-based typeMap backfill for TS/TSX files parsed by the native engine.
+ * Serves two purposes:
+ * 1. Compatibility with older native binaries that don't emit typeMap (< 3.2.0).
+ * 2. Workaround for native parser scope-collision bugs — when the same variable
+ *    name appears at multiple scopes, native type extraction can produce
+ *    incorrect results. WASM's JS-based extractor handles scope traversal
+ *    more accurately. TODO: Remove purpose (2) once the Rust extractor handles
+ *    nested scopes correctly.
+ *
  * Uses tree-sitter AST extraction instead of regex to avoid false positives from
  * matches inside comments and string literals.
- * TODO: Remove once all published native binaries include typeMap extraction (>= 3.2.0)
  */
 async function backfillTypeMap(
   filePath: string,
@@ -658,7 +717,7 @@ async function backfillTypeMap(
       return { typeMap: new Map(), backfilled: false };
     }
   }
-  const parsers = await createParsers();
+  const parsers = await ensureParsersForFiles([filePath]);
   const extracted = wasmExtractSymbols(parsers, filePath, code);
   try {
     if (!extracted || extracted.symbols.typeMap.size === 0) {
@@ -720,23 +779,26 @@ export async function parseFileAuto(
     const result = native.parseFile(filePath, source, !!opts.dataflow, opts.ast !== false);
     if (!result) return null;
     const patched = patchNativeResult(result);
-    // Only backfill typeMap for TS/TSX — JS files have no type annotations,
-    // and the native engine already handles `new Expr()` patterns.
-    if (patched.typeMap.size === 0 && TS_BACKFILL_EXTS.has(path.extname(filePath))) {
+    // Always backfill typeMap for TS/TSX from WASM — native parser's type
+    // extraction can produce incorrect scope-collision results. Non-TS files
+    // are skipped to stay consistent with the batch path (backfillTypeMapBatch).
+    if (TS_BACKFILL_EXTS.has(path.extname(filePath))) {
       const { typeMap, backfilled } = await backfillTypeMap(filePath, source);
-      patched.typeMap = typeMap;
-      if (backfilled) patched._typeMapBackfilled = true;
+      if (backfilled) {
+        patched.typeMap = typeMap;
+        patched._typeMapBackfilled = true;
+      }
     }
     return patched;
   }
 
   // WASM path
-  const parsers = await createParsers();
+  const parsers = await ensureParsersForFiles([filePath]);
   const extracted = wasmExtractSymbols(parsers, filePath, source);
   return extracted ? extracted.symbols : null;
 }
 
-/** Backfill typeMap via WASM for files missing type-map data from native engine. */
+/** Backfill typeMap via WASM for TS/TSX files parsed by the native engine. */
 async function backfillTypeMapBatch(
   needsTypeMap: { filePath: string; relPath: string }[],
   result: Map<string, ExtractorOutput>,
@@ -746,7 +808,7 @@ async function backfillTypeMapBatch(
   );
   if (tsFiles.length === 0) return;
 
-  const parsers = await createParsers();
+  const parsers = await ensureParsersForFiles(tsFiles.map((f) => f.filePath));
   for (const { filePath, relPath } of tsFiles) {
     let extracted: WasmExtractResult | null | undefined;
     try {
@@ -778,7 +840,7 @@ async function parseFilesWasm(
   rootDir: string,
 ): Promise<Map<string, ExtractorOutput>> {
   const result = new Map<string, ExtractorOutput>();
-  const parsers = await createParsers();
+  const parsers = await ensureParsersForFiles(filePaths);
   for (const filePath of filePaths) {
     let code: string;
     try {
@@ -819,7 +881,12 @@ export async function parseFilesAuto(
     const patched = patchNativeResult(r);
     const relPath = path.relative(rootDir, r.file).split(path.sep).join('/');
     result.set(relPath, patched);
-    if (patched.typeMap.size === 0) {
+    // Always backfill TS/TSX type maps from WASM — the native parser's type
+    // extraction can produce incorrect results when the same variable name
+    // appears at multiple scopes (e.g. `node: TreeSitterNode` in one function
+    // vs `node: NodeRow` in another). The WASM JS extractor handles scope
+    // traversal order more accurately.
+    if (TS_BACKFILL_EXTS.has(path.extname(r.file))) {
       needsTypeMap.push({ filePath: r.file, relPath });
     }
   }
@@ -877,12 +944,13 @@ export async function parseFileIncremental(
     const result = cache.parseFile(filePath, source);
     if (!result) return null;
     const patched = patchNativeResult(result);
-    // Only backfill typeMap for TS/TSX — JS files have no type annotations,
-    // and the native engine already handles `new Expr()` patterns.
-    if (patched.typeMap.size === 0 && TS_BACKFILL_EXTS.has(path.extname(filePath))) {
+    // Always backfill typeMap for TS/TSX from WASM (see parseFileAuto comment).
+    if (TS_BACKFILL_EXTS.has(path.extname(filePath))) {
       const { typeMap, backfilled } = await backfillTypeMap(filePath, source);
-      patched.typeMap = typeMap;
-      if (backfilled) patched._typeMapBackfilled = true;
+      if (backfilled) {
+        patched.typeMap = typeMap;
+        patched._typeMapBackfilled = true;
+      }
     }
     return patched;
   }

package/src/domain/search/models.ts

@@ -74,6 +74,7 @@ export const MODELS: Record<string, ModelConfig> = {
 export const EMBEDDING_STRATEGIES: readonly string[] = ['structured', 'source'];
 
 export const DEFAULT_MODEL: string = 'nomic-v1.5';
+const NPM_BIN = process.platform === 'win32' ? 'npm.cmd' : 'npm';
 const BATCH_SIZE_MAP: Record<string, number> = {
   minilm: 32,
   'jina-small': 16,
@@ -106,13 +107,15 @@ export function promptInstall(packageName: string): Promise<boolean> {
   if (!process.stdin.isTTY) {
     info(`Installing ${packageName} (optional dependency for semantic search)…`);
     try {
-      execFileSync('npm', ['install', '--no-save', packageName], {
+      execFileSync(NPM_BIN, ['install', '--no-save', packageName], {
         stdio: 'inherit',
         timeout: 300_000,
       });
       return Promise.resolve(true);
     } catch (err) {
-      info(`Auto-install failed: ${err instanceof Error ? err.message : String(err)}`);
+      info(
+        `Auto-install of ${packageName} failed (${err instanceof Error ? err.message : String(err)}). Install it manually with:\n  npm install ${packageName}`,
+      );
       return Promise.resolve(false);
     }
   }
@@ -125,12 +128,15 @@ export function promptInstall(packageName: string): Promise<boolean> {
         rl.close();
         if (answer.trim().toLowerCase() !== 'y') return resolve(false);
         try {
-          execFileSync('npm', ['install', packageName], {
+          execFileSync(NPM_BIN, ['install', packageName], {
             stdio: 'inherit',
             timeout: 300_000,
           });
           resolve(true);
-        } catch {
+        } catch (err) {
+          info(
+            `Install of ${packageName} failed (${err instanceof Error ? err.message : String(err)}). Install it manually with:\n  npm install ${packageName}`,
+          );
           resolve(false);
         }
       },
@@ -188,7 +194,7 @@ async function loadModel(modelKey?: string): Promise<{ extractor: unknown; confi
   pipeline = transformers.pipeline;
 
   info(`Loading embedding model: ${config.name} (${config.dim}d)...`);
-  const pipelineOpts = config.quantized ? { quantized: true } : {};
+  const pipelineOpts = config.quantized ? { dtype: 'q8' } : {};
   try {
     extractor =
       await // biome-ignore lint/complexity/noBannedTypes: dynamically loaded transformers pipeline is untyped

package/src/extractors/go.ts

@@ -266,44 +266,69 @@ function handleTypedIdentifiers(
 }
 
 /** Infer type from a single RHS expression in a short var declaration. */
-function inferShortVarType(
+/** x := Struct{...} — composite literal (confidence 1.0). */
+function inferCompositeLiteral(
   varNode: TreeSitterNode,
   rhs: TreeSitterNode,
   typeMap: Map<string, { type: string; confidence: number }>,
-): void {
-  // x := Struct{...} — composite literal (confidence 1.0)
-  if (rhs.type === 'composite_literal') {
-    const typeNode = rhs.childForFieldName('type');
-    if (typeNode) {
-      const typeName = extractGoTypeName(typeNode);
-      if (typeName) setTypeMapEntry(typeMap, varNode.text, typeName, 1.0);
-    }
-  }
-  // x := &Struct{...} — address-of composite literal (confidence 1.0)
-  if (rhs.type === 'unary_expression') {
-    const operand = rhs.childForFieldName('operand');
-    if (operand && operand.type === 'composite_literal') {
-      const typeNode = operand.childForFieldName('type');
-      if (typeNode) {
-        const typeName = extractGoTypeName(typeNode);
-        if (typeName) setTypeMapEntry(typeMap, varNode.text, typeName, 1.0);
-      }
-    }
-  }
-  // x := NewFoo() or x := pkg.NewFoo() — factory function (confidence 0.7)
-  if (rhs.type === 'call_expression') {
-    const fn = rhs.childForFieldName('function');
-    if (fn && fn.type === 'selector_expression') {
-      const field = fn.childForFieldName('field');
-      if (field?.text.startsWith('New')) {
-        const typeName = field.text.slice(3);
-        if (typeName) setTypeMapEntry(typeMap, varNode.text, typeName, 0.7);
-      }
-    } else if (fn && fn.type === 'identifier' && fn.text.startsWith('New')) {
-      const typeName = fn.text.slice(3);
+): boolean {
+  if (rhs.type !== 'composite_literal') return false;
+  const typeNode = rhs.childForFieldName('type');
+  if (!typeNode) return false;
+  const typeName = extractGoTypeName(typeNode);
+  if (typeName) setTypeMapEntry(typeMap, varNode.text, typeName, 1.0);
+  return true;
+}
+
+/** x := &Struct{...} — address-of composite literal (confidence 1.0). */
+function inferAddressOfComposite(
+  varNode: TreeSitterNode,
+  rhs: TreeSitterNode,
+  typeMap: Map<string, { type: string; confidence: number }>,
+): boolean {
+  if (rhs.type !== 'unary_expression') return false;
+  const operand = rhs.childForFieldName('operand');
+  if (!operand || operand.type !== 'composite_literal') return false;
+  const typeNode = operand.childForFieldName('type');
+  if (!typeNode) return false;
+  const typeName = extractGoTypeName(typeNode);
+  if (typeName) setTypeMapEntry(typeMap, varNode.text, typeName, 1.0);
+  return true;
+}
+
+/** x := NewFoo() or x := pkg.NewFoo() — factory function (confidence 0.7). */
+function inferFactoryCall(
+  varNode: TreeSitterNode,
+  rhs: TreeSitterNode,
+  typeMap: Map<string, { type: string; confidence: number }>,
+): boolean {
+  if (rhs.type !== 'call_expression') return false;
+  const fn = rhs.childForFieldName('function');
+  if (!fn) return false;
+
+  if (fn.type === 'selector_expression') {
+    const field = fn.childForFieldName('field');
+    if (field?.text.startsWith('New')) {
+      const typeName = field.text.slice(3);
       if (typeName) setTypeMapEntry(typeMap, varNode.text, typeName, 0.7);
+      return true;
     }
+  } else if (fn.type === 'identifier' && fn.text.startsWith('New')) {
+    const typeName = fn.text.slice(3);
+    if (typeName) setTypeMapEntry(typeMap, varNode.text, typeName, 0.7);
+    return true;
   }
+  return false;
+}
+
+function inferShortVarType(
+  varNode: TreeSitterNode,
+  rhs: TreeSitterNode,
+  typeMap: Map<string, { type: string; confidence: number }>,
+): void {
+  if (inferCompositeLiteral(varNode, rhs, typeMap)) return;
+  if (inferAddressOfComposite(varNode, rhs, typeMap)) return;
+  inferFactoryCall(varNode, rhs, typeMap);
 }
 
 /** Handle short_var_declaration: x := Struct{}, x := &Struct{}, x := NewFoo(). */

package/src/extractors/javascript.ts

@@ -202,6 +202,48 @@ function handleExportCapture(
   }
 }
 
+function handleInterfaceCapture(
+  c: Record<string, TreeSitterNode>,
+  definitions: Definition[],
+): void {
+  const ifaceNode = c.iface_node!;
+  const ifaceName = c.iface_name!.text;
+  definitions.push({
+    name: ifaceName,
+    kind: 'interface',
+    line: ifaceNode.startPosition.row + 1,
+    endLine: nodeEndLine(ifaceNode),
+  });
+  const body =
+    ifaceNode.childForFieldName('body') ||
+    findChild(ifaceNode, 'interface_body') ||
+    findChild(ifaceNode, 'object_type');
+  if (body) extractInterfaceMethods(body, ifaceName, definitions);
+}
+
+function handleTypeCapture(c: Record<string, TreeSitterNode>, definitions: Definition[]): void {
+  const typeNode = c.type_node!;
+  definitions.push({
+    name: c.type_name!.text,
+    kind: 'type',
+    line: typeNode.startPosition.row + 1,
+    endLine: nodeEndLine(typeNode),
+  });
+}
+
+function handleImportCapture(c: Record<string, TreeSitterNode>, imports: Import[]): void {
+  const impNode = c.imp_node!;
+  const isTypeOnly = impNode.text.startsWith('import type');
+  const modPath = c.imp_source!.text.replace(/['"]/g, '');
+  const names = extractImportNames(impNode);
+  imports.push({
+    source: modPath,
+    names,
+    line: impNode.startPosition.row + 1,
+    typeOnly: isTypeOnly,
+  });
+}
+
 /** Dispatch a single query match to the appropriate handler. */
 function dispatchQueryMatch(
   c: Record<string, TreeSitterNode>,
@@ -220,35 +262,11 @@ function dispatchQueryMatch(
   } else if (c.meth_node) {
     handleMethodCapture(c, definitions);
   } else if (c.iface_node) {
-    const ifaceName = c.iface_name!.text;
-    definitions.push({
-      name: ifaceName,
-      kind: 'interface',
-      line: c.iface_node.startPosition.row + 1,
-      endLine: nodeEndLine(c.iface_node),
-    });
-    const body =
-      c.iface_node.childForFieldName('body') ||
-      findChild(c.iface_node, 'interface_body') ||
-      findChild(c.iface_node, 'object_type');
-    if (body) extractInterfaceMethods(body, ifaceName, definitions);
+    handleInterfaceCapture(c, definitions);
   } else if (c.type_node) {
-    definitions.push({
-      name: c.type_name!.text,
-      kind: 'type',
-      line: c.type_node.startPosition.row + 1,
-      endLine: nodeEndLine(c.type_node),
-    });
+    handleTypeCapture(c, definitions);
   } else if (c.imp_node) {
-    const isTypeOnly = c.imp_node.text.startsWith('import type');
-    const modPath = c.imp_source!.text.replace(/['"]/g, '');
-    const names = extractImportNames(c.imp_node);
-    imports.push({
-      source: modPath,
-      names,
-      line: c.imp_node.startPosition.row + 1,
-      typeOnly: isTypeOnly,
-    });
+    handleImportCapture(c, imports);
   } else if (c.exp_node) {
     handleExportCapture(c, exps, imports);
   } else if (c.callfn_node) {
@@ -264,6 +282,14 @@ function dispatchQueryMatch(
   } else if (c.callsub_node) {
     const callInfo = extractCallInfo(c.callsub_fn!, c.callsub_node);
     if (callInfo) calls.push(callInfo);
+  } else if (c.newfn_node) {
+    calls.push({
+      name: c.newfn_name!.text,
+      line: c.newfn_node.startPosition.row + 1,
+    });
+  } else if (c.newmem_node) {
+    const callInfo = extractCallInfo(c.newmem_fn!, c.newmem_node);
+    if (callInfo) calls.push(callInfo);
   } else if (c.assign_node) {
     handleCommonJSAssignment(c.assign_left!, c.assign_right!, c.assign_node, imports);
   }
@@ -502,6 +528,9 @@ function walkJavaScriptNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
     case 'call_expression':
       handleCallExpr(node, ctx);
       break;
+    case 'new_expression':
+      handleNewExpr(node, ctx);
+      break;
     case 'import_statement':
       handleImportStmt(node, ctx);
       break;
@@ -689,6 +718,17 @@ function handleCallExpr(node: TreeSitterNode, ctx: ExtractorOutput): void {
   }
 }
 
+function handleNewExpr(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const ctor = node.childForFieldName('constructor') || node.child(1);
+  if (!ctor) return;
+  if (ctor.type === 'identifier') {
+    ctx.calls.push({ name: ctor.text, line: node.startPosition.row + 1 });
+  } else if (ctor.type === 'member_expression') {
+    const callInfo = extractCallInfo(ctor, node);
+    if (callInfo) ctx.calls.push(callInfo);
+  }
+}
+
 /** Handle a dynamic import() call expression and add to imports if static. */
 function handleDynamicImportCall(node: TreeSitterNode, imports: Import[]): void {
   const args = node.childForFieldName('arguments') || findChild(node, 'arguments');
@@ -997,21 +1037,34 @@ function handleVarDeclaratorTypeMap(
   const nameN = node.childForFieldName('name');
   if (!nameN || nameN.type !== 'identifier') return;
 
-  // Type annotation: const x: Foo = …
   const typeAnno = findChild(node, 'type_annotation');
+  const valueN = node.childForFieldName('value');
+
+  // Constructor on the same declaration wins over annotation: the runtime type is
+  // what matters for call resolution (e.g. `const x: Base = new Derived()` should
+  // resolve `x.render()` to `Derived.render`, not `Base.render`).
+  // When no constructor is present, annotation still takes precedence over factory.
+  if (valueN?.type === 'new_expression') {
+    const ctorType = extractNewExprTypeName(valueN);
+    if (ctorType) {
+      setTypeMapEntry(typeMap, nameN.text, ctorType, 1.0);
+      return;
+    }
+  }
+
+  // Type annotation: const x: Foo = … → confidence 0.9
   if (typeAnno) {
     const typeName = extractSimpleTypeName(typeAnno);
-    if (typeName) setTypeMapEntry(typeMap, nameN.text, typeName, 0.9);
+    if (typeName) {
+      setTypeMapEntry(typeMap, nameN.text, typeName, 0.9);
+      return;
+    }
   }
 
-  const valueN = node.childForFieldName('value');
   if (!valueN) return;
 
-  // Constructor: const x = new Foo() → confidence 1.0
-  if (valueN.type === 'new_expression') {
-    const ctorType = extractNewExprTypeName(valueN);
-    if (ctorType) setTypeMapEntry(typeMap, nameN.text, ctorType, 1.0);
-  }
+  // Constructor already handled above — only factory path remains.
+  if (valueN.type === 'new_expression') return;
   // Factory method: const x = Foo.create() → confidence 0.7
   else if (valueN.type === 'call_expression') {
     const fn = valueN.childForFieldName('function');