archaeopteryx 3.4.1 → 3.5.1

package/README.md

@@ -27,6 +27,7 @@ config key live and shows the exact config JSON to copy into your own
 * [Auspice / Nextstrain JSON](https://cmzmasek.github.io/archaeopteryx-js/demo.html?tree=auspice)
 * [Swine H1 HA1 + alignment (Nexus)](https://cmzmasek.github.io/archaeopteryx-js/demo.html?tree=swh1)
 * [BEAST annotations (Nexus)](https://cmzmasek.github.io/archaeopteryx-js/demo.html?tree=beast)
+* [Flavivirus mature peptides (10 trees)](https://cmzmasek.github.io/archaeopteryx-js/demo.html?tree=flavivirus)
 * [SARS-CoV-2 time tree (calendar)](https://cmzmasek.github.io/archaeopteryx-js/demo.html?tree=sarscov2)
 * [Herpesviridae DNA polymerase (201 tips)](https://cmzmasek.github.io/archaeopteryx-js/demo.html?tree=herpes_dnapol)
 * [Caliciviridae (186 strains)](https://cmzmasek.github.io/archaeopteryx-js/demo.html?tree=caliciviridae_500)
@@ -257,6 +258,70 @@ also resets rotation and label direction. Unrooted
 additionally greys out the aligned-phylogram option and Auto-hide Labels
 (there is no common label edge, and no even row spacing to hide against).
 
+## Rooting
+
+The tool row's re-root button asks how: **MAD re-root (Tria et al., 2017)**
+or **Midpoint re-root** (hover over the MAD entry for the full citation). A
+node's menu offers **Reroot** on the branch above that node. None of them is
+offered for a tree whose phyloXML says `rerootable="false"`, nor for a time
+tree, one whose internal nodes are mostly dated (BEAST node heights,
+Nextstrain dates, phyloXML `<date>`s): a new root would contradict the dates.
+For such a tree the re-root button and the node menu's Reroot are greyed,
+their tooltip saying why, and a shared view's root is ignored.
+
+A re-root can take the meaning away from data on internal nodes: a node's
+name, taxonomy, sequence, events, distribution, date, references or node
+properties describe its clade, and a new root changes the clade of every
+node between the old root and the new one. So before re-rooting (from the
+button's menu or the node menu), the change is worked out on a copy of the
+tree, and when it would change the clade of any internal node carrying data,
+a warning says how many (“This tree has data on 15 internal nodes.
+Re-rooting changes the clade of 3 of them, so their data may no longer
+describe them.”) with **Re-root** and **Cancel**. Branch lengths, support and
+MAD values, branch colours and `style:` properties do not count: they belong
+to the branch, or to the look.
+
+A tree its file declares unrooted (phyloXML `rooted="false"`, Nexus `[&U]`),
+shown in the unrooted layout, has no root to measure from. There the hover
+card and Display Node Data show an internal node's **Tips around** — the tips
+on each of its sides, smallest first, such as `2 · 3 · 5` — instead of
+distance to parent, depth and tips below; a tip shows its **Branch length**
+and no depth; and the Depth from Root, Distance from Root and Clade Size
+search fields are not offered. The same tree in the rectangular or circular
+layout keeps all of them, since those layouts draw a root.
+
+**MAD rooting** (minimal ancestor deviation) roots the tree without assuming
+a clock. The common ancestor of two tips ought to lie halfway between them,
+so every branch and position is scored by how far the tip pairs' ancestors
+fall from that halfway point, and the root goes where that deviation is
+smallest [1]. It has been compared with other rooting methods on prokaryotic
+gene families [2]. It needs branch lengths and at least three tips, and is
+offered only then. Tip pairs closer than 1/100,000 of the tree's diameter
+(identical sequences, or FastTree's 5 × 10⁻⁹ stand-in for a zero branch) are
+left out of the deviation sums: their deviation measures noise, and summing
+it would swamp the precision of all the others. The algorithm is the desktop
+Archaeopteryx's, and gives the same roots; it runs in O(n²) time and O(n) memory (the 13,246-tip H5N1
+demo tree roots in 0.4 s, measured in Node).
+
+Every internal branch then carries its **MAD value**: the root-mean-square
+deviation the tree would have with the root on that branch. Lower is better,
+and the root's branch has the smallest. The **MAD Values** checkbox (Display
+Data → Labels, present while the tree carries them) writes them on the
+branches, ahead of any support value, as `MAD/support`: `0.02/95`. They are
+not support, so the Confidence labels, Support Dots and the Confidence search
+field leave them out. Midpoint or manual re-rooting removes them, since they
+describe the MAD rooting only. A shared view remembers a MAD root. A phyloXML
+download keeps them as `<confidence type="MAD">`, as the desktop writes them;
+a Newick or Nexus download never puts one where a support value goes.
+
+1. Tria, F.D.K., Landan, G., Dagan, T. (2017). Phylogenetic rooting using
+   minimal ancestor deviation. *Nature Ecology & Evolution*, 1, 0193.
+   <https://www.nature.com/articles/s41559-017-0193>
+2. Wade, T., Rangel, L.T., Kundu, S., Fournier, G.P., Bansal, M.S. (2020).
+   Assessing the accuracy of phylogenetic rooting methods on prokaryotic
+   gene families. *PLOS ONE*, 15(5), e0232950.
+   <https://journals.plos.org/plosone/article?id=10.1371/journal.pone.0232950>
+
 ## Metadata tables
 
 A tree file rarely carries everything known about its tips. A **metadata

package/archaeopteryx.d.ts

@@ -114,15 +114,15 @@ export interface ViewState {
     display?: 'phylogram' | 'aligned' | 'cladogram';
     /** The ladderize direction applied. */
     order?: 'asc' | 'desc';
-    /** Midpoint re-rooted. */
-    root?: 'midpoint';
+    /** Re-rooted: at the midpoint, or by minimal ancestor deviation. */
+    root?: 'midpoint' | 'mad';
     subtree?: number;
     collapsed?: number[];
     /** A visualization id (as the Color-by menu values them), or 'none'. */
     colorBy?: string;
     shapeBy?: string;
     /** The panel's checked boxes: name, taxonomy, sequence, confidence,
-     * branchLength, external, internal, nodeEvents, branchEvents,
+     * madValues, branchLength, external, internal, nodeEvents, branchEvents,
      * supportDots, shortNames, autoHide, visualizations, visualStyles, and
      * custom:<key> for a nodeLabels checkbox. */
     show?: string[];

package/archaeopteryx.js

@@ -20,7 +20,7 @@
  *
  */
 
-// v 3.4.1
+// v 3.5.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.1';
+    const VERSION = '3.5.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';
@@ -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
@@ -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';
             }
@@ -3200,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) {
@@ -3811,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;
 
@@ -4080,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) {
@@ -4173,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;
         }
@@ -4763,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);
         }
@@ -5877,14 +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 () {
-                    rerootKeepingCollapse(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); }});
@@ -7106,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'],
@@ -7271,12 +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)) {
-            rerootKeepingCollapse(function () {
-                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);
@@ -7309,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;
@@ -8801,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
@@ -8815,21 +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 () {
-                        rerootKeepingCollapse(function () {
-                            forester.midpointRoot(_root);
+            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();
                         });
-                        _viewOps.root = 'midpoint';   // what a shared view replays
-                        zoomToFit();
-                    }
-                },
-                {
-                    label: 'Cancel', action: function () {
                     }
+                });
+            }
+            items.push({
+                label: 'Midpoint re-root', action: function () {
+                    confirmRerooting(_root_const, 'midpoint', null, ev, function () {
+                        rootTreeBy('midpoint');
+                        zoomToFit();
+                    });
+                }
+            });
+            items.push({
+                label: 'Cancel', action: function () {
                 }
-            ], ev, 'midpoint re-root the tree?');
+            });
+            showNodeMenu(items, ev, 're-root the tree?');
         }
     }
 
