@optave/codegraph 3.9.2 → 3.9.4

package/src/domain/graph/builder/stages/detect-changes.ts

@@ -374,24 +374,73 @@ function purgeAndAddReverseDeps(
     // Prefer NativeDatabase: purge + reverse-dep edge deletion in one transaction (#670)
     if (ctx.engineName === 'native' && ctx.nativeDb?.purgeFilesData) {
       ctx.nativeDb.purgeFilesData(filesToPurge, false, hasReverseDeps ? reverseDepList : undefined);
+      // Native path still reparses reverse-deps (works correctly with native edge builder)
+      for (const relPath of reverseDeps) {
+        const absPath = path.join(rootDir, relPath);
+        ctx.parseChanges.push({ file: absPath, relPath, _reverseDepOnly: true });
+      }
     } else {
+      // WASM/JS path: save edges from reverse-dep files → changed files BEFORE
+      // purge, then reconnect them to new node IDs after insertNodes (#932, #933).
+      //
+      // purgeFilesFromGraph deletes edges in BOTH directions for changed files,
+      // which already removes the reverse-dep → changed-file edges.  The old
+      // approach then over-deleted ALL outgoing edges from reverse-dep files and
+      // reparsed them to rebuild everything — expensive (87 extra parses) and
+      // lossy (442 missing edges due to imperfect resolution on rebuild).
+      //
+      // New approach: save the edge topology, let purge handle deletion, then
+      // reconnect using new node IDs.  No reparse needed.
+      if (hasReverseDeps && hasPurge) {
+        const changePathSet = new Set(changePaths);
+        const saveEdgesStmt = db.prepare(`
+          SELECT e.source_id, n_tgt.name AS tgt_name, n_tgt.kind AS tgt_kind,
+                 n_tgt.file AS tgt_file, n_tgt.line AS tgt_line,
+                 e.kind AS edge_kind, e.confidence, e.dynamic,
+                 n_src.file AS src_file
+          FROM edges e
+          JOIN nodes n_src ON e.source_id = n_src.id
+          JOIN nodes n_tgt ON e.target_id = n_tgt.id
+          WHERE n_tgt.file = ? AND n_src.file != n_tgt.file
+        `);
+        for (const changedPath of changePaths) {
+          for (const row of saveEdgesStmt.all(changedPath) as Array<{
+            source_id: number;
+            tgt_name: string;
+            tgt_kind: string;
+            tgt_file: string;
+            tgt_line: number;
+            edge_kind: string;
+            confidence: number;
+            dynamic: number;
+            src_file: string;
+          }>) {
+            // Skip edges whose source is also being purged — buildEdges will
+            // re-create them with correct new IDs.
+            if (changePathSet.has(row.src_file)) continue;
+            ctx.savedReverseDepEdges.push({
+              sourceId: row.source_id,
+              tgtName: row.tgt_name,
+              tgtKind: row.tgt_kind,
+              tgtFile: row.tgt_file,
+              tgtLine: row.tgt_line,
+              edgeKind: row.edge_kind,
+              confidence: row.confidence,
+              dynamic: row.dynamic,
+            });
+          }
+        }
+        debug(`Saved ${ctx.savedReverseDepEdges.length} reverse-dep edges for reconnection`);
+      }
+
       if (hasPurge) {
         purgeFilesFromGraph(db, filesToPurge, { purgeHashes: false });
       }
-      if (hasReverseDeps) {
-        const deleteOutgoingEdgesForFile = db.prepare(
-          'DELETE FROM edges WHERE source_id IN (SELECT id FROM nodes WHERE file = ?)',
-        );
-        for (const relPath of reverseDepList) {
-          deleteOutgoingEdgesForFile.run(relPath);
-        }
-      }
+      // No outgoing-edge deletion for reverse-deps — purge already removed
+      // edges targeting the changed files, and other outgoing edges are valid.
+      // No reverse-deps added to parseChanges — no reparse needed.
     }
   }
