archaeopteryx 3.4.0 → 3.5.0

package/archaeopteryx.js

@@ -20,7 +20,7 @@
  *
  */
 
-// v 3.4.0
+// v 3.5.0
 // 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.5.0';
     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';
@@ -350,6 +350,7 @@ function (root, d3, forester, phyloXml) {
     const CLADOGRAM_BUTTON = 'cla_b';
     const CONFIDENCE_VALUES_CB = 'conf_cb';
     const SUPPORT_DOTS_CB = 'suppdots_cb';
+    const MAD_VALUES_CB = 'mad_cb';
     const DOWNLOAD_BUTTON = 'dl_b';
     const DYNAHIDE_CB = 'dynahide_cb';
     const MSA_CB = 'msa_cb';
@@ -371,6 +372,7 @@ function (root, d3, forester, phyloXml) {
     const INTERNAL_LABEL_CB = 'intl_cb';
     const LABEL_COLOR_SELECT_MENU = 'lcs_menu';
     const MIDPOINT_ROOT_BUTTON = 'midpointr_b';
+    const MAD_CITATION = 'Tria F, Landan G, Dagan T. Phylogenetic rooting using minimal ancestor deviation. Nature Ecology and Evolution. 2017;1:0193';
     const UNCOLLAPSE_ALL_BUTTON = 'uncollapse_all_b';
     const TREE_PREV_BUTTON = 'tree_prev_b';
     const TREE_NEXT_BUTTON = 'tree_next_b';
@@ -559,6 +561,7 @@ function (root, d3, forester, phyloXml) {
     const HPD_BAR_COLOR = 'rgba(70,130,220,0.35)';    // translucent blue, FigTree-like
     const FOSSIL_BAR_COLOR = 'rgba(150,100,55,0.86)'; // opaque-ish sepia
     let _timeInfo = null;                 // forester.timeAxisInfo, recomputed per render
+    let _timeTree = false;                // forester.isTimeTree: never re-rooted
     let _clusterH = 0;                    // the cluster layout's vertical extent, set per render
     let _docListenersBound = false;       // page-level key/wheel handlers bind once, not per launch
     let _docListeners = [];               // ...and destroy() can take every one of them down again
@@ -1147,12 +1150,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});
                 }
@@ -1462,9 +1465,19 @@ function (root, d3, forester, phyloXml) {
                 menu.appendChild(document.createElement('hr'));
                 return;
             }
+            if (item.note) {   // a sentence to read before choosing, such as a warning
+                let note = document.createElement('div');
+                note.className = 'aptx-node-menu-note';
+                note.textContent = item.note;
+                menu.appendChild(note);
+                return;
+            }
             let b = document.createElement('button');
             b.type = 'button';
             b.textContent = item.label;
+            if (item.title) {
+                b.title = item.title;
+            }
             if (item.danger) {
                 b.className = 'aptx-menu-danger';
             }
@@ -1997,6 +2010,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 +2772,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 +2799,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 +3175,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)
@@ -3186,7 +3213,7 @@ function (root, d3, forester, phyloXml) {
         if (_state.showBranchLengthValues) {
             nodeChild('text.bllabel').text(makeBranchLengthLabel);
         }
-        if (_state.showConfidenceValues) {
+        if (_state.showConfidenceValues || _state.showMadValues) {
             nodeChild('text.conflabel').text(makeConfidenceValuesLabel);
         }
         if (_state.showBranchEvents) {
@@ -3303,43 +3330,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 +3612,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 +3663,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]);
                     }
