Fast deploy (index c3ce686a86bd)

backend/atlas.py

@@ -584,57 +584,100 @@ def walk_tree(atlas: Atlas, query: TreeQuery, root: int, t0: float) -> dict:
     # --- Ancestors (forward CSR): etymons of the selected word ---
     # Separate maps so a node that is also a descendant keeps its down-tree identity.
     #
-    # Weak binary edges (relation ``other``, including ``{{root}}`` category shortcuts)
-    # are deferred until after strong etymons + formation hyperedges are expanded.
-    # Otherwise a page-level ``{{root|en|ine-pro|*wed-}}`` edge marks *wed- visited at
-    # depth 1, and the later *wódr̥ = *wed- + *r̥ hyperedge can only attach orphan *r̥.
+    # The etymon graph is a DAG: one word can have many outbound etymon edges, and the
+    # same etymon can be reached more than once (e.g. water → *wed- via {{root}} and
+    # *wódr̥ → *wed- as a formation part). We record every edge. ``anc_parent`` is only
+    # the layout spine for tidy-tree placement (prefer formation/descent over ``other``).
     anc_parent: dict[int, int] = {}
     anc_rel_code: dict[int, int] = {}
     anc_conf_code: dict[int, int] = {}
     anc_depth: dict[int, int] = {root: 0}
+    # (via, etymon, rel_code, conf_code) — may include multiple edges into the same etymon.
+    anc_edges: list[tuple[int, int, int, int]] = []
+    anc_edge_seen: set[tuple[int, int, int]] = set()
     anc_visited = 0
-    weak_anc_rels = {REL_TO_CODE["other"]}
+
+    def _anc_layout_rank(rel_code: int, via_depth: int) -> tuple[int, int]:
+        """Higher rank wins as the single tidy-tree parent (layout only)."""
+        name = RELATIONS[rel_code] if 0 <= rel_code < len(RELATIONS) else "other"
+        strength = {
+            "compound": 5,
+            "blend": 5,
+            "inherited": 4,
+            "derived": 4,
+            "borrowed": 4,
+            "calque": 4,
+            "clipping": 3,
+            "back_formation": 3,
+            "abbreviation": 3,
+            "other": 1,
+        }.get(name, 2)
+        # Prefer a deeper via so formation parts hang under the stem, not the page lemma.
+        return (strength, via_depth)
 
     if include_ancestors and max_anc_depth > 0 and fwd is not None:
         aq: deque[int] = deque([root])
 
-        def consider_anc(etymon: int, via: int, rel_code: int, conf_code: int) -> bool:
+        def record_anc_edge(etymon: int, via: int, rel_code: int, conf_code: int) -> bool:
+            """Record an etymon edge. Enqueue on first visit. Never drop duplicate edges."""
             nonlocal anc_visited, visited, truncated
-            if etymon == root or etymon in anc_depth:
+            if etymon == root:
                 return False
             # Prefer descendant placement if already reached going down.
             if etymon in depth_of:
                 return False
-            anc_depth[etymon] = anc_depth[via] + 1
-            anc_parent[etymon] = via
-            anc_rel_code[etymon] = rel_code
-            anc_conf_code[etymon] = conf_code
-            anc_visited += 1
-            visited += 1
-            if visited >= max_visit:
-                truncated = True
-                aq.clear()
-                return True
-            aq.append(etymon)
+            if anc_depth.get(via, 0) >= max_anc_depth:
+                return False
+
+            key = (via, etymon, rel_code)
+            if key not in anc_edge_seen:
+                anc_edge_seen.add(key)
+                anc_edges.append((via, etymon, rel_code, conf_code))
+
+            first = etymon not in anc_depth
+            if first:
+                anc_depth[etymon] = anc_depth[via] + 1
+                anc_parent[etymon] = via
+                anc_rel_code[etymon] = rel_code
+                anc_conf_code[etymon] = conf_code
+                anc_visited += 1
+                visited += 1
+                if visited >= max_visit:
+                    truncated = True
+                    aq.clear()
+                    return True
+                aq.append(etymon)
+            else:
+                # Upgrade layout parent if this inbound edge is a better spine choice.
+                cur_via = anc_parent[etymon]
+                cur_rel = anc_rel_code[etymon]
+                if _anc_layout_rank(rel_code, anc_depth[via]) > _anc_layout_rank(
+                    cur_rel, anc_depth.get(cur_via, 0)
+                ):
+                    anc_parent[etymon] = via
+                    anc_rel_code[etymon] = rel_code
+                    anc_conf_code[etymon] = conf_code
+                    anc_depth[etymon] = anc_depth[via] + 1
             return False
 
-        def expand_strong_and_formations(node: int) -> bool:
-            """Follow inherited/derived/... edges and hyperedge parts. Skip weak ``other``."""
+        while aq:
+            node = aq.popleft()
             d = anc_depth[node]
             if d >= max_anc_depth:
-                return False
+                continue
             start = int(fwd.offsets[node])
             end = int(fwd.offsets[node + 1])
+            stop = False
             # Etymon walk is unfiltered by descendant edge settings — users still
             # want to see where a word comes from even when browsing only borrowings etc.
             for e in range(start, end):
