From 5c8aebc9f2abdbb369730334d6e042e3575e5b25 Mon Sep 17 00:00:00 2001
From: Andre Brait <andrebrait@gmail.com>
Date: Sat, 12 Sep 2026 20:40:10 +0000
Subject: [PATCH 1/3] fix(config): honor declared languages in extraction and
 imports

---
 graphify/extract.py                     |  59 ++++---
 graphify/extractors/csharp.py           |  13 +-
 graphify/extractors/ocaml.py            |   3 +-
 graphify/extractors/resolution.py       |  82 ++++++++--
 graphify/extractors/robot.py            |   3 +-
 graphify/symbol_resolution.py           |   5 +-
 tests/test_language_override_imports.py | 178 ++++++++++++++++++++
 tests/test_language_overrides.py        | 208 ++++++++++++++++++++++++
 8 files changed, 495 insertions(+), 56 deletions(-)
 create mode 100644 tests/test_language_override_imports.py

diff --git a/graphify/extract.py b/graphify/extract.py
index 735520e951..0badb6c7e0 100644
--- a/graphify/extract.py
+++ b/graphify/extract.py
@@ -96,6 +96,7 @@
     _disambiguate_colliding_node_ids,
     _find_workspace_root,
     _go_import_path_for_file,
+    _is_python_package_dir,
     _is_type_like_definition,
     _js_call_identifier,
     _js_default_export_name,
@@ -213,7 +214,7 @@ def _repoint_python_package_imports(paths, all_nodes, all_edges, root) -> None:
     the edge dangles and is silently dropped — the graph loses most ``imports``
     edges purely because of where the scan started. Build an alias map from the
     dotted-module id to the real file-node id by detecting each ``.py`` file's
-    package root (the contiguous run of ancestor dirs carrying ``__init__.py``)
+    package root (the contiguous run of ancestor dirs carrying a Python initializer)
     and rewrite matching ``imports``/``imports_from`` edge targets. Guards: never
     shadow an existing node id, and drop an alias claimed by more than one file
     (ambiguous -> leave dangling, as before). Files whose package root IS the
@@ -225,7 +226,7 @@ def _repoint_python_package_imports(paths, all_nodes, all_edges, root) -> None:
     node_ids = {n.get("id") for n in all_nodes if isinstance(n, dict)}
     alias_to_files: dict[str, set[str]] = {}
     for p in paths:
-        if p.suffix.lower() not in (".py", ".pyi"):
+        if effective_suffix(p).lower() not in (".py", ".pyi"):
             continue
         try:
             rel = Path(p).resolve().relative_to(root)
@@ -238,7 +239,7 @@ def _repoint_python_package_imports(paths, all_nodes, all_edges, root) -> None:
         levels = 0
         # Bounded by the number of dirs between the file and the scan root, so a
         # pathological `/__init__.py` chain can't loop forever.
-        while levels < len(parts) - 1 and (d / "__init__.py").is_file():
+        while levels < len(parts) - 1 and _is_python_package_dir(d):
             levels += 1
             d = d.parent
         if levels == 0:
@@ -249,7 +250,11 @@ def _repoint_python_package_imports(paths, all_nodes, all_edges, root) -> None:
         file_node = _file_node_id(rel)
         alias = _make_id(str(Path(*mod_parts).with_suffix("")))
         alias_to_files.setdefault(alias, set()).add(file_node)
-        if p.name in ("__init__.py", "__init__.pyi") and len(mod_parts) > 1:
+        if (
+            p.stem == "__init__"
+            and effective_suffix(p) in (".py", ".pyi")
+            and len(mod_parts) > 1
+        ):
             # `import pkg` / `from pkg import x` targets the package-dir id.
             pkg_alias = _make_id(str(Path(*mod_parts[:-1])))
             alias_to_files.setdefault(pkg_alias, set()).add(file_node)
@@ -268,7 +273,7 @@ def _repoint_python_package_imports(paths, all_nodes, all_edges, root) -> None:
         if (
             isinstance(e, dict)
             and e.get("relation") in ("imports", "imports_from")
-            and str(e.get("source_file", "")).lower().endswith((".py", ".pyi"))
+            and effective_suffix(str(e.get("source_file", ""))).lower() in (".py", ".pyi")
         ):
             tgt = e.get("target")
             if tgt in alias_map:
@@ -277,10 +282,10 @@ def _repoint_python_package_imports(paths, all_nodes, all_edges, root) -> None:
 
 def _repoint_python_sibling_imports(paths, all_nodes, all_edges, root) -> None:
     """Repoint Python sibling-import edges to the real file node in directories
-    without an __init__.py (#3430).
+    without a Python package initializer (#3430).
 
     When a Python file below the scan root lives in a non-package directory
-    (no __init__.py in its immediate parent), plain imports of same-directory
+    (no package initializer in its immediate parent), plain imports of same-directory
     modules (e.g. `scripts/main.py: import greeter`) target a bare name (`greeter`),
     while the real file node is scan-root-relative (`scripts_greeter`). Because
     the directory is not a package, `_repoint_python_package_imports` skips it
@@ -288,7 +293,7 @@ def _repoint_python_sibling_imports(paths, all_nodes, all_edges, root) -> None:
     (`greeter.greet()`) to be dropped.
 
     This pass is strictly importer-directory-local:
-    - Only applies when the importing file's parent directory has no __init__.py.
+    - Only applies when the importing file's parent directory has no package initializer.
     - Resolves only to unambiguous same-directory candidate modules in the scanned corpus.
     - Never builds a global alias map and never searches outside the importer's directory.
     - Preserves local aliases (e.g. `import greeter as g`).
@@ -304,7 +309,7 @@ def _repoint_python_sibling_imports(paths, all_nodes, all_edges, root) -> None:
     # dir_path -> {module_name_id: set_of_file_node_ids}
     dir_siblings: dict[Path, dict[str, set[str]]] = {}
     for p in paths:
-        if p.suffix.lower() not in (".py", ".pyi"):
+        if effective_suffix(p).lower() not in (".py", ".pyi"):
             continue
         try:
             p_res = Path(p).resolve()
@@ -316,11 +321,11 @@ def _repoint_python_sibling_imports(paths, all_nodes, all_edges, root) -> None:
         if file_node not in node_ids:
             continue
 
-        if p_res.name in ("__init__.py", "__init__.pyi"):
+        if p_res.stem == "__init__" and effective_suffix(p_res) in (".py", ".pyi"):
             # Sibling package directory inside parent_dir (parent_dir / subpkg / __init__.py)
             pkg_dir = p_res.parent
             parent_dir = pkg_dir.parent
-            if not (parent_dir / "__init__.py").is_file() and not (parent_dir / "__init__.pyi").is_file():
+            if not _is_python_package_dir(parent_dir, (".py", ".pyi")):
                 mod_key = _make_id(pkg_dir.name)
                 dir_siblings.setdefault(parent_dir, {}).setdefault(mod_key, set()).add(file_node)
             continue
@@ -328,7 +333,7 @@ def _repoint_python_sibling_imports(paths, all_nodes, all_edges, root) -> None:
         d = p_res.parent
         # PEP 328 guard: if the directory is a package, implicit relative imports
         # are forbidden in Python 3. Do not index packages as loose sibling directories.
-        if (d / "__init__.py").is_file() or (d / "__init__.pyi").is_file():
+        if _is_python_package_dir(d, (".py", ".pyi")):
             continue
 
         mod_key = _make_id(p_res.stem)
@@ -351,7 +356,7 @@ def _repoint_python_sibling_imports(paths, all_nodes, all_edges, root) -> None:
         if not (
             isinstance(e, dict)
             and e.get("relation") in ("imports", "imports_from")
-            and str(e.get("source_file", "")).lower().endswith((".py", ".pyi"))
+            and effective_suffix(str(e.get("source_file", ""))).lower() in (".py", ".pyi")
         ):
             continue
 
@@ -1700,7 +1705,7 @@ def extract_python(path: Path) -> dict:
 
 def extract_js(path: Path) -> dict:
     """Extract classes, functions, arrow functions, and imports from a .js/.ts/.tsx/.mts/.cts file."""
-    suffix = path.suffix.lower()
+    suffix = effective_suffix(path).lower()
     is_ts = suffix in (".ts", ".tsx", ".mts", ".cts")
     if suffix == ".tsx":
         config = _TSX_CONFIG
@@ -6148,7 +6153,7 @@ def _extract_single_file(args: tuple) -> tuple[int, dict]:
     root = Path(root_str)
     cache_location = Path(cache_location_str)
     _raise_recursion_limit()
-    bypass_cache = path.suffix in _JS_CACHE_BYPASS_SUFFIXES
+    bypass_cache = effective_suffix(path) in _JS_CACHE_BYPASS_SUFFIXES
 
     # Check cache first (avoid re-extraction)
     if not bypass_cache:
@@ -6341,7 +6346,7 @@ def _extract_sequential(
         if extractor is None:
             per_file[idx] = {"nodes": [], "edges": []}
             continue
-        bypass_cache = path.suffix in _JS_CACHE_BYPASS_SUFFIXES
+        bypass_cache = effective_suffix(path) in _JS_CACHE_BYPASS_SUFFIXES
         # XAML boundary anchors on `root` (the corpus), not the cache location.
         result = _safe_extract_with_xaml_root(extractor, path, root)
         # See _extract_single_file: don't cache an anomalous zero-node result (#1666).
@@ -6486,7 +6491,7 @@ def extract(
         if _get_extractor(path) is None:
             per_file[i] = {"nodes": [], "edges": []}
             continue
-        bypass_cache = path.suffix in _JS_CACHE_BYPASS_SUFFIXES
+        bypass_cache = effective_suffix(path) in _JS_CACHE_BYPASS_SUFFIXES
         if not bypass_cache:
             cached = load_cached(path, root, cache_root=cache_location, salt=cache_salt(path))
             if cached is not None:
@@ -6578,7 +6583,7 @@ def extract(
     from graphify.detect import CODE_EXTENSIONS as _CODE_EXTS
     _no_extractor: dict[str, int] = {}
     for _p in paths:
-        _ext = _p.suffix.lower()
+        _ext = effective_suffix(_p).lower()
         if _ext in _CODE_EXTS and _get_extractor(_p) is None:
             _no_extractor[_ext] = _no_extractor.get(_ext, 0) + 1
     if _no_extractor:
@@ -6605,7 +6610,7 @@ def extract(
     for i, _p in enumerate(paths):
         _err = (per_file[i] or {}).get("error") or ""
         if _DEP_MISSING_MARKER in _err or _DEP_LOAD_FAILED_MARKER in _err:
-            _ext = _p.suffix.lower()
+            _ext = effective_suffix(_p).lower()
             _missing_dep_count[_ext] = _missing_dep_count.get(_ext, 0) + 1
             _missing_dep_error.setdefault(_ext, _err)
     for _ext, _n in sorted(_missing_dep_count.items(), key=lambda kv: (-kv[1], kv[0])):
@@ -7144,7 +7149,7 @@ def _learn(e: dict) -> None:
     # internal class with that simple name, manufacturing a false hub. Parking
     # such references on an FQN-labeled stub first prevents the merge, and
     # import-exact resolution of internal references (#1318/#1744) still applies.
-    _java_sel = [(r, p) for r, p in zip(per_file, paths) if p.suffix == ".java"]
+    _java_sel = [(r, p) for r, p in zip(per_file, paths) if effective_suffix(p) == ".java"]
     if _java_sel:
         try:
             _resolve_java_type_references(
@@ -7155,7 +7160,7 @@ def _learn(e: dict) -> None:
             logging.getLogger(__name__).warning("Java type-reference resolution failed, skipping: %s", exc)
     # Resolve internal Go pkg.Type references exactly and park external ones
     # before the generic bare-label stub rewire can manufacture a collision.
-    _go_sel = [(r, p) for r, p in zip(per_file, paths) if p.suffix == ".go"]
+    _go_sel = [(r, p) for r, p in zip(per_file, paths) if effective_suffix(p) == ".go"]
     if _go_sel:
         try:
             _resolve_go_type_references(
@@ -7169,9 +7174,9 @@ def _learn(e: dict) -> None:
                 "Go type-reference resolution failed, skipping: %s", exc
             )
     # Cross-file Python import resolution and type-reference repointing (#3252)
-    py_paths = [p for p in paths if p.suffix == ".py"]
+    py_paths = [p for p in paths if effective_suffix(p) == ".py"]
     if py_paths:
-        py_results = [r for r, p in zip(per_file, paths) if p.suffix == ".py"]
+        py_results = [r for r, p in zip(per_file, paths) if effective_suffix(p) == ".py"]
         try:
             cross_file_edges = _resolve_cross_file_imports(py_results, py_paths, all_nodes, all_edges)
             all_edges.extend(cross_file_edges)
@@ -7181,9 +7186,9 @@ def _learn(e: dict) -> None:
     _rewire_unique_stub_nodes(all_nodes, all_edges)
 
     # Cross-file Java import resolution
-    java_paths = [p for p in paths if p.suffix == ".java"]
+    java_paths = [p for p in paths if effective_suffix(p) == ".java"]
     if java_paths:
-        java_results = [r for r, p in zip(per_file, paths) if p.suffix == ".java"]
+        java_results = [r for r, p in zip(per_file, paths) if effective_suffix(p) == ".java"]
         try:
             all_edges.extend(_resolve_cross_file_java_imports(java_results, java_paths))
         except Exception as exc:
@@ -7194,9 +7199,9 @@ def _learn(e: dict) -> None:
     # references edges left on shadow stubs, disambiguating same-named types by the
     # referencing file's `using` directives + enclosing namespace (mirrors Java #1318).
     _DOTNET_TYPE_EXTS = {".cs", ".razor", ".cshtml"}
-    cs_paths = [p for p in paths if p.suffix.lower() in _DOTNET_TYPE_EXTS]
+    cs_paths = [p for p in paths if effective_suffix(p).lower() in _DOTNET_TYPE_EXTS]
     if cs_paths:
-        cs_results = [r for r, p in zip(per_file, paths) if p.suffix.lower() in _DOTNET_TYPE_EXTS]
+        cs_results = [r for r, p in zip(per_file, paths) if effective_suffix(p).lower() in _DOTNET_TYPE_EXTS]
         try:
             _resolve_csharp_type_references(cs_results, cs_paths, all_nodes, all_edges)
         except Exception as exc:
diff --git a/graphify/extractors/csharp.py b/graphify/extractors/csharp.py
index f823d64c30..dbd6910d3c 100644
--- a/graphify/extractors/csharp.py
+++ b/graphify/extractors/csharp.py
@@ -14,6 +14,7 @@
 from pathlib import Path
 
 from graphify.extractors.base import _make_id
+from graphify.rcfile import effective_suffix
 
 
 def _build_csharp_type_def_index(all_nodes: list[dict]) -> dict[tuple[str, str], str]:
@@ -32,11 +33,7 @@ def _build_csharp_type_def_index(all_nodes: list[dict]) -> dict[tuple[str, str],
         if not (isinstance(nid, str) and nid and isinstance(label, str) and label):
             continue
         source_file = node.get("source_file")
-        if (
-            not isinstance(source_file, str)
-            or not source_file.endswith(".cs")
-            or node.get("file_type") != "code"
-        ):
+        if not _is_cs_file(source_file) or node.get("file_type") != "code":
             continue
         if label.endswith(")") or label.startswith(".") or "." in label:
             continue
@@ -153,11 +150,11 @@ def _resolve_cross_file_csharp_imports(
 
 
 def _is_cs_file(value: object) -> bool:
-    return isinstance(value, str) and value.endswith(".cs")
+    return isinstance(value, str) and effective_suffix(value) == ".cs"
 
 
 def _is_dotnet_source_file(value: object) -> bool:
-    return isinstance(value, str) and value.endswith(_DOTNET_SOURCE_EXTS)
+    return isinstance(value, str) and effective_suffix(value) in _DOTNET_SOURCE_EXTS
 
 
 def _metadata(value: object) -> dict:
@@ -201,7 +198,7 @@ def __init__(self, all_nodes: list[dict], all_edges: list[dict]) -> None:
             if not (
                 source_node
                 and isinstance(source_node.get("label"), str)
-                and source_node.get("label", "").endswith(_DOTNET_SOURCE_EXTS)
+                and _is_dotnet_source_file(source_node.get("label"))
             ):
                 continue
             source_file = source_node.get("source_file")
diff --git a/graphify/extractors/ocaml.py b/graphify/extractors/ocaml.py
index ce735c13c6..05ad665d04 100644
--- a/graphify/extractors/ocaml.py
+++ b/graphify/extractors/ocaml.py
@@ -9,6 +9,7 @@
 
 from pathlib import Path
 from graphify.extractors.base import _file_stem, _make_id, _read_text
+from graphify.rcfile import effective_suffix
 
 
 def extract_ocaml(path: Path) -> dict:
@@ -21,7 +22,7 @@ def extract_ocaml(path: Path) -> dict:
         return {"nodes": [], "edges": [], "error": "tree-sitter-ocaml not installed"}
 
     try:
-        if path.suffix == ".mli":
+        if effective_suffix(path) == ".mli":
             language = Language(tsocaml.language_ocaml_interface())
         else:
             language = Language(tsocaml.language_ocaml())
diff --git a/graphify/extractors/resolution.py b/graphify/extractors/resolution.py
index 62bb4a6e13..a8ea23d244 100644
--- a/graphify/extractors/resolution.py
+++ b/graphify/extractors/resolution.py
@@ -10,6 +10,7 @@
     _make_id,
     _read_text,
 )
+from graphify.rcfile import effective_suffix, get_language_overrides
 import functools
 import hashlib
 import json
@@ -34,6 +35,18 @@
 
 _JS_INDEX_FILES = ("index.ts", "index.tsx", "index.svelte", "index.js", "index.jsx", "index.mjs")
 
+def _declared_language_suffixes(target_exts: tuple[str, ...]) -> tuple[str, ...]:
+    """Return declared literal suffixes for these languages in deterministic order."""
+    # Mapping keys must be single suffixes, never relative path fragments.
+    suffixes = [
+        source_ext
+        for source_ext, target_ext in get_language_overrides().items()
+        if target_ext in target_exts
+        and Path(f"x{source_ext}").suffix == source_ext
+    ]
+    return tuple(sorted(suffixes))
+
+
 def _resolve_js_import_path(candidate: Path) -> Path:
     """Resolve a JS/TS/Svelte import target to a local file when it exists."""
     candidate = Path(os.path.normpath(candidate))
@@ -50,19 +63,27 @@ def _resolve_js_import_path(candidate: Path) -> Path:
         if tsx_candidate.is_file():
             return tsx_candidate
 
+    declared_exts = _declared_language_suffixes(_JS_RESOLVE_EXTS)
+
     # Append extensions to the full filename, which covers extensionless imports,
     # multi-dot helpers, and Svelte 5 rune files like Foo.svelte.ts.
-    for ext in _JS_RESOLVE_EXTS:
+    # Native suffixes retain precedence over declared ones.
+    for ext in _JS_RESOLVE_EXTS + declared_exts:
         with_ext = candidate.parent / f"{candidate.name}{ext}"
         if with_ext.is_file():
             return with_ext
 
-    # Only fall back to directory indexes after file candidates lose.
+    # Only fall back to directory indexes after file candidates lose, native
+    # index names before declared ones.
     if candidate.is_dir():
         for index_name in _JS_INDEX_FILES:
             index_candidate = candidate / index_name
             if index_candidate.is_file():
                 return index_candidate
+        for ext in declared_exts:
+            index_candidate = candidate / f"index{ext}"
+            if index_candidate.is_file():
+                return index_candidate
 
     return candidate
 
@@ -1389,17 +1410,17 @@ def _parse_js_tree(path: Path):
         # .vue embeds the script in non-JS markup; mask it out and parse the
         # <script> with TS.
         vue_lang: str | None = None
-        if path.suffix == ".vue":
+        if effective_suffix(path) == ".vue":
             masked, vue_lang = _vue_mask_non_script(
                 path.read_text(encoding="utf-8", errors="replace")
             )
             source = masked.encode("utf-8")
         else:
             source = path.read_bytes()
-        use_ts = path.suffix in (".ts", ".mts", ".cts") or (
-            path.suffix == ".vue" and vue_lang not in ("js", "jsx")
+        use_ts = effective_suffix(path) in (".ts", ".mts", ".cts") or (
+            effective_suffix(path) == ".vue" and vue_lang not in ("js", "jsx")
         )
-        if path.suffix == ".tsx":
+        if effective_suffix(path) == ".tsx":
             # .tsx must use the JSX-aware TSX grammar, mirroring the engine's
             # _TSX_CONFIG (ts_language_fn="language_tsx"). Parsing .tsx with
             # language_typescript misparses JSX, and tree-sitter's error
@@ -1777,7 +1798,7 @@ def _ts_walk_class_members(class_node, source: bytes, path: Path, class_nid: str
 def _collect_js_symbol_resolution_facts(paths: list[Path], facts: _SymbolResolutionFacts) -> None:
     js_paths = [
         path for path in paths
-        if path.suffix in _JS_CACHE_BYPASS_SUFFIXES
+        if effective_suffix(path) in _JS_CACHE_BYPASS_SUFFIXES
     ]
     if not js_paths:
         return
@@ -2063,9 +2084,30 @@ def _python_imported_names(node, source: bytes) -> list[tuple[str, str]]:
             names.append((name, local))
     return names
 
+def _is_python_package_dir(directory: Path, suffixes: tuple[str, ...] = (".py",)) -> bool:
+    if any((directory / f"__init__{suffix}").is_file() for suffix in suffixes):
+        return True
+    return any(
+        (directory / f"__init__{suffix}").is_file()
+        for suffix in _declared_language_suffixes(suffixes)
+        if suffix not in suffixes
+    )
+
+
+def _probe_declared_python_module_candidate(candidate: Path) -> Path | None:
+    for suffix in _declared_language_suffixes((".py",)):
+        init_path = candidate / f"__init__{suffix}"
+        if init_path.is_file():
+            return init_path
+        if candidate.name:
+            module_path = candidate.with_suffix(suffix)
+            if module_path.is_file():
+                return module_path
+    return None
+
+
 def _probe_python_module_candidate(candidate: Path) -> Path | None:
-    """Resolve one module-path candidate to a .py file (dir+__init__, exact, or
-    with a .py suffix), or None."""
+    """Resolve native Python modules and packages before declared suffixes."""
     if candidate.is_dir():
         init_path = candidate / "__init__.py"
         if init_path.is_file():
@@ -2073,11 +2115,11 @@ def _probe_python_module_candidate(candidate: Path) -> Path | None:
     if candidate.is_file():
         return candidate
     if not candidate.name:
-        return None
+        return _probe_declared_python_module_candidate(candidate)
     py_candidate = candidate.with_suffix(".py")
     if py_candidate.is_file():
         return py_candidate
-    return None
+    return _probe_declared_python_module_candidate(candidate)
 
 
 def _resolve_python_module_path(module_name: str, current_path: Path, root: Path, level: int) -> Path | None:
@@ -2111,7 +2153,7 @@ def _resolve_python_module_path(module_name: str, current_path: Path, root: Path
         # implicit-relative semantics), fabricating edges to what may be an
         # external dependency (#2072 review). A src-layout root (src/, no
         # __init__.py) is still probed.
-        if (anc / "__init__.py").is_file():
+        if _is_python_package_dir(anc):
             continue
         cand = _probe_python_module_candidate(anc / rel)
         if cand is not None:
@@ -2130,7 +2172,7 @@ def _resolve_python_namespace_dir(module_name: str, current_path: Path, root: Pa
     scan root, then sys.path-root ancestors) and returns only a directory that
     exists inside the root."""
     def _namespace(candidate: Path) -> "Path | None":