@@ -3752,7 +3824,7 @@ function (root, d3, forester, phyloXml) {
 
     function syncOptionalNodeChildren(node) {
         let wantBl = _state.showBranchLengthValues === true;
-        let wantConf = _state.showConfidenceValues === true;
+        let wantConf = _state.showConfidenceValues === true || _state.showMadValues === true;
         let wantEvent = _state.showBranchEvents === true;
         let wantDot = _state.showSupportDots === true;
 
@@ -4021,39 +4093,32 @@ function (root, d3, forester, phyloXml) {
         }
     };
 
+    // A branch's values as "MAD/support", as the desktop writes them: the MAD
+    // value (from MAD rooting, to two decimals, 0 included -- low is good)
+    // while MAD Values is on, then the support values while Confidence is on,
+    // those only when one reaches the minimum. A MAD value is never support.
     let makeConfidenceValuesLabel = function (phynode) {
-        if (phynode.confidences && phynode.confidences.length > 0) {
-            let c = phynode.confidences;
-            let cl = c.length;
-            if (_state.minConfidenceValueToShow) {
-                let show = false;
-                for (let i = 0; i < cl; ++i) {
-                    if (c[i].value >= _state.minConfidenceValueToShow) {
-                        show = true;
-                        break;
-                    }
-                }
-                if (!show) {
-                    return;
-                }
+        if (!phynode.confidences || phynode.confidences.length === 0) {
+            return;
+        }
+        let parts = [];
+        let support = [];
+        phynode.confidences.forEach(function (c) {
+            if (c.type !== forester.MAD_CONFIDENCE_TYPE) {
+                support.push(c);
+            } else if (_state.showMadValues && typeof c.value === 'number' && isFinite(c.value)) {
+                parts.push(+c.value.toFixed(2));
             }
-            if (cl === 1) {
-                if (c[0].value) {
-                    return +c[0].value.toFixed(CONFIDENCE_VALUE_DIGITS_DEFAULT);
-                }
-            } else {
-                let s = "";
-                for (let ii = 0; ii < cl; ++ii) {
-                    if (c[ii].value) {
-                        if (ii > 0) {
-                            s += "/";
-                        }
-                        s += +c[ii].value.toFixed(CONFIDENCE_VALUE_DIGITS_DEFAULT);
-                    }
+        });
+        if (_state.showConfidenceValues && support.length > 0
+            && (!_state.minConfidenceValueToShow || support.some(function (c) { return c.value >= _state.minConfidenceValueToShow; }))) {
+            support.forEach(function (c) {
+                if (c.value) {
+                    parts.push(+c.value.toFixed(CONFIDENCE_VALUE_DIGITS_DEFAULT));
                 }
-                return s;
-            }
+            });
         }
+        return parts.length > 0 ? parts.join('/') : undefined;
     };
 
     let makeBranchEventsLabel = function (phynode) {
@@ -4114,12 +4179,23 @@ function (root, d3, forester, phyloXml) {
         return (branchWidth + SUPPORT_DOT_EXTRA_DIAMETER) / 2;
     }
 
+    // A branch's first confidence that is support: a MAD value (MAD rooting)
+    // rates a root position, not the clade.
+    function firstSupportValue(d) {
+        for (let i = 0; i < d.confidences.length; ++i) {
+            if (d.confidences[i].type !== forester.MAD_CONFIDENCE_TYPE) {
+                return d.confidences[i].value;
+            }
+        }
+        return undefined;
+    }
+
     function showSupportDot(d) {
         if (!_state.showSupportDots || !d.parent
             || !d.confidences || d.confidences.length === 0) {
             return false;
         }
-        let v = d.confidences[0].value;
+        let v = firstSupportValue(d);
         if (typeof v !== 'number' || !isFinite(v) || v < supportDotThreshold()) {
             return false;
         }
@@ -4704,6 +4780,7 @@ function (root, d3, forester, phyloXml) {
         // elements by forester.timeAxisInfo -- again unless the caller set
         // showTimeAxis explicitly.
         _timeInfo = _treeData ? forester.timeAxisInfo(forester.getTreeRoot(_treeData)) : null;
+        _timeTree = _treeData ? forester.isTimeTree(_treeData) : false;
         if (_state.showTimeAxis === undefined) {
             _state.showTimeAxis = !!(_timeInfo && _timeInfo.type);
         }
@@ -5412,6 +5489,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 +5652,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';
-                }
-
-                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';
-                    }
+                    filename = 'External_Node_Data_for_' + ext_nodes.length + '_Nodes.tsv';
                 }
-
-                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();
             }
 
@@ -5927,9 +5895,25 @@ function (root, d3, forester, phyloXml) {
                     update(null, 0);
                 }});
             }
