archaeopteryx 3.12.0 → 3.13.0

package/README.md

@@ -316,6 +316,25 @@ 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.
 
+A tip is written under its **name**; where it has none, under its taxonomy
+(code, then scientific, then common name), then its sequence's name, symbol or
+gene name, then its sequence **accession**, and only if it has none of those
+under a `node<N>` placeholder numbering it by position among the tips. Each
+step is tried in turn, so a taxonomy element that is present but empty does
+not stop the search. An unlabeled *internal* node stays unlabeled — a
+placeholder there would invent a name for an ancestor. Newick and Nexus use
+the one chain, so a tree saved in both formats names its tips identically, and
+it is the desktop Archaeopteryx's chain, compared byte for byte.
+
+Newick and Nexus have **one** support slot per branch and no place to name
+what kind of support it is, so a branch carrying several confidences is
+written with the first that is not a MAD value, exactly as the desktop writes
+it, and a `bootstrap` read back from such a file is typed `unknown`. phyloXML
+keeps every one of them, typed. Everything else survives a trip through
+either format unchanged — names, branch lengths (including zero-length and
+negative branches) and aligned sequences — in both directions, which the test
+suite pins as two standing round trips.
+
 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>
@@ -555,7 +574,19 @@ column blank. Read `n` and judge.
 Alignments arrive with the tree: as phyloXML `<mol_seq is_aligned="true">`
 elements, or in a **Nexus** file whose characters matrix accompanies its tree.
 The **Nexus** entry in the Download menu writes the current tree *and* its
-alignment back into one Nexus file (Taxa, Characters and Trees blocks).
+alignment back into one Nexus file (Taxa, Characters and Trees blocks), in the
+same bytes the desktop Archaeopteryx writes: a row per taxon rather than per
+sequence, so a tip carrying no sequence gets a row of the missing symbol `?`
+and the matrix still covers every taxon the file declares. Reading it back,
+such a row is absence of data and not a sequence of question marks. Residues
+from a Nexus matrix are normalised as the desktop normalises them — raised to
+upper case, `.` read as a gap, and anything outside the declared alphabet read
+as the unspecified residue, `X` for protein and `N` for nucleotides, so the
+missing symbol `?` arrives as `X` or `N`. A phyloXML `<mol_seq>` is kept
+exactly as written, by both programs. Sequences
+of *unequal* length are not an alignment and cannot form a character matrix,
+so they are not written at all — the file says so in a bracketed comment
+rather than padding them into an alignment that does not exist.
 
 ## Heat maps
 
@@ -1021,11 +1052,14 @@ plus Search, and folds the ones that are adjustments to make later: Zoom,
 Sizes and the domain controls. Whatever you open or close is then remembered, for the
 page and across reloads, so a panel you have arranged stays arranged, even
 when you switch to another tree. In a short window it also keeps itself to one
-screen: opening a section folds the one you opened longest ago, but only while
-the panel would not otherwise fit — on a tall screen nothing is ever folded for
-you. Anything that puts something into a folded section opens it, so jumping to
-the search box (⌘F / Ctrl+F), revealing Search B, or a tool reporting its
-result as search hits all unfold Search. A host with little room to give can
+screen: opening a section folds the one you opened longest ago, and dragging
+the window (or the element it sits in) shorter does the same — but only while
+the panel would not otherwise fit, never past the last section left open, and
+never at all on a tall screen. Growing the window back leaves the folds where
+they are: what is open is your choice, and only running out of room overrules
+it. Anything that puts something into a folded section opens it, so jumping to
+the search box (⌘F / Ctrl+F) or a tool reporting its result as search hits
+unfolds Search. A host with little room to give can
 also start the whole panel tighter and narrower with
 [`panelDensity: 'compact'`](#configuration), or collapsed to its header bar
 with `collapseControlPanel`.
@@ -1733,7 +1767,7 @@ readout (`forester.msaResidueInfo`, `msaUngappedPosition`) names the residue
 
 Navigation: a lazily-created bar fixed at the viewport bottom — first / page
 back / slider / page forward / last, a jump-to-column box (1-based, matching
-the hover readout) and a live "column N – M of total" — plus wheel-over-track
+the hover readout) and a live "column N M of total" — plus wheel-over-track
 at a tenth of a screen per notch. Every route lands in one `msaScrollTo()`,
 which clamps and redraws; the tree never moves. A faint dashed guide runs
 from each tip's label (or its node, when labels are hidden) across to that

package/archaeopteryx.js

@@ -20,7 +20,7 @@
  *
  */
 
