Fast deploy (index 51f60c37cb32)

Dockerfile

@@ -27,7 +27,7 @@ COPY frontend/dist ./frontend/dist
 
 # Pinned prebuilt index artifact (update when republishing the dataset).
 ARG INDEX_URL=https://huggingface.co/datasets/Mongoosetross/reverse-etymology-index/resolve/main/index.tar.zst
-ARG INDEX_SHA256=321674f1d695541d7bf56653410a6398ead46eb0ed9fd1eb07d04b7542b9278d
+ARG INDEX_SHA256=51f60c37cb3219268f7852363860f7d17650cf2079888de75573f28412bb6d71
 RUN mkdir -p data/index \
     && curl -fsSL "$INDEX_URL" -o /tmp/index.tar.zst \
     && if [ -n "$INDEX_SHA256" ]; then echo "$INDEX_SHA256  /tmp/index.tar.zst" | sha256sum -c -; fi \

backend/app.py

@@ -12,6 +12,7 @@ from fastapi.staticfiles import StaticFiles
 
 from backend.atlas import Atlas
 from backend.define import fetch_definitions
+from backend.game import build_round, next_round, score_guess
 from backend.models import TreeQuery
 
 ROOT = Path(__file__).resolve().parents[1]
@@ -77,17 +78,17 @@ def examples() -> dict:
 
 
 @app.get("/api/node")
-def node(term: str, lang: str) -> dict:
-    data = atlas.inspector(term, lang)
+def node(term: str, lang: str, ety: str | None = None) -> dict:
+    data = atlas.inspector(term, lang, ety)
     if data is None:
         raise HTTPException(404, "Unknown word")
     return data
 
 
 @app.get("/api/define")
-def define(term: str, lang: str = "", iso: str | None = None) -> dict:
+def define(term: str, lang: str = "", ety: str | None = None, iso: str | None = None) -> dict:
     """Short glosses from the local Kaikki dump (baked into atlas.sqlite)."""
-    return fetch_definitions(term=term, lang=lang, iso_639_3=iso, atlas=atlas)
+    return fetch_definitions(term=term, lang=lang, ety=ety, iso_639_3=iso, atlas=atlas)
 
 
 @app.post("/api/tree")
@@ -95,6 +96,42 @@ def tree(query: TreeQuery) -> dict:
     return atlas.walk(query)
 
 
+@app.get("/api/relate")
+def relate(
+    a: str = Query(..., description="First term"),
+    a_lang: str = Query(default="english"),
+    b: str = Query(..., description="Second term"),
+    b_lang: str = Query(default="spanish"),
+    max_depth: int = Query(default=12, ge=2, le=16),
+) -> dict:
+    return atlas.relate(a, a_lang, b, b_lang, max_depth=max_depth)
+
+
+@app.get("/api/game/round")
+def game_round(
+    en: str | None = None,
+    es: str | None = None,
+    avoid: str = Query(default="", description="Comma-separated round ids to skip"),
+) -> dict:
+    if en and es:
+        rnd = build_round(atlas, en.strip(), es.strip(), source="custom")
+    else:
+        skip = {x.strip() for x in avoid.split(",") if x.strip()}
+        rnd = next_round(atlas, avoid=skip)
+    if not rnd.get("ok"):
+        raise HTTPException(404, rnd.get("error") or "No round available")
+    return rnd
+
+
+@app.post("/api/game/score")
+def game_score(body: dict) -> dict:
+    """Score a guess. Body: {round, bridge?, chain?} — pass the round payload from /api/game/round."""
+    rnd = body.get("round") or {}
+    if not rnd.get("answer"):
+        raise HTTPException(400, "round.answer required")
+    return score_guess(rnd, body.get("bridge"), body.get("chain") or [])
+
+
 @app.post("/api/export")
 def export_tree(query: TreeQuery, format: str = Query(default="csv")) -> Response:
     result = atlas.walk(query)

backend/atlas.py

@@ -46,7 +46,7 @@ class Atlas:
         self.forward: CSR | None = None
         self.n = 0
         self.ctx: FilterContext | None = None
-        self._id_cache: dict[tuple[str, str], int | None] = {}
+        self._id_cache: dict[tuple[str, str, str | None], int | None] = {}
         self.child_count: np.ndarray | None = None
         self.lang_meta: dict[str, dict] = {}
         self._arrays: dict[str, np.ndarray] = {}
@@ -171,27 +171,50 @@ class Atlas:
                 out[int(row["id"])] = row["term"]
         return out
 
-    def node_id(self, term: str, lang: str) -> int | None:
-        key = (term, lang)
+    def node_id(self, term: str, lang: str, ety: str | None = None) -> int | None:
+        """Resolve a graph node.
+
+        When ``ety`` is provided (including empty string), require an exact match.
+        When omitted, prefer the sole ``(term, lang)`` node, then the ``""`` bucket,
+        then the highest ``child_count`` among matches.
+        """
+        key = (term, lang, ety)
         if key in self._id_cache:
             return self._id_cache[key]
         assert self.conn is not None
-        row = self.conn.execute(
-            "SELECT id FROM nodes WHERE term = ? AND lang = ?",
-            (term, lang),
-        ).fetchone()
-        if row is None and self.has_aliases:
-            # Alternate spelling / reconstruction redirect → canonical lemma.
+
+        def lookup(canon: str, want_ety: str | None) -> int | None:
+            if want_ety is not None:
+                row = self.conn.execute(
+                    "SELECT id FROM nodes WHERE term = ? AND lang = ? AND ety = ?",
+                    (canon, lang, want_ety),
+                ).fetchone()
+                return int(row["id"]) if row else None
+            rows = self.conn.execute(
+                """
+                SELECT id, ety, child_count FROM nodes
+                WHERE term = ? AND lang = ?
+                ORDER BY (ety = '') DESC, child_count DESC
+                """,
+                (canon, lang),
+            ).fetchall()
+            if not rows:
+                return None
+            if len(rows) == 1:
+                return int(rows[0]["id"])
+            for r in rows:
+                if r["ety"] == "":
+                    return int(r["id"])
+            return int(rows[0]["id"])
+
+        nid = lookup(term, ety)
+        if nid is None and self.has_aliases:
             alias = self.conn.execute(
                 "SELECT canon_term FROM term_aliases WHERE alias_term = ? AND lang = ?",
                 (term, lang),
             ).fetchone()
             if alias is not None:
-                row = self.conn.execute(
-                    "SELECT id FROM nodes WHERE term = ? AND lang = ?",
-                    (alias["canon_term"], lang),
-                ).fetchone()
-        nid = int(row["id"]) if row else None
+                nid = lookup(alias["canon_term"], ety)
         self._id_cache[key] = nid
         return nid
 
