@datagrok/sequence-translator 1.10.16 → 1.10.18

package/src/polytool/pt-chem-enum-dialog.ts

@@ -45,6 +45,7 @@ interface CardOpts {
   subtitle: string;
   error?: string;
   onEdit?: () => void;
+  onDuplicate?: () => void;
   onRemove?: () => void;
 }
 
@@ -108,15 +109,22 @@ function buildCard(opts: CardOpts): HTMLElement {
   }});
   if (opts.onEdit) {
     const editBtn = ui.icons.edit((e: MouseEvent) => { e.stopPropagation(); opts.onEdit!(); }, 'Edit');
+    editBtn.style.color = 'var(--blue-3)';
     actions.appendChild(editBtn);
   }
+  if (opts.onDuplicate) {
+    const dupBtn = ui.icons.copy((e: MouseEvent) => { e.stopPropagation(); opts.onDuplicate!(); }, 'Duplicate');
+    dupBtn.style.color = 'var(--blue-3)';
+    actions.appendChild(dupBtn);
+  }
   if (opts.onRemove) {
     const delBtn = ui.icons.delete((e: MouseEvent) => { e.stopPropagation(); opts.onRemove!(); }, 'Remove');
+    delBtn.style.color = 'var(--red-3)';
     actions.appendChild(delBtn);
   }
   card.addEventListener('mouseenter', () => { actions.style.display = 'flex'; });
   card.addEventListener('mouseleave', () => { actions.style.display = 'none'; });
-  if (opts.onEdit || opts.onRemove) card.appendChild(actions);
+  if (opts.onEdit || opts.onDuplicate || opts.onRemove) card.appendChild(actions);
 
   return card;
 }