-// v 3.12.0
+// v 3.13.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.12.0';
+    const VERSION = '3.13.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';
@@ -423,8 +423,6 @@ function (root, d3, forester, phyloXml) {
     const RETURN_TO_SUPERTREE_BUTTON_BY_ONE = 'ret1_b';
     const SEARCH_FIELD_0 = 'sf0';
     const SEARCH_FIELD_1 = 'sf1';
-    const SEARCH_B_WRAP = 'search_b_wrap';
-    const SEARCH_B_TOGGLE = 'search_b_tgl';
     const SEARCH_NAV_ROW = 'searchnavrow';
     const SEARCH_NAV_PREV = 'searchnavprev';
     const SEARCH_NAV_NEXT = 'searchnavnext';
@@ -4088,8 +4086,15 @@ function (root, d3, forester, phyloXml) {
     };
 
 
+    // A branch length of ZERO is a length and gets a label. Testing the
+    // number for truthiness read 0 as "no branch length", so the one branch
+    // whose length is worth pointing out -- two identical sequences, a
+    // multifurcation written out as a run of zero-length branches -- was the
+    // one drawn bare. Same mistake the phyloXML writer was making until
+    // phyloxml 1.1.1; the desktop cannot make it at all, because it marks an
+    // absent length with a sentinel (-1024) rather than with zero.
     let makeBranchLengthLabel = function (phynode) {
-        if (phynode.branch_length) {
+        if (phynode.branch_length !== undefined && phynode.branch_length !== null) {
             if (_state.phylogram && _state.minBranchLengthValueToShow && phynode.branch_length < _state.minBranchLengthValueToShow) {
                 return;
             }
@@ -4117,7 +4122,9 @@ function (root, d3, forester, phyloXml) {
         if (_state.showConfidenceValues && support.length > 0
             && (!_state.minConfidenceValueToShow || support.some(function (c) { return c.value >= _state.minConfidenceValueToShow; }))) {
             support.forEach(function (c) {
-                if (c.value) {
+                // a support of 0 is a support value, and a telling one: the
+                // MAD branch above already tested it this way
+                if (typeof c.value === 'number' && isFinite(c.value)) {
                     parts.push(+c.value.toFixed(CONFIDENCE_VALUE_DIGITS_DEFAULT));
                 }
             });
@@ -7358,8 +7365,11 @@ function (root, d3, forester, phyloXml) {
                 msaScrollTo(Infinity);
             });
 
-            // "column [ 1234 ] - 1357 of 30,000": the box is the left edge of
-            // the window and takes a column to jump to; the rest reads back
+            // "column [ 1234 ] 1357 of 30,000": the box is the left edge of
+            // the window and takes a column to jump to; the rest reads back.
+            // No dash between them -- the box's own border already separates
+            // the two numbers, and a dash sitting against it read as a minus
+            // sign on the number after it.
             let read = document.createElement('span');
             read.className = 'aptx-msa-nav-read';
             let lbl = document.createElement('span');
@@ -7409,7 +7419,7 @@ function (root, d3, forester, phyloXml) {
                 _msaNav._jump.value = String(offset + 1);
             }
             _msaNav._jump.max = String(total);
-            _msaNav._tail.textContent = '\u2013 ' + (offset + visible).toLocaleString()
+            _msaNav._tail.textContent = (offset + visible).toLocaleString()
                 + ' of ' + total.toLocaleString();
             let atStart = offset <= 0;
             let atEnd = offset >= total - visible;
@@ -9291,9 +9301,6 @@ function (root, d3, forester, phyloXml) {
         if (want.value) {
             openPanelSection('Search');   // a view carrying a search shows it
         }
-        if (idx === 1 && want.value) {
-            showSearchB();
-        }
     }
 
     // The panel's controls from the state, after applyViewState
@@ -10429,30 +10436,6 @@ function (root, d3, forester, phyloXml) {
         });
     }
 
-    // Search B starts hidden to keep the panel compact; one click (or a
-    // configured initial value) reveals it, and it stays revealed.
-    // Search B is folded away until wanted: the '+ Search B' link (which
-    // focuses it) or a view that carries a second search.
-    function showSearchB() {
-        openPanelSection('Search');
-        let wrap = byId(SEARCH_B_WRAP);
-        if (wrap) {
-            wrap.style.display = '';
-        }
-        let tgl = byId(SEARCH_B_TOGGLE);
-        if (tgl) {
-            tgl.style.display = 'none';
-        }
-    }
-
-    function revealSearchB() {
-        showSearchB();
-        let f = byId(SEARCH_FIELD_1);
-        if (f) {
-            f.focus();
-        }
-    }
-
     // ===================== Time axis =====================
     // The desktop's time overlays, drawn beneath a rectangular PHYLOGRAM of
     // a dated tree: the two-band ICS geologic axis with a "Ma before
@@ -11441,8 +11424,6 @@ function (root, d3, forester, phyloXml) {
         }
         if (_state.searchBinitialValue) {
             setValue(SEARCH_FIELD_1, _state.searchBinitialValue);
-            revealSearchB();
-
         } else {
             setValue(SEARCH_FIELD_1, '');
         }
@@ -12539,7 +12520,13 @@ function (root, d3, forester, phyloXml) {
             let open = panelSections(panel).filter(function (s) {
                 return !s.fieldset.classList.contains('aptx-collapsed') && s.name !== justOpened;
             });
-            if (open.length === 0) {
+            // Never the one just opened -- that is the one the user asked
+            // for -- and never the last one standing. Without the second
+            // clause a container dragged short enough empties the panel down
+            // to a stack of legends, taking away the section being worked in.
+            // (justOpened is itself open and excluded from this list, so when
+            // it is set the last one standing is already protected above.)
+            if (open.length === 0 || (!justOpened && open.length === 1)) {
                 return;
             }
             open.sort(function (a, b) {
@@ -13246,8 +13233,6 @@ function (root, d3, forester, phyloXml) {
             + '.aptx-panel .aptx-slider-row { display:flex; align-items:center; gap:7px; margin:3px 0; }'
             + '.aptx-panel .aptx-slider-row label { flex:0 0 42px; font-size:10px; color:var(--p-muted); }'
             + '.aptx-panel .aptx-slider-row input[type=range] { flex:1 1 auto; min-width:0; margin:0; }'
-            + '.aptx-panel .aptx-linkbtn { background:none; border:0; padding:1px 0 2px; margin:0; font:inherit; font-size:10px; color:var(--p-accent); cursor:pointer; display:block; }'
-            + '.aptx-panel .aptx-linkbtn:hover { text-decoration:underline; }'
             // one row, its buttons sharing it evenly, its edges on the zoom rows'
             + '.aptx-panel .aptx-toolrow { margin-top:5px; display:flex; gap:3px; }'
             + '.aptx-panel .aptx-toolrow .aptx-gbtn { flex:1 1 0; min-width:0; padding:0; margin:2px 0; }'
@@ -13455,6 +13440,20 @@ function (root, d3, forester, phyloXml) {
         // spare, since the user opened none of them just now.
         fitPanelSections(panel, null);
 
+        // ... and again whenever the room changes. The panel is held to its
+        // container's height, so a window dragged shorter (or a host resizing
+        // the div around us) can push an arrangement that fitted a moment ago
+        // into a scrollbar. Watching the CONTAINER, not the panel: folding a
+        // section changes the panel's height and would re-enter the observer.
+        // One-way on purpose -- growing the window back does NOT reopen what
+        // was folded. What is open is the user's choice; only running out of
+        // room may overrule it, and then only far enough to fit.
+        if (typeof ResizeObserver !== 'undefined' && panel.parentElement) {
+            new ResizeObserver(function () {
+                fitPanelSections(panel, null);
+            }).observe(panel.parentElement);
+        }
+
         // Apply the current light/dark choice to this (and every) panel.
         applyPanelTheme();
     }
@@ -13599,7 +13598,8 @@ function (root, d3, forester, phyloXml) {
         if (d.name) {
             text += 'Name: ' + d.name + '<br>';
         }
-        if (d.branch_length && !(unrooted && d.children)) {
+        if (d.branch_length !== undefined && d.branch_length !== null
+            && !(unrooted && d.children)) {
             text += (unrooted ? 'Branch length: ' : 'Distance to parent: ') + d.branch_length + '<br>';
         }
         let date = dateText(d.date);
@@ -14241,7 +14241,6 @@ 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);
         });
@@ -14985,14 +14984,14 @@ function (root, d3, forester, phyloXml) {
             h = h.concat('<fieldset>');
             h = h.concat('<legend>Search</legend>');
             h = h.concat(makeSearchBox('Search A', 0));
-            // Search B starts hidden, one click away: the second box (and the
-            // Combine control it brings) is rarely needed, and the panel is
-            // long enough without it
-            h = h.concat('<button type="button" class="aptx-linkbtn" id="' + SEARCH_B_TOGGLE
-                + '" title="add a second search box, combinable with the first">+ Search B</button>');
-            h = h.concat('<div id="' + SEARCH_B_WRAP + '" style="display:none">');
+            // Search B used to sit behind a '+ Search B' link, to keep 45px out
+            // of the panel. That link was a second, weaker disclosure mechanism
+            // nested inside the section fold: it was forgotten on every reload
+            // (the fold is remembered), it was one-way -- nothing put B back --
+            // and it defeated the fit rule, since revealing B grew a section
+            // that had just been fitted without it, leaving the panel to
+            // scroll. The fold IS the disclosure. B is simply here.
             h = h.concat(makeSearchBox('Search B', 1));
-            h = h.concat('</div>');
             h = h.concat('<div class="aptx-searchnav" id="' + SEARCH_NAV_ROW + '" style="display:none">');
             h = h.concat('<button type="button" class="aptx-gbtn" id="' + SEARCH_NAV_PREV
                 + '" title="center the previous search hit">&#9664;</button>');
@@ -15207,7 +15206,6 @@ function (root, d3, forester, phyloXml) {
         }
         if (_state.searchBinitialValue) {
             setValue(SEARCH_FIELD_1, _state.searchBinitialValue);
-            revealSearchB();
         }
     }
 

package/forester.js

@@ -20,7 +20,7 @@
  *
  */
 
-// v 3.12.0
+// v 3.13.0
 // 2026-09-17
 //
 // forester.js is a general suite for dealing with phylogenetic trees.
@@ -5010,6 +5010,40 @@
         });
     };
 
+    // Residue normalization for a Nexus character matrix, ported from the
+    // desktop's BasicSequence.createAaSequence / createDnaSequence /
+    // createRnaSequence, which is what its Nexus reader builds a sequence
+    // with. Three steps, in this order:
+    //   1. uppercase;
+    //   2. '.' becomes the gap '-'  (before step 3, or it would become X/N);
+    //   3. anything outside the type's alphabet becomes the unspecified
+    //      residue, 'X' for protein and 'N' for nucleotides.
+    // So the Nexus missing symbol '?' arrives as X or N, which is what
+    // Christian decided on 2026-09-23 ("normalize to X, same as desktop").
+    // '?' is simply one character outside the alphabet; doing it alone would
+    // have left us differing on '.' and on stray letters instead.
+    //
+    // This is the NEXUS MATRIX reader only. A phyloXML <mol_seq> is kept
+    // exactly as written by both programs -- measured, not assumed: the
+    // desktop reads "MK??AL.N" out of phyloXML unchanged.
+    const AA_NOT_ALPHABET = /[^ARNDBCQEZGHILKMFPSTWYVXUO\-*]/g;
+    const DNA_NOT_ALPHABET = /[^ACGTRYMKWSN\-*]/g;
+    const RNA_NOT_ALPHABET = /[^ACGURYMKWSN\-*]/g;
+
+    function normalizeMatrixResidues(block, datatype) {
+        let out = block.toUpperCase().replace(/\./g, '-');
+        if (datatype === 'protein') {
+            return out.replace(AA_NOT_ALPHABET, 'X');
+        }
+        if (datatype === 'dna') {
+            return out.replace(DNA_NOT_ALPHABET, 'N');
+        }
+        if (datatype === 'rna') {
+            return out.replace(RNA_NOT_ALPHABET, 'N');
+        }
+        return out;
+    }
+
     // Parses a Nexus-formatted string and returns an ARRAY of tree objects,
     // each in the same shape parseNewHampshire produces (a Nexus file can
     // hold any number of trees). Ported from the desktop's
@@ -5031,6 +5065,10 @@
         const RESIDUES_RE = /^[A-Za-z\-_*?.]+$/;
         const DATATYPE_RE = /datatype\s*=\s*([a-z]+)/;
         const MATCHCHAR_RE = /matchchar\s*=\s*['"]?(\S)/;
+        // the desktop's patterns, character for character: one optional space
+        // either side of the '=', then the first non-space as the symbol
+        const MISSING_RE = /missing\s?.\s?(\S)/;
+        const GAP_RE = /gap\s?.\s?(\S)/;
 
         let trees = [];
         let taxlabels = [];
@@ -5058,6 +5096,22 @@
         let isRooted = false;
         let matchchar = null;
         let matrixReferenceId = null;
+        // The symbols a block DECLARES for missing data and for a gap. Nexus
+        // lets a file choose them, so assuming '?' and '-' reads an all-missing
+        // row of a "Missing=N" file as real residues -- the invented-sequence
+        // bug the residue scan exists to prevent. Defaults are the conventions.
+        let missingChar = '?';
+        let gapChar = '-';
+        // Matrix ids whose row carried at least one real residue. A row of
+        // nothing but the missing and gap symbols states that the taxon has NO
+        // data, and must not become a sequence: our own writer emits exactly
+        // such rows to keep the matrix rectangular, so without this a save and
+        // reopen invents a sequence of question marks for every tip that never
+        // had one. Tracked here rather than tested on the finished sequence
+        // because the desktop turns '?' into 'X' when it builds an AA
+        // sequence, after which a missing row is indistinguishable from a
+        // genuinely ambiguous one.
+        let seqIdsWithResidues = Object.create(null);
 
         // Nexus treats '_' and ' ' as equivalent, labels may be quoted, and a
         // matrix often capitalizes taxon names differently from the tree -- so
@@ -5168,6 +5222,19 @@
                 }
                 block = resolved;
             }
+            // '*' is NOT absence: it is a residue, the stop codon of a
+            // translated alignment. What counts as absence is what the block
+            // DECLARED, plus '.', which is the matchchar and gap convention.
+            for (let j = 0; j < block.length; ++j) {
+                let c = block.charAt(j).toLowerCase();
+                if (c !== missingChar.toLowerCase() && c !== gapChar.toLowerCase() && c !== '.') {
+                    seqIdsWithResidues[id] = true;
+                    break;
+                }
+            }
+            // ... and only THEN normalize: afterwards '?' has become X or N
+            // and a row of nothing but missing data would read as residues.
+            block = normalizeMatrixResidues(block, datatype);
             seqs[id] = {
                 value: seqs[id] ? (seqs[id].value + block) : block,
                 type: datatype
@@ -5200,7 +5267,9 @@
             }
             let seqsByKey = Object.create(null);
             for (let id in seqs) {
-                seqsByKey[joinKey(id)] = seqs[id];
+                if (seqIdsWithResidues[id]) {
+                    seqsByKey[joinKey(id)] = seqs[id];
+                }
             }
             let externals = forester.getAllExternalNodes(phy);
             let annotationNs = null;
@@ -5331,6 +5400,9 @@
                 // scope the rows to THIS matrix block, so a later block
                 // cannot cross-contaminate an earlier one
                 seqs = Object.create(null);
+                seqIdsWithResidues = Object.create(null);
+                missingChar = '?';
+                gapChar = '-';
             } else if (inTreesBlock) {
                 if (lc.startsWith('title')) {
                     let tm = TITLE_RE.exec(line);
@@ -5522,6 +5594,14 @@
                     if (mm) {
                         matchchar = mm[1];
                     }
+                    let miss = MISSING_RE.exec(dlc);
+                    if (miss) {
+                        missingChar = miss[1];
+                    }
+                    let gp = GAP_RE.exec(dlc);
+                    if (gp) {
+                        gapChar = gp[1];
+                    }
                     if (dlc === 'matrix' || dlc.startsWith('matrix ')) {
                         inMatrix = true;
                         let after = line.substring(6).trim();
@@ -6087,9 +6167,90 @@
      * @param writeConfidences - to write confidence values in brackets
      * @returns {*} - a New Hampshire (Newick) formatted string.
      */
+    // The label a node is written under, in New Hampshire and in Nexus alike:
+    // name, then taxonomy (code / scientific / common), then the sequence's
+    // name / symbol / gene name, then its ACCESSION -- each step tried in turn,
+    // so a taxonomy element that is present but empty does not stop the search.
+    // An EXTERNAL node left with nothing gets a 'node<N>' placeholder, N being
+    // its 1-based position in tip order; an empty label would not parse back
+    // out of TaxLabels, and in Newick it names nothing at all. An INTERNAL node
+    // does NOT get one: a placeholder there would invent a name for an
+    // ancestor, and an unlabeled internal node is perfectly ordinary.
+    //
+    // ONE chain for both writers. A Nexus file whose TaxLabels, matrix rows and
+    // trees block disagree about a taxon cannot be joined back up, and a tree
+    // saved as Newick and as Nexus should name its tips the same way -- ours
+    // did not, until 2026-09-23: toNexus applied this chain and toNewHampshire
+    // wrote node.name and nothing else, so a nameless tip was HUMAN in one file
+    // and empty in the other. It is the desktop's chain
+    // (PhylogenyNode.toNewHampshire), adopted on Christian's word, and the two
+    // programs' output is compared byte for byte in the tests.
+    function nhNodeLabel(node, placeholder) {
+        let s = node.name || '';
+        if (!s && node.taxonomies && node.taxonomies.length > 0) {
+            let t = node.taxonomies[0];
+            s = t.code || t.scientific_name || t.common_name || '';
+        }
+        if (!s && node.sequences && node.sequences.length > 0) {
+            let q = node.sequences[0];
+            s = q.name || q.symbol || q.gene_name || '';
+        }
+        if (!s && node.sequences && node.sequences.length > 0) {
+            let a = node.sequences[0].accession;
+            s = (a && a.value) ? a.value : '';
+        }
+        if (!s && placeholder) {
+            s = placeholder;
+        }
+        return s;
+    }
+
+    // A placeholder label for every external node, by tip index, in the order
+    // the tips are written (getAllExternalNodes collects them in pre-order from
+    // the far side, so reversing it gives left-to-right). Used only for a node
+    // that nothing else names.
+    //
+    // A tip may literally be CALLED "node2". Minting that same token for a
+    // different tip gives two taxa one label: illegal Nexus, and our own reader
+    // takes the repeated row for an interleaved continuation and hands both
+    // tips the two sequences joined together. So the labels the tree already
+    // produces are collected first and stepped over.
+    function tipPlaceholders(phy) {
+        let m = new Map();
+        // An EMPTY tree has no tips to number. Its single top node looks like
+        // an external node -- no children -- and numbering it would turn the
+        // empty string, which parseNewHampshire accepts and toNewHampshire has
+        // always written back as the empty string, into "node1;". (The desktop
+        // throws on an empty string rather than parsing it, so there is no
+        // joint behaviour to match here, only ours to keep.)
+        if (!phy.children || phy.children.length !== 1 || !phy.children[0].children) {
+            return m;
+        }
+        let ext = forester.getAllExternalNodes(phy).reverse();
+        let taken = Object.create(null);
+        ext.forEach(function (n) {
+            let label = nhNodeLabel(n, null);
+            if (label.length > 0) {
+                taken[label] = true;
+            }
+        });
+        let i = 1;
+        let spare = ext.length + 1;
+        ext.forEach(function (n) {
+            let candidate = 'node' + (i++);
+            while (taken[candidate]) {
+                candidate = 'node' + (spare++);
+            }
+            taken[candidate] = true;
+            m.set(n, candidate);
+        });
+        return m;
+    }
+
     forester.toNewHampshire = function (phy, decPointsMax, replaceChars, writeConfidences) {
         void replaceChars; // retired: see the note above; labels are always quoted now
         let nh = "";
+        let tips = tipPlaceholders(phy);
         if (phy.children && phy.children.length === 1) {
             toNewHampshireHelper(phy.children[0], true);
         }
@@ -6107,8 +6268,9 @@
                 }
                 nh += ")";
             }
-            if (node.name && node.name.length > 0) {
-                nh += sanitizeLabelForNH(node.name);
+            let label = nhNodeLabel(node, tips.get(node));
+            if (label.length > 0) {
+                nh += sanitizeLabelForNH(label);
             }
             if (node.branch_length !== undefined && node.branch_length !== null) {
                 if (decPointsMax && decPointsMax > 0) {
@@ -6120,10 +6282,21 @@
             // 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.
+            //
+            // Newick has ONE slot and phyloXML allows many, so a node carrying
+            // both a bootstrap and a posterior has to lose one of them. It
+            // writes the FIRST that is not MAD, which is what the desktop's
+            // BranchData.getSupportConfidence returns and therefore what its
+            // writer emits -- verified by running it: a node with
+            // bootstrap=95 and posterior=0.99 comes out as "ab:0.3[95]".
+            // This used to require EXACTLY one and so wrote nothing at all,
+            // which lost the bootstrap too, on real files: the repo's own
+            // phyloWithConfidences.xml has a node carrying bootstrap and
+            // likelihood together.
             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 (support.length > 0 && support[0].value !== undefined && support[0].value !== null) {
                 if (decPointsMax && decPointsMax > 0) {
                     nh += "[" + forester.roundNumber(support[0].value, decPointsMax) + "]";
                 } else {
@@ -6137,6 +6310,70 @@
 
     };
 
+    // A node's molecular sequence for the Nexus matrix: the first one carrying
+    // residues, or null. is_aligned is deliberately NOT consulted -- the
+    // desktop's writer does not have that flag and decides on the lengths
+    // instead, and equal lengths are what a character matrix actually
+    // requires. (A JS node may hold several sequences where a desktop node
+    // holds one; the first with residues is the one written.)
+    function molSeqOfNode(node) {
+        if (!node.sequences) {
+            return null;
+        }
+        for (let j = 0; j < node.sequences.length; ++j) {
+            let q = node.sequences[j];
+            if (q.mol_seq && q.mol_seq.value) {
+                return q.mol_seq.value;
+            }
+        }
+        return null;
+    }
+
+    // ForesterUtil.guessMolecularSequenceType, ported verbatim so that the two
+    // programs declare the same DataType for the same residues: the letters a
+    // nucleotide sequence cannot contain, then T for DNA and U for RNA, and
+    // null when the sequence says nothing either way (all gaps, or A/C/G
+    // alone). Note that it reads the residues and ignores any DECLARED type,
+    // which is the desktop's rule and therefore ours -- and the right one:
+    // bunya_glyco.xml declares type="protein" over 121 sequences of pure ACGT.
+    //
+    // F, P and V were added 2026-09-23 on Christian's word, jointly with the
+    // desktop, because the test was missing most of the protein-exclusive
+    // alphabet: under forester's own alphabets that is BDEFHILOPQVXZ and only
+    // DEHILQ were tested. A protein built solely from nucleotide letters
+    // therefore guessed DNA -- MKATSWNP has exactly one protein-exclusive
+    // residue and it was P -- and a matrix wrongly declared DNA comes back
+    // with every non-nucleotide residue replaced by N. Measured against
+    // UniProt residue frequencies, the chance a protein carries none of the
+    // tested letters falls from 12.5% to 3.3% at length 5 and from 1.6% to
+    // 0.11% at length 10; a real alignment of a hundred columns was never at
+    // risk either way. O, X and Z are protein-exclusive too and deliberately
+    // left out: rare enough to buy almost nothing, and every letter added is
+    // one both programs must add.
+    //
+    // V (and B, D, H) are nucleotide ambiguity codes in full IUPAC but not in
+    // forester's DNA alphabet, which maps them to N, so they cannot survive in
+    // a DNA sequence here and testing them for protein is consistent.
+    //
+    // NEITHER PROGRAM RETUNES THIS ALONE. A letter added on one side types the
+    // same file two ways, which is worse than a blind spot they share;
+    // testNexusMatrixDatatype pins the alphabet letter for letter.
+    function guessMolSeqType(v) {
+        let s = v.toUpperCase();
+        if (s.indexOf('L') >= 0 || s.indexOf('I') >= 0 || s.indexOf('E') >= 0
+            || s.indexOf('H') >= 0 || s.indexOf('D') >= 0 || s.indexOf('Q') >= 0
+            || s.indexOf('F') >= 0 || s.indexOf('P') >= 0 || s.indexOf('V') >= 0) {
+            return 'Protein';
+        }
+        if (s.indexOf('T') >= 0) {
+            return 'DNA';
+        }
+        if (s.indexOf('U') >= 0) {
+            return 'RNA';
+        }
+        return null;
+    }
+
     // Writes a phylogeny as a Nexus-formatted string, ported from the
     // desktop's PhylogenyWriter: a TAXA block (Dimensions, TaxLabels) and a
     // TREES block (the tree under its name, [&R]/[&U] rootedness, the same
@@ -6151,95 +6388,148 @@
         // all three go through sanitizeLabelForNH -- the same helper
         // toNewHampshire writes the tree with.
         //
-        // nexusLabel returns the label UNQUOTED, because it is also assigned
-        // to node.name for a nameless tip and toNewHampshire quotes it again
-        // on the way out. The old '_' substitution was idempotent so applying
-        // it twice was harmless; quoting is not, and would emit "'a b'"
-        // wrapped in quotes a second time.
-
-        // label preference as on the desktop: name, then taxonomy
-        // (code/scientific/common), then sequence (name/symbol/gene)
-        function nexusLabel(node, i) {
-            let s = '';
-            if (node.name) {
-                s = node.name;
-            } else if (node.taxonomies && node.taxonomies.length > 0) {
-                let t = node.taxonomies[0];
-                s = t.code || t.scientific_name || t.common_name || '';
-            } else if (node.sequences && node.sequences.length > 0) {
-                let q = node.sequences[0];
-                s = q.name || q.symbol || q.gene_name || '';
-            }
-            if (!s) {
-                s = 'node' + (i + 1); // an empty TaxLabels token would not parse back
-            }
-            return s;
+        // The chain lives in nhNodeLabel, shared with toNewHampshire, and it
+        // returns the label UNQUOTED because every use here quotes it through
+        // sanitizeLabelForNH -- the same helper the tree string goes through.
+        //
+        // No tip is renamed on the way past any more. This used to assign the
+        // computed label to node.name for nameless tips so that toNewHampshire,
+        // which knew only node.name, would write the same token; the caller's
+        // tree was mutated and restored around the call. Now both writers ask
+        // the same function, so there is nothing to patch up.
+        let ext = forester.getAllExternalNodes(phy).reverse();
+        let tips = tipPlaceholders(phy);
+
+        function nexusLabel(node) {
+            return nhNodeLabel(node, tips.get(node));
         }
 
-        let ext = forester.getAllExternalNodes(phy).reverse();
-        // a nameless tip gets its taxa-block label in the TREE as well --
-        // TaxLabels, the Matrix and the Newick must agree on every taxon or
-        // nothing can join them back up (restored before returning, so the
-        // caller's tree is never mutated)
-        let renamed = [];
-        ext.forEach(function (node, i) {
-            if (!node.name) {
-                node.name = nexusLabel(node, i);
-                renamed.push(node);
-            }
-        });
         let s = '#NEXUS\n';
         s += 'Begin Taxa;\n';
         s += ' Dimensions NTax=' + ext.length + ';\n';
         s += ' TaxLabels';
-        ext.forEach(function (node, i) {
-            s += ' ' + sanitizeLabelForNH(nexusLabel(node, i));
+        ext.forEach(function (node) {
+            s += ' ' + sanitizeLabelForNH(nexusLabel(node));
         });
         s += ';\n';
         s += 'End;\n';
 
-        let rows = [];
-        let nchar = 0;
-        let datatype = null;
+        // Every tip's label and, where there is one, its molecular sequence.
+        // Written to the desktop's rules (PhylogenyWriter.writeNexusCharactersBlock),
+        // because a Nexus file is a joint artifact: whichever program wrote it,
+        // the other has to read the same bytes back.
+        let labels = ext.map(function (node) {
+            return sanitizeLabelForNH(nexusLabel(node));
+        });
+        let withSeq = [];
         ext.forEach(function (node, i) {
-            if (!node.sequences) {
-                return;
+            let v = molSeqOfNode(node);
+            if (v !== null) {
+                withSeq.push({i: i, value: v});
+            }
+        });
+        if (withSeq.length > 0) {
+            // A matrix is keyed on the taxon label, so two tips sharing one
+            // cannot be told apart: our reader takes the second row for an
+            // interleaved continuation and hands BOTH tips the two sequences
+            // joined together. The Taxa and Trees blocks have always written
+            // such a tree -- invalid Nexus, but only cosmetically; a matrix
+            // would make it corrupting, so it is not written.
+            let seen = Object.create(null);
+            let duplicate = null;
+            for (let k = 0; k < labels.length; ++k) {
+                if (seen[labels[k]]) {
+                    duplicate = labels[k];
+                    break;
+                }
+                seen[labels[k]] = true;
+            }
+            if (duplicate !== null) {
+                s += '[ Molecular sequences were not written: two or more tips share the taxon label '
+                    + duplicate + ', and a character matrix keyed on an ambiguous label cannot be'
+                    + ' read back. ]\n';
+                withSeq = [];
+            }
+        }
+        if (withSeq.length > 0) {
+            let nchar = withSeq[0].value.length;
+            let ragged = -1;
+            for (let k = 1; k < withSeq.length; ++k) {
+                if (withSeq[k].value.length !== nchar) {
+                    ragged = withSeq[k].value.length;
+                    break;
+                }
             }
-            for (let j = 0; j < node.sequences.length; ++j) {
-                let q = node.sequences[j];
-                if (q.mol_seq && q.mol_seq.is_aligned && q.mol_seq.value) {
-                    rows.push({label: sanitizeLabelForNH(nexusLabel(node, i)), value: q.mol_seq.value});
-                    nchar = Math.max(nchar, q.mol_seq.value.length);
-                    if (!datatype && (q.type === 'protein' || q.type === 'dna' || q.type === 'rna')) {
-                        datatype = q.type;
+            if (ragged >= 0) {
+                // A Nexus matrix is rectangular, so sequences of unequal length
+                // cannot be one: padding them would state an alignment that
+                // does not exist. Say so in the file rather than leaving the
+                // reader to wonder where the data went.
+                s += '[ Molecular sequences were not written: they are of unequal length ('
+                    + nchar + ' vs ' + ragged + '), so they are not an alignment and cannot'
+                    + ' form a Nexus character matrix. ]\n';
+            } else {
+                // The datatype is a property of the whole MATRIX, so every
+                // sequence decides it, not the first one that guesses non-null.
+                // guessMolSeqType looks for residues only protein has, so a
+                // short protein made of nucleotide letters guesses DNA -- and a
+                // matrix wrongly declared DNA is read back with every
+                // non-nucleotide residue replaced by N (MKATSWNP came back
+                // MKATSWNN). Protein therefore wins any disagreement: calling a
+                // nucleotide alignment protein leaves the residues readable,
+                // the reverse destroys them. Gaps and missing symbols are
+                // stripped first so they cannot sway the guess.
+                let datatype = 'Protein';
+                let sawAa = false;
+                let sawNt = false;
+                let isRna = false;
+                for (let k = 0; k < withSeq.length; ++k) {
+                    let bare = withSeq[k].value.replace(/[-.?*]/g, '');
+                    if (bare.length < 1) {
+                        continue;
                     }
-                    return;
+                    let t = guessMolSeqType(bare);
+                    if (t === 'DNA') {
+                        sawNt = true;
+                    } else if (t === 'RNA') {
+                        sawNt = true;
+                        isRna = true;
+                    } else if (t !== null) {
+                        sawAa = true;
+                    }
+                }
+                if (sawNt && !sawAa) {
+                    datatype = isRna ? 'RNA' : 'DNA';
                 }
+                let width = 0;
+                labels.forEach(function (l) {
+                    width = Math.max(width, l.length);
+                });
+                ++width;
+                let missing = '?'.repeat(nchar);
+                let byTip = Object.create(null);
+                withSeq.forEach(function (r) {
+                    byTip[r.i] = r.value;
+                });
+                s += 'Begin Characters;\n';
+                // NChar ONLY: the Nexus standard allows NTax in a CHARACTERS
+                // block's DIMENSIONS solely alongside NEWTAXA (the taxa are the
+                // TAXA block's), and strict readers -- jebl, and so AliView --
+                // reject the file over it
+                s += ' Dimensions NChar=' + nchar + ';\n';
+                s += ' Format DataType=' + datatype + ' Interleave=No Gap=- Missing=?;\n';
+                s += ' Matrix\n';
+                // A row per TAXON, not per sequence: a tip carrying none gets a
+                // row of the missing symbol, so the matrix covers every taxon
+                // the Taxa block declares. parseNexus reads such a row back as
+                // absence of data, never as a sequence of question marks.
+                labels.forEach(function (label, i) {
+                    s += '  ' + label + ' '.repeat(width - label.length) + ' '
+                        + (byTip[i] === undefined ? missing : byTip[i]) + '\n';
+                });
+                s += ' ;\n';
+                s += 'End;\n';
             }
-        });
-        if (rows.length > 0) {
-            if (!datatype) {
-                // no declared type (e.g. the tree came from Newick plus a
-                // fasta): judge on the residues themselves
-                datatype = forester.msaIsNucleotide(rows[0].value) ? 'dna' : 'protein';
-            }
-            let width = 0;
-            rows.forEach(function (r) {
-                width = Math.max(width, r.label.length);
-            });
-            s += 'Begin Characters;\n';
-            // NChar ONLY: the Nexus standard allows NTax in a CHARACTERS
-            // block's DIMENSIONS solely alongside NEWTAXA (the taxa are the
-            // TAXA block's), and strict readers -- jebl, and so AliView --
-            // reject the file over it
-            s += ' Dimensions NChar=' + nchar + ';\n';
-            s += ' Format DataType=' + datatype + ' Missing=? Gap=-;\n';
-            s += ' Matrix\n';
-            rows.forEach(function (r) {
-                s += '  ' + r.label + ' '.repeat(width - r.label.length + 1) + r.value + '\n';
-            });
-            s += ' ;\n';
-            s += 'End;\n';
         }
 
         s += 'Begin Trees;\n';
@@ -6249,9 +6539,6 @@
         s += ' Tree ' + (treeName ? sanitizeLabelForNH(treeName) : 'tree1') + '=';
         s += (phy.rooted === false) ? '[&U]' : '[&R]';
         let nh = forester.toNewHampshire(phy, decPointsMax, true, writeConfidences);
-        renamed.forEach(function (node) {
-            delete node.name;
-        });
         if (nh.length === 0) {
             // an empty tree would otherwise write "Tree tree1=[&R]" with no
             // tree and no terminating ';' -- a syntactically invalid file

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "archaeopteryx",
-  "version": "3.12.0",
+  "version": "3.13.0",
   "description": "Archaeopteryx.js is a software tool for the visualization and analysis of highly annotated phylogenetic trees.",
   "main": "archaeopteryx.js",
   "types": "archaeopteryx.d.ts",
@@ -32,8 +32,8 @@
     "url": "git+https://github.com/cmzmasek/archaeopteryx-js.git"
   },
   "dependencies": {
-    "phyloxml": "^1.1.0",
-    "d3": "^7.9.0"
+    "d3": "^7.9.0",
+    "phyloxml": "^1.1.1"
   },
   "devDependencies": {
     "@eslint/js": "^9.13.0",