codmap 0.0.22__tar.gz → 0.0.24__tar.gz

{codmap-0.0.22/codmap.egg-info → codmap-0.0.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codmap
-Version: 0.0.22
+Version: 0.0.24
 Summary: Static analyzer that turns a package's source into a queryable code graph.
 Author-email: kogriv <kogriv@gmail.com>
 License-Expression: MIT
@@ -44,7 +44,7 @@ and a **SCIP index** for interop with Sourcegraph / Glean and other precise-code
 
 [![CI](https://github.com/kogriv/codemap/actions/workflows/ci.yml/badge.svg)](https://github.com/kogriv/codemap/actions/workflows/ci.yml)
 
-**Status:** 🟢 M0–M20 implemented + research track (R1/R2) — schema 0.13, **1054 tests with no failures on
+**Status:** 🟢 M0–M20 implemented + research track (R1/R2) — schema 0.13, **1128 tests with no failures on
 Python 3.11–3.14** ([in CI](docs/ci.md): the full suite including the dogfood pass, a determinism check, a
 wheel smoke test, and ctags/SCIP interop against the real CLIs), warm serve surface with 31 ops (28 exposed
 as MCP tools), and SCIP export. See **[DESIGN.md](DESIGN.md)** (product design &
@@ -107,18 +107,24 @@ answer.
 
 That sentence used to end at "None answers these", and a second pass over the 68k-star tool made it
 narrower: its *importable library* does carry a cycle finder, reachable from neither its CLI nor its MCP
-tools and called nowhere in its own source. Measured on the same tree it reports **136 cycles**; codemap
-reports **1**. Scoring both against the truth set — every intra-package import, function-local ones
-included — is less flattering than that sounds:
+tools and called nowhere in its own source. Measured on the same tree (its 1.6.0) it reported **136
+cycles**; codemap reported **1**. Scoring both against the truth set — every intra-package import,
+function-local ones included — is less flattering than that sounds:
 
-| | reported | of the 41 real ones | precision | recall |
+| | reported | of the 45 real ones | precision | recall |
 |---|---:|---:|---:|---:|
-| codemap, that morning | 1 | 1 | 100% | **2.4%** |
-| the peer's library API | 136 | 13 | 10% | 32% |
-| codemap, after R1-C29 | 41 | 41 | 100% | 100% |
-
-Theirs over-reports because it walks name-resolved call edges — a `dict.get` becomes a call into an
-unrelated class. **Ours under-reported because its import map was module-level only**, and it phrased
+| codemap, before R1-C29 | 1 | 1 | 100% | **2.2%** |
+| the peer's library API, 1.6.0 | 136 | 13 | 10% | 29% |
+| the peer's library API, **1.6.2** (re-measured 2026-10-15) | 25 | 16 | **64%** | 36% |
+| codemap, after R1-C29 (0.0.4) | 45 | 45 | 100% | 100% |
+
+*Corrected 2026-10-15.* This table first said **41** real cycles, recall 32% and 2.4%. The 41 were counted
+on a later commit of the same repository than the one both tools were measured on; on the measured tree
+there are 45 ([re-measure](research/codegraph_remeasure.md) §7, C3). The peer fixed the call edges we
+reported and its 1.6.2 row is the current one.
+
+Theirs over-reported because it walks name-resolved call edges — a `dict.get` became a call into an
+unrelated class (fixed upstream in 1.6.1). **Ours under-reported because its import map was module-level only**, and it phrased
 that as *"import graph is acyclic"* — a property claim over a partial map, which is the worse of the two
 errors even though it was the smaller one. Both halves of that came from
 [#11](https://github.com/kogriv/codemap/issues/11), filed off a different target and fixed the same day

{codmap-0.0.22 → codmap-0.0.24}/README.md

@@ -8,7 +8,7 @@ and a **SCIP index** for interop with Sourcegraph / Glean and other precise-code
 
 [![CI](https://github.com/kogriv/codemap/actions/workflows/ci.yml/badge.svg)](https://github.com/kogriv/codemap/actions/workflows/ci.yml)
 
-**Status:** 🟢 M0–M20 implemented + research track (R1/R2) — schema 0.13, **1054 tests with no failures on
+**Status:** 🟢 M0–M20 implemented + research track (R1/R2) — schema 0.13, **1128 tests with no failures on
 Python 3.11–3.14** ([in CI](docs/ci.md): the full suite including the dogfood pass, a determinism check, a
 wheel smoke test, and ctags/SCIP interop against the real CLIs), warm serve surface with 31 ops (28 exposed
 as MCP tools), and SCIP export. See **[DESIGN.md](DESIGN.md)** (product design &
@@ -71,18 +71,24 @@ answer.
 
 That sentence used to end at "None answers these", and a second pass over the 68k-star tool made it
 narrower: its *importable library* does carry a cycle finder, reachable from neither its CLI nor its MCP
-tools and called nowhere in its own source. Measured on the same tree it reports **136 cycles**; codemap
-reports **1**. Scoring both against the truth set — every intra-package import, function-local ones
-included — is less flattering than that sounds:
+tools and called nowhere in its own source. Measured on the same tree (its 1.6.0) it reported **136
+cycles**; codemap reported **1**. Scoring both against the truth set — every intra-package import,
+function-local ones included — is less flattering than that sounds:
 
-| | reported | of the 41 real ones | precision | recall |
+| | reported | of the 45 real ones | precision | recall |
 |---|---:|---:|---:|---:|
-| codemap, that morning | 1 | 1 | 100% | **2.4%** |
-| the peer's library API | 136 | 13 | 10% | 32% |
-| codemap, after R1-C29 | 41 | 41 | 100% | 100% |
-
-Theirs over-reports because it walks name-resolved call edges — a `dict.get` becomes a call into an
-unrelated class. **Ours under-reported because its import map was module-level only**, and it phrased
+| codemap, before R1-C29 | 1 | 1 | 100% | **2.2%** |
+| the peer's library API, 1.6.0 | 136 | 13 | 10% | 29% |
+| the peer's library API, **1.6.2** (re-measured 2026-10-15) | 25 | 16 | **64%** | 36% |
+| codemap, after R1-C29 (0.0.4) | 45 | 45 | 100% | 100% |
+
+*Corrected 2026-10-15.* This table first said **41** real cycles, recall 32% and 2.4%. The 41 were counted
+on a later commit of the same repository than the one both tools were measured on; on the measured tree
+there are 45 ([re-measure](research/codegraph_remeasure.md) §7, C3). The peer fixed the call edges we
+reported and its 1.6.2 row is the current one.
+
+Theirs over-reported because it walks name-resolved call edges — a `dict.get` became a call into an
+unrelated class (fixed upstream in 1.6.1). **Ours under-reported because its import map was module-level only**, and it phrased
 that as *"import graph is acyclic"* — a property claim over a partial map, which is the worse of the two
 errors even though it was the smaller one. Both halves of that came from
 [#11](https://github.com/kogriv/codemap/issues/11), filed off a different target and fixed the same day

{codmap-0.0.22 → codmap-0.0.24}/codemap/arch.py

@@ -104,8 +104,83 @@ def load_contract(root: str | Path = ".") -> ArchitectureContract:
     return replace(parse_contract(data.get("architecture", {})), path=str(path))
 
 
+#: R1-C69: the closed schema of ``[architecture]``. A key outside it is an error, not a skip.
+_FLAGS = ("no_cycles", "no_lazy_cycles", "no_type_only_cycles", "exhaustive", "no_phantom_rules")
+_KNOWN_KEYS = ("layers", "independent", "forbidden") + _FLAGS
+
+
+def _is_str_list(v) -> bool:
+    return isinstance(v, list) and all(isinstance(x, str) for x in v)
+
+
+def contract_problems(section) -> list[str]:
+    """Every way ``section`` departs from the ``[architecture]`` schema, in reading order (R1-C69).
+
+    Empty when the section is valid. Design ``docs/design/contract_validation.md`` D1: unknown
+    keys (with the nearest known one suggested), values of the wrong type — `"false"` is a
+    string and used to switch a rule *on* — and malformed items, each named by key and index.
+    Names that do not exist in the graph are not a schema question (D3, R1-C62).
+    """
+    import difflib
+
+    if not isinstance(section, dict):
+        return [f"`[architecture]` must be a table, got {type(section).__name__}"]
+    problems: list[str] = []
+    for key in section:
+        if key not in _KNOWN_KEYS:
+            near = difflib.get_close_matches(key, _KNOWN_KEYS, n=1, cutoff=0.6)
+            hint = f" (did you mean `{near[0]}`?)" if near else ""
+            problems.append(f"unknown key `{key}`{hint}; known keys: {', '.join(_KNOWN_KEYS)}")
+    if "layers" in section and not _is_str_list(section["layers"]):
+        problems.append("`layers` must be a list of strings")
+    if "independent" in section:
+        groups = section["independent"]
+        if not isinstance(groups, list):
+            problems.append("`independent` must be a list of lists of strings")
+        else:
+            for i, grp in enumerate(groups):
+                if not _is_str_list(grp) or len(grp) < 2:
+                    problems.append(f"`independent[{i}]` must be a list of at least 2 strings")
+    if "forbidden" in section:
+        items = section["forbidden"]
+        if not isinstance(items, list):
+            problems.append("`forbidden` must be a list of `{ from = \"…\", to = \"…\" }` tables")
+        else:
+            for i, item in enumerate(items):
+                if not isinstance(item, dict):
+                    problems.append(f"`forbidden[{i}]` must be a table `{{ from = \"…\", to = \"…\" }}`")
+                    continue
+                extra = sorted(set(item) - {"from", "to"})
+                missing = [k for k in ("from", "to") if k not in item]
+                wrong = [k for k in ("from", "to") if k in item and not isinstance(item[k], str)]
+                if extra:
+                    problems.append(f"`forbidden[{i}]` has unknown key(s) "
+                                    + ", ".join(f"`{k}`" for k in extra))
+                if missing:
+                    problems.append(f"`forbidden[{i}]` is missing " + ", ".join(f"`{k}`" for k in missing))
+                if wrong:
+                    problems.append(f"`forbidden[{i}]`: " + ", ".join(f"`{k}`" for k in wrong)
+                                    + " must be a string")
+    for flag in _FLAGS:
+        if flag in section and not isinstance(section[flag], bool):
+            problems.append(f"`{flag}` must be true or false, got {type(section[flag]).__name__} "
+                            f"`{section[flag]!r}`")
+    return problems
+
+
 def parse_contract(section: dict) -> ArchitectureContract:
-    """Build a contract from the parsed ``[architecture]`` table (validated leniently)."""
+    """Build a contract from the parsed ``[architecture]`` table.
+
+    R1-C69: validated against a closed schema first. A section with any problem is **not
+    enforced at all** — it comes back as an ``error`` contract, the R1-C27 path, so the CLI
+    exits 2 and MCP answers ``ok: false`` naming every problem. Enforcing the valid half used
+    to be the silent part: ``forbiden = [...]`` beside ``no_cycles = true`` printed a green
+    tick over a rule the gate never ran.
+    """
+    problems = contract_problems(section)
+    if problems:
+        return ArchitectureContract(
+            error="`[architecture]` is not a valid contract: " + "; ".join(problems))
     forbidden = []
     for item in section.get("forbidden", []) or []:
         if isinstance(item, dict) and "from" in item and "to" in item:

{codmap-0.0.22 → codmap-0.0.24}/codemap/cli.py

@@ -807,6 +807,12 @@ def _cmd_pack(args) -> int:
     return 1 if "error" in p else 0
 
 
+def _check_exit(violations, currency: dict | None, allow_stale: bool) -> int:
+    """2 on a violation, or on a graph behind its source unless ``--allow-stale`` (R1-C70)."""
+    behind = currency is not None and currency.get("status") == "behind"
+    return 2 if (violations or (behind and not allow_stale)) else 0
+
+
 def _cmd_check(args) -> int:
     """Enforce the [architecture] contract → exit 2 on any violation (R1-C3).
 
@@ -820,21 +826,28 @@ def _cmd_check(args) -> int:
     from codemap.serve.check import render_check
     q = Query(_graph_from(args))
     contract = load_contract(args.root)
+    # R1-C70: a graph read from disk may be behind the tree it is about to be judged as.
+    currency = None
+    if getattr(args, "graph", None) and not getattr(args, "build", None):
+        from codemap.serve.currency import graph_currency
+        currency = graph_currency(args.graph, (q.graph.provenance or {}).get("scope_id"))
+    allow_stale = getattr(args, "allow_stale", False)
     # R1-C27: check `error` before anything else. A malformed codemap.toml used to be
     # indistinguishable from an absent one, so removing a single `]` turned a gate that
     # reported 14 violations into exit 0. Exit 2 — the same code as a violation, not a new
     # one: the status answers "may the pipeline proceed?" (no, either way), and a new code
     # would sort an unreadable contract into the success branch of every `if rc == 2` that
     # already exists in someone's pipeline.
+    kw = {"currency": currency, "allow_stale": allow_stale}
     if contract.error:
-        _emit_answer(render_check(q, contract, []))
+        _emit_answer(render_check(q, contract, [], **kw))
         return 2
     if contract.is_empty() and args.require_contract:
-        _emit_answer(render_check(q, contract, []))
+        _emit_answer(render_check(q, contract, [], **kw))
         raise SystemExit("error: no [architecture] contract found (--require-contract)")
     violations = check_contract(q, contract)
-    _emit_answer(render_check(q, contract, violations))
-    return 2 if violations else 0
+    _emit_answer(render_check(q, contract, violations, **kw))
+    return _check_exit(violations, currency, allow_stale)
 
 
 def _cmd_diff(args) -> int:
@@ -969,8 +982,41 @@ def _add_source(p) -> None:
                    help="Deep call resolution via jedi (richer, ~1 min; default fast).")
 
 
+def version_line() -> str:
+    """``codemap 0.0.24 @abc1234 · answer format 4 · schema 0.13`` (R1-C73).
+
+    Built from ``provenance.tool_identity()`` — the identity every graph records as
+    ``provenance.tool`` — so the CLI and the artifact cannot disagree. Commit and dirtiness
+    appear only when known, as there; a missing distribution is said, never invented.
+    """
+    from codemap.model import ANSWER_FORMAT, SCHEMA_VERSION
+    from codemap.provenance import tool_identity
+    t = tool_identity()
+    head = f"codemap {t['version']}" if t.get("version") else \
+        "codemap version unknown (not installed as a distribution)"
+    if t.get("commit"):
+        head += f" @{t['commit']}"
+    if t.get("dirty"):
+        head += " (dirty)"
+    return f"{head} · answer format {ANSWER_FORMAT} · schema {SCHEMA_VERSION}"
+
+
+class _VersionAction(argparse.Action):
+    """``--version``, computed only when asked: ``tool_identity()`` calls git (design D1)."""
+
+    def __init__(self, option_strings, dest=argparse.SUPPRESS, default=argparse.SUPPRESS,
+                 help="Print the installed version, the answer format and the graph schema, then exit."):
+        super().__init__(option_strings=option_strings, dest=dest, default=default, nargs=0,
+                         help=help)
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        print(version_line())
+        parser.exit(0)
+
+
 def build_parser() -> argparse.ArgumentParser:
     p = argparse.ArgumentParser(prog="codemap", description="Static code-graph builder.")
+    p.add_argument("--version", action=_VersionAction)
     sub = p.add_subparsers(dest="command", required=True)
 
     b = sub.add_parser("build", help="Build the canonical graph from a package path.")
@@ -1173,6 +1219,9 @@ def build_parser() -> argparse.ArgumentParser:
                     help="Dir with codemap.toml holding [architecture] (default: cwd).")
     ck.add_argument("--require-contract", action="store_true",
                     help="Fail if no [architecture] contract is present (default: no-op success).")
+    ck.add_argument("--allow-stale", action="store_true",
+                    help="With --graph: do not fail when the graph is behind its source tree "
+                         "(R1-C70); the 'behind' line is still printed.")
     ck.set_defaults(func=_cmd_check)
 
     return p

{codmap-0.0.22 → codmap-0.0.24}/codemap/extract/attrflow.py

@@ -50,7 +50,7 @@ from codemap.extract.behavior import (
     _node_id,
     _own_nodes,
 )
-from codemap.extract.gsource import module_file, module_imports
+from codemap.extract.gsource import flat_inference_applies, module_file, module_imports
 from codemap.model import Edge
 
 
@@ -66,7 +66,8 @@ def add_attrflow(graph, griffe_root, target_pkg: str, *, deep: bool = False,
     (R1-C9), mirroring :func:`add_behavior`.
     """
     modules = _index_modules(griffe_root)
-    known_modules = set(modules)  # R1-C21: flat-layout sibling lookup
+    # R1-C21 sibling lookup, gated like behavior's (R1-C72).
+    known_modules = set(modules) if flat_inference_applies(graph, target_pkg) else frozenset()
     project = _jedi_project(search_path) if deep else None
     pkg = target_pkg + "."
     # (func_id, attr_id, access, resolution) — dedup collapses repeated sites.

{codmap-0.0.22 → codmap-0.0.24}/codemap/extract/behavior.py

@@ -27,8 +27,8 @@ import ast
 import math
 from pathlib import Path
 
-from codemap.extract.gsource import (NESTED_IMPORT_HINT, module_file, module_imports,
-                                     qualify_target)
+from codemap.extract.gsource import (NESTED_IMPORT_HINT, flat_inference_applies, module_file,
+                                     module_imports, qualify_target)
 from codemap.model import Edge
 
 _BUILTINS = set(vars(__import__("builtins")))
@@ -51,7 +51,9 @@ def add_behavior(graph, griffe_root, target_pkg: str, *, deep: bool = False,
     modules left out. When ``None`` (default) every module is processed.
     """
     modules = _index_modules(griffe_root)
-    known_modules = set(modules)  # R1-C21: flat-layout sibling lookup
+    # R1-C21 flat-layout sibling lookup — empty, so it never fires, in a core that imports
+    # itself by name (R1-C72): there `import warnings` is the standard library.
+    known_modules = set(modules) if flat_inference_applies(graph, target_pkg) else frozenset()
     project = _jedi_project(search_path) if deep else None
     # R1-C30-f1: a call to a re-exported name points at a name that is not a definition.
     # The structural pass already recorded where each re-export really leads.
@@ -81,11 +83,18 @@ def add_behavior(graph, griffe_root, target_pkg: str, *, deep: bool = False,
         # R1-C46: the surviving definition says which earlier bodies it replaced. Stamped
         # here because this pass holds the AST; the walkers below skip those bodies.
         _stamp_shadows(graph, tree, modpath)
+        walked_here: set[str] = set()   # R1-C74: nodes that already took a body in this module
+        shadow_skip = _shadow_map(tree)[0]
         for fnode, class_stack, scope in _named_functions_scoped(tree):
             node_id = _node_id(modpath, class_stack, fnode.name)
             local = local_imports.get(id(fnode))
             fn_imports = {**imports, **local} if local else imports
-            if node_id not in graph.nodes:
+            # R1-C74: a def nested in a function is never a definition node, whatever its
+            # name. `_node_id` sees only the class chain, so `def getfixturedefs` inside a method
+            # of `FixtureManager` used to *become* the method `FixtureManager.getfixturedefs` —
+            # its calls and edges attributed to a namesake (found by the conservation check).
+            nested_in_function = len(scope) > len(class_stack)
+            if node_id not in graph.nodes or nested_in_function:
                 # R1-C22 D3: a closure / dynamically-built class body is not a definition
                 # node, but the calls inside it are real. Attribute them to the innermost
                 # definition that *does* exist instead of discarding them.
@@ -101,7 +110,9 @@ def add_behavior(graph, griffe_root, target_pkg: str, *, deep: bool = False,
                 return _resolve(call, modpath, _cp, _im, _mm, _me, reexports, nodes)
             resolve = (_deep_then_fast(graph, script, target_pkg, fast, modpath, known_modules)
                        if script else fast)
-            _process_function(graph, node_id, fnode, resolve)
+            _process_function(graph, node_id, fnode, resolve,
+                              accumulate=node_id in walked_here)
+            walked_here.add(node_id)
             # R1-C22 D1: functions/classes named as *values* here (dispatch tables,
             # `default=` callbacks) — a use the call layer cannot see.
             _emit_name_references(graph, node_id, fnode, modpath, fn_imports, modmembers,
@@ -113,7 +124,11 @@ def add_behavior(graph, griffe_root, target_pkg: str, *, deep: bool = False,
         mod_resolve = (_deep_then_fast(graph, script, target_pkg, mod_fast, modpath, known_modules)
                        if script else mod_fast)
         _process_module_level(graph, modpath, tree, mod_resolve, imports, modmembers,
-                              reexports)
+                              reexports, shadow_skip=shadow_skip)
+        # R1-C74: class bodies run at import time and were walked by nobody.
+        _process_class_bodies(graph, modpath, tree, mod_resolve, imports, modmembers,
+                              script, target_pkg, nested, known_modules, reexports,
+                              skip=shadow_skip)
         _emit_nested_calls(graph, nested)
 
 
@@ -523,30 +538,49 @@ def _deep_then_fast(graph, script, target_pkg, fast, modpath, known_modules):
     return resolve
 
 
-def _process_function(graph, node_id, fnode, resolve) -> None:
-    counts = {"out": 0, "resolved": 0, "external": 0, "unresolved": 0, "dynamic": 0}
+def _new_counts() -> dict:
+    return {"out": 0, "resolved": 0, "external": 0, "unresolved": 0, "dynamic": 0}
+
+
+def _tally(counts: dict, graph, target, resolution) -> bool:
+    """Count one call site by how it resolved; True when it becomes an internal edge.
+
+    One rule for every scope (R1-C74): a function body, a nested function, module-level
+    code and a class body are classified the same way, so their counters can be summed
+    and checked against the source.
+    """
+    counts["out"] += 1
+    if resolution in _EDGE_RESOLUTIONS and target and target in graph.nodes:
+        counts["resolved"] += 1
+        return True
+    if resolution == "external":
+        counts["external"] += 1
+    elif resolution == "dynamic":
+        counts["dynamic"] += 1
+    else:
+        counts["unresolved"] += 1
+    return False
+
+
+def _process_function(graph, node_id, fnode, resolve, accumulate: bool = False) -> None:
+    """``accumulate``: this node already took a body in this pass (R1-C74). A name defined in
+    both branches of an ``if``/``try``, or a legitimate rebinding (a property's setter), keeps
+    *both* bodies walked (R1-C46) — their counts add up instead of the last overwriting."""
+    counts = _new_counts()
     # F7: edges are deduped caller->callee, so aggregate the per-call-site argument
     # contract before emitting — a refactorer needs "how is it called", and the
     # collapse itself (2 sites -> 1 edge) must stay visible via `callsites`.
     by_target: dict[str, dict] = {}
     for call in _own_calls(fnode):
-        counts["out"] += 1
         target, resolution = resolve(call)
         # Soundness (R1-C13-f1/f2): an internal call edge must point at a real
         # graph node. A resolver can name a non-node — a local variable jedi typed
         # to its own scope-path, or a nested/closure function that is not a
         # definition node — so downgrade any such target to unresolved rather than
         # emit an edge to nothing (which would poison callers/callees/impact).
-        if resolution in _EDGE_RESOLUTIONS and target and target in graph.nodes:
-            counts["resolved"] += 1
+        if _tally(counts, graph, target, resolution):
             agg = by_target.setdefault(target, {"resolution": resolution, "shapes": []})
             agg["shapes"].append(_arg_shape(call))
-        elif resolution == "external":
-            counts["external"] += 1
-        elif resolution == "dynamic":
-            counts["dynamic"] += 1
-        else:
-            counts["unresolved"] += 1
 
     for target in sorted(by_target):
         agg = by_target[target]
@@ -554,7 +588,11 @@ def _process_function(graph, node_id, fnode, resolve) -> None:
         graph.add_edge(Edge("calls", node_id, target, extras=extras))
 
     node = graph.nodes[node_id]
-    node.extras["calls"] = counts
+    if accumulate and "calls" in node.extras:
+        for k, v in counts.items():
+            node.extras["calls"][k] = node.extras["calls"].get(k, 0) + v
+    else:
+        node.extras["calls"] = counts
     node.extras["control"] = _control(fnode)
     node.extras["complexity"] = _complexity(fnode)
 
@@ -588,16 +626,33 @@ def _arg_contract(shapes: list[tuple]) -> dict:
     return contract
 
 
+def _is_internal(target: str, modpath: str) -> bool:
+    """R1-C71/D3: the package root is inside the package. ``startswith(pkg + ".")`` alone
+    filed ``import pkg; pkg.f()`` — and the bound name of ``import pkg.a.b`` — as external."""
+    root = modpath.split(".")[0]
+    return target == root or target.startswith(root + ".")
+
+
+def _attr_chain(node) -> tuple[str, list[str]] | None:
+    """``a.b.c`` → ``("a", ["b", "c"])`` when the chain bottoms out in a plain name."""
+    parts = []
+    while isinstance(node, ast.Attribute):
+        parts.append(node.attr)
+        node = node.value
+    if not isinstance(node, ast.Name):
+        return None
+    return node.id, parts[::-1]
+
+
 def _resolve(call, modpath, class_prefix, imports, modmembers, members, reexports=None,
              nodes=frozenset()):
     """Return (target_id, resolution). Only module/self/imported become edges."""
-    pkg = modpath.split(".")[0] + "."
     f = call.func
     if isinstance(f, ast.Name):
         name = f.id
         if name in imports:
             tgt = imports[name]
-            if tgt.startswith(pkg):
+            if _is_internal(tgt, modpath):
                 return _follow_reexport(tgt, reexports or {}, nodes), "imported"
             return tgt, "external"
         if name in modmembers:
@@ -613,13 +668,27 @@ def _resolve(call, modpath, class_prefix, imports, modmembers, members, reexport
                 # method call on self — resolve to the class that actually defines
                 # the member (own or a base), never a phantom same-class id.
                 return f"{members[attr]}.{attr}", "self"
-            if recv.id in imports:
-                tgt = imports[recv.id]
-                if tgt.startswith(pkg):
-                    return _follow_reexport(f"{tgt}.{attr}", reexports or {}, nodes), "imported"
-                return f"{tgt}.{attr}", "external"
-            if recv.id in modmembers:
+            if recv.id in modmembers and recv.id not in imports:
                 return f"{modpath}.{recv.id}.{attr}", "module"
+        # R1-C71 (design ``attribute_chain_calls.md``): a callee rooted at an imported name,
+        # at any depth. Internal: follow it hop by hop, each hop through a re-export when the
+        # name is no node (D1) — the depth-1 case is the one-hop instance and answers as it
+        # always did; the soundness guard downstream still refuses a target that is no node,
+        # so `b.registry.get()` stays unresolved. External: external at any depth (D2) —
+        # `np.random.rand()` is no more unknown than `np.zeros()`.
+        chain = _attr_chain(f)
+        if chain is not None and chain[0] in imports:
+            head, parts = chain
+            tgt = imports[head]
+            if not _is_internal(tgt, modpath):
+                return f"{tgt}.{'.'.join(parts)}", "external"
+            cur = tgt
+            for part in parts:
+                cur = _follow_reexport(f"{cur}.{part}", reexports or {}, nodes)
+            if len(parts) == 1 or cur in nodes:
+                return cur, "imported"
+            # a deeper chain that lands on no definition (`b.registry.get("k")`) keeps the
+            # answer it had before R1-C71: string-keyed dispatch, else unresolved
         # X.method('literal', ...) — dynamic string-keyed dispatch (registry/dict)
         if call.args and isinstance(call.args[0], ast.Constant) \
                 and isinstance(call.args[0].value, str) and attr in ("create", "get", "register"):
@@ -868,10 +937,9 @@ def _module_level_nodes(tree):
 def _resolve_name(name, modpath, imports, modmembers, reexports=None, nodes=frozenset()):
     """(target_id, resolution) for a bare name used as a value — the `_resolve` rules for
     ``ast.Name`` minus the call. Only module/imported become edges."""
-    pkg = modpath.split(".")[0] + "."
     if name in imports:
         tgt = imports[name]
-        if tgt.startswith(pkg):
+        if _is_internal(tgt, modpath):
             return _follow_reexport(tgt, reexports or {}, nodes), "imported"
         return tgt, "external"
     if name in modmembers:
@@ -909,14 +977,30 @@ def _emit_name_references(graph, src_id, scope, modpath, imports, modmembers,
 
 
 def _process_module_level(graph, modpath, tree, resolve, imports, modmembers,
-                          reexports=None) -> None:
-    """Calls and value-references in module-level code, sourced from the module (D1/D2)."""
+                          reexports=None, shadow_skip=None) -> None:
+    """Calls and value-references in module-level code, sourced from the module (D1/D2).
+
+    R1-C74: the module node also carries ``extras.calls`` — its sites used to make edges
+    and appear in no resolution figure.
+    """
     by_target: dict[str, dict] = {}
+    counts = _new_counts()
     for call in (n for n in _module_level_nodes(tree) if isinstance(n, ast.Call)):
         target, resolution = resolve(call)
-        if resolution in _EDGE_RESOLUTIONS and target and target in graph.nodes:
+        if _tally(counts, graph, target, resolution):
             agg = by_target.setdefault(target, {"resolution": resolution, "shapes": []})
             agg["shapes"].append(_arg_shape(call))
+    if modpath in graph.nodes:
+        graph.nodes[modpath].extras["calls"] = counts
+        # R1-C74 D1: a replaced body is not walked (R1-C46) — said, not absorbed.
+        skipped = _shadow_map(tree)[0] if shadow_skip is None else shadow_skip
+        if skipped:
+            seen: set[int] = set()
+            for node in ast.walk(tree):
+                if id(node) in skipped:
+                    seen.update(id(c) for c in ast.walk(node) if isinstance(c, ast.Call))
+            if seen:
+                graph.nodes[modpath].extras["calls_shadowed"] = len(seen)
     for target in sorted(by_target):
         agg = by_target[target]
         graph.add_edge(Edge("calls", modpath, target,
@@ -926,6 +1010,57 @@ def _process_module_level(graph, modpath, tree, resolve, imports, modmembers,
                           reexports=reexports)
 
 
+def _process_class_bodies(graph, modpath, tree, resolve, imports, modmembers, script,
+                          target_pkg, nested, known_modules=frozenset(), reexports=None,
+                          skip=None) -> None:
+    """Calls in class bodies outside their methods — bases, keywords, decorators, statements.
+
+    R1-C74 (design ``call_site_conservation.md`` D1). A class body runs at import time, so a
+    class that is a graph node is the source of its own ``calls`` edges and carries
+    ``extras.calls``, resolved like module-level code. A class nested in a function runs
+    when the function does: its sites go to the owner as nested, like a closure's. Shadowed
+    definitions are skipped, as everywhere (R1-C46).
+    """
+    skip = _shadow_map(tree)[0] if skip is None else skip
+
+    def visit(node, scope, in_function):
+        for child in ast.iter_child_nodes(node):
+            if id(child) in skip:
+                continue
+            if isinstance(child, ast.ClassDef):
+                cscope = scope + [child.name]
+                calls = [n for n in _own_nodes(child) if isinstance(n, ast.Call)]
+                cid = ".".join([modpath, *cscope])
+                if not in_function and cid in graph.nodes:
+                    counts = _new_counts()
+                    by_target: dict[str, dict] = {}
+                    for call in calls:
+                        target, resolution = resolve(call)
+                        if _tally(counts, graph, target, resolution) and target != cid:
+                            agg = by_target.setdefault(target, {"resolution": resolution,
+                                                                "shapes": []})
+                            agg["shapes"].append(_arg_shape(call))
+                    graph.nodes[cid].extras["calls"] = counts
+                    for target in sorted(by_target):
+                        agg = by_target[target]
+                        graph.add_edge(Edge("calls", cid, target,
+                                            extras={"resolution": agg["resolution"],
+                                                    **_arg_contract(agg["shapes"])}))
+                elif calls:
+                    owner = _nearest_owner(graph, modpath, scope)
+                    if owner is not None:
+                        _collect_nested_calls(graph, owner, child, modpath, imports, modmembers,
+                                              script, target_pkg, nested, known_modules,
+                                              reexports, calls=calls)
+                visit(child, cscope, in_function)
+            elif isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                visit(child, scope + [child.name], True)
+            else:
+                visit(child, scope, in_function)
+
+    visit(tree, [], False)
+
+
 def _named_functions_scoped(tree):
     """Like :func:`_named_functions`, plus the **full** enclosing scope names.
 
@@ -969,17 +1104,22 @@ def _nearest_owner(graph, modpath, scope) -> str | None:
 
 def _collect_nested_calls(graph, owner, fnode, modpath, imports, modmembers,
                           script, target_pkg, out, known_modules=frozenset(),
-                          reexports=None) -> None:
-    """Resolve a non-node function's own calls and stage them under ``owner`` (D3)."""
+                          reexports=None, calls=None) -> None:
+    """Resolve a non-node function's own calls and stage them under ``owner`` (D3).
+
+    ``fnode`` may also be a class nested in a function (R1-C74): its body runs inside the
+    owner, like a closure's. Every site is counted into the owner's ``extras.calls_nested``.
+    """
     def fast(call):
         return _resolve(call, modpath, "", imports, modmembers, {}, reexports, graph.nodes)
     # R1-C26: the same union the named-function path uses — a closure's calls must not be
     # resolved by a weaker rule than its neighbours'.
     resolve = (_deep_then_fast(graph, script, target_pkg, fast, modpath, known_modules)
                if script is not None else fast)
-    for call in _own_calls(fnode):
+    counts = graph.nodes[owner].extras.setdefault("calls_nested", _new_counts())
+    for call in (calls if calls is not None else _own_calls(fnode)):
         target, resolution = resolve(call)
-        if resolution not in _EDGE_RESOLUTIONS or not target or target not in graph.nodes:
+        if not _tally(counts, graph, target, resolution):
             continue
         if target == owner:
             continue  # a closure calling its own enclosing function — recursion, not a dep