Every registered path, in registration order.

path relative to the scan base that owns it, /-separated and rooted with a leading /. With no registered bases (library callers, unit specs that drive a parser directly) the path is returned unchanged, which is exactly the pre-registry behaviour.

Build a basename => paths index from file_map.

The companion to #build_extension_index, for the "find the file(s) whose path ends with a/b/c.py" lookups that analyzers otherwise answer with Dir.glob("root/**/a/b/c.py"). That glob walks the whole tree from the scan root — descending into node_modules, .git and every other subtree the detector deliberately pruned — and costs one opendir/getdirentries pass per call. Django's ROOT_URLCONF resolution ran it once per settings.py, which on a 44k-file monorepo was ~73% of the entire analysis phase.

Keyed on basename because that is the selective part of those patterns: urls.py narrows 44k files to a handful, and the caller confirms the rest of the path with a cheap ends_with?.

Build extension index from file_map for fast lookups

Drops every runtime-minted key under ns. Runs at a phase boundary with no fibers in flight, so a plain reject is enough — no minted-key bookkeeping to maintain.

Returns cached file content or nil if the file was not cached (budget exhausted, caching disabled, or read after cache was cleared). Callers should fall back to File.read on nil.

{original, File.expand_path(original)} for every file in file_map, built once and cached. File.expand_path is pure string normalization but non-trivial, and the monorepo helpers in FileHelper re-scan #all_files once per base path per analyzer — without this the same path is expanded thousands of times (O(analyzers × bases × files)). Invalidated whenever file_map changes (push / clear).

O(1) path => File.expand_path(path) lookup for files registered in file_map. Analyzers call path_under_root?(file, base) inside base_paths.each { files.each { ... } } loops, so the same file would otherwise be re-expanded once per base (and File.expand_path of a relative path issues a getcwd). Unregistered paths fall back to a live expansion. Shares the lazy lifecycle / invalidation of #expanded_file_map.

Files whose basename is exactly basename (O(1) lookup).

Get files by extension using the index (O(1) lookup)

String? rather than the old (String | Array(String)): the union only existed because a bare string key carried no type, so #get could not promise which map it was reading. Its one caller worked around it by interpolating the result.

One-shot used by the detector's file reader: push the path into file_map and (budget permitting) cache the content so analyzers can skip the second File.read. Files whose content exceeds the remaining budget are still registered in file_map but not cached, and #content_for(path) returns nil for them — callers must keep a File.read fallback.

Register a path with no content — the detector's content-free fast path, for files nothing will read during detection or passive scan.

Invalidates the four derived views but deliberately NOT @file_contents. A newly registered path has no cached content to invalidate, and dropping the cache here would throw away every file read so far. #content_for returning nil for a registered path is the contract — #register_file skips over-budget files the same way — so callers keep a File.read fallback regardless.

Forget every registered file, its cached content, and every derived view.

The -b roots of the current scan, published once by NoirRunner.

Convention filters ("is this file under tests/?", "is this bundled output?") must run on the path relative to the scan base, never on the absolute path — otherwise a directory above the base decides the result and the same source tree reports different endpoints depending on where it is checked out. Analyzers get that through Analyzer#base_relative_path; the shared parser layer (Noir::JSRouteExtractor and friends) has no analyzer instance, so it reads the roots from here.