Two passes, one trick

Code-explorer analyzes TypeScript and draws diagrams: type maps, call graphs, module graphs. For a single file, the analyzer sees everything. But when UserService extends BaseService and they're in different files, the analyzer has a blind spot.

The blind spot

The single-file analyzer works by parsing the AST, collecting declared names, and then walking the tree again to find references. When it sees extends BaseService, it checks if BaseService is in its set of known names. In a single file, that set only contains names declared in that file. Cross-file references vanish.

The fix is absurdly simple: give it more names.

Two passes

Pass 1 scans every file and collects all declared type and function names into a single set. No analysis, no edges, just names. Fast.

Pass 2 runs the existing single-file analyzer on each file, but passes in the global name set as extra context. Now when service.ts references BaseService, the analyzer knows that name exists (it was collected from base.ts in pass 1) and creates the edge.

The single-file analyzer already accepted an optional externalNames parameter. The multi-file wrapper just fills it in. Zero changes to the core analysis logic.

Same trick, two diagrams

The type map and call graph use the exact same approach. For types, pass 1 collects interface, class, type alias, and enum names. For call graphs, it collects function and method names. Both use the same pattern: collect, then analyze with context.

This is the same fundamental idea behind compiler forward declarations and multi-pass compilation. You can't resolve references you don't know about. So you learn all the names first.