[Bug]: C#: nested types imported with using static are never resolved #4216

--- a/graphify/extract.py
+++ b/graphify/extract.py
@@ -7494,6 +7494,89 @@
 _PARALLEL_THRESHOLD = 20
 
 
+def _csharp_build_nested_index(all_nodes: list[dict], all_edges: list[dict]):
+    """Holder type of each nested C# type, the parent chain of each member, and the
+    `using static` imports per file -- all read from edges the extractor already emits."""
+    by_id = {n.get("id"): n for n in all_nodes if isinstance(n.get("id"), str)}
+
+    def _type_key(node: dict) -> tuple[str, str]:
+        md = node.get("metadata") or {}
+        ns = md.get("namespace", "") if isinstance(md, dict) else ""
+        return (ns if isinstance(ns, str) else "", str(node.get("label") or ""))
+
+    container: dict[str, tuple[str, str]] = {}
+    parent: dict[str, str] = {}
+    static_usings: dict[str, list[tuple[str, str, str | None]]] = {}
+    for edge in all_edges:
+        rel = edge.get("relation")
+        src = by_id.get(edge.get("source"))
+        tgt = by_id.get(edge.get("target"))
+        if src is None:
+            continue
+        if rel in ("contains", "method") and tgt is not None:
+            label = str(src.get("label") or "")
+            if (
+                src.get("source_file")
+                and src.get("type") != "namespace"
+                and not label.endswith((".cs", ")"))
+            ):
+                parent.setdefault(tgt["id"], src["id"])
+                md = tgt.get("metadata") or {}
+                if rel == "contains" and isinstance(md, dict) and md.get("is_nested_type"):
+                    container[tgt["id"]] = _type_key(src)
+        elif rel == "imports":
+            md = edge.get("metadata") or {}
+            if isinstance(md, dict) and md.get("using_kind") == "static" and isinstance(md.get("target_fqn"), str):
+                static_usings.setdefault(str(src.get("source_file") or ""), []).append(
+                    (md["target_fqn"], md.get("scope_kind") or "file", md.get("scope_id"))
+                )
+    return by_id, container, parent, static_usings, _type_key
+
+
+def _csharp_nested_visible(idx, resolver, caller_node: dict, candidates: list[str]) -> str | None:
+    """The single candidate that is a nested type whose holder type the caller can see:
+    imported with `using static`, or enclosing the caller."""
+    by_id, container, parent, static_usings, type_key = idx
+    imported = {
+        fqn
+        for fqn, kind, scope_id in static_usings.get(str(caller_node.get("source_file") or ""), [])
+        if resolver._using_in_scope(kind, scope_id, caller_node)
+    }
+    enclosing: set[tuple[str, str]] = set()
+    cur, seen = caller_node.get("id"), set()
+    while cur in parent and cur not in seen:
+        seen.add(cur)
+        cur = parent[cur]
+        enclosing.add(type_key(by_id[cur]))
+    def _fqn(nid: str, depth: int = 0) -> str:
+        # Full name through the holder chain (`Demo.Print.Engine`).
+        node = by_id[nid]
+        outer = parent.get(nid)
+        if outer is not None and outer in by_id and nid in container and depth < 16:
+            return f"{_fqn(outer, depth + 1)}.{node.get('label')}"
+        ns, label = type_key(node)
+        return f"{ns}.{label}" if ns else label
+
+    hits = []
+    for cand in candidates:
+        key = container.get(cand)
+        if key is None:
+            continue
+        outer = parent.get(cand)
+        fqn = _fqn(outer) if outer in by_id else (f"{key[0]}.{key[1]}" if key[0] else key[1])
+        if fqn in imported or key in enclosing:
+            hits.append((fqn, cand))
+    # The parts of one partial nested type are separate nodes here; they are the
+    # same type, so they count once. Bind to the first part by source file, the
+    # same tie-break the C# type-definition index uses.
+    if len({fqn for fqn, _ in hits}) != 1:
+        return None
+    return min(
+        (cand for _, cand in hits),
+        key=lambda nid: (str(by_id[nid].get("source_file") or ""), str(by_id[nid].get("source_location") or ""), nid),
+    )
+
+
 def extract(
     paths: list[Path],
     cache_root: Path | None = None,
@@ -8641,6 +8724,7 @@
                 str(n.get("label", ""))
             )
     _csharp_stub_resolver: CsharpNameResolver | None = None  # built on first use
+    _csharp_nested_idx = None  # built on first use
     for rc in all_raw_calls:
         if rc.get("_ambiguous_python_import"):
             continue
@@ -8711,6 +8795,18 @@
             if scoped in candidates:
                 candidates = [scoped]
                 stub_scope_hit = True
+            elif scoped is None and rc.get("csharp_new") and caller_node is not None:
+                # Nested types are not in the type-definition index, so the resolver
+                # cannot see `new Record()` for `Layer.Record` even when the caller
+                # imports `Layer` with `using static` or sits inside `Layer`.
+                if _csharp_nested_idx is None:
+                    _csharp_nested_idx = _csharp_build_nested_index(all_nodes, all_edges)
+                nested_hit = _csharp_nested_visible(
+                    _csharp_nested_idx, _csharp_stub_resolver, caller_node, candidates
+                )
+                if nested_hit is not None:
+                    candidates = [nested_hit]
+                    stub_scope_hit = True
         # Cross-language guard: never bind a call to a definition in a different
         # language family. Name-only matching was resolving a TSX callback passed
         # by name to a same-named Kotlin method in the Android half of the repo