fix(resolution): dangling relative imports are negative evidence

- `RelativeImportLookup { Bound, NoIndexedFile, Unknown }`: `resolve_relative_import` reports `NoIndexedFile` only when every accepted path is absent from a complete index view, no same-directory file shares the first-dot stem, and the path is not an indexed directory; anything else is `Unknown`
- `ImportOrigin::Dangling`: the TypeScript and JavaScript builders register a `NoIndexedFile` binding as dangling, install nothing into scope, and skip the module-string fallback
- shared resolver: a receiver-less row of any kind whose name is owned by a dangling binding fails closed before the name-keyed tiers; the file's own definitions and the inheritance witness still resolve; receiver-bearing rows unchanged
- `PipelineSymbolCache::{file_presence, sibling_stem_present, directory_present}` answer from file rows; only a cache built from every persisted row (`from_index` over the uncapped `for_each_file_path`) answers `Absent`; walk-scoped caches answer `Unknown`
- boundary: a file governed by a tsconfig or jsconfig with `moduleSuffixes` or `rootDirs` gets no negative evidence (`ResolutionRules::relative_specifiers_redirected`; provider cache `RESOLUTION_INDEX_VERSION` 1.1)
- preservation goldens under `tests/fixtures/dangling_import/` captured from a `71b6cdb` release build; `EMISSION_SEMANTICS_VERSION` unchanged, `codanna index --force` applies the change to an existing index

Co-authored-by: Mason James <297610+masonjames@users.noreply.github.com>

Author: bartolli

src/indexing/facade.rs

@@ -19,7 +19,7 @@ use crate::indexing::pipeline::types::{
     CallerContext, ResolutionContext, ResolvedBatch, ResolvedRelationship, SymbolLookupCache,
     UnresolvedRelationship,
 };
-use crate::parsing::resolution::{GenericInheritanceResolver, InheritanceResolver};
+use crate::parsing::resolution::{GenericInheritanceResolver, ImportOrigin, InheritanceResolver};
 use crate::parsing::{Import, LanguageBehavior, LanguageId};
 use crate::types::{FileId, SymbolId};
 use crate::{RelationKind, Symbol};
@@ -226,6 +226,21 @@ impl ResolveStage {
             }
         }
 
+        // A dangling import owns its name: the builder proved the target
+        // file absent from the index, so a same-name symbol anywhere else
+        // is not this reference's target. Receiver-less rows of every kind
+        // fail closed here, after the file's own definitions (scope hit)
+        // and the inheritance witness, before any name-keyed tier.
+        // Receiver-bearing rows carry their own evidence and keep it.
+        if Self::is_receiver_less(unresolved)
+            && context
+                .scope
+                .import_binding(&unresolved.to_name)
+                .is_some_and(|binding| binding.origin == ImportOrigin::Dangling)
+        {
+            return None;
+        }
+
         // For qualified static calls (`Type::method` / `Type.method`), the
         // tier-based `cache.resolve()` returns the local same-name candidate
         // before consulting any non-local match. Bypass tier logic and filter
@@ -955,6 +970,14 @@ impl ResolveStage {
             })
     }
 
