archaeopteryx 3.12.0 → 3.14.0

package/forester.js

@@ -20,7 +20,7 @@
  *
  */
 
-// v 3.12.0
+// v 3.14.0
 // 2026-09-17
 //
 // forester.js is a general suite for dealing with phylogenetic trees.
@@ -3814,6 +3814,230 @@
     };
 
 
+    // Everything the Tree Properties dialog reports, gathered in ONE pass:
+    // the desktop's TreeFacts.scan, minus its histogram (Christian, 2026-09-23:
+    // "we don't need a histogram ... but a more detailed stats would be
+    // useful, min, median, max, n, also type ... also need to include the
+    // properties").
+    //
+    // Side-effect free and DOM-free, so it can be tested in Node -- the whole
+    // reason it lives here rather than in the dialog that renders it, which is
+    // the same split the desktop makes between TreeFacts and
+    // TreePropertiesForm.
+    //
+    // Support values are grouped BY TYPE, because a tree can carry a bootstrap
+    // and a posterior on the same branch and their ranges are not comparable
+    // (0-100 against 0-1); averaging them together would produce a number that
+    // describes neither. MAD values are excluded for the same reason they are
+    // excluded from the Newick support slot: they rate a root position, not a
+    // clade.
+    forester.treeStatistics = function (phyOrNode) {
+        // Callers hand this either a phylogeny wrapper or the root node, and
+        // the difference is one extra internal node, one extra branch and one
+        // more of depth -- small enough to read as plausible. getTreeRoot
+        // normalizes both, as collectBasicTreeProperties does.
+        let root = phyOrNode ? forester.getTreeRoot(phyOrNode) : null;
+        let stats = {
+            tips: 0, internal: 0, nodes: 0, branches: 0,
+            polytomies: 0, maxChildren: 0,
+            depth: 0, height: 0, heightKnown: false,
+            collapsed: 0,
+            branchLengths: null,
+            support: [],
+            ultrametric: false,
+            tipsWithTaxonomy: 0, distinctTaxonomies: 0, tipsWithTaxonomyId: 0,
+            tipsWithSequence: 0, tipsWithMolSeq: 0, tipsWithDomains: 0,
+            nodesWithDate: 0, tipsWithDistribution: 0, namedInternal: 0,
+            duplications: 0, speciations: 0, nodesWithEvents: 0,
+            propertyRefs: []
+        };
+        if (!root) {
+            return stats;
+        }
+        let lengths = [];
+        let zeroLengths = 0;
+        let negativeLengths = 0;
+        let byType = Object.create(null);
+        let taxa = Object.create(null);
+        let refs = Object.create(null);
+        let refOrder = [];
+        let tipDepths = [];
+        let maxDepth = 0;
+
+        (function walk(n, depth, distance) {
+            ++stats.nodes;
+            let kids = n.children || [];
+            if (depth > maxDepth) {
+                maxDepth = depth;
+            }
+            if (n !== root) {
+                ++stats.branches;
+                let b = n.branch_length;
+                if (typeof b === 'number' && isFinite(b)) {
+                    lengths.push(b);
+                    if (b === 0) {
+                        ++zeroLengths;
+                    } else if (b < 0) {
+                        ++negativeLengths;
+                    }
+                    distance += b;
+                }
+            }
+            // support, by type, MAD left out
+            if (n.confidences) {
+                for (let i = 0; i < n.confidences.length; ++i) {
+                    let c = n.confidences[i];
+                    if (c.type === forester.MAD_CONFIDENCE_TYPE) {
+                        continue;
+                    }
+                    if (typeof c.value !== 'number' || !isFinite(c.value)) {
+                        continue;
+                    }
+                    let key = c.type || '';
+                    if (!byType[key]) {
+                        byType[key] = [];
+                        stats.support.push({type: key, values: byType[key]});
+                    }
+                    byType[key].push(c.value);
+                }
+            }
+            if (n.date && typeof n.date.value === 'number' && isFinite(n.date.value)) {
+                ++stats.nodesWithDate;
+            }
+            if (n.properties) {
+                let seen = Object.create(null);
+                for (let i = 0; i < n.properties.length; ++i) {
+                    let ref = n.properties[i] && n.properties[i].ref;
+                    if (!ref || seen[ref]) {
+                        continue;   // a node carrying a ref twice counts once
+                    }
+                    seen[ref] = true;
+                    if (refs[ref] === undefined) {
+                        refs[ref] = 0;
+                        refOrder.push(ref);
+                    }
+                    ++refs[ref];
+                }
+            }
+            if (n.events) {
+                ++stats.nodesWithEvents;
+                if (n.events.duplications > 0) {
+                    stats.duplications += n.events.duplications;
+                }
+                if (n.events.speciations > 0) {
+                    stats.speciations += n.events.speciations;
+                }
+            }
+            if (kids.length > 0) {
+                ++stats.internal;
+                if (kids.length > stats.maxChildren) {
+                    stats.maxChildren = kids.length;
+                }
+                if (kids.length > 2) {
+                    ++stats.polytomies;
+                }
+                if (n !== root && n.name) {
+                    ++stats.namedInternal;
+                }
+                for (let i = 0; i < kids.length; ++i) {
+                    walk(kids[i], depth + 1, distance);
+                }
+                return;
+            }
+            ++stats.tips;
+            tipDepths.push(distance);
+            if (n.taxonomies && n.taxonomies.length > 0) {
+                ++stats.tipsWithTaxonomy;
+                let t = n.taxonomies[0];
+                let label = t.scientific_name || t.code || t.common_name || '';
+                if (label) {
+                    taxa[label] = true;
+                }
+                if (t.id && t.id.value) {
+                    ++stats.tipsWithTaxonomyId;
+                }
+            }
+            if (n.sequences && n.sequences.length > 0) {
+                ++stats.tipsWithSequence;
+                let q = n.sequences[0];
+                if (q.mol_seq && q.mol_seq.value) {
+                    ++stats.tipsWithMolSeq;
+                }
+                if (forester.domainArchitectureOf(n)) {
+                    ++stats.tipsWithDomains;
+                }
+            }
+            if (n.distributions && n.distributions.length > 0) {
+                ++stats.tipsWithDistribution;
+            }
+        })(root, 0, 0);
+
+        stats.depth = maxDepth;
+        stats.distinctTaxonomies = Object.keys(taxa).length;
+        stats.propertyRefs = refOrder.map(function (r) {
+            return {ref: r, nodes: refs[r]};
+        });
+        stats.branchLengths = forester.describeValues(lengths);
+        if (stats.branchLengths) {
+            stats.branchLengths.zero = zeroLengths;
+            stats.branchLengths.negative = negativeLengths;
+        }
+        stats.support = stats.support.map(function (g) {
+            let d = forester.describeValues(g.values);
+            d.type = g.type;
+            return d;
+        }).filter(function (d) {
+            return d.n > 0;
+        });
+        if (tipDepths.length > 0) {
+            // running, not Math.min.apply: the spread of 150k tip depths
+            // overflows the call stack, as timeAxisInfo found before this
+            let lo = Infinity;
+            let hi = -Infinity;
+            for (let i = 0; i < tipDepths.length; ++i) {
+                if (tipDepths[i] < lo) {
+                    lo = tipDepths[i];
+                }
+                if (tipDepths[i] > hi) {
+                    hi = tipDepths[i];
+                }
+            }
+            stats.height = hi;
+            stats.heightKnown = lengths.length > 0;
+            // ultrametric: every tip the same distance from the root, to a
+            // tolerance scaled to the tree, since branch lengths are floats
+            stats.ultrametric = stats.heightKnown && (hi - lo) <= (Math.max(hi, 1e-12) * 1e-6);
+        }
+        return stats;
+    };
+
+    // n, minimum, median, maximum, mean and sum of a list of numbers, or null
+    // when there are none. The median is the middle value of the sorted list,
+    // or the mean of the two middle ones -- taken on a COPY, because sorting
+    // the caller's array would reorder data it still owns.
+    forester.describeValues = function (values) {
+        if (!values || values.length === 0) {
+            return null;
+        }
+        let v = values.slice().sort(function (a, b) {
+            return a - b;
+        });
+        let n = v.length;
+        let sum = 0;
+        for (let i = 0; i < n; ++i) {
+            sum += v[i];
+        }
+        let mid = Math.floor(n / 2);
+        return {
+            n: n,
+            min: v[0],
+            max: v[n - 1],
+            median: (n % 2 === 1) ? v[mid] : ((v[mid - 1] + v[mid]) / 2),
+            mean: sum / n,
+            sum: sum
+        };
+    };
+
     forester.calcMaxBranchLength = function (node) {
         let max = 0;
         forester.preOrderTraversalAll(node, function (n) {
@@ -5010,6 +5234,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 +5289,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 +5320,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 +5446,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 +5491,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 +5624,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 +5818,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 +6391,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 +6492,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 +6506,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 +6534,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 +6612,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 = [];
             }
-            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 (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;
+                }
+            }
+            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 +6763,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