optave-codegraph 3.13.0

package/dist/domain/graph/builder/helpers.d.ts

@@ -0,0 +1,97 @@
+import type { BetterSqlite3Database, CodegraphConfig, PathAliases } from '../../../types.js';
+export declare const BUILTIN_RECEIVERS: Set<string>;
+/** Phase 8.6: confidence penalty applied to CHA-dispatch edges. */
+export declare const CHA_DISPATCH_PENALTY = 0.1;
+/** Phase 8.6: fixed confidence for typed-receiver (interface/CHA) dispatch edges.
+ *  File proximity is not meaningful for virtual dispatch — all three engine paths
+ *  (WASM inline, WASM post-pass, native post-pass) must agree on this value. */
+export declare const CHA_TYPED_DISPATCH_CONFIDENCE = 0.8;
+/**
+ * Check whether a source file passes the configured include/exclude globs.
+ *
+ * Patterns are matched against the path relative to the project root,
+ * normalized to forward slashes (e.g. `src/foo/bar.ts`). When both lists
+ * are set, a file must match at least one include and no exclude.
+ */
+export declare function passesIncludeExclude(relPath: string, includeRegexes: readonly RegExp[], excludeRegexes: readonly RegExp[]): boolean;
+/**
+ * Parse the `.gitignore` file at the project root and return compiled regexes
+ * for each non-negated, non-comment pattern.
+ *
+ * Only the root-level `.gitignore` is read — nested `.gitignore` files and
+ * global gitignore are not consulted. This gives the WASM file-collection
+ * walker the same coarse gitignore respect that the Rust engine gets from the
+ * `ignore` crate's `git_ignore(true)` option, without requiring an additional
+ * npm dependency.
+ *
+ * Negation patterns (`!pattern`) are intentionally skipped — honoring them
+ * correctly requires ordered evaluation which is outside scope here. The Rust
+ * engine's `ignore` crate handles negation natively.
+ */
+export declare function readGitignorePatterns(rootDir: string): readonly RegExp[];
+/**
+ * Recursively collect all source files under `dir`.
+ * When `directories` is a Set, also tracks which directories contain files.
+ *
+ * `dir` establishes the project root against which `config.include` /
+ * `config.exclude` globs are matched.
+ */
+export declare function collectFiles(dir: string, files: string[], config: Partial<CodegraphConfig>, directories: Set<string>): {
+    files: string[];
+    directories: Set<string>;
+};
+export declare function collectFiles(dir: string, files?: string[], config?: Partial<CodegraphConfig>, directories?: null): string[];
+/**
+ * Load path aliases from tsconfig.json / jsconfig.json.
+ */
+export declare function loadPathAliases(rootDir: string): PathAliases;
+/**
+ * Compute MD5 hash of file contents for incremental builds.
+ */
+export declare function fileHash(content: string): string;
+/**
+ * Stat a file, returning { mtime, size } or null on error.
+ *
+ * `mtime` is `Math.floor(stat.mtimeMs)` so it matches the integer column
+ * stored in the DB. Floor-once-here keeps every consumer honest: storing or
+ * comparing a non-floored `mtimeMs` against the integer DB column would cause
+ * spurious fast-skip misses on the next build.
+ */
+export declare function fileStat(filePath: string): {
+    mtime: number;
+    size: number;
+} | null;
+export declare function readFileSafe(filePath: string, retries?: number): string;
+/**
+ * Purge all graph data for the specified files.
+ */
+export declare function purgeFilesFromGraph(db: BetterSqlite3Database, files: string[], options?: Record<string, unknown>): void;
+/**
+ * Batch-insert node rows via multi-value INSERT statements.
+ * Each row: [name, kind, file, line, end_line, parent_id, qualified_name, scope, visibility]
+ */
+export declare function batchInsertNodes(db: BetterSqlite3Database, rows: unknown[][]): void;
+/**
+ * Batch-insert edge rows via multi-value INSERT statements.
+ * Each row: [source_id, target_id, kind, confidence, dynamic, technique, dynamic_kind]
+ */
+export declare function batchInsertEdges(db: BetterSqlite3Database, rows: unknown[][]): void;
+/** Confidence assigned to CHA-expanded interface/abstract dispatch edges. */
+export declare const CHA_DISPATCH_CONFIDENCE = 0.8;
+/**
+ * CHA (Class Hierarchy Analysis) post-pass.
+ *
+ * Expands virtual-dispatch call edges for class hierarchies and interface
+ * implementations already present in the DB:
+ *
+ *  1. Build implementors map: parent/interface → [child/implementing class] from
+ *     `extends` and `implements` edges.
+ *  2. Collect RTA evidence: class nodes that appear as `calls` targets (new X()).
+ *  3. Find all `calls` edges to qualified method nodes (name contains '.').
+ *  4. For each such call, expand to concrete overrides via the implementors map,
+ *     filtered by RTA when evidence exists.
+ *
+ * Used by both the native orchestrator post-pass and the WASM build-edges pass.
+ */
+export declare function runChaPostPass(db: BetterSqlite3Database): number;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/domain/graph/builder/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../../src/domain/graph/builder/helpers.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EACV,qBAAqB,EACrB,eAAe,EACf,WAAW,EAEZ,MAAM,mBAAmB,CAAC;AAE3B,eAAO,MAAM,iBAAiB,EAAE,GAAG,CAAC,MAAM,CA6BxC,CAAC;AAEH,mEAAmE;AACnE,eAAO,MAAM,oBAAoB,MAAM,CAAC;AACxC;;gFAEgF;AAChF,eAAO,MAAM,6BAA6B,MAAM,CAAC;AAajD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EACf,cAAc,EAAE,SAAS,MAAM,EAAE,EACjC,cAAc,EAAE,SAAS,MAAM,EAAE,GAChC,OAAO,CAIT;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAkCxE;AA6ED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,EAAE,EACf,MAAM,EAAE,OAAO,CAAC,eAAe,CAAC,EAChC,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,GACvB;IAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CAAE,CAAC;AACjD,wBAAgB,YAAY,CAC1B,GAAG,EAAE,MAAM,EACX,KAAK,CAAC,EAAE,MAAM,EAAE,EAChB,MAAM,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,EACjC,WAAW,CAAC,EAAE,IAAI,GACjB,MAAM,EAAE,CAAC;AA0BZ;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,CA4B5D;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAOjF;AAQD,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,GAAE,MAAU,GAAG,MAAM,CAa1E;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,EAAE,EAAE,qBAAqB,EACzB,KAAK,EAAE,MAAM,EAAE,EACf,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GACpC,IAAI,CAGN;AA6CD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,qBAAqB,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,GAAG,IAAI,CAanF;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,qBAAqB,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,GAAG,IAAI,CAanF;AAED,6EAA6E;AAC7E,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAwJ3C;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,qBAAqB,GAAG,MAAM,CAuEhE"}