+    /// A row of any kind whose emitted metadata names no receiver.
+    fn is_receiver_less(unresolved: &UnresolvedRelationship) -> bool {
+        unresolved
+            .metadata
+            .as_ref()
+            .is_none_or(|m| m.receiver.is_none())
+    }
+
     /// A Calls row with no receiver metadata and no static flag.
     fn is_bare_instance_call(unresolved: &UnresolvedRelationship) -> bool {
         unresolved.kind == RelationKind::Calls

src/indexing/pipeline/stages/resolve.rs

@@ -4,6 +4,7 @@
 //! Key design principle: Parse stage produces "raw" types without IDs,
 //! Collect stage assigns IDs and produces final types.
 
+use crate::parsing::resolution::FilePresence;
 use crate::parsing::{Import, LanguageId, PipelineSymbolCache, ResolveResult};
 use crate::relationship::RelationshipMetadata;
 use crate::symbol::ScopeContext;
@@ -462,6 +463,40 @@ pub struct SymbolLookupCache {
     /// Re-exported paths: "pkg.helper" -> the symbol defined at "pkg.a.helper"
     /// when pkg's namespace imports it. Populated by the Phase 2 pre-pass.
     module_aliases: dashmap::DashMap<Box<str>, crate::types::SymbolId>,
+    /// Every file row in the index, in the decoded path form symbols
+    /// carry. `Some` only for a cache built from the persisted index:
+    /// a walk-scoped cache sees its own run's files and cannot prove a
+    /// path absent.
+    indexed_files: Option<IndexedFileView>,
+}
+
+/// Every file row in the index, projected three ways for the negative
+/// evidence a dangling relative import needs: the paths themselves, the
+/// `(directory, first-dot stem)` pairs extension-substituted siblings
+/// share, and every ancestor directory.
+#[derive(Debug, Default, PartialEq, Eq)]
+pub(crate) struct IndexedFileView {
+    paths: std::collections::HashSet<PathBuf>,
+    stems: std::collections::HashSet<(PathBuf, String)>,
+    dirs: std::collections::HashSet<PathBuf>,
+}
+
+impl IndexedFileView {
+    fn from_paths(files: impl IntoIterator<Item = PathBuf>) -> Self {
+        let mut view = Self::default();
+        for path in files {
+            if let Some(stem) = crate::parsing::paths::dir_and_first_dot_stem(&path) {
+                view.stems.insert(stem);
+            }
+            for dir in path.ancestors().skip(1) {
+                if !dir.as_os_str().is_empty() {
+                    view.dirs.insert(dir.to_path_buf());
+                }
+            }
+            view.paths.insert(path);
+        }
+        view
+    }
 }
 
 impl Default for SymbolLookupCache {
@@ -478,6 +513,7 @@ impl SymbolLookupCache {
             by_name: dashmap::DashMap::new(),
             by_file_id: dashmap::DashMap::new(),
             module_aliases: dashmap::DashMap::new(),
+            indexed_files: None,
         }
     }
 
@@ -488,9 +524,24 @@ impl SymbolLookupCache {
             by_name: dashmap::DashMap::with_capacity(symbols / 10), // Fewer unique names
             by_file_id: dashmap::DashMap::with_capacity(symbols / 50), // ~50 symbols/file avg
             module_aliases: dashmap::DashMap::new(),
+            indexed_files: None,
         }
     }
 