-  for (const relPath of reverseDeps) {
-    const absPath = path.join(rootDir, relPath);
-    ctx.parseChanges.push({ file: absPath, relPath, _reverseDepOnly: true });
-  }
 }
 
 function detectHasEmbeddings(db: BetterSqlite3Database, nativeDb?: NativeDatabase): boolean {

package/src/domain/graph/builder/stages/finalize.ts

@@ -81,13 +81,20 @@ function persistBuildMetadata(
 ): void {
   const useNativeDb = ctx.engineName === 'native' && !!ctx.nativeDb;
   if (!ctx.isFullBuild && ctx.allSymbols.size <= 3) return;
+  // When the native engine is active, persist the Rust addon version so that
+  // checkEngineSchemaMismatch compares against the same value on the next build.
+  // Writing CODEGRAPH_VERSION (the npm package version) here would create a
+  // permanent mismatch whenever npm and crate versions diverge, forcing every
+  // subsequent build to be a full rebuild.
+  const codeVersionToWrite =
+    ctx.engineName === 'native' && ctx.engineVersion ? ctx.engineVersion : CODEGRAPH_VERSION;
   try {
     if (useNativeDb) {
       ctx.nativeDb!.setBuildMeta(
         Object.entries({
           engine: ctx.engineName,
-          engine_version: CODEGRAPH_VERSION,
-          codegraph_version: CODEGRAPH_VERSION,
+          engine_version: codeVersionToWrite,
+          codegraph_version: codeVersionToWrite,
           schema_version: String(ctx.schemaVersion),
           built_at: buildNow.toISOString(),
           node_count: String(nodeCount),
@@ -97,8 +104,8 @@ function persistBuildMetadata(
     } else {
       setBuildMeta(ctx.db, {
         engine: ctx.engineName,
-        engine_version: CODEGRAPH_VERSION,
-        codegraph_version: CODEGRAPH_VERSION,
+        engine_version: codeVersionToWrite,
+        codegraph_version: codeVersionToWrite,
         schema_version: String(ctx.schemaVersion),
         built_at: buildNow.toISOString(),
         node_count: nodeCount,

package/src/domain/graph/builder/stages/run-analyses.ts

@@ -2,39 +2,18 @@
  * Stage: runAnalyses
  *
  * Dispatches to the unified AST analysis engine (AST nodes, complexity, CFG, dataflow).
- * Filters out reverse-dep files for incremental builds.
+ * Reverse-dep files are no longer in allSymbols (they are not reparsed since #932/#933),
+ * so no filtering is needed here.
  */
-import { debug, warn } from '../../../../infrastructure/logger.js';
-import type { ExtractorOutput } from '../../../../types.js';
+import { warn } from '../../../../infrastructure/logger.js';
 import type { PipelineContext } from '../context.js';
 
 export async function runAnalyses(ctx: PipelineContext): Promise<void> {
-  const { db, allSymbols, rootDir, opts, engineOpts, isFullBuild, filesToParse } = ctx;
-
-  // For incremental builds, exclude reverse-dep-only files
-  let astComplexitySymbols: Map<string, ExtractorOutput> = allSymbols;
-  if (!isFullBuild) {
-    const reverseDepFiles = new Set(
-      filesToParse
-        .filter((item) => (item as { _reverseDepOnly?: boolean })._reverseDepOnly)
-        .map((item) => item.relPath),
-    );
-    if (reverseDepFiles.size > 0) {
-      astComplexitySymbols = new Map();
-      for (const [relPath, symbols] of allSymbols) {
-        if (!reverseDepFiles.has(relPath)) {
-          astComplexitySymbols.set(relPath, symbols);
-        }
-      }
-      debug(
-        `AST/complexity/CFG/dataflow: processing ${astComplexitySymbols.size} changed files (skipping ${reverseDepFiles.size} reverse-deps)`,
-      );
-    }
-  }
+  const { db, allSymbols, rootDir, opts, engineOpts } = ctx;
 
   const { runAnalyses: runAnalysesFn } = await import('../../../../ast-analysis/engine.js');
   try {
-    const analysisTiming = await runAnalysesFn(db, astComplexitySymbols, rootDir, opts, engineOpts);
+    const analysisTiming = await runAnalysesFn(db, allSymbols, rootDir, opts, engineOpts);
     ctx.timing.astMs = analysisTiming.astMs;
     ctx.timing.complexityMs = analysisTiming.complexityMs;
     ctx.timing.cfgMs = analysisTiming.cfgMs;

package/src/domain/parser.ts

@@ -780,7 +780,7 @@ export async function parseFileAuto(
   const { native } = resolveEngine(opts);
 
   if (native) {
-    const result = native.parseFile(filePath, source, !!opts.dataflow, opts.ast !== false);
+    const result = native.parseFile(filePath, source, true, true);
     if (!result) return null;
     const patched = patchNativeResult(result);
     // Always backfill typeMap for TS/TSX from WASM — native parser's type
@@ -878,7 +878,11 @@ export async function parseFilesAuto(
   if (!native) return parseFilesWasm(filePaths, rootDir);
 
   const result = new Map<string, ExtractorOutput>();
-  const nativeResults = native.parseFiles(filePaths, rootDir, !!opts.dataflow, opts.ast !== false);
+  // Always extract all analysis data (dataflow + AST nodes) during native parse.
+  // This eliminates the need for any downstream WASM re-parse or native standalone calls.
+  const nativeResults = native.parseFilesFull
+    ? native.parseFilesFull(filePaths, rootDir)
+    : native.parseFiles(filePaths, rootDir, true, true);
   const needsTypeMap: { filePath: string; relPath: string }[] = [];
   for (const r of nativeResults) {
     if (!r) continue;

package/src/extractors/javascript.ts

@@ -274,14 +274,17 @@ function dispatchQueryMatch(
       name: c.callfn_name!.text,
       line: c.callfn_node.startPosition.row + 1,
     });
+    calls.push(...extractCallbackReferenceCalls(c.callfn_node));
   } else if (c.callmem_node) {
     const callInfo = extractCallInfo(c.callmem_fn!, c.callmem_node);
     if (callInfo) calls.push(callInfo);
     const cbDef = extractCallbackDefinition(c.callmem_node, c.callmem_fn);
     if (cbDef) definitions.push(cbDef);
+    calls.push(...extractCallbackReferenceCalls(c.callmem_node));
   } else if (c.callsub_node) {
     const callInfo = extractCallInfo(c.callsub_fn!, c.callsub_node);
     if (callInfo) calls.push(callInfo);
+    calls.push(...extractCallbackReferenceCalls(c.callsub_node));
   } else if (c.newfn_node) {
     calls.push({
       name: c.newfn_name!.text,
@@ -321,6 +324,9 @@ function extractSymbolsQuery(tree: TreeSitterTree, query: TreeSitterQuery): Extr
   // Extract typeMap from type annotations and new expressions
   extractTypeMapWalk(tree.rootNode, typeMap);
 
+  // Extract definitions from destructured bindings (query patterns don't match object_pattern)
+  extractDestructuredBindingsWalk(tree.rootNode, definitions);
+
   return { definitions, calls, imports, classes, exports: exps, typeMap };
 }
 
@@ -334,6 +340,20 @@ const FUNCTION_SCOPE_TYPES = new Set([
   'generator_function',
 ]);
 
+/**
+ * Return true when `node` has an ancestor whose type is in FUNCTION_SCOPE_TYPES.
+ * Used by the walk path to skip declarations inside function bodies, matching
+ * the query path's top-down FUNCTION_SCOPE_TYPES filter.
+ */
+function hasFunctionScopeAncestor(node: TreeSitterNode): boolean {
+  let p: TreeSitterNode | null = node.parent ?? null;
+  while (p) {
+    if (FUNCTION_SCOPE_TYPES.has(p.type)) return true;
+    p = p.parent ?? null;
+  }
+  return false;
+}
+
 /**
  * Recursively walk the AST to extract `const x = <literal>` as constants.
  * Skips nodes inside function scopes so only file-level / block-level constants
@@ -363,6 +383,48 @@ function extractConstantsWalk(node: TreeSitterNode, definitions: Definition[]):
   }
 }
 
+/**
+ * Walk the AST to find destructured const bindings (query patterns don't match object_pattern).
+ * e.g. `const { handleToken, checkPermissions } = initAuth(config)`
+ */
+function extractDestructuredBindingsWalk(node: TreeSitterNode, definitions: Definition[]): void {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (FUNCTION_SCOPE_TYPES.has(child.type)) continue;
+
+    let declNode = child;
+    if (child.type === 'export_statement') {
+      const inner = child.childForFieldName('declaration');
+      if (inner) declNode = inner;
+    }
+
+    const t = declNode.type;
+    if (
+      (t === 'lexical_declaration' || t === 'variable_declaration') &&
+      declNode.text.startsWith('const ')
+    ) {
+      for (let j = 0; j < declNode.childCount; j++) {
+        const declarator = declNode.child(j);
+        if (!declarator || declarator.type !== 'variable_declarator') continue;
+        const nameN = declarator.childForFieldName('name');
+        if (nameN && nameN.type === 'object_pattern') {
+          extractDestructuredBindings(
+            nameN,
+            declNode.startPosition.row + 1,
+            nodeEndLine(declNode),
+            definitions,
+          );
+        }
+      }
+    }
+
+    if (child.type !== 'export_statement') {
+      extractDestructuredBindingsWalk(child, definitions);
+    }
+  }
+}
+
 /** Extract constant definitions from a `const` declaration node. */
 function extractConstDeclarators(declNode: TreeSitterNode, definitions: Definition[]): void {
   const t = declNode.type;
@@ -637,6 +699,39 @@ function handleTypeAliasDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   }
 }
 
+/**
+ * Extract definitions from destructured object bindings.
+ * `const { handleToken, checkPermissions } = initAuth(...)` creates definitions
+ * for handleToken and checkPermissions so they can be resolved as call targets.
+ */
+function extractDestructuredBindings(
+  pattern: TreeSitterNode,
+  line: number,
+  endLine: number,
+  definitions: Definition[],
+): void {
+  for (let i = 0; i < pattern.childCount; i++) {
+    const child = pattern.child(i);
+    if (!child) continue;
+    if (
+      child.type === 'shorthand_property_identifier_pattern' ||
+      child.type === 'shorthand_property_identifier'
+    ) {
+      // { handleToken } — shorthand binding
+      definitions.push({ name: child.text, kind: 'function', line, endLine });
+    } else if (child.type === 'pair_pattern' || child.type === 'pair') {
+      // { original: renamed } — renamed binding, use the local alias
+      const value = child.childForFieldName('value');
+      if (
+        value &&
+        (value.type === 'identifier' || value.type === 'shorthand_property_identifier_pattern')
+      ) {
+        definitions.push({ name: value.text, kind: 'function', line, endLine });
+      }
+    }
+  }
+}
+
 function handleVariableDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const isConst = node.text.startsWith('const ');
   for (let i = 0; i < node.childCount; i++) {
@@ -667,6 +762,20 @@ function handleVariableDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
             line: node.startPosition.row + 1,
             endLine: nodeEndLine(node),
           });
+        } else if (isConst && nameN.type === 'object_pattern' && !hasFunctionScopeAncestor(node)) {
+          // Destructured bindings: const { handleToken, checkPermissions } = initAuth(...)
+          // Each destructured property becomes a function definition so it can be
+          // resolved when passed as a callback (e.g. router.use(handleToken)).
+          // Restricted to const to avoid creating spurious definitions for
+          // transient let/var destructuring (e.g. let { userId } = parseRequest(req)).
+          // Scope guard mirrors extractDestructuredBindingsWalk (query path) and
+          // handle_var_decl (Rust path) — skips bindings inside function bodies.
+          extractDestructuredBindings(
+            nameN,
+            node.startPosition.row + 1,
+            nodeEndLine(node),
+            ctx.definitions,
+          );
         }
       }
     }
@@ -715,6 +824,7 @@ function handleCallExpr(node: TreeSitterNode, ctx: ExtractorOutput): void {
       const cbDef = extractCallbackDefinition(node, fn);
       if (cbDef) ctx.definitions.push(cbDef);
     }
+    ctx.calls.push(...extractCallbackReferenceCalls(node));
   }
 }
 
@@ -1167,6 +1277,38 @@ function extractSubscriptCallInfo(fn: TreeSitterNode, callNode: TreeSitterNode):
   return null;
 }
 
+/**
+ * Extract Call entries for named function references passed as arguments.
+ * e.g. `router.use(handleToken, checkAuth)` yields calls to handleToken and checkAuth.
+ * `app.use(auth.validate)` yields a call to validate with receiver auth.
+ * Skips literals, objects, arrays, anonymous functions, and call expressions (already handled).
+ */
+function extractCallbackReferenceCalls(callNode: TreeSitterNode): Call[] {
+  const args = callNode.childForFieldName('arguments') || findChild(callNode, 'arguments');
+  if (!args) return [];
+
+  const result: Call[] = [];
+  const callLine = callNode.startPosition.row + 1;
+
+  for (let i = 0; i < args.childCount; i++) {
+    const child = args.child(i);
+    if (!child) continue;
+
+    if (child.type === 'identifier') {
+      result.push({ name: child.text, line: callLine, dynamic: true });
+    } else if (child.type === 'member_expression') {
+      const prop = child.childForFieldName('property');
+      const obj = child.childForFieldName('object');
+      if (prop) {
+        const receiver = extractReceiverName(obj);
+        result.push({ name: prop.text, line: callLine, dynamic: true, receiver });
+      }
+    }
+  }
+
+  return result;
+}
+
 function findAnonymousCallback(argsNode: TreeSitterNode): TreeSitterNode | null {
   for (let i = 0; i < argsNode.childCount; i++) {
     const child = argsNode.child(i);

package/src/features/ast.ts

@@ -115,8 +115,8 @@ function tryNativeBulkInsert(
           receiver: n.receiver ?? '',
         })),
       });
-    } else if (symbols.calls || symbols._tree) {
-      return false; // needs JS fallback
+    } else if (symbols._tree) {
+      return false; // has WASM tree not yet processed — needs JS fallback
     }
   }
 

package/src/features/cfg.ts

@@ -369,7 +369,7 @@ export async function buildCFGData(
   db: BetterSqlite3Database,
   fileSymbols: Map<string, FileSymbols>,
   rootDir: string,
-  _engineOpts?: {
+  engineOpts?: {
     nativeDb?: { bulkInsertCfg?(entries: Array<Record<string, unknown>>): number };
     suspendJsDb?: () => void;
     resumeJsDb?: () => void;
@@ -379,11 +379,56 @@ export async function buildCFGData(
   // skip WASM parser init, tree parsing, and JS visitor entirely — just persist.
   const allNative = allCfgNative(fileSymbols);
 
-  // NOTE: nativeDb.bulkInsertCfg is intentionally NOT used here.
-  // The CFG path requires delete-before-insert (deleteCfgForNode) which creates
-  // a dual-connection WAL conflict when deletes go through JS (better-sqlite3)
-  // and inserts go through native (rusqlite). The JS-only persistNativeFileCfg
-  // path below handles both on a single connection safely.
+  // ── Native bulk-insert fast path ──────────────────────────────────────
+  // The Rust bulkInsertCfg handles delete-before-insert atomically on a
+  // single rusqlite connection, so there is no dual-connection WAL conflict.
+  const nativeDb = engineOpts?.nativeDb;
+  if (allNative && nativeDb?.bulkInsertCfg) {
+    const entries: Array<Record<string, unknown>> = [];
+    for (const [relPath, symbols] of fileSymbols) {
+      const ext = path.extname(relPath).toLowerCase();
+      if (!CFG_EXTENSIONS.has(ext)) continue;
+
+      for (const def of symbols.definitions) {
+        if (def.kind !== 'function' && def.kind !== 'method') continue;
+        if (!def.line) continue;
+
+        const nodeId = getFunctionNodeId(db, def.name, relPath, def.line);
+        if (!nodeId) continue;
+
+        const cfg = def.cfg as { blocks?: CfgBuildBlock[]; edges?: CfgBuildEdge[] } | undefined;
+        if (!cfg?.blocks?.length) continue;
+
+        entries.push({
+          nodeId,
+          blocks: cfg.blocks.map((b) => ({
+            index: b.index,
+            blockType: b.type,
+            startLine: b.startLine ?? undefined,
+            endLine: b.endLine ?? undefined,
+            label: b.label ?? undefined,
+          })),
+          edges: (cfg.edges || []).map((e) => ({
+            sourceIndex: e.sourceIndex,
+            targetIndex: e.targetIndex,
+            kind: e.kind,
+          })),
+        });
+      }
+    }
+
+    if (entries.length > 0) {
+      let inserted = 0;
+      try {
+        engineOpts?.suspendJsDb?.();
+        inserted = nativeDb.bulkInsertCfg(entries);
+      } finally {
+        engineOpts?.resumeJsDb?.();
+      }
+      info(`CFG (native bulk): ${inserted} functions analyzed`);
+    }
+    return;
+  }
 
   const extToLang = buildExtToLangMap();
   let parsers: unknown = null;

package/src/features/complexity.ts

@@ -545,6 +545,10 @@ function collectNativeBulkRows(
   const rows: Array<Record<string, unknown>> = [];
 
   for (const [relPath, symbols] of fileSymbols) {
+    const ext = path.extname(relPath).toLowerCase();
+    const langId = symbols._langId || '';
+    const langSupported = COMPLEXITY_EXTENSIONS.has(ext) || COMPLEXITY_RULES.has(langId);
+
     for (const def of symbols.definitions) {
       if (def.kind !== 'function' && def.kind !== 'method') continue;
       if (!def.line) continue;
@@ -554,6 +558,9 @@ function collectNativeBulkRows(
       // of the native bulk-insert path for every TypeScript codebase (#846).
       if (!def.complexity) {
         if (def.name.includes('.') || !def.endLine || def.endLine <= def.line) continue;
+        // Languages without complexity rules will never have data — skip them
+        // rather than bailing out of the entire native bulk path.
+        if (!langSupported) continue;
         return null; // genuine function body missing complexity — needs JS fallback
       }
       const nodeId = getFunctionNodeId(db, def.name, relPath, def.line);

package/src/features/structure.ts

@@ -166,6 +166,22 @@ function computeFileMetrics(
   fanOutMap: Map<string, number>,
 ): void {
   db.transaction(() => {
+    // Batch-load import counts per file (distinct imported files,
+    // matching the fast-path semantics in updateChangedFileMetrics).
+    // Runs inside the transaction for parity with the Rust path.
+    const importCountMap = new Map<string, number>();
+    for (const row of db
+      .prepare(
+        `SELECT n1.file AS src, COUNT(DISTINCT n2.file) AS cnt FROM edges e
+         JOIN nodes n1 ON e.source_id = n1.id
+         JOIN nodes n2 ON e.target_id = n2.id
+         WHERE e.kind = 'imports'
+         GROUP BY n1.file`,
+      )
+      .all() as { src: string; cnt: number }[]) {
+      importCountMap.set(row.src, row.cnt);
+    }
+
     for (const [relPath, symbols] of fileSymbols) {
       const fileRow = getNodeIdStmt.get(relPath, 'file', relPath, 0);
       if (!fileRow) continue;
@@ -180,7 +196,7 @@ function computeFileMetrics(
           symbolCount++;
         }
       }
-      const importCount = symbols.imports.length;
+      const importCount = importCountMap.get(relPath) || 0;
       const exportCount = symbols.exports.length;
       const fanIn = fanInMap.get(relPath) || 0;
       const fanOut = fanOutMap.get(relPath) || 0;

package/src/infrastructure/update-check.ts

@@ -18,11 +18,11 @@ interface UpdateCache {
 
 /**
  * Minimal semver comparison. Returns -1, 0, or 1.
- * Only handles numeric x.y.z (no pre-release tags).
+ * Strips pre-release suffixes (e.g. "3.9.3-dev.6" → "3.9.3") before comparing.
  */
 export function semverCompare(a: string, b: string): -1 | 0 | 1 {
-  const pa = a.split('.').map(Number);
-  const pb = b.split('.').map(Number);
+  const pa = a.replace(/-.*$/, '').split('.').map(Number);
+  const pb = b.replace(/-.*$/, '').split('.').map(Number);
   for (let i = 0; i < 3; i++) {
     const na = pa[i] || 0;
     const nb = pb[i] || 0;

package/src/types.ts

@@ -1874,6 +1874,7 @@ export type StmtCache<TRow = unknown> = WeakMap<BetterSqlite3Database, SqliteSta
 export interface NativeAddon {
   parseFile(filePath: string, source: string, dataflow: boolean, ast: boolean): unknown;
   parseFiles(files: string[], rootDir: string, dataflow: boolean, ast: boolean): unknown[];
+  parseFilesFull?(files: string[], rootDir: string): unknown[];
   resolveImport(fromFile: string, importSource: string, rootDir: string, aliases: unknown): string;
   resolveImports(
     items: Array<{ fromFile: string; importSource: string }>,