codedeep-mcp 0.1.0

package/dist/indexer/languages/typescript.js

@@ -0,0 +1,485 @@
+import { IMPORT_DEFAULT, IMPORT_NAMESPACE, RECEIVER_OPAQUE } from '../../types.js';
+import { SIGNATURE_DISPLAY_CAP, bareDecoratorIdentifier, commentDocLine, declSignature, normalizeSignature, resolveCalls, symbolId, } from '../extractor.js';
+import { cFamilyBooleanOperatorKind, computeComplexity, isCFamilyBooleanOperator, } from '../complexity.js';
+// Function-like nodes whose bodies contain calls that shouldn't attribute
+// to an enclosing body. walkDecorators uses this subset (NOT the full
+// SKIP_TYPES) so it still descends through class bodies — top-level
+// decorators on inner classes attribute to the enclosing function — but
+// stops at nested function bodies, where decorator firing is gated on the
+// nested function being called.
+const TS_FUNCTION_BODY_SKIP_TYPES = new Set([
+    'function_declaration',
+    'function_expression',
+    'arrow_function',
+    'method_definition',
+]);
+const TS_SKIP_TYPES = new Set([
+    ...TS_FUNCTION_BODY_SKIP_TYPES,
+    'class_declaration',
+    'class_expression',
+    'abstract_class_declaration',
+]);
+const TS_SELECTORS = [
+    { nodeType: 'call_expression', getCallee: (n) => n.childForFieldName('function') },
+    { nodeType: 'new_expression', getCallee: (n) => n.childForFieldName('constructor') },
+    { nodeType: 'jsx_opening_element', getCallee: jsxComponentName },
+    { nodeType: 'jsx_self_closing_element', getCallee: jsxComponentName },
+    { nodeType: 'decorator', getCallee: bareDecoratorIdentifier },
+];
+// JSX components are PascalCase by convention; lowercase first char is an
+// HTML element (`<div>`, `<span>`) which we don't track as a symbol ref.
+function jsxComponentName(node) {
+    const name = node.childForFieldName('name');
+    if (!name || name.type !== 'identifier')
+        return null;
+    const ch = name.text.charAt(0);
+    if (ch >= 'a' && ch <= 'z')
+        return null;
+    return name;
+}
+// Dominant JS/TS fluent/stdlib method names (>=4 chars) suppressed when a
+// member call to them is unresolved — without this, capturing chained calls
+// floods the name-keyed store with `.then()`/`.filter()`/`.map()`-style noise.
+// Domain method names (zod's `.optional`/`.nullable`/`.refine`, etc.) are
+// deliberately absent — those are the recall win. <=3-char names (`.map`,
+// `.get`, `.set`) are gated downstream by SHORT_NAME_THRESHOLD, so they're
+// omitted here.
+const TS_IGNORED_MEMBER_CALLEES = new Set([
+    'then', 'catch', 'finally', 'filter', 'forEach', 'reduce', 'flatMap',
+    'concat', 'slice', 'splice', 'indexOf', 'lastIndexOf', 'includes', 'join',
+    'find', 'findIndex', 'some', 'every', 'sort', 'reverse', 'push',
+    'replace', 'replaceAll', 'trim', 'split', 'startsWith', 'endsWith',
+    'substring', 'toLowerCase', 'toUpperCase', 'toString', 'valueOf',
+    'keys', 'values', 'entries', 'hasOwnProperty', 'charAt', 'padStart',
+    'padEnd', 'repeat', 'delete',
+]);
+// The four TS loop nodes (`for_in_statement` covers both for-of and for-in) —
+// shared by the cyclomatic decision set and the cognitive surcharge set.
+const TS_LOOP_NODE_TYPES = new Set([
+    'for_statement',
+    'for_in_statement',
+    'while_statement',
+    'do_statement',
+]);
+// Cyclomatic decision nodes — VERIFIED against SonarJS source (S1541 rule.ts):
+// each adds +1. `for_in_statement` covers both `for…of` and `for…in`;
+// `switch_case` counts per non-default case label (the extractor's `switch_case`
+// node corresponds to a SwitchCase WITH a test) while `switch_default` and the
+// `switch_statement` container do NOT. `&&`/`||`/`??` count via the shared
+// isCFamilyBooleanOperator. NOTE the deliberate omissions that match SonarJS but
+// differ from the textbook set: `throw` and `catch` do NOT count (ThrowStatement
+// / CatchClause are absent from SonarJS's cyclomatic switch); `else`/`finally`/
+// `default` never count; logical-assignment `&&=`/`||=`/`??=` do NOT count.
+const TS_DECISION_NODE_TYPES = new Set([
+    ...TS_LOOP_NODE_TYPES,
+    'if_statement',
+    'switch_case',
+    'ternary_expression',
+]);
+// COGNITIVE config — VERIFIED-EXACT against SonarJS S3776 (eslint-plugin-sonarjs
+// `cjs/S3776/rule.js`, clean-room read + threshold-0 oracle), which differs
+// MATERIALLY from sonar-java (do not assume the Java config transfers): see the
+// boolean + JSX notes below. All node names AST-dumped against the bundled
+// grammars. See complexity.ts + the project docs' "Cognitive Complexity Rules".
+const TS_COGNITIVE_OPTIONS = {
+    ifType: 'if_statement',
+    conditionField: 'condition',
+    consequenceField: 'consequence',
+    alternativeField: 'alternative',
+    // tree-sitter-typescript wraps else/else-if in an `else_clause` node (UNLIKE
+    // Java's direct `alternative`); the engine unwraps it. else-if = +1 flat.
+    elseClauseType: 'else_clause',
+    loopTypes: TS_LOOP_NODE_TYPES,
+    // TS uses `switch_statement` (not Java's `switch_expression`); the WHOLE switch
+    // is +1 regardless of case count (the cognitive/cyclomatic divergence).
+    switchTypes: new Set(['switch_statement']),
+    ternaryType: 'ternary_expression',
+    catchType: 'catch_clause',
+    // EMPTY by design: nested functions/arrows are already in TS_SKIP_TYPES (the
+    // cognitive walk's boundary prunes them), so each top-level fn / method /
+    // arrow-const gets its OWN standalone cognitive number and nested-fn control
+    // flow counts toward nobody — matching SonarJS's per-function report (an
+    // extracted symbol's number == SonarJS's) and the TS cyclomatic arrow-callback
+    // gap. Adding arrows here would double-count them into the encloser.
+    nestOnlyTypes: new Set(),
+    labeledJumpTypes: new Set(['break_statement', 'continue_statement']),
+    // Read the `label` FIELD, not namedChildCount: an unlabeled `break /*c*/;`
+    // carries a comment as a named child, so counting children would misread it as
+    // labeled and add a spurious +1.
+    hasLabel: (node) => node.childForFieldName('label') != null,
+    // SonarJS counts ONLY maximal `&&` runs; `cFamilyBooleanOperatorKind` returns
+    // the kind for `&&`/`||`/`??` so `||`/`??` stay in the source-order run as
+    // breakers, and booleanRunStarts filters to `&&`-run-starts (`||`/`??` never
+    // count). NB cyclomatic DOES count `||`/`??` — the expected cyc/cog divergence.
+    booleanOperatorKind: cFamilyBooleanOperatorKind,
+    booleanRunStarts: (kind, prev) => kind === '&&' && prev !== '&&',
+    excludeBooleanRun: tsBooleanRunExcluded,
+    parenthesizedType: 'parenthesized_expression',
+};
+// SonarJS S3776 excludes a UNIFORM-operator logical expression whose immediate
+// parent is a JSX `{...}` container (`jsx_expression` — covers both JSX children
+// and attribute values) from the cognitive count: `{cond && <X/>}` / `{a && b}` /
+// `{foo() && bar()}` / `<div x={a && a}/>` all score 0 (oracle-confirmed). A
+// MIXED-operator tree is NOT excluded (`{(a || b) && <X/>}` = 1). Mirrors the
+// plugin's `flattenJsxShortCircuitNodes`: bail on a ternary or a different-operator
+// logical node; recurse same-operator operands; any other leaf is fine.
+function tsBooleanRunExcluded(root) {
+    // Walk up through parenthesized_expression wrappers before the container test:
+    // SonarJS runs on ESTree, which has no paren nodes, so a WHOLE-expression-
+    // parenthesized short-circuit (`{(cond && <X/>)}`, a common conditional-render
+    // idiom) sits DIRECTLY under the JSX container there and IS excluded. tree-sitter
+    // keeps the paren node between them, so without this walk codedeep-mcp would over-count.
+    let container = root.parent;
+    while (container?.type === 'parenthesized_expression')
+        container = container.parent;
+    if (container?.type !== 'jsx_expression')
+        return false;
+    const rootOp = cFamilyBooleanOperatorKind(root);
+    if (rootOp === null)
+        return false;
+    const uniform = (node) => {
+        // Unwrap parens like the engine's skipParens (sonar's ESTree has no paren
+        // nodes, so operands are the raw children).
+        let n = node;
+        while (n && n.type === 'parenthesized_expression')
+            n = n.namedChild(0);
+        if (!n)
+            return true;
+        if (n.type === 'ternary_expression')
+            return false;
+        const k = cFamilyBooleanOperatorKind(n);
+        if (k === null)
+            return true; // non-logical leaf
+        if (k !== rootOp)
+            return false; // different operator → not a JSX short-circuit
+        return uniform(n.childForFieldName('left')) && uniform(n.childForFieldName('right'));
+    };
+    return uniform(root);
+}
+// Peels receiver wrappers that are transparent to receiver IDENTITY:
+// `non_null_expression` (`a!`) and `parenthesized_expression` (`(a)`). The
+// wrapped expression is the first NON-COMMENT named child (the `!` and parens are
+// anonymous tokens; a leading inline comment — `(/*c*/ a)` — is a NAMED node, so
+// skip it, the same comment-skip the Go receiver unwrap does), so `a!.x()` /
+// `(a).x()` recover the inner `a`/`this` and resolve like `a.x()`. A genuinely
+// chained receiver (`a.b().c()` → call_expression) is NOT a wrapper and is left
+// intact → stays opaque.
+function unwrapReceiver(node) {
+    let n = node;
+    while (n.type === 'non_null_expression' || n.type === 'parenthesized_expression') {
+        let inner = n.firstNamedChild;
+        while (inner && inner.type === 'comment')
+            inner = inner.nextNamedSibling;
+        if (!inner)
+            break;
+        n = inner;
+    }
+    return n;
+}
+// `this.x()` / `obj.x()` carry their literal receiver token; a non-null `a!.x()`
+// or parenthesized `(a).x()` receiver is unwrapped to that token too (so it
+// resolves like `a.x()`). Genuinely chained or indexed receivers (`a.b().c()`,
+// `arr[0].run()`) carry RECEIVER_OPAQUE so the called method stays findable by
+// name (recall) but never resolves. `super.x()` (parent-class call) and
+// computed-property calls (no clean property name, e.g. `foo()[k]()`) emit nothing.
+function tsMemberCallInfo(callee) {
+    if (callee.type !== 'member_expression')
+        return null;
+    const obj = callee.childForFieldName('object');
+    const prop = callee.childForFieldName('property');
+    if (!obj || !prop)
+        return null;
+    if (prop.type !== 'property_identifier' && prop.type !== 'private_property_identifier') {
+        return null;
+    }
+    const recv = unwrapReceiver(obj);
+    if (recv.type === 'this')
+        return { receiver: 'this', property: prop.text, isSelf: true };
+    if (recv.type === 'identifier') {
+        return { receiver: recv.text, property: prop.text, isSelf: false };
+    }
+    if (recv.type === 'super')
+        return null;
+    return { receiver: RECEIVER_OPAQUE, property: prop.text, isSelf: false };
+}
+export function extractTypeScript(tree, content, fileInfo) {
+    const symbols = [];
+    const imports = [];
+    const bodies = [];
+    for (const child of tree.rootNode.namedChildren) {
+        let exported = false;
+        let target = child;
+        if (child.type === 'export_statement') {
+            const decl = child.childForFieldName('declaration');
+            // Re-exports (`export { x }`, `export * from '...'`) have no
+            // `declaration` field and contribute no new symbols here.
+            if (!decl)
+                continue;
+            exported = true;
+            target = decl;
+        }
+        extractTopLevel(target, child, content, fileInfo, exported, symbols, imports, bodies);
+    }
+    const references = resolveCalls(bodies, tree.rootNode, symbols, fileInfo, TS_SELECTORS, TS_SKIP_TYPES, TS_FUNCTION_BODY_SKIP_TYPES, tsMemberCallInfo, { ignoredMemberCallees: TS_IGNORED_MEMBER_CALLEES });
+    computeComplexity(bodies, symbols, {
+        decisionNodeTypes: TS_DECISION_NODE_TYPES,
+        extraDecisionPredicate: isCFamilyBooleanOperator,
+        skipTypes: TS_SKIP_TYPES,
+        cognitive: TS_COGNITIVE_OPTIONS,
+    });
+    return { symbols, references, imports };
+}
+function extractTopLevel(target, outer, content, fileInfo, exported, outSymbols, outImports, outBodies) {
+    switch (target.type) {
+        case 'ambient_declaration': {
+            const inner = target.firstNamedChild;
+            if (inner)
+                extractTopLevel(inner, outer, content, fileInfo, exported, outSymbols, outImports, outBodies);
+            return;
+        }
+        case 'function_declaration':
+        case 'function_signature': {
+            const name = target.childForFieldName('name')?.text;
+            if (!name)
+                return;
+            const sym = makeSymbol(target, outer, declSignature(target, content), fileInfo, 'function', name, `${fileInfo.path}:${name}`, exported);
+            outSymbols.push(sym);
+            const body = target.childForFieldName('body');
+            if (body)
+                outBodies.push({ symbolId: sym.id, body });
+            return;
+        }
+        case 'class_declaration':
+        case 'abstract_class_declaration': {
+            const className = target.childForFieldName('name')?.text;
+            if (!className)
+                return;
+            const classSym = makeSymbol(target, outer, declSignature(target, content), fileInfo, 'class', className, `${fileInfo.path}:${className}`, exported);
+            outSymbols.push(classSym);
+            const body = target.childForFieldName('body');
+            if (!body)
+                return;
+            for (const member of body.namedChildren) {
+                extractClassMember(member, content, fileInfo, className, exported, outSymbols, outBodies);
+            }
+            // Walk the class body itself so calls in static blocks and
+            // non-callable field initializers (`static x = helper()`,
+            // `field = helper()`) attribute to the class. TS_SKIP_TYPES
+            // contains method_definition + function/arrow forms, so calls
+            // inside member function bodies stay attributed to the member.
+            outBodies.push({ symbolId: classSym.id, body, className });
+            return;
+        }
+        case 'interface_declaration': {
+            const name = target.childForFieldName('name')?.text;
+            if (!name)
+                return;
+            outSymbols.push(makeSymbol(target, outer, declSignature(target, content), fileInfo, 'interface', name, `${fileInfo.path}:${name}`, exported));
+            return;
+        }
+        case 'type_alias_declaration': {
+            const name = target.childForFieldName('name')?.text;
+            if (!name)
+                return;
+            outSymbols.push(makeSymbol(target, outer, declSignature(target, content), fileInfo, 'type', name, `${fileInfo.path}:${name}`, exported));
+            return;
+        }
+        case 'enum_declaration': {
+            // Covers `enum`, `const enum` (const modifier inside the node), and —
+            // via the ambient_declaration recursion above — `declare enum`. Enum
+            // MEMBERS are not extracted (extraction scope: top-level and
+            // class-level declarations only).
+            const name = target.childForFieldName('name')?.text;
+            if (!name)
+                return;
+            outSymbols.push(makeSymbol(target, outer, declSignature(target, content), fileInfo, 'enum', name, `${fileInfo.path}:${name}`, exported));
+            return;
+        }
+        // Bare `namespace X {}` parses as expression_statement > internal_module
+        // (grammar quirk); `export namespace` and `declare namespace` surface
+        // internal_module directly via the declaration field / ambient recursion.
+        case 'expression_statement': {
+            const inner = target.firstNamedChild;
+            if (inner && (inner.type === 'internal_module' || inner.type === 'module')) {
+                extractTopLevel(inner, outer, content, fileInfo, exported, outSymbols, outImports, outBodies);
+            }
+            return;
+        }
+        case 'internal_module': // namespace X { … }
+        case 'module': { // module X { … } (legacy keyword)
+            const nameNode = target.childForFieldName('name');
+            // Simple identifiers only. A dotted `namespace A.B` (nested_identifier)
+            // would put a '.' in the FQN and trip classNameFromFqn's member
+            // parsing (isClassMember → true → dropped from file outlines), and a
+            // string name (`declare module "pkg"`) names a package, not a symbol.
+            // Declaration-only: namespace MEMBERS are not extracted this round —
+            // a member FQN `file:Ns.fn` would collide with class-member semantics.
+            if (nameNode?.type !== 'identifier')
+                return;
+            outSymbols.push(makeSymbol(target, outer, declSignature(target, content), fileInfo, 'module', nameNode.text, `${fileInfo.path}:${nameNode.text}`, exported));
+            return;
+        }
+        case 'lexical_declaration':
+        case 'variable_declaration': {
+            for (const declarator of target.namedChildren) {
+                if (declarator.type !== 'variable_declarator')
+                    continue;
+                const nameNode = declarator.childForFieldName('name');
+                // Skip destructuring patterns (array_pattern, object_pattern).
+                if (!nameNode || nameNode.type !== 'identifier')
+                    continue;
+                const name = nameNode.text;
+                const value = declarator.childForFieldName('value');
+                const isFunction = !!value && (value.type === 'arrow_function' || value.type === 'function_expression');
+                const kind = isFunction ? 'function' : 'variable';
+                const sym = makeSymbol(declarator, outer, variableSignature(declarator, value, content), fileInfo, kind, name, `${fileInfo.path}:${name}`, exported);
+                outSymbols.push(sym);
+                if (isFunction && value) {
+                    const body = value.childForFieldName('body');
+                    if (body)
+                        outBodies.push({ symbolId: sym.id, body });
+                }
+            }
+            return;
+        }
+        case 'import_statement': {
+            extractImport(target, fileInfo, outImports);
+            return;
+        }
+        default:
+            return;
+    }
+}
+function extractClassMember(member, content, fileInfo, className, exported, outSymbols, outBodies) {
+    switch (member.type) {
+        case 'method_definition':
+        case 'method_signature':
+        case 'abstract_method_signature': {
+            const methodName = member.childForFieldName('name')?.text;
+            if (!methodName)
+                return;
+            const methodSym = makeSymbol(member, member, declSignature(member, content), fileInfo, 'method', methodName, `${fileInfo.path}:${className}.${methodName}`, exported, className);
+            outSymbols.push(methodSym);
+            const methodBody = member.childForFieldName('body');
+            if (methodBody) {
+                outBodies.push({ symbolId: methodSym.id, body: methodBody, className });
+            }
+            return;
+        }
+        case 'public_field_definition': {
+            const propName = member.childForFieldName('name')?.text;
+            if (!propName)
+                return;
+            const value = member.childForFieldName('value');
+            const isCallable = !!value && (value.type === 'arrow_function' || value.type === 'function_expression');
+            const kind = isCallable ? 'method' : 'variable';
+            const fieldSym = makeSymbol(member, member, variableSignature(member, value, content), fileInfo, kind, propName, `${fileInfo.path}:${className}.${propName}`, exported, className);
+            outSymbols.push(fieldSym);
+            if (isCallable && value) {
+                const fnBody = value.childForFieldName('body');
+                if (fnBody) {
+                    outBodies.push({ symbolId: fieldSym.id, body: fnBody, className });
+                }
+            }
+            return;
+        }
+        default:
+            return;
+    }
+}
+function extractImport(stmt, fileInfo, out) {
+    const sourceNode = stmt.childForFieldName('source');
+    if (!sourceNode)
+        return;
+    const sourceModule = sourceNode.text.replace(/^['"`]|['"`]$/g, '');
+    const importedNames = [];
+    // `import type { ... }` — the `type` token is an unnamed child of
+    // import_statement, so it isn't surfaced via namedChildren.
+    const wholeIsTypeOnly = hasTypeKeyword(stmt);
+    for (const child of stmt.namedChildren) {
+        if (child.type !== 'import_clause')
+            continue;
+        for (const item of child.namedChildren) {
+            if (item.type === 'identifier') {
+                const named = { name: IMPORT_DEFAULT, alias: item.text };
+                if (wholeIsTypeOnly)
+                    named.kind = 'type';
+                importedNames.push(named);
+            }
+            else if (item.type === 'namespace_import') {
+                for (const nsChild of item.namedChildren) {
+                    if (nsChild.type !== 'identifier')
+                        continue;
+                    const named = { name: IMPORT_NAMESPACE, alias: nsChild.text };
+                    named.kind = wholeIsTypeOnly ? 'type' : 'namespace';
+                    importedNames.push(named);
+                }
+            }
+            else if (item.type === 'named_imports') {
+                for (const spec of item.namedChildren) {
+                    if (spec.type !== 'import_specifier')
+                        continue;
+                    const specName = spec.childForFieldName('name')?.text;
+                    if (!specName)
+                        continue;
+                    const specAlias = spec.childForFieldName('alias')?.text;
+                    const named = { name: specName };
+                    if (specAlias)
+                        named.alias = specAlias;
+                    // `import { type X, Y }` — per-specifier `type` keyword sits
+                    // as an unnamed child before the name identifier.
+                    if (wholeIsTypeOnly || hasTypeKeyword(spec))
+                        named.kind = 'type';
+                    importedNames.push(named);
+                }
+            }
+        }
+    }
+    out.push({
+        file: fileInfo.path,
+        sourceModule,
+        importedNames,
+        line: stmt.startPosition.row + 1,
+    });
+}
+function hasTypeKeyword(node) {
+    for (let i = 0; i < node.childCount; i++) {
+        if (node.child(i)?.type === 'type')
+            return true;
+    }
+    return false;
+}
+function makeSymbol(decl, docNode, signature, fileInfo, kind, name, fqn, exported, qualifier = '') {
+    return {
+        // The id hashes the FULL signature; only the stored copy is capped —
+        // otherwise overloads differing past the cap share an id (JG1).
+        id: symbolId(fileInfo.path, name, kind, signature, qualifier),
+        name,
+        fqn,
+        kind,
+        file: fileInfo.path,
+        startLine: decl.startPosition.row + 1,
+        endLine: decl.endPosition.row + 1,
+        signature: signature.slice(0, SIGNATURE_DISPLAY_CAP),
+        doc: extractDoc(docNode),
+        exported,
+        language: fileInfo.language,
+    };
+}
+function variableSignature(declarator, value, content) {
+    if (value && (value.type === 'arrow_function' || value.type === 'function_expression')) {
+        const body = value.childForFieldName('body');
+        const sigEnd = body ? body.startIndex : declarator.endIndex;
+        let sig = normalizeSignature(content.slice(declarator.startIndex, sigEnd));
+        if (value.type === 'arrow_function')
+            sig = sig.replace(/=>\s*$/, '').trimEnd();
+        return sig;
+    }
+    return normalizeSignature(content.slice(declarator.startIndex, declarator.endIndex));
+}
+function extractDoc(node) {
+    const prev = node.previousNamedSibling;
+    if (!prev || prev.type !== 'comment')
+        return null;
+    return commentDocLine(prev.text);
+}

package/dist/indexer/parser.js

@@ -0,0 +1,175 @@
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import { Parser, Language } from 'web-tree-sitter';
+import { log } from '../logger.js';
+const here = path.dirname(fileURLToPath(import.meta.url));
+// From dist/indexer/parser.js or src/indexer/parser.ts → up two levels to repo root.
+const grammarsDir = path.resolve(here, '..', '..', 'grammars');
+const LANG_TO_WASM = {
+    typescript: 'tree-sitter-typescript.wasm',
+    tsx: 'tree-sitter-tsx.wasm',
+    javascript: 'tree-sitter-javascript.wasm',
+    python: 'tree-sitter-python.wasm',
+    java: 'tree-sitter-java.wasm',
+    go: 'tree-sitter-go.wasm',
+    rust: 'tree-sitter-rust.wasm',
+    swift: 'tree-sitter-swift.wasm',
+    kotlin: 'tree-sitter-kotlin.wasm',
+    dart: 'tree-sitter-dart.wasm',
+    // @repomix ships this as tree-sitter-c_sharp.wasm (underscore), not -csharp.
+    csharp: 'tree-sitter-c_sharp.wasm',
+    php: 'tree-sitter-php.wasm',
+    ruby: 'tree-sitter-ruby.wasm',
+    cpp: 'tree-sitter-cpp.wasm',
+    // `.c` needs the dedicated C grammar (tree-sitter-cpp errors on K&R + C code
+    // using C++ keywords as identifiers); the extractor is shared with cpp.
+    c: 'tree-sitter-c.wasm',
+    objc: 'tree-sitter-objc.wasm',
+};
+const parsers = new Map();
+let initPromise = null;
+// Conditional-compilation directive lines (#if / #elseif / #else / #endif).
+// `m` matches ^/$ per line; without `s`, `.*` stays within one line.
+const SWIFT_DIRECTIVE_LINE = /^[ \t]*#(?:if|elseif|else|endif)\b.*$/gm;
+// tree-sitter-swift cannot parse a #if/#endif conditional-compilation block
+// INSIDE a type or function body — it emits ERROR nodes that drop the enclosing
+// type AND its first guarded member, hoisting the rest to the top level with
+// the wrong kind/FQN. We blank each directive LINE to equal-length whitespace
+// (newlines untouched) before parsing: byte offsets and line numbers are
+// preserved, so the extractor's signature slices and get_context body slices
+// still match the on-disk file, while every #if branch's declarations now parse
+// as ordinary consecutive members. A member defined in more than one branch is
+// extracted from each — over-extraction (the symbol-id occurrence counter keeps
+// ids unique), never the silent type loss the raw grammar produces. Fast-pathed
+// when the file contains no #if at all. Invoked by parseFile ONLY when the raw
+// parse errors and only adopted when the result parses clean (see call site).
+function neutralizeSwiftDirectives(content) {
+    if (!content.includes('#if'))
+        return content;
+    return content.replace(SWIFT_DIRECTIVE_LINE, (line) => ' '.repeat(line.length));
+}
+// tree-sitter-objc cannot parse a bare `NS_ASSUME_NONNULL_BEGIN` (no trailing
+// semicolon) before an `@interface` — it mis-parses the macro as a type and DROPS THE
+// WHOLE interface (degrading to a labeled/expression statement, 0 symbols). That macro
+// brackets virtually every modern ObjC header. We blank each `NS_ASSUME_NONNULL_BEGIN/
+// END` LINE to equal-length whitespace (newlines untouched) so byte offsets + line
+// numbers are preserved — the extractor's slices still match the on-disk file — while
+// the interface now parses. Exactly the Swift `#if` pattern: applied by parseFile ONLY
+// when the raw parse errors and the neutralized parse is clean (see call site).
+// Fast-pathed when the file contains no such macro. (Residual NS_ENUM/NS_OPTIONS/
+// FOUNDATION_EXPORT macro-opacity is a documented recall-only gap, not covered here.)
+// Only a STANDALONE macro line (optionally followed by whitespace or a `//` line
+// comment) is blanked — never a line that carries real code after the macro. This
+// keeps the equal-length-blanking safe (it removes only the stray macro token, never
+// shifts braces or drops a declaration sharing the line).
+const OBJC_NULLABILITY_LINE = /^[ \t]*NS_ASSUME_NONNULL_(?:BEGIN|END)\b[ \t]*(?:\/\/.*)?$/gm;
+function neutralizeObjcDirectives(content) {
+    if (!content.includes('NS_ASSUME_NONNULL_'))
+        return content;
+    return content.replace(OBJC_NULLABILITY_LINE, (line) => ' '.repeat(line.length));
+}
+// Counts ERROR + MISSING nodes in a tree. Used to decide whether the ObjC
+// nullability-neutralized parse is strictly better than the raw one: an ObjC header
+// commonly retains OTHER macro-opacity (NS_ENUM/FOUNDATION_EXPORT) after the
+// NS_ASSUME_NONNULL fix, so the bar is "fewer errors", not "zero" (unlike Swift's
+// brace-sensitive #if, where only a fully clean reparse is safe to adopt). Prunes
+// clean subtrees via `hasError` so the walk stays cheap.
+function countParseErrors(root) {
+    let count = 0;
+    const stack = [root];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node.type === 'ERROR' || node.isMissing)
+            count++;
+        for (const c of node.children) {
+            if (c.hasError || c.isMissing)
+                stack.push(c);
+        }
+    }
+    return count;
+}
+export function initParser() {
+    if (!initPromise) {
+        initPromise = (async () => {
+            await Parser.init();
+            const loaded = await Promise.all(Object.entries(LANG_TO_WASM).map(async ([lang, wasm]) => {
+                const language = await Language.load(path.join(grammarsDir, wasm));
+                const parser = new Parser();
+                parser.setLanguage(language);
+                return [lang, parser];
+            }));
+            for (const [lang, parser] of loaded) {
+                parsers.set(lang, parser);
+            }
+        })();
+        // A cached rejection would otherwise disable parsing (and pattern
+        // validation) for the process lifetime after one transient failure
+        // (EMFILE during the WASM reads) — reset so the next call retries.
+        initPromise.catch(() => {
+            initPromise = null;
+        });
+    }
+    return initPromise;
+}
+// The returned Tree holds WASM memory; callers must call `tree.delete()` when
+// finished — JS GC won't free it.
+export function parseFile(content, language) {
+    if (parsers.size === 0) {
+        throw new Error('parser not initialized; call initParser() first');
+    }
+    const parser = parsers.get(language);
+    if (!parser) {
+        log.warn(`parseFile: unsupported language "${language}"`);
+        return null;
+    }
+    let tree = parser.parse(content);
+    if (!tree) {
+        log.warn(`parseFile: parser returned null for language "${language}"`);
+        return null;
+    }
+    // Workaround for tree-sitter-swift's in-body #if mis-parse (see above), applied
+    // CONDITIONALLY: only swap in the directive-neutralized parse when the original
+    // ERRORS and neutralization yields a CLEAN parse. So a file that already parses
+    // — including one with a `#if`-looking line inside a multi-line string literal —
+    // is never rewritten, and a neutralization that unbalances braces (a guard
+    // straddling an opening brace) is discarded rather than producing wrong nesting.
+    // The neutralized tree's offsets stay aligned with the ORIGINAL content the
+    // caller passes to extractSymbols (equal-length blanking).
+    if (language === 'swift' && tree.rootNode.hasError && content.includes('#if')) {
+        const neutralized = neutralizeSwiftDirectives(content);
+        if (neutralized !== content) {
+            const alt = parser.parse(neutralized);
+            if (alt && !alt.rootNode.hasError) {
+                tree.delete();
+                tree = alt;
+            }
+            else {
+                alt?.delete();
+            }
+        }
+    }
+    // tree-sitter-objc's NS_ASSUME_NONNULL_BEGIN mis-parse (see above), applied the same
+    // CONDITIONALLY: adopt the neutralized parse only when the raw one ERRORS and
+    // neutralization does NOT increase the error count. A header may carry other
+    // unfixable macro-opacity (NS_ENUM etc.), so the bar is no-more-errors, not zero
+    // (unlike Swift). Crucially `<=`, not `<`: when the raw mis-parse buries a whole
+    // @interface inside ONE giant ERROR node and the neutralized parse hoists that
+    // interface cleanly but still errors on an intervening NS_ENUM, the error-NODE counts
+    // tie — yet the neutralized parse is strictly better. Blanking a balanced STANDALONE
+    // macro line only removes a stray token (never adds one or shifts braces), so the
+    // neutralized parse is never structurally worse; adopting an equal-count tie is safe.
+    if (language === 'objc' && tree.rootNode.hasError && content.includes('NS_ASSUME_NONNULL_')) {
+        const neutralized = neutralizeObjcDirectives(content);
+        if (neutralized !== content) {
+            const alt = parser.parse(neutralized);
+            if (alt && countParseErrors(alt.rootNode) <= countParseErrors(tree.rootNode)) {
+                tree.delete();
+                tree = alt;
+            }
+            else {
+                alt?.delete();
+            }
+        }
+    }
+    return tree;
+}