+    /// Create an empty cache that knows the complete set of indexed file
+    /// paths, so the presence queries can answer `Absent`.
+    pub fn with_indexed_files(files: impl IntoIterator<Item = PathBuf>) -> Self {
+        let mut cache = Self::new();
+        cache.indexed_files = Some(IndexedFileView::from_paths(files));
+        cache
+    }
+
+    /// The complete file view, when this cache was built from the index.
+    #[cfg(test)]
+    pub(crate) fn indexed_files(&self) -> Option<&IndexedFileView> {
+        self.indexed_files.as_ref()
+    }
+
     /// Insert a symbol into the cache.
     pub fn insert(&self, symbol: crate::Symbol) {
         let id = symbol.id;
@@ -875,6 +926,32 @@ impl PipelineSymbolCache for SymbolLookupCache {
     fn lookup_candidates(&self, name: &str) -> Vec<SymbolId> {
         SymbolLookupCache::lookup_candidates(self, name)
     }
+
+    fn file_presence(&self, path: &std::path::Path) -> FilePresence {
+        match &self.indexed_files {
+            None => FilePresence::Unknown,
+            Some(view) if view.paths.contains(path) => FilePresence::Present,
+            Some(_) => FilePresence::Absent,
+        }
+    }
+
+    fn sibling_stem_present(&self, path: &std::path::Path) -> FilePresence {
+        let Some(view) = &self.indexed_files else {
+            return FilePresence::Unknown;
+        };
+        match crate::parsing::paths::dir_and_first_dot_stem(path) {
+            Some(stem) if view.stems.contains(&stem) => FilePresence::Present,
+            _ => FilePresence::Absent,
+        }
+    }
+
+    fn directory_present(&self, path: &std::path::Path) -> FilePresence {
+        match &self.indexed_files {
+            None => FilePresence::Unknown,
+            Some(view) if view.dirs.contains(path) => FilePresence::Present,
+            Some(_) => FilePresence::Absent,
+        }
+    }
 }
 
 impl SymbolLookupCache {
@@ -890,7 +967,21 @@ impl SymbolLookupCache {
         let count = index
             .count_symbols()
             .map_err(|e| PipelineError::Index(crate::IndexError::Storage(e)))?;
-        let cache = Self::with_capacity(count);
+        let mut cache = Self::with_capacity(count);
+
+        // File rows decode through the same portable-path boundary as the
+        // symbols they are compared against. The visitor is uncapped, so
+        // the view is complete at every index size.
+        let mut files: Vec<PathBuf> = Vec::new();
+        index.for_each_file_path(|stored| -> Result<(), PipelineError> {
+            files.push(match index.to_portable_file_path(&stored) {
+                Some(portable) => PathBuf::from(portable),
+                None => PathBuf::from(stored),
+            });
+            Ok(())
+        })?;
+        cache.indexed_files = Some(IndexedFileView::from_paths(files));
+
         if count == 0 {
             return Ok(cache);
         }

src/indexing/pipeline/types.rs

@@ -3,7 +3,7 @@
 use crate::parsing::LanguageBehavior;
 use crate::parsing::behavior_state::{BehaviorState, StatefulBehavior};
 use crate::parsing::paths::strip_extension;
-use crate::parsing::resolution::{InheritanceResolver, ResolutionScope};
+use crate::parsing::resolution::{InheritanceResolver, RelativeImportLookup, ResolutionScope};
 use crate::project_resolver::persist::ResolutionPersistence;
 use crate::types::FileId;
 use crate::{SymbolId, Visibility};
@@ -343,9 +343,27 @@ impl LanguageBehavior for JavaScriptBehavior {
             // Path-domain arm first: relative specifiers resolve by file
             // identity (trait default). Module-string normalization cannot
             // represent the navigation when stems contain dots.
-            let file_resolved = importing_file.as_deref().and_then(|f| {
-                self.resolve_relative_import(cache, lookup_name, &import.path, f, extensions)
-            });
+            let lookup = importing_file
+                .as_deref()
+                .map_or(RelativeImportLookup::Unknown, |f| {
+                    self.resolve_relative_import(cache, lookup_name, &import.path, f, extensions)
+                });
+            // Boundary stated at the TypeScript builder: configured
+            // redirection withholds negative evidence.
+            let lookup = if lookup == RelativeImportLookup::NoIndexedFile
+                && maybe_enhancer
+                    .as_ref()
+                    .is_some_and(|e| e.redirects_relative_specifiers())
+            {
+                RelativeImportLookup::Unknown
+            } else {
+                lookup
+            };
+            let (file_resolved, dangling) = match lookup {
+                RelativeImportLookup::Bound(id) => (Some(id), false),
+                RelativeImportLookup::NoIndexedFile => (None, true),
+                RelativeImportLookup::Unknown => (None, false),
+            };
             let file_resolved_module = file_resolved
                 .and_then(|id| cache.get(id))
                 .and_then(|s| s.module_path.map(String::from));
@@ -389,10 +407,12 @@ impl LanguageBehavior for JavaScriptBehavior {
             // module_path. Exact match wins outright; segment-boundary
             // suffix matches bind only an exactly-one survivor (candidate
             // order is file-processing order, not identity; raw ends_with
-            // also admitted mid-segment captures).
+            // also admitted mid-segment captures). A dangling import's
+            // target file is provably absent, so no module-string match
+            // can be it.
             let mut resolved_symbol: Option<SymbolId> = file_resolved;
             let mut suffix_matches: Vec<SymbolId> = Vec::new();
-            if resolved_symbol.is_none() {
+            if resolved_symbol.is_none() && !dangling {
                 for id in cache.lookup_candidates(lookup_name) {
                     if let Some(symbol) = cache.get(id) {
                         if let Some(module) = symbol.module_path.as_deref() {
@@ -417,7 +437,9 @@ impl LanguageBehavior for JavaScriptBehavior {
             }
 
             // Determine origin
-            let origin = if resolved_symbol.is_some() {
+            let origin = if dangling {
+                ImportOrigin::Dangling
+            } else if resolved_symbol.is_some() {
                 ImportOrigin::Internal
             } else {
                 ImportOrigin::External

src/parsing/javascript/behavior.rs

@@ -44,6 +44,15 @@ pub struct CompilerOptions {
     /// Path mapping for module resolution
     #[serde(default)]
     pub paths: HashMap<String, Vec<String>>,
+
+    /// `moduleSuffixes`: a relative specifier may resolve to a suffixed
+    /// sibling (`./dep` naming `dep_native.ts`)
+    #[serde(default, rename = "moduleSuffixes")]
+    pub moduleSuffixes: Option<Vec<String>>,
+
+    /// `rootDirs`: a relative specifier may resolve across the listed roots
+    #[serde(default, rename = "rootDirs")]
+    pub rootDirs: Option<Vec<String>>,
 }
 
 /// Minimal jsconfig.json representation for path resolution
@@ -153,6 +162,14 @@ fn merge_jsconfig(parent: JsConfig, child: JsConfig) -> JsConfig {
                 merged.extend(child.compilerOptions.paths);
                 merged
             },
+            moduleSuffixes: child
+                .compilerOptions
+                .moduleSuffixes
+                .or(parent.compilerOptions.moduleSuffixes),
+            rootDirs: child
+                .compilerOptions
+                .rootDirs
+                .or(parent.compilerOptions.rootDirs),
         },
     }
 }
@@ -349,6 +366,9 @@ mod tests {
                     ("@parent/*".to_string(), vec!["parent/*".to_string()]),
                     ("@common/*".to_string(), vec!["parent/common/*".to_string()]),
                 ]),
+
+                moduleSuffixes: None,
+                rootDirs: None,
             },
         };
 
@@ -360,6 +380,9 @@ mod tests {
                     ("@child/*".to_string(), vec!["child/*".to_string()]),
                     ("@common/*".to_string(), vec!["child/common/*".to_string()]),
                 ]),
+
+                moduleSuffixes: None,
+                rootDirs: None,
             },
         };
 
@@ -407,6 +430,9 @@ mod tests {
             compilerOptions: CompilerOptions {
                 baseUrl: Some("./src".to_string()),
                 paths: HashMap::from([("@/*".to_string(), vec!["*".to_string()])]),
+
+                moduleSuffixes: None,
+                rootDirs: None,
             },
         };
 

src/parsing/javascript/jsconfig.rs

@@ -594,13 +594,16 @@ impl InheritanceResolver for JavaScriptInheritanceResolver {
 /// Applies jsconfig.json path mappings to transform import paths.
 /// Mirrors TypeScript's TypeScriptProjectEnhancer architecture.
 pub struct JavaScriptProjectEnhancer {
+    /// The governing config redirects relative specifiers
+    redirects_relative_specifiers: bool,
     /// Compiled path alias resolver (built from the resolution rules)
     resolver: Option<crate::parsing::javascript::jsconfig::PathAliasResolver>,
 }
 
 impl JavaScriptProjectEnhancer {
     /// Create a new enhancer from resolution rules
     pub fn new(rules: crate::project_resolver::persist::ResolutionRules) -> Self {
+        let redirects_relative_specifiers = rules.relative_specifiers_redirected;
         // Build the PathAliasResolver from rules
         let resolver = if !rules.paths.is_empty() || rules.base_url.is_some() {
             // Create a minimal JsConfig to use from_jsconfig
@@ -609,6 +612,9 @@ impl JavaScriptProjectEnhancer {
                 compilerOptions: crate::parsing::javascript::jsconfig::CompilerOptions {
                     baseUrl: rules.base_url.clone(),
                     paths: rules.paths.clone(),
+
+                    moduleSuffixes: None,
+                    rootDirs: None,
                 },
             };
 
@@ -618,7 +624,16 @@ impl JavaScriptProjectEnhancer {
             None
         };
 
-        Self { resolver }
+        Self {
+            redirects_relative_specifiers,
+            resolver,
+        }
+    }
+
+    /// Whether the governing config redirects relative specifiers
+    /// (`moduleSuffixes`, `rootDirs`).
+    pub fn redirects_relative_specifiers(&self) -> bool {
+        self.redirects_relative_specifiers
     }
 }