codd-dev 2.33.0__tar.gz → 2.35.0__tar.gz

{codd_dev-2.33.0 → codd_dev-2.35.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 2.33.0
+Version: 2.35.0
 Summary: CoDD: Coherence-Driven Development — cross-artifact change impact analysis
 Project-URL: Homepage, https://github.com/yohey-w/codd-dev
 Project-URL: Repository, https://github.com/yohey-w/codd-dev

{codd_dev-2.33.0 → codd_dev-2.35.0}/codd/__init__.py

@@ -1,3 +1,3 @@
 """CoDD — Coherence-Driven Development."""
 
-__version__ = "2.33.0"
+__version__ = "2.35.0"

{codd_dev-2.33.0 → codd_dev-2.35.0}/codd/vb_marker_authenticity.py

@@ -1001,10 +1001,33 @@ def _net_braces(line: str) -> int:
 #      (the argument anchor that defeats no-op / constant-only helpers).
 # A helper that itself delegates to a deeper helper is followed ONE more hop
 # (so expectSuccessfulRun → expectExitCode is honored), bounded to avoid cycles.
+#
+# BARREL re-export following (step 2b). The binding module is frequently a
+# *barrel* — an index module that carries NO definition of its own and only
+# RE-EXPORTS sibling modules (TS ``export * from "./assertions"`` /
+# ``export { expectOk as ok } from "./asserts"``; Python ``__init__.py`` with
+# ``from .asserts import expect_ok``). The conventional e2e shape imports helpers
+# from such a barrel (``import { expectSuccessResult } from "./helpers"`` →
+# ``helpers/index.ts`` → ``export * from "./assertions"`` → the real
+# ``expectSuccessResult`` body). When ``def_finder`` finds no def in the binding
+# module, the resolver FOLLOWS the module's re-exports to the file that actually
+# defines the symbol (bounded by ``_MAX_REEXPORT_HOPS`` + a cycle guard). This is
+# purely an "ability to reach the real body"; the body still has to carry a
+# PRIMITIVE assertion + argument anchor — a barrel re-exporting a no-op/constant
+# helper still FAILS, and an unfollowable / depth-exhausted re-export is still an
+# unresolved helper (greenfield strict ⇒ fail). The follower is per-profile (TS
+# ``export */named/alias``; Python ``__init__`` ``from .x import y``) so the gate
+# stays language-agnostic; an unknown stack supplies no follower and degrades.
 # ---------------------------------------------------------------------------
 
 
 _MAX_HELPER_HOPS = 2
+#: Bound on how many re-export edges (barrel → barrel → … → defining module) the
+#: resolver will chase for ONE symbol. Generous enough for nested index barrels
+#: (``helpers/index → assertions/index → cli-assertions``) yet bounded to keep a
+#: pathological re-export web finite; combined with a per-symbol ``seen`` set of
+#: visited module files for cycle safety.
+_MAX_REEXPORT_HOPS = 4
 
 #: A bare or member call ``name(`` / ``a.b.name(`` — captures the dotted callee.
 _CALL_RE = re.compile(r"(?P<callee>[A-Za-z_$][\w$.]*)\s*\(")
@@ -1136,8 +1159,10 @@ def _ts_find_function_def(module_text: str, name: str) -> "tuple[str, list[str]]
     Returns ``(body_text, param_names)`` or ``None``. Anchored on the function
     NAME, then the parameter list is read by paren-matching from the following
     ``(`` (so a MULTI-LINE signature works), and the body is brace-matched from
-    the first ``{`` after the params. Arrow / function-expression / ``function``
-    declaration forms are all handled.
+    the function-body ``{`` AFTER any return-type annotation (so a brace-bearing
+    return type like ``Promise<{ error: string }>`` / ``: { ok: boolean }`` is not
+    mistaken for the body — see :func:`_ts_body_brace_index`). Arrow /
+    function-expression / ``function`` declaration forms are all handled.
     """
 
     for pattern in _TS_FUNC_NAME_RES:
@@ -1145,11 +1170,12 @@ def _ts_find_function_def(module_text: str, name: str) -> "tuple[str, list[str]]
             if m.group("name") != name:
                 continue
             # The name-anchor match ends at the def's opening ``(``; paren-match
-            # the (possibly multi-line) params, then brace-match the body.
+            # the (possibly multi-line) params, then locate the BODY ``{`` past
+            # any return-type annotation, then brace-match the body.
             params, after = _read_paren_group(module_text, m.end() - 1)
             if params is None:
                 continue
-            brace = module_text.find("{", after)
+            brace = _ts_body_brace_index(module_text, after)
             if brace < 0:
                 continue
             body = _read_brace_group(module_text, brace)
@@ -1157,6 +1183,167 @@ def _ts_find_function_def(module_text: str, name: str) -> "tuple[str, list[str]]
     return None
 
 
+def _ts_body_brace_index(text: str, after_params: int) -> int:
+    """Index of the FUNCTION-BODY ``{`` that follows a TS signature's params.
+
+    ``after_params`` is the index just past the params' closing ``)``. Between it
+    and the body there may be a RETURN-TYPE ANNOTATION (``): T {``) and/or an arrow
+    (``) => {``). The naive "first ``{`` after the params" is WRONG when the return
+    type itself contains braces — ``): Promise<{ error: string }> {`` (the noteapi
+    false-RED), ``): { ok: boolean } {`` (object-type literal), or
+    ``): Promise<Array<{ id: number }>> {`` — there the first ``{`` is part of the
+    TYPE, not the body. This skips the annotation and returns the body ``{``.
+
+    The decision uses the ``:`` (return-type marker) as the disambiguator:
+
+    * The first significant token after the params is ``{`` → the BODY (no return
+      type at all, e.g. ``function g(a) {``).
+    * It is ``=>`` → an arrow with NO return type; the body is the next top-level
+      ``{`` (an EXPRESSION-bodied arrow has no block ``{`` → return ``-1`` so the
+      caller degrades rather than mis-extract).
+    * It is ``:`` → a return-type annotation. Consume the type (skipping balanced
+      ``<> () [] {}`` groups so a generic / tuple / object-type literal inside the
+      type is never seen at top level), and stop at the top-level ``{`` (body) or
+      ``=>`` (typed arrow → body is its next ``{``). An object-type literal that is
+      the WHOLE return type (``: { ok: boolean } {``) is the first balanced
+      ``{...}`` right after ``:`` — it is skipped, and the body is the ``{`` after.
+
+    Returns ``-1`` when no body brace is found (unbalanced / expression arrow).
+
+    KNOWN LIMITATION (fails CLOSED, never false-green): a return type that is
+    itself a FUNCTION TYPE (``): (x) => { y: 1 } {``) is not disambiguated — the
+    inner ``=>`` is read as the function's own arrow. This degrades to a wrong
+    body span ⇒ ``helper_no_primitive`` ⇒ the marker FAILS (a conservative
+    false-RED, not a false pass). Such a return annotation on an assertion helper
+    is vanishingly rare; the gate stays anti-false-green either way.
+    """
+
+    n = len(text)
+    i = _ts_skip_trivia(text, after_params)
+    if i >= n:
+        return -1
+    # No return-type annotation: an immediate body brace, or a `=>` arrow.
+    if text[i] == "{":
+        return i
+    if text.startswith("=>", i):
+        j = _ts_skip_trivia(text, i + 2)
+        return j if j < n and text[j] == "{" else -1
+    if text[i] != ":":
+        # Unexpected token between params and body — be permissive: take the next
+        # top-level brace past it (covers exotic but brace-free prefixes).
+        return _ts_scan_type_to_body(text, i)
+    # `:` return-type annotation. Skip it and consume the type up to the body.
+    return _ts_scan_type_to_body(text, i + 1)
+
+
+def _ts_skip_trivia(text: str, i: int) -> int:
+    """Advance ``i`` past whitespace and ``//`` / ``/* */`` comments."""
+
+    n = len(text)
+    while i < n:
+        ch = text[i]
+        if ch.isspace():
+            i += 1
+        elif ch == "/" and i + 1 < n and text[i + 1] == "/":
+            nl = text.find("\n", i)
+            i = n if nl < 0 else nl + 1
+        elif ch == "/" and i + 1 < n and text[i + 1] == "*":
+            end = text.find("*/", i + 2)
+            i = n if end < 0 else end + 2
+        else:
+            break
+    return i
+
+
+#: Type-level binary operators that JOIN type atoms (``A | B``, ``A & B``). After
+#: one of these the parser expects ANOTHER atom, so a following object-type literal
+#: ``{...}`` is still part of the return type, not the body.
+_TS_TYPE_JOIN_CHARS = frozenset("|&")
+
+
+def _ts_scan_type_to_body(text: str, i: int) -> int:
+    """From inside a return-type annotation, return the body ``{`` index (or -1).
+
+    Models the return type as a sequence of type ATOMS joined by ``|`` / ``&``
+    operators, ending at the body ``{`` or a typed-arrow ``=>``. ``expecting_atom``
+    starts True (the type begins right after ``:`` or a join operator); a top-level
+    ``{`` while ``expecting_atom`` is an OBJECT-TYPE LITERAL atom (``: { ok } {`` /
+    ``: A | { err } {``) and is skipped as a balanced group, whereas a top-level
+    ``{`` while NOT expecting an atom (a complete type already consumed, no join
+    operator following) is the BODY. Generics ``<…>``, tuples ``[…]`` and paren
+    types ``(…)`` are skipped as balanced groups (their inner braces never surface).
+    """
+
+    n = len(text)
+    angle = paren = bracket = 0
+    expecting_atom = True
+    in_str: str | None = None
+    prev = ""
+    while i < n:
+        ch = text[i]
+        if in_str is not None:
+            if ch == in_str and prev != "\\":
+                in_str = None
+            prev = ch
+            i += 1
+            continue
+        if ch in ("'", '"', "`"):
+            in_str = ch
+            expecting_atom = False
+            prev = ch
+            i += 1
+            continue
+        if ch == "/" and i + 1 < n and text[i + 1] == "/":
+            nl = text.find("\n", i)
+            i = n if nl < 0 else nl
+            prev = ""
+            continue
+        if ch == "/" and i + 1 < n and text[i + 1] == "*":
+            end = text.find("*/", i + 2)
+            i = n if end < 0 else end + 2
+            prev = ""
+            continue
+        top = angle == 0 and paren == 0 and bracket == 0
+        if ch == "<":
+            angle += 1
+            expecting_atom = False
+        elif ch == ">":
+            if angle > 0:
+                angle -= 1
+        elif ch == "(":
+            paren += 1
+            expecting_atom = False
+        elif ch == "[":
+            bracket += 1
+            expecting_atom = False
+        elif ch in (")", "]"):
+            if ch == ")" and paren > 0:
+                paren -= 1
+            elif ch == "]" and bracket > 0:
+                bracket -= 1
+        elif top and text.startswith("=>", i):
+            # Typed arrow: the body is the next top-level `{`.
+            j = _ts_skip_trivia(text, i + 2)
+            return j if j < n and text[j] == "{" else -1
+        elif top and ch == "{":
+            if not expecting_atom:
+                return i  # a complete type precedes this `{` → it is the body.
+            # Object-type literal atom (`: { ok } {` / `A | { err } {`) — skip its
+            # balanced group; an atom is now consumed (no longer expecting one).
+            group = _read_brace_group(text, i)
+            i += len(group)
+            expecting_atom = False
+            prev = "}"
+            continue
+        elif top and ch in _TS_TYPE_JOIN_CHARS:
+            expecting_atom = True  # `|`/`&` → another atom follows.
+        elif top and not ch.isspace():
+            expecting_atom = False  # identifier / `.` / `:` … consumes/continues an atom
+        prev = ch
+        i += 1
+    return -1
+
+
 def _read_paren_group(text: str, open_idx: int) -> "tuple[str | None, int]":
     """Inner text of the paren group whose ``(`` is at/just after ``open_idx``.
 
@@ -1218,6 +1405,62 @@ def _read_brace_group(text: str, open_brace_idx: int) -> str:
     return text[open_brace_idx:]
 
 
+# ── TypeScript / JavaScript barrel re-export following ───────────────────────
+#
+# A barrel module re-exports siblings instead of defining the symbol. Two forms:
+#   ``export * from "./X"``                 (star — symbol unchanged, try X)
+#   ``export { Y } from "./X"``             (named — local name Y, original Y)
+#   ``export { Y as Z } from "./X"``        (named+alias — local Z, original Y)
+# A ``export {}`` with NO ``from`` clause is a LOCAL re-export of in-file symbols,
+# not a re-export edge, and is ignored here (the def, if any, is found in-file by
+# ``_ts_find_function_def`` already).
+
+#: ``export * from "./x"`` and ``export * as ns from "./x"`` (a namespace star
+#: binds a NAMESPACE object, not the bare symbol, so it is NOT a transparent
+#: re-export of ``symbol`` — only the plain ``export * from`` is followed).
+_TS_EXPORT_STAR_RE = re.compile(
+    r"""^[ \t]*export\s+\*\s+from\s*['"](?P<spec>[^'"]+)['"]""", re.MULTILINE
+)
+#: ``export { a, b as c } from "./x"`` (the ``from`` clause makes it a re-export).
+_TS_EXPORT_NAMED_FROM_RE = re.compile(
+    r"""^[ \t]*export\s+(?:type\s+)?\{(?P<names>[^}]*)\}\s*from\s*['"](?P<spec>[^'"]+)['"]""",
+    re.MULTILINE,
+)
+
+
+def _ts_reexport_edges(module_text: str, symbol: str) -> list[tuple[str, str]]:
+    """Re-export edges from a TS barrel that can carry ``symbol`` onward.
+
+    Returns ``(spec, original_name)`` pairs: ``spec`` is the relative module to
+    follow, ``original_name`` is the name to look for THERE (an alias flips the
+    name back). ``export * from "./x"`` forwards ``symbol`` unchanged. A named
+    re-export forwards ONLY when its LOCAL name (after ``as``) equals ``symbol``,
+    and the original (before ``as``) is what the target module defines. Order:
+    explicit named re-exports first (a precise alias should win over a star), then
+    ``export *`` fan-out. Only relative (same-repo) specs are returned.
+    """
+
+    edges: list[tuple[str, str]] = []
+    for match in _TS_EXPORT_NAMED_FROM_RE.finditer(module_text):
+        spec = match.group("spec")
+        if not spec.startswith("."):
+            continue
+        for raw in match.group("names").split(","):
+            name = raw.strip()
+            if not name:
+                continue
+            parts = [p.strip() for p in name.split(" as ")]
+            original = parts[0]
+            local = parts[-1]
+            if local == symbol:
+                edges.append((spec, original))
+    for match in _TS_EXPORT_STAR_RE.finditer(module_text):
+        spec = match.group("spec")
+        if spec.startswith("."):
+            edges.append((spec, symbol))  # star forwards the name unchanged
+    return edges
+
+
 # ── Python resolution ───────────────────────────────────────────────────────
 
 #: ``from pkg.mod import a, b as c`` / ``from .mod import x``.
@@ -1241,6 +1484,42 @@ def _py_imported_module(importer_text: str, symbol: str) -> str | None:
     return None
 
 
+def _py_reexport_edges(module_text: str, symbol: str) -> list[tuple[str, str]]:
+    """Re-export edges from a Python ``__init__.py`` barrel carrying ``symbol``.
+
+    Mirrors :func:`_ts_reexport_edges` for the Python package-barrel convention.
+    Returns ``(mod, original_name)`` pairs: ``mod`` is the relative module to
+    follow (resolved with the SAME ``_py_resolve_module`` rules, with the barrel's
+    own path as the importer), ``original_name`` is the name to look for there.
+      ``from .x import y``        → forwards ``y`` unchanged when ``y == symbol``
+      ``from .x import y as z``   → forwards ``y`` when the LOCAL ``z == symbol``
+      ``from .x import *``        → forwards ``symbol`` unchanged (star)
+    Only explicit-relative imports (``from .x`` / ``from ..pkg.x``) are followed —
+    an absolute ``from app.x import y`` re-export is unusual in a test barrel and
+    is conservatively skipped (kept out of the same-dir 1-hop re-export graph).
+    """
+
+    edges: list[tuple[str, str]] = []
+    for match in _PY_FROM_IMPORT_RE.finditer(module_text):
+        mod = match.group("mod")
+        if not mod.startswith("."):
+            continue
+        names = match.group("names")
+        for raw in names.replace("(", " ").replace(")", " ").split(","):
+            name = raw.strip()
+            if not name:
+                continue
+            if name == "*":
+                edges.append((mod, symbol))  # star re-export forwards the name
+                continue
+            parts = [p.strip() for p in name.split(" as ")]
+            original = parts[0]
+            local = parts[-1]
+            if local == symbol:
+                edges.append((mod, original))
+    return edges
+
+
 def _py_resolve_module(importer_rel: str, mod: str, project_root: Path) -> Path | None:
     """Resolve a python ``from <mod> import`` module to a sibling file (1 hop).
 
@@ -1351,13 +1630,19 @@ def _resolve_evidence(
     imported_lookup: Callable[[str, str], str | None],
     module_resolver: Callable[[str, str, Path], Path | None],
     def_finder: Callable[[str, str], "tuple[str, list[str]] | None"],
+    reexport_edges: Callable[[str, str], list[tuple[str, str]]] | None = None,
 ) -> AssertionEvidence:
     """Shared 1-hop helper-resolution engine (language plug-ins supply the rest).
 
     ``primitive_re`` detects a primitive assertion/fail in a helper body;
     ``imported_lookup(importer_text, symbol)`` returns the binding specifier/module;
     ``module_resolver(importer_rel, spec, root)`` resolves it to a file;
-    ``def_finder(module_text, name)`` returns ``(body, params)`` for the helper.
+    ``def_finder(module_text, name)`` returns ``(body, params)`` for the helper;
+    ``reexport_edges(module_text, symbol)`` (optional) returns the barrel
+    re-export edges that can carry ``symbol`` onward, so a helper imported from a
+    barrel index that only RE-EXPORTS its real definition is still reachable. A
+    profile that supplies no follower simply never crosses a barrel (degrades to
+    the 2.31.0 direct/simple-import behavior).
     """
 
     calls = _extract_helper_calls(block.body_text)
@@ -1379,6 +1664,7 @@ def _resolve_evidence(
             imported_lookup=imported_lookup,
             module_resolver=module_resolver,
             def_finder=def_finder,
+            reexport_edges=reexport_edges,
             hops=_MAX_HELPER_HOPS,
             seen=frozenset(),
         )
@@ -1400,6 +1686,75 @@ def _resolve_evidence(
     return AssertionEvidence(ok=False, reason="no_assertion")
 
 
+def _follow_reexports_for_def(
+    *,
+    name: str,
+    module_text: str,
+    module_rel: str,
+    project_root: Path,
+    module_resolver: Callable[[str, str, Path], Path | None],
+    def_finder: Callable[[str, str], "tuple[str, list[str]] | None"],
+    reexport_edges: Callable[[str, str], list[tuple[str, str]]],
+    depth: int,
+    visited: frozenset[str],
+) -> "tuple[tuple[str, list[str]], str, str] | None":
+    """Follow a barrel's re-export edges to the module that DEFINES ``name``.
+
+    ``module_text`` / ``module_rel`` are the current (barrel) module. Each
+    re-export edge ``(spec, original_name)`` from :func:`reexport_edges` is
+    resolved with the SAME ``module_resolver`` used for imports (the barrel acts
+    as the importer for its own relative re-exports), the target module is read,
+    and ``def_finder`` is tried there for ``original_name``. A target that is
+    itself a barrel is recursed into (``original_name`` carried forward, depth
+    decremented). Returns ``((body, params), defining_text, defining_rel)`` for
+    the FIRST edge that reaches a real def, or ``None`` if no edge within
+    ``depth`` hops resolves. Bounded by ``depth`` and a ``visited`` set of module
+    rel-paths (cycle guard: ``a → b → a`` barrels terminate).
+
+    Pure reach: the returned body is still subject to the caller's primitive +
+    argument-anchor checks, so a barrel that re-exports a no-op/constant helper
+    yields that no-op body (which then FAILS) — never a pass.
+    """
+
+    if depth <= 0 or module_rel in visited:
+        return None
+    visited = visited | {module_rel}
+
+    for spec, original in reexport_edges(module_text, name):
+        target_file = module_resolver(module_rel, spec, project_root)
+        if target_file is None:
+            continue
+        try:
+            target_text = target_file.read_text(encoding="utf-8")
+        except (OSError, UnicodeDecodeError):
+            continue
+        try:
+            target_rel = target_file.resolve().relative_to(project_root).as_posix()
+        except ValueError:
+            target_rel = spec
+        if target_rel in visited:
+            continue
+        found = def_finder(target_text, original)
+        if found is not None:
+            return found, target_text, target_rel
+        # Target is itself a barrel — recurse, carrying the (possibly aliased)
+        # original name onward and decrementing the re-export budget.
+        deeper = _follow_reexports_for_def(
+            name=original,
+            module_text=target_text,
+            module_rel=target_rel,
+            project_root=project_root,
+            module_resolver=module_resolver,
+            def_finder=def_finder,
+            reexport_edges=reexport_edges,
+            depth=depth - 1,
+            visited=visited,
+        )
+        if deeper is not None:
+            return deeper
+    return None
+
+
 def _resolve_one_helper(
     *,
     name: str,
@@ -1410,6 +1765,7 @@ def _resolve_one_helper(
     imported_lookup: Callable[[str, str], str | None],
     module_resolver: Callable[[str, str, Path], Path | None],
     def_finder: Callable[[str, str], "tuple[str, list[str]] | None"],
+    reexport_edges: Callable[[str, str], list[tuple[str, str]]] | None = None,
     hops: int,
     seen: frozenset[str],
 ) -> AssertionEvidence:
@@ -1420,6 +1776,13 @@ def _resolve_one_helper(
     delegates to a DEEPER assertion helper (forwarding its own params, checked via
     ``inner_anchor & param_set`` below) is followed one more hop, so a chain like
     ``expectSuccessfulRun → expectExitCode`` resolves.
+
+    When the binding module is a BARREL (it carries no def of ``name`` and only
+    re-exports siblings), the def is located by following the module's re-export
+    edges via ``reexport_edges`` (bounded by ``_MAX_REEXPORT_HOPS`` + a visited-
+    file cycle guard). The defining module's text/rel then replace the barrel's so
+    the SAME primitive + argument-anchor checks (and any deeper helper hop) run
+    against the real body — barrel following adds reach, never a pass.
     """
 
     if hops <= 0 or name in seen:
@@ -1443,19 +1806,41 @@ def _resolve_one_helper(
             resolved_rel = importer_rel
 
     found = def_finder(module_text, name)
+    if found is None and reexport_edges is not None and spec is not None:
+        # Binding module has no def of ``name`` — it may be a BARREL that only
+        # re-exports the real definition. Follow re-export edges to the defining
+        # module, then continue with the SAME credibility checks below.
+        followed = _follow_reexports_for_def(
+            name=name,
+            module_text=module_text,
+            module_rel=resolved_rel,
+            project_root=project_root,
+            module_resolver=module_resolver,
+            def_finder=def_finder,
+            reexport_edges=reexport_edges,
+            depth=_MAX_REEXPORT_HOPS,
+            visited=frozenset(),
+        )
+        if followed is not None:
+            found, module_text, resolved_rel = followed
     if found is None:
-        # Not defined in the binding module (and no same-file def) → unresolved.
+        # Not defined in the binding module, no same-file def, and no resolvable
+        # re-export chain reaches a def → unresolved (greenfield strict ⇒ fail).
         return AssertionEvidence(ok=False, reason="unresolved_helper", detail=name)
     body, params = found
     param_set = set(params)
 
     # Primitive assertion/fail in the helper body?
     if primitive_re.search(body):
-        # Argument anchor (anti-no-op): a PRIMITIVE assertion LINE must reference
-        # one of the helper's own parameters. A helper that asserts only a
-        # constant (``expect(true).toBe(true)`` / ``assert True``) never does, so
+        # Argument anchor (anti-no-op): a PRIMITIVE assertion must reference one of
+        # the helper's own parameters OR a local DERIVED from a parameter (1-2
+        # hops), e.g. ``const body = await readJson(response); expect(body.error)``
+        # — ``body`` flows from the ``response`` param, so the assertion IS anchored
+        # to the call's data. A helper that asserts only a constant
+        # (``expect(true).toBe(true)`` / ``assert True``) references neither, so
         # marker-spam delegating to it FAILS — the helper NAME is never trusted.
-        if _body_references_params(body, param_set, primitive_re):
+        anchor_set = _params_and_derived_locals(body, param_set)
+        if _body_references_params(body, anchor_set, primitive_re):
             return AssertionEvidence(ok=True, reason="helper_resolved", detail=name)
         return AssertionEvidence(ok=False, reason="constant_helper", detail=name)
 
@@ -1474,6 +1859,7 @@ def _resolve_one_helper(
             imported_lookup=imported_lookup,
             module_resolver=module_resolver,
             def_finder=def_finder,
+            reexport_edges=reexport_edges,
             hops=hops - 1,
             seen=seen,
         )
@@ -1482,20 +1868,75 @@ def _resolve_one_helper(
     return AssertionEvidence(ok=False, reason="helper_no_primitive", detail=name)
 
 
+#: An ASSIGNMENT binding a local from an expression: ``const body = …`` /
+#: ``let x = …`` / ``var y = …`` (TS/JS) and a bare ``name = …`` (Python). Captures
+#: the bound NAME(s) (lhs) and the RHS expression so a local derived from a
+#: parameter can be added to the anchor set. ``==`` / ``=>`` / ``<=`` / ``>=`` /
+#: ``!=`` are excluded (comparisons / arrows, not bindings). Single-name binds are
+#: matched anywhere a line allows; DESTRUCTURING (``const { a, b } = …`` /
+#: ``const [x] = …``) requires a leading ``const``/``let``/``var`` keyword and may
+#: not span a newline — this is what stops the lhs ``{…}`` alternative from
+#: swallowing the FUNCTION BODY's own opening brace.
+_ASSIGN_RE = re.compile(
+    r"^[ \t]*(?:"
+    r"(?:const|let|var)\s+(?P<destructure>\{[^}\n]*\}|\[[^\]\n]*\])"
+    r"|(?:(?:const|let|var)\s+)?(?P<name>[A-Za-z_$][\w$]*)"
+    r")\s*=(?![=>])\s*(?P<rhs>.+)$",
+    re.MULTILINE,
+)
+#: Derivation hops: ``a = f(param); b = g(a); expect(b…)`` resolves with 2 passes.
+_MAX_DERIVE_PASSES = 2
+
+
+def _params_and_derived_locals(body: str, param_set: set[str]) -> set[str]:
+    """``param_set`` plus locals DERIVED from a parameter within ``body`` (≤2 hops).
+
+    The argument anchor must credit ``const body = await readJson(response);
+    expect(body.error)…`` — the assertion references ``body``, a local that FLOWS
+    from the ``response`` parameter, so it is genuinely anchored to the call's data
+    (root-cause-#2: the 2.31.0 anchor only saw a DIRECT param reference and wrongly
+    rejected param-derived locals). A binding ``X = <rhs>`` adds ``X`` to the set
+    iff its RHS references something already in the set (a param or an
+    already-derived local). Two passes follow a short ``param → a → b`` chain.
+    Constants never enter the set (``const k = 5`` references no param), so a
+    constant-only helper stays unanchored ⇒ FAIL. Destructured bindings
+    (``const { error } = body``) add each bound name when the RHS is derived.
+    """
+
+    if not param_set:
+        return set()
+    derived = set(param_set)
+    for _ in range(_MAX_DERIVE_PASSES):
+        grew = False
+        for match in _ASSIGN_RE.finditer(body):
+            rhs_idents = set(re.findall(r"[A-Za-z_$][\w$]*", match.group("rhs")))
+            if not (rhs_idents & derived):
+                continue
+            lhs = match.group("destructure") or match.group("name") or ""
+            for lhs_name in re.findall(r"[A-Za-z_$][\w$]*", lhs):
+                if lhs_name not in derived:
+                    derived.add(lhs_name)
+                    grew = True
+        if not grew:
+            break
+    return derived
+
+
 def _body_references_params(
     body: str, param_set: set[str], primitive_re: re.Pattern[str]
 ) -> bool:
     """A primitive assertion in ``body`` references one of ``param_set``.
 
     The "argument anchor": a primitive assertion must mention a parameter (or a
-    value derived from it), so a no-op helper that asserts only a CONSTANT
-    (``expect(true).toBe(true)`` / ``assert True``) and merely *names* a param
-    elsewhere is NOT anchored. The check is per primitive-assertion STATEMENT,
-    where a statement is the assertion line PLUS any following lines indented
-    MORE than it (its block) — so a context-manager assertion
-    (``with pytest.raises(...):\\n    fn()``) is anchored by the ``fn()`` call in
-    its block, while a trailing same-indent ``log(result)`` after a constant
-    ``expect(true)`` is not.
+    value derived from it — ``param_set`` is pre-expanded with param-derived locals
+    by :func:`_params_and_derived_locals` at the call site), so a no-op helper that
+    asserts only a CONSTANT (``expect(true).toBe(true)`` / ``assert True``) and
+    merely *names* a param elsewhere is NOT anchored. The check is per
+    primitive-assertion STATEMENT, where a statement is the assertion line PLUS any
+    following lines indented MORE than it (its block) — so a context-manager
+    assertion (``with pytest.raises(...):\\n    fn()``) is anchored by the ``fn()``
+    call in its block, while a trailing same-indent ``log(result)`` after a
+    constant ``expect(true)`` is not.
     """
 
     if not param_set:
@@ -1541,6 +1982,7 @@ def _resolve_typescript_evidence(
         imported_lookup=_ts_imported_specifier,
         module_resolver=_mod_resolver,
         def_finder=_ts_find_function_def,
+        reexport_edges=_ts_reexport_edges,
     )
 
 
@@ -1559,4 +2001,5 @@ def _resolve_python_evidence(
         imported_lookup=_py_imported_module,
         module_resolver=_mod_resolver,
         def_finder=_py_find_function_def,
+        reexport_edges=_py_reexport_edges,
     )

{codd_dev-2.33.0 → codd_dev-2.35.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "codd-dev"
-version = "2.33.0"
+version = "2.35.0"
 description = "CoDD: Coherence-Driven Development — cross-artifact change impact analysis"
 readme = "README.md"
 license = "MIT"