archaeopteryx 3.4.0 → 3.4.1

package/README.md

@@ -217,15 +217,24 @@ any node does — an event, a search hit, a selection, a visualization.
 internal node's whole clade into a wedge and opens it again; **Uncollapse
 Subtree** opens everything below a node; the tool row's uncollapse-all button
 (the desktop's glyph, lit only while something is collapsed) opens the whole
-tree, and so does **Esc**. The wedge is the desktop's triangle: its apex at
-the node, its vertical base at the clade's average tip distance (one depth
-step in a cladogram), so its depth stays readable; it is filled in the colour most of its tips wear under the current
-Color-by, grows gently taller with its tip count, and is named — the node's
+tree, and so does **Esc**. The wedge has its apex at the node, one edge
+reaching the clade's nearest tip and the other its farthest, so the shape
+shows how uneven the clade's branch lengths are, as iTOL draws it (one depth
+step in a cladogram). Its label stands where a tip's would: on the label
+column in the aligned phylogram and on the outer ring in circular, with the
+same guide line; it is filled in the colour most of its tips wear under the current
+Color-by (the colour
+they wore, even when no tip on screen shares their value), grows gently taller with its tip count, and is named — the node's
 own name if it has one; else the one Color-by value nearly all its tips share,
 so a clade reads "Bovine · 12 tips" while you look at hosts; else the tips'
 common name prefix; always with the tip count, and with `[found/total]` while
 a search hits inside it. Legends, alignment rows and domain tracks describe
-the tips on screen, so a collapsed clade's tips leave them. Collapsing is
+the tips on screen, so a collapsed clade's tips leave them,
+and the counts follow every clade you fold or open. A clade holding search
+hits is one dot in the overview and one stop for the hit navigator; one
+holding selected tips is outlined in the selection colour, and filled when
+all its tips are selected. Re-rooting opens any collapsed clade whose tips it
+would change, such as one the new midpoint falls inside. Collapsing is
 display state only: nothing is removed, exports and downloads carry every
 tip, and the unrooted layout, which has no rows to fold, shows every clade
 open. The controls are the desktop's; the drawing and naming are this
@@ -270,6 +279,13 @@ nothing; a column the tree already carries under the same ref is replaced by
 the table's values. Quoted cells, `#` comment lines and Windows line ends are
 fine.
 