-            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(); }});
+            if (!_in_subtree && d.parent && d.parent.parent) {
+                let blocked = rerootBlockedReason();
+                if (blocked) {
+                    // offered but greyed, saying why, as the desktop does
+                    items.push({label: 'Reroot', disabled: true, title: blocked, action: function () {
+                    }});
+                } else {
+                    items.push({label: 'Reroot', action: function () {
+                        confirmRerooting(tree, 'node', d, event, function () {
+                            rerootKeepingCollapse(function () {
+                                forester.removeMadConfidences(tree);   // they rate the MAD rooting only
+                                forester.reRoot(tree, d, -1);
+                            });
+                            _basicTreeProperties = forester.collectBasicTreeProperties(_root);
+                            syncMadValuesCheckbox();
+                            zoomToFit();
+                        });
+                    }});
+                }
             }
             if (_settings.enableManualNodeSelection) {
                 items.push({label: 'Select/Deselect Node', action: function () { selectDeselectNode(d); }});
@@ -6848,6 +6832,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 +6841,7 @@ function (root, d3, forester, phyloXml) {
             n.collapsed = false;
         });
         calcMaxExtLabel();
+        refreshVisualizations(false);
         scheduleUpdate(null, 0);
     }
 
@@ -6871,6 +6857,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 +6939,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 +7004,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 +7048,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');
             }
         });