@@ -231,7 +254,7 @@ class Atlas:
         if self.has_aliases:
             for r in self.conn.execute(
                 """
-                SELECT a.alias_term, n.id, n.term, n.lang, n.child_count
+                SELECT a.alias_term, n.id, n.term, n.lang, n.ety, n.child_count
                 FROM term_aliases a
                 JOIN nodes n ON n.term = a.canon_term AND n.lang = a.lang
                 WHERE a.alias_norm = ?
@@ -245,7 +268,7 @@ class Atlas:
         if len(norm) == 1:
             for r in self.conn.execute(
                 """
-                SELECT id, term, lang, child_count
+                SELECT id, term, lang, ety, child_count
                 FROM nodes
                 WHERE term_norm LIKE ? || '%'
                 ORDER BY child_count DESC, term_norm
@@ -257,7 +280,7 @@ class Atlas:
         else:
             for r in self.conn.execute(
                 """
-                SELECT id, term, lang, child_count
+                SELECT id, term, lang, ety, child_count
                 FROM nodes
                 WHERE term_norm = ? OR term_norm LIKE ? || '%'
                 ORDER BY (term_norm = ?) DESC, child_count DESC, term_norm
@@ -270,7 +293,7 @@ class Atlas:
         if self.has_aliases and len(rows) < limit:
             for r in self.conn.execute(
                 """
-                SELECT a.alias_term, n.id, n.term, n.lang, n.child_count
+                SELECT a.alias_term, n.id, n.term, n.lang, n.ety, n.child_count
                 FROM term_aliases a
                 JOIN nodes n ON n.term = a.canon_term AND n.lang = a.lang
                 WHERE a.alias_norm LIKE ? || '%'
@@ -287,7 +310,7 @@ class Atlas:
             fts_q = '"' + norm.replace('"', "") + '"*'
             for r in self.conn.execute(
                 """
-                SELECT n.id, n.term, n.lang, n.child_count
+                SELECT n.id, n.term, n.lang, n.ety, n.child_count
                 FROM nodes_fts
                 JOIN nodes n ON n.id = nodes_fts.rowid
                 WHERE nodes_fts MATCH ?
@@ -308,6 +331,7 @@ class Atlas:
                 "id": nid,
                 "term": r["term"],
                 "lang": r["lang"],
+                "ety": r["ety"] if "ety" in r.keys() else "",
                 "lang_display": info["lang_display"],
                 "family_name": info["family_name"],
                 "child_count": int(r["child_count"]),
@@ -328,7 +352,7 @@ class Atlas:
             part = ids[i : i + chunk]
             qmarks = ",".join("?" * len(part))
             for row in self.conn.execute(
-                f"SELECT id, term, lang, child_count FROM nodes WHERE id IN ({qmarks})",
+                f"SELECT id, term, lang, ety, child_count, wiki_title FROM nodes WHERE id IN ({qmarks})",
                 part,
             ):
                 nid = int(row["id"])
@@ -337,13 +361,15 @@ class Atlas:
                     "id": nid,
                     "term": row["term"],
                     "lang": row["lang"],
+                    "ety": row["ety"] if "ety" in row.keys() else "",
                     "child_count": int(row["child_count"]),
+                    "wiki_title": row["wiki_title"],
                     **info,
                 }
         return out
 
-    def inspector(self, term: str, lang: str) -> dict | None:
-        nid = self.node_id(term, lang)
+    def inspector(self, term: str, lang: str, ety: str | None = None) -> dict | None:
+        nid = self.node_id(term, lang, ety)
         if nid is None:
             return None
         nodes = self.hydrate([nid])
@@ -368,10 +394,12 @@ class Atlas:
                     "id": tid,
                     "term": info.get("term", ""),
                     "lang": info.get("lang", ""),
+                    "ety": info.get("ety", ""),
                     "lang_display": info.get("lang_display"),
                     "family_name": info.get("family_name"),
                     "relation": RELATIONS[int(fwd.rel[e])],
                     "confidence": int(fwd.conf[e]) / 100.0,
+                    "child_count": info.get("child_count", 0),
                 }
             )
 
@@ -403,6 +431,7 @@ class Atlas:
                             "id": int(pid),
                             "term": info.get("term", ""),
                             "lang": info.get("lang", ""),
+                            "ety": info.get("ety", ""),
                             "lang_display": info.get("lang_display"),
                             "family_name": info.get("family_name"),
                             "part_index": pi,
@@ -469,7 +498,11 @@ class Atlas:
             "cognate_sets": cognates,
             "wals": wals[:80],
             "phonemes": phoneme_list,
-            "wiktionary": wiktionary_url(term, lang, node.get("lang_display")),
+            "wiktionary": wiktionary_url(
+                node.get("wiki_title"),
+                lang=lang,
+                lang_display=node.get("lang_display"),
+            ),
         }
         if self.ctx.freq_zipf is not None:
             z = float(self.ctx.freq_zipf[nid])
@@ -481,7 +514,7 @@ class Atlas:
     def walk(self, query: TreeQuery) -> dict:
         t0 = time.perf_counter()
         assert self.reverse is not None and self.ctx is not None
-        nid = self.node_id(query.term, query.lang)
+        nid = self.node_id(query.term, query.lang, getattr(query, "ety", None))
         if nid is None:
             return {
                 "root": None,
@@ -491,6 +524,189 @@ class Atlas:
             }
         return walk_tree(self, query, nid, t0)
 
+    def ancestor_map(self, nid: int, max_depth: int = 12) -> tuple[dict[int, int], dict[int, int], dict[int, int]]:
+        """Forward BFS: parent[node], depth[node], rel_code into parent.
+
+        ``parent[nid] = -1``. Depth is hops from ``nid`` toward etymons.
+        """
+        fwd = self.forward
+        assert fwd is not None
+        parent: dict[int, int] = {nid: -1}
+        depth: dict[int, int] = {nid: 0}
+        rel_into: dict[int, int] = {nid: -1}
+        q: deque[int] = deque([nid])
+        while q:
+            cur = q.popleft()
+            d = depth[cur]
+            if d >= max_depth:
+                continue
+            for e in fwd.edge_range(cur):
+                tgt = int(fwd.targets[e])
+                if tgt in parent:
+                    continue
+                parent[tgt] = cur
+                depth[tgt] = d + 1
+                rel_into[tgt] = int(fwd.rel[e])
+                q.append(tgt)
+        return parent, depth, rel_into
+
+    def relate(
+        self,
+        term_a: str,
+        lang_a: str,
+        term_b: str,
+        lang_b: str,
+        *,
+        ety_a: str | None = None,
+        ety_b: str | None = None,
+        max_depth: int = 12,
+    ) -> dict:
+        """Closest shared etymon (DAG meet) and reconstructed paths a→lca and b→lca."""
+        id_a = self.node_id(term_a, lang_a, ety_a)
+        id_b = self.node_id(term_b, lang_b, ety_b)
+        if id_a is None or id_b is None:
+            return {
+                "ok": False,
+                "error": "not_found",
+                "a": {"term": term_a, "lang": lang_a, "id": id_a},
+                "b": {"term": term_b, "lang": lang_b, "id": id_b},
+            }
+        if id_a == id_b:
+            nodes = self.hydrate([id_a])
+            node = nodes[id_a]
+            return {
+                "ok": True,
+                "a": node,
+                "b": node,
+                "shared_count": 1,
+                "lca": {**node, "depth_a": 0, "depth_b": 0, "bridge": _bridge_label(node["lang"])},
+                "path_a": [node],
+                "path_b": [node],
+                "bridge": _bridge_label(node["lang"]),
+            }
+
+        par_a, dep_a, _rel_a = self.ancestor_map(id_a, max_depth)
+        par_b, dep_b, _rel_b = self.ancestor_map(id_b, max_depth)
+        shared = set(par_a) & set(par_b)
+        shared.discard(id_a)
+        shared.discard(id_b)
+        if not shared:
+            # One word may be an ancestor of the other.
+            if id_a in par_b:
+                shared = {id_a}
+            elif id_b in par_a:
+                shared = {id_b}
+        if not shared:
+            ha = self.hydrate([id_a, id_b])
+            return {
+                "ok": False,
+                "error": "no_shared_ancestor",
+                "a": ha[id_a],
+                "b": ha[id_b],
+                "shared_count": 0,
+            }
+
+        hydrated = self.hydrate(list(shared) + [id_a, id_b])
+
+        def score(cid: int) -> tuple:
+            node = hydrated.get(cid) or {}
+            term = (node.get("term") or "").strip()
+            junk = 1 if (not term or set(term) <= {">", "*", "-"}) else 0
+            bridge = _bridge_label(node.get("lang") or "")
+            # Prefer concrete historical stages over deep PIE when equally close.
+            bridge_rank = {
+                "Latin": 0,
+                "Old / Middle French": 1,
+                "Old English": 2,
+                "Proto-Germanic": 3,
+                "Proto-Italic": 4,
+                "Ancient Greek": 5,
+                "Proto-Slavic": 6,
+                "Sanskrit": 7,
+                "Proto-Indo-European": 8,
+                "Other": 9,
+            }.get(bridge, 9)
+            da, db = dep_a.get(cid, 99), dep_b.get(cid, 99)
+            return (junk, da + db, max(da, db), bridge_rank, -int(node.get("child_count") or 0))
+
+        lca_id = min(shared, key=score)
+        lca_node = hydrated[lca_id]
+        bridge = _bridge_label(lca_node["lang"])
+
+        def climb_to_lca(start: int, parents: dict[int, int]) -> list[int]:
+            # ancestor_map: parent[etymon] = node closer to the modern word (child → etymon).
+            fwd_map: dict[int, list[int]] = {}
+            for ety_n, child in parents.items():
+                if child != -1:
+                    fwd_map.setdefault(child, []).append(ety_n)
+            came: dict[int, int] = {start: -1}
+            dq: deque[int] = deque([start])
+            found = False
+            while dq:
+                cur = dq.popleft()
+                if cur == lca_id:
+                    found = True
+                    break
+                for n in fwd_map.get(cur, ()):
+                    if n not in came:
+                        came[n] = cur
+                        dq.append(n)
+            if not found:
+                return [start, lca_id] if start != lca_id else [start]
+            path = [lca_id]
+            cur = lca_id
+            while cur != start:
+                cur = came[cur]
+                path.append(cur)
+            path.reverse()
+            return path
+
+        ids_a = climb_to_lca(id_a, par_a)
+        ids_b = climb_to_lca(id_b, par_b)
+        need = list(dict.fromkeys(ids_a + ids_b))
+        nodes = self.hydrate(need)
+
+        def pack(ids: list[int]) -> list[dict]:
+            return [nodes[i] for i in ids if i in nodes]
+
+        return {
+            "ok": True,
+            "a": nodes[id_a],
+            "b": nodes[id_b],
+            "shared_count": len(shared),
+            "lca": {
+                **lca_node,
+                "depth_a": int(dep_a.get(lca_id, 0)),
+                "depth_b": int(dep_b.get(lca_id, 0)),
+                "bridge": bridge,
+            },
+            "path_a": pack(ids_a),
+            "path_b": pack(ids_b),
+            "bridge": bridge,
+        }
+
+
+def _bridge_label(lang: str) -> str:
+    lk = (lang or "").casefold()
+    buckets = {
+        "Latin": {"latin", "classical latin", "medieval latin", "late latin", "vulgate latin"},
+        "Old / Middle French": {"old french", "middle french"},
+        "Old English": {"old english"},
+        "Proto-Germanic": {"proto-germanic"},
+        "Proto-Italic": {"proto-italic"},
+        "Ancient Greek": {"ancient greek", "classical greek"},
+        "Proto-Slavic": {"proto-slavic", "common slavic"},
+        "Sanskrit": {"sanskrit", "vedic sanskrit"},
+        "Proto-Indo-European": {"proto-indo-european"},
+    }
+    for label, langs in buckets.items():
+        if lk in langs:
+            return label
+    if not lk:
+        return "Other"
+    # Title-ish display for other stages (Middle English, etc.)
+    return lang.replace("-", " ").title() if lang else "Other"
+
 
 def _allowed_rel_mask(edges: EdgeFilter) -> np.ndarray:
     names = edges.relations or DEFAULT_RELATIONS
@@ -797,6 +1013,7 @@ def walk_tree(atlas: Atlas, query: TreeQuery, root: int, t0: float) -> dict:
                 "branch": "root" if nid == root else "down",
                 "term": terms.get(nid, ""),
                 "lang": ctx.lang_key(nid),
+                "ety": "",
                 "depth": int(depth_of[nid]),
                 "relation": relation_of(nid) if nid != root else None,
                 "confidence": conf_of(nid) if nid != root else None,
@@ -923,6 +1140,7 @@ def walk_tree(atlas: Atlas, query: TreeQuery, root: int, t0: float) -> dict:
                 "branch": "up",
                 "term": terms.get(nid, ""),
                 "lang": ctx.lang_key(nid),
+                "ety": "",
                 "depth": int(anc_depth[nid]),
                 "relation": RELATIONS[int(rc)] if rc >= 0 else None,
                 "confidence": int(anc_conf_code.get(nid, 100)) / 100.0,
@@ -1011,6 +1229,7 @@ def walk_tree(atlas: Atlas, query: TreeQuery, root: int, t0: float) -> dict:
         raw_id = node["id"]
         nid = int(str(raw_id)[2:]) if isinstance(raw_id, str) and str(raw_id).startswith("a:") else int(raw_id)
         info = extra.get(nid, {})
+        node["ety"] = info.get("ety", "")
         node["lang_display"] = info.get("lang_display")
         node["family_name"] = info.get("family_name")
         node["macroarea"] = info.get("macroarea")
@@ -1043,6 +1262,7 @@ def walk_tree(atlas: Atlas, query: TreeQuery, root: int, t0: float) -> dict:
             "id": root,
             "term": terms.get(root) or root_info.get("term") or query.term,
             "lang": ctx.lang_key(root),
+            "ety": root_info.get("ety", ""),
             **{k: root_info.get(k) for k in ("lang_display", "family_name", "macroarea", "latitude", "longitude")},
         },
         "nodes": payload_nodes,

backend/define.py

@@ -64,6 +64,7 @@ def lookup_definitions(
     conn: sqlite3.Connection,
     term: str,
     lang: str = "",
+    ety: str | None = None,
     iso_639_3: str | None = None,
     lang_meta: dict[str, dict] | None = None,
 ) -> dict:
@@ -75,20 +76,32 @@ def lookup_definitions(
 
     row = None
     matched_lang = None
+    matched_ety = None
     for cand in candidates:
-        row = conn.execute(
-            "SELECT lang, senses_json FROM definitions WHERE term = ? AND lang = ?",
-            (term, cand),
-        ).fetchone()
+        if ety is not None:
+            row = conn.execute(
+                "SELECT lang, ety, senses_json FROM definitions WHERE term = ? AND lang = ? AND ety = ?",
+                (term, cand, ety),
+            ).fetchone()
+        else:
+            row = conn.execute(
+                """
+                SELECT lang, ety, senses_json FROM definitions
+                WHERE term = ? AND lang = ?
+                ORDER BY (ety = '') DESC, ety
+                LIMIT 1
+                """,
+                (term, cand),
+            ).fetchone()
         if row is not None:
             matched_lang = row["lang"] if isinstance(row, sqlite3.Row) else row[0]
+            matched_ety = row["ety"] if isinstance(row, sqlite3.Row) else row[1]
             break
 
     fallback = False
     if row is None:
-        # Any language for this spelling (last resort for mismatched atlas keys).
         rows = conn.execute(
-            "SELECT lang, senses_json FROM definitions WHERE term = ? ORDER BY lang LIMIT 8",
+            "SELECT lang, ety, senses_json FROM definitions WHERE term = ? ORDER BY lang, ety LIMIT 8",
             (term,),
         ).fetchall()
         if rows:
@@ -101,12 +114,14 @@ def lookup_definitions(
                     break
             row = chosen or rows[0]
             matched_lang = row["lang"] if isinstance(row, sqlite3.Row) else row[0]
+            matched_ety = row["ety"] if isinstance(row, sqlite3.Row) else row[1]
             fallback = bool(candidates) and matched_lang not in candidates
 
     if row is None:
         return {
             "term": term,
             "lang": lang,
+            "ety": ety or "",
             "matched_code": None,
             "senses": [],
             "fallback": False,
@@ -114,11 +129,12 @@ def lookup_definitions(
             "error": "not_found",
         }
 
-    senses_json = row["senses_json"] if isinstance(row, sqlite3.Row) else row[1]
+    senses_json = row["senses_json"] if isinstance(row, sqlite3.Row) else row[2]
     senses = _trim_senses(senses_json)
     return {
         "term": term,
         "lang": lang,
+        "ety": matched_ety or "",
         "matched_code": matched_lang,
         "senses": senses,
         "fallback": fallback,
@@ -130,6 +146,7 @@ def lookup_definitions(
 def fetch_definitions(
     term: str,
     lang: str = "",
+    ety: str | None = None,
     iso_639_3: str | None = None,
     *,
     atlas=None,
@@ -139,6 +156,7 @@ def fetch_definitions(
         return {
             "term": term,
             "lang": lang,
+            "ety": ety or "",
             "matched_code": None,
             "senses": [],
             "fallback": False,
@@ -149,6 +167,7 @@ def fetch_definitions(
         atlas.conn,
         term=term,
         lang=lang,
+        ety=ety,
         iso_639_3=iso_639_3,
         lang_meta=getattr(atlas, "lang_meta", None),
     )

backend/game.py

@@ -0,0 +1,240 @@
+"""Etymology link game: guess how two related words meet in the graph."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import random
+from pathlib import Path
+
+from backend.atlas import Atlas, _bridge_label
+from backend.define import lookup_definitions
+
+ROOT = Path(__file__).resolve().parents[1]
+DECK_PATH = ROOT / "data" / "game" / "en_es_pairs.json"
+
+BRIDGE_CHOICES = [
+    "Latin",
+    "Old / Middle French",
+    "Proto-Germanic",
+    "Proto-Indo-European",
+    "Ancient Greek",
+    "Old English",
+]
+
+SEED_PAIRS: list[dict] = [
+    {"en": "family", "es": "familia", "source": "seed"},
+    {"en": "nation", "es": "nación", "source": "seed"},
+    {"en": "name", "es": "nombre", "source": "seed"},
+    {"en": "five", "es": "cinco", "source": "seed"},
+    {"en": "four", "es": "cuatro", "source": "seed"},
+    {"en": "star", "es": "estrella", "source": "seed"},
+    {"en": "night", "es": "noche", "source": "seed"},
+    {"en": "sun", "es": "sol", "source": "seed"},
+    {"en": "tooth", "es": "diente", "source": "seed"},
+    {"en": "heart", "es": "corazón", "source": "seed"},
+    {"en": "foot", "es": "pie", "source": "seed"},
+    {"en": "eye", "es": "ojo", "source": "seed"},
+    {"en": "fish", "es": "pez", "source": "seed"},
+    {"en": "new", "es": "nuevo", "source": "seed"},
+    {"en": "full", "es": "lleno", "source": "seed"},
+    {"en": "come", "es": "venir", "source": "seed"},
+    {"en": "mother", "es": "madre", "source": "seed"},
+    {"en": "father", "es": "padre", "source": "seed"},
+    {"en": "three", "es": "tres", "source": "seed"},
+    {"en": "two", "es": "dos", "source": "seed"},
+    {"en": "one", "es": "uno", "source": "seed"},
+    {"en": "wind", "es": "viento", "source": "seed"},
+    {"en": "red", "es": "rojo", "source": "seed"},
+    {"en": "school", "es": "escuela", "source": "seed"},
+    {"en": "music", "es": "música", "source": "seed"},
+    {"en": "animal", "es": "animal", "source": "seed"},
+    {"en": "hospital", "es": "hospital", "source": "seed"},
+    {"en": "nature", "es": "naturaleza", "source": "seed"},
+    {"en": "important", "es": "importante", "source": "seed"},
+]
+
+
+def _load_deck() -> list[dict]:
+    pairs = list(SEED_PAIRS)
+    if DECK_PATH.exists():
+        try:
+            data = json.loads(DECK_PATH.read_text())
+            for row in data.get("pairs") or []:
+                en = (row.get("en") or "").strip()
+                es = (row.get("es") or "").strip()
+                if en and es:
+                    pairs.append({"en": en, "es": es, "source": row.get("source") or "deck"})
+        except (json.JSONDecodeError, OSError):
+            pass
+    seen: set[tuple[str, str]] = set()
+    out: list[dict] = []
+    for p in pairs:
+        key = (p["en"].casefold(), p["es"].casefold())
+        if key in seen:
+            continue
+        seen.add(key)
+        out.append(p)
+    return out
+
+
+def _gloss(atlas: Atlas, term: str, lang: str) -> str:
+    assert atlas.conn is not None
+    payload = lookup_definitions(atlas.conn, term=term, lang=lang, lang_meta=atlas.lang_meta)
+    senses = payload.get("senses") or []
+    if not senses:
+        return ""
+    glosses = senses[0].get("glosses") or []
+    return glosses[0] if glosses else ""
+
+
+def _display_lang(atlas: Atlas, lang: str) -> str:
+    meta = atlas.lang_meta.get(lang) or {}
+    return meta.get("display") or (lang or "").replace("-", " ").title()
+
+
+def _pack_node(atlas: Atlas, n: dict) -> dict:
+    return {
+        "term": n["term"],
+        "lang": n["lang"],
+        "lang_display": n.get("lang_display") or _display_lang(atlas, n["lang"]),
+    }
+
+
+def _round_id(en: str, es: str) -> str:
+    return hashlib.sha1(f"{en}\0{es}".encode()).hexdigest()[:12]
+
+
+def build_round(atlas: Atlas, en: str, es: str, *, source: str = "custom") -> dict:
+    related = atlas.relate(en, "english", es, "spanish", max_depth=12)
+    if not related.get("ok"):
+        return {"ok": False, "error": related.get("error") or "unrelated", "en": en, "es": es}
+
+    path_a = related["path_a"]
+    path_b = related["path_b"]
+    lca = related["lca"]
+    bridge = _bridge_label(lca["lang"])
+
+    # Language hops after the modern word, including the shared ancestor language once.
+    langs_a = [_display_lang(atlas, n["lang"]) for n in path_a[1:]]
+    langs_b = [_display_lang(atlas, n["lang"]) for n in path_b[1:]]
+    a_only = langs_a[:-1] if langs_a else []
+    b_only = langs_b[:-1] if langs_b else []
+    answer_chain = a_only + [bridge] + list(reversed(b_only))
+
+    distractors = [
+        "Proto-Germanic",
+        "Latin",
+        "Old French",
+        "Middle English",
+        "Old English",
+        "Old Spanish",
+        "Proto-Italic",
+        "Ancient Greek",
+        "Proto-Indo-European",
+        "Middle French",
+        "Proto-West Germanic",
+        "Old / Middle French",
+    ]
+    needed = list(dict.fromkeys(answer_chain))
+    pool = list(dict.fromkeys([*needed, *distractors]))
+    rng = random.Random(_round_id(en, es))
+    # Keep all needed + a few distractors
+    extras = [p for p in pool if p not in needed]
+    rng.shuffle(extras)
+    pool = needed + extras[:4]
+    rng.shuffle(pool)
+
+    opts = [bridge]
+    for c in BRIDGE_CHOICES:
+        if c not in opts:
+            opts.append(c)
+        if len(opts) >= 4:
+            break
+    rng.shuffle(opts)
+
+    a = related["a"]
+    b = related["b"]
+    return {
+        "ok": True,
+        "id": _round_id(en, es),
+        "source": source,
+        "a": {
+            "term": a["term"],
+            "lang": a["lang"],
+            "lang_display": a.get("lang_display") or "English",
+            "gloss": _gloss(atlas, a["term"], a["lang"]),
+        },
+        "b": {
+            "term": b["term"],
+            "lang": b["lang"],
+            "lang_display": b.get("lang_display") or "Spanish",
+            "gloss": _gloss(atlas, b["term"], b["lang"]),
+        },
+        "bridge_choices": opts,
+        "slot_count": len(answer_chain),
+        "chip_pool": pool,
+        "answer": {
+            "bridge": bridge,
+            "chain": answer_chain,
+            "lca": {**_pack_node(atlas, lca), "bridge": bridge},
+            "path_a": [_pack_node(atlas, n) for n in path_a],
+            "path_b": [_pack_node(atlas, n) for n in path_b],
+        },
+    }
+
+
+def next_round(atlas: Atlas, *, avoid: set[str] | None = None) -> dict:
+    deck = _load_deck()
+    avoid = avoid or set()
+    # Prefer pedagogical pairs (seed / IE-CoR) over opportunistic Latin-root samples.
+    def priority(p: dict) -> int:
+        src = p.get("source") or ""
+        if src == "seed":
+            return 0
+        if src == "iecor":
+            return 1
+        return 2
+
+    ranked = sorted(deck, key=priority)
+    buckets = {0: [], 1: [], 2: []}
+    for p in ranked:
+        rid = _round_id(p["en"], p["es"])
+        if rid in avoid:
+            continue
+        buckets[priority(p)].append(p)
+    # Weighted draw: mostly seed/iecor
+    pool: list[dict] = []
+    pool.extend(buckets[0] * 3)
+    pool.extend(buckets[1] * 2)
+    pool.extend(buckets[2])
+    if not pool:
+        pool = list(deck)
+    random.shuffle(pool)
+    last_err = "empty_deck"
+    for p in pool[:60]:
+        rnd = build_round(atlas, p["en"], p["es"], source=p.get("source") or "deck")
+        if rnd.get("ok"):
+            return rnd
+        last_err = rnd.get("error") or last_err
+    return {"ok": False, "error": last_err}
+
+
+def score_guess(round_payload: dict, bridge_guess: str | None, chain_guess: list[str] | None) -> dict:
+    ans = round_payload.get("answer") or {}
+    true_bridge = ans.get("bridge") or ""
+    true_chain = ans.get("chain") or []
+    bridge_ok = (bridge_guess or "").strip() == true_bridge
+    chain = list(chain_guess or [])
+    n = len(true_chain)
+    correct_slots = sum(1 for i in range(n) if i < len(chain) and chain[i] == true_chain[i])
+    chain_ok = chain[:n] == true_chain and len(chain) >= n
+    return {
+        "bridge_ok": bridge_ok,
+        "chain_ok": chain_ok,
+        "correct_slots": correct_slots,
+        "slot_count": n,
+        "score": int(bridge_ok) + correct_slots,
+        "max_score": 1 + n,
+        "answer": ans,
+    }

backend/models.py

@@ -61,6 +61,8 @@ class PathFilter(BaseModel):
 class TreeQuery(BaseModel):
     term: str
     lang: str
+    # Editorial etymology id / etymology_number key; omit to auto-resolve.
+    ety: str | None = None
     edges: EdgeFilter = Field(default_factory=EdgeFilter)
     leaf: NodePredicate = Field(default_factory=NodePredicate)
     path: PathFilter = Field(default_factory=PathFilter)
@@ -74,6 +76,7 @@ class TreeQuery(BaseModel):
 class SuggestHit(BaseModel):
     term: str
     lang: str
+    ety: str = ""
     lang_display: str | None = None
     family_name: str | None = None
     child_count: int = 0

backend/wiktionary.py

@@ -1,39 +1,10 @@
-"""Build en.wiktionary.org links for atlas nodes."""
+"""Build en.wiktionary.org links from persisted Wiktionary page titles."""
 
 from __future__ import annotations
 
 from urllib.parse import quote
 
-# Length marks are common in our lemmas but usually absent from WT page titles.
-_MACRON_FOLD = str.maketrans({
-    "ā": "a", "ē": "e", "ī": "i", "ō": "o", "ū": "u", "ȳ": "y",
-    "Ā": "A", "Ē": "E", "Ī": "I", "Ō": "O", "Ū": "U", "Ȳ": "Y",
-    "ă": "a", "ĕ": "e", "ĭ": "i", "ŏ": "o", "ŭ": "u",
-})
-
-# Reconstruction: namespace language titles (Wiktionary English names).
-# Stages of Latin share Reconstruction:Latin/… on Wiktionary.
-_RECON_LANG_TITLE: dict[str, str] = {
-    "latin": "Latin",
-    "vulgar latin": "Latin",
-    "late latin": "Latin",
-    "medieval latin": "Latin",
-    "new latin": "Latin",
-    "old latin": "Old Latin",
-    "proto-indo-european": "Proto-Indo-European",
-    "proto-germanic": "Proto-Germanic",
-    "proto-west germanic": "Proto-West Germanic",
-    "proto-italic": "Proto-Italic",
-    "proto-celtic": "Proto-Celtic",
-    "proto-slavic": "Proto-Slavic",
-    "proto-balto-slavic": "Proto-Balto-Slavic",
-    "proto-indo-iranian": "Proto-Indo-Iranian",
-    "proto-iranian": "Proto-Iranian",
-    "proto-semitic": "Proto-Semitic",
-    "proto-romance": "Proto-Romance",
-}
-
-# Fragment / heading language names when display metadata is missing or poorly cased.
+# Fragment / heading language names for mainspace multi-language pages.
 _SECTION_LANG_TITLE: dict[str, str] = {
     "old french": "Old French",
     "middle french": "Middle French",
@@ -45,70 +16,50 @@ _SECTION_LANG_TITLE: dict[str, str] = {
     "vulgar latin": "Vulgar Latin",
     "late latin": "Late Latin",
     "medieval latin": "Medieval Latin",
+    "latin": "Latin",
+    "english": "English",
+    "french": "French",
 }
 
 
-def fold_length_marks(term: str) -> str:
-    return term.translate(_MACRON_FOLD)
-
-
 def wiki_section_title(lang: str, lang_display: str | None = None) -> str:
-    """Language heading as used in `#Old_French` fragments."""
+    """Language heading as used in `#Old_French` fragments on mainspace pages."""
     key = (lang or "").strip().casefold()
     if key in _SECTION_LANG_TITLE:
         return _SECTION_LANG_TITLE[key]
-    if key in _RECON_LANG_TITLE and key != "vulgar latin":
-        # Prefer canonical WT casing for proto-* etc.
-        return _RECON_LANG_TITLE[key]
     name = (lang_display or lang or "").strip().replace("_", " ")
     if not name:
         return ""
-    # Title-case hyphenated segments: proto-indo-european → Proto-Indo-European
     return "-".join(
         " ".join(w[:1].upper() + w[1:] if w else w for w in part.split())
         for part in name.split("-")
     )
 
 
-def reconstruction_lang_title(lang: str) -> str:
-    key = (lang or "").strip().casefold()
-    if key in _RECON_LANG_TITLE:
-        return _RECON_LANG_TITLE[key]
-    return wiki_section_title(lang)
-
-
 def mediawiki_path_title(title: str) -> str:
     """Percent-encode a wiki title for use in /wiki/… paths."""
     return quote(title.replace(" ", "_"), safe="/:()'!,*-.")
 
 
-def wiktionary_url(term: str, lang: str, lang_display: str | None = None) -> str:
-    """Return an en.wiktionary.org URL for a (term, lang) node.
+def wiktionary_url(
+    wiki_title: str | None,
+    *,
+    lang: str = "",
+    lang_display: str | None = None,
+) -> str | None:
+    """Build a Wiktionary URL from a stored page title, or None if unknown.
 
-    Reconstructed lemmas (leading ``*``) live under ``Reconstruction:Lang/form``.
-    Attested lemmas use mainspace with a ``#Language`` section fragment.
-
-    Note: some graph spellings (e.g. Old French *akever*) are cited in etymologies
-    but have no Wiktionary entry; those links will 404 until WT has a page.
+    ``wiki_title`` is the Kaikki ``original_title`` (e.g. ``Reconstruction:Latin/accapare``)
+    or the mainspace lemma. Nodes minted only from descendant-tree labels have no title
+    and return ``None`` (no link).
     """
-    term = (term or "").strip()
-    lang = (lang or "").strip()
-    if not term:
-        return "https://en.wiktionary.org/"
-
-    if term.startswith("*"):
-        form = fold_length_marks(term[1:])
-        lang_title = reconstruction_lang_title(lang)
-        if not form or not lang_title:
-            # Fall back to search rather than a guaranteed-bad *lemma URL.
-            q = quote(term)
-            return f"https://en.wiktionary.org/w/index.php?search={q}"
-        page = f"Reconstruction:{lang_title}/{form}"
-        return f"https://en.wiktionary.org/wiki/{mediawiki_path_title(page)}"
-
+    title = (wiki_title or "").strip()
+    if not title:
+        return None
+    path = mediawiki_path_title(title)
+    if title.startswith("Reconstruction:"):
+        return f"https://en.wiktionary.org/wiki/{path}"
     section = wiki_section_title(lang, lang_display)
-    # Keep attested-orthography diacritics; only encode for the URL path.
-    path = mediawiki_path_title(term)
     if section:
         frag = quote(section.replace(" ", "_"), safe="")
         return f"https://en.wiktionary.org/wiki/{path}#{frag}"

frontend/dist/assets/index-Dr1iPrLq.css

@@ -0,0 +1 @@
+@import"https://fonts.googleapis.com/css2?family=Fraunces:opsz,wght@9..144,500;9..144,700&family=Source+Sans+3:wght@400;500;600;700&display=swap";.leaflet-pane,.leaflet-tile,.leaflet-marker-icon,.leaflet-marker-shadow,.leaflet-tile-container,.leaflet-pane>svg,.leaflet-pane>canvas,.leaflet-zoom-box,.leaflet-image-layer,.leaflet-layer{position:absolute;left:0;top:0}.leaflet-container{overflow:hidden}.leaflet-tile,.leaflet-marker-icon,.leaflet-marker-shadow{-webkit-user-select:none;-moz-user-select:none;user-select:none;-webkit-user-drag:none}.leaflet-tile::selection{background:transparent}.leaflet-safari .leaflet-tile{image-rendering:-webkit-optimize-contrast}.leaflet-safari .leaflet-tile-container{width:1600px;height:1600px;-webkit-transform-origin:0 0}.leaflet-marker-icon,.leaflet-marker-shadow{display:block}.leaflet-container .leaflet-overlay-pane svg{max-width:none!important;max-height:none!important}.leaflet-container .leaflet-marker-pane img,.leaflet-container .leaflet-shadow-pane img,.leaflet-container .leaflet-tile-pane img,.leaflet-container img.leaflet-image-layer,.leaflet-container .leaflet-tile{max-width:none!important;max-height:none!important;width:auto;padding:0}.leaflet-container img.leaflet-tile{mix-blend-mode:plus-lighter}.leaflet-container.leaflet-touch-zoom{-ms-touch-action:pan-x pan-y;touch-action:pan-x pan-y}.leaflet-container.leaflet-touch-drag{-ms-touch-action:pinch-zoom;touch-action:none;touch-action:pinch-zoom}.leaflet-container.leaflet-touch-drag.leaflet-touch-zoom{-ms-touch-action:none;touch-action:none}.leaflet-container{-webkit-tap-highlight-color:transparent}.leaflet-container a{-webkit-tap-highlight-color:rgba(51,181,229,.4)}.leaflet-tile{filter:inherit;visibility:hidden}.leaflet-tile-loaded{visibility:inherit}.leaflet-zoom-box{width:0;height:0;-moz-box-sizing:border-box;box-sizing:border-box;z-index:800}.leaflet-overlay-pane svg{-moz-user-select:none}.leaflet-pane{z-index:400}.leaflet-tile-pane{z-index:200}.leaflet-overlay-pane{z-index:400}.leaflet-shadow-pane{z-index:500}.leaflet-marker-pane{z-index:600}.leaflet-tooltip-pane{z-index:650}.leaflet-popup-pane{z-index:700}.leaflet-map-pane canvas{z-index:100}.leaflet-map-pane svg{z-index:200}.leaflet-vml-shape{width:1px;height:1px}.lvml{behavior:url(#default#VML);display:inline-block;position:absolute}.leaflet-control{position:relative;z-index:800;pointer-events:visiblePainted;pointer-events:auto}.leaflet-top,.leaflet-bottom{position:absolute;z-index:1000;pointer-events:none}.leaflet-top{top:0}.leaflet-right{right:0}.leaflet-bottom{bottom:0}.leaflet-left{left:0}.leaflet-control{float:left;clear:both}.leaflet-right .leaflet-control{float:right}.leaflet-top .leaflet-control{margin-top:10px}.leaflet-bottom .leaflet-control{margin-bottom:10px}.leaflet-left .leaflet-control{margin-left:10px}.leaflet-right .leaflet-control{margin-right:10px}.leaflet-fade-anim .leaflet-popup{opacity:0;-webkit-transition:opacity .2s linear;-moz-transition:opacity .2s linear;transition:opacity .2s linear}.leaflet-fade-anim .leaflet-map-pane .leaflet-popup{opacity:1}.leaflet-zoom-animated{-webkit-transform-origin:0 0;-ms-transform-origin:0 0;transform-origin:0 0}svg.leaflet-zoom-animated{will-change:transform}.leaflet-zoom-anim .leaflet-zoom-animated{-webkit-transition:-webkit-transform .25s cubic-bezier(0,0,.25,1);-moz-transition:-moz-transform .25s cubic-bezier(0,0,.25,1);transition:transform .25s cubic-bezier(0,0,.25,1)}.leaflet-zoom-anim .leaflet-tile,.leaflet-pan-anim .leaflet-tile{-webkit-transition:none;-moz-transition:none;transition:none}.leaflet-zoom-anim .leaflet-zoom-hide{visibility:hidden}.leaflet-interactive{cursor:pointer}.leaflet-grab{cursor:-webkit-grab;cursor:-moz-grab;cursor:grab}.leaflet-crosshair,.leaflet-crosshair .leaflet-interactive{cursor:crosshair}.leaflet-popup-pane,.leaflet-control{cursor:auto}.leaflet-dragging .leaflet-grab,.leaflet-dragging .leaflet-grab .leaflet-interactive,.leaflet-dragging .leaflet-marker-draggable{cursor:move;cursor:-webkit-grabbing;cursor:-moz-grabbing;cursor:grabbing}.leaflet-marker-icon,.leaflet-marker-shadow,.leaflet-image-layer,.leaflet-pane>svg path,.leaflet-tile-container{pointer-events:none}.leaflet-marker-icon.leaflet-interactive,.leaflet-image-layer.leaflet-interactive,.leaflet-pane>svg path.leaflet-interactive,svg.leaflet-image-layer.leaflet-interactive path{pointer-events:visiblePainted;pointer-events:auto}.leaflet-container{background:#ddd;outline-offset:1px}.leaflet-container a{color:#0078a8}.leaflet-zoom-box{border:2px dotted #38f;background:#ffffff80}.leaflet-container{font-family:Helvetica Neue,Arial,Helvetica,sans-serif;font-size:12px;font-size:.75rem;line-height:1.5}.leaflet-bar{box-shadow:0 1px 5px #000000a6;border-radius:4px}.leaflet-bar a{background-color:#fff;border-bottom:1px solid #ccc;width:26px;height:26px;line-height:26px;display:block;text-align:center;text-decoration:none;color:#000}.leaflet-bar a,.leaflet-control-layers-toggle{background-position:50% 50%;background-repeat:no-repeat;display:block}.leaflet-bar a:hover,.leaflet-bar a:focus{background-color:#f4f4f4}.leaflet-bar a:first-child{border-top-left-radius:4px;border-top-right-radius:4px}.leaflet-bar a:last-child{border-bottom-left-radius:4px;border-bottom-right-radius:4px;border-bottom:none}.leaflet-bar a.leaflet-disabled{cursor:default;background-color:#f4f4f4;color:#bbb}.leaflet-touch .leaflet-bar a{width:30px;height:30px;line-height:30px}.leaflet-touch .leaflet-bar a:first-child{border-top-left-radius:2px;border-top-right-radius:2px}.leaflet-touch .leaflet-bar a:last-child{border-bottom-left-radius:2px;border-bottom-right-radius:2px}.leaflet-control-zoom-in,.leaflet-control-zoom-out{font:700 18px Lucida Console,Monaco,monospace;text-indent:1px}.leaflet-touch .leaflet-control-zoom-in,.leaflet-touch .leaflet-control-zoom-out{font-size:22px}.leaflet-control-layers{box-shadow:0 1px 5px #0006;background:#fff;border-radius:5px}.leaflet-control-layers-toggle{background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABoAAAAaCAQAAAADQ4RFAAACf0lEQVR4AY1UM3gkARTePdvdoTxXKc+qTl3aU5U6b2Kbkz3Gtq3Zw6ziLGNPzrYx7946Tr6/ee/XeCQ4D3ykPtL5tHno4n0d/h3+xfuWHGLX81cn7r0iTNzjr7LrlxCqPtkbTQEHeqOrTy4Yyt3VCi/IOB0v7rVC7q45Q3Gr5K6jt+3Gl5nCoDD4MtO+j96Wu8atmhGqcNGHObuf8OM/x3AMx38+4Z2sPqzCxRFK2aF2e5Jol56XTLyggAMTL56XOMoS1W4pOyjUcGGQdZxU6qRh7B9Zp+PfpOFlqt0zyDZckPi1ttmIp03jX8gyJ8a/PG2yutpS/Vol7peZIbZcKBAEEheEIAgFbDkz5H6Zrkm2hVWGiXKiF4Ycw0RWKdtC16Q7qe3X4iOMxruonzegJzWaXFrU9utOSsLUmrc0YjeWYjCW4PDMADElpJSSQ0vQvA1Tm6/JlKnqFs1EGyZiFCqnRZTEJJJiKRYzVYzJck2Rm6P4iH+cmSY0YzimYa8l0EtTODFWhcMIMVqdsI2uiTvKmTisIDHJ3od5GILVhBCarCfVRmo4uTjkhrhzkiBV7SsaqS+TzrzM1qpGGUFt28pIySQHR6h7F6KSwGWm97ay+Z+ZqMcEjEWebE7wxCSQwpkhJqoZA5ivCdZDjJepuJ9IQjGGUmuXJdBFUygxVqVsxFsLMbDe8ZbDYVCGKxs+W080max1hFCarCfV+C1KATwcnvE9gRRuMP2prdbWGowm1KB1y+zwMMENkM755cJ2yPDtqhTI6ED1M/82yIDtC/4j4BijjeObflpO9I9MwXTCsSX8jWAFeHr05WoLTJ5G8IQVS/7vwR6ohirYM7f6HzYpogfS3R2OAAAAAElFTkSuQmCC);width:36px;height:36px}.leaflet-retina .leaflet-control-layers-toggle{background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADQAAAA0CAQAAABvcdNgAAAEsklEQVR4AWL4TydIhpZK1kpWOlg0w3ZXP6D2soBtG42jeI6ZmQTHzAxiTbSJsYLjO9HhP+WOmcuhciVnmHVQcJnp7DFvScowZorad/+V/fVzMdMT2g9Cv9guXGv/7pYOrXh2U+RRR3dSd9JRx6bIFc/ekqHI29JC6pJ5ZEh1yWkhkbcFeSjxgx3L2m1cb1C7bceyxA+CNjT/Ifff+/kDk2u/w/33/IeCMOSaWZ4glosqT3DNnNZQ7Cs58/3Ce5HL78iZH/vKVIaYlqzfdLu8Vi7dnvUbEza5Idt36tquZFldl6N5Z/POLof0XLK61mZCmJSWjVF9tEjUluu74IUXvgttuVIHE7YxSkaYhJZam7yiM9Pv82JYfl9nptxZaxMJE4YSPty+vF0+Y2up9d3wwijfjZbabqm/3bZ9ecKHsiGmRflnn1MW4pjHf9oLufyn2z3y1D6n8g8TZhxyzipLNPnAUpsOiuWimg52psrTZYnOWYNDTMuWBWa0tJb4rgq1UvmutpaYEbZlwU3CLJm/ayYjHW5/h7xWLn9Hh1vepDkyf7dE7MtT5LR4e7yYpHrkhOUpEfssBLq2pPhAqoSWKUkk7EDqkmK6RrCEzqDjhNDWNE+XSMvkJRDWlZTmCW0l0PHQGRZY5t1L83kT0Y3l2SItk5JAWHl2dCOBm+fPu3fo5/3v61RMCO9Jx2EEYYhb0rmNQMX/vm7gqOEJLcXTGw3CAuRNeyaPWwjR8PRqKQ1PDA/dpv+on9Shox52WFnx0KY8onHayrJzm87i5h9xGw/tfkev0jGsQizqezUKjk12hBMKJ4kbCqGPVNXudyyrShovGw5CgxsRICxF6aRmSjlBnHRzg7Gx8fKqEubI2rahQYdR1YgDIRQO7JvQyD52hoIQx0mxa0ODtW2Iozn1le2iIRdzwWewedyZzewidueOGqlsn1MvcnQpuVwLGG3/IR1hIKxCjelIDZ8ldqWz25jWAsnldEnK0Zxro19TGVb2ffIZEsIO89EIEDvKMPrzmBOQcKQ+rroye6NgRRxqR4U8EAkz0CL6uSGOm6KQCdWjvjRiSP1BPalCRS5iQYiEIvxuBMJEWgzSoHADcVMuN7IuqqTeyUPq22qFimFtxDyBBJEwNyt6TM88blFHao/6tWWhuuOM4SAK4EI4QmFHA+SEyWlp4EQoJ13cYGzMu7yszEIBOm2rVmHUNqwAIQabISNMRstmdhNWcFLsSm+0tjJH1MdRxO5Nx0WDMhCtgD6OKgZeljJqJKc9po8juskR9XN0Y1lZ3mWjLR9JCO1jRDMd0fpYC2VnvjBSEFg7wBENc0R9HFlb0xvF1+TBEpF68d+DHR6IOWVv2BECtxo46hOFUBd/APU57WIoEwJhIi2CdpyZX0m93BZicktMj1AS9dClteUFAUNUIEygRZCtik5zSxI9MubTBH1GOiHsiLJ3OCoSZkILa9PxiN0EbvhsAo8tdAf9Seepd36lGWHmtNANTv5Jd0z4QYyeo/UEJqxKRpg5LZx6btLPsOaEmdMyxYdlc8LMaJnikDlhclqmPiQnTEpLUIZEwkRagjYkEibQErwhkTAKCLQEbUgkzJQWc/0PstHHcfEdQ+UAAAAASUVORK5CYII=);background-size:26px 26px}.leaflet-touch .leaflet-control-layers-toggle{width:44px;height:44px}.leaflet-control-layers .leaflet-control-layers-list,.leaflet-control-layers-expanded .leaflet-control-layers-toggle{display:none}.leaflet-control-layers-expanded .leaflet-control-layers-list{display:block;position:relative}.leaflet-control-layers-expanded{padding:6px 10px 6px 6px;color:#333;background:#fff}.leaflet-control-layers-scrollbar{overflow-y:scroll;overflow-x:hidden;padding-right:5px}.leaflet-control-layers-selector{margin-top:2px;position:relative;top:1px}.leaflet-control-layers label{display:block;font-size:13px;font-size:1.08333em}.leaflet-control-layers-separator{height:0;border-top:1px solid #ddd;margin:5px -10px 5px -6px}.leaflet-default-icon-path{background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABkAAAApCAYAAADAk4LOAAAFgUlEQVR4Aa1XA5BjWRTN2oW17d3YaZtr2962HUzbDNpjszW24mRt28p47v7zq/bXZtrp/lWnXr337j3nPCe85NcypgSFdugCpW5YoDAMRaIMqRi6aKq5E3YqDQO3qAwjVWrD8Ncq/RBpykd8oZUb/kaJutow8r1aP9II0WmLKLIsJyv1w/kqw9Ch2MYdB++12Onxee/QMwvf4/Dk/Lfp/i4nxTXtOoQ4pW5Aj7wpici1A9erdAN2OH64x8OSP9j3Ft3b7aWkTg/Fm91siTra0f9on5sQr9INejH6CUUUpavjFNq1B+Oadhxmnfa8RfEmN8VNAsQhPqF55xHkMzz3jSmChWU6f7/XZKNH+9+hBLOHYozuKQPxyMPUKkrX/K0uWnfFaJGS1QPRtZsOPtr3NsW0uyh6NNCOkU3Yz+bXbT3I8G3xE5EXLXtCXbbqwCO9zPQYPRTZ5vIDXD7U+w7rFDEoUUf7ibHIR4y6bLVPXrz8JVZEql13trxwue/uDivd3fkWRbS6/IA2bID4uk0UpF1N8qLlbBlXs4Ee7HLTfV1j54APvODnSfOWBqtKVvjgLKzF5YdEk5ewRkGlK0i33Eofffc7HT56jD7/6U+qH3Cx7SBLNntH5YIPvODnyfIXZYRVDPqgHtLs5ABHD3YzLuespb7t79FY34DjMwrVrcTuwlT55YMPvOBnRrJ4VXTdNnYug5ucHLBjEpt30701A3Ts+HEa73u6dT3FNWwflY86eMHPk+Yu+i6pzUpRrW7SNDg5JHR4KapmM5Wv2E8Tfcb1HoqqHMHU+uWDD7zg54mz5/2BSnizi9T1Dg4QQXLToGNCkb6tb1NU+QAlGr1++eADrzhn/u8Q2YZhQVlZ5+CAOtqfbhmaUCS1ezNFVm2imDbPmPng5wmz+gwh+oHDce0eUtQ6OGDIyR0uUhUsoO3vfDmmgOezH0mZN59x7MBi++WDL1g/eEiU3avlidO671bkLfwbw5XV2P8Pzo0ydy4t2/0eu33xYSOMOD8hTf4CrBtGMSoXfPLchX+J0ruSePw3LZeK0juPJbYzrhkH0io7B3k164hiGvawhOKMLkrQLyVpZg8rHFW7E2uHOL888IBPlNZ1FPzstSJM694fWr6RwpvcJK60+0HCILTBzZLFNdtAzJaohze60T8qBzyh5ZuOg5e7uwQppofEmf2++DYvmySqGBuKaicF1blQjhuHdvCIMvp8whTTfZzI7RldpwtSzL+F1+wkdZ2TBOW2gIF88PBTzD/gpeREAMEbxnJcaJHNHrpzji0gQCS6hdkEeYt9DF/2qPcEC8RM28Hwmr3sdNyht00byAut2k3gufWNtgtOEOFGUwcXWNDbdNbpgBGxEvKkOQsxivJx33iow0Vw5S6SVTrpVq11ysA2Rp7gTfPfktc6zhtXBBC+adRLshf6sG2RfHPZ5EAc4sVZ83yCN00Fk/4kggu40ZTvIEm5g24qtU4KjBrx/BTTH8ifVASAG7gKrnWxJDcU7x8X6Ecczhm3o6YicvsLXWfh3Ch1W0k8x0nXF+0fFxgt4phz8QvypiwCCFKMqXCnqXExjq10beH+UUA7+nG6mdG/Pu0f3LgFcGrl2s0kNNjpmoJ9o4B29CMO8dMT4Q5ox8uitF6fqsrJOr8qnwNbRzv6hSnG5wP+64C7h9lp30hKNtKdWjtdkbuPA19nJ7Tz3zR/ibgARbhb4AlhavcBebmTHcFl2fvYEnW0ox9xMxKBS8btJ+KiEbq9zA4RthQXDhPa0T9TEe69gWupwc6uBUphquXgf+/FrIjweHQS4/pduMe5ERUMHUd9xv8ZR98CxkS4F2n3EUrUZ10EYNw7BWm9x1GiPssi3GgiGRDKWRYZfXlON+dfNbM+GgIwYdwAAAAASUVORK5CYII=)}.leaflet-container .leaflet-control-attribution{background:#fff;background:#fffc;margin:0}.leaflet-control-attribution,.leaflet-control-scale-line{padding:0 5px;color:#333;line-height:1.4}.leaflet-control-attribution a{text-decoration:none}.leaflet-control-attribution a:hover,.leaflet-control-attribution a:focus{text-decoration:underline}.leaflet-attribution-flag{display:inline!important;vertical-align:baseline!important;width:1em;height:.6669em}.leaflet-left .leaflet-control-scale{margin-left:5px}.leaflet-bottom .leaflet-control-scale{margin-bottom:5px}.leaflet-control-scale-line{border:2px solid #777;border-top:none;line-height:1.1;padding:2px 5px 1px;white-space:nowrap;-moz-box-sizing:border-box;box-sizing:border-box;background:#fffc;text-shadow:1px 1px #fff}.leaflet-control-scale-line:not(:first-child){border-top:2px solid #777;border-bottom:none;margin-top:-2px}.leaflet-control-scale-line:not(:first-child):not(:last-child){border-bottom:2px solid #777}.leaflet-touch .leaflet-control-attribution,.leaflet-touch .leaflet-control-layers,.leaflet-touch .leaflet-bar{box-shadow:none}.leaflet-touch .leaflet-control-layers,.leaflet-touch .leaflet-bar{border:2px solid rgba(0,0,0,.2);background-clip:padding-box}.leaflet-popup{position:absolute;text-align:center;margin-bottom:20px}.leaflet-popup-content-wrapper{padding:1px;text-align:left;border-radius:12px}.leaflet-popup-content{margin:13px 24px 13px 20px;line-height:1.3;font-size:13px;font-size:1.08333em;min-height:1px}.leaflet-popup-content p{margin:1.3em 0}.leaflet-popup-tip-container{width:40px;height:20px;position:absolute;left:50%;margin-top:-1px;margin-left:-20px;overflow:hidden;pointer-events:none}.leaflet-popup-tip{width:17px;height:17px;padding:1px;margin:-10px auto 0;pointer-events:auto;-webkit-transform:rotate(45deg);-moz-transform:rotate(45deg);-ms-transform:rotate(45deg);transform:rotate(45deg)}.leaflet-popup-content-wrapper,.leaflet-popup-tip{background:#fff;color:#333;box-shadow:0 3px 14px #0006}.leaflet-container a.leaflet-popup-close-button{position:absolute;top:0;right:0;border:none;text-align:center;width:24px;height:24px;font:16px/24px Tahoma,Verdana,sans-serif;color:#757575;text-decoration:none;background:transparent}.leaflet-container a.leaflet-popup-close-button:hover,.leaflet-container a.leaflet-popup-close-button:focus{color:#585858}.leaflet-popup-scrolled{overflow:auto}.leaflet-oldie .leaflet-popup-content-wrapper{-ms-zoom:1}.leaflet-oldie .leaflet-popup-tip{width:24px;margin:0 auto;-ms-filter:"progid:DXImageTransform.Microsoft.Matrix(M11=0.70710678, M12=0.70710678, M21=-0.70710678, M22=0.70710678)";filter:progid:DXImageTransform.Microsoft.Matrix(M11=.70710678,M12=.70710678,M21=-.70710678,M22=.70710678)}.leaflet-oldie .leaflet-control-zoom,.leaflet-oldie .leaflet-control-layers,.leaflet-oldie .leaflet-popup-content-wrapper,.leaflet-oldie .leaflet-popup-tip{border:1px solid #999}.leaflet-div-icon{background:#fff;border:1px solid #666}.leaflet-tooltip{position:absolute;padding:6px;background-color:#fff;border:1px solid #fff;border-radius:3px;color:#222;white-space:nowrap;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;pointer-events:none;box-shadow:0 1px 3px #0006}.leaflet-tooltip.leaflet-interactive{cursor:pointer;pointer-events:auto}.leaflet-tooltip-top:before,.leaflet-tooltip-bottom:before,.leaflet-tooltip-left:before,.leaflet-tooltip-right:before{position:absolute;pointer-events:none;border:6px solid transparent;background:transparent;content:""}.leaflet-tooltip-bottom{margin-top:6px}.leaflet-tooltip-top{margin-top:-6px}.leaflet-tooltip-bottom:before,.leaflet-tooltip-top:before{left:50%;margin-left:-6px}.leaflet-tooltip-top:before{bottom:0;margin-bottom:-12px;border-top-color:#fff}.leaflet-tooltip-bottom:before{top:0;margin-top:-12px;margin-left:-6px;border-bottom-color:#fff}.leaflet-tooltip-left{margin-left:-6px}.leaflet-tooltip-right{margin-left:6px}.leaflet-tooltip-left:before,.leaflet-tooltip-right:before{top:50%;margin-top:-6px}.leaflet-tooltip-left:before{right:0;margin-right:-12px;border-left-color:#fff}.leaflet-tooltip-right:before{left:0;margin-left:-12px;border-right-color:#fff}@media print{.leaflet-control{-webkit-print-color-adjust:exact;print-color-adjust:exact}}:root{--ink: #10161c;--ink-2: #182028;--ink-3: #222c36;--parchment: #f4efe4;--muted: #b7aea0;--line: rgba(244, 239, 228, .12);--teal: #3cb8c4;--copper: #e09a45;--moss: #7cb07c;--danger: #c45c5c;--radius: 14px;--font: "Source Sans 3", "Segoe UI", sans-serif;--display: "Fraunces", Georgia, serif}*{box-sizing:border-box}html,body,#root{height:100%;height:100dvh;margin:0;overflow:hidden}body{background:var(--ink);color:var(--parchment);font-family:var(--font);font-size:15px;-webkit-tap-highlight-color:transparent;touch-action:manipulation}button,input,select,textarea{font:inherit;color:inherit}button{cursor:pointer}button,a,input,select,label{touch-action:manipulation}.app{height:100%;display:grid;grid-template-rows:auto auto 1fr;background:radial-gradient(1200px 600px at 10% -10%,rgba(60,184,196,.08),transparent 50%),radial-gradient(900px 500px at 110% 0%,rgba(224,154,69,.07),transparent 46%),var(--ink)}.topbar{display:flex;gap:12px;align-items:center;padding:12px 16px 8px;border-bottom:1px solid var(--line)}.brand{display:flex;flex-direction:column;min-width:180px}.brand strong{font-family:var(--display);font-size:22px;letter-spacing:-.02em;font-weight:700}.brand span{color:var(--muted);font-size:12px}.search-wrap{position:relative;flex:1;min-width:0}.search-wrap input{width:100%;background:var(--ink-2);border:1px solid var(--line);border-radius:999px;padding:10px 16px 10px 40px;outline:none}.search-wrap input:focus{border-color:var(--teal)}.search-icon{position:absolute;left:14px;top:50%;transform:translateY(-50%);color:var(--muted)}.suggest{position:absolute;z-index:20;left:0;right:0;top:calc(100% + 6px);background:var(--ink-2);border:1px solid var(--line);border-radius:var(--radius);max-height:360px;overflow:auto;box-shadow:0 18px 40px #00000059}.suggest button{display:flex;width:100%;text-align:left;background:none;border:0;padding:10px 14px;gap:10px;align-items:baseline}.suggest button:hover,.suggest button.active{background:var(--ink-3)}.suggest .term{font-family:var(--display);font-size:17px}.suggest .alias-from{opacity:.72}.suggest .alias-arrow{opacity:.45;font-family:var(--sans);font-size:13px}.suggest .meta{color:var(--muted);font-size:12px;margin-left:auto}.toolbar{display:flex;gap:8px;align-items:center;padding:8px 16px;flex-wrap:wrap;border-bottom:1px solid var(--line)}.seg{display:flex;background:var(--ink-2);border-radius:999px;padding:3px;border:1px solid var(--line)}.seg button,.chip,.ghost{background:transparent;border:0;color:var(--muted);padding:6px 12px;border-radius:999px}.seg button.on,.chip{background:var(--ink-3);color:var(--parchment)}.chip{border:1px solid var(--line);display:inline-flex;gap:6px;align-items:center;font-size:12px}.chip b{color:var(--teal);font-weight:600}.ghost{border:1px solid var(--line)}.ghost.primary{background:var(--teal);color:var(--ink);border-color:transparent;font-weight:600}.workspace{display:grid;grid-template-columns:320px 1fr 320px;min-height:0;position:relative;overflow:hidden}.panel{background:#182028b8;border-right:1px solid var(--line);overflow:auto;padding:14px;-webkit-overflow-scrolling:touch}.panel.right{border-right:0;border-left:1px solid var(--line)}.stage{position:relative;min-width:0;min-height:0;overflow:hidden;overscroll-behavior:none}.stage canvas,.stage .map,.stage .table-wrap,.stage .stats,.stage .game{position:absolute;inset:0;width:100%;height:100%}.viz-canvas{touch-action:none;display:block;cursor:grab;-webkit-user-select:none;user-select:none}.sheet-grab,.sheet-backdrop{display:none}.tabs{display:flex;gap:6px;margin-bottom:12px}.tabs button{flex:1;background:var(--ink-2);border:1px solid var(--line);border-radius:10px;padding:7px;color:var(--muted)}.tabs button.on{color:var(--parchment);border-color:var(--teal)}label.field{display:block;font-size:12px;color:var(--muted);margin:10px 0 4px}.row{display:flex;gap:8px;align-items:center}select,.field-input{width:100%;background:var(--ink);border:1px solid var(--line);border-radius:10px;padding:8px 10px}.checklist{max-height:140px;overflow:auto;border:1px solid var(--line);border-radius:10px;background:var(--ink)}.checklist label{display:flex;gap:8px;padding:5px 8px;font-size:13px;color:var(--parchment)}.rel-grid{display:grid;grid-template-columns:1fr 1fr;gap:4px}.rel-grid label{display:flex;gap:6px;font-size:13px;align-items:center}.dot{width:8px;height:8px;border-radius:50%;display:inline-block}.legend{position:absolute;left:12px;bottom:12px;background:#10161cd1;border:1px solid var(--line);border-radius:12px;padding:8px 10px;font-size:12px;display:flex;flex-wrap:wrap;gap:8px 12px;max-width:min(520px,calc(100% - 24px))}.status-line{position:absolute;right:12px;bottom:12px;color:var(--muted);font-size:12px;background:#10161cb8;padding:6px 10px;border-radius:999px}.table-wrap{overflow:auto;padding:8px 12px 48px}table{width:100%;border-collapse:collapse;font-size:13px}th,td{text-align:left;padding:8px;border-bottom:1px solid var(--line)}th{color:var(--muted);font-weight:600;position:sticky;top:0;background:var(--ink)}tr:hover td{background:var(--ink-3);cursor:pointer}.stats{overflow:auto;padding:18px}.bars{display:grid;gap:6px}.bar-row{display:grid;grid-template-columns:140px 1fr 40px;gap:8px;align-items:center;font-size:13px}.bar{height:8px;background:var(--ink-3);border-radius:99px;overflow:hidden}.bar>i{display:block;height:100%;background:var(--teal)}.inspector h2{font-family:var(--display);margin:0 0 4px;font-size:28px}.inspector-def{margin:12px 0 4px}.inspector-def h3{margin:0 0 6px;font-size:12px;letter-spacing:.04em;text-transform:uppercase;color:var(--muted);font-weight:600}.kv{display:grid;grid-template-columns:110px 1fr;gap:4px 8px;font-size:13px;margin:12px 0}.kv dt{color:var(--muted)}.path-list{display:flex;flex-direction:column;gap:6px}.path-list button{background:var(--ink);border:1px solid var(--line);border-radius:10px;padding:8px;text-align:left}.formation-list{display:flex;flex-direction:column;gap:10px;margin:0 0 12px}.formation-meta{font-size:12px;letter-spacing:.04em;text-transform:uppercase;color:var(--muted);margin-bottom:4px}.formation-parts{display:flex;flex-wrap:wrap;align-items:baseline;gap:2px 0}.formation-plus{color:var(--muted);padding:0 4px}.formation-part{background:transparent;border:0;border-bottom:1px solid color-mix(in srgb,var(--teal) 55%,transparent);border-radius:0;padding:2px 2px 1px;text-align:left;font-family:var(--display);font-size:18px;line-height:1.2}.formation-part small{display:block;font-family:var(--font);font-size:11px;color:var(--muted);font-weight:500}.formation-part:hover{color:var(--teal)}.cognate-list{display:flex;flex-direction:column;gap:12px;margin:0 0 12px}.cognate-set{display:flex;flex-direction:column;gap:6px}.cognate-meta{font-size:12px;color:var(--muted);letter-spacing:.02em}.cognate-words{display:flex;flex-wrap:wrap;gap:6px;align-items:center}.cognate-word{display:inline-flex;flex-direction:column;align-items:flex-start;gap:1px;padding:4px 8px;border:1px solid color-mix(in srgb,#c56b9b 45%,transparent);background:color-mix(in srgb,#c56b9b 12%,transparent);color:var(--text);font:inherit;font-size:13px;line-height:1.2;cursor:pointer;text-align:left}.cognate-word.static{cursor:default;opacity:.85;border-color:color-mix(in srgb,var(--muted) 35%,transparent);background:transparent}.cognate-word.on,.cognate-word:hover{border-color:#c56b9b;color:#f4efe4}.cognate-word small{font-size:10px;color:var(--muted);max-width:140px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.cognate-more{font-size:12px;color:var(--muted)}.sheet{display:none}.examples{display:grid;grid-template-columns:repeat(auto-fill,minmax(180px,1fr));gap:8px;padding:16px}.examples button{background:var(--ink-2);border:1px solid var(--line);border-radius:12px;padding:12px;text-align:left}.examples .t{font-family:var(--display);font-size:18px;display:block}.examples .b{color:var(--muted);font-size:12px}.qr img{width:180px;height:180px;background:#fff;padding:8px;border-radius:8px}.modal-root{position:fixed;inset:0;z-index:80;display:grid;place-items:center;padding:16px}.modal-backdrop{position:absolute;inset:0;border:0;padding:0;background:#060a0e9e;cursor:pointer}.modal-dialog{position:relative;z-index:1;width:min(560px,100%);max-height:min(86dvh,820px);display:flex;flex-direction:column;background:radial-gradient(700px 240px at 0% 0%,rgba(60,184,196,.12),transparent 55%),var(--ink-2);border:1px solid var(--line);border-radius:18px;box-shadow:0 24px 60px #00000073;overflow:hidden}.modal-head{display:flex;justify-content:space-between;gap:12px;align-items:flex-start;padding:16px 16px 10px;border-bottom:1px solid var(--line)}.modal-head h2{font-family:var(--display);margin:0;font-size:28px;line-height:1.1}.modal-head p{margin:4px 0 0;color:var(--muted);font-size:13px}.modal-body{overflow:auto;-webkit-overflow-scrolling:touch;padding:8px 16px 16px;flex:1;min-height:0}.modal-body section{margin-top:14px}.modal-body h3{margin:0 0 6px;font-size:12px;letter-spacing:.04em;text-transform:uppercase;color:var(--muted);font-weight:600}.modal-muted{color:var(--muted);font-size:13px;margin:0}.modal-muted a{color:var(--teal)}.modal-senses{display:grid;gap:10px}.modal-pos{font-size:12px;color:var(--copper);font-style:italic;margin-bottom:2px}.modal-sense ol{margin:0;padding-left:18px;display:grid;gap:4px}.modal-sense li{font-size:14px;line-height:1.35}.modal-chips{display:flex;flex-wrap:wrap;gap:6px;margin:8px 0 0}.modal-foot{display:flex;flex-wrap:wrap;gap:8px;padding:12px 16px 16px;border-top:1px solid var(--line)}.modal-foot .ghost,.modal-foot a.ghost{text-decoration:none;display:inline-flex;align-items:center;min-height:40px}@media(max-width:840px){.workspace{grid-template-columns:1fr}.panel{display:none}.sheet-backdrop{display:block;position:absolute;inset:0;z-index:25;border:0;background:#00000073;padding:0}.panel.open-sheet{display:flex;flex-direction:column;position:absolute;left:0;right:0;bottom:0;z-index:30;height:min(78dvh,640px);max-height:calc(100% - 12px);border-right:0;border-left:0;border-top:1px solid var(--line);border-radius:18px 18px 0 0;background:var(--ink-2);padding:0 14px 18px;overflow:hidden;box-shadow:0 -12px 40px #00000059}.sheet-body{overflow:auto;-webkit-overflow-scrolling:touch;flex:1;min-height:0}.sheet-grab{display:grid;grid-template-columns:64px 1fr auto;align-items:center;gap:8px;padding:10px 0 8px;position:sticky;top:0;background:var(--ink-2);z-index:1}.sheet-grab>span{width:42px;height:4px;border-radius:99px;background:#f4efe447;justify-self:start;margin-left:10px}.sheet-grab strong{font-size:14px;font-weight:600}.sheet-close{padding:8px 12px;min-height:40px}.brand{min-width:0}.brand span{display:none}.brand strong{font-size:18px}.topbar{padding:10px;gap:8px}.toolbar{padding:8px 10px;gap:6px;flex-wrap:nowrap;overflow-x:auto;-webkit-overflow-scrolling:touch;scrollbar-width:none}.toolbar::-webkit-scrollbar{display:none}.seg{flex:0 0 auto}.seg button{padding:8px 10px;min-height:36px}.filters-btn{flex:0 0 auto;min-height:40px}.legend{display:none}.status-line{left:12px;right:12px;bottom:10px;text-align:center}.search-wrap input{padding:12px 16px 12px 40px;font-size:16px}.suggest{max-height:min(50dvh,320px)}.suggest button{padding:12px 14px;min-height:44px}.checklist{max-height:180px}.checklist label{padding:10px 8px;min-height:40px}}.game{overflow:auto;padding:28px 28px 48px;background:radial-gradient(900px 420px at 20% 0%,rgba(60,184,196,.1),transparent 55%),radial-gradient(700px 380px at 90% 10%,rgba(224,154,69,.08),transparent 50%),var(--ink)}.game-hero{max-width:720px;margin-bottom:22px}.game-kicker{margin:0 0 6px;color:var(--teal);font-size:12px;letter-spacing:.08em;text-transform:uppercase}.game-hero h2{font-family:var(--display);font-size:clamp(28px,4vw,40px);margin:0 0 8px;letter-spacing:-.02em}.game-hero p{color:var(--muted);margin:0 0 14px;max-width:54ch}.game-scoreline{display:flex;flex-wrap:wrap;gap:14px;align-items:center;color:var(--muted)}.game-scoreline b{color:var(--parchment)}.game-status{color:var(--muted)}.game-status.err{color:var(--danger)}.game-pair{display:grid;grid-template-columns:1fr auto 1fr;gap:16px;align-items:stretch;max-width:860px;margin-bottom:18px}.game-word{background:var(--ink-2);border:1px solid var(--line);border-radius:var(--radius);padding:18px 20px;display:flex;flex-direction:column;gap:6px}.game-lang{color:var(--teal);font-size:12px;text-transform:uppercase;letter-spacing:.06em}.game-word strong{font-family:var(--display);font-size:28px;letter-spacing:-.02em}.game-word em{font-style:normal;color:var(--muted);font-size:14px;line-height:1.35}.game-link{width:36px;display:flex;align-items:center;justify-content:center}.game-link span{display:block;width:100%;height:2px;background:linear-gradient(90deg,var(--teal),var(--copper));border-radius:2px}.game-panel{max-width:860px;background:var(--ink-2);border:1px solid var(--line);border-radius:var(--radius);padding:18px 20px 20px;margin-bottom:16px}.game-panel h3{font-family:var(--display);margin:0 0 6px;font-size:20px}.game-choices,.game-pool,.game-actions{display:flex;flex-wrap:wrap;gap:8px;margin-top:12px}.game-choices button,.game-pool button{background:var(--ink-3);border:1px solid var(--line);border-radius:999px;padding:8px 14px}.game-choices button.on,.game-pool button:hover,.game-choices button:hover{border-color:var(--teal);color:var(--teal)}.game-actions{margin-top:16px}.game-actions .primary{background:var(--teal);color:var(--ink);border:none;border-radius:999px;padding:10px 16px;font-weight:600}.game-actions .primary:disabled{opacity:.4}.game-actions .ghost,.game-scoreline .ghost{background:transparent;border:1px solid var(--line);border-radius:999px;padding:8px 14px;color:var(--muted)}.game-chain{display:flex;flex-wrap:wrap;gap:8px;align-items:center;margin-top:14px}.game-anchor{font-family:var(--display);font-size:18px}.game-slot{min-width:88px;min-height:40px;border:1px dashed rgba(244,239,228,.28);background:#0000002e;border-radius:10px;color:var(--muted)}.game-slot.filled{border-style:solid;border-color:var(--copper);color:var(--parchment);background:var(--ink-3)}.game-paths{display:grid;grid-template-columns:1fr 1fr;gap:18px;margin-top:12px}.game-paths ol{margin:0;padding-left:18px}.game-paths li{margin-bottom:8px;display:flex;flex-direction:column;gap:2px}.game-paths span{color:var(--muted);font-size:13px}.game-lca{margin-top:14px;color:var(--muted)}.game-lca b{color:var(--copper)}.game-result{color:var(--teal);margin:0 0 8px}.game-custom{display:grid;grid-template-columns:1fr 1fr auto;gap:10px;align-items:start;margin-top:10px}.game-custom input{width:100%;background:var(--ink-3);border:1px solid var(--line);border-radius:10px;padding:10px 12px}.game-mini-suggest{display:flex;flex-direction:column;gap:4px;margin-top:6px}.game-mini-suggest button{text-align:left;background:var(--ink-3);border:1px solid var(--line);border-radius:8px;padding:6px 10px;font-size:13px}@media(max-width:840px){.game{padding:16px 14px 40px}.game-pair{grid-template-columns:1fr}.game-link{display:none}.game-paths,.game-custom{grid-template-columns:1fr}}

frontend/dist/index.html

@@ -9,8 +9,8 @@
     <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-BkbsJgPA.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-CL00p6UV.css">
+    <script type="module" crossorigin src="/assets/index-CSxQdCV8.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-Dr1iPrLq.css">
   </head>
   <body>
     <div id="root"></div>