@@ -9034,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;
@@ -9369,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;
@@ -9529,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();
@@ -10249,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);'
@@ -10731,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
@@ -10744,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) {
@@ -10764,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) {
@@ -11359,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);
@@ -11867,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'));
             }
@@ -11955,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;
@@ -12190,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);
@@ -12308,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) {

package/forester.js

@@ -20,7 +20,7 @@
  *
  */
 
-// v 3.4.1
+// v 3.5.1
 // 2026-09-10
 //
 // forester.js is a general suite for dealing with phylogenetic trees.
@@ -252,7 +252,9 @@
         if (!node) {
             throw ("cannot re-root on null node");
         }
-        if (!branchLength) {
+        // no position: the middle of the branch. 0 is a position -- the root
+        // right at the node, where MAD rooting can put it.
+        if (typeof branchLength !== 'number' || isNaN(branchLength)) {
             branchLength = -1;
         }
         if (forester.isString(node)) {
@@ -449,6 +451,544 @@
         }
     };
 
+    /** The confidence type of the per-branch values madRoot records. */
+    forester.MAD_CONFIDENCE_TYPE = 'MAD';
+
+    const MAD_EPSILON = 1e-9;
+    // Tip pairs closer than this share of the tree's diameter are left out of
+    // every sum, like pairs at distance 0. Their 1/d^2 terms (tips 1e-8 apart,
+    // as FastTree's 5e-9 "zero" branches make them, reach 1e16) cancel
+    // catastrophically in the subtractions below and swamp every other pair:
+    // MAD then answered differently from every rooting, and re-rooting moved
+    // the root back and forth. The diameter does not depend on the rooting, so
+    // neither does the cut. Joint with the desktop (Christian, 2026-09-14).
+    const MAD_NEAR_FRACTION = 1e-5;
+
+    /**
+     * Roots the tree by Minimal Ancestor Deviation (Tria, Landan & Dagan,
+     * Nature Ecology & Evolution 1, 0193, 2017; doi:10.1038/s41559-017-0193),
+     * ported from the desktop's PhylogenyMethods.madRoot.
+     *
+     * Under a (relaxed) clock the ancestor of two tips is equidistant from
+     * both; the pair (i,j) with ancestor a deviates by |2*dist(a,i)/dist(i,j) - 1|.
+     * For every branch the root position minimizing the summed squared
+     * deviation of all tip pairs is found analytically, and the branch and
+     * position with the smallest total become the root.
+     *
+     * Every internal branch gets a confidence of type 'MAD': the root-mean-
+     * square deviation were the root placed on that branch -- low is good,
+     * and the root's branch carries the smallest. Pendant branches get none,
+     * and MAD values from an earlier run are replaced.
+     *
+     * Tip pairs closer than 1e-5 of the tree's diameter (identical sequences,
+     * FastTree's 5e-9 "zero" branches) are left out of the deviation sums:
+     * their deviation measures noise, and their terms would swamp the
+     * precision of all the others.
+     *
+     * A no-op for fewer than three tips or a tree without branch lengths.
+     * O(n^2) time and O(n) memory: the desktop fills an n x n distance matrix
+     * only to sum its columns (1.4 GB at 13,000 tips), so the column sums are
+     * added up here as the pairs are met, and a subtree's tips are a range of
+     * tip numbers rather than a list.
+     *
+     * @param phy the tree
+     * @returns {boolean} whether the tree was re-rooted
+     */
+    forester.madRoot = function (phy) {
+        let root = forester.getTreeRoot(phy);
+        if (!root) {
+            return false;
+        }
+        let t = madTraversal(root);
+        let pre = t.pre;
+        let kids = t.kids;
+        let post = t.post;
+        let m = pre.length;
+        let tipNo = new Int32Array(m).fill(-1);
+        let tipPos = [];
+        for (let k = 0; k < m; ++k) {
+            if (kids[k].length === 0) {
+                tipNo[k] = tipPos.length;
+                tipPos.push(k);
+            }
+        }
+        let n = tipPos.length;
+        if (n < 3) {
+            return false;
+        }
+        // depth (distance from the current root) of every node
+        let depth = new Float64Array(m);
+        let maxDepth = 0;
+        for (let k = 1; k < m; ++k) {
+            depth[k] = depth[t.parentOf[k]] + madLength(pre[k]);
+            maxDepth = Math.max(maxDepth, depth[k]);
+        }
+        if (maxDepth <= 0) {
+            return false;   // no usable branch lengths
+        }
+        // the diameter, the longest tip-to-tip path: at every node, its two
+        // longest paths down through different children
+        let longestDown = new Float64Array(m);
+        let diameter = 0;
+        for (let q = 0; q < m; ++q) {
+            let k = post[q];
+            let first = 0;
+            let second = 0;
+            for (let c = 0; c < kids[k].length; ++c) {
+                let path = longestDown[kids[k][c]] + madLength(pre[kids[k][c]]);
+                if (path > first) {
+                    second = first;
+                    first = path;
+                } else if (path > second) {
+                    second = path;
+                }
+            }
+            longestDown[k] = first;
+            diameter = Math.max(diameter, first + second);
+        }
+        let nearEps = Math.max(MAD_EPSILON, MAD_NEAR_FRACTION * diameter);
+        let tipDepth = new Float64Array(n);
+        for (let i = 0; i < n; ++i) {
+            tipDepth[i] = depth[tipPos[i]];
+        }
+        // Pass 1 (post-order): the within-subtree deviation sums, and the
+        // column sums sum_i 1/d^2 and sum_i 1/d of every tip. For a pair whose
+        // common ancestor sits at depth dm, d = depth[i] + depth[j] - 2*dm and
+        // the deviation is 2*(depth[i]-dm)/d - 1.
+        let lo = new Int32Array(m);        // a subtree's tips are the numbers lo..hi-1
+        let hi = new Int32Array(m);
+        let down = new Float64Array(m);    // sum dev^2 over pairs with their ancestor inside the subtree
+        let w0 = new Float64Array(m);      // sum_{i!=j in subtree} 1/d^2                 (ordered)
+        let w1 = new Float64Array(m);      // sum_{i!=j in subtree} (2*depth[j]/d^2 - 1/d) (j second)
+        let w2 = new Float64Array(m);      // sum_{i!=j in subtree} (2*depth[j]/d - 1)^2   (j second)
+        let col0 = new Float64Array(n);
+        let colInv = new Float64Array(n);
+        let partners = new Int32Array(n);   // the tips each tip is counted against (d > nearEps)
+        for (let q = 0; q < m; ++q) {
+            let k = post[q];
+            let ch = kids[k];
+            if (ch.length === 0) {
+                lo[k] = tipNo[k];
+                hi[k] = tipNo[k] + 1;
+                continue;
+            }
+            let dm = depth[k];
+            let dwn = 0, sw0 = 0, sw1 = 0, sw2 = 0;
+            for (let c = 0; c < ch.length; ++c) {
+                dwn += down[ch[c]];
+                sw0 += w0[ch[c]];
+                sw1 += w1[ch[c]];
+                sw2 += w2[ch[c]];
+            }
+            // the pairs whose ancestor is this node: one tip from each of two children
+            for (let a = 0; a < ch.length; ++a) {
+                for (let b = a + 1; b < ch.length; ++b) {
+                    for (let i = lo[ch[a]]; i < hi[ch[a]]; ++i) {
+                        let di = tipDepth[i];
+                        for (let j = lo[ch[b]]; j < hi[ch[b]]; ++j) {
+                            let dj = tipDepth[j];
+                            let dij = (di - dm) + (dj - dm);
+                            if (dij > nearEps) {
+                                let inv = 1.0 / dij;
+                                let inv2 = inv * inv;
+                                let dev = (2.0 * (di - dm) * inv) - 1.0;
+                                dwn += dev * dev;
+                                sw0 += 2.0 * inv2;   // both orderings
+                                sw1 += (2.0 * (di + dj) * inv2) - (2.0 * inv);
+                                let gi = (2.0 * di * inv) - 1.0;
+                                let gj = (2.0 * dj * inv) - 1.0;
+                                sw2 += (gi * gi) + (gj * gj);
+                                col0[i] += inv2;
+                                col0[j] += inv2;
+                                colInv[i] += inv;
+                                colInv[j] += inv;
+                                ++partners[i];
+                                ++partners[j];
+                            }
+                        }
+                    }
+                }
+            }
+            lo[k] = lo[ch[0]];
+            hi[k] = hi[ch[ch.length - 1]];
+            down[k] = dwn;
+            w0[k] = sw0;
+            w1[k] = sw1;
+            w2[k] = sw2;
+        }
+        // Pass 2 (post-order): per-subtree "all-i" sums a0,a1,a2; the cross
+        // sums between a subtree and its complement are then b_k = a_k - w_k.
+        let a0 = new Float64Array(m);
+        let a1 = new Float64Array(m);
+        let a2 = new Float64Array(m);
+        let b0 = new Float64Array(m);
+        let b1 = new Float64Array(m);
+        let b2 = new Float64Array(m);
+        for (let q = 0; q < m; ++q) {
+            let k = post[q];
+            let s0 = 0, s1 = 0, s2 = 0;
+            if (kids[k].length === 0) {
+                let j = tipNo[k];
+                s0 = col0[j];
+                s1 = (2.0 * tipDepth[j] * col0[j]) - colInv[j];
+                // (2*depth/d - 1)^2 expands to 4*depth^2/d^2 - 4*depth/d + 1: the
+                // 1 is owed once per pair actually summed. The desktop adds n - 1,
+                // which also counts the pairs at distance 0 (identical sequences)
+                // that every other sum skips.
+                s2 = (4.0 * tipDepth[j] * tipDepth[j] * col0[j]) - (4.0 * tipDepth[j] * colInv[j]) + partners[j];
+            } else {
+                for (let c = 0; c < kids[k].length; ++c) {
+                    s0 += a0[kids[k][c]];
+                    s1 += a1[kids[k][c]];
+                    s2 += a2[kids[k][c]];
+                }
+            }
+            a0[k] = s0;
+            a1[k] = s1;
+            a2[k] = s2;
+            b0[k] = s0 - w0[k];
+            b1[k] = s1 - w1[k];
+            b2[k] = s2 - w2[k];
+        }
+        // Pass 3 (pre-order): up[k] = the deviation sum of the pairs whose
+        // ancestor lies outside subtree k, by the rerooting recursion, so
+        // every branch's total is O(1).
+        let up = new Float64Array(m);
+        let atParent = new Float64Array(m);   // a branch's cross deviation with the root at its parent
+        for (let k = 0; k < m; ++k) {
+            let ch = kids[k];
+            if (ch.length === 0) {
+                continue;
+            }
+            let sumDown = 0;
+            let sumAtParent = 0;
+            for (let c = 0; c < ch.length; ++c) {
+                let x = ch[c];
+                sumDown += down[x];
+                atParent[x] = madCross(depth[x], b0[x], b1[x], b2[x], madLength(pre[x]));
+                sumAtParent += atParent[x];
+            }
+            // cross deviation among all the groups meeting here: the child subtrees and the complement
+            let own = (k === 0) ? 0.0 : madCross(depth[k], b0[k], b1[k], b2[k], 0.0);
+            let crossAmong = (sumAtParent + own) / 2.0;
+            for (let c = 0; c < ch.length; ++c) {
+                let x = ch[c];
+                up[x] = up[k] + (sumDown - down[x]) + (crossAmong - atParent[x]);
+            }
+        }
+        // The branch and position with the smallest total deviation, and every
+        // branch's smallest MAD value keyed by the tips on its far side, so
+        // the value finds its branch again after the re-root has turned
+        // parents into children. The first minimum in post-order wins, as on
+        // the desktop.
+        let hash = madTipHashes(n);
+        let nPairs = (n * (n - 1.0)) / 2.0;
+        let madByKey = new Map();
+        let bestSsd = Infinity;
+        let best = -1;
+        let bestX = 0;
+        for (let q = 0; q < m; ++q) {
+            let c = post[q];
+            if (c === 0) {
+                continue;
+            }
+            let length = madLength(pre[c]);
+            // the optimal root position, as a distance from c toward its parent, kept on the branch
+            let x = (b0[c] > MAD_EPSILON) ? (depth[c] - (b1[c] / (2.0 * b0[c]))) : 0.0;
+            if (x < 0) {
+                x = 0;
+            } else if (x > length) {
+                x = length;
+            }
+            let ssd = madCross(depth[c], b0[c], b1[c], b2[c], x) + down[c] + up[c];
+            // a sum of squares; clamp a tiny negative left by cancellation, so sqrt is never NaN
+            let mad = Math.sqrt(Math.max(0.0, ssd) / nPairs);
+            let key = hash.key(hi[c] - lo[c], hash.xa[hi[c]] ^ hash.xa[lo[c]], hash.xb[hi[c]] ^ hash.xb[lo[c]], lo[c] === 0);
+            let prev = madByKey.get(key);
+            if (prev === undefined || mad < prev) {
+                madByKey.set(key, mad);   // the two halves of a bifurcating root share a key
+            }
+            if (ssd < bestSsd) {
+                bestSsd = ssd;
+                best = c;
+                bestX = x;
+            }
+        }
+        if (best < 0) {
+            return false;
+        }
+        let tipNumber = new Map();
+        for (let i = 0; i < n; ++i) {
+            tipNumber.set(pre[tipPos[i]], i);
+        }
+        forester.removeMadConfidences(phy);
+        forester.reRoot(phy, pre[best], bestX);
+        // annotate the internal branches of the re-rooted tree
+        let r = madTraversal(forester.getTreeRoot(phy));
+        let count = new Int32Array(r.pre.length);
+        let xa = new Int32Array(r.pre.length);
+        let xb = new Int32Array(r.pre.length);
+        let hasFirst = new Uint8Array(r.pre.length);
+        for (let q = 0; q < r.post.length; ++q) {
+            let k = r.post[q];
+            let ch = r.kids[k];
+            if (ch.length === 0) {
+                let i = tipNumber.get(r.pre[k]);
+                count[k] = 1;
+                xa[k] = hash.xa[i + 1] ^ hash.xa[i];
+                xb[k] = hash.xb[i + 1] ^ hash.xb[i];
+                hasFirst[k] = (i === 0) ? 1 : 0;
+                continue;
+            }
+            for (let c = 0; c < ch.length; ++c) {
+                count[k] += count[ch[c]];
+                xa[k] ^= xa[ch[c]];
+                xb[k] ^= xb[ch[c]];
+                hasFirst[k] |= hasFirst[ch[c]];
+            }
+            if (k !== 0) {
+                let mad = madByKey.get(hash.key(count[k], xa[k], xb[k], hasFirst[k] === 1));
+                if (mad !== undefined) {
+                    let kept = r.pre[k].confidences || [];
+                    r.pre[k].confidences = kept.concat([{value: mad, type: forester.MAD_CONFIDENCE_TYPE}]);
+                }
+            }
+        }
+        return true;
+    };
+
+    /**
+     * Removes every 'MAD' confidence (from madRoot) and keeps all others: a
+     * tree rooted any other way no longer has the rooting those values rate.
+     *
+     * @param phy the tree
+     */
+    forester.removeMadConfidences = function (phy) {
+        let root = forester.getTreeRoot(phy);
+        if (!root) {
+            return;
+        }
+        madTraversal(root).pre.forEach(function (node) {
+            if (node.confidences && node.confidences.some(function (c) { return c.type === forester.MAD_CONFIDENCE_TYPE; })) {
+                // a new array: re-rooting can leave two branches sharing one
+                let kept = node.confidences.filter(function (c) { return c.type !== forester.MAD_CONFIDENCE_TYPE; });
+                if (kept.length > 0) {
+                    node.confidences = kept;
+                } else {
+                    delete node.confidences;
+                }
+            }
+        });
+    };
+
+    /**
+     * Whether a node carries data about the node itself, the kind a
+     * re-rooting can take the meaning away from: a name, taxonomy, sequence
+     * (a domain architecture lives there), events, distribution, date,
+     * references, or a property about the node. Not data in this sense: the
+     * branch above it -- length, support and MAD values, colour, width, a
+     * property applying to the branch -- which re-rooting carries along,
+     * visual styling (style: properties), the viewer's own aptx: properties,
+     * and an empty taxonomy. The desktop's list is the same.
+     *
+     * @param node
+     * @returns {boolean}
+     */
+    forester.nodeHasData = function (node) {
+        let filled = function (x) {
+            return x !== undefined && x !== null && x !== '' && !(Array.isArray(x) && x.length === 0);
+        };
+        if ((typeof node.name === 'string' && node.name.length > 0)
+            || (node.taxonomies && node.taxonomies.some(function (t) {
+                return t && Object.keys(t).some(function (key) { return filled(t[key]); });
+            }))
+            || (node.sequences && node.sequences.length > 0)
+            || node.events
+            || (node.distributions && node.distributions.length > 0)
+            || node.date
+            || (node.references && node.references.length > 0)) {
+            return true;
+        }
+        return !!node.properties && node.properties.some(function (p) {
+            return p.applies_to !== BRANCH_EVENT_APPLIES_TO
+                && !(typeof p.ref === 'string' && (p.ref.indexOf('style:') === 0 || p.ref.indexOf('aptx:') === 0));
+        });
+    };
+
+    /**
+     * What a re-rooting would do to the data on internal nodes, worked out on
+     * a bare copy so the tree itself is untouched: `annotated`, the internal
+     * nodes carrying data (nodeHasData), and `changed`, those among them whose
+     * clade -- the tips below -- the re-rooting changes. Those lie between
+     * the old root and the new one (an old two-child root disappears); every
+     * other node keeps its tips. Midpoint and MAD rooting find their root on
+     * the copy first. Nothing is copied when no internal node carries data.
+     *
+     * @param phy the tree
+     * @param method 'mad', 'midpoint', or 'node': the root on the branch above `node`
+     * @param node the node, for 'node'
+     * @returns {{annotated: Array, changed: Array}} nodes of `phy`
+     */
+    forester.cladesChangedByRerooting = function (phy, method, node) {
+        let t = madTraversal(forester.getTreeRoot(phy));
+        let annotated = [];
+        for (let k = 0; k < t.pre.length; ++k) {
+            if (t.kids[k].length > 0 && forester.nodeHasData(t.pre[k])) {
+                annotated.push(t.pre[k]);
+            }
+        }
+        if (annotated.length === 0) {
+            return {annotated: annotated, changed: []};
+        }
+        // the copy: shape and branch lengths only, each copy knowing its original
+        let copyOf = new Map();
+        let tipNumber = new Map();
+        for (let k = 0; k < t.pre.length; ++k) {
+            let c = {branch_length: t.pre[k].branch_length, original: t.pre[k]};
+            if (t.kids[k].length > 0) {
+                c.children = [];
+            } else {
+                tipNumber.set(t.pre[k], tipNumber.size);
+            }
+            if (k > 0) {
+                c.parent = copyOf.get(t.pre[t.parentOf[k]]);
+                c.parent.children.push(c);
+            }
+            copyOf.set(t.pre[k], c);
+        }
+        let copy = {children: [copyOf.get(t.pre[0])]};
+        copy.children[0].parent = copy;
+        if (method === 'mad') {
+            forester.madRoot(copy);
+        } else if (method === 'midpoint') {
+            forester.midpointRoot(copy);
+        } else {
+            forester.reRoot(copy, copyOf.get(node), -1);
+        }
+        // the tips below every node, before and after, as a count and two hashes
+        let hash = madTipHashes(tipNumber.size);
+        let cladeKeys = function (traversal, originalOf) {
+            let count = new Int32Array(traversal.pre.length);
+            let xa = new Int32Array(traversal.pre.length);
+            let xb = new Int32Array(traversal.pre.length);
+            let keys = new Map();
+            for (let q = 0; q < traversal.post.length; ++q) {
+                let k = traversal.post[q];
+                let ch = traversal.kids[k];
+                if (ch.length === 0) {
+                    let i = tipNumber.get(originalOf(traversal.pre[k]));
+                    count[k] = 1;
+                    xa[k] = hash.xa[i + 1] ^ hash.xa[i];
+                    xb[k] = hash.xb[i + 1] ^ hash.xb[i];
+                    continue;
+                }
+                for (let c = 0; c < ch.length; ++c) {
+                    count[k] += count[ch[c]];
+                    xa[k] ^= xa[ch[c]];
+                    xb[k] ^= xb[ch[c]];
+                }
+                let original = originalOf(traversal.pre[k]);
+                if (original) {   // not the copy's new root node
+                    keys.set(original, count[k] + ':' + xa[k] + ':' + xb[k]);
+                }
+            }
+            return keys;
+        };
+        let before = cladeKeys(t, function (n) { return n; });
+        let after = cladeKeys(madTraversal(forester.getTreeRoot(copy)), function (c) { return c.original; });
+        return {
+            annotated: annotated,
+            changed: annotated.filter(function (n) { return after.get(n) !== before.get(n); })
+        };
+    };
+
+    function madLength(node) {
+        return node.branch_length > 0 ? node.branch_length : 0;
+    }
+
+    // The sum of squared cross-pair deviations between subtree c and its
+    // complement, with the root at distance x from c toward its parent. With
+    // K = 2*(x - depth[c]) a pair deviates by K/d + (2*depth[j]/d - 1), so the
+    // sum is K^2*b0 + 2*K*b1 + b2.
+    function madCross(depthC, b0, b1, b2, x) {
+        let k = 2.0 * (x - depthC);
+        return (k * k * b0) + (2.0 * k * b1) + b2;
+    }
+
+    // Pre-order (the root at 0, parents before children) and post-order,
+    // children left to right, as node positions -- without recursion, since
+    // a caterpillar tree nests as deep as it has tips.
+    function madTraversal(root) {
+        let pre = [];
+        let parentOf = [];
+        let stack = [root];
+        let stackParent = [-1];
+        while (stack.length > 0) {
+            let node = stack.pop();
+            let p = stackParent.pop();
+            let k = pre.length;
+            pre.push(node);
+            parentOf.push(p);
+            if (node.children) {
+                for (let i = node.children.length - 1; i >= 0; --i) {
+                    stack.push(node.children[i]);
+                    stackParent.push(k);
+                }
+            }
+        }
+        let kids = pre.map(function () {
+            return [];
+        });
+        for (let k = 1; k < pre.length; ++k) {
+            kids[parentOf[k]].push(k);   // siblings come in left to right
+        }
+        // the mirrored pre-order, reversed, is the post-order left to right
+        let post = [];
+        let st = [0];
+        while (st.length > 0) {
+            let k = st.pop();
+            post.push(k);
+            for (let c = 0; c < kids[k].length; ++c) {
+                st.push(kids[k][c]);
+            }
+        }
+        post.reverse();
+        return {pre: pre, parentOf: parentOf, kids: kids, post: post};
+    }
+
+    // A set of tips as a key that does not depend on the rooting: its size
+    // and two 32-bit XOR hashes of its tips, taken on the side WITHOUT tip 0
+    // so both sides of a branch give the same key. xa/xb are prefix XORs, so
+    // the tips lo..hi-1 hash to xa[hi] ^ xa[lo].
+    function madTipHashes(n) {
+        let xa = new Int32Array(n + 1);
+        let xb = new Int32Array(n + 1);
+        let s = 0x2545f491;
+        let next = function () {   // a fixed seed: the same tree always hashes the same
+            s = (s + 0x9e3779b9) | 0;
+            let z = s;
+            z = Math.imul(z ^ (z >>> 16), 0x85ebca6b);
+            z = Math.imul(z ^ (z >>> 13), 0xc2b2ae35);
+            return z ^ (z >>> 16);
+        };
+        for (let i = 0; i < n; ++i) {
+            xa[i + 1] = xa[i] ^ next();
+            xb[i + 1] = xb[i] ^ next();
+        }
+        return {
+            xa: xa,
+            xb: xb,
+            key: function (size, ha, hb, holdsFirst) {
+                if (holdsFirst) {
+                    size = n - size;
+                    ha ^= xa[n];
+                    hb ^= xb[n];
+                }
+                return size + ':' + ha + ':' + hb;
+            }
+        };
+    }
+
     forester.getFurthestDescendant = function (node) {
         let children = forester.getAllExternalNodes(node);
         let farthest = null;
@@ -1691,6 +2231,8 @@
         properties.longestNodeName = 0;
         properties.branchLengths = false;
         properties.confidences = false;
+        // MAD values (madRoot) rate root positions, not clades: never support
+        properties.madValues = false;
         // the largest confidence value seen -- how a caller tells a
         // posterior-probability tree (max <= 1) from a bootstrap tree
         properties.maxConfidence = 0;
@@ -1803,8 +2345,12 @@
                 }
             }
             if (n.confidences && n.confidences.length > 0) {
-                properties.confidences = true;
                 for (let ci = 0; ci < n.confidences.length; ++ci) {
+                    if (n.confidences[ci].type === forester.MAD_CONFIDENCE_TYPE) {
+                        properties.madValues = true;
+                        continue;
+                    }
+                    properties.confidences = true;
                     let cv = n.confidences[ci].value;
                     if (typeof cv === 'number' && isFinite(cv) && cv > properties.maxConfidence) {
                         properties.maxConfidence = cv;
@@ -3470,11 +4016,17 @@
                     nh += ":" + node.branch_length;
                 }
             }
-            if (writeConfidences && node.confidences && node.confidences.length === 1 && node.confidences[0].value !== undefined && node.confidences[0].value !== null) {
+            // the support slot holds support: a MAD value (madRoot) never goes
+            // there -- it would read as support, and would crowd out the
+            // bootstrap on a branch carrying both. phyloXML keeps it, typed.
+            let support = writeConfidences && node.confidences
+                ? node.confidences.filter(function (c) { return c.type !== forester.MAD_CONFIDENCE_TYPE; })
+                : [];
+            if (support.length === 1 && support[0].value !== undefined && support[0].value !== null) {
                 if (decPointsMax && decPointsMax > 0) {
-                    nh += "[" + forester.roundNumber(node.confidences[0].value, decPointsMax) + "]";
+                    nh += "[" + forester.roundNumber(support[0].value, decPointsMax) + "]";
                 } else {
-                    nh += "[" + node.confidences[0].value + "]";
+                    nh += "[" + support[0].value + "]";
                 }
             }
             if (!last) {
@@ -4258,7 +4810,8 @@
     }, {suggest: false});
 
     const SEARCH_BRANCH_LENGTH = numericField('Branch Length', n => (typeof n.branch_length === 'number') ? [n.branch_length] : []);
-    const SEARCH_CONFIDENCE = numericField('Confidence', n => n.confidences ? n.confidences.map(c => c.value).filter(v => typeof v === 'number') : []);
+    // support only: a MAD value rates a root position, not the clade
+    const SEARCH_CONFIDENCE = numericField('Confidence', n => n.confidences ? n.confidences.filter(c => c.type !== forester.MAD_CONFIDENCE_TYPE).map(c => c.value).filter(v => typeof v === 'number') : []);
     const SEARCH_CLADE_SIZE = numericField('Clade Size (tips)', n => [n._srchClade], {metrics: true});
     const SEARCH_CHILD_COUNT = numericField('Number of Children', n => [n.children ? n.children.length : 0]);
     const SEARCH_DEPTH = numericField('Depth from Root', n => [n._srchDepth], {metrics: true});
@@ -4397,7 +4950,7 @@
             if (!hasBL && typeof n.branch_length === 'number' && n.branch_length >= 0) hasBL = true;
             if (!hasConf && n.confidences) {
                 for (let i = 0; i < n.confidences.length; ++i) {
-                    if (typeof n.confidences[i].value === 'number') { hasConf = true; break; }
+                    if (typeof n.confidences[i].value === 'number' && n.confidences[i].type !== forester.MAD_CONFIDENCE_TYPE) { hasConf = true; break; }
                 }
             }
             if (n.properties) {
@@ -4845,6 +5398,32 @@
         'calendar year': 1, 'calendar years': 1
     };
 
+    /**
+     * Whether the tree's branch lengths are time: most of its internal nodes
+     * carry a date, and at least two do -- BEAST node heights, Nextstrain
+     * dates, phyloXML <date>s on ancestors. Tip dates alone do not make one:
+     * a divergence tree can carry collection dates, and re-rooting it (as a
+     * root-to-tip regression does) is a normal step. A time tree is never
+     * re-rooted: a new root would contradict the ancestors' dates. The
+     * desktop's rule is the same (its detectTimeTree, internal-node half).
+     *
+     * @param phy the tree
+     * @returns {boolean}
+     */
+    forester.isTimeTree = function (phy) {
+        let internal = 0;
+        let dated = 0;
+        forester.preOrderTraversalAll(forester.getTreeRoot(phy), function (n) {
+            if (n.children && n.children.length > 0) {
+                ++internal;
+                if (n.date && typeof n.date.value === 'number' && isFinite(n.date.value)) {
+                    ++dated;
+                }
+            }
+        });
+        return dated >= 2 && dated * 2 > internal;
+    };
+
     // Everything the viewer needs to decide about and draw a time axis:
     // {type: 'geologic'|'calendar'|null, rootAge, presentDate, dated,
     //  hasInternalIntervals, hasExternalIntervals}. rootAge (geologic) and

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "archaeopteryx",
-  "version": "3.4.1",
+  "version": "3.5.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",