archaeopteryx 3.13.0 → 3.15.0

package/archaeopteryx.js

@@ -20,7 +20,7 @@
  *
  */
 
-// v 3.13.0
+// v 3.15.0
 // 2026-09-17
 //
 // 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.13.0';
+    const VERSION = '3.15.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';
@@ -414,6 +414,7 @@ function (root, d3, forester, phyloXml) {
     const BRANCH_SCALE_TIME_BUTTON = 'branch_scale_time_b';
     const BRANCH_SCALE_DIV_BUTTON = 'branch_scale_div_b';
     const ABOUT_DIALOG = 'aptx_about';
+    const TREE_PROPERTIES_DIALOG = 'aptx_tree_props';
     const PROG_NAME = 'progname';
     const PROGNAMELINK = 'prognamelink';
     const TREE_DESC = 'tree_desc';
@@ -1480,6 +1481,26 @@ function (root, d3, forester, phyloXml) {
     // so the guess was what the reader saw every time.
     const HOVER_READOUT_GAP = 14;
 
+    // One way to open an external page. There were three: window.open + a
+    // win.focus() that throws when a popup blocker hands back null and which
+    // passed no noopener, an <a target="_blank" rel="noopener noreferrer">,
+    // and a third for the domain link. Three security postures for one job,
+    // and a change to the policy would have had to find all of them.
+    //
+    // noopener: the opened page must not get a handle on this window.
+    // noreferrer with it, since a tree can come from anywhere and its URL is
+    // not the external site's business.
+    function openExternal(url) {
+        if (!url) {
+            return null;
+        }
+        let win = window.open(url, '_blank', 'noopener,noreferrer');
+        if (win) {
+            win.focus();   // a blocked popup hands back null; that is not an error
+        }
+        return win;
+    }
+
     function placeHoverReadout(el, event) {
         let w = el.offsetWidth;
         let h = el.offsetHeight;
@@ -2318,12 +2339,23 @@ function (root, d3, forester, phyloXml) {
 
     let _legendMeasureCtx = null;
 
-    function legendTextWidth(text, font) {
+    // One lazily made canvas for every text measurement: the legend's widths,
+    // the branch-data line metrics and the sequence logo's glyph boxes each
+    // used to make their own.
+    function measureCtx() {
         if (!_legendMeasureCtx) {
             _legendMeasureCtx = document.createElement('canvas').getContext('2d');
         }
-        _legendMeasureCtx.font = font;
-        return _legendMeasureCtx.measureText(text).width;
+        return _legendMeasureCtx;
+    }
+
+    function legendTextWidth(text, font) {
+        let ctx = measureCtx();
+        if (!ctx) {
+            return 0;
+        }
+        ctx.font = font;
+        return ctx.measureText(text).width;
     }
 
     // The card's row order and cap, the desktop's way: rank by count first
@@ -3177,7 +3209,11 @@ function (root, d3, forester, phyloXml) {
             .attr('transform', function (d) {
                 return radialDisplay() ? branchLabelTransform(d) : null;
             })
-            .attr('dy', '-.25em')
+            // Every one of these three reads its offset from branchMarkPlacement,
+            // the same function the occupancy boxes are built from: a box that is
+            // not where the text is hides the wrong marks, and two copies of the
+            // same number drift apart the first time one of them is edited.
+            .attr('dy', branchMarkPlacement('bl', _state.branchDataFontSize).dy)
             .attr('x', function (d) {
                 if (radialDisplay()) {
                     return 0;
@@ -3198,7 +3234,7 @@ function (root, d3, forester, phyloXml) {
             .attr('transform', function (d) {
                 return radialDisplay() ? branchLabelTransform(d) : null;
             })
-            .attr('dy', _state.branchDataFontSize)
+            .attr('dy', branchMarkPlacement('conf', _state.branchDataFontSize).dy)
             .attr('x', function (d) {
                 if (radialDisplay()) {
                     return 0;
@@ -3234,7 +3270,7 @@ function (root, d3, forester, phyloXml) {
             .attr('transform', function (d) {
                 return radialDisplay() ? branchLabelTransform(d) : null;
             })
-            .attr('dy', '-.25em')
+            .attr('dy', branchMarkPlacement('event', _state.branchDataFontSize).dy)
             .attr('x', function (d) {
                 if (radialDisplay()) {
                     return 0;
@@ -3819,6 +3855,169 @@ function (root, d3, forester, phyloXml) {
     // a support dot. Returns the nodes that need a <g> -- those with any of
     // them, and every collapsed clade (its wedge and label). The rest are
     // drawn entirely by drawTreeGeometry's batched paths.
+    // ===================== Crowded branch data =====================
+    // A branch-anchored mark is drawn only when its box does not overlap one
+    // already granted in the same pass. Ported from the desktop's
+    // LabelOccupancy (0.11.161) as a JOINT rule on Christian's word,
+    // 2026-09-25: "match the desktop's new auto-hide rule for crowded branch
+    // data". Neither side retunes it alone.
+    //
+    // It exists because the obvious rule does not work. The desktop built
+    // "hide when the branch is drawn shorter than the text" first and measured
+    // it: on an 825-tip tree a third-of-text threshold hid 285 numbers of
+    // which only 51 collided, and still left 22 pile-ups. A number is
+    // unreadable when it overlaps ANOTHER number, which depends on closeness
+    // in y as much as in x, and branch length only sees x. Measured here
+    // before adopting it: with Auto-hide Labels already ON, 240 of 267 drawn
+    // support numbers overlapped another on flu_h5.xml (90%), 149 of 262 on
+    // Adenoviridae, 13 of 119 on bcl2 -- our auto-hide decimates TIP labels
+    // and had never touched branch data.
+    //
+    // WHAT MUST MATCH, or the two viewers drop different marks:
+    //  - the tie-break: PREORDER, first claim wins, so the mark nearer the
+    //    root keeps its place. d3's descendants() is preorder already.
+    //  - TWO maps, numbers and symbols. The symbol sits ON the branch and the
+    //    numbers just above and below it, so one shared map would let a
+    //    branch's own symbol block its own numbers.
+    //  - a refused claim records NOTHING, so a rejected mark never blocks a
+    //    later one.
+    //  - a zero-size box is granted and not recorded.
+    //  - symbols are never shrunk to fit: in a size-scaled mode the diameter
+    //    IS the support, and a smaller dot would report weaker support.
+    //
+    // WHAT CANNOT MATCH, and is not meant to: the COUNTS. The boxes come from
+    // each program's own font metrics, so the same tree at the same size drops
+    // a similar but not identical set. The rule is the contract; the tally is
+    // not.
+    //
+    // Where a branch-anchored mark sits, in the tree group's coordinates.
+    // Mirrors the placement in syncOptionalNodeChildren exactly -- the branch
+    // length back toward the parent and above the branch, the confidence at
+    // the branch midpoint and below it -- because a box that is not where the
+    // text is would hide the wrong marks.
+    // The font's LINE box, which is what the marks are laid out with and what
+    // the desktop measures too (FontMetrics.getHeight()). Not the per-glyph
+    // ink box: two numbers collide when their lines overlap, and ink boxes
+    // would let "1" slide under "0.81".
+    //
+    // Measured from the font rather than assumed. The fallback is what this
+    // font actually reports at 9px -- ascent 9, descent 2, line 11 -- read off
+    // a rendered label's getBBox rather than guessed.
+    let _branchFontCache = null;
+
+    function branchFontMetrics(fontPx) {
+        if (_branchFontCache && _branchFontCache.px === fontPx) {
+            return _branchFontCache;
+        }
+        let ctx = measureCtx();
+        ctx.font = fontPx + 'px ' + FONT_DEFAULTS;
+        let m = ctx.measureText('0');
+        let ascent = m.fontBoundingBoxAscent;
+        let descent = m.fontBoundingBoxDescent;
+        // Both, separately: a canvas that reports an ascent and no descent
+        // would give height = ascent + undefined = NaN, every box would be
+        // refused a claim as zero-sized, and the feature would turn itself off
+        // with no error and a green suite.
+        if (!(ascent > 0)) {
+            ascent = fontPx;
+        }
+        if (!(descent >= 0)) {
+            descent = fontPx * (2 / 9);
+        }
+        _branchFontCache = {px: fontPx, ascent: ascent, descent: descent,
+            height: ascent + descent};
+        return _branchFontCache;
+    }
+
+    // Where a branch mark sits on its branch, read off the rendered elements
+    // rather than inferred: the horizontal anchor and the `dy` the element is
+    // drawn with. Getting either wrong is not a rounding error. A
+    // middle-anchored box modelled as left-anchored is half its own width out,
+    // which once let 44% of the granted numbers still overlap; and a branch
+    // EVENT sits a quarter em ABOVE the line like the branch length, not a
+    // font size below it like the confidence, so modelling it as a confidence
+    // put its box on the wrong side of the branch -- the one side it could
+    // never collide on.
+    function branchMarkPlacement(kind, fontPx) {
+        if (kind === 'conf') {
+            return {mid: true, dy: fontPx};
+        }
+        if (kind === 'event') {
+            // A radial layout draws every mark on ONE point, the branch's
+            // midpoint, so a branch event and a branch length -- both a quarter
+            // em above the line -- printed straight through each other. The
+            // event is lifted a whole line clear of the length. The rectangular
+            // layout already separates them along the branch (the length at the
+            // parent end, the event at the middle), so there they share a line.
+            return {mid: true, dy: radialDisplay()
+                ? ((-0.25 * fontPx) - branchFontMetrics(fontPx).height)
+                : (-0.25 * fontPx)};
+        }
+        return {mid: false, dy: -0.25 * fontPx};   // 'bl': start-anchored, a quarter em up
+    }
+
+    // The incoming branch's MIDPOINT and screen direction, in the tree group's
+    // own coordinates -- what a radial mark is actually drawn on, since
+    // branchLabelTransform rotates to the spoke and translates half a branch
+    // back along it. Circular: the leg runs along ONE spoke, so the midpoint is
+    // the mean of the two radii at the same angle (an arc's chord is not on the
+    // leg). Unrooted: the branch is a straight line, so it is the mean of the
+    // two points. Both match the desktop's two call sites of
+    // paintBranchDataRadial.
+    function radialBranchMid(d) {
+        let angle = spokeAngle(d);
+        if (_state.unrootedDisplay) {
+            if (d.ux === undefined) {
+                return null;
+            }
+            let p = (d.parent && d.parent.ux !== undefined) ? d.parent : null;
+            return p ? [0.5 * (d.ux + p.ux), 0.5 * (d.uy + p.uy), angle] : [d.ux, d.uy, angle];
+        }
+        let r = radialRadius(d.y);
+        if (d.parent) {
+            r = 0.5 * (r + radialRadius(d.parent.y));
+        }
+        let pt = polarXY(radialAngle(d.x), r);
+        return [pt[0], pt[1], angle];
+    }
+
+    function branchMarkBox(d, kind, text, fontPx) {
+        let w = legendTextWidth(text, fontPx + 'px ' + FONT_DEFAULTS);
+        let fm = branchFontMetrics(fontPx);
+        let h = fm.height;
+        let at = branchMarkPlacement(kind, fontPx);
+        if (radialDisplay()) {
+            // The mark rides the branch, so its box is the AXIS-ALIGNED bounds
+            // of the rotated rectangle, centred where the text's own centre
+            // lands: forester.rotatedLabelBox, which carries the desktop's
+            // formula and the reasons it is the conservative one.
+            let mid = radialBranchMid(d);
+            if (!mid) {
+                return null;
+            }
+            // `dy` shifts the BASELINE, so the box's centre sits half a line
+            // below it; and the 180-degree flip that keeps the far half of the
+            // fan upright carries this perpendicular offset with it.
+            let off = at.dy + (0.5 * (fm.descent - fm.ascent));
+            if (labelFlip(d)) {
+                off = -off;
+            }
+            // every radial mark is middle-anchored at x=0, so only the
+            // perpendicular offset moves its centre off the branch midpoint
+            return forester.rotatedLabelBox(mid[0] - (Math.sin(mid[2]) * off),
+                mid[1] + (Math.cos(mid[2]) * off), w, h, mid[2]);
+        }
+        // The ROOT's numbers are drawn too, at x=0 in its own group, and they
+        // used to claim nothing -- so the first child's number, landing in
+        // almost the same place, was granted and painted over them. The one
+        // place the pass could not keep its promise.
+        let span = d.parent ? (d.parent.y - d.y) : 0;
+        let x = at.mid
+            ? (d.y + (0.5 * span) - (w / 2))          // middle-anchored
+            : (d.y + span + 1);                       // start-anchored
+        return [x, (d.x + at.dy) - fm.ascent, w, h];
+    }
+
     function prepareNodeDrawing(nodes) {
         let wantBl = _state.showBranchLengthValues === true;
         let wantConf = _state.showConfidenceValues === true || _state.showMadValues === true;
@@ -3840,6 +4039,14 @@ function (root, d3, forester, phyloXml) {
             d._confText = wantConf ? asText(makeConfidenceValuesLabel(d)) : '';
             d._eventText = wantEvent ? asText(makeBranchEventsLabel(d)) : '';
             d._suppDot = wantDot && showSupportDot(d);
+        }
+        // Before `drawn` is built, not after: a refused mark used to leave a
+        // childless <g class="node"> behind, and those are transformed on
+        // every animation frame. On the big tree that was ~18,000 empty groups
+        // per redraw, defeating the very thing the `drawn` filter is for.
+        hideCrowdedBranchData(nodes);
+        for (let i = 0, len = nodes.length; i !== len; ++i) {
+            let d = nodes[i];
             if (d._extLabelText !== '' || d._blText !== '' || d._confText !== ''
                 || d._eventText !== '' || d._suppDot || isCollapsed(d)) {
                 drawn.push(d);
@@ -3848,6 +4055,88 @@ function (root, d3, forester, phyloXml) {
         return drawn;
     }
 
+    // The occupancy pass, in PREORDER -- so the mark nearer the root claims
+    // its space first and keeps it. NOT the order the layout hands out: d3's
+    // descendants() is breadth-first and the viewer reverses it for drawing,
+    // which puts the root LAST and inverts the entire tie-break. That shipped,
+    // and a review caught it; forester.preorderOf derives the right order from
+    // the nodes themselves.
+    //
+    // Runs before anything is drawn, so the decision cannot depend on the
+    // order the DOM happens to be updated in.
+    //
+    // Rides the existing Auto-hide Labels toggle: switch it off and everything
+    // is drawn. Runs in ALL THREE layouts, as the desktop does -- the boxes are
+    // built in the tree group's own coordinates, which is where every mark is
+    // actually drawn, so the circular and unrooted views are measured in their
+    // own space and not in the cluster's. (The tip-label decimation that shares
+    // the toggle is still skipped in unrooted: that one needs even row spacing
+    // to decimate against, and there is none.)
+    function hideCrowdedBranchData(nodes) {
+        if (!_state.dynahide) {
+            return;
+        }
+        // No layout state, no honest boxes. Bailing out draws everything; going
+        // on would put every mark at the origin, where they all overlap and all
+        // but the first would be hidden -- a blank tree, with no error.
+        if ((_state.circularDisplay && !_radial) || (_state.unrootedDisplay && !_unroot)) {
+            return;
+        }
+        let fontPx = _state.branchDataFontSize;
+        let dotCell = 0;
+        for (let i = 0; i < nodes.length; ++i) {
+            if (nodes[i]._suppDot) {
+                dotCell = Math.max(dotCell, 2 * supportDotRadius(nodes[i]));
+            }
+        }
+        let cell = Math.max(fontPx, dotCell);
+        let numbers = forester.labelOccupancy(cell);
+        let symbols = forester.labelOccupancy(cell);
+        let ordered = forester.preorderOf(nodes);
+        for (let i = 0, len = ordered.length; i !== len; ++i) {
+            let d = ordered[i];
+            // Branch length first, then confidence: they sit on opposite sides
+            // of the branch, so they rarely contend, but the order decides
+            // which survives when they do.
+            if (d._blText !== '') {
+                let b = branchMarkBox(d, 'bl', d._blText, fontPx);
+                if (b && !numbers.claim(b[0], b[1], b[2], b[3])) {
+                    d._blText = '';
+                }
+            }
+            if (d._confText !== '') {
+                let b = branchMarkBox(d, 'conf', d._confText, fontPx);
+                if (b && !numbers.claim(b[0], b[1], b[2], b[3])) {
+                    d._confText = '';
+                }
+            }
+            // Branch EVENTS are branch-anchored too, half a branch from the
+            // branch length and on the same side of it, so they can land on
+            // the same pixels. Left out of the map, they neither refused a
+            // number nor were refused by one, and the pass reported "no
+            // overlapping marks" while the user could see two.
+            if (d._eventText !== '') {
+                let b = branchMarkBox(d, 'event', d._eventText, fontPx);
+                if (b && !numbers.claim(b[0], b[1], b[2], b[3])) {
+                    d._eventText = '';
+                }
+            }
+            if (d._suppDot) {
+                // never shrunk to fit: in a size-scaled mode the diameter IS
+                // the support value, and a smaller dot reports weaker support
+                let r = supportDotRadius(d);
+                // showSupportDot already required a parent; a circle's bounds
+                // do not rotate, so the radial case needs only the midpoint
+                let at = radialDisplay()
+                    ? radialBranchMid(d)
+                    : [d.y + (0.5 * (d.parent.y - d.y)), d.x];
+                if (at && !symbols.claim(at[0] - r, at[1] - r, 2 * r, 2 * r)) {
+                    d._suppDot = false;
+                }
+            }
+        }
+    }
+
     function syncOptionalNodeChildren(node) {
         let wantBl = _state.showBranchLengthValues === true;
         let wantConf = _state.showConfidenceValues === true || _state.showMadValues === true;
@@ -6378,8 +6667,7 @@ function (root, d3, forester, phyloXml) {
                 }
 
                 if (url) {
-                    let win = window.open(url, '_blank');
-                    win.focus();
+                    openExternal(url);
                 } else {
                     // Not a programming error -- the user clicked and there is
                     // simply nowhere to go -- so this one gets told in the same
@@ -6879,11 +7167,9 @@ function (root, d3, forester, phyloXml) {
         if (_logoGlyphs[ch]) {
             return _logoGlyphs[ch];
         }
-        if (!_legendMeasureCtx) {
-            _legendMeasureCtx = document.createElement('canvas').getContext('2d');
-        }
-        _legendMeasureCtx.font = MSA_LOGO_FONT_PX + 'px monospace';
-        let m = _legendMeasureCtx.measureText(ch);
+        let ctx = measureCtx();
+        ctx.font = MSA_LOGO_FONT_PX + 'px monospace';
+        let m = ctx.measureText(ch);
         let ascent = m.actualBoundingBoxAscent;
         let descent = m.actualBoundingBoxDescent;
         if (!(ascent > 0)) {
@@ -9575,6 +9861,7 @@ function (root, d3, forester, phyloXml) {
         {key: 'g', label: 'G', shift: true, what: 'Previous search hit', run: function () { stepToFoundNode(-1); }, typing: true},
         {key: ',', label: '<', aliases: ['<'], shift: true, what: 'Previous tree of the file', run: function () { stepTree(-1); }},
         {key: '.', label: '>', aliases: ['>'], shift: true, what: 'Next tree of the file', run: function () { stepTree(1); }},
+        {key: 'i', label: 'I', what: 'Tree properties and statistics', run: showTreePropertiesDialog},
         {key: '/', label: '/', aliases: ['?'], what: 'This list', run: showShortcutsDialog, typing: true}
     ];
 
@@ -9953,6 +10240,114 @@ function (root, d3, forester, phyloXml) {
     // the later one's shadow and glow used to fall across the earlier body,
     // and now lie under it; overlapping shadows of one level no longer
     // darken each other.
+    // ===================== Domain hover =====================
+    // Domain architectures are what Archaeopteryx has always been best at, and
+    // until now the boxes said nothing: you could see a domain but not read
+    // its name, its E-value or where it sits, short of opening the node's data
+    // dialog and finding it in a list. Christian, 2026-09-23.
+    //
+    // The readout is the one the heat map and the alignment already use, so a
+    // hover anywhere in the viewer looks and behaves the same, and it is
+    // placed by placeHoverReadout, which measures the box rather than assuming
+    // a size.
+
+    function domainInfoAt(event) {
+        let t = event.target;
+        return (t && t.__aptxDomain) ? t.__aptxDomain : null;
+    }
+
+    let _domainHovered = null;
+
+    function domainHover(event) {
+        let info = domainInfoAt(event);
+        if (!info) {
+            domainHoverOut();
+            return;
+        }
+        // mousemove fires all the way across a box, and a wide domain is
+        // hundreds of pixels. The TEXT only changes when the box does, so
+        // re-escaping it, reparsing it as HTML and restarting the fade sixty
+        // times a second would be work for a byte-identical result -- and the
+        // restarted transition would keep opacity approaching 0.95 without
+        // ever arriving. The readout must still FOLLOW the pointer, so the
+        // placement runs either way.
+        let tip_el = _node_mouseover_div.node();
+        if (info === _domainHovered) {
+            placeHoverReadout(tip_el, event);
+            return;
+        }
+        _domainHovered = info;
+        let ref = forester.domainReference(info);
+        let txt = 'Domain: ' + (info.name || '(unnamed)') + '<br>';
+        let ev = forester.domainEvalueText(info.evalue);
+        if (ev !== null) {
+            txt += 'E-value: ' + ev + '<br>';
+        }
+        txt += 'Residues: ' + info.from + '–' + info.to
+            + ' (' + ((info.to - info.from) + 1) + ' aa'
+            + (info.proteinLength > 0 ? (' of ' + info.proteinLength) : '') + ')<br>';
+        if (info.tip) {
+            txt += 'Tip: ' + info.tip + '<br>';
+        }
+        if (info.id) {
+            txt += 'Accession: ' + info.id + '<br>';
+        }
+        if (ref) {
+            // A readout that follows the pointer cannot hold a link you could
+            // reach, so the BOX is the link and the readout says so. Written
+            // as a "label: value" row on purpose: markUpDataLabels renders a
+            // line WITHOUT a colon as a section divider (9px bold uppercase
+            // faint), which is the wrong voice entirely for a call to action.
+            txt += ref.exact ? 'Click: the Pfam entry' : 'Click: to look this domain up at InterPro';
+        }
+        tip_el.classList.remove('aptx-light', 'aptx-dark');
+        if (_panelTheme) {
+            tip_el.classList.add('aptx-' + _panelTheme);
+        }
+        _node_mouseover_div.html(markUpDataLabels(escapeHtmlKeepBreaks(txt)));
+        placeHoverReadout(tip_el, event);
+        _node_mouseover_div.transition().duration(100).style('opacity', 0.95);
+    }
+
+    function domainHoverOut() {
+        _domainHovered = null;
+        _node_mouseover_div.transition().duration(300).style('opacity', 1e-6);
+    }
+
+    let _domainOpenedAt = 0;
+
+    function domainClicked(event) {
+        let info = domainInfoAt(event);
+        if (!info) {
+            return;
+        }
+        // A click that LANDED on a box is the box's, whether or not it has
+        // somewhere to send you; letting an unlinkable domain fall through
+        // would open the node menu for whatever node is within five units.
+        event.stopPropagation();
+        let ref = forester.domainReference(info);
+        if (!ref) {
+            return;
+        }
+        // Double-clicking is the natural gesture for "open this", and it
+        // arrives as two clicks: without this it opens two identical tabs.
+        let now = Date.now();
+        if ((now - _domainOpenedAt) < 500) {
+            return;
+        }
+        _domainOpenedAt = now;
+        openExternal(ref.url);
+    }
+
+    // The tree zooms on double click. Over a domain box the gesture means the
+    // box, so the zoom must not also happen behind the tabs that just opened.
+    function domainDblClicked(event) {
+        if (domainInfoAt(event)) {
+            event.stopPropagation();
+            event.preventDefault();
+        }
+    }
+
     function drawDomainArchitectures() {
         if (!_svgGroup) {
             return;
@@ -9964,6 +10359,7 @@ function (root, d3, forester, phyloXml) {
         let f = tips.length > 0 ? domainScale() : 0;
         if (tips.length === 0 || !(f > 0) || !isFinite(f)) {
             existing.remove();
+            domainHoverOut();   // the box under the pointer just stopped existing
             return;
         }
         // [defs, the batched paths, the bodies, the names], kept between
@@ -9983,6 +10379,20 @@ function (root, d3, forester, phyloXml) {
         let underLayer = g.children[1];
         let bodyLayer = g.children[2];
         let labelLayer = g.children[3];
+        // The group ignores the mouse so the tree underneath stays clickable;
+        // the BODIES alone take it back, so a hover lands on a domain and not
+        // on its shadow, its glow or its label.
+        bodyLayer.style.pointerEvents = 'auto';
+        if (!bodyLayer.__aptxWired) {
+            bodyLayer.__aptxWired = true;
+            // mousemove alone, as the heat map and the alignment do it: a
+            // mouseover is always followed by a mousemove, so binding both
+            // only built the readout twice on entry.
+            bodyLayer.addEventListener('mousemove', domainHover);
+            bodyLayer.addEventListener('mouseout', domainHoverOut);
+            bodyLayer.addEventListener('click', domainClicked);
+            bodyLayer.addEventListener('dblclick', domainDblClicked);
+        }
 
         // one vertical gradient per base colour, lighter at the top; the
         // defs ride into the SVG / PDF / PNG exports with the boxes
@@ -10085,6 +10495,10 @@ function (root, d3, forester, phyloXml) {
             }
             let set = row.transform ? pathSet() : track;
             let geo = forester.domainBoxes(da, row.start, f, _state.domainEvalueExponent);
+            // once per ROW: displayNodeName walks the node's properties when a
+            // label-ref visualization is on, and a row can hold dozens of boxes
+            let rowTip = displayNodeName(row.d) || '';
+            let rowLength = Number(da.length) || 0;
             let h = row.h;
             let y1 = row.y1;
             set.backbones.push(roundRectPath(geo.backbone.x, y1 + (h / 2) - 0.5, geo.backbone.w, 1, 0));
@@ -10108,7 +10522,13 @@ function (root, d3, forester, phyloXml) {
                     });
                 }
                 bodies.push({x: b.x, y: y1, w: b.w, h: h, r: r, transform: row.transform,
-                    fill: gradientFor(base), stroke: forester.domainDarken(base, 0.24)});
+                    fill: gradientFor(base), stroke: forester.domainDarken(base, 0.24),
+                    // what the hover readout says. Carried per BOX rather than
+                    // looked up again on hover: the boxes are pooled and
+                    // reused between redraws, so an index into the tree would
+                    // go stale the moment the tips on screen change.
+                    info: {name: b.name, from: b.from, to: b.to, evalue: b.evalue, id: b.id,
+                        tip: rowTip, proteinLength: rowLength}});
                 if (row.labelsOn && b.name && fs > 4 && legendTextWidth(b.name, font) <= b.w - 4) {
                     names.push({x: b.x + (b.w / 2), y: y1 + (h / 2), font: font,
                         fill: forester.domainLabelInk(base), text: b.name});
@@ -10132,6 +10552,11 @@ function (root, d3, forester, phyloXml) {
             paths[k].style.fill = u.fill;
             paths[k].style.fillOpacity = u.opacity;
         });
+        // A redraw can take the hovered box away without the pointer moving
+        // -- a keyboard zoom, a panel change applied with Enter, a collapse --
+        // and a removed element fires no mouseout, so the readout would stay
+        // painted over a domain that is no longer there.
+        domainHoverOut();
         let rects = sizeLayer(bodyLayer, 'rect', bodies.length);
         bodies.forEach(function (b, k) {
             let el = rects[k];
@@ -10149,6 +10574,11 @@ function (root, d3, forester, phyloXml) {
             el.style.fill = b.fill;
             el.style.stroke = b.stroke;
             el.style.strokeWidth = 1;
+            el.__aptxDomain = b.info;
+            // only where there is somewhere to go: an unnamed domain with no
+            // accession has no reference, and a hand cursor over it would
+            // promise a link that the click cannot deliver
+            el.style.cursor = forester.domainReference(b.info) ? 'pointer' : 'default';
         });
         let texts = sizeLayer(labelLayer, 'text', names.length);
         names.forEach(function (t, k) {
@@ -11738,7 +12168,7 @@ function (root, d3, forester, phyloXml) {
         if (matches.length > SUGGEST_MAX_ROWS) {
             let more = document.createElement('div');
             more.className = 'aptx-suggest-more';
-            more.textContent = (matches.length - SUGGEST_MAX_ROWS) + ' more — keep typing';
+            more.textContent = (matches.length - SUGGEST_MAX_ROWS) + ' more, keep typing';
             box.appendChild(more);
         }
         document.body.appendChild(box);
@@ -11934,10 +12364,11 @@ function (root, d3, forester, phyloXml) {
         if (alignBtn) {
             alignBtn.disabled = _state.unrootedDisplay || _basicTreeProperties.branchLengths !== true;
         }
-        let dyna = byId(DYNAHIDE_CB);
-        if (dyna) {
-            dyna.disabled = _state.unrootedDisplay;
-        }
+        // Auto-hide Labels stays live in every layout. It used to be greyed out
+        // in unrooted, where the tip-label decimation it governs does not run --
+        // but it also governs the crowded branch-data rule, which does run
+        // there, so greying it out left the user unable to switch off something
+        // that was happening.
         let msaCb = byId(MSA_CB);
         if (msaCb) {
             msaCb.disabled = radialDisplay();
@@ -12165,7 +12596,8 @@ function (root, d3, forester, phyloXml) {
         }
         item.classList.toggle('aptx-check-active', !!active);
         item.title = active
-            ? item.dataset.baseTitle + ' — hiding now: 1 in ' + _dynahide_factor + ' labels shown'
+            ? item.dataset.baseTitle + ', hiding now: 1 in ' + _dynahide_factor
+                + ' labels shown, and branch data that would overlap'
             : item.dataset.baseTitle;
     }
 
@@ -12795,6 +13227,15 @@ function (root, d3, forester, phyloXml) {
     }
 
     // The theme toggle, showing the theme it will switch TO.
+    // A circled "i": the tree-properties button. The stem is a stroke and the
+    // tittle a filled dot, so both keep their shape at the 20px the header
+    // button draws them at.
+    function glyphInfo() {
+        return '<circle cx="50" cy="50" r="40"/>'
+            + glyphLine(50, 45, 50, 71)
+            + glyphDot(50, 29, 5.5);
+    }
+
     function glyphSun() {
         let s = glyphDot(50, 50, 20);
         for (let i = 0; i < 8; ++i) {
@@ -12862,6 +13303,7 @@ function (root, d3, forester, phyloXml) {
             case 'uncollapse_all': sw = 8.5; cap = 'round'; body = glyphUncollapseAll(); break;
             case 'tree_prev': sw = 9; cap = 'round'; body = glyphChevron(false); break;
             case 'tree_next': sw = 9; cap = 'round'; body = glyphChevron(true); break;
+            case 'info': sw = 7; cap = 'round'; body = glyphInfo(); break;
             case 'sun': body = glyphSun(); break;
             case 'moon': body = glyphMoon(); break;
             default: throw new Error('unknown control-panel glyph: ' + kind);
@@ -13000,7 +13442,14 @@ function (root, d3, forester, phyloXml) {
             + '@media (prefers-reduced-motion:reduce){ .aptx-busy-dot { animation:none;'
             + '  border-color:var(--p-accent); } }'
             + '.aptx-busy-sub { color:var(--p-muted); }'
+            // The same frosted glass as the node menu and the suggestion list:
+            // --p-bg is deliberately translucent (0.86) so panels float over
+            // the tree, but without the blur a dialog puts dense text straight
+            // on top of whatever is behind it -- and over an alignment or a
+            // heat map that is a rainbow. The menus had the blur from the
+            // start; the dialogs were simply missed.
             + '.aptx-dialog { padding:0; border:1px solid var(--p-line-strong); border-radius:12px;'
+            + '  -webkit-backdrop-filter:blur(8px); backdrop-filter:blur(8px);'
             + '  background:var(--p-bg); color:var(--p-ink); max-width:92vw;'
             + '  box-shadow:0 24px 48px -16px rgba(23,34,46,0.45),0 4px 12px -4px rgba(23,34,46,0.22);'
             + '  font-family:system-ui,-apple-system,"Segoe UI",Roboto,Helvetica,Arial,sans-serif;'
@@ -13045,6 +13494,9 @@ function (root, d3, forester, phyloXml) {
             + '.aptx-dialog-key { flex:0 0 42%; color:var(--p-muted); }'
             + '.aptx-dialog-val { flex:1 1 auto; min-width:0; overflow-wrap:anywhere; }'
             // the shortcuts cheat sheet: key chips in the key column
+            + '.aptx-props .aptx-props-head { font-size:10px; letter-spacing:.08em; text-transform:uppercase; color:var(--p-muted); margin:12px 0 3px; }'
+            + '.aptx-props > div:first-child { margin-top:0; }'
+            + '.aptx-props .aptx-dialog-key { flex-basis:46%; }'
             + '.aptx-shortcuts .aptx-dialog-key { flex-basis:38%; display:flex; align-items:center; }'
             + '.aptx-shortcuts .aptx-dialog-val { align-self:center; }'
             + '.aptx-keys { display:inline-flex; gap:3px; flex-wrap:wrap; }'
@@ -13199,7 +13651,7 @@ function (root, d3, forester, phyloXml) {
             + '.aptx-panel .aptx-seg:has(> input:checked) { background:var(--p-accent); color:#fff; }'
             + '.aptx-panel .aptx-seg:has(> input:disabled) { opacity:0.4; cursor:default; }'
             + '.aptx-panel .aptx-actions { margin-left:auto; display:flex; align-items:center; gap:5px; }'
-            + '.aptx-panel .aptx-theme-btn { flex:none; width:20px; height:20px; display:grid; place-items:center; padding:0; border:1px solid var(--p-line-strong); border-radius:6px; background:var(--p-surface2); color:var(--p-muted); cursor:pointer; font-size:12px; line-height:1; }'
+            + '.aptx-panel .aptx-theme-btn, .aptx-panel .aptx-info-btn { flex:none; width:20px; height:20px; display:grid; place-items:center; padding:0; border:1px solid var(--p-line-strong); border-radius:6px; background:var(--p-surface2); color:var(--p-muted); cursor:pointer; font-size:12px; line-height:1; }'
             + '.aptx-panel .aptx-theme-btn:hover { background:var(--p-accent-weak); color:var(--p-accent-ink); border-color:var(--p-accent); }'
             + '.aptx-panel input[type=range] { -webkit-appearance:none; appearance:none; display:block; width:100%; height:15px; margin:2px 0 9px; padding:0; background:transparent; cursor:pointer; }'
             + '.aptx-panel input[type=range]::-webkit-slider-runnable-track { height:4px; border-radius:999px; background:var(--p-line-strong); }'
@@ -13354,6 +13806,24 @@ function (root, d3, forester, phyloXml) {
             let actions = document.createElement('div');
             actions.className = 'aptx-actions';
 
+            let infoBtn = document.createElement('button');
+            infoBtn.type = 'button';
+            // NOT aptx-theme-btn: applyPanelTheme repaints the innerHTML of
+            // every element carrying that class with the sun/moon, so
+            // borrowing it for the chrome replaced this glyph the instant a
+            // theme was applied. The two share their styling through the CSS
+            // selector instead, which is all the class was wanted for.
+            infoBtn.className = 'aptx-info-btn';
+            infoBtn.title = 'Tree properties and statistics ('
+                + (IS_MAC ? '\u2318I' : 'Ctrl+I') + ')';
+            infoBtn.setAttribute('aria-label', 'Tree properties and statistics');
+            infoBtn.innerHTML = makeGlyph('info');
+            infoBtn.addEventListener('click', function (e) {
+                e.stopPropagation();
+                showTreePropertiesDialog();
+            });
+            actions.appendChild(infoBtn);
+
             let progName = header.querySelector('.' + PROGNAMELINK);
             if (progName) {
                 // Clicking the title used to navigate away to the project site;
@@ -13927,6 +14397,257 @@ function (root, d3, forester, phyloXml) {
         shell.dialog.showModal();
     }
 
+    // ===================== Tree properties =====================
+    // What the tree IS and what it carries: the desktop's View > Tree
+    // Properties, read-only (Christian, 2026-09-23 -- the editable half waits
+    // for demand). Nothing else in the viewer answers "what is actually in
+    // this file", which is the first question a tree raises.
+    //
+    // Computed FRESH every time it opens rather than cached: the whole of
+    // collectBasicTreeProperties costs 7ms on the 13,246-tip H5N1 demo, and a
+    // cache would go stale the moment the user re-roots or enters a subtree.
+    // It describes what is ON SCREEN, so in a subtree it describes the
+    // subtree, and says so.
+    //
+    // Every value goes in through textContent. Tree names, descriptions and
+    // identifiers are file data, and file data never becomes markup.
+
+    function treePropRow(parent, label, value) {
+        if (value === null || value === undefined || value === '') {
+            return;
+        }
+        let line = document.createElement('div');
+        line.className = 'aptx-dialog-line';
+        let k = document.createElement('span');
+        k.className = 'aptx-dialog-key';
+        k.textContent = label;
+        let v = document.createElement('span');
+        v.className = 'aptx-dialog-val';
+        v.textContent = String(value);
+        line.appendChild(k);
+        line.appendChild(v);
+        parent.appendChild(line);
+    }
+
+    function treePropSection(body, title) {
+        let h = document.createElement('div');
+        h.className = 'aptx-props-head';
+        h.textContent = title;
+        body.appendChild(h);
+        let box = document.createElement('div');
+        body.appendChild(box);
+        return box;
+    }
+
+    function countNumber(n) {
+        return (typeof n === 'number' && isFinite(n)) ? n.toLocaleString() : null;
+    }
+
+    // A number for a fact row: thousands separators for counts, and enough
+    // significant digits for a branch length, which can be 5e-9.
+    function statNumber(v, digits) {
+        if (typeof v !== 'number' || !isFinite(v)) {
+            return null;
+        }
+        if (v === 0 || (Math.abs(v) >= 0.001 && Math.abs(v) < 1e7)) {
+            return String(forester.roundNumber(v, digits === undefined ? 6 : digits));
+        }
+        return v.toExponential(3);
+    }
+
+    // "1,234 of 5,678 tips", the desktop's coverage phrasing.
+    function statOf(part, whole, noun) {
+        if (!(whole > 0)) {
+            return null;
+        }
+        return countNumber(part) + ' of ' + countNumber(whole) + (noun ? (' ' + noun) : '');
+    }
+
+    // n / minimum / median / maximum / mean, the block Christian asked for in
+    // place of a histogram. One shape, used for branch lengths and for each
+    // kind of support, so the two read the same way.
+    function statSpread(box, d, digits) {
+        treePropRow(box, 'Minimum', statNumber(d.min, digits));
+        treePropRow(box, 'Median', statNumber(d.median, digits));
+        treePropRow(box, 'Maximum', statNumber(d.max, digits));
+        treePropRow(box, 'Mean', statNumber(d.mean, digits));
+    }
+
+    function showTreePropertiesDialog() {
+        if (!_root) {
+            return;
+        }
+        let shell = makeDialogShell(TREE_PROPERTIES_DIALOG, 'Tree properties', 420);
+        shell.body.classList.add('aptx-props');
+        // A description is free text and can be a paragraph, and the coverage
+        // section grows with the annotations, so the body scrolls rather than
+        // running off the screen.
+        shell.body.style.maxHeight = '66vh';
+        shell.body.style.overflowY = 'auto';
+        let st = forester.treeStatistics(_root);
+        let bp = forester.collectBasicTreeProperties(_root);
+        let time = forester.timeAxisInfo(_root);
+        let phy = _treeData || {};
+
+        // --- what the tree says it is ---------------------------------
+        let box = treePropSection(shell.body, 'Tree');
+        treePropRow(box, 'Name', phy.name);
+        treePropRow(box, 'Description', phy.description);
+        if (phy.id && phy.id.value) {
+            treePropRow(box, 'Identifier', phy.id.provider
+                ? (phy.id.value + '  (' + phy.id.provider + ')') : phy.id.value);
+        }
+        treePropRow(box, 'Type', phy.type);
+        treePropRow(box, 'Branch-length unit', phy.branch_length_unit);
+        // Only when the FILE said so. phyloXML has a rooted attribute and a
+        // Nexus tree statement has [&R]/[&U]; plain Newick says nothing, and a
+        // properties dialog that answered "yes" there would be reporting our
+        // writing default as though the file had stated it.
+        if (typeof phy.rooted === 'boolean') {
+            treePropRow(box, 'Rooted', phy.rooted ? 'yes' : 'no');
+        }
+        if (typeof phy.rerootable === 'boolean') {
+            treePropRow(box, 'Rerootable', phy.rerootable ? 'yes' : 'no');
+        }
+        if (_trees && _trees.length > 1) {
+            treePropRow(box, 'In this file', 'tree ' + (_treeIndex + 1) + ' of ' + _trees.length);
+        }
+        if (_in_subtree) {
+            treePropRow(box, 'Showing', 'a subtree, not the whole tree');
+        }
+        if (!box.firstChild) {
+            treePropRow(box, 'Name', '(the tree carries no name or metadata)');
+        }
+
+        // --- shape ----------------------------------------------------
+        box = treePropSection(shell.body, 'Structure');
+        treePropRow(box, 'Tips', countNumber(st.tips));
+        treePropRow(box, 'Internal nodes', countNumber(st.internal));
+        treePropRow(box, 'Nodes, total', countNumber(st.nodes));
+        treePropRow(box, 'Branches', countNumber(st.branches));
+        treePropRow(box, 'Branching', st.polytomies === 0 ? 'fully binary'
+            : (countNumber(st.polytomies) + (st.polytomies === 1 ? ' polytomy' : ' polytomies')
+                + ', widest ' + countNumber(st.maxChildren) + ' children'));
+        treePropRow(box, 'Depth', countNumber(st.depth) + ' (root to deepest tip)');
+        // ours, not the desktop's, and worth keeping: the label width is what
+        // decides how much room the tree needs, and whether internal nodes are
+        // named decides whether their labels are worth turning on
+        treePropRow(box, 'Longest tip label', bp.longestNodeName > 0
+            ? (countNumber(bp.longestNodeName)
+                + (bp.longestNodeName === 1 ? ' character' : ' characters')) : null);
+        treePropRow(box, 'Internal nodes named', st.internal > 0
+            ? (st.namedInternal > 0 ? statOf(st.namedInternal, st.internal) : 'none') : null);
+
+        // --- branch lengths -------------------------------------------
+        box = treePropSection(shell.body, 'Branch lengths');
+        if (st.branchLengths) {
+            treePropRow(box, 'Branches with a length',
+                statOf(st.branchLengths.n, st.branches));
+            statSpread(box, st.branchLengths);
+            treePropRow(box, 'Sum', statNumber(st.branchLengths.sum) + ' (total tree length)');
+            treePropRow(box, 'Height', statNumber(st.height) + ' (root to farthest tip)');
+            if (st.branchLengths.zero > 0) {
+                treePropRow(box, 'Zero-length', countNumber(st.branchLengths.zero));
+            }
+            if (st.branchLengths.negative > 0) {
+                treePropRow(box, 'Negative', countNumber(st.branchLengths.negative)
+                    + ' (not drawn to scale)');
+            }
+            treePropRow(box, 'Ultrametric', st.ultrametric
+                ? 'yes (every tip the same distance from the root)' : 'no');
+        } else {
+            treePropRow(box, 'Branches with a length', 'none, the tree has no lengths');
+        }
+
+        // --- support, one section per kind ----------------------------
+        // A bootstrap and a posterior on the same branch are not on one scale,
+        // so they are never pooled: each type gets its own n and spread.
+        st.support.forEach(function (d) {
+            // 'unknown' is what the Newick and Nexus readers put on a bare
+            // [95]: those formats have one support slot and nowhere to name
+            // what it is, so it is an absence of type rather than a type
+            // called unknown, and it should not head a section as one.
+            let untyped = !d.type || d.type === 'unknown';
+            let title = (st.support.length === 1 && untyped)
+                ? 'Support values' : ('Support: ' + (untyped ? 'untyped' : d.type));
+            let sbox = treePropSection(shell.body, title);
+            treePropRow(sbox, 'Branches with support', statOf(d.n, st.branches));
+            statSpread(sbox, d);
+        });
+
+        // --- what came with it ----------------------------------------
+        box = treePropSection(shell.body, 'The tree carries');
+        let carried = 0;
+        function carries(label, present, detail) {
+            if (!present) {
+                return;
+            }
+            ++carried;
+            treePropRow(box, label, detail || 'yes');
+        }
+        carries('Taxonomies', st.tipsWithTaxonomy > 0, statOf(st.tipsWithTaxonomy, st.tips, 'tips')
+            + (st.distinctTaxonomies > 0 ? (', ' + countNumber(st.distinctTaxonomies) + ' distinct') : ''));
+        carries('Taxonomy identifiers', st.tipsWithTaxonomyId > 0,
+            statOf(st.tipsWithTaxonomyId, st.tips, 'tips'));
+        carries('Sequences', st.tipsWithSequence > 0, statOf(st.tipsWithSequence, st.tips, 'tips'));
+        // alignedMolSeqs starts TRUE and is only ever set false, so it means
+        // "no UNALIGNED sequence was seen" -- a tree carrying no sequences at
+        // all reports true. Read alone it told the flu and ammonite demos they
+        // had an alignment. Every other reader in this file pairs it with a
+        // length for the same reason.
+        carries('Molecular sequences', st.tipsWithMolSeq > 0,
+            statOf(st.tipsWithMolSeq, st.tips, 'tips')
+            + (bp.alignedMolSeqs && bp.maxMolSeqLength > 0
+                ? (', aligned, ' + countNumber(bp.maxMolSeqLength) + ' columns') : ''));
+        carries('Domain architectures', st.tipsWithDomains > 0,
+            statOf(st.tipsWithDomains, st.tips, 'tips')
+            + (bp.maxDomainArchitectureLength > 0
+                ? (', up to ' + countNumber(bp.maxDomainArchitectureLength) + ' residues') : ''));
+        carries('Dates', st.nodesWithDate > 0, statOf(st.nodesWithDate, st.nodes, 'nodes'));
+        carries('Distributions', st.tipsWithDistribution > 0,
+            statOf(st.tipsWithDistribution, st.tips, 'tips'));
+        carries('MAD values', bp.madValues);
+        carries('Branch colours', bp.branchColors);
+        if (st.nodesWithEvents > 0) {
+            let parts = [];
+            if (st.duplications > 0) {
+                parts.push(countNumber(st.duplications)
+                    + (st.duplications === 1 ? ' duplication' : ' duplications'));
+            }
+            if (st.speciations > 0) {
+                parts.push(countNumber(st.speciations)
+                    + (st.speciations === 1 ? ' speciation' : ' speciations'));
+            }
+            parts.push(statOf(st.nodesWithEvents, st.nodes, 'nodes'));
+            carries('Events', true, parts.join(', '));
+        }
+        st.propertyRefs.forEach(function (r) {
+            carries('Property ' + r.ref, true, statOf(r.nodes, st.nodes, 'nodes'));
+        });
+        if (carried === 0) {
+            treePropRow(box, 'Annotations', 'none, names and topology only');
+        }
+
+        // --- time -----------------------------------------------------
+        if (time && (time.type || time.dated)) {
+            box = treePropSection(shell.body, 'Time');
+            treePropRow(box, 'Dates', time.type === 'geologic'
+                ? 'geologic ages' : (time.type === 'calendar' ? 'calendar years' : 'yes'));
+            treePropRow(box, 'Dated nodes', statOf(st.nodesWithDate, st.nodes, 'nodes')
+                + (time.dated ? ' (a dated tree)' : ''));
+            if (time.type === 'geologic' && time.rootAge > 0) {
+                treePropRow(box, 'Oldest node', statNumber(time.rootAge, 4) + ' Ma');
+            }
+            if (time.type === 'calendar' && time.presentDate > 0) {
+                treePropRow(box, 'Most recent tip', statNumber(time.presentDate, 4));
+            }
+            treePropRow(box, 'Confidence intervals',
+                (time.hasInternalIntervals || time.hasExternalIntervals) ? 'yes' : null);
+        }
+
+        shell.dialog.showModal();
+    }
+
     // The About box behind the panel's title. Everything here is fixed text and
     // fixed URLs -- no tree data reaches it -- so the links are built as real
     // elements rather than markup.
@@ -14793,10 +15514,10 @@ function (root, d3, forester, phyloXml) {
             // "Auto-hide Labels" matches the desktop, which renamed the historical
             // "Dyna Hide" because that named the mechanism rather than what the user
             // sees. The _state.dynahide field keeps its name internally.
-            opts.push(makeCheckboxItem('Auto-hide Labels', DYNAHIDE_CB, 'automatically hide external labels when the tree is too dense for them to be readable', true));
+            opts.push(makeCheckboxItem('Auto-hide Labels', DYNAHIDE_CB, 'automatically hide external labels, and branch values that would overprint each other, where the tree is too dense for them to be readable', true));
             opts.push(makeCheckboxItem('Short Names', SHORTEN_NODE_NAME_CB, 'to shorten long node names'));
             if (_basicTreeProperties.confidences) {
-                opts.push(makeCheckboxItem('Support Dots', SUPPORT_DOTS_CB, 'to mark every branch with support of at least ' + _settings.supportDotMinimum + '% with a dot at its midpoint'));
+                opts.push(makeCheckboxItem('Support Dots', SUPPORT_DOTS_CB, 'to mark a branch with support of at least ' + _settings.supportDotMinimum + '% with a dot at its midpoint, where there is room to draw it'));
             }
             // Styles and visualizations sit here too, so the Nodes group only
             // appears at all on a tree carrying node/branch events