@datagrok/sequence-translator 1.10.15 → 1.10.17

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@datagrok/sequence-translator",
   "friendlyName": "Sequence Translator",
-  "version": "1.10.15",
+  "version": "1.10.17",
   "author": {
     "name": "Davit Rizhinashvili",
     "email": "drizhinashvili@datagrok.ai"
@@ -22,8 +22,8 @@
     }
   ],
   "dependencies": {
-    "@datagrok-libraries/bio": "^5.65.0",
-    "@datagrok-libraries/chem-meta": "^1.2.8",
+    "@datagrok-libraries/bio": "^5.65.1",
+    "@datagrok-libraries/chem-meta": "^1.2.12",
     "@datagrok-libraries/tutorials": "^1.6.1",
     "@datagrok-libraries/utils": "^4.6.5",
     "@types/react": "^18.0.15",

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

@@ -25,7 +25,7 @@
 
 import {
   BASE_COLORS, FALLBACK_COLOR,
-  canonicalSugarSymbol,
+  canonicalPhosphateSymbol, canonicalSugarSymbol,
   ParsedDuplex, ParsedMonomer, ParsedNucleotide, ParsedStrand,
   resolveConjugate, resolvePhosphate, resolveSugar,
 } from './types';
@@ -364,9 +364,14 @@ function isModifiedSugar(sugar: string): boolean {
 }
 
 function drawLinkage(g: CanvasRenderingContext2D, link: LinkagePos): void {
+  // Only the canonical phosphate (`p` / aliased `P`) is treated as "no marker".
+  // Every other linkage — known PS / PS₂ / MeP, or unknown custom symbol that
+  // got a hash-derived color — gets a bar in the inter-chip gap so the user
+  // can see and hover it. Color comes from resolvePhosphate which is
+  // deterministic per symbol, so two distinct unknown symbols get distinct bars.
+  const canonical = canonicalPhosphateSymbol(link.phosphateSymbol);
+  if (canonical === 'p') return;
   const ps = resolvePhosphate(link.phosphateSymbol);
-  if (ps.meta.short !== 'PS' && ps.meta.short !== 'PS₂' && ps.meta.short !== 'MeP')
-    return; // only draw markers for non-canonical linkages
   const barW = Math.max(2.5, link.w * PS_BAR_RATIO);
   const barX = link.x + (link.w - barW) / 2;
   g.fillStyle = ps.color;

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

@@ -98,8 +98,14 @@ export class OligoNucleotideCellRenderer extends DG.GridCellRenderer {
     return m;
   }
 
+  /** Cache key for a cell's layout. Includes the column's `version` so any
+   * edit to the column (which bumps version) orphans previous cache entries
+   * — preventing onMouseMove from hit-testing a stale layout that was cached
+   * before the edit and not yet replaced by a fresh render(). */
   private cellKey(gridCell: DG.GridCell): string {
-    const colName = gridCell.tableColumn?.name ?? gridCell.gridColumn?.name ?? '?';
-    return `${colName}::${gridCell.tableRowIndex ?? -1}`;
+    const col = gridCell.tableColumn;
+    const colName = col?.name ?? gridCell.gridColumn?.name ?? '?';
+    const ver = col?.version ?? 0;
+    return `${colName}@${ver}::${gridCell.tableRowIndex ?? -1}`;
   }
 }

package/src/oligo-renderer/tooltip.ts

@@ -22,6 +22,7 @@ import {
   canonicalPhosphateSymbol, canonicalSugarSymbol,
   ParsedNucleotide, resolveConjugate, resolvePhosphate, resolveSugar,
 } from './types';
+import {PolymerType} from '@datagrok-libraries/js-draw-lite/src/types/org';
 
 const STRUCT_W = 110;
 const STRUCT_H = 90;
@@ -117,7 +118,10 @@ function findMonomerMolfile(lib: IMonomerLib, rawSymbol: string, kind: Structure
   else if (kind === 'phosphate') candidates.push(canonicalPhosphateSymbol(rawSymbol));
   // Bases (A/C/G/U/T) and conjugates: try the symbol as-is.
 
-  const polymerTypes = lib.getPolymerTypes();
+  // make sure RNA and chem come first :D
+  const polymerTypes: PolymerType[] = (lib.getPolymerTypes()
+    .filter((pt) => pt === 'RNA' || pt === 'CHEM') as PolymerType[])
+    .concat(lib.getPolymerTypes().filter((pt) => pt !== 'RNA' && pt !== 'CHEM'));
   for (const sym of candidates) {
     for (const pt of polymerTypes) {
       const monomer = lib.getMonomer(pt, sym);

package/src/oligo-renderer/types.ts

@@ -200,7 +200,8 @@ export function resolveConjugate(symbol: string): { color: string; meta: ModMeta
     return {color: known.color, meta: known};
   return {
     color: hashColor(symbol),
-    meta: {name: symbol, short: symbol.length > 6 ? symbol.slice(0, 6) : symbol, color: hashColor(symbol), category: 'conjugate'},
+    meta: {name: symbol, short: symbol.length > 6 ? symbol.slice(0, 6) : symbol,
+      color: hashColor(symbol), category: 'conjugate'},
   };
 }
 

package/src/package-api.ts

@@ -133,6 +133,10 @@ export namespace funcs {
     return await grok.functions.call('SequenceTranslator:GetPtChemEnumeratorDialog', { cell });
   }
 
+  export async function getPtOligoEnumeratorDialog(cell: any | null): Promise<void> {
+    return await grok.functions.call('SequenceTranslator:GetPtOligoEnumeratorDialog', { cell });
+  }
+
   /**
   Enumerate provided HELM sequence on provided positions with provided monomers and generates new table
   */

package/src/package.g.ts

@@ -197,6 +197,12 @@ export async function getPtChemEnumeratorDialog(cell?: any) : Promise<void> {
   await PackageFunctions.getPtChemEnumeratorDialog(cell);
 }
 
+//name: Polytool Oligo Enumerator dialog
+//input: object cell { nullable: true }
+export async function getPtOligoEnumeratorDialog(cell?: any) : Promise<void> {
+  await PackageFunctions.getPtOligoEnumeratorDialog(cell);
+}
+
 //name: Enumerate Single HELM Sequence
 //description: Enumerate provided HELM sequence on provided positions with provided monomers and generates new table
 //input: string helmSequence 

package/src/package.ts

@@ -358,6 +358,34 @@ export class PackageFunctions {
     return polyToolEnumerateChemUI(cell);
   }
 
+
+  /** Enumerator entry for OligoNucleotide cells.
+   *
+   * The cell value is HELM (under the hood). The enumerator dialog is built
+   * around `Macromolecule` cells, so we wrap the oligo HELM in a temp
+   * Macromolecule column and pass that cell in. The `outputAsOligo` flag
+   * makes the dialog tag the enumerated result column as OligoNucleotide so
+   * the duplex renderer picks it up automatically. */
+  @grok.decorators.func({
+    name: 'Polytool Oligo Enumerator dialog'
+  })
+  static async getPtOligoEnumeratorDialog(
+    @grok.decorators.param({type: 'object', options: {nullable: true}}) cell?: DG.Cell) {
+    if (!cell || cell.value == null)
+      return polyToolEnumerateHelmUI(undefined, true);
+
+    const helm = String(cell.value);
+    const tempCol = DG.Column.fromStrings('helm', [helm]);
+    tempCol.semType = DG.SEMTYPE.MACROMOLECULE;
+    tempCol.meta.units = 'helm';
+    tempCol.setTag('aligned', 'SEQ');
+    tempCol.setTag('alphabet', 'RNA');
+    tempCol.setTag('cell.renderer', 'helm');
+    const tempDf = DG.DataFrame.fromColumns([tempCol]);
+    const tempCell = tempDf.cell(0, 'helm');
+    return polyToolEnumerateHelmUI(tempCell, true);
+  }
+
   @grok.decorators.func({
     name: 'Enumerate Single HELM Sequence',
     description: 'Enumerate provided HELM sequence on provided positions with provided monomers and generates new table',

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);