@@ -197,25 +205,38 @@ async function openRGroupSketchDialog(rdkit: RDModule, initialMolfile?: string,
     const status = ui.divText('', {style: {fontSize: '11px', padding: '4px 0', minHeight: '18px'}});
     let currentSmiles: string | null = null;
     let detectedRs: number[] = [];
+    let isSingleAtom = false;
     let okBtn: HTMLButtonElement | null = null;
     let userTouchedR = false;
     rNumberInput.onChanged.subscribe(() => { userTouchedR = true; updateOk(); });
 
     const updateOk = () => {
       const n = rNumberInput.value;
-      const ok = currentSmiles != null && n != null && n >= 1 && detectedRs.length === 1;
+      const ok = currentSmiles != null && n != null && n >= 1 &&
+        (detectedRs.length === 1 || isSingleAtom);
       if (okBtn) okBtn.disabled = !ok;
     };
 
     const revalidate = async () => {
       currentSmiles = await smilesFromSketcher(sk, rdkit);
       detectedRs = currentSmiles ? extractRNumbers(currentSmiles) : [];
+      // Probe single-atom mode only when there's no R-label — keeps the
+      // common labeled path free of an extra RDKit parse.
+      isSingleAtom = false;
+      if (currentSmiles && detectedRs.length === 0) {
+        const probe = makeRGroup(currentSmiles, rNumberInput.value ?? 1, '', rdkit);
+        isSingleAtom = !!probe.isSingleAtom;
+      }
       if (!currentSmiles) {
-        status.innerText = 'Draw an R-group with exactly one attachment point.';
+        status.innerText = 'Draw an R-group with one attachment point, or a single atom (e.g. N, O, Cl).';
         status.style.color = 'var(--grey-4)';
-      } else if (detectedRs.length === 0) {
-        status.innerText = 'No R-group detected — add [*:N] to mark the attachment point.';
+      } else if (detectedRs.length === 0 && !isSingleAtom) {
+        status.innerText = 'No R-group detected — add [*:N] to mark the attachment point, or draw a single atom (e.g. N, O, Cl).';
         status.style.color = 'var(--red-3)';
+      } else if (detectedRs.length === 0 && isSingleAtom) {
+        const targetN = rNumberInput.value;
+        status.innerText = `Single atom — will be substituted into [*:${targetN ?? '?'}] in the core.`;
+        status.style.color = 'var(--green-2)';
       } else if (detectedRs.length > 1) {
         status.innerText = `R-group must contain exactly one attachment point. Found ${detectedRs.length}: ${detectedRs.map((n) => 'R' + n).join(', ')}.`;
         status.style.color = 'var(--red-3)';
@@ -266,6 +287,10 @@ async function openImportWizard(
     const columnInput = ui.input.choice<string>('Column', {items: [] as string[], nullable: true});
     const rNumberInput = kind === 'rgroups' ?
       ui.input.int('Target R#', {value: 1, min: 1}) : null;
+    if (rNumberInput) {
+      ui.tooltip.bind(rNumberInput.input,
+        'Target R-number for these R-groups. Single-atom rows (no [*:N] label, e.g. just N or O) get substituted into the core\'s R# slot directly.');
+    }
     const dedupInput = ui.input.bool('Remove duplicates', {value: defaultDedup});
     ui.tooltip.bind(dedupInput.input,
       kind === 'cores' ?
@@ -361,10 +386,10 @@ async function openImportWizard(
         built.rGroups = rGroups;
         rGroups.forEach((rg, i) => {
           if (rg.error) errs.push(`R-group ${i + 1}: ${rg.error}`);
-          items.push({
-            smi: rg.error ? '' : rg.smiles, err: rg.error,
-            subtitle: rg.error ? 'invalid' : `R${rg.rNumber}${rg.sourceRNumber != null && rg.sourceRNumber !== rg.rNumber ? ` (from R${rg.sourceRNumber})` : ''}`,
-          });
+          const subtitle = rg.error ? 'invalid' :
+            rg.isSingleAtom ? `R${rg.rNumber} · atom` :
+              `R${rg.rNumber}${rg.sourceRNumber != null && rg.sourceRNumber !== rg.rNumber ? ` (from R${rg.sourceRNumber})` : ''}`;
+          items.push({smi: rg.error ? '' : rg.smiles, err: rg.error, subtitle});
         });
         countText.innerText = `${rGroups.length} R-group${rGroups.length === 1 ? '' : 's'} for R${n}` +
           (dedup && dupCount ? ` (${dupCount} duplicate${dupCount === 1 ? '' : 's'} skipped)` : '') + '.';
@@ -558,6 +583,10 @@ function buildChemEnumPanel(rdkit: RDModule, preloadCore: ChemEnumCore | null):
         const edited = await openCoreSketchDialog(rdkit, c.smiles);
         if (edited) { state.cores[i] = edited; refresh(); }
       },
+      onDuplicate: async () => {
+        const dup = await openCoreSketchDialog(rdkit, c.smiles);
+        if (dup) { state.cores.push(dup); refresh(); }
+      },
       onRemove: () => { state.cores.splice(i, 1); refresh(); },
     });
   };
@@ -625,9 +654,12 @@ function buildChemEnumPanel(rdkit: RDModule, preloadCore: ChemEnumCore | null):
       const renderer = (i: number): HTMLElement => {
         const rg = list[i];
         const remap = rg.sourceRNumber != null && rg.sourceRNumber !== rg.rNumber ? ` (from R${rg.sourceRNumber})` : '';
+        const subtitle = rg.error ? 'invalid' :
+          rg.isSingleAtom ? `r group ${i + 1} · R${rg.rNumber} · atom` :
+            `r group ${i + 1} · R${rg.rNumber}${remap}`;
         return buildCard({
           smiles: rg.error ? '' : rg.smiles,
-          subtitle: rg.error ? 'invalid' : `r group ${i + 1} · R${rg.rNumber}${remap}`,
+          subtitle,
           error: rg.error,
           onEdit: async () => {
             const edited = await openRGroupSketchDialog(rdkit, rg.smiles, rg.rNumber);
@@ -644,6 +676,14 @@ function buildChemEnumPanel(rdkit: RDModule, preloadCore: ChemEnumCore | null):
             }
             refresh();
           },
+          onDuplicate: async () => {
+            const dup = await openRGroupSketchDialog(rdkit, rg.smiles, rg.rNumber);
+            if (!dup) return;
+            const target = state.rGroupsByNum.get(dup.rNumber) ?? [];
+            target.push(dup);
+            state.rGroupsByNum.set(dup.rNumber, target);
+            refresh();
+          },
           onRemove: () => {
             list.splice(i, 1);
             if (list.length === 0) state.rGroupsByNum.delete(n);

package/src/polytool/pt-chem-enum.ts

@@ -42,7 +42,11 @@ export interface ChemEnumCore {
 }
 
 export interface ChemEnumRGroup {
-  /** Normalized SMILES with its single R-label remapped to the target R number. */
+  /**
+   * Normalized SMILES with its single R-label remapped to the target R number,
+   * OR — when {@link isSingleAtom} is set — the canonical single-atom token
+   * (e.g. `N`, `O`, `[N+]`) to splice into the core's `[*:N]` slot.
+   */
   smiles: string;
   /** SMILES as supplied (pre-normalization and pre-remap). */
   originalSmiles: string;
@@ -50,6 +54,12 @@ export interface ChemEnumRGroup {
   rNumber: number;
   /** R number as originally written in `originalSmiles` (pre-remap). */
   sourceRNumber?: number;
+  /**
+   * True when the R-group has zero R-labels and is exactly one heavy atom.
+   * Such groups are spliced into the core's `[*:N]` slot via plain string
+   * replace instead of ring-closure joining.
+   */
+  isSingleAtom?: boolean;
   id: string;
   error?: string;
 }
@@ -169,9 +179,21 @@ export function makeRGroup(
   const rNumbers = extractRNumbers(normalized);
 
   if (rNumbers.length === 0) {
+    // Single-atom mode: a no-R-label SMILES is acceptable iff RDKit confirms
+    // exactly one heavy atom. The atom is then substituted into the core's
+    // `[*:N]` slot by `buildJoinedSmiles` instead of ring-closure-joined.
+    if (rdkit) {
+      const atomSmi = trySingleAtomCanonical(normalized, rdkit);
+      if (atomSmi) {
+        return {
+          smiles: atomSmi, originalSmiles, rNumber: targetRNumber, id,
+          isSingleAtom: true,
+        };
+      }
+    }
     return {
       smiles: normalized, originalSmiles, rNumber: targetRNumber, id,
-      error: 'R-group must contain exactly one R label (found none)'};
+      error: 'R-group must contain exactly one R label, or be a single atom (e.g. N, O, Cl)'};
   }
   if (rNumbers.length > 1) {
     return {
@@ -208,6 +230,27 @@ function tryParse(smi: string, rdkit: RDModule): string | null {
   }
 }
 
+/**
+ * Returns the canonical, H-stripped SMILES iff `smi` parses as exactly one
+ * heavy atom — used to detect single-atom R-groups (`N`, `O`, `[N+]`, …) that
+ * substitute into the core's `[*:N]` slot directly. Returns null otherwise.
+ */
+function trySingleAtomCanonical(smi: string, rdkit: RDModule): string | null {
+  let mol: RDMol | null = null;
+  try {
+    mol = rdkit.get_mol(smi);
+    if (!mol || !mol.is_valid()) return null;
+    if (mol.get_num_atoms(true) !== 1) return null;
+    mol.remove_hs_in_place();
+    const canon = mol.get_smiles();
+    return canon && canon.length > 0 ? canon : null;
+  } catch {
+    return null;
+  } finally {
+    mol?.delete();
+  }
+}
+
 // ─── Count + validation ─────────────────────────────────────────────────────
 
 /** Results per core: depends on mode and the R-numbers the core uses. */
@@ -302,17 +345,34 @@ export function buildJoinedSmiles(
 ): string | null {
   if (rgSmilesByNum.size === 0) return null;
 
-  const coreFixed = moveStartRLabelToBranch(coreSmiles);
+  // Single-atom R-groups (no `[*:k]` in their SMILES) are spliced into the
+  // core's `[*:k]` slot directly. Labeled R-groups go through the standard
+  // ring-closure join. The two paths cooperate when both are present:
+  // atoms are substituted first, then the labeled rest is joined.
+  const atomReps = new Map<number, string>();
+  const labeled = new Map<number, string>();
+  for (const [k, s] of rgSmilesByNum) {
+    if (extractRNumbers(s).includes(k)) labeled.set(k, s);
+    else atomReps.set(k, s);
+  }
+
+  let preparedCore = coreSmiles;
+  for (const [k, atom] of atomReps)
+    preparedCore = substituteRLabelWithAtom(preparedCore, k, atom);
+
+  if (labeled.size === 0) return preparedCore;
+
+  const coreFixed = moveStartRLabelToBranch(preparedCore);
   const rgsFixed = new Map<number, string>();
-  for (const [k, s] of rgSmilesByNum) rgsFixed.set(k, moveStartRLabelToBranch(s));
+  for (const [k, s] of labeled) rgsFixed.set(k, moveStartRLabelToBranch(s));
 
   const allPieces = [coreFixed, ...rgsFixed.values()];
-  const digits = pickFreeRingDigits(allPieces, rgSmilesByNum.size);
-  if (digits.length < rgSmilesByNum.size) return null;
+  const digits = pickFreeRingDigits(allPieces, labeled.size);
+  if (digits.length < labeled.size) return null;
 
   const digitByNum = new Map<number, string>();
   let i = 0;
-  for (const k of rgSmilesByNum.keys()) digitByNum.set(k, formatRingDigit(digits[i++]));
+  for (const k of labeled.keys()) digitByNum.set(k, formatRingDigit(digits[i++]));
 
   let assembledCore = coreFixed;
   for (const [k, d] of digitByNum)
@@ -325,6 +385,15 @@ export function buildJoinedSmiles(
   return [assembledCore, ...assembledRgs].join('.');
 }
 
+/**
+ * Splices an atom token into every `[*:n]` slot of `smi`. Unlike ring-digit
+ * substitution, parens around the label (`(N)` etc.) are valid SMILES, so a
+ * plain string replace is enough.
+ */
+export function substituteRLabelWithAtom(smi: string, n: number, atom: string): string {
+  return smi.split(`[*:${n}]`).join(atom);
+}
+
 /**
  * Joins a core with one R-group per R-number and canonicalizes via RDKit.
  * Per-molecule sync RDKit call — **do not use in bulk**; prefer {@link buildJoinedSmiles}

package/src/polytool/pt-enumerate-seq-dialog.ts

@@ -33,6 +33,7 @@ import {Chain} from './conversion/pt-chain';
 import {polyToolConvert} from './pt-dialog';
 
 import {_package, applyNotationProviderForCyclized, PackageFunctions} from '../package';
+import {tagAsOligoNucleotide} from '../oligo-renderer/converters';
 import {buildMonomerHoverLink} from '@datagrok-libraries/bio/src/monomer-works/monomer-hover';
 import {getRdKitModule} from '@datagrok-libraries/bio/src/chem/rdkit-module';
 
@@ -84,8 +85,12 @@ type PolyToolEnumerateHelmSerialized = {
   rules: string[],
 };
 
-/** Entry point: creates, sizes, and shows the enumeration dialog. */
-export async function polyToolEnumerateHelmUI(cell?: DG.Cell): Promise<void> {
+/** Entry point: creates, sizes, and shows the enumeration dialog.
+ * @param outputAsOligo If true, the enumerated HELM column in the result df
+ *   is tagged as `OligoNucleotide` (semType + units=helm + cellRenderer hints)
+ *   so the duplex cell renderer picks it up. Used when the source cell was an
+ *   OligoNucleotide column. */
+export async function polyToolEnumerateHelmUI(cell?: DG.Cell, outputAsOligo: boolean = false): Promise<void> {
   await _package.initPromise;
 
   // Capture viewport dimensions for dialog sizing
@@ -122,7 +127,7 @@ export async function polyToolEnumerateHelmUI(cell?: DG.Cell): Promise<void> {
         }
       }
     };
-    dialog = await getPolyToolEnumerateDialog(cell, resizeInputs);
+    dialog = await getPolyToolEnumerateDialog(cell, resizeInputs, outputAsOligo);
 
     // On first show, center the dialog at 70% of viewport; on subsequent resizes, just reflow inputs
     let isFirstShow = true;
@@ -155,7 +160,7 @@ export async function polyToolEnumerateHelmUI(cell?: DG.Cell): Promise<void> {
 
 /** Builds and configures the enumeration dialog with all inputs, validators, and event handlers. */
 async function getPolyToolEnumerateDialog(
-  cell?: DG.Cell, resizeInputs?: () => void
+  cell?: DG.Cell, resizeInputs?: () => void, outputAsOligo: boolean = false,
 ): Promise<DG.Dialog> {
   const logPrefix = `ST: PT: HelmDialog()`;
   let inputs: PolyToolEnumerateInputs;
@@ -712,6 +717,15 @@ async function getPolyToolEnumerateDialog(
               rules: await ruleInputs.getActive()
             } : false,
             helmHelper);
+
+          // When the source was an OligoNucleotide cell, tag the enumerated
+          // HELM column as OligoNucleotide so the duplex renderer picks it up.
+          if (outputAsOligo) {
+            const enumCol = enumeratorResDf.col('Enumerated');
+            if (enumCol && enumCol.type === DG.COLUMN_TYPE.STRING)
+              tagAsOligoNucleotide(enumCol as DG.Column<string>);
+          }
+
           const appendTarget = inputs.appendToTable.value;
           if (appendTarget) {
             appendTarget.append(enumeratorResDf, true);

package/src/tests/oligo-cell-editor-tests.ts

@@ -0,0 +1,83 @@
+import {after, category, test, expect, awaitCheck, delay} from '@datagrok-libraries/test/src/test';
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+
+import $ from 'cash-dom';
+
+import {tagAsOligoNucleotide} from '../oligo-renderer/converters';
+
+const SAMPLE_HELM =
+  'RNA1{r(A)p.r(C)p.r(G)p.r(U)p}|RNA2{r(U)p.r(C)p.r(G)p.r(A)p}$$$$';
+
+function dialogCount(): number {
+  return $('.d4-dialog').length;
+}
+
+function closeAllDialogs(): void {
+  $('.d4-dialog .ui-btn-cancel, .d4-dialog .d4-dialog-header .grok-icon.fa-times').trigger('click');
+}
+
+category('OligoCellEditor', () => {
+  after(async () => {
+    closeAllDialogs();
+    grok.shell.closeAll();
+  });
+
+  test('cellEditor opens HELM editor for OligoNucleotide cell and saves on OK', async () => {
+    const col = DG.Column.fromStrings('seq', [SAMPLE_HELM]);
+    tagAsOligoNucleotide(col);
+    const df = DG.DataFrame.fromColumns([col]);
+    df.name = 'oligo-edit-test';
+    const tv = grok.shell.addTableView(df);
+
+    await awaitCheck(() => $(tv.root).find('.d4-grid canvas').length > 0,
+      'Grid canvas did not appear', 5000);
+
+    // Find the cellEditor that the platform would dispatch on double-click for
+    // a column tagged quality=OligoNucleotide. Pre-fix: zero matches (the
+    // registration didn't exist). Post-fix: exactly one — editOligoNucleotideCell.
+    const matches = DG.Func.find({tags: ['cellEditor'], package: 'SequenceTranslator'})
+      .filter((f) => f.description === 'OligoNucleotide');
+    expect(matches.length, 1);
+    expect(matches[0].name, 'editOligoNucleotideCell');
+
+    const gridCell = tv.grid.cell('seq', 0);
+    expect(gridCell != null, true);
+    expect(gridCell.cell.value, SAMPLE_HELM);
+
+    const dialogsBefore = dialogCount();
+
+    // Invoke the cellEditor as the platform would on double-click.
+    // Pre-fix (delegating to Helm:editMoleculeCell): throws synchronously
+    //   "The column of notation 'helm' must be 'Macromolecule'" — dialog never opens.
+    // Post-fix (using helmHelper.createWebEditorApp directly): dialog opens.
+    await matches[0].apply({cell: gridCell});
+
+    await awaitCheck(() => dialogCount() > dialogsBefore,
+      'HELM editor dialog did not open within 15s', 15000);
+
+    // Wait for HWE async init (Dojo + JSDraw2 + monomer lib) to mount the editor.
+    // JSDraw2 renders to SVG, so wait for the OK button to be wired up — that's
+    // a reliable signal that the dialog footer is fully constructed.
+    await awaitCheck(() => $('.d4-dialog .ui-btn-ok, .d4-dialog button.ui-btn.ui-btn-ok').length > 0,
+      'OK button did not appear in HELM editor dialog within 15s', 15000);
+
+    // Allow the editor a moment to load the HELM string into the canvas before we read it back.
+    await delay(1000);
+
+    const okBtn = $('.d4-dialog .ui-btn-ok, .d4-dialog button.ui-btn.ui-btn-ok').first();
+    expect(okBtn.length > 0, true, 'OK button not found in dialog');
+
+    okBtn.trigger('click');
+
+    await awaitCheck(() => dialogCount() <= dialogsBefore,
+      'Dialog did not close after OK', 5000);
+
+    // After OK: cell.setValue(helmValue) must have run with the editor's HELM.
+    // The editor may canonicalize formatting, so we don't require byte-equality —
+    // we require it remains a valid two-strand HELM string for our input.
+    const after = gridCell.cell.value as string;
+    expect(typeof after === 'string' && after.includes('RNA1{') && after.includes('RNA2{') && after.includes('$$$$'), true,
+      `Expected cell value to remain valid HELM after OK; got: ${after}`);
+  });
+});

package/src/tests/oligo-renderer-tests.ts

@@ -1,6 +1,7 @@
 import {category, test, expect} from '@datagrok-libraries/test/src/test';
 
-import {parseHelmDuplex, looksLikeHelm} from '../oligo-renderer/helm-parser';
+import {parseHelmDuplex, looksLikeHelm, canonicalizeHelm} from '../oligo-renderer/helm-parser';
+import {ParsedNucleotide} from '../oligo-renderer/types';
 import {computeLayout, hitTest, drawDuplex} from '../oligo-renderer/canvas-renderer';
 import {
   resolveSugar, resolvePhosphate, resolveConjugate,
@@ -94,6 +95,68 @@ category('OligoRenderer: parser', () => {
       expect(m0.phosphate, 'zp');
     }
   });
+
+  test('parser strips brackets from multi-char base in parens', async () => {
+    // Bug: pre-fix, cleanupHelmSymbol was not called on the base, so base === '[5Br-dC]'.
+    // Post-fix: cleanupHelmSymbol('[5Br-dC]') → '5Br-dC'.
+    const dup = parseHelmDuplex('RNA1{r([5Br-dC])p}$$$$');
+    const m = dup.sense.monomers[0] as ParsedNucleotide;
+    expect(m.kind, 'nucleotide');
+    expect(m.sugar, 'r');
+    // pre-fix: '[5Br-dC]'  post-fix: '5Br-dC'
+    expect(m.base, '5Br-dC');
+    expect(m.phosphate, 'p');
+  });
+
+  test('parser strips brackets from multi-char base on both strands', async () => {
+    // Covers both strands and different modification combinations.
+    // pre-fix: base === '[5meC]', '[5Br-dC]', '[5fU]'  post-fix: '5meC', '5Br-dC', '5fU'
+    const dup = parseHelmDuplex('RNA1{r([5meC])p.[fl2r]([5Br-dC])[sp]}|RNA2{r([5fU])p}$$$$');
+    const senseFirst = dup.sense.monomers[0] as ParsedNucleotide;
+    const senseSecond = dup.sense.monomers[1] as ParsedNucleotide;
+    const antiFirst = dup.antisense!.monomers[0] as ParsedNucleotide;
+    // pre-fix: '[5meC]'  post-fix: '5meC'
+    expect(senseFirst.base, '5meC');
+    expect(senseSecond.sugar, 'fl2r');
+    // pre-fix: '[5Br-dC]'  post-fix: '5Br-dC'
+    expect(senseSecond.base, '5Br-dC');
+    expect(senseSecond.phosphate, 'sp');
+    // pre-fix: '[5fU]'  post-fix: '5fU'
+    expect(antiFirst.base, '5fU');
+  });
+
+  test('parser leaves bare-letter base unchanged', async () => {
+    // Regression guard: single-letter bases must NOT be transformed.
+    // A, G, C, T, U are all single-char and do not have brackets → unchanged by cleanupHelmSymbol.
+    const dup = parseHelmDuplex('RNA1{r(A)p.r(G)p.r(C)p.r(T)p.r(U)p}$$$$');
+    const bases = dup.sense.monomers.map((m) => (m as ParsedNucleotide).base);
+    // Expected: ['A', 'G', 'C', 'T', 'U'] — unchanged for all five bases.
+    expect(bases.join(','), 'A,G,C,T,U');
+  });
+
+  test('canonicalizeHelm re-brackets multi-char base on output', async () => {
+    // serializeCanonicalMonomer emits `([${base}])` when base.length > 1.
+    // pre-fix: emitted '(5Br-dC)' (invalid HELM, missing brackets).
+    // post-fix: emits '([5Br-dC])' — round-trip is valid HELM.
+    const out = canonicalizeHelm('RNA1{r([5Br-dC])p}$$$$');
+    // Must contain the bracketed base form.
+    expect(out.includes('([5Br-dC])'), true,
+      `expected canonicalized HELM to contain '([5Br-dC])', got: ${out}`);
+    // Must NOT contain the bare (unbracketed) form.
+    expect(out.includes('(5Br-dC)') && !out.includes('([5Br-dC])'), false,
+      `must not emit unbracketed (5Br-dC) without wrapping brackets, got: ${out}`);
+  });
+
+  test('canonicalizeHelm keeps single-letter base unbracketed', async () => {
+    // serializeCanonicalMonomer: base.length === 1 → `(${base})`, not `([${base}])`.
+    // Expected output contains 'r(A)p' — single letter stays bare.
+    const out = canonicalizeHelm('RNA1{r(A)p}$$$$');
+    expect(out.includes('r(A)p'), true,
+      `expected single-letter base to stay unbracketed, got: ${out}`);
+    // Single-letter base must NOT get double-bracketed.
+    expect(out.includes('([A])'), false,
+      `single-letter base must NOT be wrapped in brackets, got: ${out}`);
+  });
 });
 
 category('OligoRenderer: modification dictionary', () => {