Genome Atlas: expanding Sankey view with annotated / not-annotated bars

Reworks the Genome Atlas tree into an expanding Sankey diagram.

**Sankey bars.** Each group is a bar split into annotated (green) and not-annotated (gray) assemblies. Two-tone flows carry both parts from a parent into its lineages. Bar and flow heights follow assembly counts within a column, and each column is rescaled to the full height so deep lineages stay legible.

**Expands to the right.** Clicking a group adds its lineages as a new column instead of re-rooting the view, so every ancestor stays visible. Clicking a group in an earlier column replaces the columns after it. The selection is encoded as a path (`2759/33154/33208`, with `~offset` for expanded "Other lineages"), validated server-side, so the view stays stateless. Search and the shortcuts open the full lineage of a taxon. A selected lineage outside a column's top six is pinned into that column. The view auto-scrolls to the newest column.

Other details:
- Event payload key is `route`, because Gradio treats a `path` field as a file reference.
- "← Parent group" is now "← Collapse last group"; breadcrumbs collapse to any ancestor.
- Added `tests/test_taxonomy.py`: column expansion, lineage paths, aggregate expansion, invalid-path rejection. The full suite passes (19 tests).
- Updated the README and FEATURE_BACKLOG descriptions.

Tested locally in sample mode with Gradio 6.6.0.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

FEATURE_BACKLOG.md

@@ -40,7 +40,7 @@ Decisions and dependencies for implementation:
 
 ## F002 — Taxonomy map and navigation
 
