@optave/codegraph 3.9.5 → 3.9.6

package/src/ast-analysis/rules/index.ts

@@ -73,10 +73,187 @@ export const DATAFLOW_RULES: Map<string, DataflowRulesConfig> = new Map([
   ['ruby', ruby.dataflow],
 ]);
 
-// ─── AST Type Maps ───────────────────────────────────────────────────────
+// ─── AST Node Type Maps ──────────────────────────────────────────────────
+//
+// These mirror the per-language `LangAstConfig` constants in the native Rust
+// engine (`crates/codegraph-core/src/extractors/helpers.rs`). WASM and native
+// must agree on which tree-sitter node types to emit as `ast_nodes` rows.
+// Languages without a dedicated rules/*.ts file have their maps inlined here.
+
+const JS_AST_TYPES = javascript.astTypes as Record<string, string>;
+const PY_AST_TYPES = python.astTypes as Record<string, string>;
+const GO_AST_TYPES = go.astTypes as Record<string, string>;
+const RS_AST_TYPES = rust.astTypes as Record<string, string>;
+const JAVA_AST_TYPES = java.astTypes as Record<string, string>;
+const CS_AST_TYPES = csharp.astTypes as Record<string, string>;
+const RB_AST_TYPES = ruby.astTypes as Record<string, string>;
+const PHP_AST_TYPES = php.astTypes as Record<string, string>;
+
+const C_AST_TYPES: Record<string, string> = {
+  string_literal: 'string',
+};
+
+const CPP_AST_TYPES: Record<string, string> = {
+  new_expression: 'new',
+  throw_statement: 'throw',
+  co_await_expression: 'await',
+  string_literal: 'string',
+  raw_string_literal: 'string',
+};
+
+const KOTLIN_AST_TYPES: Record<string, string> = {
+  throw_expression: 'throw',
+  string_literal: 'string',
+};
+
+const SWIFT_AST_TYPES: Record<string, string> = {
+  throw_statement: 'throw',
+  await_expression: 'await',
+  string_literal: 'string',
+};
+
+const SCALA_AST_TYPES: Record<string, string> = {
+  object_creation_expression: 'new',
+  throw_expression: 'throw',
+  string_literal: 'string',
+};
+
+const BASH_AST_TYPES: Record<string, string> = {
+  string: 'string',
+  expansion: 'string',
+};
+
+const ELIXIR_AST_TYPES: Record<string, string> = {
+  string: 'string',
+  sigil: 'regex',
+};
+
+const LUA_AST_TYPES: Record<string, string> = {
+  string: 'string',
+};
+
+const DART_AST_TYPES: Record<string, string> = {
+  new_expression: 'new',
+  constructor_invocation: 'new',
+  throw_expression: 'throw',
+  await_expression: 'await',
+  string_literal: 'string',
+};
+
+const ZIG_AST_TYPES: Record<string, string> = {
+  string_literal: 'string',
+};
+
+const HASKELL_AST_TYPES: Record<string, string> = {
+  string: 'string',
+  char: 'string',
+};
+
+const OCAML_AST_TYPES: Record<string, string> = {
+  string: 'string',
+};
 
 export const AST_TYPE_MAPS: Map<string, Record<string, string>> = new Map([
-  ['javascript', javascript.astTypes as Record<string, string>],
-  ['typescript', javascript.astTypes as Record<string, string>],
-  ['tsx', javascript.astTypes as Record<string, string>],
+  ['javascript', JS_AST_TYPES],
+  ['typescript', JS_AST_TYPES],
+  ['tsx', JS_AST_TYPES],
+  ['python', PY_AST_TYPES],
+  ['go', GO_AST_TYPES],
+  ['rust', RS_AST_TYPES],
+  ['java', JAVA_AST_TYPES],
+  ['csharp', CS_AST_TYPES],
+  ['ruby', RB_AST_TYPES],
+  ['php', PHP_AST_TYPES],
+  ['c', C_AST_TYPES],
+  ['cpp', CPP_AST_TYPES],
+  ['kotlin', KOTLIN_AST_TYPES],
+  ['swift', SWIFT_AST_TYPES],
+  ['scala', SCALA_AST_TYPES],
+  ['bash', BASH_AST_TYPES],
+  ['elixir', ELIXIR_AST_TYPES],
+  ['lua', LUA_AST_TYPES],
+  ['dart', DART_AST_TYPES],
+  ['zig', ZIG_AST_TYPES],
+  ['haskell', HASKELL_AST_TYPES],
+  ['ocaml', OCAML_AST_TYPES],
+  ['ocaml-interface', OCAML_AST_TYPES],
+]);
+
+// ─── Per-language string-extraction config ───────────────────────────────
+//
+// Mirrors `quote_chars` + `string_prefixes` in the native `LangAstConfig`.
+// Used by the AST-store visitor to strip quote characters and language-
+// specific prefix sigils (Python `r"..."`, C# verbatim `@"..."`, Rust raw
+// `r#"..."#`, etc.) when computing string content for the `name` column.
+
+export interface AstStringConfig {
+  quoteChars: string;
+  stringPrefixes: string;
+}
+
+const JS_STRING_CONFIG: AstStringConfig = { quoteChars: '\'"`', stringPrefixes: '' };
+const PY_STRING_CONFIG: AstStringConfig = { quoteChars: '\'"', stringPrefixes: 'rbfuRBFU' };
+const GO_STRING_CONFIG: AstStringConfig = { quoteChars: '"`', stringPrefixes: '' };
+const RS_STRING_CONFIG: AstStringConfig = { quoteChars: '"', stringPrefixes: '' };
+const JAVA_STRING_CONFIG: AstStringConfig = { quoteChars: '"', stringPrefixes: '' };
+const CS_STRING_CONFIG: AstStringConfig = { quoteChars: '"', stringPrefixes: '' };
+const RB_STRING_CONFIG: AstStringConfig = { quoteChars: '\'"', stringPrefixes: '' };
+const PHP_STRING_CONFIG: AstStringConfig = { quoteChars: '\'"', stringPrefixes: '' };
+const C_STRING_CONFIG: AstStringConfig = { quoteChars: '"', stringPrefixes: '' };
+const CPP_STRING_CONFIG: AstStringConfig = { quoteChars: '"', stringPrefixes: 'LuUR' };
+const KOTLIN_STRING_CONFIG: AstStringConfig = { quoteChars: '"', stringPrefixes: '' };
+const SWIFT_STRING_CONFIG: AstStringConfig = { quoteChars: '"', stringPrefixes: '' };
+const SCALA_STRING_CONFIG: AstStringConfig = { quoteChars: '"', stringPrefixes: '' };
+const BASH_STRING_CONFIG: AstStringConfig = { quoteChars: '"\'', stringPrefixes: '' };
+const ELIXIR_STRING_CONFIG: AstStringConfig = { quoteChars: '"', stringPrefixes: '' };
+const LUA_STRING_CONFIG: AstStringConfig = { quoteChars: '\'"', stringPrefixes: '' };
+const DART_STRING_CONFIG: AstStringConfig = { quoteChars: '\'"', stringPrefixes: '' };
+const ZIG_STRING_CONFIG: AstStringConfig = { quoteChars: '"', stringPrefixes: '' };
+const HASKELL_STRING_CONFIG: AstStringConfig = { quoteChars: '"\'', stringPrefixes: '' };
+const OCAML_STRING_CONFIG: AstStringConfig = { quoteChars: '"', stringPrefixes: '' };
+
+export const AST_STRING_CONFIGS: Map<string, AstStringConfig> = new Map([
+  ['javascript', JS_STRING_CONFIG],
+  ['typescript', JS_STRING_CONFIG],
+  ['tsx', JS_STRING_CONFIG],
+  ['python', PY_STRING_CONFIG],
+  ['go', GO_STRING_CONFIG],
+  ['rust', RS_STRING_CONFIG],
+  ['java', JAVA_STRING_CONFIG],
+  ['csharp', CS_STRING_CONFIG],
+  ['ruby', RB_STRING_CONFIG],
+  ['php', PHP_STRING_CONFIG],
+  ['c', C_STRING_CONFIG],
+  ['cpp', CPP_STRING_CONFIG],
+  ['kotlin', KOTLIN_STRING_CONFIG],
+  ['swift', SWIFT_STRING_CONFIG],
+  ['scala', SCALA_STRING_CONFIG],
+  ['bash', BASH_STRING_CONFIG],
+  ['elixir', ELIXIR_STRING_CONFIG],
+  ['lua', LUA_STRING_CONFIG],
+  ['dart', DART_STRING_CONFIG],
+  ['zig', ZIG_STRING_CONFIG],
+  ['haskell', HASKELL_STRING_CONFIG],
+  ['ocaml', OCAML_STRING_CONFIG],
+  ['ocaml-interface', OCAML_STRING_CONFIG],
 ]);