+The node menu's **Download Ext. Node Data** writes the other direction: the
+tips under a node as a tab-separated table, header first, with the desktop
+Archaeopteryx's column names (`name`, `taxonomy_scientific_name`, …,
+`branch_length`, then one column per property ref). A column no tip fills
+is left out, and a `node_id` column comes first when tip names are blank or
+repeated. Such a file opens again as a metadata table.
+
 Embedders do the same in two lines, before `launch()`:
 
 ```js
@@ -291,10 +307,12 @@ and **Inverse** apply to both.
 Hits are hard to miss: their labels take the search colour **in bold**, a
 translucent **pulsing halo** breathes behind each hit, and everything that is
 *not* a hit fades — the desktop's "dim non-matches", engaged only while at
-least one hit is actually visible, so a fruitless search never washes the
-tree out. The **overview** miniature marks every hit as a dot in the same
+least one hit is on screen, so a fruitless search never washes the tree out.
+A collapsed clade holding a hit counts as on screen: it stays bright, its
+wedge outlined in the search colour and its label counting the hits, and
+the rest fades even when every hit is inside collapsed clades. The **overview** miniature marks every hit as a dot in the same
 colour, and a **◀ k / N ▶** navigator appears under the search boxes: each
-press centres the previous / next hit in the viewport, wrapping around.
+press centres the previous / next hit in the viewport, wrapping around. A collapsed clade holding hits is one dot and one stop.
 
 ## Keyboard
 
@@ -403,6 +421,8 @@ displayed), and a 1-based **column ruler**. **Hover any residue** for its
 alignment column, its position within that sequence's own ungapped residues,
 its full name, class, and Kyte-Doolittle hydropathy. The **Alignment**
 checkbox under Display Data toggles the whole track.
+To find a motif, pick **Molecular Sequence** in a search box: it matches the
+residues as written, gap characters included, as the desktop does.
 
 Alignments arrive with the tree: as phyloXML `<mol_seq is_aligned="true">`
 elements, or in a **Nexus** file whose characters matrix accompanies its tree.
@@ -615,7 +635,7 @@ a name ending in `xml` as phyloXML, anything else as New Hampshire (Newick).
 A file holding **several trees** — a Nexus TREES block, a Newick file with one
 tree per `;`, a phyloXML with several phylogenies — opens on the first, and a
 picker with previous / next buttons at the top of the control panel moves
-between them; each tree opens fresh under the same config, the way a new tab
+between them; each tree opens fresh under the same config, nothing collapsed, the way a new tab
 does on the desktop. A protein/DNA/RNA characters matrix in a Nexus file
 (sequential or interleaved) lands on the tips as an aligned `mol_seq`, so the
 alignment track appears just as it does for phyloXML.

package/archaeopteryx.js

@@ -20,7 +20,7 @@
  *
  */
 
-// v 3.4.0
+// v 3.4.1
 // 2026-09-10
 //
 // Archaeopteryx.js is a software tool for the visualization and
@@ -103,7 +103,7 @@ function (root, d3, forester, phyloXml) {
     // IIFE's own function name -- a plain object says what it is.)
     let archaeopteryx = {};
 
-    const VERSION = '3.4.0';
+    const VERSION = '3.4.1';
     const WEBSITE = 'https://cmzmasek.github.io/archaeopteryx-js/';
     const DESKTOP_WEBSITE = 'https://cmzmasek.github.io/archaeopteryx/';
     const SOURCE_WEBSITE = 'https://github.com/cmzmasek/archaeopteryx-js';
@@ -1147,12 +1147,12 @@ function (root, d3, forester, phyloXml) {
         // on the desktop: dots in the search colours, so hits outside the
         // current viewport can be spotted and steered to. Search results
         // re-run update(), which ends here, so the dots track every search.
-        // Visible nodes only (children, not _children): a hit inside a
-        // collapsed clade has no drawn position.
+        // Displayed nodes only: a hit inside a collapsed clade has no drawn
+        // position, so the clade gets the dot, in its wedge's mark colour.
         let hits = [];
         if (_root) {
             forEachDisplayed(function (n) {
-                let c = getFoundColor(n);
+                let c = getFoundColor(n) || (isCollapsed(n) ? collapsedMarkColor(n) : null);
                 if (c) {
                     hits.push({node: n, color: c});
                 }
@@ -1997,6 +1997,7 @@ function (root, d3, forester, phyloXml) {
             }
         });
         _vis.colorNext[vis.id] = next;
+        vis.categoryOnScreen = new Set(vis.values);   // what the scale may be asked about (visualizationColorFor)
         vis.categoryScale = d3.scaleOrdinal()
             .domain(vis.values)
             .range(vis.values.map(function (v) {
@@ -2758,13 +2759,16 @@ function (root, d3, forester, phyloXml) {
             }
         }
 
-        // The dim gate: only while a hit is actually DRAWN, so the tree never
+        // The dim gate: only while a hit is actually SHOWN, so the tree never
         // washes out with nothing emphasised (a 0-hit search, or every hit
-        // hidden inside a collapsed clade / outside the displayed subtree).
+        // outside the displayed subtree). A collapsed clade holding a hit
+        // counts as shown: it stays bright, outlined and counting its hits,
+        // so the rest fading points at it (Christian, 2026-09-14: "less
+        // confusing to users" than no dimming at all).
         _dimNonMatches = false;
         if ((_foundNodes0 && _foundNodes0.size > 0) || (_foundNodes1 && _foundNodes1.size > 0)) {
             for (let i = 0, len = nodes.length; i !== len; ++i) {
-                if (isNodeFound(nodes[i])) {
+                if (isNodeFound(nodes[i]) || (isCollapsed(nodes[i]) && collapsedFoundCounts(nodes[i]).found > 0)) {
                     _dimNonMatches = true;
                     break;
                 }
@@ -2782,10 +2786,15 @@ function (root, d3, forester, phyloXml) {
         placeRootStub();
 
         if (_state.circularDisplay) {
+            // the outermost drawn point sets the scale: a node, or the far
+            // edge of a collapsed clade's wedge -- which reaches the clade's
+            // farthest tip, hidden from nodes but not from the drawing, and
+            // would otherwise poke through the ring the labels stand on
             let maxY = 0;
             for (let i = 0; i < nodes.length; ++i) {
-                if (nodes[i].y > maxY) {
-                    maxY = nodes[i].y;
+                let y = isCollapsed(nodes[i]) ? Math.max(nodes[i].y, collapsedReach(nodes[i])[1]) : nodes[i].y;
+                if (y > maxY) {
+                    maxY = y;
                 }
             }
             _radial = {
@@ -3153,9 +3162,14 @@ function (root, d3, forester, phyloXml) {
         // Dim Non-Matches: one opacity on the node GROUP dims its labels, dot,
         // shape and branch-data numbers together; the branch lines are separate
         // path.link elements and keep their full colour, as on the desktop.
-        // Hits and selected nodes (getFoundColor) are never dimmed.
+        // Hits and selected nodes (getFoundColor) are never dimmed -- and
+        // neither is a collapsed clade holding one: its wedge and label live in
+        // the clade node's group, and the clade node itself is never a hit.
         node.style('opacity', function (d) {
-            return (_dimNonMatches && !getFoundColor(d)) ? DIM_NON_MATCH_OPACITY : null;
+            if (!_dimNonMatches || getFoundColor(d) || (isCollapsed(d) && collapsedHoldsHighlight(d))) {
+                return null;
+            }
+            return DIM_NON_MATCH_OPACITY;
         });
 
         let nodeUpdate = animateOrSet(node, transitionDuration)
@@ -3303,43 +3317,75 @@ function (root, d3, forester, phyloXml) {
         // _svgGroup, so that name put them in the way of selectAll('path.link')
         // -- the main link data-join, and the overview's miniature.
         _svgGroup.selectAll('g.aptx-align-ext').remove();
-        if (!radialDisplay() && _state.phylogram && _state.alignPhylogram && _state.showExternalLabels
-            && (_state.showNodeName || _state.showTaxonomy || _state.showSequence)) {
+        let alignedRect = !radialDisplay() && _state.phylogram && _state.alignPhylogram;
+        let tipGuides = alignedRect && _state.showExternalLabels
+            && (_state.showNodeName || _state.showTaxonomy || _state.showSequence);
+        // a collapsed clade's label always shows, so its guide does too: from
+        // past the wedge's farthest tip to the label column
+        let collapsedGuides = alignedRect ? nodes.filter(function (d) {
+            return isCollapsed(d) && !(_state.dynahide && d.hide);
+        }) : [];
+        if (tipGuides || collapsedGuides.length > 0) {
             let ext = _svgGroup.insert('g', 'g').attr('class', 'aptx-align-ext');
-            ext.selectAll('path')
-                .data(links.filter(function (d) {
-                    return (!d.target.children && !(_state.dynahide && d.target.hide));
-                }))
-                .enter().append('path')
-                .attr('fill', 'none')
-                .attr('stroke-width', 1)
-                .attr('stroke', _state.branchColorDefault)
-                .style('stroke-opacity', 0.25)
+            let guideStyle = function (sel) {
+                return sel.attr('fill', 'none')
+                    .attr('stroke-width', 1)
+                    .attr('stroke', _state.branchColorDefault)
+                    .style('stroke-opacity', 0.25);
+            };
+            if (tipGuides) {
+                guideStyle(ext.selectAll('path.aptx-tip-guide')
+                    .data(links.filter(function (d) {
+                        return (!d.target.children && !(_state.dynahide && d.target.hide));
+                    }))
+                    .enter().append('path').attr('class', 'aptx-tip-guide'))
+                    .attr('d', function (d) {
+                        return connection(d.target);
+                    });
+            }
+            guideStyle(ext.selectAll('path.aptx-collapsed-guide')
+                .data(collapsedGuides)
+                .enter().append('path').attr('class', 'aptx-collapsed-guide'))
                 .attr('d', function (d) {
-                    return connection(d.target);
+                    let x1 = collapsedReach(d)[1] + 5;
+                    return (_w - x1) > 5 ? 'M' + x1 + ',' + d.x + 'L' + _w + ',' + d.x : null;
                 });
         }
 
         // circular: a thin dashed connector from each external node out to the
         // common label ring (so labels line up like iTOL's aligned display).
         _svgGroup.selectAll('g.aptx-radial-conn').remove();
-        if (_state.circularDisplay && _state.showExternalLabels) {
-            let conn = _svgGroup.insert('g', 'g').attr('class', 'aptx-radial-conn');
-            conn.selectAll('line')
-                .data(nodes.filter(function (d) {
-                    return !d.children && !(_state.dynahide && d.hide);
-                }))
-                .enter().append('line')
-                .attr('stroke', _state.branchColorDefault)
-                // width/opacity match the rectangular aligned extensions; the
-                // dash alone marks these as connectors (0.5px at 0.3 vanished)
-                .attr('stroke-width', 1)
-                .style('stroke-opacity', 0.4)
-                .style('stroke-dasharray', '2,3')
-                .attr('x1', function (d) { return radialXY(d.x, d.y)[0]; })
-                .attr('y1', function (d) { return radialXY(d.x, d.y)[1]; })
-                .attr('x2', function (d) { return polarXY(radialAngle(d.x), _radial.maxRad)[0]; })
-                .attr('y2', function (d) { return polarXY(radialAngle(d.x), _radial.maxRad)[1]; });
+        if (_state.circularDisplay) {
+            // tips while their labels show; a collapsed clade always (its label
+            // always shows), from its wedge's farthest reach out to the ring
+            let connected = nodes.filter(function (d) {
+                if (_state.dynahide && d.hide) {
+                    return false;
+                }
+                if (isCollapsed(d)) {
+                    return _radial.maxRad - radialRadius(collapsedReach(d)[1]) > 2;
+                }
+                return !d.children && _state.showExternalLabels;
+            });
+            let innerY = function (d) {
+                return isCollapsed(d) ? collapsedReach(d)[1] : d.y;
+            };
+            if (connected.length > 0) {
+                let conn = _svgGroup.insert('g', 'g').attr('class', 'aptx-radial-conn');
+                conn.selectAll('line')
+                    .data(connected)
+                    .enter().append('line')
+                    .attr('stroke', _state.branchColorDefault)
+                    // width/opacity match the rectangular aligned extensions; the
+                    // dash alone marks these as connectors (0.5px at 0.3 vanished)
+                    .attr('stroke-width', 1)
+                    .style('stroke-opacity', 0.4)
+                    .style('stroke-dasharray', '2,3')
+                    .attr('x1', function (d) { return radialXY(d.x, innerY(d))[0]; })
+                    .attr('y1', function (d) { return radialXY(d.x, innerY(d))[1]; })
+                    .attr('x2', function (d) { return polarXY(radialAngle(d.x), _radial.maxRad)[0]; })
+                    .attr('y2', function (d) { return polarXY(radialAngle(d.x), _radial.maxRad)[1]; });
+            }
         }
 
         for (let i = 0, len = nodes.length; i !== len; ++i) {
@@ -3553,6 +3599,17 @@ function (root, d3, forester, phyloXml) {
         if (colorModeOf(vis) === 'range') {
             return vis.rangeScale ? vis.rangeScale(Number(value)) : null;
         }
+        // A value only tips hidden in a collapsed clade carry is not on
+        // screen, so not in the scale's domain -- and a d3 ordinal scale asked
+        // about an unknown value extends its domain and hands out an on-screen
+        // value's colour. Such a value keeps its remembered colour instead
+        // (assigned at launch over the whole tree, or the user's override):
+        // the clade's wedge keeps the colour its tips wore. Christian,
+        // 2026-09-14; reported by the desktop session, which follows.
+        if (vis.categoryOnScreen && !vis.categoryOnScreen.has(value)) {
+            let mem = _vis.colorMemory[vis.id];
+            return (mem && mem[visMemoryKey(vis, value)]) || null;
+        }
         return vis.categoryScale(value);
     }
 
@@ -3593,11 +3650,13 @@ function (root, d3, forester, phyloXml) {
         if (_root && ((_foundNodes0 && _foundNodes0.size > 0) || (_foundNodes1 && _foundNodes1.size > 0))) {
             // natural (top-to-bottom) drawing order -- forester's preorder
             // walks children in reverse, which made the NEXT arrow step upward
+            // a collapsed clade holding hits is ONE stop, on its node: the hits
+            // inside have no position of their own to step to
             let walk = function (n) {
-                if (isNodeFound(n)) {
+                if (isNodeFound(n) || (isCollapsed(n) && collapsedFoundCounts(n).found > 0)) {
                     hits.push(n);
                 }
-                if (n.children && !isCollapsed(n)) {   // a hit inside a collapsed clade has no position to step to
+                if (n.children && !isCollapsed(n)) {
                     for (let i = 0; i < n.children.length; ++i) {
                         walk(n.children[i]);
                     }
@@ -5412,6 +5471,10 @@ function (root, d3, forester, phyloXml) {
         if (index === _treeIndex) {
             return makeViewerHandle();
         }
+        // collapsing is part of the view, and a switched-to tree opens fresh:
+        // nothing collapsed, now or when you come back (Christian, 2026-09-14)
+        clearCollapsedFlags(_trees[_treeIndex]);
+        clearCollapsedFlags(_trees[index]);
         return launchInto(_container, _trees, index, _launchConfig);
     }
 
@@ -5571,134 +5634,21 @@ function (root, d3, forester, phyloXml) {
                 update();
             }
 
+            // The tips under the node as a tab-separated table with a header,
+            // the desktop's columns (forester.externalNodeDataTable), top to
+            // bottom as drawn; it reads back through a metadata-table join.
             function downloadExternalNodeDataAll(node) {
-
-                let addSep = function (t) {
-                    if (t.length > 0) {
-                        t += '\t';
-                    }
-                    return t;
-                };
-
-                let addSepSame = function (t) {
-                    if (t.length > 0) {
-                        t += ', ';
-                    }
-                    return t;
-                };
-                let text_all = '';
-
                 const ext_nodes = forester.getAllExternalNodes(node).reverse();
-
                 let filename;
                 if (ext_nodes.length === 1 && ext_nodes[0].name) {
-                    filename = 'External_Node_Data_for_Node_' + ext_nodes[0].name.replace(/\W/g, '_') + '.txt';
+                    filename = 'External_Node_Data_for_Node_' + ext_nodes[0].name.replace(/\W/g, '_') + '.tsv';
                 } else {
-                    filename = 'External_Node_Data_for_' + ext_nodes.length + '_Nodes.txt';
+                    filename = 'External_Node_Data_for_' + ext_nodes.length + '_Nodes.tsv';
                 }
-
-                for (let j = 0, l = ext_nodes.length; j < l; ++j) {
-                    let text = '';
-                    let n = ext_nodes[j];
-                    if (n.name) {
-                        text += n.name
-                    }
-
-                    if (n.properties && (n.properties.length > 0)) {
-                        const sorted_properties = n.properties.concat().sort();
-                        const l = sorted_properties.length;
-                        let properties_text = '';
-                        let prev_property_ref = null;
-                        for (let pl = 0; pl < l; ++pl) {
-                            if (forester.isNodeScopedProperty(sorted_properties[pl])) {
-                                if (sorted_properties[pl].ref === prev_property_ref) {
-                                    properties_text = addSepSame(properties_text);
-                                } else {
-                                    prev_property_ref = sorted_properties[pl].ref;
-                                    properties_text = addSep(properties_text);
-                                }
-                                properties_text += sorted_properties[pl].value;
-                            }
-                        }
-                        if (properties_text.length > 0) {
-                            text = addSep(text);
-                            text += properties_text;
-                        }
-                    }
-
-                    if (n.taxonomies) {
-                        let tax_text = '';
-                        for (let i = 0; i < n.taxonomies.length; ++i) {
-                            let t = n.taxonomies[i];
-                            if (t.id) {
-                                if (t.id.provider) {
-                                    tax_text = addSep(tax_text);
-                                    tax_text += '[' + t.id.provider + ']:' + t.id.value;
-                                } else {
-                                    tax_text = addSep(tax_text);
-                                    tax_text += t.id.value;
-                                }
-                            }
-                            if (t.code) {
-                                tax_text = addSep(tax_text);
-                                tax_text += t.code;
-                            }
-                            if (t.scientific_name) {
-                                tax_text = addSep(tax_text);
-                                tax_text += t.scientific_name;
-                            }
-                            if (t.common_name) {
-                                tax_text = addSep(tax_text);
-                                tax_text += t.common_name;
-                            }
-                            if (t.rank) {
-                                tax_text = addSep(tax_text);
-                                tax_text += t.rank;
-                            }
-                        }
-                        text = addSep(text);
-                        text += tax_text;
-                    }
-                    if (n.sequences) {
-                        let seq_text = '';
-                        for (let i = 0; i < n.sequences.length; ++i) {
-                            let s = n.sequences[i];
-                            if (s.accession) {
-                                if (s.accession.source) {
-                                    seq_text = addSep(seq_text);
-                                    seq_text += '[' + s.accession.source + ']:' + s.accession.value;
-                                } else {
-                                    seq_text = addSep(seq_text);
-                                    seq_text += s.accession.value;
-                                }
-                            }
-                            if (s.symbol) {
-                                seq_text = addSep(seq_text);
-                                seq_text += s.symbol;
-                            }
-                            if (s.name) {
-                                seq_text = addSep(seq_text);
-                                seq_text += s.name;
-                            }
-                            if (s.gene_name) {
-                                seq_text = addSep(seq_text);
-                                seq_text += s.gene_name;
-                            }
-                            if (s.location) {
-                                seq_text = addSep(seq_text);
-                                seq_text += s.location;
-                            }
-                        }
-                        text = addSep(text);
-                        text += seq_text;
-                    }
-                    if (text.length > 0) {
-                        text_all += text + '\n';
-                    }
-                }
-
-                saveAs(new Blob([text_all], {type: "application/txt"}), filename);
-
+                const tsv = forester.externalNodeDataTsv(ext_nodes, function (n, i) {
+                    return (n.viewId !== undefined) ? n.viewId : i + 1;
+                });
+                saveAs(new Blob([tsv], {type: 'text/tab-separated-values'}), filename);
                 update();
             }
 
@@ -5929,7 +5879,12 @@ function (root, d3, forester, phyloXml) {
             }
             if (!_in_subtree && d.parent && d.parent.parent
                 && ((_treeData.rerootable === undefined) || (_treeData.rerootable === true))) {
-                items.push({label: 'Reroot', action: function () { forester.reRoot(tree, d, -1); zoomToFit(); }});
+                items.push({label: 'Reroot', action: function () {
+                    rerootKeepingCollapse(function () {
+                        forester.reRoot(tree, d, -1);
+                    });
+                    zoomToFit();
+                }});
             }
             if (_settings.enableManualNodeSelection) {
                 items.push({label: 'Select/Deselect Node', action: function () { selectDeselectNode(d); }});
@@ -6848,6 +6803,7 @@ function (root, d3, forester, phyloXml) {
         }
         d.collapsed = !d.collapsed;
         calcMaxExtLabel();
+        refreshVisualizations(false);   // the legends describe the tips on screen
         scheduleUpdate(null, 0);
     }
 
@@ -6856,6 +6812,7 @@ function (root, d3, forester, phyloXml) {
             n.collapsed = false;
         });
         calcMaxExtLabel();
+        refreshVisualizations(false);
         scheduleUpdate(null, 0);
     }
 
@@ -6871,6 +6828,47 @@ function (root, d3, forester, phyloXml) {
         });
     }
 
+    // Runs a re-rooting without turning a collapsed clade inside out. A clade
+    // on the path to the new root has its parent turned into a child, so its
+    // flag would go on hiding a different set of tips -- with a midpoint
+    // inside a collapsed clade, the whole rest of the tree. Such a clade
+    // opens; every other clade keeps its tips and stays collapsed.
+    function rerootKeepingCollapse(reroot) {
+        let flagged = [];
+        forester.preOrderTraversalAll(_root_const || _root, function (n) {
+            if (n.collapsed === true && n.children) {
+                flagged.push({node: n, tips: forester.getAllExternalNodes(n)});
+            }
+        });
+        reroot();
+        let opened = false;
+        flagged.forEach(function (f) {
+            let now = f.node.children ? forester.getAllExternalNodes(f.node) : [];
+            let kept = new Set(f.tips);
+            if (now.length !== f.tips.length || !now.every(function (t) { return kept.has(t); })) {
+                f.node.collapsed = false;
+                opened = true;
+            }
+        });
+        if (opened) {
+            calcMaxExtLabel();
+            refreshVisualizations(false);
+        }
+    }
+
+    // What a collapsed clade is marked with for the tips it hides: the colour
+    // of its first search hit, else the selection colour when a tip is
+    // selected, else null. The wedge, the overview dot and the dimming all
+    // read it, so they always agree.
+    function collapsedMarkColor(d) {
+        let tips = forester.getAllExternalNodes(d);
+        let hit = tips.filter(isNodeFound)[0];
+        if (hit) {
+            return getFoundColor(hit);
+        }
+        return tips.some(function (t) { return _selectedNodes.has(t); }) ? _state.selectedColorDefault : null;
+    }
+
     // How tall a collapsed clade draws, in rows: 1 for a pair, growing with
     // the logarithm of the tip count, capped so a huge clade does not eat
     // the screen. The cluster layout's separation turns it into space.
@@ -6912,6 +6910,24 @@ function (root, d3, forester, phyloXml) {
         return prefix.length >= 2 ? prefix : '';
     }
 
+    // Whether any tip hidden in a collapsed clade is a hit or selected -- the
+    // clade then stays undimmed, as that tip would be if it were drawn.
+    function collapsedHoldsHighlight(d) {
+        return collapsedMarkColor(d) !== null;
+    }
+
+    // Whether every tip a collapsed clade hides is marked: all of them search
+    // hits when the clade holds any hit, else all of them selected. Such a
+    // wedge is filled in the mark colour and its label set in it, bold.
+    function collapsedFullyMarked(d) {
+        let hits = collapsedFoundCounts(d);
+        if (hits.found > 0) {
+            return hits.found === hits.total;
+        }
+        let tips = forester.getAllExternalNodes(d);
+        return tips.length > 0 && tips.every(function (t) { return _selectedNodes.has(t); });
+    }
+
     function collapsedFoundCounts(d) {
         let found = 0;
         let total = 0;
@@ -6959,26 +6975,28 @@ function (root, d3, forester, phyloXml) {
         return best || _state.branchColorDefault;
     }
 
-    // The wedge's base: the desktop's triangle (paintCollapsedNode with its
-    // default "collapsed with average height") stands on a VERTICAL base at
-    // the clade's average tip distance, so the shape is symmetric about the
-    // node's row and its depth still reads. A cladogram, where every leaf
-    // sits on the tip column, gives it one depth step.
-    function collapsedBase(d) {
+    // The wedge's reach: the clade's nearest and farthest tips, in the
+    // layout's x. One edge runs to the nearest tip and the other to the
+    // farthest, so the shape itself shows how uneven the clade's branch
+    // lengths are (as iTOL draws it). Christian chose this over the
+    // desktop's symmetric triangle on an average base (2026-09-14). A
+    // phylogram measures the tips; a cladogram, where every leaf sits on
+    // the tip column, gives the wedge one depth step.
+    function collapsedReach(d) {
         if (_state.phylogram && _yScale) {
-            let sum = 0;
-            let n = 0;
+            let min = Infinity;
+            let max = -Infinity;
             forester.preOrderTraversal(d, function (t) {
                 if (!t.children && typeof t.distToRoot === 'number') {
-                    sum += t.distToRoot;
-                    ++n;
+                    if (t.distToRoot < min) { min = t.distToRoot; }
+                    if (t.distToRoot > max) { max = t.distToRoot; }
                 }
             });
-            if (n > 0) {
-                return Math.max(d.y + 2, _yScale(sum / n));
+            if (isFinite(min)) {
+                return [Math.max(d.y + 2, _yScale(min)), Math.max(d.y + 2, _yScale(max))];
             }
         }
-        return d.y + _cladogramUnit;
+        return [d.y + _cladogramUnit, d.y + _cladogramUnit];
     }
 
     let _cladogramUnit = 0;   // one depth step of the last cladogram layout, px
@@ -7001,52 +7019,71 @@ function (root, d3, forester, phyloXml) {
         let fs = _state.externalNodeFontSize;
         wedge.each(function (d) {
             let color = collapsedColor(d);
-            let hits = collapsedFoundCounts(d);
-            let foundColor = hits.found > 0 ? getFoundColor(forester.getAllExternalNodes(d).filter(isNodeFound)[0]) : null;
+            let mark = collapsedMarkColor(d);
+            let full = collapsedFullyMarked(d);
             let h = Math.max(6, collapsedRows(d) * _rowUnit * 0.82);
-            let base = collapsedBase(d);
+            let reach = collapsedReach(d);
             let path;
             if (radialDisplay()) {
                 // in the rotated frame: +x along the spoke from the node (the
-                // group's origin, already at the node's radius), the base
-                // across it -- a distance, never an absolute radius, or the
-                // wedge lands a whole radius further out than its label
-                let dr = radialRadius(base) - radialRadius(d.y);
-                path = 'M0,0 L' + dr + ',' + (-h / 2) + ' L' + dr + ',' + (h / 2) + ' Z';
+                // group's origin, already at the node's radius) -- distances,
+                // never absolute radii, or the wedge lands a whole radius
+                // further out than its label
+                let r0 = radialRadius(d.y);
+                let dr1 = radialRadius(reach[0]) - r0;
+                let dr2 = radialRadius(reach[1]) - r0;
+                path = 'M0,0 L' + dr1 + ',' + (-h / 2) + ' L' + dr2 + ',' + (h / 2) + ' Z';
             } else {
-                let dx = base - d.y;
-                path = 'M0,0 L' + dx + ',' + (-h / 2) + ' L' + dx + ',' + (h / 2) + ' Z';
+                let dx1 = reach[0] - d.y;
+                let dx2 = reach[1] - d.y;
+                path = 'M0,0 L' + dx1 + ',' + (-h / 2) + ' L' + dx2 + ',' + (h / 2) + ' Z';
             }
             d3.select(this)
                 .attr('d', path)
                 .attr('transform', radialDisplay() ? 'rotate(' + labelAngleDeg(d) + ')' : null)
-                .style('fill', (hits.found > 0 && hits.found === hits.total) ? foundColor : color)
-                .style('fill-opacity', (hits.found > 0 && hits.found === hits.total) ? 0.45 : 0.22)
-                .style('stroke', foundColor || color)
-                .style('stroke-width', foundColor ? 1.5 : 1)
+                .style('fill', full ? mark : color)
+                .style('fill-opacity', full ? 0.45 : 0.22)
+                .style('stroke', mark || color)
+                .style('stroke-width', mark ? 1.5 : 1)
                 .style('stroke-opacity', 0.9)
                 .style('stroke-linejoin', 'round');
         });
         label.each(function (d) {
-            let base = collapsedBase(d);
-            let hits = collapsedFoundCounts(d);
-            let allFound = hits.found > 0 && hits.found === hits.total;
-            let ink = allFound ? getFoundColor(forester.getAllExternalNodes(d).filter(isNodeFound)[0]) : _state.labelColorDefault;
+            let far = collapsedReach(d)[1];   // the label clears the farthest tip
+            let allFound = collapsedFullyMarked(d);
+            let ink = allFound ? collapsedMarkColor(d) : _state.labelColorDefault;
             let t = d3.select(this)
                 .text(collapsedLabel(d))
                 .style('font', (allFound ? '600 ' : '') + fs + 'px ' + FONT_DEFAULTS)
                 .style('fill', ink)
                 .style('pointer-events', 'none');
-            if (radialDisplay()) {
-                let r = radialRadius(base) - radialRadius(d.y) + _state.nodeLabelGap;
-                let flip = labelFlip(d);
+            // placed exactly as a tip's label is (update's text.extlabel): on
+            // the common ring in circular, rotated along the spoke or upright;
+            // on the label column in the aligned phylogram; else just past the
+            // wedge, where a tip's label sits past its tip
+            let gap = _state.nodeLabelGap;
+            let flip = radialDisplay() && labelFlip(d);
+            if (_state.circularDisplay && _radial) {
+                t.attr('text-anchor', flip ? 'end' : 'start')
+                    .attr('x', flip ? -gap : gap).attr('dy', '0.32em');
+                if (_radialLabelsHorizontal) {
+                    let p = radialXY(d.x, d.y);
+                    let q = polarXY(radialAngle(d.x), _radial.maxRad);
+                    t.attr('transform', 'translate(' + (q[0] - p[0]) + ',' + (q[1] - p[1]) + ')');
+                } else {
+                    let off = _radial.maxRad - radialRadius(d.y);
+                    t.attr('transform', 'rotate(' + labelAngleDeg(d) + ') translate(' + off + ',0)' + (flip ? ' rotate(180)' : ''));
+                }
+            } else if (radialDisplay()) {
+                let r = radialRadius(far) - radialRadius(d.y) + gap;
                 t.attr('transform', 'rotate(' + labelAngleDeg(d) + ') translate(' + r + ',0)' + (flip ? ' rotate(180)' : ''))
                     .attr('text-anchor', flip ? 'end' : 'start')
                     .attr('x', 0).attr('dy', '0.32em');
             } else {
+                let column = (_state.phylogram && _state.alignPhylogram) ? _w : far;
                 t.attr('transform', null)
                     .attr('text-anchor', 'start')
-                    .attr('x', base - d.y + _state.nodeLabelGap)
+                    .attr('x', column - d.y + gap)
                     .attr('dy', (0.3 * fs) + 'px');
             }
         });
@@ -7236,7 +7273,9 @@ function (root, d3, forester, phyloXml) {
         }
         if (s.root === 'midpoint' && _viewOps.root !== 'midpoint'
             && (_treeData.rerootable === undefined || _treeData.rerootable === true)) {
-            forester.midpointRoot(_root_const);
+            rerootKeepingCollapse(function () {
+                forester.midpointRoot(_root_const);
+            });
             _viewOps.root = 'midpoint';
         }
         if (s.order === 'asc' || s.order === 'desc') {
@@ -8779,7 +8818,9 @@ function (root, d3, forester, phyloXml) {
             showNodeMenu([
                 {
                     label: 'Midpoint re-root', action: function () {
-                        forester.midpointRoot(_root);
+                        rerootKeepingCollapse(function () {
+                            forester.midpointRoot(_root);
+                        });
                         _viewOps.root = 'midpoint';   // what a shared view replays
                         zoomToFit();
                     }

package/forester.js

@@ -20,7 +20,7 @@
  *
  */
 
-// v 3.4.0
+// v 3.4.1
 // 2026-09-10
 //
 // forester.js is a general suite for dealing with phylogenetic trees.
@@ -3978,6 +3978,98 @@
     // becomes "meta:" plus the header with its whitespace as '_' -- the
     // display name prettifies that back to spaces, so "Collection Date"
     // stays "Collection Date" in every menu.
+    // The tips' data as a table, one row per tip in the order given, header
+    // first: what the node menu's "Download Ext. Node Data" writes. The
+    // columns and their names are the desktop's (NodeDataExporter.toNodeDataTsv),
+    // so the two programs write the same table: name (always), the first
+    // taxonomy's scientific name, common name, code, id and rank, the first
+    // sequence's name, gene name, symbol, accession and type, the branch
+    // length, then one column per property ref, sorted, holding its first
+    // value. A column no tip has a value for is left out. When the tip names
+    // cannot key the rows (one blank or repeated), a node_id column comes
+    // first, from idOf(tip, index) or the row number. Tabs and line breaks
+    // inside a value become spaces. A property keeps its ref as the header,
+    // so the table joins back onto a tree with joinMetadataTable.
+    forester.externalNodeDataTable = function (tips, idOf) {
+        tips = tips || [];
+        if (tips.length === 0) {
+            return {columns: [], rows: []};
+        }
+        let clean = function (v) {
+            return (v === undefined || v === null) ? '' : String(v).replace(/[\t\n\r]/g, ' ');
+        };
+        let tax = function (n) {
+            return (n.taxonomies && n.taxonomies[0]) || {};
+        };
+        let seq = function (n) {
+            return (n.sequences && n.sequences[0]) || {};
+        };
+        let cols = [];
+        let add = function (name, extract, force) {
+            let vals = tips.map(function (n, i) {
+                return clean(extract(n, i));
+            });
+            if (force || vals.some(function (v) { return v.length > 0; })) {
+                cols.push({name: name, vals: vals});
+            }
+        };
+        let seen = new Set();
+        let unique = tips.every(function (n) {
+            if (!n.name || seen.has(n.name)) {
+                return false;
+            }
+            seen.add(n.name);
+            return true;
+        });
+        if (!unique) {
+            add('node_id', function (n, i) { return idOf ? idOf(n, i) : i + 1; }, true);
+        }
+        add('name', function (n) { return n.name; }, true);
+        add('taxonomy_scientific_name', function (n) { return tax(n).scientific_name; });
+        add('taxonomy_common_name', function (n) { return tax(n).common_name; });
+        add('taxonomy_code', function (n) { return tax(n).code; });
+        add('taxonomy_id', function (n) { return tax(n).id && tax(n).id.value; });
+        add('taxonomy_rank', function (n) { return tax(n).rank; });
+        add('sequence_name', function (n) { return seq(n).name; });
+        add('gene_name', function (n) { return seq(n).gene_name; });
+        add('sequence_symbol', function (n) { return seq(n).symbol; });
+        add('sequence_accession', function (n) { return seq(n).accession && seq(n).accession.value; });
+        add('sequence_type', function (n) { return seq(n).type; });
+        add('branch_length', function (n) { return (typeof n.branch_length === 'number') ? n.branch_length : ''; });
+        let refs = new Set();
+        tips.forEach(function (n) {
+            (n.properties || []).forEach(function (p) {
+                if (p.ref) {
+                    refs.add(p.ref);
+                }
+            });
+        });
+        Array.from(refs).sort().forEach(function (ref) {
+            add(ref, function (n) {
+                let p = (n.properties || []).filter(function (q) { return q.ref === ref; })[0];
+                return p ? p.value : '';
+            });
+        });
+        return {
+            columns: cols.map(function (c) { return c.name; }),
+            rows: tips.map(function (n, i) {
+                return cols.map(function (c) { return c.vals[i]; });
+            })
+        };
+    };
+
+    // externalNodeDataTable as tab-separated text, header line first; empty
+    // for no tips.
+    forester.externalNodeDataTsv = function (tips, idOf) {
+        let t = forester.externalNodeDataTable(tips, idOf);
+        if (t.columns.length === 0) {
+            return '';
+        }
+        return [t.columns].concat(t.rows).map(function (r) {
+            return r.join('\t');
+        }).join('\n') + '\n';
+    };
+
     forester.metadataColumnRef = function (header, index) {
         let h = String(header || '').trim();
         if (h.length === 0) {
@@ -4135,7 +4227,13 @@
     const SEARCH_DOMAIN = textField('Domain', n => searchSeqs(n).reduce((a, s) => a.concat((s.domain_architecture && s.domain_architecture.domains) ? s.domain_architecture.domains.map(d => d.name) : []), []).filter(Boolean));
     const SEARCH_ANNOTATION = textField('Annotation', n => searchSeqs(n).reduce((a, s) => a.concat((s.annotations || []).reduce((b, an) => b.concat([an.desc, an.ref]), [])), []).filter(Boolean), {anyText: true});
     const SEARCH_CROSS_REFERENCE = textField('Cross-Reference', n => searchSeqs(n).reduce((a, s) => a.concat((s.cross_references || []).reduce((b, x) => b.concat([x.value, x.source, x.comment]), [])), []).filter(Boolean), {anyText: true});
-    const SEARCH_MOLECULAR_SEQUENCE = textField('Molecular Sequence', n => searchSeqs(n).map(s => s.mol_seq).filter(Boolean), {suggest: false});
+    // The residues: the phyloXML and Nexus readers give mol_seq as {value,
+    // is_aligned}, and a hand-built tree may carry the plain string. Reading
+    // the object itself compared every query against "[object Object]", so
+    // this field never matched a real file (its test built the string form).
+    const SEARCH_MOLECULAR_SEQUENCE = textField('Molecular Sequence', n => searchSeqs(n).map(function (s) {
+        return (s.mol_seq && typeof s.mol_seq === 'object') ? s.mol_seq.value : s.mol_seq;
+    }).filter(Boolean), {suggest: false});
     // in menu order
     const SEARCH_TEXT_FIELDS = [
         SEARCH_NODE_NAME, SEARCH_TAXONOMY_SCIENTIFIC_NAME, SEARCH_TAXONOMY_COMMON_NAME, SEARCH_TAXONOMY_CODE,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "archaeopteryx",
-  "version": "3.4.0",
+  "version": "3.4.1",
   "description": "Archaeopteryx.js is a software tool for the visualization and analysis of highly annotated phylogenetic trees.",
   "main": "archaeopteryx.js",
   "types": "archaeopteryx.d.ts",