-                rel_c = int(fwd.rel[e])
-                if rel_c in weak_anc_rels:
-                    continue
                 etymon = int(fwd.targets[e])
-                if consider_anc(etymon, node, rel_c, int(fwd.conf[e])):
-                    return True
-            # Formation parts of this word (compositional etymons), one hop.
+                stop = record_anc_edge(etymon, node, int(fwd.rel[e]), int(fwd.conf[e]))
+                if stop:
+                    break
+            if stop:
+                break
+            # Formation parts of this word (compositional etymons).
             if (
                 getattr(atlas, "par_off", None) is not None
                 and getattr(atlas, "par_hyper", None) is not None
@@ -650,44 +693,13 @@ def walk_tree(atlas: Atlas, query: TreeQuery, root: int, t0: float) -> dict:
                     ha = int(atlas.hyper_part_off[h])
                     hb = int(atlas.hyper_part_off[h + 1])
                     for part in atlas.hyper_part_tgt[ha:hb]:
-                        if consider_anc(int(part), node, rel_c, conf_c):
-                            return True
-            return False
-
-        def expand_weak_others(node: int) -> bool:
-            """Attach ``other``/root shortcuts only if not already claimed by a formation."""
-            d = anc_depth[node]
-            if d >= max_anc_depth:
-                return False
-            start = int(fwd.offsets[node])
-            end = int(fwd.offsets[node + 1])
-            for e in range(start, end):
-                rel_c = int(fwd.rel[e])
-                if rel_c not in weak_anc_rels:
-                    continue
-                etymon = int(fwd.targets[e])
-                if consider_anc(etymon, node, rel_c, int(fwd.conf[e])):
-                    return True
-            return False
-
-        # Phase 1: strong binary etymons + formation hyperedges (full BFS).
-        while aq:
-            if expand_strong_and_formations(aq.popleft()):
-                break
-
-        # Phase 2: weak ``other`` edges (e.g. {{root}}) for nodes already reached;
-        # newly attached targets then get their own strong/formation expansion.
-        # Repeat until no new weak targets appear (rare multi-hop other chains).
-        while not truncated:
-            before = anc_visited
-            for node in list(anc_depth.keys()):
-                if expand_weak_others(node):
-                    break
-            while aq and not truncated:
-                if expand_strong_and_formations(aq.popleft()):
+                        stop = record_anc_edge(int(part), node, rel_c, conf_c)
+                        if stop:
+                            break
+                    if stop:
+                        break
+                if stop:
                     break
-            if truncated or anc_visited == before:
-                break
 
     has_child: set[int] = set()
     for nid, p in parent.items():
@@ -919,6 +931,56 @@ def walk_tree(atlas: Atlas, query: TreeQuery, root: int, t0: float) -> dict:
             }
         )
 
+    # Explicit edge list: tidy-tree ``parent`` is layout-only; DAG multi-edges live here.
+    # Descendants currently have one parent each; ancestors may have several inbound edges.
+    payload_edges: list[dict] = []
+    edge_keys: set[tuple[str, str, str]] = set()
+
+    def push_edge(
+        source: int | str,
+        target: int | str,
+        relation: str | None,
+        confidence: float | None,
+        branch: str,
+    ) -> None:
+        rel = relation or ""
+        key = (str(source), str(target), rel)
+        if key in edge_keys:
+            return
+        edge_keys.add(key)
+        payload_edges.append(
+            {
+                "source": source,
+                "target": target,
+                "relation": relation,
+                "confidence": confidence,
+                "branch": branch,
+            }
+        )
+
+    for node in payload_nodes:
+        if node.get("parent") is None:
+            continue
+        push_edge(
+            node["parent"],
+            node["id"],
+            node.get("relation"),
+            node.get("confidence"),
+            node.get("branch") or "down",
+        )
+
+    anc_keep_ids = set(anc_ids) | {root}
+    for via, etymon, rel_c, conf_c in anc_edges:
+        if etymon not in anc_keep_ids or via not in anc_keep_ids:
+            continue
+        push_edge(
+            anc_payload_id(via),
+            anc_payload_id(etymon),
+            RELATIONS[int(rel_c)] if 0 <= rel_c < len(RELATIONS) else None,
+            int(conf_c) / 100.0,
+            "up",
+        )
+
     hydrate_ids = list(word_ids) + list(anc_ids)
     extra = atlas.hydrate(hydrate_ids)
     for node in payload_nodes:
@@ -962,6 +1024,7 @@ def walk_tree(atlas: Atlas, query: TreeQuery, root: int, t0: float) -> dict:
             **{k: root_info.get(k) for k in ("lang_display", "family_name", "macroarea", "latitude", "longitude")},
         },
         "nodes": payload_nodes,
+        "edges": payload_edges,
         "stats": {
             "visited": int(visited),
             "kept_leaves": int(kept_leaves),

frontend/dist/index.html

@@ -9,7 +9,7 @@
     <link rel="icon" href="/icon.svg" type="image/svg+xml" />
     <link rel="apple-touch-icon" href="/icon.svg" />
     <title>Reverse Etymology Atlas</title>
-    <script type="module" crossorigin src="/assets/index-BCsMQuux.js"></script>
+    <script type="module" crossorigin src="/assets/index-DIxRZy10.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-CL00p6UV.css">
   </head>
   <body>