+
+// ─── Per-language "stop-after-collect" kinds ─────────────────────────────
+//
+// Mirrors the subtle difference between the native JS walker
+// (`extractors/javascript.rs::walk_ast_nodes_depth`) — which *returns* after
+// collecting `new_expression` and `throw_statement` to avoid double-counting
+// the wrapped expression — and the generic walker (`helpers.rs::walk_ast_
+// nodes_with_config_depth`), which always recurses. For WASM/native parity
+// the JS family must skip recursion on `new` and `throw`; every other
+// language recurses normally.
+
+const JS_STOP_RECURSE: ReadonlySet<string> = new Set(['new', 'throw']);
+const EMPTY_STOP_RECURSE: ReadonlySet<string> = new Set();
+
+export function astStopRecurseKinds(langId: string): ReadonlySet<string> {
+  if (langId === 'javascript' || langId === 'typescript' || langId === 'tsx') {
+    return JS_STOP_RECURSE;
+  }
+  return EMPTY_STOP_RECURSE;
+}

package/src/ast-analysis/rules/java.ts

@@ -174,4 +174,8 @@ export const dataflow: DataflowRulesConfig = makeDataflowRules({
 
 // ─── AST Node Types ───────────────────────────────────────────────────────
 
-export const astTypes: Record<string, string> | null = null;
+export const astTypes: Record<string, string> | null = {
+  object_creation_expression: 'new',
+  throw_statement: 'throw',
+  string_literal: 'string',
+};

package/src/ast-analysis/rules/php.ts

@@ -218,4 +218,9 @@ export const dataflow: DataflowRulesConfig = makeDataflowRules({
 
 // ─── AST Node Types ───────────────────────────────────────────────────────
 
-export const astTypes: Record<string, string> | null = null;
+export const astTypes: Record<string, string> | null = {
+  object_creation_expression: 'new',
+  throw_expression: 'throw',
+  string: 'string',
+  encapsed_string: 'string',
+};

package/src/ast-analysis/rules/python.ts

@@ -195,4 +195,8 @@ export const dataflow: DataflowRulesConfig = makeDataflowRules({
 
 // ─── AST Node Types ───────────────────────────────────────────────────────
 
-export const astTypes: Record<string, string> | null = null;
+export const astTypes: Record<string, string> | null = {
+  raise_statement: 'throw',
+  await: 'await',
+  string: 'string',
+};

package/src/ast-analysis/rules/ruby.ts

@@ -203,4 +203,7 @@ export const dataflow: DataflowRulesConfig = makeDataflowRules({
 
 // ─── AST Node Types ───────────────────────────────────────────────────────
 
-export const astTypes: Record<string, string> | null = null;
+export const astTypes: Record<string, string> | null = {
+  string: 'string',
+  regex: 'regex',
+};

package/src/ast-analysis/rules/rust.ts

@@ -172,4 +172,8 @@ export const dataflow: DataflowRulesConfig = makeDataflowRules({
 
 // ─── AST Node Types ───────────────────────────────────────────────────────
 
-export const astTypes: Record<string, string> | null = null;
+export const astTypes: Record<string, string> | null = {
+  await_expression: 'await',
+  string_literal: 'string',
+  raw_string_literal: 'string',
+};

package/src/ast-analysis/visitors/ast-store-visitor.ts

@@ -5,9 +5,42 @@ import type {
   Visitor,
   VisitorContext,
 } from '../../types.js';
+import type { AstStringConfig } from '../rules/index.js';
 
 const TEXT_MAX = 200;
 
+// ── Cross-language node-type constants (mirror Rust `helpers.rs`) ────────
+const IDENT_TYPES = new Set<string>([
+  'identifier',
+  'type_identifier',
+  'name',
+  'qualified_name',
+  'scoped_identifier',
+  'qualified_identifier',
+  'member_expression',
+  'member_access_expression',
+  'field_expression',
+  'attribute',
+  'scoped_type_identifier',
+]);
+
+const CALL_TYPES = new Set<string>([
+  'call_expression',
+  'call',
+  'invocation_expression',
+  'method_invocation',
+  'function_call_expression',
+  'member_call_expression',
+  'scoped_call_expression',
+]);
+
+const DEFAULT_STRING_CONFIG: AstStringConfig = { quoteChars: '\'"`', stringPrefixes: '' };
+
+// Keyword tokens skipped when extracting the inner expression text of a
+// throw/raise/await/new node. Module-level constant avoids reallocating on
+// every call (can be hot in large files).
+const CHILD_EXPR_SKIP_KEYWORDS = new Set<string>(['throw', 'raise', 'await', 'new']);
+
 interface AstStoreRow {
   file: string;
   line: number;
@@ -20,69 +53,122 @@ interface AstStoreRow {
 
 function truncate(s: string | null | undefined, max: number = TEXT_MAX): string | null {
   if (!s) return null;
-  return s.length <= max ? s : `${s.slice(0, max - 1)}\u2026`;
+  return s.length <= max ? s : `${s.slice(0, max - 1)}…`;
+}
+
+function trimLeadingChars(s: string, chars: string): string {
+  if (!chars) return s;
+  let i = 0;
+  while (i < s.length && chars.includes(s[i]!)) i++;
+  return i === 0 ? s : s.slice(i);
 }
 
-function extractNewName(node: TreeSitterNode): string {
+function trimTrailingChars(s: string, chars: string): string {
+  if (!chars) return s;
+  let i = s.length;
+  while (i > 0 && chars.includes(s[i - 1]!)) i--;
+  return i === s.length ? s : s.slice(0, i);
+}
+
+/** Extract constructor name from a `new_expression` / `object_creation_expression`. */
+function extractConstructorName(node: TreeSitterNode): string {
+  for (const field of ['type', 'class', 'constructor']) {
+    const f = node.childForFieldName(field);
+    if (f?.text) return f.text;
+  }
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
     if (!child) continue;
-    if (child.type === 'identifier') return child.text;
-    if (child.type === 'member_expression') return child.text;
+    if (IDENT_TYPES.has(child.type)) return child.text;
+  }
+  const raw = node.text || '';
+  const beforeParen = raw.split('(')[0] || raw;
+  return beforeParen.replace(/^new\s+/, '').trim() || '?';
+}
+
+/** Extract function name from a call node. */
+function extractCallName(node: TreeSitterNode): string {
+  for (const field of ['function', 'method', 'name']) {
+    const f = node.childForFieldName(field);
+    if (f?.text) return f.text;
   }
-  return node.text?.split('(')[0]?.replace('new ', '').trim() || '?';
+  const text = node.text || '';
+  return text.split('(')[0] || '?';
 }
 
-function extractExpressionText(node: TreeSitterNode): string | null {
+/** Extract name from a throw/raise statement — matches native `extract_throw_target`. */
+function extractThrowName(node: TreeSitterNode, newTypes: Set<string>): string {
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
     if (!child) continue;
-    if (child.type !== 'throw' && child.type !== 'await') {
-      return truncate(child.text);
-    }
+    const ck = child.type;
+    if (newTypes.has(ck)) return extractConstructorName(child);
+    if (CALL_TYPES.has(ck)) return extractCallName(child);
+    if (IDENT_TYPES.has(ck)) return child.text;
   }
-  return truncate(node.text);
+  return truncate(node.text) ?? node.text ?? '';
 }
 
-/** Extract the name from a throw statement's child nodes. */
-function extractThrowName(node: TreeSitterNode): string | null {
+/** Extract name from an await expression — matches native `extract_awaited_name`. */
+function extractAwaitName(node: TreeSitterNode): string {
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
     if (!child) continue;
-    if (child.type === 'new_expression') return extractNewName(child);
-    if (child.type === 'call_expression') {
-      const fn = child.childForFieldName('function');
-      return fn ? fn.text : child.text?.split('(')[0] || '?';
-    }
-    if (child.type === 'identifier') return child.text;
+    const ck = child.type;
+    if (CALL_TYPES.has(ck)) return extractCallName(child);
+    if (IDENT_TYPES.has(ck)) return child.text;
   }
-  return truncate(node.text);
+  return truncate(node.text) ?? node.text ?? '';
 }
 
-/** Extract the name from an await expression's child nodes. */
-function extractAwaitName(node: TreeSitterNode): string | null {
+/** Extract text of the expression inside a throw/await, skipping the keyword. */
+function extractChildExpressionText(node: TreeSitterNode): string | null {
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
     if (!child) continue;
-    if (child.type === 'call_expression') {
-      const fn = child.childForFieldName('function');
-      return fn ? fn.text : child.text?.split('(')[0] || '?';
-    }
-    if (child.type === 'identifier' || child.type === 'member_expression') {
-      return child.text;
-    }
+    if (!CHILD_EXPR_SKIP_KEYWORDS.has(child.type)) return truncate(child.text);
   }
   return truncate(node.text);
 }
 
+/**
+ * Extract string content from a string-literal node, mirroring the native
+ * engine's `build_string_node` (`helpers.rs`). Returns `null` when the
+ * content is shorter than 2 Unicode code points.
+ */
+function extractStringContent(node: TreeSitterNode, cfg: AstStringConfig): string | null {
+  const raw = node.text ?? '';
+  const isRawString = node.type.includes('raw_string');
+
+  let s = raw;
+  s = trimLeadingChars(s, '@');
+  s = trimLeadingChars(s, cfg.stringPrefixes);
+  if (isRawString) s = trimLeadingChars(s, 'r#');
+  s = trimLeadingChars(s, cfg.quoteChars);
+  if (isRawString) s = trimTrailingChars(s, '#');
+  s = trimTrailingChars(s, cfg.quoteChars);
+
+  // Count code points, not UTF-16 code units — matches Rust `chars().count()`.
+  const codePointCount = [...s].length;
+  if (codePointCount < 2) return null;
+  return s;
+}
+
 export function createAstStoreVisitor(
   astTypeMap: Record<string, string>,
   defs: Definition[],
   relPath: string,
   nodeIdMap: Map<string, number>,
+  stringConfig: AstStringConfig = DEFAULT_STRING_CONFIG,
+  stopRecurseKinds: ReadonlySet<string> = new Set(),
 ): Visitor {
   const rows: AstStoreRow[] = [];
   const matched = new Set<number>();
+  const newTypes = new Set<string>(
+    Object.entries(astTypeMap)
+      .filter(([, kind]) => kind === 'new')
+      .map(([type]) => type),
+  );
 
   function findParentDef(line: number): Definition | null {
     let best: Definition | null = null;
@@ -106,12 +192,15 @@ export function createAstStoreVisitor(
   type KindHandler = (node: TreeSitterNode) => NameTextResult;
 
   const kindHandlers: Record<string, KindHandler> = {
-    new: (node) => ({ name: extractNewName(node), text: truncate(node.text) }),
-    throw: (node) => ({ name: extractThrowName(node), text: extractExpressionText(node) }),
-    await: (node) => ({ name: extractAwaitName(node), text: extractExpressionText(node) }),
+    new: (node) => ({ name: extractConstructorName(node), text: truncate(node.text) }),
+    throw: (node) => ({
+      name: extractThrowName(node, newTypes),
+      text: extractChildExpressionText(node),
+    }),
+    await: (node) => ({ name: extractAwaitName(node), text: extractChildExpressionText(node) }),
     string: (node) => {
-      const content = node.text?.replace(/^['"`]|['"`]$/g, '') || '';
-      if (content.length < 2) return { name: null, text: null, skip: true };
+      const content = extractStringContent(node, stringConfig);
+      if (content == null) return { name: null, text: null, skip: true };
       return { name: truncate(content, 100), text: truncate(node.text) };
     },
     regex: (node) => ({ name: node.text || '?', text: truncate(node.text) }),
@@ -156,7 +245,13 @@ export function createAstStoreVisitor(
 
       collectNode(node, kind);
 
-      if (kind !== 'string' && kind !== 'regex') {
+      // Mirror the native walker's recursion policy. In JS/TS, the native
+      // javascript.rs walker returns after collecting `new` or `throw` to
+      // avoid double-counting the wrapped expression (e.g. `throw new
+      // Error('x')` emits one `throw` row, not throw+new+string). Other
+      // languages go through helpers.rs::walk_ast_nodes_with_config_depth
+      // which always recurses — so `stopRecurseKinds` is empty for them.
+      if (stopRecurseKinds.has(kind)) {
         return { skipChildren: true };
       }
     },

package/src/domain/graph/builder/pipeline.ts

@@ -32,7 +32,13 @@ import type {
   ExtractorOutput,
   SqliteStatement,
 } from '../../../types.js';
-import { getActiveEngine, getInstalledWasmExtensions, parseFilesAuto } from '../../parser.js';
+import {
+  classifyNativeDrops,
+  formatDropExtensionSummary,
+  getActiveEngine,
+  getInstalledWasmExtensions,
+  parseFilesAuto,
+} from '../../parser.js';
 import { setWorkspaces } from '../resolve.js';
 import { PipelineContext } from './context.js';
 import { batchInsertNodes, collectFiles as collectFilesUtil, loadPathAliases } from './helpers.js';
@@ -761,18 +767,32 @@ async function backfillNativeDroppedFiles(ctx: PipelineContext): Promise<void> {
   // minimal installs) can't be parsed by either engine, so they're not a
   // native regression — excluding them keeps the warn count meaningful.
   const installedExts = getInstalledWasmExtensions();
+  const missingRel: string[] = [];
   const missingAbs: string[] = [];
   for (const rel of expected) {
     if (existing.has(rel)) continue;
     const ext = path.extname(rel).toLowerCase();
     if (!installedExts.has(ext)) continue;
+    missingRel.push(rel);
     missingAbs.push(path.join(ctx.rootDir, rel));
   }
   if (missingAbs.length === 0) return;
 
-  warn(
-    `Native orchestrator dropped ${missingAbs.length} file(s); backfilling via WASM for engine parity`,
-  );
+  // Classify drops so users see per-extension reasons instead of just a count
+  // (#1011). `unsupported-by-native` is a legitimate parser limit (no Rust
+  // extractor); `native-extractor-failure` indicates a real native bug since
+  // the language IS supported by the addon yet the file was dropped anyway.
+  const { byReason, totals } = classifyNativeDrops(missingRel);
+  if (totals['unsupported-by-native'] > 0) {
+    info(
+      `Native orchestrator skipped ${totals['unsupported-by-native']} file(s) in languages without a Rust extractor; backfilling via WASM: ${formatDropExtensionSummary(byReason['unsupported-by-native'])}`,
+    );
+  }
+  if (totals['native-extractor-failure'] > 0) {
+    warn(
+      `Native orchestrator dropped ${totals['native-extractor-failure']} file(s) in natively-supported languages — likely a Rust extractor bug. Backfilling via WASM: ${formatDropExtensionSummary(byReason['native-extractor-failure'])}`,
+    );
+  }
   const wasmResults = await parseFilesAuto(missingAbs, ctx.rootDir, { engine: 'wasm' });
 
   const rows: unknown[][] = [];

package/src/domain/parser.ts

@@ -412,6 +412,128 @@ export function getInstalledWasmExtensions(): Set<string> {
   return exts;
 }
 
+/**
+ * Lowercase file extensions covered by the native Rust addon.
+ *
+ * Mirrors `LanguageKind::from_extension` in
+ * `crates/codegraph-core/src/parser_registry.rs`. Used to classify why the
+ * native orchestrator dropped a file: extensions outside this set are a
+ * legitimate parser limit (no Rust extractor exists), while extensions inside
+ * it indicate a real native bug (parse/read/extract failure).
+ *
+ * Keep this list in sync with the Rust enum — the native addon is a separate
+ * npm package, so JS has no runtime way to discover its language coverage.
+ */
+export const NATIVE_SUPPORTED_EXTENSIONS: ReadonlySet<string> = new Set([
+  '.js',
+  '.jsx',
+  '.mjs',
+  '.cjs',
+  '.ts',
+  '.tsx',
+  '.py',
+  '.pyi',
+  '.tf',
+  '.hcl',
+  '.go',
+  '.rs',
+  '.java',
+  '.cs',
+  '.rb',
+  '.rake',
+  '.gemspec',
+  '.php',
+  '.phtml',
+  '.c',
+  '.h',
+  '.cpp',
+  '.cc',
+  '.cxx',
+  '.hpp',
+  '.kt',
+  '.kts',
+  '.swift',
+  '.scala',
+  '.sh',
+  '.bash',
+  '.ex',
+  '.exs',
+  '.lua',
+  '.dart',
+  '.zig',
+  '.hs',
+  '.ml',
+  '.mli',
+]);
+
+/**
+ * Classification for a file the native orchestrator dropped.
+ * - `unsupported-by-native`: extension has no Rust extractor (legitimate parser limit).
+ * - `native-extractor-failure`: extension is supported by native but the file was
+ *   still dropped — points at a real bug (read error, parse failure, extractor crash).
+ */
+export type NativeDropReason = 'unsupported-by-native' | 'native-extractor-failure';
+
+export interface NativeDropClassification {
+  /** Per-reason → per-extension → list of relative paths that hit that bucket. */
+  byReason: Record<NativeDropReason, Map<string, string[]>>;
+  /** Total file count per reason. */
+  totals: Record<NativeDropReason, number>;
+}
+
+/**
+ * Group the missing files (relative paths) by drop reason and extension so the
+ * caller can log per-extension counts and a sample path. Pure function — no
+ * I/O, safe to unit-test independently of the build pipeline.
+ */
+export function classifyNativeDrops(relPaths: Iterable<string>): NativeDropClassification {
+  const byReason: Record<NativeDropReason, Map<string, string[]>> = {
+    'unsupported-by-native': new Map(),
+    'native-extractor-failure': new Map(),
+  };
+  const totals: Record<NativeDropReason, number> = {
+    'unsupported-by-native': 0,
+    'native-extractor-failure': 0,
+  };
+  for (const rel of relPaths) {
+    const ext = path.extname(rel).toLowerCase();
+    const reason: NativeDropReason = NATIVE_SUPPORTED_EXTENSIONS.has(ext)
+      ? 'native-extractor-failure'
+      : 'unsupported-by-native';
+    const bucket = byReason[reason];
+    let list = bucket.get(ext);
+    if (!list) {
+      list = [];
+      bucket.set(ext, list);
+    }
+    list.push(rel);
+    totals[reason]++;
+  }
+  return { byReason, totals };
+}
+
+/**
+ * Render `{ ext → paths[] }` as `ext (n: sample.ext, ...)` slices for log lines.
+ * Caps at 3 sample paths per extension and 6 extensions total to keep warnings
+ * readable when many languages are dropped at once. Extensions are sorted by
+ * descending file count so the loudest offender shows up first; ties keep
+ * insertion order. Pure function — safe to unit-test independently.
+ */
+export function formatDropExtensionSummary(buckets: Map<string, string[]>): string {
+  const MAX_EXTS = 6;
+  const MAX_SAMPLES = 3;
+  const entries = Array.from(buckets.entries()).sort((a, b) => b[1].length - a[1].length);
+  const shown = entries.slice(0, MAX_EXTS).map(([ext, paths]) => {
+    const sample = paths.slice(0, MAX_SAMPLES).join(', ');
+    const more = paths.length > MAX_SAMPLES ? `, +${paths.length - MAX_SAMPLES} more` : '';
+    return `${ext} (${paths.length}: ${sample}${more})`;
+  });
+  if (entries.length > MAX_EXTS) {
+    shown.push(`+${entries.length - MAX_EXTS} more extension(s)`);
+  }
+  return shown.join('; ');
+}
+
 // ── Unified API ──────────────────────────────────────────────────────────────
 
 function resolveEngine(opts: ParseEngineOpts = {}): ResolvedEngine {

package/src/domain/search/models.ts

@@ -253,7 +253,7 @@ export async function embed(
     }
 
     if (texts.length > batchSize) {
-      process.stdout.write(`  Embedded ${Math.min(i + batchSize, texts.length)}/${texts.length}\r`);
+      process.stderr.write(`  Embedded ${Math.min(i + batchSize, texts.length)}/${texts.length}\r`);
     }
   }