@@ -7069,6 +7135,7 @@ function (root, d3, forester, phyloXml) {
         ['taxonomy', TAXONOMY_CB, 'showTaxonomy'],
         ['sequence', SEQUENCE_CB, 'showSequence'],
         ['confidence', CONFIDENCE_VALUES_CB, 'showConfidenceValues'],
+        ['madValues', MAD_VALUES_CB, 'showMadValues'],
         ['branchLength', BRANCH_LENGTH_VALUES_CB, 'showBranchLengthValues'],
         ['external', EXTERNAL_LABEL_CB, 'showExternalLabels'],
         ['internal', INTERNAL_LABEL_CB, 'showInternalLabels'],
@@ -7234,10 +7301,9 @@ function (root, d3, forester, phyloXml) {
             launchInto(_container, _trees, s.tree, cfg);
             return;
         }
-        if (s.root === 'midpoint' && _viewOps.root !== 'midpoint'
-            && (_treeData.rerootable === undefined || _treeData.rerootable === true)) {
-            forester.midpointRoot(_root_const);
-            _viewOps.root = 'midpoint';
+        if ((s.root === 'midpoint' || s.root === 'mad') && _viewOps.root !== s.root
+            && rerootingAllowed()) {
+            rootTreeBy(s.root);
         }
         if (s.order === 'asc' || s.order === 'desc') {
             ladderizeSubtree(_root_const, s.order === 'asc', false);
@@ -7270,6 +7336,9 @@ function (root, d3, forester, phyloXml) {
         if (s.layout === 'rectangular' || s.layout === 'circular' || s.layout === 'unrooted') {
             _state.circularDisplay = s.layout === 'circular';
             _state.unrootedDisplay = s.layout === 'unrooted';
+            if (_treeData && _treeData.rooted === false && byId(SEARCH_FIELD_SELECT_0)) {
+                populateSearchMenus();   // before the view's searches pick their fields
+            }
         }
         if (s.display === 'phylogram' || s.display === 'aligned' || s.display === 'cladogram') {
             let measured = _basicTreeProperties.branchLengths === true;
@@ -8762,11 +8831,86 @@ function (root, d3, forester, phyloXml) {
         }
     }
 
-    // Midpoint re-rooting rearranges the whole tree and its button is easy to
-    // hit by accident, so it asks first -- through the same little popup the
-    // node menu uses (click anywhere else or press Esc to cancel).
+    // Why the tree cannot be re-rooted, or null when it can. Every way of
+    // re-rooting asks -- the re-root button and its menu, the node menu's
+    // Reroot, a shared view's root: never a tree its file marks
+    // rerootable="false", never a time tree. The reason is the greyed
+    // controls' tooltip, as on the desktop.
+    function rerootBlockedReason() {
+        if (!_treeData) {
+            return 'no tree';
+        }
+        if (_treeData.rerootable === false) {
+            return 'This tree is marked as not re-rootable (rerootable="false").';
+        }
+        if (_timeTree) {
+            return 'Time trees can\'t be re-rooted: their branch lengths are times measured from this root.';
+        }
+        return null;
+    }
+
+    function rerootingAllowed() {
+        return rerootBlockedReason() === null;
+    }
+
+    // MAD rooting needs branch lengths, three tips, and a tree that may be
+    // re-rooted at all.
+    function madRootingPossible() {
+        return rerootingAllowed()
+            && !!_basicTreeProperties && !!_basicTreeProperties.branchLengths
+            && _basicTreeProperties.externalNodesCount >= 3;
+    }
+
+    // Roots the whole tree by 'mad' or 'midpoint', from the re-root menu or a
+    // shared view. MAD values rate the MAD rooting only, so any other rooting
+    // removes them.
+    function rootTreeBy(method) {
+        let rooted = true;
+        rerootKeepingCollapse(function () {
+            if (method === 'mad') {
+                rooted = forester.madRoot(_root_const);
+            } else {
+                forester.removeMadConfidences(_root_const);
+                forester.midpointRoot(_root_const);
+            }
+        });
+        if (rooted) {
+            _viewOps.root = method;   // what a shared view replays
+        }
+        _basicTreeProperties = forester.collectBasicTreeProperties(_root_const);
+        syncMadValuesCheckbox();
+    }
+
+    // Before a re-root from the panel or the node menu (a shared view never
+    // asks: whoever shared it chose): when it would change the clade of
+    // internal nodes carrying data, say so where the choice was made, and
+    // re-root only on "Re-root". Otherwise re-root at once.
+    function confirmRerooting(phy, method, node, anchor, proceed) {
+        let effect = forester.cladesChangedByRerooting(phy, method, node);
+        let k = effect.changed.length;
+        if (k === 0) {
+            proceed();
+            return;
+        }
+        let n = effect.annotated.length;
+        let text = (n === 1)
+            ? 'This tree has data on 1 internal node. Re-rooting changes its clade, so its data may no longer describe it.'
+            : 'This tree has data on ' + n + ' internal nodes. Re-rooting changes the clade of ' + k + ' of them, so '
+            + (k === 1 ? 'its data may no longer describe it.' : 'their data may no longer describe them.');
+        showNodeMenu([
+            {note: text},
+            {label: 'Re-root', action: proceed},
+            {label: 'Cancel', action: function () {
+            }}
+        ], anchor, 'Re-root tree');
+    }
+
+    // Re-rooting rearranges the whole tree and its button is easy to hit by
+    // accident, so it asks first -- through the same little popup the node
+    // menu uses (click anywhere else or press Esc to cancel) -- and the popup
+    // is where the method is picked.
     function midpointRootButtonPressed(event) {
-        if (!_in_subtree && _root && ((_treeData.rerootable === undefined) || (_treeData.rerootable === true))) {
+        if (!_in_subtree && _root && rerootingAllowed()) {
             let ev = event;
             if (!ev || ev.pageX === undefined || (ev.pageX === 0 && ev.pageY === 0)) {
                 // keyboard/synthetic invocation: anchor the popup at the button
@@ -8776,19 +8920,30 @@ function (root, d3, forester, phyloXml) {
                     ev = {pageX: window.scrollX + r.right + 4, pageY: window.scrollY + r.top};
                 }
             }
-            showNodeMenu([
-                {
-                    label: 'Midpoint re-root', action: function () {
-                        forester.midpointRoot(_root);
-                        _viewOps.root = 'midpoint';   // what a shared view replays
-                        zoomToFit();
-                    }
-                },
-                {
-                    label: 'Cancel', action: function () {
+            let items = [];
+            if (madRootingPossible()) {
+                items.push({
+                    label: 'MAD re-root (Tria et al., 2017)', title: MAD_CITATION, action: function () {
+                        confirmRerooting(_root_const, 'mad', null, ev, function () {
+                            rootTreeBy('mad');
+                            zoomToFit();
+                        });
                     }
+                });
+            }
+            items.push({
+                label: 'Midpoint re-root', action: function () {
+                    confirmRerooting(_root_const, 'midpoint', null, ev, function () {
+                        rootTreeBy('midpoint');
+                        zoomToFit();
+                    });
                 }
-            ], ev, 'midpoint re-root the tree?');
+            });
+            items.push({
+                label: 'Cancel', action: function () {
+                }
+            });
+            showNodeMenu(items, ev, 're-root the tree?');
         }
     }
 
@@ -8993,7 +9148,11 @@ function (root, d3, forester, phyloXml) {
     // then set up each box's mode menu. Called when a tree is (re)loaded.
     function populateSearchMenus() {
         let before = _searchFields;
-        _searchFields = forester.availableSearchFields(_root);
+        // an unrooted tree in the unrooted layout has no root to measure from
+        let rootMeasured = [forester.searchFields.depth, forester.searchFields.distanceFromRoot, forester.searchFields.cladeSize];
+        _searchFields = forester.availableSearchFields(_root).filter(function (f) {
+            return !unrootedContext() || rootMeasured.indexOf(f) < 0;
+        });
         [SEARCH_FIELD_SELECT_0, SEARCH_FIELD_SELECT_1].forEach(function (selId) {
             let sel = byId(selId);
             if (!sel) return;
@@ -9328,6 +9487,11 @@ function (root, d3, forester, phyloXml) {
     function layoutButtonClicked() {
         _state.circularDisplay = getCheckboxValue(LAYOUT_CIRC_BUTTON);
         _state.unrootedDisplay = getCheckboxValue(LAYOUT_UNROOTED_BUTTON);
+        if (_treeData && _treeData.rooted === false) {
+            populateSearchMenus();   // the root-measured search fields go and come with the unrooted layout
+            search0();
+            search1();
+        }
         if (radialDisplay() && _state.showDomainArchitectures && _basicTreeProperties.domainArchitectures) {
             // the domain boxes ride the tips' spokes, so the labels must too
             _radialLabelsHorizontal = false;
@@ -9488,6 +9652,31 @@ function (root, d3, forester, phyloXml) {
         scheduleUpdate();
     }
 
+    function madValuesCbClicked() {
+        _state.showMadValues = getCheckboxValue(MAD_VALUES_CB);
+        scheduleUpdate();
+    }
+
+    // The MAD Values checkbox is built for every tree MAD rooting could root
+    // and shows while the tree carries MAD values: after MAD rooting, or from
+    // a file saved after it. Any other rooting removes the values, and the
+    // checkbox goes with them. Inside a subtree the whole tree's state stands.
+    function syncMadValuesCheckbox() {
+        let cb = byId(MAD_VALUES_CB);
+        if (!cb || _in_subtree) {
+            return;
+        }
+        let present = !!(_basicTreeProperties && _basicTreeProperties.madValues);
+        if (!present) {
+            _state.showMadValues = false;
+        }
+        setCheckboxValue(MAD_VALUES_CB, _state.showMadValues === true);
+        let item = cb.closest('label');
+        if (item) {
+            item.style.display = present ? '' : 'none';
+        }
+    }
+
     function branchLengthsCbClicked() {
         _state.showBranchLengthValues = getCheckboxValue(BRANCH_LENGTH_VALUES_CB);
         scheduleUpdate();
@@ -10208,6 +10397,7 @@ function (root, d3, forester, phyloXml) {
             + '.aptx-node-menu button.aptx-menu-danger:hover, .aptx-node-menu button.aptx-menu-danger:focus-visible {'
             + '  background:#e5484d; color:#fff; }'
             + '.aptx-node-menu hr { border:0; border-top:1px solid var(--p-line); margin:3px 4px; }'
+            + '.aptx-node-menu-note { padding:4px 9px 7px; color:var(--p-ink); white-space:normal; }'
             // The search suggestions: the node menu's chrome under the value box.
             + '.aptx-suggest { position:absolute; z-index:1000; max-width:320px; padding:4px; box-sizing:border-box;'
             + '  border:1px solid var(--p-line-strong); border-radius:10px; background:var(--p-bg); color:var(--p-ink);'
@@ -10690,6 +10880,32 @@ function (root, d3, forester, phyloXml) {
     // Content arrives as "Label: value" lines separated by <br>. Setting the
     // label part apart makes a wall of such lines scannable. Lines without a
     // label (a heading like "Taxonomy", or a FASTA sequence) are left alone.
+    // The unrooted layout of a tree its file declares unrooted (phyloXML
+    // rooted="false", Nexus [&U]; a plain Newick tree declares nothing). The
+    // unrooted layout of a rooted tree still has its root.
+    function unrootedContext() {
+        return _state.unrootedDisplay === true && !!_treeData && _treeData.rooted === false;
+    }
+
+    // The tips on each side of an internal node of an unrooted tree, one
+    // count per neighbour, smallest first: what "tips below" becomes when
+    // there is no below.
+    function tipsAround(d) {
+        let sides = d.children.map(function (c) {
+            return forester.calcSumOfAllExternalDescendants(c);
+        });
+        let below = sides.reduce(function (a, b) {
+            return a + b;
+        }, 0);
+        let all = forester.calcSumOfAllExternalDescendants(forester.getTreeRoot(_treeData));
+        if (all > below) {
+            sides.push(all - below);
+        }
+        return sides.sort(function (a, b) {
+            return a - b;
+        });
+    }
+
     // The node's data as the hover tooltip and the "Display Node Data" dialog
     // both show it -- ONE builder, because they used to be two near-copies
     // and carried the same two bugs twice (a bare "Date: " line whenever a
@@ -10703,13 +10919,19 @@ function (root, d3, forester, phyloXml) {
     // the section above it. markUpDataLabels() renders the result: a line
     // shaped "Key: value" is a row, anything else a heading, and a leading
     // "- " marks a row as a section's sub-entry.
+    //
+    // A tree its file declares unrooted, shown in the unrooted layout, has no
+    // root to measure from (unrootedContext): an internal node shows no
+    // distance to parent, depth or tips below but the tips on each of its
+    // sides, and a tip's branch is just its branch length -- as on the desktop.
     function nodeDataText(d) {
         let text = '';
+        let unrooted = unrootedContext();
         if (d.name) {
             text += 'Name: ' + d.name + '<br>';
         }
-        if (d.branch_length) {
-            text += 'Distance to parent: ' + d.branch_length + '<br>';
+        if (d.branch_length && !(unrooted && d.children)) {
+            text += (unrooted ? 'Branch length: ' : 'Distance to parent: ') + d.branch_length + '<br>';
         }
         let date = dateText(d.date);
         if (date) {
@@ -10723,9 +10945,13 @@ function (root, d3, forester, phyloXml) {
                 }
             }
         }
-        text += 'Depth: ' + forester.calcDepth(d) + '<br>';
-        if (d.children) {
-            text += 'Tips below: ' + forester.calcSumOfAllExternalDescendants(d) + '<br>';
+        if (!unrooted) {
+            text += 'Depth: ' + forester.calcDepth(d) + '<br>';
+            if (d.children) {
+                text += 'Tips below: ' + forester.calcSumOfAllExternalDescendants(d) + '<br>';
+            }
+        } else if (d.children) {
+            text += 'Tips around: ' + tipsAround(d).join(' · ') + '<br>';
         }
         if (d.confidences) {
             for (let i = 0; i < d.confidences.length; ++i) {
@@ -11318,6 +11544,7 @@ function (root, d3, forester, phyloXml) {
 
         on(CONFIDENCE_VALUES_CB, 'click', confidenceValuesCbClicked);
         on(SUPPORT_DOTS_CB, 'click', supportDotsCbClicked);
+        on(MAD_VALUES_CB, 'click', madValuesCbClicked);
         on(SEARCH_B_TOGGLE, 'click', revealSearchB);
         on(SEARCH_NAV_PREV, 'click', function () {
             stepToFoundNode(-1);
@@ -11826,6 +12053,9 @@ function (root, d3, forester, phyloXml) {
             if (_basicTreeProperties.confidences) {
                 labels.push(makeCheckboxItem('Confidence', CONFIDENCE_VALUES_CB, 'to show/hide confidence values'));
             }
+            if (_basicTreeProperties.madValues || madRootingPossible()) {
+                labels.push(makeCheckboxItem('MAD Values', MAD_VALUES_CB, 'to show/hide MAD values: the ancestor deviation were the root on that branch (lower is better, the root branch has the smallest)'));
+            }
             if (_basicTreeProperties.branchLengths) {
                 labels.push(makeCheckboxItem('Branch Length', BRANCH_LENGTH_VALUES_CB, 'to show/hide branch length values'));
             }
@@ -11914,7 +12144,7 @@ function (root, d3, forester, phyloXml) {
             h = h.concat(makeGlyphButton('whole_tree', RETURN_TO_SUPERTREE_BUTTON, 'return all the way to the complete tree (if in a sub-tree)'));
             h = h.concat(makeGlyphButton('up_one_level', RETURN_TO_SUPERTREE_BUTTON_BY_ONE, 'move up by one level towards the complete tree (if in a sub-tree)'));
             h = h.concat(makeGlyphButton('uncollapse_all', UNCOLLAPSE_ALL_BUTTON, 'uncollapse all'));
-            h = h.concat(makeGlyphButton('midpoint', MIDPOINT_ROOT_BUTTON, 'midpoint re-root'));
+            h = h.concat(makeGlyphButton('midpoint', MIDPOINT_ROOT_BUTTON, 're-root the tree: MAD or midpoint'));
             h = h.concat('</div>');
             h = h.concat('</fieldset>');
             return h;
@@ -12149,6 +12379,7 @@ function (root, d3, forester, phyloXml) {
         setCheckboxValue(SEQUENCE_CB, _state.showSequence)
         setCheckboxValue(CONFIDENCE_VALUES_CB, _state.showConfidenceValues);
         setCheckboxValue(SUPPORT_DOTS_CB, _state.showSupportDots);
+        syncMadValuesCheckbox();
         setCheckboxValue(BRANCH_LENGTH_VALUES_CB, _state.showBranchLengthValues);
         setCheckboxValue(NODE_EVENTS_CB, _state.showNodeEvents);
         setCheckboxValue(BRANCH_EVENTS_CB, _state.showBranchEvents);
@@ -12267,10 +12498,16 @@ function (root, d3, forester, phyloXml) {
             disableButton(byId(RETURN_TO_SUPERTREE_BUTTON));
         }
 
-        if (!_in_subtree && ((_treeData.rerootable === undefined) || (_treeData.rerootable === true))) {
-            enableButton(byId(MIDPOINT_ROOT_BUTTON));
+        let rerootButton = byId(MIDPOINT_ROOT_BUTTON);
+        let blocked = rerootBlockedReason();
+        if (!_in_subtree && !blocked) {
+            enableButton(rerootButton);
         } else {
-            disableButton(byId(MIDPOINT_ROOT_BUTTON));
+            disableButton(rerootButton);
+        }
+        if (rerootButton) {
+            rerootButton.title = blocked
+                || (_in_subtree ? 'return to the whole tree to re-root it' : 're-root the tree: MAD or midpoint');
         }
         let b;
         if (_foundNodes0 && !_searchBox0Empty) {