@optave/codegraph 3.3.1 → 3.4.1

package/src/domain/analysis/{roles.js → roles.ts}

@@ -4,14 +4,24 @@ import { isTestFile } from '../../infrastructure/test-filter.js';
 import { DEAD_ROLE_PREFIX } from '../../shared/kinds.js';
 import { normalizeSymbol } from '../../shared/normalize.js';
 import { paginateResult } from '../../shared/paginate.js';
+import type { NodeRow } from '../../types.js';
 
-export function rolesData(customDbPath, opts = {}) {
+export function rolesData(
+  customDbPath: string,
+  opts: {
+    noTests?: boolean;
+    role?: string | null;
+    file?: string;
+    limit?: number;
+    offset?: number;
+  } = {},
+) {
   const db = openReadonlyOrFail(customDbPath);
   try {
     const noTests = opts.noTests || false;
     const filterRole = opts.role || null;
     const conditions = ['role IS NOT NULL'];
-    const params = [];
+    const params: (string | number)[] = [];
 
     if (filterRole) {
       if (filterRole === DEAD_ROLE_PREFIX) {
@@ -23,7 +33,7 @@ export function rolesData(customDbPath, opts = {}) {
       }
     }
     {
-      const fc = buildFileConditionSQL(opts.file, 'file');
+      const fc = buildFileConditionSQL(opts.file || '', 'file');
       if (fc.sql) {
         // Strip leading ' AND ' since we're using conditions array
         conditions.push(fc.sql.replace(/^ AND /, ''));
@@ -31,17 +41,25 @@ export function rolesData(customDbPath, opts = {}) {
       }
     }
 
+    // NOTE: cachedStmt cannot be applied here because the SQL varies per call —
+    // the WHERE clause is built dynamically from `conditions` (role filter, file
+    // filter). A future optimisation could use a fixed SQL with CASE/COALESCE to
+    // absorb optional filters, or maintain a small Map<string, StmtCache> keyed
+    // by the unique condition combination (there are only ~4 variants). For now
+    // the dynamic prepare is acceptable given the low call frequency of `roles`.
     let rows = db
       .prepare(
         `SELECT name, kind, file, line, end_line, role FROM nodes WHERE ${conditions.join(' AND ')} ORDER BY role, file, line`,
       )
-      .all(...params);
+      .all(...params) as NodeRow[];
 
     if (noTests) rows = rows.filter((r) => !isTestFile(r.file));
 
-    const summary = {};
+    const summary: Record<string, number> = {};
     for (const r of rows) {
-      summary[r.role] = (summary[r.role] || 0) + 1;
+      // SQL guarantees role IS NOT NULL
+      const role = r.role as string;
+      summary[role] = (summary[role] || 0) + 1;
     }
 
     const hc = new Map();

package/src/domain/analysis/{symbol-lookup.js → symbol-lookup.ts}

@@ -19,31 +19,54 @@ import { isTestFile } from '../../infrastructure/test-filter.js';
 import { EVERY_SYMBOL_KIND } from '../../shared/kinds.js';
 import { getFileHash, normalizeSymbol } from '../../shared/normalize.js';
 import { paginateResult } from '../../shared/paginate.js';
-
-const FUNCTION_KINDS = ['function', 'method', 'class', 'constant'];
+import type {
+  AdjacentEdgeRow,
+  BetterSqlite3Database,
+  ChildNodeRow,
+  ImportEdgeRow,
+  NodeRow,
+  NodeRowWithFanIn,
+  SymbolKind,
+} from '../../types.js';
+
+const FUNCTION_KINDS: SymbolKind[] = ['function', 'method', 'class', 'constant'];
 
 /**
  * Find nodes matching a name query, ranked by relevance.
  * Scoring: exact=100, prefix=60, word-boundary=40, substring=10, plus fan-in tiebreaker.
- *
- * @param {object} dbOrRepo - A better-sqlite3 Database or a Repository instance
  */
-export function findMatchingNodes(dbOrRepo, name, opts = {}) {
-  const kinds = opts.kind ? [opts.kind] : opts.kinds?.length ? opts.kinds : FUNCTION_KINDS;
+export function findMatchingNodes(
+  dbOrRepo: BetterSqlite3Database | InstanceType<typeof Repository>,
+  name: string,
+  opts: { noTests?: boolean; file?: string; kind?: string; kinds?: readonly string[] } = {},
+): Array<NodeRowWithFanIn & { _relevance: number }> {
+  const kinds = (
+    opts.kind ? [opts.kind] : opts.kinds?.length ? [...opts.kinds] : FUNCTION_KINDS
+  ) as SymbolKind[];
 
   const isRepo = dbOrRepo instanceof Repository;
-  const rows = isRepo
-    ? dbOrRepo.findNodesWithFanIn(`%${name}%`, { kinds, file: opts.file })
-    : findNodesWithFanIn(dbOrRepo, `%${name}%`, { kinds, file: opts.file });
-
-  const nodes = opts.noTests ? rows.filter((n) => !isTestFile(n.file)) : rows;
+  const rows = (
+    isRepo
+      ? (dbOrRepo as InstanceType<typeof Repository>).findNodesWithFanIn(`%${name}%`, {
+          kinds,
+          file: opts.file,
+        })
+      : findNodesWithFanIn(dbOrRepo as BetterSqlite3Database, `%${name}%`, {
+          kinds,
+          file: opts.file,
+        })
+  ) as NodeRowWithFanIn[];
+
+  const nodes: Array<NodeRowWithFanIn & { _relevance: number }> = (
+    opts.noTests ? rows.filter((n) => !isTestFile(n.file)) : rows
+  ) as Array<NodeRowWithFanIn & { _relevance: number }>;
 
   const lowerQuery = name.toLowerCase();
   for (const node of nodes) {
     const lowerName = node.name.toLowerCase();
-    const bareName = lowerName.includes('.') ? lowerName.split('.').pop() : lowerName;
+    const bareName = lowerName.includes('.') ? lowerName.split('.').pop()! : lowerName;
 
-    let matchScore;
+    let matchScore: number;
     if (lowerName === lowerQuery || bareName === lowerQuery) {
       matchScore = 100;
     } else if (lowerName.startsWith(lowerQuery) || bareName.startsWith(lowerQuery)) {
@@ -62,11 +85,15 @@ export function findMatchingNodes(dbOrRepo, name, opts = {}) {
   return nodes;
 }
 
-export function queryNameData(name, customDbPath, opts = {}) {
+export function queryNameData(
+  name: string,
+  customDbPath: string,
+  opts: { noTests?: boolean; limit?: number; offset?: number } = {},
+) {
   const db = openReadonlyOrFail(customDbPath);
   try {
     const noTests = opts.noTests || false;
-    let nodes = db.prepare(`SELECT * FROM nodes WHERE name LIKE ?`).all(`%${name}%`);
+    let nodes = db.prepare(`SELECT * FROM nodes WHERE name LIKE ?`).all(`%${name}%`) as NodeRow[];
     if (noTests) nodes = nodes.filter((n) => !isTestFile(n.file));
     if (nodes.length === 0) {
       return { query: name, results: [] };
@@ -74,9 +101,9 @@ export function queryNameData(name, customDbPath, opts = {}) {
 
     const hc = new Map();
     const results = nodes.map((node) => {
-      let callees = findAllOutgoingEdges(db, node.id);
+      let callees = findAllOutgoingEdges(db, node.id) as AdjacentEdgeRow[];
 
-      let callers = findAllIncomingEdges(db, node.id);
+      let callers = findAllIncomingEdges(db, node.id) as AdjacentEdgeRow[];
 
       if (noTests) {
         callees = callees.filter((c) => !isTestFile(c.file));
@@ -109,13 +136,13 @@ export function queryNameData(name, customDbPath, opts = {}) {
   }
 }
 
-function whereSymbolImpl(db, target, noTests) {
+function whereSymbolImpl(db: BetterSqlite3Database, target: string, noTests: boolean) {
   const placeholders = EVERY_SYMBOL_KIND.map(() => '?').join(', ');
   let nodes = db
     .prepare(
       `SELECT * FROM nodes WHERE name LIKE ? AND kind IN (${placeholders}) ORDER BY file, line`,
     )
-    .all(`%${target}%`, ...EVERY_SYMBOL_KIND);
+    .all(`%${target}%`, ...EVERY_SYMBOL_KIND) as NodeRow[];
   if (noTests) nodes = nodes.filter((n) => !isTestFile(n.file));
 
   const hc = new Map();
@@ -123,7 +150,7 @@ function whereSymbolImpl(db, target, noTests) {
     const crossCount = countCrossFileCallers(db, node.id, node.file);
     const exported = crossCount > 0;
 
-    let uses = findCallers(db, node.id);
+    let uses = findCallers(db, node.id) as Array<{ name: string; file: string; line: number }>;
     if (noTests) uses = uses.filter((u) => !isTestFile(u.file));
 
     return {
@@ -134,18 +161,18 @@ function whereSymbolImpl(db, target, noTests) {
   });
 }
 
-function whereFileImpl(db, target) {
-  const fileNodes = findFileNodes(db, `%${target}%`);
+function whereFileImpl(db: BetterSqlite3Database, target: string) {
+  const fileNodes = findFileNodes(db, `%${target}%`) as NodeRow[];
   if (fileNodes.length === 0) return [];
 
   return fileNodes.map((fn) => {
-    const symbols = findNodesByFile(db, fn.file);
+    const symbols = findNodesByFile(db, fn.file) as NodeRow[];
 
-    const imports = findImportTargets(db, fn.id).map((r) => r.file);
+    const imports = (findImportTargets(db, fn.id) as ImportEdgeRow[]).map((r) => r.file);
 
-    const importedBy = findImportSources(db, fn.id).map((r) => r.file);
+    const importedBy = (findImportSources(db, fn.id) as ImportEdgeRow[]).map((r) => r.file);
 
-    const exportedIds = findCrossFileCallTargets(db, fn.file);
+    const exportedIds = findCrossFileCallTargets(db, fn.file) as Set<number>;
 
     const exported = symbols.filter((s) => exportedIds.has(s.id)).map((s) => s.name);
 
@@ -160,7 +187,11 @@ function whereFileImpl(db, target) {
   });
 }
 
-export function whereData(target, customDbPath, opts = {}) {
+export function whereData(
+  target: string,
+  customDbPath: string,
+  opts: { noTests?: boolean; file?: boolean; limit?: number; offset?: number } = {},
+) {
   const db = openReadonlyOrFail(customDbPath);
   try {
     const noTests = opts.noTests || false;
@@ -175,12 +206,21 @@ export function whereData(target, customDbPath, opts = {}) {
   }
 }
 
-export function listFunctionsData(customDbPath, opts = {}) {
+export function listFunctionsData(
+  customDbPath: string,
+  opts: {
+    noTests?: boolean;
+    file?: string;
+    pattern?: string;
+    limit?: number;
+    offset?: number;
+  } = {},
+) {
   const db = openReadonlyOrFail(customDbPath);
   try {
     const noTests = opts.noTests || false;
 
-    let rows = listFunctionNodes(db, { file: opts.file, pattern: opts.pattern });
+    let rows = listFunctionNodes(db, { file: opts.file, pattern: opts.pattern }) as NodeRow[];
 
     if (noTests) rows = rows.filter((r) => !isTestFile(r.file));
 
@@ -193,7 +233,11 @@ export function listFunctionsData(customDbPath, opts = {}) {
   }
 }
 
-export function childrenData(name, customDbPath, opts = {}) {
+export function childrenData(
+  name: string,
+  customDbPath: string,
+  opts: { noTests?: boolean; file?: string; kind?: string; limit?: number; offset?: number } = {},
+) {
   const db = openReadonlyOrFail(customDbPath);
   try {
     const noTests = opts.noTests || false;
@@ -204,11 +248,11 @@ export function childrenData(name, customDbPath, opts = {}) {
     }
 
     const results = nodes.map((node) => {
-      let children;
+      let children: ChildNodeRow[];
       try {
-        children = findNodeChildren(db, node.id);
-      } catch (e) {
-        debug(`findNodeChildren failed for node ${node.id}: ${e.message}`);
+        children = findNodeChildren(db, node.id) as ChildNodeRow[];
+      } catch (e: unknown) {
+        debug(`findNodeChildren failed for node ${node.id}: ${(e as Error).message}`);
         children = [];
       }
       if (noTests) children = children.filter((c) => !isTestFile(c.file || node.file));

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

@@ -0,0 +1,81 @@
+/**
+ * PipelineContext — shared mutable state threaded through all build stages.
+ *
+ * Each stage reads what it needs and writes what it produces.
+ * This replaces the closure-captured locals in the old monolithic buildGraph().
+ */
+import type {
+  BetterSqlite3Database,
+  BuildGraphOpts,
+  CodegraphConfig,
+  EngineOpts,
+  ExtractorOutput,
+  FileToParse,
+  MetadataUpdate,
+  NodeRow,
+  ParseChange,
+  PathAliases,
+} from '../../../types.js';
+
+export class PipelineContext {
+  // ── Inputs (set during setup) ──────────────────────────────────────
+  rootDir!: string;
+  db!: BetterSqlite3Database;
+  dbPath!: string;
+  config!: CodegraphConfig;
+  opts!: BuildGraphOpts;
+  engineOpts!: EngineOpts;
+  engineName!: 'native' | 'wasm';
+  engineVersion!: string | null;
+  aliases!: PathAliases;
+  incremental!: boolean;
+  forceFullRebuild: boolean = false;
+  schemaVersion!: number;
+
+  // ── File collection (set by collectFiles stage) ────────────────────
+  allFiles!: string[];
+  discoveredDirs!: Set<string>;
+
+  // ── Change detection (set by detectChanges stage) ──────────────────
+  isFullBuild!: boolean;
+  parseChanges!: ParseChange[];
+  metadataUpdates!: MetadataUpdate[];
+  removed!: string[];
+  earlyExit: boolean = false;
+
+  // ── Parsing (set by parseFiles stage) ──────────────────────────────
+  allSymbols!: Map<string, ExtractorOutput>;
+  fileSymbols!: Map<string, ExtractorOutput>;
+  filesToParse!: FileToParse[];
+
+  // ── Import resolution (set by resolveImports stage) ────────────────
+  batchResolved!: Map<string, string> | null;
+  reexportMap!: Map<string, unknown[]>;
+  barrelOnlyFiles!: Set<string>;
+
+  // ── Node lookup (set by insertNodes / buildEdges stages) ───────────
+  nodesByName!: Map<string, NodeRow[]>;
+  nodesByNameAndFile!: Map<string, NodeRow[]>;
+
+  // ── Misc state ─────────────────────────────────────────────────────
+  hasEmbeddings: boolean = false;
+  lineCountMap!: Map<string, number>;
+
+  // ── Phase timing ───────────────────────────────────────────────────
+  timing: {
+    setupMs?: number;
+    parseMs?: number;
+    insertMs?: number;
+    resolveMs?: number;
+    edgesMs?: number;
+    structureMs?: number;
+    rolesMs?: number;
+    astMs?: number;
+    complexityMs?: number;
+    cfgMs?: number;
+    dataflowMs?: number;
+    finalizeMs?: number;
+    [key: string]: number | undefined;
+  } = {};
+  buildStart!: number;
+}

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

@@ -0,0 +1,292 @@
+/**
+ * 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 { warn } from '../../../infrastructure/logger.js';
+import { EXTENSIONS, IGNORE_DIRS } from '../../../shared/constants.js';
+import type {
+  BetterSqlite3Database,
+  CodegraphConfig,
+  PathAliases,
+  SqliteStatement,
+} from '../../../types.js';
+
+export const BUILTIN_RECEIVERS: Set<string> = 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',
+]);
+
+/**
+ * Recursively collect all source files under `dir`.
+ * When `directories` is a Set, also tracks which directories contain files.
+ */
+export function collectFiles(
+  dir: string,
+  files: string[],
+  config: Partial<CodegraphConfig>,
+  directories: Set<string>,
+  _visited?: Set<string>,
+): { files: string[]; directories: Set<string> };
+export function collectFiles(
+  dir: string,
+  files?: string[],
+  config?: Partial<CodegraphConfig>,
+  directories?: null,
+  _visited?: Set<string>,
+): string[];
+export function collectFiles(
+  dir: string,
+  files: string[] = [],
+  config: Partial<CodegraphConfig> = {},
+  directories: Set<string> | null = null,
+  _visited: Set<string> = new Set(),
+): string[] | { files: string[]; directories: Set<string> } {
+  const trackDirs = directories instanceof Set;
+  let hasFiles = false;
+
+  // Merge config ignoreDirs with defaults
+  const extraIgnore = config.ignoreDirs ? new Set(config.ignoreDirs) : null;
+
+  // Detect symlink loops (before I/O to avoid wasted readdirSync)
+  let realDir: string;
+  try {
+    realDir = fs.realpathSync(dir);
+  } catch {
+    return trackDirs ? { files, directories: directories as Set<string> } : files;
+  }
+  if (_visited.has(realDir)) {
+    warn(`Symlink loop detected, skipping: ${dir}`);
+    return trackDirs ? { files, directories: directories as Set<string> } : files;
+  }
+  _visited.add(realDir);
+
+  let entries: fs.Dirent[];
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch (err: unknown) {
+    warn(`Cannot read directory ${dir}: ${(err as Error).message}`);
+    return trackDirs ? { files, directories: directories as Set<string> } : files;
+  }
+
+  for (const entry of entries) {
+    if (entry.name.startsWith('.') && entry.name !== '.') {
+      if (IGNORE_DIRS.has(entry.name)) continue;
+      if (entry.isDirectory()) continue;
+    }
+    if (IGNORE_DIRS.has(entry.name)) continue;
+    if (extraIgnore?.has(entry.name)) continue;
+
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (trackDirs) {
+        collectFiles(full, files, config, directories as Set<string>, _visited);
+      } else {
+        collectFiles(full, files, config, null, _visited);
+      }
+    } else if (EXTENSIONS.has(path.extname(entry.name))) {
+      files.push(full);
+      hasFiles = true;
+    }
+  }
+  if (trackDirs && hasFiles) {
+    (directories as Set<string>).add(dir);
+  }
+  return trackDirs ? { files, directories: directories as Set<string> } : files;
+}
+
+/**
+ * Load path aliases from tsconfig.json / jsconfig.json.
+ */
+export function loadPathAliases(rootDir: string): PathAliases {
+  const aliases: PathAliases = { 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) as {
+        compilerOptions?: { baseUrl?: string; paths?: Record<string, string[]> };
+      };
+      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: string) =>
+            path.resolve(aliases.baseUrl || rootDir, t),
+          );
+        }
+      }
+      break;
+    } catch (err: unknown) {
+      warn(`Failed to parse ${configName}: ${(err as Error).message}`);
+    }
+  }
+  return aliases;
+}
+
+/**
+ * Compute MD5 hash of file contents for incremental builds.
+ */
+export function fileHash(content: string): string {
+  return createHash('md5').update(content).digest('hex');
+}
+
+/**
+ * Stat a file, returning { mtimeMs, size } or null on error.
+ */
+export function fileStat(filePath: string): { mtimeMs: number; size: number } | null {
+  try {
+    const s = fs.statSync(filePath);
+    return { mtimeMs: s.mtimeMs, size: s.size };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Read a file with retry on transient errors (EBUSY/EACCES/EPERM).
+ */
+const TRANSIENT_CODES: Set<string> = new Set(['EBUSY', 'EACCES', 'EPERM']);
+const RETRY_DELAY_MS = 50;
+
+export function readFileSafe(filePath: string, retries: number = 2): string {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return fs.readFileSync(filePath, 'utf-8');
+    } catch (err: unknown) {
+      if (attempt < retries && TRANSIENT_CODES.has((err as NodeJS.ErrnoException).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: BetterSqlite3Database,
+  files: string[],
+  options: Record<string, unknown> = {},
+): void {
+  // Double-cast needed: better-sqlite3 types don't declare `open`/`name` properties
+  purgeFilesData(db as unknown as BetterSqlite3Database, 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<BetterSqlite3Database, Map<number, SqliteStatement>>();
+const edgeStmtCache = new WeakMap<BetterSqlite3Database, Map<number, SqliteStatement>>();
+
+function getNodeStmt(db: BetterSqlite3Database, chunkSize: number): SqliteStatement {
+  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: BetterSqlite3Database, chunkSize: number): SqliteStatement {
+  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) 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: BetterSqlite3Database, rows: unknown[][]): void {
+  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: unknown[] = [];
+    for (let j = i; j < end; j++) {
+      const r = rows[j] as unknown[];
+      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]
+ */
+export function batchInsertEdges(db: BetterSqlite3Database, rows: unknown[][]): void {
+  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: unknown[] = [];
+    for (let j = i; j < end; j++) {
+      const r = rows[j] as unknown[];
+      vals.push(r[0], r[1], r[2], r[3], r[4]);
+    }
+    stmt.run(...vals);
+  }
+}