archaeopteryx 3.11.0 → 3.13.0

package/forester.js

@@ -20,7 +20,7 @@
  *
  */
 
-// v 3.11.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;
+                    }
+                    let t = guessMolSeqType(bare);
+                    if (t === 'DNA') {
+                        sawNt = true;
+                    } else if (t === 'RNA') {
+                        sawNt = true;
+                        isRna = true;
+                    } else if (t !== null) {
+                        sawAa = true;
                     }
-                    return;
                 }
+                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
@@ -8440,6 +8727,70 @@
         return {scores: scores, consensus: consensus};
     };
 
+    // Per-column sequence logo over the given rows -- the stack of letters
+    // whose total height is the column's information content in BITS and whose
+    // shares are the residue frequencies (Schneider & Stephens 1990), which is
+    // the display the MEME Suite and WebLogo draw.
+    //
+    // No small-sample correction. Schneider's e_n = (K-1)/(2 ln2 n) is meant
+    // for a motif sampled from many sequences; here the rows are the tips
+    // currently on screen, so n is routinely 3 or 4 -- and for protein at n=3
+    // the correction (4.57 bits) EXCEEDS the maximum (4.32), so a perfectly
+    // conserved column of a small clade would draw nothing at all, exactly
+    // when the reader has asked about that clade. The caller names n instead.
+    //
+    // Gaps are not a letter: frequencies are taken over the non-gap residues,
+    // and the stack is then scaled by the column's occupancy, so a column held
+    // up by two residues out of fifty is short rather than perfectly conserved.
+    // `bits` and `occupancy` are returned separately so a caller can say which
+    // of the two made a column short.
+    //
+    // Letters come back most frequent FIRST, ties broken alphabetically, so a
+    // figure is reproducible rather than at the mercy of key order.
+    forester.msaLogo = function (rows, length, nucleotide) {
+        let maxBits = Math.log(nucleotide ? 4 : 20) / Math.LN2;
+        if (!(length >= 0) || !isFinite(length)) {
+            return {columns: [], maxBits: maxBits};
+        }
+        length = Math.floor(length);
+        let n = rows.length;
+        let columns = new Array(length);
+        for (let c = 0; c < length; ++c) {
+            let counts = {};
+            let nonGap = 0;
+            for (let r = 0; r < n; ++r) {
+                let row = rows[r];
+                let ch = (row && c < row.length) ? row.charAt(c) : '-';
+                if (forester.isMsaGap(ch)) {
+                    continue;
+                }
+                ch = ch.toUpperCase();
+                ++nonGap;
+                counts[ch] = (counts[ch] || 0) + 1;
+            }
+            if (n < 1 || nonGap < 1) {
+                columns[c] = {bits: 0, occupancy: 0, height: 0, letters: []};
+                continue;
+            }
+            let H = 0;
+            Object.keys(counts).forEach(function (ch) {
+                let p = counts[ch] / nonGap;
+                H -= p * (Math.log(p) / Math.LN2);
+            });
+            let bits = Math.max(0, maxBits - H);
+            let occupancy = nonGap / n;
+            let height = bits * occupancy;
+            let letters = Object.keys(counts).sort().sort(function (a, b) {
+                return counts[b] - counts[a];   // count first, alphabetical within a tie
+            }).map(function (ch) {
+                let p = counts[ch] / nonGap;
+                return {ch: ch, p: p, h: p * height};
+            });
+            columns[c] = {bits: bits, occupancy: occupancy, height: height, letters: letters};
+        }
+        return {columns: columns, maxBits: maxBits};
+    };
+
     // The hover readout's description of one residue: full name, class (amino
     // acids), Kyte-Doolittle hydropathy. Returns null for a gap.
     forester.msaResidueInfo = function (ch, nucleotide) {

package/package.json

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