diffctx 1.14.0__tar.gz → 1.15.0__tar.gz

{diffctx-1.14.0 → diffctx-1.15.0}/CHANGELOG.md

@@ -7,6 +7,48 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- **Changed files that produced no fragments are disclosed in the md/text
+  output** ("Changed files not represented in the output"): a range whose
+  selection dropped some changed files no longer hides the gap — the footer
+  names exactly the changed files absent from the fragment list. Derived
+  from the already policy-clean `changed_files`, so withheld paths can never
+  appear in it.
+
+### Fixed
+
+- **Path-reference ambiguity cap counted duplicate index keys** (#207): every
+  file was indexed under its absolute AND repo-relative path, so
+  `MAX_FILES_PER_PATH_REF` (8) effectively halved, and host directory
+  components (`/home/runner/work/...`) matched references they had nothing
+  to do with. The index now carries one repo-relative posix entry per file.
+- **`<script>` type detection** (#213): `data-type="json"` no longer opts a
+  real JavaScript block out of parsing, and a legal MIME parameter
+  (`type="text/javascript; charset=utf-8"`) no longer degrades the block to
+  raw line windows.
+- **Scala import/package extraction gaps** (#215): Scala 3 renames
+  (`import a.b.C as D`, `a.{B as C}`) keep the original name, multi-line
+  brace imports keep their selectors, and nested package blocks no longer
+  concatenate sibling scopes into a nonexistent package.
+- **Rust `pub use` re-export registration no longer depends on file
+  iteration order** (#199): registration now runs after the definition maps
+  are complete, so a re-export defined in a later-iterated file still
+  resolves (`rust_027_arc_mutex` left the corpus baseline on this fix).
+- **The per-file budget ceiling now also gates signature substitution**
+  (#212): a file at its ceiling can no longer keep placing signature stubs
+  ahead of other files' cores.
+- **A signature stub substituted for a changed core renders as `changed`**
+  (#209): the stub shares the core's location, and both surfaces (pack render
+  and locate) now agree it carries the change, same as an excerpt. Ordinary
+  context signatures stay context.
+- **Config-key word boundaries treat non-ASCII bytes as word bytes** (#216):
+  a config key ending exactly where a non-ASCII letter begins (e.g. inside
+  `tokenización`) is no longer a match, restoring the Unicode-`\b` rejection
+  the Aho-Corasick rewrite lost.
+
+## [1.14.0] - 2026-08-16
+
 ### Fixed
 
 - **Changed secret-classified files (`id_rsa`, `*.key`, `*.pem`, …) are now
@@ -991,7 +1033,8 @@ Earlier releases shipped as `treemapper`; see
 <https://github.com/nikolay-e/diffctx/releases> for the corresponding GitHub
 release notes (`1.0.0` through `1.6.1`).
 
-[Unreleased]: https://github.com/nikolay-e/diffctx/compare/v1.13.0...HEAD
+[Unreleased]: https://github.com/nikolay-e/diffctx/compare/v1.14.0...HEAD
+[1.14.0]: https://github.com/nikolay-e/diffctx/compare/v1.13.0...v1.14.0
 [1.13.0]: https://github.com/nikolay-e/diffctx/compare/v1.12.3...v1.13.0
 [1.12.3]: https://github.com/nikolay-e/diffctx/compare/v1.12.2...v1.12.3
 [1.12.2]: https://github.com/nikolay-e/diffctx/compare/v1.12.1...v1.12.2

{diffctx-1.14.0 → diffctx-1.15.0}/Cargo.lock

@@ -194,7 +194,7 @@ checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
 [[package]]
 name = "diffctx"
-version = "1.14.0"
+version = "1.15.0"
 dependencies = [
  "aho-corasick",
  "anyhow",

{diffctx-1.14.0 → diffctx-1.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diffctx
-Version: 1.14.0
+Version: 1.15.0
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{diffctx-1.14.0 → diffctx-1.15.0}/crates/diffctx-native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "diffctx"
-version = "1.14.0"
+version = "1.15.0"
 edition = "2024"
 rust-version = "1.85"
 description = "Selects the minimum code an LLM needs to review a git diff: walks the dependency graph outward from changed lines and stops when extra context stops paying for itself"

{diffctx-1.14.0 → diffctx-1.15.0}/crates/diffctx-native/src/edges/base.rs

@@ -97,8 +97,8 @@ pub struct FragmentIndex {
     /// interior) requires each reference component to appear as a whole path
     /// component, so the last component is a complete candidate filter. Each
     /// entry carries the file's representative fragment: a path reference is a
-    /// file-level relation, and the containment star spreads its mass inside
-    /// the file.
+    /// file-level relation and endorses the file, not each sibling (see
+    /// `file_representatives` on the accepted reachability trade, #208).
     lower_paths: Vec<(String, FragmentId)>,
     component_to_paths: FxHashMap<String, Vec<u32>>,
 }
@@ -136,18 +136,29 @@ impl FragmentIndex {
             }
         }
 
+        // One entry per FILE, keyed on the repo-relative posix path (the form
+        // path references are written in). Indexing every `by_path` variant put
+        // the same file under 2-3 keys, so `MAX_FILES_PER_PATH_REF` counted
+        // duplicate keys and silently halved (#207) — and the absolute keys'
+        // host directory components (`/home/runner/work/...`) matched
+        // references they had nothing to do with.
         let reps = file_representatives(fragments);
-        let mut lower_paths: Vec<(String, FragmentId)> = Vec::with_capacity(by_path.len());
+        let mut lower_paths: Vec<(String, FragmentId)> = Vec::with_capacity(reps.len());
         let mut component_to_paths: FxHashMap<String, Vec<u32>> = FxHashMap::default();
-        for (path_str, ids) in &by_path {
-            // Every id under one path key belongs to one file; its
-            // representative is looked up by the id's own (canonical) path,
-            // which also covers the relative-variant keys.
-            let Some(rep) = ids.first().and_then(|id| reps.get(id.path.as_ref())) else {
+        let mut indexed_files: FxHashSet<&str> = FxHashSet::default();
+        for f in fragments {
+            if !indexed_files.insert(f.path()) {
+                continue;
+            }
+            let Some(rep) = reps.get(f.path()) else {
                 continue;
             };
+            let matchable = repo_root
+                .and_then(|root| Path::new(f.path()).strip_prefix(root).ok())
+                .map(|rel| rel.to_string_lossy().replace('\\', "/"))
+                .unwrap_or_else(|| f.path().replace('\\', "/"));
             let idx = lower_paths.len() as u32;
-            let lower = path_str.to_lowercase();
+            let lower = matchable.to_lowercase();
             for comp in lower.split('/').filter(|c| !c.is_empty()) {
                 let posting = component_to_paths.entry(comp.to_string()).or_default();
                 if posting.last() != Some(&idx) {
@@ -174,8 +185,11 @@ impl FragmentIndex {
 /// change endorsing a file diffusely must not outweigh a call edge naming one
 /// symbol — the fragment-pair encoding gave both the same weight, which is
 /// simultaneously the quadratic edge blow-up (envoy: 22M c-family edges) and
-/// the file-level noise mechanism of #65. Reachability of the file's other
-/// fragments is the containment star's job.
+/// the file-level noise mechanism of #65. The file's other fragments are
+/// reachable only through nesting and naming edges — the intra-file star is
+/// OFF by default and measured net-negative on the corpus (#208) — an
+/// accepted trade: a file-level relation endorses the file, not each of its
+/// siblings.
 pub fn file_representatives(fragments: &[Fragment]) -> FxHashMap<String, FragmentId> {
     let mut file_to_rep: FxHashMap<String, FragmentId> = FxHashMap::default();
     let mut file_to_token_count: FxHashMap<String, u32> = FxHashMap::default();
@@ -498,4 +512,43 @@ mod tests {
         let hit = linked_paths("pkg/api", &paths);
         assert_eq!(hit, vec!["pkg/api/server.go".to_string()]);
     }
+
+    fn linked_paths_rooted(reference: &str, root: &str, paths: &[&str]) -> Vec<String> {
+        let frags: Vec<Fragment> = paths.iter().map(|p| frag(p)).collect();
+        let idx = FragmentIndex::new(&frags, Some(Path::new(root)));
+        let src = frag("/ci/work/repo/src/origin.yml");
+        let mut edges: EdgeDict = FxHashMap::default();
+        link_by_path_match(&src.id, reference, &idx, &mut edges, 0.5, 0.5);
+        let mut out: Vec<String> = edges
+            .keys()
+            .map(|(_, dst)| dst.path.to_string())
+            .filter(|p| p != src.id.path.as_ref())
+            .collect();
+        out.sort();
+        out.dedup();
+        out
+    }
+
+    #[test]
+    fn the_ambiguity_cap_counts_distinct_files_not_index_keys() {
+        // 5 distinct files under a rooted index: the pre-#207 code indexed
+        // each under its absolute AND relative key, so matched.len() was 10
+        // and the cap (8) dropped a reference naming only 5 files.
+        let paths: Vec<String> = (0..5)
+            .map(|i| format!("/ci/work/repo/lib/util/mod_{i}.py"))
+            .collect();
+        let refs: Vec<&str> = paths.iter().map(String::as_str).collect();
+        let hit = linked_paths_rooted("lib/util", "/ci/work/repo", &refs);
+        assert_eq!(hit.len(), 5, "cap must count files, not duplicate keys");
+    }
+
+    #[test]
+    fn host_directory_components_are_not_matchable() {
+        let paths = ["/ci/work/repo/src/app.rs", "/ci/work/repo/src/db.rs"];
+        let hit = linked_paths_rooted("work", "/ci/work/repo", &paths);
+        assert!(
+            hit.is_empty(),
+            "components outside the repo root must not resolve a reference"
+        );
+    }
 }

{diffctx-1.14.0 → diffctx-1.15.0}/crates/diffctx-native/src/edges/config_edges/generic.rs

@@ -170,7 +170,13 @@ fn extract_config_keys(suffix: &str, content: &str) -> FxHashSet<String> {
 }
 
 fn is_word_byte(b: u8) -> bool {
-    b.is_ascii_alphanumeric() || b == b'_'
+    // Non-ASCII bytes count as word bytes: the regex `\b` this check replaced
+    // treats a Unicode letter as a word character, so `token` inside
+    // `tokenización` was NOT a match (#216). Treating every non-ASCII byte as
+    // a word byte is the conservative direction — it can only reject matches
+    // adjacent to non-ASCII punctuation that `\b` would have accepted, never
+    // admit ones it rejected.
+    b.is_ascii_alphanumeric() || b == b'_' || !b.is_ascii()
 }
 
 fn build_key_patterns(keys: &FxHashSet<String>) -> Vec<Regex> {
@@ -403,3 +409,41 @@ impl EdgeBuilder for ConfigToCodeEdgeBuilder {
         discovered
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::types::{FragmentId, FragmentKind};
+    use std::sync::Arc;
+
+    fn frag(path: &str, content: &str) -> Fragment {
+        Fragment {
+            id: FragmentId::new(Arc::from(path), 1, 5),
+            kind: FragmentKind::Chunk,
+            content: Arc::from(content),
+            identifiers: FxHashSet::default(),
+            token_count: 10,
+            symbol_name: None,
+        }
+    }
+
+    /// #216: the manual boundary check replaced the regex crate's Unicode
+    /// `\b`, which treats a non-ASCII letter as a word character. A key ending
+    /// exactly where a non-ASCII letter begins is NOT a whole-word match.
+    #[test]
+    fn a_key_inside_a_non_ascii_word_is_not_a_match() {
+        let cfg = frag("app.yaml", "sesion_timeout: 30\n");
+        let hit = frag("b.py", "sesion = abrir()\n");
+        let miss = frag("a.py", "valor = sesion\u{00e9}s\n");
+        let frags = vec![cfg.clone(), hit.clone(), miss.clone()];
+        let edges = ConfigToCodeEdgeBuilder.build(&frags, None);
+        assert!(
+            edges.contains_key(&(cfg.id.clone(), hit.id.clone())),
+            "a standalone key occurrence must still link"
+        );
+        assert!(
+            !edges.contains_key(&(cfg.id.clone(), miss.id.clone())),
+            "`sesion` inside `sesion\u{00e9}s` is not a word match"
+        );
+    }
+}

{diffctx-1.14.0 → diffctx-1.15.0}/crates/diffctx-native/src/edges/semantic/c_family.rs

@@ -172,8 +172,8 @@ impl EdgeBuilder for CFamilyEdgeBuilder {
 
         // An include names a file, so its edge lands on the file's
         // representative fragment (base::file_representatives — the sibling
-        // builder's long-standing semantics); the containment star carries the
-        // mass to the rest of the file. Buckets therefore hold file paths, and
+        // builder's long-standing semantics; see its doc on the accepted
+        // reachability trade, #208). Buckets therefore hold file paths, and
         // ambiguity is measured in files: a basename repeated across the tree
         // is what makes an include unresolvable.
         // Representatives keyed off the full slice: is_c_family is per-path, so
@@ -362,8 +362,9 @@ impl EdgeBuilder for CFamilyEdgeBuilder {
         }
 
         // A header/impl pair is a relation between two files; representatives
-        // carry it, the containment star spreads it. Pairing every fragment
-        // with every fragment restated the same fact quadratically.
+        // carry it (see base::file_representatives on the accepted
+        // reachability trade, #208). Pairing every fragment with every
+        // fragment restated the same fact quadratically.
         for (i, (_key, (files, _))) in by_stem.iter().enumerate() {
             crate::deadline::check_current_every(i, 256, "edge construction (c_family pairing)");
             if files.len() < 2 {

{diffctx-1.14.0 → diffctx-1.15.0}/crates/diffctx-native/src/edges/semantic/jvm.rs

@@ -187,10 +187,15 @@ fn parse_scala_import_clause(clause: &str) -> Option<ScalaImport> {
         let mut selectors = Vec::new();
         let mut wildcard = false;
         for sel in inner.split(',') {
+            // A rename keeps the ORIGINAL name — that is what the target file
+            // defines. Scala 2 spells it `C => D`, Scala 3 `C as D`.
             let name = sel
                 .split("=>")
                 .next()
                 .unwrap_or("")
+                .split(" as ")
+                .next()
+                .unwrap_or("")
                 .trim()
                 .trim_matches('`');
             match name {
@@ -211,6 +216,8 @@ fn parse_scala_import_clause(clause: &str) -> Option<ScalaImport> {
             wildcard,
         });
     }
+    // Scala 3 top-level rename: `import a.b.c as d` imports `a.b.c`.
+    let clause = clause.split(" as ").next().unwrap_or(clause).trim();
     if let Some(p) = clause
         .strip_suffix("._")
         .or_else(|| clause.strip_suffix(".*"))
@@ -248,9 +255,30 @@ fn parse_scala_import_clause(clause: &str) -> Option<ScalaImport> {
 
 fn parse_scala_imports(content: &str) -> Vec<ScalaImport> {
     let mut out = Vec::new();
-    for cap in SCALA_IMPORT_LINE_RE.captures_iter(content) {
-        let rest = cap[1].split("//").next().unwrap_or("").trim();
-        for clause in split_top_level_commas(rest) {
+    let mut lines = content.lines();
+    while let Some(line) = lines.next() {
+        let Some(cap) = SCALA_IMPORT_LINE_RE.captures(line) else {
+            continue;
+        };
+        let mut clause_text = cap[1].split("//").next().unwrap_or("").trim().to_string();
+        // A brace group may span lines; join until the braces balance so
+        // `import scala.collection.{\n mutable,\n immutable\n}` keeps its
+        // selectors instead of yielding an empty list.
+        let mut open = clause_text.matches('{').count();
+        let mut close = clause_text.matches('}').count();
+        let mut joined = 0;
+        // The join is bounded so an unbalanced brace (a file mid-edit) cannot
+        // swallow the rest of the file into one clause.
+        while open > close && joined < 32 {
+            joined += 1;
+            let Some(next) = lines.next() else { break };
+            let next = next.split("//").next().unwrap_or("").trim();
+            open += next.matches('{').count();
+            close += next.matches('}').count();
+            clause_text.push(' ');
+            clause_text.push_str(next);
+        }
+        for clause in split_top_level_commas(&clause_text) {
             if let Some(imp) = parse_scala_import_clause(clause) {
                 out.push(imp);
             }
@@ -315,7 +343,10 @@ fn extract_package(content: &str, path: &Path) -> Option<String> {
     if is_scala(path) {
         // Scala chains package clauses (`package com.acme` then `package svc`
         // means com.acme.svc); `package object x` is a member of the enclosing
-        // package, not a chain segment.
+        // package, not a chain segment. A block-form clause (`package util {`)
+        // opens a scope whose SIBLINGS are not chain segments — concatenating
+        // past it produced nonexistent packages (`com.example.util.data`), so
+        // the chain stops at the first block.
         let mut parts: Vec<String> = Vec::new();
         for cap in SCALA_PACKAGE_RE.captures_iter(content) {
             let seg = &cap[1];
@@ -323,6 +354,10 @@ fn extract_package(content: &str, path: &Path) -> Option<String> {
                 continue;
             }
             parts.push(seg.to_string());
+            let after = content[cap.get(0).map_or(0, |m| m.end())..].trim_start();
+            if after.starts_with('{') {
+                break;
+            }
         }
         if parts.is_empty() {
             None
@@ -875,6 +910,40 @@ mod tests {
         assert!(object_rooted.wildcard);
     }
 
+    #[test]
+    fn scala3_renames_keep_the_original_name() {
+        let top = parse_one("a.b.Conf as Config");
+        assert_eq!(top.prefix, "a.b");
+        assert_eq!(top.selectors, vec!["Conf".to_string()]);
+
+        let braced = parse_one("a.{B as C, D}");
+        assert_eq!(braced.prefix, "a");
+        assert_eq!(braced.selectors, vec!["B".to_string(), "D".to_string()]);
+    }
+
+    #[test]
+    fn scala_multiline_brace_import_keeps_its_selectors() {
+        let content = "import scala.collection.{\n  mutable,\n  immutable\n}\nimport a.B\n";
+        let imports = parse_scala_imports(content);
+        assert_eq!(imports.len(), 2);
+        assert_eq!(imports[0].prefix, "scala.collection");
+        assert_eq!(
+            imports[0].selectors,
+            vec!["mutable".to_string(), "immutable".to_string()]
+        );
+        assert_eq!(imports[1].selectors, vec!["B".to_string()]);
+    }
+
+    #[test]
+    fn scala_nested_package_blocks_do_not_concatenate_siblings() {
+        let content =
+            "package com.example\npackage util {\n  class A\n}\npackage data {\n  class B\n}\n";
+        assert_eq!(
+            extract_package(content, Path::new("a.scala")),
+            Some("com.example.util".to_string())
+        );
+    }
+
     #[test]
     fn scala_chained_packages_join_and_package_object_is_skipped() {
         let content = "package com.acme\npackage service\n\nclass X {}\n";

{diffctx-1.14.0 → diffctx-1.15.0}/crates/diffctx-native/src/edges/semantic/rust_lang.rs

@@ -259,25 +259,34 @@ impl EdgeBuilder for RustEdgeBuilder {
             if !impls.is_empty() {
                 trait_impls.insert(f.id.clone(), impls);
             }
+        }
 
+        // Re-export registration runs over the COMPLETE definition maps:
+        // inline in the loop above it saw only files iterated before the
+        // re-exporting one, so which `pub use` leaves resolved depended on
+        // file iteration order (#199). Registrations are collected before
+        // insertion so re-exporters do not shadow each other either.
+        let mut pub_use_regs: Vec<(String, FragmentId)> = Vec::new();
+        for f in &rust_frags {
             for pub_use_path in extract_pub_uses(&f.content) {
                 let leaf_lower = pub_use_path.split("::").last().unwrap_or("").to_lowercase();
-                if !leaf_lower.is_empty() && !name_to_frags.contains_key(&leaf_lower) {
-                    let has_target = type_defs
+                if leaf_lower.is_empty() || name_to_frags.contains_key(&leaf_lower) {
+                    continue;
+                }
+                let has_target = type_defs
+                    .get(&leaf_lower)
+                    .map_or(false, |v| v.iter().any(|fid| fid != &f.id))
+                    || fn_defs
                         .get(&leaf_lower)
-                        .map_or(false, |v| v.iter().any(|fid| fid != &f.id))
-                        || fn_defs
-                            .get(&leaf_lower)
-                            .map_or(false, |v| v.iter().any(|fid| fid != &f.id));
-                    if has_target {
-                        name_to_frags
-                            .entry(leaf_lower)
-                            .or_default()
-                            .push(f.id.clone());
-                    }
+                        .map_or(false, |v| v.iter().any(|fid| fid != &f.id));
+                if has_target {
+                    pub_use_regs.push((leaf_lower, f.id.clone()));
                 }
             }
         }
+        for (leaf_lower, fid) in pub_use_regs {
+            name_to_frags.entry(leaf_lower).or_default().push(fid);
+        }
 
         let mut edges: EdgeDict = FxHashMap::default();
         // Same ambiguity bar as CFamilySemanticWeights::max_files_per_name: a
@@ -520,3 +529,41 @@ impl EdgeBuilder for RustEdgeBuilder {
         result
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::types::FragmentKind;
+
+    fn frag(path: &str, content: &str) -> Fragment {
+        Fragment {
+            id: FragmentId::new(std::sync::Arc::from(path), 1, 20),
+            kind: FragmentKind::Function,
+            content: std::sync::Arc::from(content),
+            identifiers: FxHashSet::default(),
+            token_count: 20,
+            symbol_name: None,
+        }
+    }
+
+    #[test]
+    fn pub_use_registration_does_not_depend_on_file_iteration_order() {
+        // The re-exporting file iterates FIRST, the defining file after it —
+        // exactly the order that dropped the registration before #199.
+        let facade = frag("src/facade.rs", "pub use detail::WidgetFactory;\n");
+        let detail = frag(
+            "src/z_detail.rs",
+            "pub struct WidgetFactory {\n    size: u32,\n}\n",
+        );
+        let consumer = frag(
+            "src/consumer.rs",
+            "use crate::api::WidgetFactory;\n\nfn run() {}\n",
+        );
+        let frags = vec![facade.clone(), detail, consumer.clone()];
+        let edges = RustEdgeBuilder.build(&frags, None);
+        assert!(
+            edges.contains_key(&(consumer.id.clone(), facade.id.clone())),
+            "a use of the re-exported leaf must resolve to the re-exporting file"
+        );
+    }
+}

{diffctx-1.14.0 → diffctx-1.15.0}/crates/diffctx-native/src/edges/structural/containment.rs

@@ -22,7 +22,15 @@ impl EdgeBuilder for ContainmentEdgeBuilder {
 
         let mut edges: EdgeDict = FxHashMap::default();
 
-        let reps = super::super::base::file_representatives(fragments);
+        // Computed only for the experimental star below — OFF by default, and
+        // measured net-negative when ON (#208): 21 corpus regressions vs 14
+        // improvements, 2026-08-16 A/B at shipped defaults.
+        let star_on = std::env::var_os("DIFFCTX_FILE_STAR").is_some();
+        let reps = if star_on {
+            super::super::base::file_representatives(fragments)
+        } else {
+            FxHashMap::default()
+        };
 
         for (path, frags) in &by_path {
             if frags.len() < 2 {
@@ -58,13 +66,13 @@ impl EdgeBuilder for ContainmentEdgeBuilder {
                 stack.push(f);
             }
 
-            // The nesting pass only connects a fragment to what encloses it,
-            // so a file's top-level fragments were mutually unreachable. The
-            // star through the file representative gives every file an
-            // intra-file spine — linear in fragment count — which is what
-            // lets file-level relations (includes, path references, pairing)
-            // link representatives instead of full fragment cross products.
-            if std::env::var_os("DIFFCTX_FILE_STAR").is_some() {
+            // Experimental intra-file spine: connects every fragment to the
+            // file representative so top-level siblings become mutually
+            // reachable. Ships OFF — the 2026-08-16 corpus A/B measured it
+            // net-negative (#208) — so by default a flat file's siblings are
+            // reachable only through nesting and naming edges, and the
+            // representative-only builders accept that.
+            if star_on {
                 if let Some(rep) = reps.get(*path) {
                     for f in &sorted {
                         if f.id != *rep {

{diffctx-1.14.0 → diffctx-1.15.0}/crates/diffctx-native/src/edges/structural/testing.rs

@@ -120,8 +120,8 @@ impl EdgeBuilder for TestEdgeBuilder {
         let mut edges: EdgeDict = FxHashMap::default();
 
         // The naming convention names a FILE, so the relation is carried by
-        // the two files' representatives (base::file_representatives) and the
-        // containment star spreads it within each file. One pair per
+        // the two files' representatives (base::file_representatives; see its
+        // doc on the accepted reachability trade, #208). One pair per
         // (test file, source file), not per fragment pair.
         let mut linked_file_pairs: FxHashSet<(&str, &str)> = FxHashSet::default();
 

{diffctx-1.14.0 → diffctx-1.15.0}/crates/diffctx-native/src/locate.rs

@@ -226,13 +226,28 @@ fn rel_path(state: &ScoredState, path: &str) -> String {
         .unwrap_or_else(|| crate::paths::to_posix_display(std::borrow::Cow::Borrowed(path)))
 }
 
+/// Same predicate on both surfaces (pack render agrees via
+/// `render::carries_changed_role`): the fragment is a core, an excerpt
+/// stand-in, or a signature stub substituted at a core's location (#209).
+fn carries_change(
+    state: &ScoredState,
+    frag: &Fragment,
+    core_locs: &rustc_hash::FxHashSet<(std::sync::Arc<str>, u32)>,
+) -> bool {
+    state.core_ids.contains(&frag.id)
+        || frag.kind == crate::types::FragmentKind::Excerpt
+        || (frag.kind.is_signature()
+            && core_locs.contains(&(frag.id.path.clone(), frag.id.start_line)))
+}
+
 fn reasons_for(
     state: &ScoredState,
     frag: &Fragment,
+    core_locs: &rustc_hash::FxHashSet<(std::sync::Arc<str>, u32)>,
     hops: Option<u32>,
     attribution: Option<&Vec<(String, String, f64)>>,
 ) -> Vec<Reason> {
-    if state.core_ids.contains(&frag.id) || frag.kind == crate::types::FragmentKind::Excerpt {
+    if carries_change(state, frag, core_locs) {
         return vec![Reason::Changed];
     }
     let mut reasons: Vec<Reason> = Vec::new();
@@ -456,12 +471,12 @@ pub fn build_locate(state: &ScoredState, outcome: &SelectionOutcome) -> LocateOu
     let attribution = incoming_attribution(state);
     let (overflow, overflow_count, next_up) = build_overflow(state, outcome, &hops, &attribution);
 
+    let core_locs = crate::render::core_substitute_locs(&state.core_ids);
     let items: Vec<LocateItem> = outcome
         .selected
         .iter()
         .map(|frag| {
-            let is_changed = state.core_ids.contains(&frag.id)
-                || frag.kind == crate::types::FragmentKind::Excerpt;
+            let is_changed = carries_change(state, frag, &core_locs);
             let path = rel_path(state, frag.id.path.as_ref());
             let group = group_of(&path, frag.kind);
             LocateItem {
@@ -479,6 +494,7 @@ pub fn build_locate(state: &ScoredState, outcome: &SelectionOutcome) -> LocateOu
                 reasons: reasons_for(
                     state,
                     frag,
+                    &core_locs,
                     hops.get(&frag.id).copied(),
                     attribution.get(&frag.id),
                 ),