package/dist/domain/graph/builder/helpers.js

@@ -0,0 +1,558 @@
+/**
+ * Builder helper functions — shared utilities used across pipeline stages.
+ *
+ * Extracted from the monolithic builder.js so stages can import individually.
+ */
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { purgeFilesData } from '../../../db/index.js';
+import { debug, warn } from '../../../infrastructure/logger.js';
+import { EXTENSIONS, IGNORE_DIRS, normalizePath } from '../../../shared/constants.js';
+import { compileGlobs, globToRegex, matchesAny } from '../../../shared/globs.js';
+export const BUILTIN_RECEIVERS = new Set([
+    'console',
+    'Math',
+    'JSON',
+    'Object',
+    'Array',
+    'String',
+    'Number',
+    'Boolean',
+    'Date',
+    'RegExp',
+    'Map',
+    'Set',
+    'WeakMap',
+    'WeakSet',
+    'Promise',
+    'Symbol',
+    'Error',
+    'TypeError',
+    'RangeError',
+    'Proxy',
+    'Reflect',
+    'Intl',
+    'globalThis',
+    'window',
+    'document',
+    'process',
+    'Buffer',
+    'require',
+]);
+/** Phase 8.6: confidence penalty applied to CHA-dispatch edges. */
+export const CHA_DISPATCH_PENALTY = 0.1;
+/** Phase 8.6: fixed confidence for typed-receiver (interface/CHA) dispatch edges.
+ *  File proximity is not meaningful for virtual dispatch — all three engine paths
+ *  (WASM inline, WASM post-pass, native post-pass) must agree on this value. */
+export const CHA_TYPED_DISPATCH_CONFIDENCE = 0.8;
+/** Check if a directory entry should be skipped (ignored dirs, dotfiles). */
+function shouldSkipEntry(entry, extraIgnore) {
+    if (entry.name.startsWith('.') && entry.name !== '.') {
+        if (IGNORE_DIRS.has(entry.name))
+            return true;
+        if (entry.isDirectory())
+            return true;
+    }
+    if (IGNORE_DIRS.has(entry.name))
+        return true;
+    if (extraIgnore?.has(entry.name))
+        return true;
+    return false;
+}
+/**
+ * Check whether a source file passes the configured include/exclude globs.
+ *
+ * Patterns are matched against the path relative to the project root,
+ * normalized to forward slashes (e.g. `src/foo/bar.ts`). When both lists
+ * are set, a file must match at least one include and no exclude.
+ */
+export function passesIncludeExclude(relPath, includeRegexes, excludeRegexes) {
+    if (includeRegexes.length > 0 && !matchesAny(includeRegexes, relPath))
+        return false;
+    if (excludeRegexes.length > 0 && matchesAny(excludeRegexes, relPath))
+        return false;
+    return true;
+}
+/**
+ * Parse the `.gitignore` file at the project root and return compiled regexes
+ * for each non-negated, non-comment pattern.
+ *
+ * Only the root-level `.gitignore` is read — nested `.gitignore` files and
+ * global gitignore are not consulted. This gives the WASM file-collection
+ * walker the same coarse gitignore respect that the Rust engine gets from the
+ * `ignore` crate's `git_ignore(true)` option, without requiring an additional
+ * npm dependency.
+ *
+ * Negation patterns (`!pattern`) are intentionally skipped — honoring them
+ * correctly requires ordered evaluation which is outside scope here. The Rust
+ * engine's `ignore` crate handles negation natively.
+ */
+export function readGitignorePatterns(rootDir) {
+    const gitignorePath = path.join(rootDir, '.gitignore');
+    let contents;
+    try {
+        contents = fs.readFileSync(gitignorePath, 'utf-8');
+    }
+    catch {
+        return [];
+    }
+    const regexes = [];
+    for (const rawLine of contents.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        // Skip empty lines, comments, and negation patterns
+        if (!line || line.startsWith('#') || line.startsWith('!'))
+            continue;
+        // Strip trailing slash (directory indicator) — we match files by path regardless
+        const pattern = line.endsWith('/') ? line.slice(0, -1) : line;
+        try {
+            // If pattern contains no '/', it should match at any depth — prefix with `**/`.
+            // If pattern starts with '/', it is anchored to root — strip the leading slash.
+            // Otherwise use as-is (e.g. `crates/codegraph-core/index.js`).
+            let normalized;
+            if (pattern.startsWith('/')) {
+                normalized = pattern.slice(1);
+            }
+            else if (!pattern.includes('/')) {
+                normalized = `**/${pattern}`;
+            }
+            else {
+                normalized = pattern;
+            }
+            regexes.push(globToRegex(normalized));
+        }
+        catch {
+            // Ignore patterns that don't compile (e.g. those with unsupported syntax)
+        }
+    }
+    return Object.freeze(regexes);
+}
+/** Detect a symlink loop for `dir`. Returns true if `dir` was already visited. */
+function isSymlinkLoop(dir, visited) {
+    let realDir;
+    try {
+        realDir = fs.realpathSync(dir);
+    }
+    catch {
+        return true;
+    }
+    if (visited.has(realDir)) {
+        warn(`Symlink loop detected, skipping: ${dir}`);
+        return true;
+    }
+    visited.add(realDir);
+    return false;
+}
+/** Read directory entries, returning null on error (already logged). */
+function readDirSafe(dir) {
+    try {
+        return fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch (err) {
+        warn(`Cannot read directory ${dir}: ${err.message}`);
+        return null;
+    }
+}
+/** True if `entry` is a source file we should collect under `ctx`. */
+function isCollectableSourceFile(full, entry, ctx) {
+    if (!EXTENSIONS.has(path.extname(entry.name)))
+        return false;
+    const rel = normalizePath(path.relative(ctx.rootDir, full));
+    // Respect .gitignore patterns before applying include/exclude globs
+    if (ctx.gitignoreRegexes.length > 0 && matchesAny(ctx.gitignoreRegexes, rel))
+        return false;
+    if (!ctx.hasGlobFilters)
+        return true;
+    return passesIncludeExclude(rel, ctx.includeRegexes, ctx.excludeRegexes);
+}
+function walkCollect(dir, files, directories, ctx) {
+    if (isSymlinkLoop(dir, ctx.visited))
+        return;
+    const entries = readDirSafe(dir);
+    if (!entries)
+        return;
+    let hasFiles = false;
+    for (const entry of entries) {
+        if (shouldSkipEntry(entry, ctx.extraIgnore))
+            continue;
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            walkCollect(full, files, directories, ctx);
+        }
+        else if (isCollectableSourceFile(full, entry, ctx)) {
+            files.push(full);
+            hasFiles = true;
+        }
+    }
+    if (directories && hasFiles) {
+        directories.add(dir);
+    }
+}
+export function collectFiles(dir, files = [], config = {}, directories = null) {
+    const trackDirs = directories instanceof Set;
+    const includeRegexes = compileGlobs(config.include);
+    const excludeRegexes = compileGlobs(config.exclude);
+    const gitignoreRegexes = readGitignorePatterns(dir);
+    const ctx = {
+        rootDir: dir,
+        includeRegexes,
+        excludeRegexes,
+        gitignoreRegexes,
+        hasGlobFilters: includeRegexes.length > 0 || excludeRegexes.length > 0,
+        extraIgnore: config.ignoreDirs ? new Set(config.ignoreDirs) : null,
+        visited: new Set(),
+    };
+    walkCollect(dir, files, trackDirs ? directories : null, ctx);
+    return trackDirs ? { files, directories: directories } : files;
+}
+/**
+ * Load path aliases from tsconfig.json / jsconfig.json.
+ */
+export function loadPathAliases(rootDir) {
+    const aliases = { baseUrl: null, paths: {} };
+    for (const configName of ['tsconfig.json', 'jsconfig.json']) {
+        const configPath = path.join(rootDir, configName);
+        if (!fs.existsSync(configPath))
+            continue;
+        try {
+            const raw = fs
+                .readFileSync(configPath, 'utf-8')
+                .replace(/("(?:[^"\\]|\\.)*")|\/\*[\s\S]*?\*\/|\/\/.*$/gm, (_, str) => str ?? '')
+                .replace(/,\s*([\]}])/g, '$1');
+            const config = JSON.parse(raw);
+            const opts = config.compilerOptions || {};
+            if (opts.baseUrl)
+                aliases.baseUrl = path.resolve(rootDir, opts.baseUrl);
+            if (opts.paths) {
+                for (const [pattern, targets] of Object.entries(opts.paths)) {
+                    aliases.paths[pattern] = targets.map((t) => path.resolve(aliases.baseUrl || rootDir, t));
+                }
+            }
+            break;
+        }
+        catch (err) {
+            warn(`Failed to parse ${configName}: ${err.message}`);
+        }
+    }
+    return aliases;
+}
+/**
+ * Compute MD5 hash of file contents for incremental builds.
+ */
+export function fileHash(content) {
+    return createHash('md5').update(content).digest('hex');
+}
+/**
+ * Stat a file, returning { mtime, size } or null on error.
+ *
+ * `mtime` is `Math.floor(stat.mtimeMs)` so it matches the integer column
+ * stored in the DB. Floor-once-here keeps every consumer honest: storing or
+ * comparing a non-floored `mtimeMs` against the integer DB column would cause
+ * spurious fast-skip misses on the next build.
+ */
+export function fileStat(filePath) {
+    try {
+        const s = fs.statSync(filePath);
+        return { mtime: Math.floor(s.mtimeMs), size: s.size };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Read a file with retry on transient errors (EBUSY/EACCES/EPERM).
+ */
+const TRANSIENT_CODES = new Set(['EBUSY', 'EACCES', 'EPERM']);
+const RETRY_DELAY_MS = 50;
+export function readFileSafe(filePath, retries = 2) {
+    for (let attempt = 0;; attempt++) {
+        try {
+            return fs.readFileSync(filePath, 'utf-8');
+        }
+        catch (err) {
+            if (attempt < retries && TRANSIENT_CODES.has(err.code ?? '')) {
+                const sharedBuf = new SharedArrayBuffer(4);
+                Atomics.wait(new Int32Array(sharedBuf), 0, 0, RETRY_DELAY_MS);
+                continue;
+            }
+            throw err;
+        }
+    }
+}
+/**
+ * Purge all graph data for the specified files.
+ */
+export function purgeFilesFromGraph(db, files, options = {}) {
+    // Double-cast needed: better-sqlite3 types don't declare `open`/`name` properties
+    purgeFilesData(db, files, options);
+}
+/** Batch INSERT chunk size for multi-value INSERTs. */
+const BATCH_CHUNK = 500;
+// Statement caches keyed by chunk size — avoids recompiling for every batch.
+const nodeStmtCache = new WeakMap();
+const edgeStmtCache = new WeakMap();
+function getNodeStmt(db, chunkSize) {
+    let cache = nodeStmtCache.get(db);
+    if (!cache) {
+        cache = new Map();
+        nodeStmtCache.set(db, cache);
+    }
+    let stmt = cache.get(chunkSize);
+    if (!stmt) {
+        const ph = '(?,?,?,?,?,?,?,?,?)';
+        stmt = db.prepare('INSERT OR IGNORE INTO nodes (name,kind,file,line,end_line,parent_id,qualified_name,scope,visibility) VALUES ' +
+            Array.from({ length: chunkSize }, () => ph).join(','));
+        cache.set(chunkSize, stmt);
+    }
+    return stmt;
+}
+function getEdgeStmt(db, chunkSize) {
+    let cache = edgeStmtCache.get(db);
+    if (!cache) {
+        cache = new Map();
+        edgeStmtCache.set(db, cache);
+    }
+    let stmt = cache.get(chunkSize);
+    if (!stmt) {
+        const ph = '(?,?,?,?,?,?,?)';
+        stmt = db.prepare('INSERT INTO edges (source_id,target_id,kind,confidence,dynamic,technique,dynamic_kind) VALUES ' +
+            Array.from({ length: chunkSize }, () => ph).join(','));
+        cache.set(chunkSize, stmt);
+    }
+    return stmt;
+}
+/**
+ * Batch-insert node rows via multi-value INSERT statements.
+ * Each row: [name, kind, file, line, end_line, parent_id, qualified_name, scope, visibility]
+ */
+export function batchInsertNodes(db, rows) {
+    if (!rows.length)
+        return;
+    for (let i = 0; i < rows.length; i += BATCH_CHUNK) {
+        const end = Math.min(i + BATCH_CHUNK, rows.length);
+        const chunkSize = end - i;
+        const stmt = getNodeStmt(db, chunkSize);
+        const vals = [];
+        for (let j = i; j < end; j++) {
+            const r = rows[j];
+            vals.push(r[0], r[1], r[2], r[3], r[4], r[5], r[6], r[7], r[8]);
+        }
+        stmt.run(...vals);
+    }
+}
+/**
+ * Batch-insert edge rows via multi-value INSERT statements.
+ * Each row: [source_id, target_id, kind, confidence, dynamic, technique, dynamic_kind]
+ */
+export function batchInsertEdges(db, rows) {
+    if (!rows.length)
+        return;
+    for (let i = 0; i < rows.length; i += BATCH_CHUNK) {
+        const end = Math.min(i + BATCH_CHUNK, rows.length);
+        const chunkSize = end - i;
+        const stmt = getEdgeStmt(db, chunkSize);
+        const vals = [];
+        for (let j = i; j < end; j++) {
+            const r = rows[j];
+            vals.push(r[0], r[1], r[2], r[3], r[4], r[5] ?? null, r[6] ?? null);
+        }
+        stmt.run(...vals);
+    }
+}
+/** Confidence assigned to CHA-expanded interface/abstract dispatch edges. */
+export const CHA_DISPATCH_CONFIDENCE = 0.8;
+/**
+ * Build the parent→children implementor map from `extends`/`implements` edges.
+ * Returns null if no hierarchy edges exist.
+ */
+function buildImplementorMap(db) {
+    const hasHierarchy = db
+        .prepare(`SELECT 1 FROM edges WHERE kind IN ('extends', 'implements') LIMIT 1`)
+        .get();
+    if (!hasHierarchy)
+        return null;
+    const hierarchyRows = db
+        .prepare(`SELECT src.name AS child_name, tgt.name AS parent_name
+       FROM edges e
+       JOIN nodes src ON e.source_id = src.id
+       JOIN nodes tgt ON e.target_id = tgt.id
+       WHERE e.kind IN ('extends', 'implements')`)
+        .all();
+    const implementorSets = new Map();
+    for (const row of hierarchyRows) {
+        let set = implementorSets.get(row.parent_name);
+        if (!set) {
+            set = new Set();
+            implementorSets.set(row.parent_name, set);
+        }
+        set.add(row.child_name);
+    }
+    if (implementorSets.size === 0)
+        return null;
+    // Convert to arrays for iteration compatibility
+    const implementors = new Map([...implementorSets.entries()].map(([k, v]) => [k, [...v]]));
+    return { implementors, implementorSets };
+}
+/**
+ * Collect RTA (Rapid Type Analysis) evidence: class names instantiated via
+ * constructor calls (`new X()`). Falls back to constructor/function-kind nodes
+ * for languages that record constructor calls differently (e.g. TS via WASM).
+ */
+function collectRtaInstantiated(db, implementorSets) {
+    let rtaRows = db
+        .prepare(`SELECT DISTINCT tgt.name
+       FROM edges e
+       JOIN nodes tgt ON e.target_id = tgt.id
+       WHERE e.kind = 'calls' AND tgt.kind = 'class'`)
+        .all();
+    if (rtaRows.length === 0) {
+        // Fallback: some languages (e.g. TypeScript via WASM) record constructor calls as
+        // 'function' or 'constructor' kind rather than 'class'. Restrict to names that are
+        // actually known class names to avoid treating unrelated function calls like `logger()`
+        // as class-instantiation evidence.
+        // Include both parent/interface names AND implementor (child) names so that
+        // `new UserRepository()` (a child class) is correctly detected as RTA evidence.
+        const knownClassNames = [
+            ...new Set([
+                ...implementorSets.keys(),
+                ...[...implementorSets.values()].flatMap((s) => [...s]),
+            ]),
+        ];
+        if (knownClassNames.length > 0) {
+            // Chunk to stay within SQLite SQLITE_MAX_VARIABLE_NUMBER (999 in many builds).
+            const CHUNK = 999;
+            for (let i = 0; i < knownClassNames.length; i += CHUNK) {
+                const chunk = knownClassNames.slice(i, i + CHUNK);
+                const placeholders = chunk.map(() => '?').join(',');
+                const chunkRows = db
+                    .prepare(`SELECT DISTINCT tgt.name
+             FROM edges e
+             JOIN nodes tgt ON e.target_id = tgt.id
+             WHERE e.kind = 'calls' AND tgt.kind IN ('constructor', 'function')
+             AND tgt.name IN (${placeholders})`)
+                    .all(...chunk);
+                rtaRows = rtaRows.concat(chunkRows);
+            }
+        }
+    }
+    return new Set(rtaRows.map((r) => r.name));
+}
+/**
+ * BFS-expand a single call-to-qualified-method into CHA dispatch edges.
+ *
+ * For `source_id` calling `typeName.methodSuffix`, walks the implementors
+ * map (BFS) and emits an edge for each concrete override that passes the
+ * RTA filter.  New edges are appended to `newEdges`; `seen` is updated in
+ * place to prevent duplicate insertions within the same pass.
+ */
+function expandChaCall(sourceId, typeName, methodSuffix, implementors, instantiated, noRtaEvidence, findMethodStmt, seen, newEdges) {
+    // BFS over the implementors map — handles multi-level hierarchies where
+    // abstract/non-instantiated classes sit between the call-site type and
+    // the concrete leaf implementations (matches runPostNativeCha, issue #1311).
+    const bfsQueue = [typeName];
+    const bfsVisited = new Set([typeName]);
+    while (bfsQueue.length > 0) {
+        const current = bfsQueue.shift();
+        const children = implementors.get(current);
+        if (!children?.length)
+            continue;
+        for (const cls of children) {
+            if (bfsVisited.has(cls))
+                continue;
+            bfsVisited.add(cls);
+            if (noRtaEvidence || instantiated.has(cls)) {
+                const qualifiedName = `${cls}.${methodSuffix}`;
+                const methodNodes = findMethodStmt.all(qualifiedName);
+                for (const methodNode of methodNodes) {
+                    if (methodNode.id === sourceId)
+                        continue; // skip self-loops
+                    const key = `${sourceId}|${methodNode.id}`;
+                    if (seen.has(key))
+                        continue;
+                    seen.add(key);
+                    newEdges.push([
+                        sourceId,
+                        methodNode.id,
+                        'calls',
+                        CHA_TYPED_DISPATCH_CONFIDENCE,
+                        0,
+                        'cha-expanded',
+                    ]);
+                }
+            }
+            // Always traverse children — non-instantiated classes may have instantiated subclasses.
+            bfsQueue.push(cls);
+        }
+    }
+}
+/**
+ * CHA (Class Hierarchy Analysis) post-pass.
+ *
+ * Expands virtual-dispatch call edges for class hierarchies and interface
+ * implementations already present in the DB:
+ *
+ *  1. Build implementors map: parent/interface → [child/implementing class] from
+ *     `extends` and `implements` edges.
+ *  2. Collect RTA evidence: class nodes that appear as `calls` targets (new X()).
+ *  3. Find all `calls` edges to qualified method nodes (name contains '.').
+ *  4. For each such call, expand to concrete overrides via the implementors map,
+ *     filtered by RTA when evidence exists.
+ *
+ * Used by both the native orchestrator post-pass and the WASM build-edges pass.
+ */
+export function runChaPostPass(db) {
+    const hierarchy = buildImplementorMap(db);
+    if (!hierarchy)
+        return 0;
+    const { implementors, implementorSets } = hierarchy;
+    const instantiated = collectRtaInstantiated(db, implementorSets);
+    const noRtaEvidence = instantiated.size === 0;
+    if (noRtaEvidence) {
+        debug('runChaPostPass: no constructor-call evidence — proceeding without RTA filter');
+    }
+    const callToMethods = db
+        .prepare(`SELECT e.source_id, src.name AS caller_name, tgt.name AS method_name
+       FROM edges e
+       JOIN nodes tgt ON e.target_id = tgt.id
+       JOIN nodes src ON e.source_id = src.id
+       WHERE e.kind = 'calls' AND tgt.kind = 'method'
+       AND INSTR(tgt.name, '.') > 0
+       AND (e.technique IS NULL OR e.technique != 'cha-expanded')`)
+        .all();
+    // Scope deduplication to only the source_ids we are about to expand, avoiding
+    // a full-table scan. CHA only inserts edges FROM callers that already call a
+    // qualified method (the source_ids in callToMethods), so we only need to
+    // check existing edges for those specific callers.
+    const seen = new Set();
+    const callerIds = [...new Set(callToMethods.map((r) => r.source_id))];
+    if (callerIds.length > 0) {
+        // Chunk to stay within SQLite SQLITE_MAX_VARIABLE_NUMBER (999 in many builds).
+        const CHUNK = 999;
+        for (let i = 0; i < callerIds.length; i += CHUNK) {
+            const chunk = callerIds.slice(i, i + CHUNK);
+            const placeholders = chunk.map(() => '?').join(',');
+            const existingPairs = db
+                .prepare(`SELECT source_id, target_id FROM edges WHERE kind = 'calls' AND source_id IN (${placeholders})`)
+                .all(...chunk);
+            for (const e of existingPairs)
+                seen.add(`${e.source_id}|${e.target_id}`);
+        }
+    }
+    // No LIMIT: multiple files can define the same qualified name in a monorepo.
+    const findMethodStmt = db.prepare(`SELECT id FROM nodes WHERE name = ? AND kind = 'method'`);
+    const newEdges = [];
+    for (const { source_id, method_name } of callToMethods) {
+        const dotIdx = method_name.indexOf('.');
+        if (dotIdx === -1)
+            continue;
+        const typeName = method_name.slice(0, dotIdx);
+        const methodSuffix = method_name.slice(dotIdx + 1);
+        expandChaCall(source_id, typeName, methodSuffix, implementors, instantiated, noRtaEvidence, findMethodStmt, seen, newEdges);
+    }
+    if (newEdges.length > 0) {
+        db.transaction(() => batchInsertEdges(db, newEdges))();
+        debug(`runChaPostPass: inserted ${newEdges.length} CHA dispatch edge(s)`);
+    }
+    return newEdges.length;
+}
+//# sourceMappingURL=helpers.js.map