-        if not candidate.is_dir() or (candidate / "__init__.py").is_file():
+        if not candidate.is_dir() or _is_python_package_dir(candidate):
             return None
         try:
             _resolve_cached(candidate).relative_to(_resolve_cached(root))
@@ -2154,7 +2196,7 @@ def _namespace(candidate: Path) -> "Path | None":
             anc.relative_to(root)
         except ValueError:
             break  # left the scan root; stop walking up
-        if anc == root or (anc / "__init__.py").is_file():
+        if anc == root or _is_python_package_dir(anc):
             continue  # root already probed; a package dir is not a sys.path root (#2072)
         hit = _namespace(anc / rel)
         if hit is not None:
@@ -2186,7 +2228,7 @@ def _collect_python_symbol_resolution_facts(
     root: Path,
     facts: _SymbolResolutionFacts,
 ) -> None:
-    py_paths = [path for path in paths if path.suffix == ".py"]
+    py_paths = [path for path in paths if effective_suffix(path) == ".py"]
     if not py_paths:
         return
 
@@ -2211,7 +2253,11 @@ def _collect_python_symbol_resolution_facts(
                 # (__init__.py) and an imported name matches a submodule file on
                 # disk, emit a file-level import edge to that submodule rather
                 # than only to the package.
-                pkg_dir = target_path.parent if target_path.name == "__init__.py" else None
+                pkg_dir = (
+                    target_path.parent
+                    if target_path.stem == "__init__" and effective_suffix(target_path) == ".py"
+                    else None
+                )
             else:
                 # A PEP 420 namespace package: the module names a directory with
                 # no __init__.py, so there is no module file to resolve to, but
@@ -2227,6 +2273,8 @@ def _collect_python_symbol_resolution_facts(
                     sub_py = pkg_dir / f"{imported_name}.py"
                     sub_pkg = pkg_dir / imported_name / "__init__.py"
                     submodule = sub_py if sub_py.is_file() else (sub_pkg if sub_pkg.is_file() else None)
+                    if submodule is None:
+                        submodule = _probe_declared_python_module_candidate(pkg_dir / imported_name)
                     if submodule is not None:
                         facts.module_imports.append((path, submodule, line, local_name))
                         continue
@@ -2235,7 +2283,7 @@ def _collect_python_symbol_resolution_facts(
                 facts.imports.append(
                     _SymbolImportFact(path, local_name, target_path, imported_name, line)
                 )
-                if path.name == "__init__.py":
+                if path.stem == "__init__":
                     facts.exports.append(
                         _SymbolExportFact(
                             path,
diff --git a/graphify/extractors/robot.py b/graphify/extractors/robot.py
index c224c3a3b0..364c846c54 100644
--- a/graphify/extractors/robot.py
+++ b/graphify/extractors/robot.py
@@ -6,6 +6,7 @@
 
 from pathlib import Path
 from graphify.extractors.base import _file_stem, _make_id
+from graphify.rcfile import effective_suffix
 
 
 # Robot Framework standard libraries - imports of these are noise (like the
@@ -159,7 +160,7 @@ def add_edge(src: str, tgt: str, relation: str, line: int,
     add_node(file_nid, path.name, 1)
 
     try:
-        if path.suffix.lower() == ".resource":
+        if effective_suffix(path).lower() == ".resource":
             model = get_resource_model(str_path)
         else:
             model = get_model(str_path)
diff --git a/graphify/symbol_resolution.py b/graphify/symbol_resolution.py
index 6adb4a2aca..91ba5b97a1 100644
--- a/graphify/symbol_resolution.py
+++ b/graphify/symbol_resolution.py
@@ -13,6 +13,7 @@
 from graphify.ids import make_id as _shared_make_id
 from graphify.paths import disambiguate_ambiguous_candidates
 from graphify.security import sanitize_metadata
+from graphify.rcfile import effective_suffix
 
 
 
@@ -242,14 +243,14 @@ def resolve_python_import_guided_calls(
     #     downstream `.get("raw_calls", [])` lookup never raises
     result_by_file: dict[str, dict[str, Any]] = {}
     for index, path in enumerate(paths):
-        if path.suffix != ".py":
+        if effective_suffix(path) != ".py":
             continue
         slot: Any = per_file[index] if index < len(per_file) else None
         result_by_file[str(path)] = slot if isinstance(slot, dict) else {"nodes": [], "edges": []}
     resolved_edges: list[dict[str, Any]] = []
 
     for path in paths:
-        if path.suffix != ".py":
+        if effective_suffix(path) != ".py":
             continue
         source_file = str(path)
         aliases = parse_python_import_aliases(path)
diff --git a/tests/test_language_override_imports.py b/tests/test_language_override_imports.py
new file mode 100644
index 0000000000..5e3bcaf49a
--- /dev/null
+++ b/tests/test_language_override_imports.py
@@ -0,0 +1,178 @@
+"""Declared JS-family suffixes participate in local extensionless imports."""
+
+import pytest
+
+from graphify.extractors.resolution import _resolve_js_module_path
+from graphify.rcfile import activate_language_overrides, set_language_overrides
+
+
+@pytest.fixture(autouse=True)
+def reset_overrides():
+    set_language_overrides(None)
+    yield
+    set_language_overrides(None)
+
+
+@pytest.mark.parametrize("relative", ["dep.tpl", "dep/index.tpl"])
+def test_extensionless_import_finds_declared_source_or_directory_index(tmp_path, relative):
+    (tmp_path / ".graphifyrc").write_text("language.tpl=typescript\n")
+    source = tmp_path / relative
+    source.parent.mkdir(parents=True, exist_ok=True)
+    source.write_text("export function chosen() {}\n")
+    activate_language_overrides(tmp_path)
+    assert _resolve_js_module_path("./dep", tmp_path) == source
+
+
+@pytest.mark.parametrize("directory", [False, True])
+def test_native_source_precedence_and_literal_declared_paths_are_preserved(tmp_path, directory):
+    (tmp_path / ".graphifyrc").write_text("language.tpl=typescript\n")
+    stem = tmp_path / ("dep/index" if directory else "dep")
+    stem.parent.mkdir(parents=True, exist_ok=True)
+    native, declared = stem.with_suffix(".ts"), stem.with_suffix(".tpl")
+    native.write_text("export function native() {}\n")
+    declared.write_text("export function declared() {}\n")
+    activate_language_overrides(tmp_path)
+    assert _resolve_js_module_path("./dep", tmp_path) == native
+    assert _resolve_js_module_path(declared) == declared
+
+
+def test_extensionless_js_lookup_does_not_claim_other_declared_languages(tmp_path):
+    (tmp_path / ".graphifyrc").write_text("language.tpl=php\n")
+    (tmp_path / "dep.tpl").write_text("<?php function chosen() {}\n")
+    activate_language_overrides(tmp_path)
+    assert _resolve_js_module_path("./dep", tmp_path) == tmp_path / "dep"
+
+
+def test_import_candidates_ignore_mapping_keys_that_are_not_literal_suffixes(tmp_path):
+    (tmp_path / ".graphifyrc").write_text("language.tpl/../secret.ts=typescript\n")
+    (tmp_path / "dep.tpl").mkdir()
+    (tmp_path / "secret.ts").write_text("export function unrelated() {}\n")
+    activate_language_overrides(tmp_path)
+    assert _resolve_js_module_path("./dep", tmp_path) == tmp_path / "dep"
+
+
+@pytest.mark.parametrize("layout", ["module", "package", "reexport", "submodule", "namespace"])
+def test_python_imports_bind_declared_providers_instead_of_same_named_alternatives(tmp_path, layout):
+    from graphify.extract import extract
+
+    (tmp_path / ".graphifyrc").write_text("language.pyx=python\n")
+    sources = {"other.pyx": "def chosen(): return 2\n"}
+    statement = "from one import chosen as local\ndef caller(): return local()\n"
+    if layout == "module":
+        target = "one.pyx"
+    elif layout == "package":
+        target = "one/__init__.pyx"
+    elif layout == "reexport":
+        target = "one/body.pyx"
+        sources["one/__init__.pyx"] = "from .body import chosen\n"
+    else:
+        target = "pkg/one.pyx"
+        statement = "from pkg import one\ndef caller(): return one.chosen()\n"
+        if layout == "submodule":
+            sources["pkg/__init__.pyx"] = ""
+    sources[target] = "def chosen(): return 1\n"
+    sources["caller.pyx"] = statement
+    paths = []
+    for relative, content in sources.items():
+        path = tmp_path / relative
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(content)
+        paths.append(path)
+    result = extract(paths, root=tmp_path, cache_root=tmp_path)
+    nodes = {node["id"]: node for node in result["nodes"]}
+    targets = {(nodes[edge["target"]]["label"], nodes[edge["target"]].get("source_file"))
+               for edge in result["edges"] if edge["relation"] == "calls"
+               and nodes.get(edge["source"], {}).get("label") == "caller()"}
+    assert targets == {("chosen()", target)}
+
+
+def test_python_native_module_and_package_precedence_is_preserved(tmp_path):
+    from graphify.extractors.resolution import _resolve_python_module_path
+
+    (tmp_path / ".graphifyrc").write_text("language.pyx=python\n")
+    (tmp_path / "one").mkdir()
+    (tmp_path / "one/__init__.pyx").write_text("def declared(): pass\n")
+    native = tmp_path / "one.py"
+    native.write_text("def native(): pass\n")
+    activate_language_overrides(tmp_path)
+    caller = tmp_path / "caller.py"
+    assert _resolve_python_module_path("one", caller, tmp_path, 0) == native
+    native_package = tmp_path / "one/__init__.py"
+    native_package.write_text("def package(): pass\n")
+    assert _resolve_python_module_path("one", caller, tmp_path, 0) == native_package
+
+
+def test_python_lookup_does_not_claim_another_declared_language(tmp_path):
+    from graphify.extractors.resolution import _resolve_python_module_path
+
+    (tmp_path / ".graphifyrc").write_text("language.tpl=php\n")
+    (tmp_path / "one.tpl").write_text("<?php function chosen() {}\n")
+    activate_language_overrides(tmp_path)
+    assert _resolve_python_module_path("one", tmp_path / "caller.py", tmp_path, 0) is None
+
+
+def test_declared_native_suffix_can_supply_an_additional_directory_index(tmp_path):
+    (tmp_path / ".graphifyrc").write_text("language.cjs=typescript\n")
+    source = tmp_path / "dep/index.cjs"
+    source.parent.mkdir()
+    source.write_text("export function chosen() {}\n")
+    activate_language_overrides(tmp_path)
+    assert _resolve_js_module_path("./dep", tmp_path) == source
+
+
+@pytest.mark.parametrize("suffix", [".py", ".pyx"])
+@pytest.mark.parametrize("namespace", [False, True])
+def test_declared_packages_preserve_absolute_and_explicit_relative_import_scope(tmp_path, suffix, namespace):
+    from graphify.extract import extract
+
+    (tmp_path / ".graphifyrc").write_text("language.pyx=python\n")
+    package = tmp_path / "src/pkg"
+    package.mkdir(parents=True)
+    init = package / f"__init__{suffix}"
+    init.write_text("")
+    target = package / (f"utilities/helper{suffix}" if namespace else f"helper{suffix}")
+    target.parent.mkdir(exist_ok=True)
+    target.write_text("def chosen(): return 1\n")
+    caller = package / f"caller{suffix}"
+    for relative in (True, False):
+        prefix = "." if relative else ""
+        statement = (
+            f"from {prefix}utilities import helper\ndef caller(): return helper.chosen()\n"
+            if namespace else
+            f"from {prefix}helper import chosen as local\ndef caller(): return local()\n"
+        )
+        caller.write_text(statement)
+        result = extract([init, target, caller], root=tmp_path, cache_root=tmp_path)
+        nodes = {node["id"]: node for node in result["nodes"]}
+        targets = {nodes[edge["target"]].get("source_file") for edge in result["edges"]
+                   if edge["relation"] == "calls" and nodes.get(edge["source"], {}).get("label") == "caller()"}
+        assert targets == ({target.relative_to(tmp_path).as_posix()} if relative else set())
+
+
+def test_declared_package_initializer_is_not_a_namespace_package(tmp_path):
+    from graphify.extractors.resolution import _resolve_python_namespace_dir
+
+    (tmp_path / ".graphifyrc").write_text("language.pyx=python\n")
+    package = tmp_path / "pkg"
+    package.mkdir()
+    (package / "__init__.pyx").write_text("def chosen(): return 1\n")
+    activate_language_overrides(tmp_path)
+    assert _resolve_python_namespace_dir("pkg", tmp_path / "caller.py", tmp_path, 0) is None
+
+
+def test_import_of_declared_src_layout_package_targets_its_real_initializer(tmp_path):
+    from graphify.extract import extract
+
+    (tmp_path / ".graphifyrc").write_text("language.pyx=python\n")
+    package = tmp_path / "src/pkg"
+    package.mkdir(parents=True)
+    init = package / "__init__.pyx"
+    init.write_text("def chosen(): return 1\n")
+    caller = tmp_path / "src/caller.pyx"
+    caller.write_text("import pkg\n")
+    result = extract([init, caller], root=tmp_path, cache_root=tmp_path)
+    nodes = {node["id"]: node for node in result["nodes"]}
+    targets = {nodes.get(edge["target"], {}).get("source_file") for edge in result["edges"]
+               if edge["relation"] in {"imports", "imports_from"}
+               and nodes.get(edge["source"], {}).get("source_file") == "src/caller.pyx"}
+    assert targets == {"src/pkg/__init__.pyx"}
diff --git a/tests/test_language_overrides.py b/tests/test_language_overrides.py
index 90b1d648a6..09d3d1da39 100644
--- a/tests/test_language_overrides.py
+++ b/tests/test_language_overrides.py
@@ -36,6 +36,8 @@
     extract_pascal,
     extract_php,
 )
+from graphify.extractors.ocaml import extract_ocaml
+from graphify.extractors.robot import extract_robot
 
 try:
     from graphify.extract import _worker_init
@@ -407,3 +409,209 @@ def other() -> None:
     # main thread must still see the real suffix, not the other thread's map
     assert effective_suffix("x.inc") == ".inc"
     t.join()
+
+
+def _edges(result, relation):
+    return [e for e in result["edges"] if e["relation"] == relation]
+
+
+def test_a_declared_ts_file_keeps_its_implements_edge(tmp_path):
+    base_src = "export interface Base {\n    id: number;\n}\n"
+    consumer_src = (
+        "import { Base } from './base';\n\n"
+        "class Consumer implements Base {\n    id: number = 1;\n}\n"
+    )
+    declared = tmp_path / "declared"
+    declared.mkdir()
+    (declared / "base.ts").write_text(base_src, encoding="utf-8")
+    (declared / "consumer.tpl").write_text(consumer_src, encoding="utf-8")
+    (declared / ".graphifyrc").write_text("language.tpl=.ts\n", encoding="utf-8")
+    real = tmp_path / "real"
+    real.mkdir()
+    (real / "base.ts").write_text(base_src, encoding="utf-8")
+    (real / "consumer.ts").write_text(consumer_src, encoding="utf-8")
+
+    declared_result = _quiet_extract(
+        [declared / "base.ts", declared / "consumer.tpl"], cache_root=declared, root=declared
+    )
+    real_result = _quiet_extract(
+        [real / "base.ts", real / "consumer.ts"], cache_root=real, root=real
+    )
+    assert len(_edges(real_result, "implements")) == 1
+    assert len(_edges(declared_result, "implements")) == len(_edges(real_result, "implements"))
+
+
+def test_a_declared_java_file_disambiguates_implements_by_package(tmp_path):
+    pkg1 = "package com.pkg1;\npublic interface Base {\n    void run();\n}\n"
+    pkg2 = "package com.pkg2;\npublic interface Base {\n    void other();\n}\n"
+    impl_src = (
+        "package com.app;\nimport com.pkg1.Base;\n\n"
+        "public class Impl implements Base {\n    public void run() {}\n}\n"
+    )
+    declared = tmp_path / "declared"
+    (declared / "pkg1").mkdir(parents=True)
+    (declared / "pkg2").mkdir()
+    (declared / "pkg1" / "Base.java").write_text(pkg1, encoding="utf-8")
+    (declared / "pkg2" / "Base.java").write_text(pkg2, encoding="utf-8")
+    (declared / "Impl.jav").write_text(impl_src, encoding="utf-8")
+    (declared / ".graphifyrc").write_text("language.jav=java\n", encoding="utf-8")
+
+    result = _quiet_extract(
+        [declared / "pkg1" / "Base.java", declared / "pkg2" / "Base.java", declared / "Impl.jav"],
+        cache_root=declared, root=declared,
+    )
+    implements = _edges(result, "implements")
+    assert len(implements) == 1
+    target = implements[0]["target"]
+    target_node = next(n for n in result["nodes"] if n["id"] == target)
+    assert target_node.get("source_file", "").replace("\\", "/").endswith("pkg1/Base.java")
+
+
+def test_a_declared_python_file_repoints_a_nested_package_import(tmp_path):
+    mod_src = "def helper():\n    pass\n"
+    caller_src = "import pkg.mod\n\npkg.mod.helper()\n"
+    declared = tmp_path / "declared"
+    (declared / "src" / "pkg").mkdir(parents=True)
+    (declared / "src" / "pkg" / "__init__.py").write_text("", encoding="utf-8")
+    (declared / "src" / "pkg" / "mod.pyx").write_text(mod_src, encoding="utf-8")
+    (declared / "src" / "app.py").write_text(caller_src, encoding="utf-8")
+    (declared / ".graphifyrc").write_text("language.pyx=python\n", encoding="utf-8")
+
+    result = _quiet_extract(
+        [
+            declared / "src" / "pkg" / "__init__.py",
+            declared / "src" / "pkg" / "mod.pyx",
+            declared / "src" / "app.py",
+        ],
+        cache_root=declared, root=declared,
+    )
+    imports = _edges(result, "imports")
+    mod_node_id = next(n["id"] for n in result["nodes"] if n["source_file"].endswith("mod.pyx"))
+    assert any(e["target"] == mod_node_id for e in imports)
+
+
+def test_a_declared_csharp_file_disambiguates_inherits_by_namespace(tmp_path):
+    ns1 = "namespace App.Pkg1 {\n    public interface Shape { }\n}\n"
+    ns2 = "namespace App.Pkg2 {\n    public interface Shape { }\n}\n"
+    main_src = (
+        "using App.Pkg1;\n\nnamespace App {\n    public class Wrapper : Shape {\n    }\n}\n"
+    )
+    declared = tmp_path / "declared"
+    (declared / "Pkg1").mkdir(parents=True)
+    (declared / "Pkg2").mkdir()
+    (declared / "Pkg1" / "Shape.cs").write_text(ns1, encoding="utf-8")
+    (declared / "Pkg2" / "Shape.cs").write_text(ns2, encoding="utf-8")
+    (declared / "Main.rzr").write_text(main_src, encoding="utf-8")
+    (declared / ".graphifyrc").write_text("language.rzr=csharp\n", encoding="utf-8")
+
+    result = _quiet_extract(
+        [declared / "Pkg1" / "Shape.cs", declared / "Pkg2" / "Shape.cs", declared / "Main.rzr"],
+        cache_root=declared, root=declared,
+    )
+    inherits = _edges(result, "inherits")
+    assert len(inherits) == 1
+    target = inherits[0]["target"]
+    target_node = next(n for n in result["nodes"] if n["id"] == target)
+    assert target_node.get("source_file", "").replace("\\", "/").endswith("Pkg1/Shape.cs")
+
+
+def test_a_declared_unsupported_language_still_warns_no_extractor(tmp_path, capsys):
+    (tmp_path / "a.tpl").write_text("helper <- function(x) x + 1\n", encoding="utf-8")
+    (tmp_path / ".graphifyrc").write_text("language.tpl=r\n", encoding="utf-8")
+    _quiet_extract([tmp_path / "a.tpl"], cache_root=tmp_path, root=tmp_path)
+    assert "no AST extractor" in capsys.readouterr().err
+
+
+def test_a_declared_mli_interface_is_parsed_as_an_interface_not_ml(tmp_path):
+    pytest.importorskip("tree_sitter_ocaml")
+    root = tmp_path
+    (root / ".graphifyrc").write_text("language.tpl4=.mli\n", encoding="utf-8")
+    activate_language_overrides(root)
+    impl_src = "let helper x =\n  x + 1\n\nlet main () =\n  helper 41\n"
+    declared_path = root / "a.tpl4"
+    declared_path.write_text(impl_src, encoding="utf-8")
+    real_mli = root / "a.mli"
+    real_mli.write_text(impl_src, encoding="utf-8")
+
+    declared_result = extract_ocaml(declared_path)
+    set_language_overrides(None)
+    real_result = extract_ocaml(real_mli)
+    assert real_result["edges"] == []  # real .mli: not valid interface syntax, nothing extracted
+    assert declared_result["edges"] == real_result["edges"]
+
+
+def test_a_declared_resource_file_excludes_test_cases_like_a_real_resource(tmp_path):
+    pytest.importorskip("robot")
+    root = tmp_path
+    (root / ".graphifyrc").write_text("language.tplr=.resource\n", encoding="utf-8")
+    content = (
+        "*** Test Cases ***\nMy Test\n    Log    hello\n\n"
+        "*** Keywords ***\nDo Something\n    Log    hi\n"
+    )
+    activate_language_overrides(root)
+    declared_path = root / "a.tplr"
+    declared_path.write_text(content, encoding="utf-8")
+    real_resource = root / "a.resource"
+    real_resource.write_text(content, encoding="utf-8")
+
+    declared_result = extract_robot(declared_path)
+    set_language_overrides(None)
+    real_result = extract_robot(real_resource)
+    declared_labels = {n["label"] for n in declared_result["nodes"]}
+    real_labels = {n["label"] for n in real_result["nodes"]}
+    assert "My Test" not in real_labels  # real .resource: Test Cases section dropped
+    assert "Do Something" in real_labels
+    assert declared_labels - {declared_path.name} == real_labels - {real_resource.name}
+
+
+def test_declared_typescript_preserves_symbols_and_original_source_paths(tmp_path):
+    (tmp_path / ".graphifyrc").write_text("language.tpl=typescript\n", encoding="utf-8")
+    source = tmp_path / "declarations.tpl"
+    source.write_text("""interface Point { x: number; y: number; }
+enum Color { Red, Green, Blue }
+class Shape<T> {
+  constructor(private kind: T) {}
+  describe(): string { return String(this.kind); }
+}
+""", encoding="utf-8")
+    result = _quiet_extract([source], root=tmp_path, cache_root=tmp_path)
+    expected = {"Point", "Color", "Red", "Green", "Blue", "Shape", ".constructor()", ".describe()"}
+    assert expected <= {node["label"] for node in result["nodes"]}
+    assert {node["source_file"] for node in result["nodes"] if node["label"] in expected} == {source.name}
+
+
+def test_declared_typescript_imports_follow_changed_tsconfig_without_source_edit(tmp_path):
+    import json
+
+    (tmp_path / ".graphifyrc").write_text("language.tpl=ts\n", encoding="utf-8")
+    caller, one, two = (tmp_path / name for name in ("consumer.tpl", "one.ts", "two.ts"))
+    caller.write_text("import { chosen } from '@target'; export function run() { return chosen(); }\n", encoding="utf-8")
+    one.write_text("export function chosen() { return 1; }\n", encoding="utf-8")
+    two.write_text("export function chosen() { return 2; }\n", encoding="utf-8")
+    config = tmp_path / "tsconfig.json"
+    for target in ("one.ts", "two.ts"):
+        config.write_text(json.dumps({"compilerOptions": {"baseUrl": ".", "paths": {"@target": [target]}}}), encoding="utf-8")
+        result = _quiet_extract([caller, one, two], root=tmp_path, cache_root=tmp_path)
+        nodes = {node["id"]: node for node in result["nodes"]}
+        targets = {nodes[edge["target"]].get("source_file") for edge in _edges(result, "imports_from")
+                   if nodes.get(edge["source"], {}).get("source_file") == caller.name}
+        assert targets == {target}, (target, targets)
+
+
+def test_declared_go_resolves_qualified_type_among_same_named_packages(tmp_path):
+    (tmp_path / ".graphifyrc").write_text("language.gox=go\n", encoding="utf-8")
+    (tmp_path / "go.mod").write_text("module example.com/app\ngo 1.21\n", encoding="utf-8")
+    paths = []
+    for package in ("pkg1", "pkg2"):
+        directory = tmp_path / package
+        directory.mkdir()
+        source = directory / "shape.go"
+        source.write_text(f"package {package}\ntype Shape struct {{ Sides int }}\n", encoding="utf-8")
+        paths.append(source)
+    caller = tmp_path / "main.gox"
+    caller.write_text('package main\nimport "example.com/app/pkg1"\ntype Wrapper struct { S pkg1.Shape }\n', encoding="utf-8")
+    result = _quiet_extract([caller, *paths], root=tmp_path, cache_root=tmp_path)
+    nodes = {node["id"]: node for node in result["nodes"]}
+    targets = {nodes[edge["target"]].get("source_file") for edge in _edges(result, "references")
+               if nodes.get(edge["source"], {}).get("label") == "Wrapper"}
+    assert targets == {"pkg1/shape.go"}, targets

From 481574300794093d44ea40d5371db0ef058b21fa Mon Sep 17 00:00:00 2001
From: Andre Brait <andrebrait@gmail.com>
Date: Sat, 12 Sep 2026 20:40:11 +0000
Subject: [PATCH 2/3] fix(config): refresh graphs when language declarations
 change

---
 README.md                                 |   6 +-
 graphify/detect.py                        |  22 +-
 graphify/watch.py                         |  38 ++-
 tests/test_language_override_lifecycle.py | 293 ++++++++++++++++++++++
 4 files changed, 349 insertions(+), 10 deletions(-)
 create mode 100644 tests/test_language_override_lifecycle.py

diff --git a/README.md b/README.md
index f340c025df..c69c9f8aee 100644
--- a/README.md
+++ b/README.md
@@ -442,7 +442,11 @@ language.tpl=.ts
 viz_node_limit=0
 ```
 
-The declaration applies everywhere graphify keys a decision on the extension — file classification, extractor dispatch, cross-file resolution, and the AST cache (a file re-parsed under a different language never reuses the old entry). It is read by `graphify extract`, `graphify update`, `watch`, the hooks, the MCP server, and the `/graphify` skill alike. A typo is reported once on stderr and the scan continues with graphify's defaults.
+The declaration controls file classification, extractor selection and language-specific grammar and resolution, and the AST cache: a file re-parsed under a different language never reuses the old entry. Original source paths and physical format conventions, such as Fortran `.F90` preprocessing and C/C++ header/implementation pairing, are preserved. Optional language backends must still be installed. A typo is reported once on stderr and the scan continues with graphify's defaults.
+
+Adding, changing, or removing a language declaration invalidates affected incremental manifest entries even when the source bytes have not changed. `graphify watch` recognizes declared source extensions and root `.graphifyrc` changes, including atomic replacement; configuration changes schedule an AST rebuild and flag semantic work for the next extraction. The same configuration is read by `graphify extract`, `graphify update`, the hooks, the MCP server, and the `/graphify` skill.
+
+Extensionless local JS/TS imports can also resolve declared suffixes. Native suffixes retain precedence within file and directory-index lookup, and file candidates are tried before directory indexes. Python module and package lookups also support declared Python suffixes, while retaining native `.py` precedence.
 
 ---
 
diff --git a/graphify/detect.py b/graphify/detect.py
index 32004363fa..5c3b3a12b9 100644
--- a/graphify/detect.py
+++ b/graphify/detect.py
@@ -20,7 +20,7 @@
     google_workspace_enabled,
 )
 from graphify.paths import GRAPHIFY_OUT, out_path
-from graphify.rcfile import activate_language_overrides, effective_suffix
+from graphify.rcfile import activate_language_overrides, cache_salt, effective_suffix
 
 
 class FileType(str, Enum):
@@ -2227,6 +2227,9 @@ def save_manifest(
     re-queues the file after the failure is fixed, without deleting
     graphify-out/.
     """
+    # Another root may have activated different overrides in this thread.
+    if root is not None:
+        activate_language_overrides(Path(root))
     existing = load_manifest(manifest_path, root=root)
 
     # Index both raw and NFC forms so scan/clear membership survives the
@@ -2347,12 +2350,19 @@ def _normalise_entry(entry):
         mtime, h = hashed[f]
         key = _nfc(f)
         prev = _normalise_entry(existing.get(key, {})) or {}
+        # Hash workers do not inherit this thread's language overrides.
+        current_lang = cache_salt(f)
+        lang_changed = current_lang != prev.get("language")
         if kind in ("ast", "both"):
             ast_h = h
+        elif lang_changed:
+            ast_h = ""
         else:
             ast_h = prev.get("ast_hash", "")
         if kind in ("semantic", "both"):
             sem_h = h
+        elif lang_changed:
+            sem_h = ""
         else:
             # Preserve semantic_hash only when content is unchanged
             sem_h = prev.get("semantic_hash", "") if h == prev.get("ast_hash", "") else ""
@@ -2365,6 +2375,7 @@ def _normalise_entry(entry):
             and mtime == prev.get("mtime")
             and (ast_h == prev.get("ast_hash", "") if kind in ("ast", "both") else True)
             and (sem_h == prev.get("semantic_hash", "") if kind in ("semantic", "both") else True)
+            and not lang_changed
             and not _in_clear_ast(f)
             and not _in_clear(f)
         )
@@ -2374,6 +2385,9 @@ def _normalise_entry(entry):
             "ast_hash": ast_h,
             "semantic_hash": sem_h,
         }
+        if current_lang is not None:
+            # No override keeps legacy rows unchanged.
+            entry["language"] = current_lang
         manifest[key] = entry
     if root is not None:
         # Persist in portable form: forward-slash relative paths. Keys outside
@@ -2504,7 +2518,11 @@ def detect_incremental(
             # the graph drifted from disk (#1859). No stored hash means we
             # cannot verify content — any mtime delta forces a re-extract,
             # and the next save promotes the entry into the dict schema.
-            if isinstance(stored, (int, float)):
+            # A language change invalidates even identical bytes and legacy rows.
+            stored_lang = stored.get("language") if isinstance(stored, dict) else None
+            if stored is not None and cache_salt(f) != stored_lang:
+                changed = True
+            elif isinstance(stored, (int, float)):
                 changed = current_mtime != stored
             elif isinstance(stored, dict):
                 # Normalise legacy {mtime, hash} to new schema
diff --git a/graphify/watch.py b/graphify/watch.py
index 58028eae09..b1a0392b9b 100644
--- a/graphify/watch.py
+++ b/graphify/watch.py
@@ -274,6 +274,12 @@ def _git_head(cwd: Path | str | None = None) -> str | None:
     _load_graphifyignore,
     _is_ignored,
 )
+from graphify.rcfile import (
+    RC_FILENAME,
+    activate_language_overrides,
+    effective_suffix,
+    set_language_overrides,
+)
 
 _WATCHED_EXTENSIONS = CODE_EXTENSIONS | DOC_EXTENSIONS | PAPER_EXTENSIONS | IMAGE_EXTENSIONS
 _CODE_EXTENSIONS = CODE_EXTENSIONS
@@ -2134,7 +2140,7 @@ def _notify_only(watch_path: Path) -> None:
 
 
 def _has_non_code(changed_paths: list[Path]) -> bool:
-    return any(p.suffix.lower() not in _CODE_EXTENSIONS for p in changed_paths)
+    return any(effective_suffix(p).lower() not in _CODE_EXTENSIONS for p in changed_paths)
 
 
 def _batch_triggers_rebuild(batch: list[Path]) -> bool:
@@ -2146,7 +2152,7 @@ def _batch_triggers_rebuild(batch: list[Path]) -> bool:
     this, a doc-only deletion batch would sit behind the needs_update flag
     until the next code event or a manual `graphify update` (#2580).
     """
-    has_code = any(p.suffix.lower() in _CODE_EXTENSIONS for p in batch)
+    has_code = any(effective_suffix(p).lower() in _CODE_EXTENSIONS for p in batch)
     has_deletion = any(not p.exists() for p in batch)
     return has_code or has_deletion
 
@@ -2213,9 +2219,14 @@ def watch(watch_path: Path, debounce: float = 3.0) -> None:
         gitignore=_read_build_gitignore(watch_path / _GRAPHIFY_OUT),
     )
 
+    # Observer and dispatch threads need the same root-specific snapshot.
+    root_config_path = watch_root_for_ignore / RC_FILENAME
+    override_snapshot: dict[str, str] = activate_language_overrides(watch_root_for_ignore)
+    config_changed = False
+
     class Handler(FileSystemEventHandler):
         def on_any_event(self, event):
-            nonlocal last_trigger, pending
+            nonlocal last_trigger, pending, override_snapshot, config_changed
             if event.is_directory or _is_read_only_event(event):
                 return
             path = Path(os.fsdecode(event.src_path))
@@ -2226,7 +2237,17 @@ def on_any_event(self, event):
             # relative_to guard, so a stray symlinked event won't raise.
             if ignore_patterns and _is_ignored(path, watch_root_for_ignore, ignore_patterns):
                 return
-            if path.suffix.lower() not in _WATCHED_EXTENSIONS:
+            # Atomic replacement reports the new root config in dest_path.
+            dest_raw = getattr(event, "dest_path", None)
+            dest_path = Path(os.fsdecode(dest_raw)) if dest_raw else None
+            if path == root_config_path or dest_path == root_config_path:
+                override_snapshot = activate_language_overrides(watch_root_for_ignore)
+                config_changed = True
+                last_trigger = time.monotonic()
+                pending = True
+                return
+            set_language_overrides(override_snapshot)
+            if effective_suffix(path).lower() not in _WATCHED_EXTENSIONS:
                 return
             try:
                 filter_parts = path.relative_to(watch_root_for_ignore).parts
@@ -2243,7 +2264,7 @@ def on_any_event(self, event):
     handler = Handler()
     # Use polling observer on macOS — FSEvents can miss rapid saves in some editors
     observer = PollingObserver() if sys.platform == "darwin" else Observer()
-    observer.schedule(handler, str(watch_path), recursive=True)
+    observer.schedule(handler, str(watch_root_for_ignore), recursive=True)
     observer.start()
 
     print(f"[graphify watch] Watching {watch_path.resolve()} - press Ctrl+C to stop")
@@ -2258,10 +2279,13 @@ def on_any_event(self, event):
                 pending = False
                 batch = list(changed)
                 changed.clear()
+                config_event, config_changed = config_changed, False
                 print(f"\n[graphify watch] {len(batch)} file(s) changed")
-                if _batch_triggers_rebuild(batch):
+                # Reapply the observer's snapshot on the dispatch thread.
+                set_language_overrides(override_snapshot)
+                if config_event or _batch_triggers_rebuild(batch):
                     _rebuild_code(watch_path)
-                if _batch_needs_llm_flag(batch):
+                if config_event or _batch_needs_llm_flag(batch):
                     _notify_only(watch_path)
     except KeyboardInterrupt:
         print("\n[graphify watch] Stopped.")
diff --git a/tests/test_language_override_lifecycle.py b/tests/test_language_override_lifecycle.py
new file mode 100644
index 0000000000..89cce0c70f
--- /dev/null
+++ b/tests/test_language_override_lifecycle.py
@@ -0,0 +1,293 @@
+"""Language declarations must invalidate incremental state and reach watch events."""
+import hashlib
+import json
+import threading
+from pathlib import Path
+
+import pytest
+
+from graphify import watch as watch_mod
+from graphify.detect import detect_incremental, save_manifest
+from graphify.rcfile import set_language_overrides
+
+
+@pytest.fixture(autouse=True)
+def reset_overrides():
+    set_language_overrides(None)
+    yield
+    set_language_overrides(None)
+
+
+def manifest(root):
+    return root / "graphify-out" / "manifest.json"
+
+
+def save(root, files, kind="both"):
+    save_manifest({"code": [str(p) for p in files]}, str(manifest(root)), kind=kind, root=root)
+
+
+def pending(root, kind="ast"):
+    result = detect_incremental(root, str(manifest(root)), kind=kind)
+    return {Path(p).name for p in result["new_files"]["code"]}
+
+
+def test_language_transitions_requeue_unchanged_bytes_but_not_unrelated_files(tmp_path):
+    inc, py = tmp_path / "legacy.inc", tmp_path / "other.py"
+    inc.write_text("<?php function hello() { return 1; }\n")
+    py.write_text("def other(): return 2\n")
+    save(tmp_path, [inc, py])
+    assert pending(tmp_path) == set()
+    original_stat = inc.stat()
+    rc = tmp_path / ".graphifyrc"
+    for language in ("php", "pascal", None):
+        if language is None:
+            rc.unlink()
+        else:
+            rc.write_text(f"language.inc={language}\n")
+        assert pending(tmp_path) == {"legacy.inc"}, language
+        assert inc.stat().st_mtime_ns == original_stat.st_mtime_ns
+        save(tmp_path, [inc, py])
+        assert pending(tmp_path) == set(), language
+
+
+def test_noop_config_edit_and_partial_save_preserve_only_valid_state(tmp_path):
+    inc, py = tmp_path / "legacy.inc", tmp_path / "other.py"
+    inc.write_text("<?php function hello() {}\n")
+    py.write_text("def other(): pass\n")
+    rc = tmp_path / ".graphifyrc"
+    rc.write_text("language.inc=php\n")
+    save(tmp_path, [inc, py])
+    assert pending(tmp_path) == set()
+    rc.write_text("# Same declaration, different spelling\nlanguage.inc=.PHP\n")
+    save(tmp_path, [py])
+    assert pending(tmp_path) == set()
+    rc.write_text("language.inc=pascal\n")
+    save(tmp_path, [py])
+    assert pending(tmp_path) == {"legacy.inc"}
+
+
+@pytest.mark.parametrize("kind", ["ast", "semantic", "both"])
+def test_saving_one_tier_does_not_validate_the_other_old_language(tmp_path, kind):
+    inc = tmp_path / "legacy.inc"
+    inc.write_text("<?php function hello() {}\n")
+    save(tmp_path, [inc])
+    assert pending(tmp_path, "ast") == pending(tmp_path, "semantic") == set()
+    (tmp_path / ".graphifyrc").write_text("language.inc=php\n")
+    save(tmp_path, [inc], kind)
+    assert pending(tmp_path, "ast") == ({inc.name} if kind == "semantic" else set())
+    assert pending(tmp_path, "semantic") == ({inc.name} if kind == "ast" else set())
+
+
+@pytest.mark.parametrize("shape", ["mtime", "hash", "tiers"])
+def test_legacy_manifest_stays_warm_until_a_language_override_applies(tmp_path, shape):
+    inc = tmp_path / "legacy.inc"
+    inc.write_text("<?php function hello() {}\n")
+    stamp = inc.stat().st_mtime
+    digest = hashlib.md5(inc.read_bytes()).hexdigest()
+    entry = {
+        "mtime": stamp,
+        "hash": {"mtime": stamp, "hash": digest},
+        "tiers": {"mtime": stamp, "ast_hash": digest, "semantic_hash": digest},
+    }[shape]
+    manifest(tmp_path).parent.mkdir()
+    manifest(tmp_path).write_text(json.dumps({inc.name: entry}))
+    assert pending(tmp_path) == set()
+    (tmp_path / ".graphifyrc").write_text("language.inc=php\n")
+    assert pending(tmp_path) == {inc.name}
+
+
+def test_save_uses_explicit_root_not_another_roots_active_override(tmp_path):
+    left, right = tmp_path / "left", tmp_path / "right"
+    left.mkdir()
+    right.mkdir()
+    inc = left / "legacy.inc"
+    inc.write_text("<?php function hello() {}\n")
+    (left / ".graphifyrc").write_text("language.inc=php\n")
+    pending(right)
+    save(left, [inc])
+    assert pending(left) == set()
+
+
+def drive_watch(root, monkeypatch, actions, *, observed_roots=None):
+    """Dispatch real watchdog events on a joined observer thread; run real rebuilds."""
+    observers = pytest.importorskip("watchdog.observers")
+    polling = pytest.importorskip("watchdog.observers.polling")
+    handler = None
+
+    class Observer:
+        def schedule(self, value, *args, **kwargs):
+            nonlocal handler
+            handler = value
+            if observed_roots is not None:
+                observed_roots.append(args[0])
+
+        def start(self):
+            pass
+
+        def stop(self):
+            pass
+
+        def join(self):
+            pass
+
+    original_rebuild = watch_mod._rebuild_code
+
+    def rebuild(path, **kwargs):
+        kwargs["no_cluster"] = True
+        return original_rebuild(path, **kwargs)
+
+    steps = iter(actions)
+
+    def pump(_seconds):
+        try:
+            event = next(steps)()
+        except StopIteration:
+            raise KeyboardInterrupt
+        errors = []
+
+        def dispatch():
+            try:
+                for notification in event if isinstance(event, list) else [event]:
+                    handler.on_any_event(notification)
+            except BaseException as error:
+                errors.append(error)
+
+        worker = threading.Thread(target=dispatch)
+        worker.start()
+        worker.join(timeout=5)
+        assert not worker.is_alive(), "STUCK: watcher event handler did not return"
+        assert not errors, errors
+
+    monkeypatch.setattr(observers, "Observer", Observer)
+    monkeypatch.setattr(polling, "PollingObserver", Observer)
+    monkeypatch.setattr(watch_mod, "_rebuild_code", rebuild)
+    monkeypatch.setattr(watch_mod.time, "sleep", pump)
+    watch_mod.watch(root, debounce=0)
+
+
+def graph_labels(root):
+    graph = json.loads((root / "graphify-out" / "graph.json").read_text())
+    return {node["label"] for node in graph["nodes"]}
+
+
+def test_watch_declared_code_updates_graph_on_observer_thread(tmp_path, monkeypatch):
+    events = pytest.importorskip("watchdog.events")
+    (tmp_path / ".graphifyrc").write_text("language.tpl=php\n")
+    source = tmp_path / "page.tpl"
+
+    def change():
+        source.write_text("<?php function watched() {}\n")
+        return events.FileModifiedEvent(str(source))
+
+    drive_watch(tmp_path, monkeypatch, [change])
+    assert "watched()" in graph_labels(tmp_path)
+    assert not (tmp_path / "graphify-out" / "needs_update").exists()
+
+
+def test_watch_document_override_marks_semantic_work_instead_of_rebuilding(tmp_path, monkeypatch):
+    events = pytest.importorskip("watchdog.events")
+    (tmp_path / ".graphifyrc").write_text("language.tpl=yaml\n")
+    source = tmp_path / "notes.tpl"
+
+    def change():
+        source.write_text("service: database\n")
+        return events.FileModifiedEvent(str(source))
+
+    drive_watch(tmp_path, monkeypatch, [change])
+    assert (tmp_path / "graphify-out" / "needs_update").read_text() == "1"
+    assert not (tmp_path / "graphify-out" / "graph.json").exists()
+
+
+@pytest.mark.parametrize("operation", ["create", "modify", "replace", "delete"])
+def test_watch_root_config_lifecycle_rebuilds_and_refreshes_event_mapping(tmp_path, monkeypatch, operation):
+    events = pytest.importorskip("watchdog.events")
+    rc = tmp_path / ".graphifyrc"
+    source = tmp_path / "page.tpl"
+    source.write_text("<?php function initial() {}\n")
+    (tmp_path / "stable.py").write_text("def stable(): pass\n")
+    if operation != "create":
+        rc.write_text("language.tpl=pascal\n")
+
+    def config_change():
+        if operation == "delete":
+            rc.unlink()
+            return events.FileDeletedEvent(str(rc))
+        if operation == "replace":
+            temporary = tmp_path / ".config-new"
+            temporary.write_text("language.tpl=php\n")
+            temporary.replace(rc)
+            return events.FileMovedEvent(str(temporary), str(rc))
+        rc.write_text("language.tpl=php\n")
+        return events.FileModifiedEvent(str(rc))
+
+    def source_change():
+        source.write_text("<?php function changed() {}\n")
+        return events.FileModifiedEvent(str(source))
+
+    drive_watch(tmp_path, monkeypatch, [config_change] + ([] if operation == "delete" else [source_change]))
+    labels = graph_labels(tmp_path)
+    assert "stable()" in labels
+    if operation != "delete":
+        assert "changed()" in labels
+        assert "initial()" not in labels
+
+
+@pytest.mark.parametrize("ignored", ["nested-config", "ignored-directory", "output", "read-only"])
+def test_watch_keeps_ignored_and_read_only_events_inert(tmp_path, monkeypatch, ignored):
+    events = pytest.importorskip("watchdog.events")
+    (tmp_path / ".graphifyrc").write_text("language.tpl=php\n")
+    (tmp_path / ".graphifyignore").write_text("ignored/\n")
+    stable = tmp_path / "stable.py"
+    stable.write_text("def stable(): pass\n")
+
+    def ignored_change():
+        if ignored == "read-only":
+            return events.FileOpenedEvent(str(stable))
+        path = tmp_path / {"nested-config": "nested/.graphifyrc", "ignored-directory": "ignored/file.tpl", "output": "graphify-out/cache/file.py"}[ignored]
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text("language.tpl=php\n" if ignored == "nested-config" else "def ignored(): pass\n")
+        return events.FileModifiedEvent(str(path))
+
+    drive_watch(tmp_path, monkeypatch, [ignored_change])
+    assert not (tmp_path / "graphify-out" / "graph.json").exists()
+    assert not (tmp_path / "graphify-out" / "needs_update").exists()
+
+
+@pytest.mark.parametrize("with_document_event", [False, True])
+def test_watch_config_changes_keep_semantic_work_visible(tmp_path, monkeypatch, with_document_event):
+    events = pytest.importorskip("watchdog.events")
+    rc = tmp_path / ".graphifyrc"
+    document = tmp_path / "notes.md"
+    (tmp_path / "stable.py").write_text("def stable(): pass\n")
+    (tmp_path / "data.tpl").write_text("service: database\n")
+
+    def change():
+        rc.write_text("language.tpl=yaml\n")
+        batch = [events.FileModifiedEvent(str(rc))]
+        if with_document_event:
+            document.write_text("# Changed document\n")
+            batch.append(events.FileModifiedEvent(str(document)))
+        return batch
+
+    drive_watch(tmp_path, monkeypatch, [change])
+    assert "stable()" in graph_labels(tmp_path)
+    assert (tmp_path / "graphify-out" / "needs_update").read_text() == "1"
+
+
+@pytest.mark.parametrize("argument", [".", "src"])
+def test_watch_relative_roots_receive_config_events_without_rebasing_source_paths(tmp_path, monkeypatch, argument):
+    events = pytest.importorskip("watchdog.events")
+    monkeypatch.chdir(tmp_path)
+    root = tmp_path / argument
+    root.mkdir(exist_ok=True)
+    (root / "page.tpl").write_text("<?php function watched() {}\n")
+    registered_roots = []
+
+    def change():
+        (root / ".graphifyrc").write_text("language.tpl=php\n")
+        return events.FileModifiedEvent(str(Path(registered_roots[0]) / ".graphifyrc"))
+
+    drive_watch(Path(argument), monkeypatch, [change], observed_roots=registered_roots)
+    graph = json.loads((root / "graphify-out" / "graph.json").read_text())
+    paths = {node["source_file"] for node in graph["nodes"] if node["label"] == "watched()"}
+    assert paths == {str(Path(argument) / "page.tpl")}

From a59563e5c0f63d6a71eaf7df6c4c97ae30564098 Mon Sep 17 00:00:00 2001
From: Andre Brait <andrebrait@gmail.com>
Date: Sat, 12 Sep 2026 21:33:25 +0000
Subject: [PATCH 3/3] fix(config): close reviewed override eligibility gaps

---
 graphify/csharp_dispatch.py             |   8 +-
 graphify/extract.py                     |  14 +--
 graphify/extractors/resolution.py       |  18 ++--
 graphify/watch.py                       |  14 +--
 tests/test_pr10_csharp_overrides.py     |  72 +++++++++++++++
 tests/test_pr10_resolution_overrides.py | 113 ++++++++++++++++++++++++
 tests/test_pr10_watch_overrides.py      |  25 ++++++
 7 files changed, 240 insertions(+), 24 deletions(-)
 create mode 100644 tests/test_pr10_csharp_overrides.py
 create mode 100644 tests/test_pr10_resolution_overrides.py
 create mode 100644 tests/test_pr10_watch_overrides.py

diff --git a/graphify/csharp_dispatch.py b/graphify/csharp_dispatch.py
index 4982e67728..0396b5d558 100644
--- a/graphify/csharp_dispatch.py
+++ b/graphify/csharp_dispatch.py
@@ -26,7 +26,7 @@
 """
 from __future__ import annotations
 
-_CSHARP_SUFFIXES = (".cs",)
+from graphify.extractors.csharp import _is_cs_file
 
 DISPATCH_RELATION = "dispatches_to"
 
@@ -44,7 +44,7 @@ def _is_csharp(node: dict | None) -> bool:
     if not node:
         return False
     source_file = node.get("source_file")
-    return bool(source_file) and str(source_file).endswith(_CSHARP_SUFFIXES)
+    return bool(source_file) and _is_cs_file(str(source_file))
 
 
 def _method_label(node: dict) -> str:
@@ -74,11 +74,11 @@ def resolve_csharp_interface_dispatch(
     place, since the call site really does name the interface.
     """
     if not any(
-        str(result.get("source_file", "")).endswith(_CSHARP_SUFFIXES)
+        _is_csharp(result)
         for result in per_file
         if isinstance(result, dict)
     ) and not any(
-        str(n.get("source_file", "")).endswith(_CSHARP_SUFFIXES) for n in all_nodes
+        _is_csharp(n) for n in all_nodes
     ):
         return
 
diff --git a/graphify/extract.py b/graphify/extract.py
index 0badb6c7e0..ed78e8c23c 100644
--- a/graphify/extract.py
+++ b/graphify/extract.py
@@ -45,6 +45,8 @@
 from graphify.extractors.blade import extract_blade  # noqa: F401
 from graphify.extractors.csharp import (
     CsharpNameResolver,
+    _is_cs_file,
+    _is_dotnet_source_file,
     _resolve_cross_file_csharp_imports,
     _resolve_csharp_type_references,
 )
@@ -2900,7 +2902,7 @@ def _names_own_builtin_base(edge: dict, stub_id: str, remapped_id: str) -> bool:
         return target_fam is not None and target_fam != edge_fam
     for edge in edges:
         is_csharp_scoped_edge = (
-            str(edge.get("source_file", "")).endswith((".cs", ".razor", ".cshtml"))
+            _is_dotnet_source_file(str(edge.get("source_file", "")))
             and edge.get("relation") in csharp_scoped_relations
         )
         source = edge.get("source")
@@ -2908,7 +2910,7 @@ def _names_own_builtin_base(edge: dict, stub_id: str, remapped_id: str) -> bool:
             remapped_source = remap[str(source)]
             if not (
                 is_csharp_scoped_edge
-                and str(by_id.get(remapped_source, {}).get("source_file", "")).endswith(".cs")
+                and _is_cs_file(str(by_id.get(remapped_source, {}).get("source_file", "")))
             ):
                 edge["source"] = remapped_source
         target = edge.get("target")
@@ -2916,7 +2918,7 @@ def _names_own_builtin_base(edge: dict, stub_id: str, remapped_id: str) -> bool:
             remapped_target = remap[str(target)]
             if not (
                 is_csharp_scoped_edge
-                and str(by_id.get(remapped_target, {}).get("source_file", "")).endswith(".cs")
+                and _is_cs_file(str(by_id.get(remapped_target, {}).get("source_file", "")))
             ) and not _names_own_builtin_base(edge, str(target), remapped_target):
                 edge["target"] = remapped_target
 
@@ -3097,7 +3099,7 @@ def _merge_csharp_partial_class_nodes(
     """
     groups: dict[tuple[str, str], list[dict]] = {}
     for n in all_nodes:
-        if not str(n.get("source_file", "")).endswith(".cs"):
+        if not _is_cs_file(str(n.get("source_file", ""))):
             continue
         if n.get("file_type") != "code":
             continue
@@ -3961,7 +3963,7 @@ def _key(label: str) -> str:
         if e.get("relation") != "inherits":
             continue
         src_file = e.get("source_file")
-        if not (isinstance(src_file, str) and src_file.endswith(".cs")):
+        if not _is_cs_file(src_file):
             continue
         src, tgt = e.get("source"), e.get("target")
         if not (isinstance(src, str) and isinstance(tgt, str)):
@@ -7563,7 +7565,7 @@ def _has_import_evidence(candidate_id: str) -> bool:
         # legitimately call across files without an explicit import. Scoped to
         # direct calls: the indirect_call path above is already conservative
         # (INFERRED, callable-target-gated) and independent of import evidence.
-        if not has_import_evidence and str(rc.get("source_file", "")).endswith(_JS_TS_CALL_SUFFIXES):
+        if not has_import_evidence and effective_suffix(str(rc.get("source_file", ""))) in _JS_TS_CALL_SUFFIXES:
             continue
         if tgt != caller and (caller, tgt) not in existing_pairs:
             existing_pairs.add((caller, tgt))
diff --git a/graphify/extractors/resolution.py b/graphify/extractors/resolution.py
index a8ea23d244..8000ae886b 100644
--- a/graphify/extractors/resolution.py
+++ b/graphify/extractors/resolution.py
@@ -56,11 +56,11 @@ def _resolve_js_import_path(candidate: Path) -> Path:
     # TS ESM convention: imports often spell .js/.jsx while source is .ts/.tsx.
     if candidate.suffix == ".js":
         ts_candidate = candidate.with_suffix(".ts")
-        if ts_candidate.is_file():
+        if ts_candidate.is_file() and effective_suffix(ts_candidate) in _JS_CACHE_BYPASS_SUFFIXES:
             return ts_candidate
     elif candidate.suffix == ".jsx":
         tsx_candidate = candidate.with_suffix(".tsx")
-        if tsx_candidate.is_file():
+        if tsx_candidate.is_file() and effective_suffix(tsx_candidate) in _JS_CACHE_BYPASS_SUFFIXES:
             return tsx_candidate
 
     declared_exts = _declared_language_suffixes(_JS_RESOLVE_EXTS)
@@ -70,7 +70,7 @@ def _resolve_js_import_path(candidate: Path) -> Path:
     # Native suffixes retain precedence over declared ones.
     for ext in _JS_RESOLVE_EXTS + declared_exts:
         with_ext = candidate.parent / f"{candidate.name}{ext}"
-        if with_ext.is_file():
+        if with_ext.is_file() and effective_suffix(with_ext) in _JS_CACHE_BYPASS_SUFFIXES:
             return with_ext
 
     # Only fall back to directory indexes after file candidates lose, native
@@ -78,7 +78,7 @@ def _resolve_js_import_path(candidate: Path) -> Path:
     if candidate.is_dir():
         for index_name in _JS_INDEX_FILES:
             index_candidate = candidate / index_name
-            if index_candidate.is_file():
+            if index_candidate.is_file() and effective_suffix(index_candidate) in _JS_CACHE_BYPASS_SUFFIXES:
                 return index_candidate
         for ext in declared_exts:
             index_candidate = candidate / f"index{ext}"
@@ -2085,7 +2085,11 @@ def _python_imported_names(node, source: bytes) -> list[tuple[str, str]]:
     return names
 
 def _is_python_package_dir(directory: Path, suffixes: tuple[str, ...] = (".py",)) -> bool:
-    if any((directory / f"__init__{suffix}").is_file() for suffix in suffixes):
+    if any(
+        (directory / f"__init__{suffix}").is_file()
+        and effective_suffix(directory / f"__init__{suffix}") in suffixes
+        for suffix in suffixes
+    ):
         return True
     return any(
         (directory / f"__init__{suffix}").is_file()
@@ -2110,14 +2114,14 @@ def _probe_python_module_candidate(candidate: Path) -> Path | None:
     """Resolve native Python modules and packages before declared suffixes."""
     if candidate.is_dir():
         init_path = candidate / "__init__.py"
-        if init_path.is_file():
+        if init_path.is_file() and effective_suffix(init_path) == ".py":
             return init_path
     if candidate.is_file():
         return candidate
     if not candidate.name:
         return _probe_declared_python_module_candidate(candidate)
     py_candidate = candidate.with_suffix(".py")
-    if py_candidate.is_file():
+    if py_candidate.is_file() and effective_suffix(py_candidate) == ".py":
         return py_candidate
     return _probe_declared_python_module_candidate(candidate)
 
diff --git a/graphify/watch.py b/graphify/watch.py
index b1a0392b9b..ff1895e600 100644
--- a/graphify/watch.py
+++ b/graphify/watch.py
@@ -2230,13 +2230,6 @@ def on_any_event(self, event):
             if event.is_directory or _is_read_only_event(event):
                 return
             path = Path(os.fsdecode(event.src_path))
-            # Check .graphifyignore BEFORE the extension/dotfile/out filters so
-            # the cheapest short-circuit for users with broad ignore patterns
-            # (node_modules/, .venv/, build/, …) fires first. _is_ignored
-            # tolerates absolute paths outside watch_root via its internal
-            # relative_to guard, so a stray symlinked event won't raise.
-            if ignore_patterns and _is_ignored(path, watch_root_for_ignore, ignore_patterns):
-                return
             # Atomic replacement reports the new root config in dest_path.
             dest_raw = getattr(event, "dest_path", None)
             dest_path = Path(os.fsdecode(dest_raw)) if dest_raw else None
@@ -2246,6 +2239,13 @@ def on_any_event(self, event):
                 last_trigger = time.monotonic()
                 pending = True
                 return
+            # Check .graphifyignore BEFORE the extension/dotfile/out filters so
+            # the cheapest short-circuit for users with broad ignore patterns
+            # (node_modules/, .venv/, build/, …) fires first. _is_ignored
+            # tolerates absolute paths outside watch_root via its internal
+            # relative_to guard, so a stray symlinked event won't raise.
+            if ignore_patterns and _is_ignored(path, watch_root_for_ignore, ignore_patterns):
+                return
             set_language_overrides(override_snapshot)
             if effective_suffix(path).lower() not in _WATCHED_EXTENSIONS:
                 return
diff --git a/tests/test_pr10_csharp_overrides.py b/tests/test_pr10_csharp_overrides.py
new file mode 100644
index 0000000000..beb333531b
--- /dev/null
+++ b/tests/test_pr10_csharp_overrides.py
@@ -0,0 +1,72 @@
+from pathlib import Path
+
+import pytest
+
+from tests.test_csharp_interface_dispatch import _INJECTED
+from tests.test_csharp_partial_classes import _HALVES, _find
+from tests.test_language_overrides import _no_overrides_leak as _no_overrides_leak
+from tests.test_language_overrides import _quiet_extract
+
+
+def _extract_declared(tmp_path, monkeypatch, files, suffix):
+    monkeypatch.chdir(tmp_path)
+    (tmp_path / ".graphifyrc").write_text("language.rzr=csharp\n", encoding="utf-8")
+    paths = []
+    for name, source in files.items():
+        path = tmp_path / Path(name).with_suffix(suffix)
+        path.write_text(source, encoding="utf-8")
+        paths.append(path)
+    return _quiet_extract(paths, root=tmp_path, cache_root=tmp_path / ".cache")
+
+
+@pytest.mark.parametrize("suffix", [".cs", ".rzr"])
+def test_partial_halves_share_one_class_and_both_members(tmp_path, monkeypatch, suffix):
+    result = _extract_declared(tmp_path, monkeypatch, _HALVES, suffix)
+    classes = [node for node in result["nodes"] if node["label"] == "Foo"]
+    assert len(classes) == 1, "partial halves must merge into one Foo declaration"
+    members = {
+        edge["target"] for edge in result["edges"]
+        if edge["relation"] == "method" and edge["source"] == classes[0]["id"]
+    }
+    assert members == {
+        _find(result, ".Alpha()", "foo"),
+        _find(result, ".Beta()", "foo"),
+    }
+
+
+@pytest.mark.parametrize("suffix", [".cs", ".rzr"])
+def test_derived_receiver_calls_the_inherited_base_method(tmp_path, monkeypatch, suffix):
+    result = _extract_declared(tmp_path, monkeypatch, {
+        "S.cs": (
+            "public class BaseSvc { public bool Ping() => true; }\n"
+            "public class Derived : BaseSvc { }\n"
+            "public class User {\n"
+            "    public bool Use(Derived d) { return d.Ping(); }\n"
+            "}\n"
+        ),
+    }, suffix)
+    calls = {
+        (edge["source"], edge["target"]) for edge in result["edges"]
+        if edge["relation"] == "calls"
+    }
+    assert (
+        _find(result, ".Use()", "user"),
+        _find(result, ".Ping()", "basesvc"),
+    ) in calls
+
+
+@pytest.mark.parametrize("suffix", [".cs", ".rzr"])
+def test_injected_interface_dispatches_to_its_implementation(tmp_path, monkeypatch, suffix):
+    result = _extract_declared(tmp_path, monkeypatch, _INJECTED, suffix)
+    interface_method = _find(result, ".Build()", "ireport")
+    implementation_method = _find(result, ".Build()", "report_report")
+    calls = {
+        (edge["source"], edge["target"]) for edge in result["edges"]
+        if edge["relation"] == "calls"
+    }
+    dispatch = {
+        (edge["source"], edge["target"]) for edge in result["edges"]
+        if edge["relation"] == "dispatches_to"
+    }
+    assert (_find(result, ".Go()", "runner"), interface_method) in calls
+    assert dispatch == {(interface_method, implementation_method)}
diff --git a/tests/test_pr10_resolution_overrides.py b/tests/test_pr10_resolution_overrides.py
new file mode 100644
index 0000000000..0acf231de1
--- /dev/null
+++ b/tests/test_pr10_resolution_overrides.py
@@ -0,0 +1,113 @@
+"""PR10: inferred candidates and call scope honor declared languages."""
+
+import pytest
+
+from graphify.extractors import resolution
+from graphify.rcfile import activate_language_overrides, set_language_overrides
+from tests.test_language_overrides import _quiet_extract
+
+
+@pytest.fixture(autouse=True)
+def _restore_language_overrides():
+    set_language_overrides(None)
+    yield
+    set_language_overrides(None)
+
+
+@pytest.mark.parametrize("remap_native", [False, True])
+@pytest.mark.parametrize("layout", ["file", "index", "esm"])
+def test_js_inferred_candidates_respect_language_and_native_precedence(
+    tmp_path, layout, remap_native
+):
+    config = "language.tpl=typescript\n"
+    if remap_native:
+        config += "language.ts=php\n"
+    (tmp_path / ".graphifyrc").write_text(config, encoding="utf-8")
+    activate_language_overrides(tmp_path)
+    candidate = tmp_path / ("dep.js" if layout == "esm" else "dep")
+    if layout == "index":
+        candidate.mkdir()
+        native, declared = candidate / "index.ts", candidate / "index.tpl"
+    else:
+        native, declared = tmp_path / "dep.ts", tmp_path / "dep.tpl"
+    native.write_text(
+        "<?php function foreign() {}" if remap_native else "export function native() {}",
+        encoding="utf-8",
+    )
+    declared.write_text("export function declared() {}", encoding="utf-8")
+
+    # A missing explicit .js path stays unresolved; it must not substitute PHP.
+    expected = (candidate if layout == "esm" else declared) if remap_native else native
+    assert resolution._resolve_js_module_path(candidate) == expected
+
+
+@pytest.mark.parametrize("remap_native", [False, True])
+@pytest.mark.parametrize("layout", ["module", "package"])
+def test_python_inferred_candidates_respect_language_and_native_precedence(
+    tmp_path, layout, remap_native
+):
+    config = "language.pyx=python\n"
+    if remap_native:
+        config += "language.py=javascript\n"
+    (tmp_path / ".graphifyrc").write_text(config, encoding="utf-8")
+    activate_language_overrides(tmp_path)
+    if layout == "package":
+        package = tmp_path / "dep"
+        package.mkdir()
+        native, declared = package / "__init__.py", package / "__init__.pyx"
+    else:
+        native, declared = tmp_path / "dep.py", tmp_path / "dep.pyx"
+    native.write_text(
+        "export function foreign() {}" if remap_native else "def native(): pass\n",
+        encoding="utf-8",
+    )
+    declared.write_text("def declared(): pass\n", encoding="utf-8")
+
+    assert resolution._resolve_python_module_path(
+        "dep", tmp_path / "caller.pyx", tmp_path, 0
+    ) == (declared if remap_native else native)
+
+
+@pytest.mark.parametrize(
+    "config, marker, expected",
+    [
+        ("language.pyx=python\n", "__init__.py", True),
+        ("language.py=javascript\nlanguage.pyx=python\n", "__init__.py", False),
+        ("language.py=javascript\nlanguage.pyx=python\n", "__init__.pyx", True),
+    ],
+)
+def test_python_package_marker_must_be_python(tmp_path, config, marker, expected):
+    (tmp_path / ".graphifyrc").write_text(config, encoding="utf-8")
+    (tmp_path / marker).write_text("", encoding="utf-8")
+    activate_language_overrides(tmp_path)
+
+    assert resolution._is_python_package_dir(tmp_path) is expected
+
+
+@pytest.mark.parametrize("caller_suffix", [".ts", ".tpl"])
+@pytest.mark.parametrize("has_import", [False, True])
+def test_js_cross_file_call_requires_an_import(tmp_path, caller_suffix, has_import):
+    (tmp_path / ".graphifyrc").write_text("language.tpl=typescript\n", encoding="utf-8")
+    provider = tmp_path / "provider.ts"
+    caller = tmp_path / f"caller{caller_suffix}"
+    provider.write_text("export function hidden() {}\n", encoding="utf-8")
+    caller.write_text(
+        ("import { hidden } from './provider';\n" if has_import else "")
+        + "export function caller() { hidden(); }\n",
+        encoding="utf-8",
+    )
+
+    result = _quiet_extract([provider, caller], root=tmp_path, cache_root=tmp_path)
+    caller_id = next(
+        node["id"] for node in result["nodes"]
+        if node.get("source_file") == caller.name and node["label"] == "caller()"
+    )
+    provider_id = next(
+        node["id"] for node in result["nodes"]
+        if node.get("source_file") == provider.name and node["label"] == "hidden()"
+    )
+    assert any(
+        edge["source"] == caller_id and edge["target"] == provider_id
+        and edge["relation"] == "calls"
+        for edge in result["edges"]
+    ) is has_import
diff --git a/tests/test_pr10_watch_overrides.py b/tests/test_pr10_watch_overrides.py
new file mode 100644
index 0000000000..1ade230ee3
--- /dev/null
+++ b/tests/test_pr10_watch_overrides.py
@@ -0,0 +1,25 @@
+"""Root configuration controls extraction even when excluded from the corpus."""
+import pytest
+
+from tests.test_language_override_lifecycle import drive_watch, graph_labels
+
+
+@pytest.mark.parametrize("replacement", [False, True])
+def test_ignored_root_configuration_still_rebuilds_the_graph(tmp_path, monkeypatch, replacement):
+    events = pytest.importorskip("watchdog.events")
+    (tmp_path / ".graphifyignore").write_text(".*\n" if replacement else ".graphifyrc\n")
+    (tmp_path / "page.tpl").write_text("<?php function configured() {}\n")
+    config = tmp_path / ".graphifyrc"
+
+    def change():
+        if replacement:
+            staged = tmp_path / ".replacement"
+            staged.write_text("language.tpl=php\n")
+            staged.replace(config)
+            return events.FileMovedEvent(str(staged), str(config))
+        config.write_text("language.tpl=php\n")
+        return events.FileModifiedEvent(str(config))
+
+    drive_watch(tmp_path, monkeypatch, [change])
+    assert "configured()" in graph_labels(tmp_path)
+    assert (tmp_path / "graphify-out" / "needs_update").read_text() == "1"