-Current implementation: an illustrated SVG taxonomy tree leads the page, above annotation lookup. It supports click/keyboard branch expansion, breadcrumbs, parent navigation, shortcuts, and scientific-name/taxon-ID search. Every route is restricted to Eukaryota. Coverage colors, counts, and percentages use a separate SQLite snapshot; see [refresh instructions](README.md#refresh-annotation-coverage). Linking taxa to annotation accessions remains future work.
+Current implementation: a server-rendered SVG Sankey of the taxonomy leads the page, above annotation lookup. It supports click/keyboard expansion into columns that keep every ancestor visible, breadcrumbs, parent navigation, shortcuts, and scientific-name/taxon-ID search. Every route is restricted to Eukaryota. Coverage colors, counts, and percentages use a separate SQLite snapshot; see [refresh instructions](README.md#refresh-annotation-coverage). Linking taxa to annotation accessions remains future work.
 
 **Goal:** Provide a taxonomy-based view of the available genomes and annotations.
 

README.md

@@ -17,13 +17,13 @@ Future features and open design decisions are tracked in the [feature backlog](F
 
 ## GenBank taxonomy
 
-The landing page opens with an interactive **tree of eukaryotic life**, using NCBI's current GenBank assembly summary and taxonomy. Curved branches and nodes are colored by the fraction of assemblies with published annotations: gray for none found in the inventory, increasingly dark teal for higher percentages. Counts and percentages appear beside the groups, with details on hover. The default **Genome atlas** tab contains the tree and its lineage controls. A separate **Database** tab holds accession search, segment visualization, and downloads, using the full published-file snapshot. A third **Wet Lab Experiments** tab is ready for experimental results and currently shows a clearly labeled coming-soon state. RefSeq exploration can be added beneath the tree. The three equal-width navigation options span the top of the page.
+The landing page opens with an interactive **tree of eukaryotic life**, using NCBI's current GenBank assembly summary and taxonomy. It is drawn as a Sankey diagram: each group is a bar split into annotated (green) and not-annotated (gray) assemblies, and flows carry both parts from a group into its lineages. Counts and percentages appear beside the groups, with details on hover. The default **Genome atlas** tab contains the tree and its lineage controls. A separate **Database** tab holds accession search, segment visualization, and downloads, using the full published-file snapshot. A third **Wet Lab Experiments** tab is ready for experimental results and currently shows a clearly labeled coming-soon state. RefSeq exploration can be added beneath the tree. The three equal-width navigation options span the top of the page.
 
 The viewer is restricted to **Eukaryota (NCBI taxid 2759) and its descendants**, including search, breadcrumbs, and parent navigation. The model predicts eukaryotic annotations; bacteria, archaea, and viruses are outside this display. The current eukaryotic snapshot contains **70,395 assemblies**, of which **17,561 (24.9%)** have published annotations. The underlying SQLite snapshot retains the full NCBI inventory for refresh/provenance, while the interface uses only the eukaryotic subtree and its denominators. Assemblies with unresolved taxonomy cannot be assigned to that subtree and are excluded.
 
 The inventory accepts `GCA_` accessions with `version_status=latest`. Each assembly contributes once to its taxon and each ancestor. These counts describe genome assemblies, not all GenBank nucleotide records. An assembly counts as having annotations when it occurs in the publication inventory; this includes partial assemblies and does not imply full base coverage. Exact accession versions are matched to the NCBI snapshot. Published versions outside that snapshot are excluded from percentages.
 
-Click a group to unfold its direct lineages, and use breadcrumbs, parent navigation, or shortcuts to return. Nodes support Enter/Space keyboard navigation. The opening view expands the actual animal/fungal ancestor, Opisthokonta, alongside green plants, SAR, and the remaining eukaryotic lineages. Other views show six direct lineages and an expandable remainder. “Other lineages” is an explicitly labeled display aggregate, not an invented clade; its counts sum the remaining siblings. Repeated expansion reaches all siblings without truncating them. Scientific-name/taxon-ID search also reaches individual taxa. Branch lengths, spacing, and widths are illustrative and do not encode time or abundance. Mobile users can scroll the tree horizontally.
+Click a group to expand its direct lineages into a new column on the right; every ancestor column stays visible, so the full path from Eukaryota is always on screen. Clicking a group in an earlier column replaces the columns after it. Use breadcrumbs, “Collapse last group”, or shortcuts to go back. Nodes support Enter/Space keyboard navigation. The opening view expands the actual animal/fungal ancestor, Opisthokonta. Each column shows six direct lineages, an expandable remainder, and the selected lineage if it falls outside the top six. Bar and flow heights follow assembly counts within a column; every column is rescaled to the full height. “Other lineages” is an explicitly labeled display aggregate, not an invented clade; its counts sum the remaining siblings. Repeated expansion reaches all siblings without truncating them. Scientific-name/taxon-ID search also reaches individual taxa. Column spacing does not encode time. The view scrolls horizontally, and jumps to the newest column after each expansion.
 
 The graphic uses server-rendered SVG/HTML with scoped styles in `atlas.css` and delegated click/keyboard handlers in `atlas.js`; no external graphics library or image assets are required. Include these files when deploying.
 

atlas.css

@@ -22,23 +22,31 @@
 .atlas-breadcrumb button:hover { text-decoration:underline; }
 .crumb-divider { opacity:.4; }
 .tree-scroll { overflow-x:auto; overscroll-behavior-x:contain; margin:0 -5px; }
-.life-tree { display:block; width:100%; min-width:830px; height:auto; overflow:visible; }
-.tree-branch-under { fill:none; stroke:#e4e9dd; stroke-width:9; stroke-linecap:round; }
-.tree-branch { fill:none; stroke-width:4; stroke-linecap:round; }
+.life-tree { display:block; width:100%; height:auto; overflow:visible; }
+.flow { stroke:none; transition:opacity .15s; }
+.flow-annotated { fill:#40916f; opacity:.42; }
+.flow-missing { fill:#cfd5c9; opacity:.6; }
+.bar-annotated { fill:#287557; }
+.bar-missing { fill:#bcc4b5; }
+.bar-outline { fill:none; stroke:#f7f8f0; stroke-width:1; }
 .tree-node { cursor:pointer; }
+.tree-node.is-direct { cursor:default; }
 .tree-hit { fill:transparent; transition:fill .15s; }
-.tree-node:hover .tree-hit,.tree-node:focus .tree-hit { fill:#e5ecdd; }
+.tree-node:hover .tree-hit,.tree-node:focus .tree-hit { fill:#e5ecdd99; }
 .tree-node:focus { outline:none; }
-.tree-node:focus .tree-dot { stroke:#173c30; stroke-width:3; }
-.tree-dot { stroke:#f7f8f0; stroke-width:3; }
-.tree-label { font:600 17px Arial,Helvetica,sans-serif; fill:#254735; }
-.tree-internal { font-size:14px; }
-.tree-count { font:12px Arial,Helvetica,sans-serif; fill:#697966; }
-.tree-percent { font:500 20px Georgia,'Times New Roman',serif; fill:#28543d; }
+.tree-node:focus .bar-outline { stroke:#173c30; stroke-width:2; }
+.tree-node.is-selected .bar-outline { stroke:#173c30; stroke-width:1.5; }
+.tree-node.is-sibling { opacity:.62; transition:opacity .15s; }
+.tree-node.is-sibling:hover,.tree-node.is-sibling:focus { opacity:1; }
+.tree-label,.tree-count { paint-order:stroke; stroke:#f7f8f0; stroke-width:4px; stroke-linejoin:round; }
+.tree-label { font:600 13px Arial,Helvetica,sans-serif; fill:#254735; }
+.tree-node.is-selected .tree-label { font-weight:700; fill:#173c30; }
+.tree-count { font:11px Arial,Helvetica,sans-serif; fill:#697966; }
 .atlas-footer { display:flex; align-items:center; flex-wrap:wrap; gap:15px; justify-content:space-between; border-top:1px solid #dde4d5; padding-top:14px; color:#6c7a66; font-size:11px; line-height:1.6; }
 .atlas-legend { display:flex; gap:7px; align-items:center; }
-.atlas-zero { width:8px; height:8px; border-radius:50%; background:#d5d9d0; }
-.atlas-gradient { display:block; width:60px; height:7px; border-radius:10px; background:linear-gradient(90deg,#badbc8,#40916f,#0f4e3b); }
+.atlas-swatch { width:10px; height:10px; border-radius:2px; }
+.atlas-annotated { background:#287557; }
+.atlas-missing { background:#bcc4b5; }
 .atlas-date { opacity:.8; }
 .atlas-footnote { font-size:10px; line-height:1.6; color:#77816e; margin-top:12px; max-width:860px; }
 .atlas-tooltip { position:absolute; z-index:5; pointer-events:none; max-width:290px; padding:12px 15px; border-radius:12px; color:#f5f8ef; background:#1d4334; font-size:12px; line-height:1.7; box-shadow:0 5px 20px #18372122; }

atlas.js

@@ -1,12 +1,12 @@
 // Delegate to the component root so navigation still works after HTML updates.
 function activate(event) {
-  const target = event.target.closest('[data-taxid]');
+  const target = event.target.closest('[data-path]');
   if (!target || !element.contains(target)) return;
   if (event.type === 'keydown' && !['Enter', ' '].includes(event.key)) return;
   // Native buttons already synthesize a click on keyboard activation.
   if (event.type === 'keydown' && target.tagName.toLowerCase() === 'button') return;
   event.preventDefault();
-  trigger('click', {taxid: Number(target.dataset.taxid), offset: Number(target.dataset.offset || 0)});
+  trigger('click', {route: target.dataset.path});
 }
 element.addEventListener('click', activate);
 element.addEventListener('keydown', activate);
@@ -26,3 +26,12 @@ element.addEventListener('pointerleave', () => {
   const tooltip = element.querySelector('.atlas-tooltip');
   if (tooltip) tooltip.hidden = true;
 });
+// Newly expanded columns appear on the right; keep them in view after each update.
+let shownRoute = element.querySelector('.life-tree')?.dataset.route;
+new MutationObserver(() => {
+  const route = element.querySelector('.life-tree')?.dataset.route;
+  if (!route || route === shownRoute) return;
+  shownRoute = route;
+  const scroller = element.querySelector('.tree-scroll');
+  if (scroller) requestAnimationFrame(() => { scroller.scrollLeft = scroller.scrollWidth; });
+}).observe(element, {childList: true, subtree: true, attributes: true, attributeFilter: ['data-route']});

taxonomy.py

@@ -20,15 +20,14 @@ DISPLAY_NAMES = {2759: "Eukaryotes", 33208: "Animals", 33090: "Green plants",
                  2763: "Red algae", 3041: "Green algae"}
 
 
-def coverage_color(percent):
-    if percent <= 0:
-        return "#d5d9d0"
-    stops = [(0, (186, 219, 200)), (50, (64, 145, 111)), (100, (15, 78, 59))]
-    for (a, low), (b, high) in zip(stops, stops[1:]):
-        if percent <= b:
-            fraction = (percent - a) / (b - a)
-            return "#" + "".join(f"{round(x + fraction * (y - x)):02x}" for x, y in zip(low, high))
-    return "#0f4e3b"
+COLUMN_LIMIT = 6
+MAX_DEPTH = 80
+DEFAULT_PATH = "2759/33154"
+
+
+def encode_path(steps):
+    """Serialize selected (taxid, offset) pairs; an offset marks an expanded "Other lineages" aggregate."""
+    return "/".join(f"{t}~{o}" if o else str(t) for t, o in steps)
 
 
 class Taxonomy:
@@ -57,132 +56,194 @@ class Taxonomy:
                 rows = conn.execute(EUK_TREE + "SELECT taxa.* FROM taxa JOIN euk USING(taxid) WHERE name LIKE ? ESCAPE '\\' ORDER BY total_count DESC LIMIT 100", (pattern,)).fetchall()
         return [(f"{r['name']} · {r['total_count']:,} assemblies · taxid {r['taxid']}", str(r['taxid'])) for r in rows]
 
-    def view(self, taxid=EUKARYOTA, offset=0):
-        taxid, offset = int(taxid), int(offset)
-        if taxid not in self.eukaryote_ids or offset < 0:
+    def lineage(self, conn, taxid):
+        rows = [dict(conn.execute("SELECT * FROM taxa WHERE taxid=?", (taxid,)).fetchone())]
+        while rows[-1]['taxid'] != EUKARYOTA:
+            rows.append(dict(conn.execute("SELECT * FROM taxa WHERE taxid=?", (rows[-1]['parent_id'],)).fetchone()))
+        return rows[::-1]
+
+    def taxon_path(self, taxid):
+        """Path that expands every ancestor of a taxon, for search results and shortcuts."""
+        taxid = int(taxid)
+        if taxid not in self.eukaryote_ids:
+            raise ValueError("Choose a eukaryotic taxon from this snapshot.")
+        with closing(self.connect()) as conn:
+            return encode_path((r['taxid'], 0) for r in self.lineage(conn, taxid))
+
+    def view_taxon(self, taxid):
+        return self.view(self.taxon_path(taxid))
+
+    def view(self, path=DEFAULT_PATH):
+        """Render one column per expanded group. A path lists the selected node of each column."""
+        try:
+            steps = [(int(t), int(o or 0)) for t, _, o in (part.partition("~") for part in str(path).split("/"))]
+        except ValueError as exc:
+            raise ValueError("Choose a eukaryotic taxon from this snapshot.") from exc
+        if steps[0] != (EUKARYOTA, 0) or len(steps) > MAX_DEPTH or any(
+                t not in self.eukaryote_ids or o < 0 for t, o in steps):
             raise ValueError("Choose a eukaryotic taxon from this snapshot.")
         with closing(self.connect()) as conn:
-            def children(t):
-                return [dict(r) for r in conn.execute("SELECT * FROM taxa WHERE parent_id=? AND taxid!=? ORDER BY total_count DESC, taxid", (t, t))]
+            def taxon(t):
+                return dict(conn.execute("SELECT * FROM taxa WHERE taxid=?", (t,)).fetchone())
 
-            def node(row):
-                return dict(taxid=row['taxid'], offset=0, name=row['name'],
+            def node(row, offset=0, **extra):
+                return dict(taxid=row['taxid'], offset=offset, name=row['name'],
                             label=DISPLAY_NAMES.get(row['taxid'], row['name']),
-                            total=row['total_count'], covered=row.get('covered_total', 0), children=[])
+                            total=row['total_count'], covered=row.get('covered_total', 0), **extra)
 
             def remainder(rows, parent, start):
                 return dict(taxid=parent, offset=start, name=f"Other lineages · {len(rows):,} groups (display aggregate)",
                             label=f"Other lineages ({len(rows):,})", total=sum(r['total_count'] for r in rows),
-                            covered=sum(r.get('covered_total', 0) for r in rows), children=[], aggregate=True)
-
-            row = dict(conn.execute("SELECT * FROM taxa WHERE taxid=?", (taxid,)).fetchone())
-            all_children = children(taxid)
-            if offset and offset >= len(all_children):
-                raise ValueError("This group has no further lineages.")
-            root = remainder(all_children[offset:], taxid, offset) if offset else node(row)
-            if offset:
-                root['label'] = "More lineages"
-            visible = all_children[offset:]
-            overview = taxid == EUKARYOTA and offset == 0
-            limit = 3 if overview else 6
-            root['children'] = [node(r) for r in visible[:limit]]
-            if len(visible) > limit:
-                root['children'].append(remainder(visible[limit:], taxid, offset + limit))
-            if not offset and row['direct_count'] and all_children:
-                root['children'].append(dict(taxid=taxid, offset=0, name="Assemblies assigned directly to this taxon",
-                                             label="Direct assignments", total=row['direct_count'],
-                                             covered=row.get('covered_direct', 0), children=[], direct=True))
-            if overview:
-                for item in root['children']:
-                    if item['taxid'] == 33154 and not item.get('aggregate'):
-                        relatives = children(33154)
-                        item['children'] = [node(r) for r in relatives[:2]]
-                        if len(relatives) > 2:
-                            item['children'].append(remainder(relatives[2:], 33154, 2))
-            lineage = [row]
-            while lineage[-1]['taxid'] != EUKARYOTA:
-                lineage.append(dict(conn.execute("SELECT * FROM taxa WHERE taxid=?", (lineage[-1]['parent_id'],)).fetchone()))
-        parent = taxid if offset else row['parent_id'] if taxid != EUKARYOTA else EUKARYOTA
-        return self.render(root, list(reversed(lineage)), parent)
-
-    def render(self, root, lineage, parent):
-        leaves = []
-
-        def position(node, depth=0):
-            node['depth'] = depth
-            if node['children']:
-                for child in node['children']:
-                    position(child, depth + 1)
-                node['y'] = (node['children'][0]['y'] + node['children'][-1]['y']) / 2
-            else:
-                node['y'] = 64 + len(leaves) * 67
-                leaves.append(node)
-            node['x'] = 80 if depth == 0 else 335 if node['children'] else 610
-
-        position(root)
-        height = max(230, 64 + len(leaves) * 67)
-        if not root['children']:
-            root['y'] = height / 2
-        paths, nodes = [], []
-
-        def draw(node):
-            x, y = node['x'], node['y']
-            percent = 100 * node['covered'] / node['total'] if self.coverage and node['total'] else 0
-            color = coverage_color(percent) if self.coverage else "#d5d9d0"
-            for child in node['children']:
-                cx, cy = child['x'], child['y']
-                cp = 100 * child['covered'] / child['total'] if self.coverage and child['total'] else 0
-                bend = (x + cx) / 2
-                curve = f"M{x},{y} C{bend},{y} {bend},{cy} {cx},{cy}"
-                paths.append(f'<path d="{curve}" class="tree-branch-under"/><path d="{curve}" stroke="{coverage_color(cp) if self.coverage else color}" class="tree-branch"/>')
-                draw(child)
-            tip = not node['children'] and node['depth'] > 0
-            label = escape(node['label'])
-            stats = f"{node['covered']:,} / {node['total']:,}" if self.coverage else f"{node['total']:,}"
-            coverage_text = f"{percent:.1f}%" if self.coverage else "—"
-            detail = (f"{node['name']} · {node['covered']:,} of {node['total']:,} assemblies have published annotations ({percent:.2f}%). Includes partial assemblies."
-                      if self.coverage else f"{node['name']} · {node['total']:,} assemblies. Coverage inventory unavailable.")
-            action = "" if node.get('direct') else f'data-taxid="{node["taxid"]}" data-offset="{node["offset"]}" role="button" tabindex="0"'
-            if node.get('aggregate'):
-                detail += " Display aggregate, not a taxonomic clade. Activate to see its lineages."
-            elif not node.get('direct'):
-                detail += " Activate to explore this group."
-            nodes.append(f'<g class="tree-node" {action} aria-label="{escape(detail, quote=True)}" data-detail="{escape(detail, quote=True)}"><title>{escape(detail)}</title>')
-            if tip:
-                nodes.append(f'<rect x="{x-20}" y="{y-27}" width="425" height="56" rx="14" class="tree-hit"/>')
-            else:
-                nodes.append(f'<rect x="{max(0,x-78)}" y="{y-46}" width="156" height="88" rx="14" class="tree-hit"/>')
-            nodes.append(f'<circle cx="{x}" cy="{y}" r="13" fill="{color}" class="tree-dot"/><circle cx="{x}" cy="{y}" r="4" fill="#fafbf5"/>')
-            if tip:
-                label = escape(node['label'] if len(node['label']) <= 27 else node['label'][:25] + "…")
-                suffix = "annotated" if self.coverage else "assemblies"
-                nodes.append(f'<text x="{x+25}" y="{y-3}" class="tree-label">{label}</text>'
-                             f'<text x="{x+25}" y="{y+18}" class="tree-count">{stats} {suffix}</text>'
-                             f'<text x="1010" y="{y+3}" text-anchor="end" class="tree-percent">{coverage_text}</text>')
-            else:
-                label = label if len(node['label']) <= 23 else escape(node['label'][:21] + "…")
-                nodes.append(f'<text x="{x}" y="{y-27}" text-anchor="middle" class="tree-label tree-internal">{label}</text>'
-                             f'<text x="{x}" y="{y+33}" text-anchor="middle" class="tree-count">{coverage_text} annotated</text>')
-            nodes.append('</g>')
-
-        draw(root)
-        svg = (f'<svg viewBox="0 0 1040 {height}" class="life-tree" aria-label="Eukaryotic taxonomy and annotation coverage">'
-               + ''.join(paths) + ''.join(nodes) + '</svg>')
-        total, covered = root['total'], root['covered']
+                            covered=sum(r.get('covered_total', 0) for r in rows), aggregate=True)
+
+            def column(step, selected):
+                """Direct lineages of a selected node, keeping the next selection visible."""
+                parent, offset = step
+                rows = [dict(r) for r in conn.execute("SELECT * FROM taxa WHERE parent_id=? AND taxid!=? ORDER BY total_count DESC, taxid", (parent, parent))]
+                if offset and offset >= len(rows):
+                    raise ValueError("This group has no further lineages.")
+                shown, rest = rows[offset:offset + COLUMN_LIMIT], rows[offset + COLUMN_LIMIT:]
+                pinned = [r for r in rest if selected and not selected[1] and r['taxid'] == selected[0]]
+                shown, rest = shown + pinned, [r for r in rest if r not in pinned]
+                nodes = [node(r) for r in shown]
+                if rest:
+                    nodes.append(remainder(rest, parent, offset + COLUMN_LIMIT))
+                row = taxon(parent)
+                if not offset and row['direct_count'] and rows:
+                    nodes.append(dict(taxid=parent, offset=0, name="Assemblies assigned directly to this taxon",
+                                      label="Direct assignments", total=row['direct_count'],
+                                      covered=row.get('covered_direct', 0), direct=True))
+                return nodes
+
+            columns = [[node(taxon(EUKARYOTA))]]
+            for depth, step in enumerate(steps[1:], 1):
+                if step[1] and (step[0] != steps[depth - 1][0] or step[1] <= steps[depth - 1][1]) or \
+                        not step[1] and taxon(step[0])['parent_id'] != steps[depth - 1][0]:
+                    raise ValueError("Choose a eukaryotic taxon from this snapshot.")
+                columns.append(column(steps[depth - 1], step))
+            tail = column(steps[-1], None)
+            if tail:
+                columns.append(tail)
+            for depth, nodes in enumerate(columns):
+                for item in nodes:
+                    item['path'] = encode_path(steps[:depth] + [(item['taxid'], item['offset'])])
+                    item['selected'] = depth < len(steps) and not item.get('direct') and \
+                        (item['taxid'], item['offset']) == steps[depth]
+                if depth < len(steps) and not any(item['selected'] for item in nodes):
+                    raise ValueError("Choose a eukaryotic taxon from this snapshot.")
+            lineage = [taxon(t) for t, _ in steps]
+            shortcuts = {t: encode_path((r['taxid'], 0) for r in self.lineage(conn, t)) for t in (33208, 33090, 4751)}
+        return self.render(columns, steps, lineage, shortcuts, has_children=bool(tail))
+
+    def render(self, columns, steps, lineage, shortcuts, has_children):
+        top, chart, spacing, bar = 24, 460, 250, 14
+        width = max(830, 40 + (len(columns) - 1) * spacing + bar + 250)
+        height = top * 2 + chart
+
+        def stack(nodes):
+            """Sankey layout: bar heights follow assembly counts, with room for every label."""
+            gap, slot = (12 if len(nodes) > 1 else 0), 36
+            fixed, scale = set(), 0
+            for _ in range(len(nodes) + 1):
+                free = chart - gap * (len(nodes) - 1) - slot * len(fixed)
+                flexible = sum(n['total'] for k, n in enumerate(nodes) if k not in fixed)
+                scale = free / flexible if flexible else 0
+                small = fixed | {k for k, n in enumerate(nodes) if n['total'] * scale < slot}
+                if small == fixed:
+                    break
+                fixed = small
+            y = top
+            for k, n in enumerate(nodes):
+                room = slot if k in fixed else n['total'] * scale
+                n['h'] = max(3, n['total'] * scale)
+                n['y'] = y + (room - n['h']) / 2
+                y += room + gap
+
+        def share(n):
+            return n['covered'] / n['total'] if self.coverage and n['total'] else 0
+
+        def ribbon(x0, a0, a1, x1, b0, b1, kind):
+            bend = (x0 + x1) / 2
+            return (f'<path d="M{x0},{a0:.1f} C{bend},{a0:.1f} {bend},{b0:.1f} {x1},{b0:.1f} '
+                    f'L{x1},{b1:.1f} C{bend},{b1:.1f} {bend},{a1:.1f} {x0},{a1:.1f} Z" class="flow flow-{kind}"/>')
+
+        flows, nodes = [], []
+        for depth, column in enumerate(columns):
+            stack(column)
+            x = 40 + depth * spacing
+            for n in column:
+                n['x'] = x
+        for depth, column in enumerate(columns[:-1]):
+            parent = next((n for n in column if n['selected']), None)
+            children = columns[depth + 1]
+            if not parent:
+                continue
+            total = sum(c['total'] for c in children) or 1
+            cursor = parent['y']
+            for child in children:
+                a0 = cursor
+                a1 = cursor + parent['h'] * child['total'] / total
+                cursor = a1
+                f = share(child)
+                am, bm = a0 + f * (a1 - a0), child['y'] + f * child['h']
+                x0, x1 = parent['x'] + bar, child['x']
+                if f > 0:
+                    flows.append(ribbon(x0, a0, am, x1, child['y'], bm, "annotated"))
+                if f < 1:
+                    flows.append(ribbon(x0, am, a1, x1, bm, child['y'] + child['h'], "missing"))
+
+        for depth, column in enumerate(columns):
+            on_path = depth < len(steps)
+            for n in column:
+                x, y, h = n['x'], n['y'], n['h']
+                f = share(n)
+                percent = 100 * f
+                detail = (f"{n['name']} · {n['covered']:,} of {n['total']:,} assemblies have published annotations ({percent:.2f}%). Includes partial assemblies."
+                          if self.coverage else f"{n['name']} · {n['total']:,} assemblies. Coverage inventory unavailable.")
+                if n.get('aggregate'):
+                    detail += " Display aggregate, not a taxonomic clade. Activate to see its lineages."
+                elif not n.get('direct') and not n['selected']:
+                    detail += " Activate to expand this group to the right."
+                action = "" if n.get('direct') else f'data-path="{n["path"]}" role="button" tabindex="0"'
+                classes = "tree-node" + (" is-selected" if n['selected'] else " is-sibling" if on_path else "") + \
+                    (" is-direct" if n.get('direct') else "")
+                nodes.append(f'<g class="{classes}" {action} aria-label="{escape(detail, quote=True)}" data-detail="{escape(detail, quote=True)}"><title>{escape(detail)}</title>')
+                cy = y + h / 2
+                nodes.append(f'<rect x="{x - 6}" y="{min(y, cy - 18):.1f}" width="{spacing - 40}" height="{max(h, 36):.1f}" rx="10" class="tree-hit"/>')
+                green = h * f
+                if green > 0:
+                    nodes.append(f'<rect x="{x}" y="{y:.1f}" width="{bar}" height="{green:.1f}" class="bar bar-annotated"/>')
+                if green < h:
+                    nodes.append(f'<rect x="{x}" y="{y + green:.1f}" width="{bar}" height="{h - green:.1f}" class="bar bar-missing"/>')
+                nodes.append(f'<rect x="{x}" y="{y:.1f}" width="{bar}" height="{h:.1f}" class="bar-outline"/>')
+                label = n['label'] if len(n['label']) <= 24 else n['label'][:22] + "…"
+                stats = f"{percent:.1f}% · {n['covered']:,} / {n['total']:,}" if self.coverage else f"{n['total']:,} assemblies"
+                nodes.append(f'<text x="{x + bar + 8}" y="{cy - 3:.1f}" class="tree-label">{escape(label)}</text>'
+                             f'<text x="{x + bar + 8}" y="{cy + 13:.1f}" class="tree-count">{stats}</text></g>')
+        svg = (f'<svg viewBox="0 0 {width} {height}" class="life-tree" data-route="{encode_path(steps)}" style="min-width:{width if width > 1040 else 760}px" '
+               f'aria-label="Eukaryotic taxonomy and annotation coverage">' + ''.join(flows) + ''.join(nodes) + '</svg>')
+
+        focus = next(n for n in columns[len(steps) - 1] if n['selected'])
+        total, covered = focus['total'], focus['covered']
         percent = 100 * covered / total if self.coverage and total else 0
-        selected_name = root['label'] if not root.get('aggregate') else f"Other lineages of {lineage[-1]['name']}"
-        breadcrumbs = ' <span class="crumb-divider">/</span> '.join(
-            f'<button data-taxid="{r["taxid"]}" data-offset="0">{escape(DISPLAY_NAMES.get(r["taxid"], r["name"]))}</button>' for r in lineage)
-        if root.get('aggregate'):
-            breadcrumbs += ' <span class="crumb-divider">/</span> <span>Other lineages</span>'
+        selected_name = f"Other lineages of {lineage[-1]['name']}" if focus.get('aggregate') else focus['label']
+        crumbs = []
+        for depth, (row, (_, offset)) in enumerate(zip(lineage, steps)):
+            name = "Other lineages" if offset else DISPLAY_NAMES.get(row['taxid'], row['name'])
+            crumbs.append(f'<button data-path="{encode_path(steps[:depth + 1])}">{escape(name)}</button>')
+        breadcrumbs = ' <span class="crumb-divider">/</span> '.join(crumbs)
+        parent = encode_path(steps[:-1] or steps)
         stamp = (self.coverage or self.metadata)['created_at'][:10]
         if self.coverage:
             summary = (f'<div class="atlas-kicker">{escape(selected_name)} · ASSEMBLY COVERAGE</div>'
                        f'<div class="atlas-summary"><strong>{covered:,}</strong><span>of {total:,}<br>assemblies annotated</span>'
                        f'<b class="atlas-badge">{percent:.1f}%</b></div>')
+            legend = ('<div class="atlas-legend"><i class="atlas-swatch atlas-annotated"></i><span>Annotated</span>'
+                      '<i class="atlas-swatch atlas-missing"></i><span>Not annotated</span></div>')
         else:
             summary = f'<div class="atlas-kicker">{escape(selected_name)}</div><div class="atlas-summary"><strong>{total:,}</strong><span>GenBank assemblies<br>Coverage unavailable</span></div>'
-        leaf_note = '<p class="atlas-leaf-note">This is a terminal taxon in the assembly snapshot. Use the breadcrumb to explore its relatives.</p>' if not root['children'] else ''
+            legend = '<div class="atlas-legend"><i class="atlas-swatch atlas-missing"></i><span>Assemblies · coverage unavailable</span></div>'
+        leaf_note = '<p class="atlas-leaf-note">This is a terminal taxon in the assembly snapshot. Use the breadcrumb to explore its relatives.</p>' if not has_children else ''
         return f'''<section class="atlas" aria-label="Tree of eukaryotic life">
           <header class="atlas-header">
             <div><div class="atlas-kicker">HUGGING FACE BIO <span> / </span> GENOME ATLAS</div>
@@ -191,19 +252,18 @@ class Taxonomy:
             <div class="atlas-summary-block">{summary}</div>
           </header>
           <nav class="atlas-nav" aria-label="Explore major lineages">
-            <div class="atlas-shortcuts"><button data-taxid="2759" data-offset="0">All eukaryotes</button>
-            <button data-taxid="33208" data-offset="0">Animals</button><button data-taxid="33090" data-offset="0">Green plants</button>
-            <button data-taxid="4751" data-offset="0">Fungi</button></div>
-            <button class="atlas-back" data-taxid="{parent}" data-offset="0">← Parent group</button>
+            <div class="atlas-shortcuts"><button data-path="{DEFAULT_PATH}">All eukaryotes</button>
+            <button data-path="{shortcuts[33208]}">Animals</button><button data-path="{shortcuts[33090]}">Green plants</button>
+            <button data-path="{shortcuts[4751]}">Fungi</button></div>
+            <button class="atlas-back" data-path="{parent}">← Collapse last group</button>
           </nav>
           <div class="atlas-breadcrumb">{breadcrumbs}</div>
-          <div class="tree-scroll" tabindex="0" aria-label="Interactive tree. Scroll horizontally on small screens.">{svg}</div>
+          <div class="tree-scroll" tabindex="0" aria-label="Interactive tree. Scroll horizontally to see deeper lineages.">{svg}</div>
           {leaf_note}<div class="atlas-tooltip" role="tooltip" hidden></div>
-          <footer class="atlas-footer"><div class="atlas-legend"><span>Coverage</span><i class="atlas-zero"></i><span>None</span>
-            <i class="atlas-gradient"></i><span>Low → 100%</span></div>
-            <span>Click a group to unfold its lineages <span class="atlas-mobile-hint">· Swipe to explore</span></span>
+          <footer class="atlas-footer">{legend}
+            <span>Click a group to expand it to the right <span class="atlas-mobile-hint">· Swipe to explore</span></span>
             <span class="atlas-date">Updated {stamp}</span></footer>
-          <div class="atlas-footnote">Coverage counts assemblies with published annotations, including partial assemblies. Branch lengths and spacing are for readability; they do not encode time or assembly counts.</div>
+          <div class="atlas-footnote">Bar and flow heights are proportional to assembly counts within each column; each column is rescaled to fill the height, so compare sizes within a column. Coverage counts assemblies with published annotations, including partial assemblies.</div>
         </section>'''
 
 
@@ -219,7 +279,7 @@ def build_taxonomy_tab():
 
     def explore_tree(evt: gr.EventData):
         try:
-            return taxonomy.view(evt.taxid, evt.offset)
+            return taxonomy.view(evt.route)
         except (ValueError, TypeError, AttributeError) as exc:
             raise gr.Error("Choose a eukaryotic group in this snapshot.") from exc
 
@@ -236,7 +296,7 @@ def build_taxonomy_tab():
             return gr.Dropdown(choices=choices, value=None), f"{len(choices)} results (up to 100, largest first)." if choices else "No matching eukaryotic taxa in this snapshot."
 
         def taxonomy_view(taxid):
-            return taxonomy.view(taxid or EUKARYOTA)
+            return taxonomy.view_taxon(taxid) if taxid else taxonomy.view()
 
         matches.input(taxonomy_view, matches, tree)
         find.click(taxonomy_search, query, [matches, status])
@@ -244,8 +304,9 @@ def build_taxonomy_tab():
     with gr.Accordion("About the tree and coverage", open=False, elem_classes="atlas-disclosure"):
         gr.Markdown("This tree follows **NCBI Taxonomy within Eukaryota**. Animals and fungi share the Opisthokonta branch; "
                     "green plants include green algae. ‘Other lineages’ combines the remaining siblings for display and can be expanded. "
-                    "Each view shows up to six direct lineages plus any remainder. The opening view also opens the animal/fungal branch. "
-                    "The tree layout is illustrative; **counts and colors use the actual assembly inventory**.\n\n"
+                    "Each expanded group adds a column on the right with up to six direct lineages plus any remainder, so every ancestor stays visible. "
+                    "The opening view also expands the animal/fungal branch. Bars and flows are drawn like a Sankey diagram: "
+                    "heights follow **actual assembly counts** within each column, split into annotated and not-annotated assemblies.\n\n"
                     "Coverage means the fraction of current GenBank assembly versions with published annotations, including partial assemblies. "
                     "It does not measure the fraction of bases annotated. Parent counts include descendants once each. "
                     "Exact accession versions are matched. The Database tab searches a dated snapshot of all published annotation files.\n\n"

tests/test_taxonomy.py

@@ -0,0 +1,40 @@
+import re
+import unittest
+
+from taxonomy import DATABASE, DEFAULT_PATH, Taxonomy
+
+
+@unittest.skipUnless(DATABASE.exists(), "taxonomy snapshot unavailable")
+class TaxonomyTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.taxonomy = Taxonomy()
+
+    def columns(self, html):
+        return sorted({float(x) for x in re.findall(r'<rect x="([\d.]+)" y="[\d.]+" width="14"', html)})
+
+    def test_expansion_keeps_every_ancestor_column(self):
+        self.assertEqual(len(self.columns(self.taxonomy.view("2759"))), 2)
+        self.assertEqual(len(self.columns(self.taxonomy.view(DEFAULT_PATH))), 3)
+        html = self.taxonomy.view("2759/33154/33208")
+        self.assertEqual(len(self.columns(html)), 4)
+        self.assertEqual(html.count('class="tree-node is-selected"'), 3)
+
+    def test_search_path_expands_lineage(self):
+        path = self.taxonomy.taxon_path(9606)
+        self.assertTrue(path.startswith("2759/33154/33208/"))
+        self.assertTrue(path.endswith("/9606"))
+        self.assertIn(f'data-route="{path}"', self.taxonomy.view_taxon(9606))
+
+    def test_other_lineages_expand_as_columns(self):
+        html = self.taxonomy.view("2759/2759~6")
+        self.assertIn('data-path="2759/2759~6/2759~12"', html)
+
+    def test_rejects_paths_outside_the_tree(self):
+        for path in ("1", "33208", "2759/33208", "2759/2759~3", "2759/9606", "abc"):
+            with self.assertRaises(ValueError, msg=path):
+                self.taxonomy.view(path)
+
+
+if __name__ == "__main__":
+    unittest.main()