@datagrok/sequence-translator 1.10.13 → 1.10.15

package/src/oligo-renderer/tooltip.ts

@@ -0,0 +1,223 @@
+/**
+ * Hover tooltip for OligoNucleotide cells.
+ *
+ * Shows monomer details synchronously, then async-loads RDKit structures
+ * for whatever was hovered:
+ *   - Nucleotide chip → sugar + base + 3'-phosphate (3 small structures)
+ *   - PS / phosphate-mod linkage in the gap → just the phosphate structure
+ *   - Conjugate pill → that conjugate's structure
+ *
+ * Structures come from the **central Bio monomer library** (not the
+ * SequenceTranslator-internal one). Symbols are resolved via the alias map
+ * so legacy / vendor shorthand still finds the canonical entry.
+ */
+
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+
+import {getMonomerLibHelper, IMonomerLib} from '@datagrok-libraries/bio/src/types/monomer-library';
+
+import {HitResult} from './canvas-renderer';
+import {
+  canonicalPhosphateSymbol, canonicalSugarSymbol,
+  ParsedNucleotide, resolveConjugate, resolvePhosphate, resolveSugar,
+} from './types';
+
+const STRUCT_W = 110;
+const STRUCT_H = 90;
+
+type StructureKind = 'sugar' | 'base' | 'phosphate' | 'conjugate';
+
+/** Show a tooltip for the hovered hit. Idempotent — replaces any current tooltip. */
+export function showMonomerTooltip(hit: HitResult, clientX: number, clientY: number): void {
+  const root = buildTooltipRoot(hit);
+  ui.tooltip.show(root, clientX + 14, clientY + 14);
+  void renderStructuresAsync(root, hit);
+}
+
+function buildTooltipRoot(hit: HitResult): HTMLElement {
+  const m = hit.monomer;
+  const title = ui.divText('', {style: {fontWeight: '600', marginBottom: '4px'}});
+  const detailRows: HTMLElement[] = [];
+
+  // Linkage hover (PS marker in the gap) — shape the tooltip around the linkage
+  if (hit.linkage) {
+    const phos = resolvePhosphate(hit.linkage.phosphateSymbol);
+    title.textContent = `${phos.meta.name} linkage`;
+    detailRows.push(
+      kv('Strand', hit.strand === 'sense' ? 'Sense' : 'Antisense'),
+      kv('Between', `pos ${hit.position + 1} – ${hit.position + 2}`),
+      kv('HELM symbol', `[${canonicalPhosphateSymbol(hit.linkage.phosphateSymbol)}]`, true),
+    );
+  } else if (m.kind === 'nucleotide') {
+    const nt = m as ParsedNucleotide;
+    const sugarRes = resolveSugar(nt.sugar, nt.base);
+    const phosRes = resolvePhosphate(nt.phosphate);
+    title.textContent = `${nt.base ?? '?'}${hit.position + 1} — ${sugarRes.meta.name}`;
+    detailRows.push(
+      kv('Strand', hit.strand === 'sense' ? 'Sense' : 'Antisense'),
+      kv('Position', String(hit.position + 1)),
+      kv('Base', nt.base ?? '—'),
+      kv('Sugar', sugarRes.meta.name),
+      kv('3\'-linkage', phosRes.meta.name),
+      kv('HELM', nt.raw, true),
+    );
+  } else {
+    const conj = resolveConjugate(m.symbol);
+    title.textContent = conj.meta.name;
+    detailRows.push(
+      kv('Strand', hit.strand === 'sense' ? 'Sense' : 'Antisense'),
+      kv('Position', String(hit.position + 1)),
+      kv('Type', 'Terminal conjugate / linker'),
+      kv('HELM', m.raw, true),
+    );
+  }
+
+  // Reserved area for structures — populated async.
+  // Holds 1 (linkage / conjugate) or 3 (full nucleotide) small canvases side by side.
+  const structHost = ui.div([], {style: {
+    marginTop: '8px',
+    display: 'flex', flexDirection: 'row', gap: '6px',
+    flexWrap: 'wrap',
+  }});
+  structHost.dataset.role = 'struct';
+  const placeholder = ui.divText('Loading structures…', {style: {
+    fontSize: '11px', color: 'var(--grey-4, #888)',
+  }});
+  structHost.appendChild(placeholder);
+
+  return ui.divV([title, ...detailRows, structHost], {
+    style: {fontSize: '12px', lineHeight: '1.45', minWidth: '240px', maxWidth: '380px'},
+  });
+}
+
+function kv(k: string, v: string, mono = false): HTMLElement {
+  return ui.divH([
+    ui.divText(k, {style: {color: 'var(--grey-4, #888)', width: '90px', flexShrink: '0'}}),
+    ui.divText(v, {style: mono ? {fontFamily: 'ui-monospace, Menlo, monospace', wordBreak: 'break-all'} : {}}),
+  ], {style: {gap: '6px'}});
+}
+
+/** Cached merged Bio monomer library. */
+let _bioLibPromise: Promise<IMonomerLib> | null = null;
+function getBioLib(): Promise<IMonomerLib> {
+  if (!_bioLibPromise) {
+    _bioLibPromise = (async () => {
+      const helper = await getMonomerLibHelper();
+      return helper.getMonomerLib();
+    })();
+  }
+  return _bioLibPromise;
+}
+
+/** Try the original symbol first, then the canonical alias, across all polymer types. */
+function findMonomerMolfile(lib: IMonomerLib, rawSymbol: string, kind: StructureKind): string | null {
+  const candidates: string[] = [rawSymbol];
+  if (kind === 'sugar') candidates.push(canonicalSugarSymbol(rawSymbol));
+  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();
+  for (const sym of candidates) {
+    for (const pt of polymerTypes) {
+      const monomer = lib.getMonomer(pt, sym);
+      if (monomer && monomer.molfile) return monomer.molfile;
+    }
+  }
+  return null;
+}
+
+async function renderStructuresAsync(root: HTMLElement, hit: HitResult): Promise<void> {
+  const host = root.querySelector('[data-role="struct"]') as HTMLDivElement | null;
+  if (!host) return;
+
+  // Determine which structures to show
+  let requests: { label: string; symbol: string; kind: StructureKind }[];
+  if (hit.linkage) {
+    requests = [{label: 'Linkage', symbol: hit.linkage.phosphateSymbol, kind: 'phosphate'}];
+  } else if (hit.monomer.kind === 'nucleotide') {
+    const nt = hit.monomer as ParsedNucleotide;
+    requests = [
+      {label: 'Sugar', symbol: nt.sugar, kind: 'sugar'},
+    ];
+    if (nt.base) requests.push({label: 'Base', symbol: nt.base, kind: 'base'});
+    if (nt.phosphate) requests.push({label: '3\'-linkage', symbol: nt.phosphate, kind: 'phosphate'});
+  } else {
+    requests = [{label: 'Conjugate', symbol: hit.monomer.symbol, kind: 'conjugate'}];
+  }
+
+  let lib: IMonomerLib;
+  try {
+    lib = await getBioLib();
+  } catch {
+    host.innerHTML = '';
+    host.appendChild(ui.divText('Monomer library unavailable', {
+      style: {fontSize: '11px', color: 'var(--grey-4, #888)'},
+    }));
+    return;
+  }
+
+  host.innerHTML = '';
+
+  for (const req of requests) {
+    const cell = makeStructureCell(req.label);
+    host.appendChild(cell.root);
+    const molfile = findMonomerMolfile(lib, req.symbol, req.kind);
+    if (!molfile) {
+      cell.body.textContent = `Not in HELMCore: ${req.symbol}`;
+      continue;
+    }
+    void drawMolfileCached(cell.body, molfile, cacheKeyFor(req));
+  }
+}
+
+/** Cache key for a structure render. */
+function cacheKeyFor(req: {kind: StructureKind; symbol: string}): string {
+  let canonical = req.symbol;
+  if (req.kind === 'sugar') canonical = canonicalSugarSymbol(req.symbol);
+  else if (req.kind === 'phosphate') canonical = canonicalPhosphateSymbol(req.symbol);
+  return `${req.kind}:${canonical}`;
+}
+
+function makeStructureCell(label: string): { root: HTMLElement; body: HTMLDivElement } {
+  const body = ui.div([], {style: {
+    // width: `${STRUCT_W}px`, height: `${STRUCT_H}px`,
+    // background: 'var(--grey-1, #f4f4f4)', border: '1px solid var(--grey-2, #ddd)',
+    borderRadius: '4px',
+    display: 'flex', alignItems: 'center', justifyContent: 'center',
+    fontSize: '10px', color: 'var(--grey-4, #888)', textAlign: 'center', padding: '4px',
+  }}) as HTMLDivElement;
+  const cap = ui.divText(label, {style: {
+    fontSize: '10px', color: 'var(--grey-5, #555)', textAlign: 'center', marginTop: '2px',
+    letterSpacing: '0.04em', textTransform: 'uppercase', fontWeight: '600',
+  }});
+  const root = ui.divV([body, cap], {style: {display: 'inline-flex'}});
+  return {root, body};
+}
+
+/** Cache of rendered structures by kind+canonical-symbol.
+ *
+ * We cache the actual element returned by grok.chem.drawMolecule and reuse
+ * the same instance across tooltips. We deliberately do NOT clone — when
+ * `drawMolecule` returns a canvas, its bitmap is painted asynchronously
+ * (RDKit init etc.), so a clone taken right after the call ends up blank.
+ * Since only one tooltip is visible at a time, moving the cached node
+ * between tooltip hosts via `appendChild` is safe: the previous host is
+ * being torn down. */
+const _structCache = new Map<string, HTMLElement>();
+
+function drawMolfileCached(host: HTMLDivElement, molfile: string, cacheKey: string): void {
+  try {
+    let cached = _structCache.get(cacheKey);
+    if (!cached) {
+      cached = grok.chem.drawMolecule(molfile, STRUCT_W, STRUCT_H, false);
+      if (_structCache.size > 256) _structCache.clear();
+      _structCache.set(cacheKey, cached);
+    }
+    host.innerHTML = '';
+    // appendChild moves the node from any previous parent automatically.
+    host.appendChild(cached);
+  } catch {
+    host.textContent = 'Render failed';
+  }
+}

package/src/oligo-renderer/types.ts

@@ -0,0 +1,221 @@
+/**
+ * Types and modification dictionary for the OligoNucleotide cell renderer.
+ *
+ * The renderer is intentionally self-contained — it does NOT depend on
+ * `_package.initLibData()` having completed, so the grid can render oligo
+ * cells before any app has opened. Only the tooltip's RDKit structure
+ * depends on the monomer library (which is loaded async there).
+ */
+
+export const OLIGO_SEM_TYPE = 'OligoNucleotide';
+export const OLIGO_UNITS = 'helm';
+
+/** Per-nucleotide parsed model. One per chip in the rendered output. */
+export interface ParsedNucleotide {
+  kind: 'nucleotide';
+  /** Index inside the strand (0-based). */
+  position: number;
+  /** Sugar HELM symbol, normalized (no brackets). HELMCore canonical: 'r', 'd', 'm', 'fl2r', 'lna'. */
+  sugar: string;
+  /** Single-letter base — A / C / G / U / T or null when missing. */
+  base: string | null;
+  /** Phosphate HELM symbol normalized (no brackets). HELMCore canonical: 'p', 'sp'. Empty for terminal. */
+  phosphate: string;
+  /** Original HELM monomer text for tooltip + structure lookup. */
+  raw: string;
+}
+
+/** Terminal conjugate (GalNAc, cholesterol, biotin, L3 linker, …). */
+export interface ParsedConjugate {
+  kind: 'conjugate';
+  position: number;
+  symbol: string;
+  raw: string;
+}
+
+export type ParsedMonomer = ParsedNucleotide | ParsedConjugate;
+
+export interface ParsedStrand {
+  /** 'RNA' | 'DNA' | 'CHEM' */
+  type: string;
+  monomers: ParsedMonomer[];
+}
+
+export interface ParsedDuplex {
+  sense: ParsedStrand;
+  antisense: ParsedStrand | null;
+  /** Original HELM string (kept verbatim for tooltip / debug). */
+  raw: string;
+}
+
+/** Visual classification used for chip coloring. */
+export type ModCategory = 'sugar' | 'phosphate' | 'conjugate' | 'base';
+
+export interface ModMeta {
+  /** Full user-facing name, used in tooltip + legend. */
+  name: string;
+  /** 3–8 char display label for chips that don't show a base letter (conjugates). */
+  short: string;
+  /** Canonical CSS color. */
+  color: string;
+  category: ModCategory;
+}
+
+/* ---------------------------------------------------------------- *
+ * Modification dictionary — flat lookups by HELM symbol.
+ *
+ * Canonical symbols are HELMCore (Pistoia / Bio package):
+ *   sugars      — `r`, `d`, `m`, `25r`, `fl2r`, `lna`, `moe`, ...
+ *   phosphates  — `p`, `sp`, ...
+ *   bases       — `A`, `C`, `G`, `U`, `T`
+ *
+ * Some vendor / Axolabs-style strings (`R`, `mR`, `fR`, `LR`, `dR`, `sP`)
+ * appear in legacy data and in older internal tools. The SYMBOL_ALIASES
+ * map normalizes them to canonical at lookup time, so the renderer
+ * accepts both. Tooltips / structure look-up use the canonical symbol
+ * (which is what the central Bio monomer library actually contains).
+ *
+ * Anything not in the dictionary falls back to a deterministic hash color.
+ * ---------------------------------------------------------------- */
+
+export const SUGAR_MODS: Readonly<Record<string, ModMeta>> = Object.freeze({
+  // Canonical sugars — chip uses base-canonical color (see BASE_COLORS), not a sugar color
+  'r': {name: 'Ribose', short: 'RNA', color: '#D0D0D0', category: 'sugar'},
+  'd': {name: 'Deoxyribose', short: 'DNA', color: '#BDBDBD', category: 'sugar'},
+
+  // 2'-O-Methyl
+  'm': {name: '2\'-O-Methyl', short: '2\'-OMe', color: '#4A90E2', category: 'sugar'},
+  '25r': {name: '2\'-O-Methyl (2,5)', short: '2\'-OMe', color: '#4A90E2', category: 'sugar'},
+
+  // 2'-Fluoro
+  'fl2r': {name: '2\'-Fluoro', short: '2\'-F', color: '#50C878', category: 'sugar'},
+
+  // LNA / cEt / ENA — bridged
+  'lna': {name: 'LNA', short: 'LNA', color: '#E89D3C', category: 'sugar'},
+  'cet': {name: 'cEt', short: 'cEt', color: '#E07B30', category: 'sugar'},
+  'ena': {name: 'ENA', short: 'ENA', color: '#D26C20', category: 'sugar'},
+
+  // 2'-MOE
+  'moe': {name: '2\'-MOE', short: '2\'-MOE', color: '#66CDAA', category: 'sugar'},
+
+  // GNA / UNA / FANA / hexitol-NA
+  'Rgna': {name: '(R)-GNA', short: 'GNA', color: '#C7A981', category: 'sugar'},
+  'Sgna': {name: '(S)-GNA', short: 'GNA', color: '#C7A981', category: 'sugar'},
+  'una': {name: 'UNA', short: 'UNA', color: '#ED68B8', category: 'sugar'},
+  'fana': {name: 'FANA', short: 'FANA', color: '#76B947', category: 'sugar'},
+  'hna': {name: 'HNA', short: 'HNA', color: '#A4D080', category: 'sugar'},
+});
+
+/** Vendor / legacy / Pistoia-style sugar symbols mapped to canonical HELMCore. */
+export const SUGAR_ALIASES: Readonly<Record<string, string>> = Object.freeze({
+  'R': 'r',
+  'dR': 'd',
+  'mR': 'm',
+  'fR': 'fl2r',
+  'LR': 'lna',
+  'L': 'lna',
+  'MOE': 'moe',
+  'GNA': 'Sgna',
+  'UNA': 'una',
+});
+
+export const PHOSPHATE_MODS: Readonly<Record<string, ModMeta>> = Object.freeze({
+  'p': {name: 'Phosphate', short: 'PO', color: '#888888', category: 'phosphate'},
+  'sp': {name: 'Phosphorothioate', short: 'PS', color: '#6B46C1', category: 'phosphate'},
+  's2p': {name: 'Phosphorodithioate', short: 'PS₂', color: '#7E2BC4', category: 'phosphate'},
+  'mp': {name: 'Methylphosphonate', short: 'MeP', color: '#9B5DE5', category: 'phosphate'},
+});
+
+export const PHOSPHATE_ALIASES: Readonly<Record<string, string>> = Object.freeze({
+  'P': 'p',
+  'sP': 'sp',
+});
+
+export const CONJUGATE_MODS: Readonly<Record<string, ModMeta>> = Object.freeze({
+  'GalNAc': {name: 'GalNAc', short: 'GalNAc', color: '#E91E63', category: 'conjugate'},
+  'L3': {name: 'GalNAc-L3 linker', short: 'L3', color: '#E91E63', category: 'conjugate'},
+  'Chol': {name: 'Cholesterol', short: 'Chol', color: '#B57F50', category: 'conjugate'},
+  'Bio': {name: 'Biotin', short: 'Bio', color: '#FFC107', category: 'conjugate'},
+});
+
+/** Pale per-base colors used when sugar is unmodified (R / dR).
+ * Modifications override these. */
+export const BASE_COLORS: Readonly<Record<string, string>> = Object.freeze({
+  A: '#C1E7C5', // pale green
+  C: '#C5DCF0', // pale blue
+  G: '#E8DCA9', // pale tan
+  U: '#F0C5C5', // pale pink
+  T: '#F0C5C5',
+});
+
+export const FALLBACK_COLOR = '#BCBCBC';
+
+/** Deterministic color for unknown HELM monomer symbols. Stable across cells. */
+export function hashColor(symbol: string): string {
+  let h = 0;
+  for (let i = 0; i < symbol.length; i++)
+    h = ((h * 31) + symbol.charCodeAt(i)) | 0;
+  const hue = ((h >>> 0) % 360);
+  return `hsl(${hue}, 42%, 60%)`;
+}
+
+/** Canonicalize a sugar symbol via the alias map, then return the canonical form. */
+export function canonicalSugarSymbol(sugar: string): string {
+  return SUGAR_ALIASES[sugar] ?? sugar;
+}
+
+/** Canonicalize a phosphate symbol via the alias map. */
+export function canonicalPhosphateSymbol(phosphate: string): string {
+  return PHOSPHATE_ALIASES[phosphate] ?? phosphate;
+}
+
+/** Resolve a sugar HELM symbol to (color + meta). Accepts canonical or aliased input. */
+export function resolveSugar(sugar: string, base: string | null): { color: string; meta: ModMeta } {
+  const canonical = canonicalSugarSymbol(sugar);
+  const known = SUGAR_MODS[canonical];
+  if (known) {
+    // For ribose / deoxyribose use the per-base canonical color rather than a flat gray
+    if ((canonical === 'r' || canonical === 'd') && base && BASE_COLORS[base])
+      return {color: BASE_COLORS[base], meta: known};
+    return {color: known.color, meta: known};
+  }
+  const c = hashColor(canonical);
+  return {color: c, meta: {name: canonical, short: canonical, color: c, category: 'sugar'}};
+}
+
+export function resolvePhosphate(phosphate: string): { color: string; meta: ModMeta } {
+  if (!phosphate)
+    return {color: '#888', meta: {name: '(none)', short: '', color: '#888', category: 'phosphate'}};
+  const canonical = canonicalPhosphateSymbol(phosphate);
+  const known = PHOSPHATE_MODS[canonical];
+  if (known)
+    return {color: known.color, meta: known};
+  const c = hashColor(canonical);
+  return {color: c, meta: {name: canonical, short: canonical, color: c, category: 'phosphate'}};
+}
+
+export function resolveConjugate(symbol: string): { color: string; meta: ModMeta } {
+  const known = CONJUGATE_MODS[symbol];
+  if (known)
+    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'},
+  };
+}
+
+/** Pick black or white text for readability on a given background hex/rgb/hsl color. */
+export function contrastTextColor(bg: string): string {
+  // Resolve any CSS color string to RGB through a temp DOM element
+  const probe = document.createElement('span');
+  probe.style.color = bg;
+  document.body.appendChild(probe);
+  const computed = getComputedStyle(probe).color;
+  document.body.removeChild(probe);
+  const m = computed.match(/\d+/g);
+  if (!m) return '#000';
+  const [r, g, b] = m.slice(0, 3).map(Number);
+  // perceptual luminance — black on light, white on dark
+  const lum = 0.299 * r + 0.587 * g + 0.114 * b;
+  return lum > 160 ? '#1a1a1a' : '#ffffff';
+}

package/src/package-api.ts

@@ -102,6 +102,13 @@ export namespace funcs {
     return await grok.functions.call('SequenceTranslator:PolyToolEnumerateChemTopMenu', {});
   }
 
+  /**
+  Enumerate cores and R-group lists into a molecule table (Zip or Cartesian)
+  */
+  export async function chemEnumerateReactionsTopMenu(): Promise<void> {
+    return await grok.functions.call('SequenceTranslator:ChemEnumerateReactionsTopMenu', {});
+  }
+
   export async function polyToolColumnChoice(df: DG.DataFrame , macroMolecule: DG.Column ): Promise<void> {
     return await grok.functions.call('SequenceTranslator:PolyToolColumnChoice', { df, macroMolecule });
   }
@@ -114,7 +121,7 @@ export namespace funcs {
     return await grok.functions.call('SequenceTranslator:PtEnumeratorHelmApp', {});
   }
 
-  export async function ptEnumeratorChemApp(): Promise<void> {
+  export async function ptEnumeratorChemApp(): Promise<DG.View> {
     return await grok.functions.call('SequenceTranslator:PtEnumeratorChemApp', {});
   }
 
@@ -144,6 +151,41 @@ export namespace funcs {
     return await grok.functions.call('SequenceTranslator:GetPolyToolCombineDialog', {});
   }
 
+  /**
+  Renders OligoNucleotide (siRNA / ASO) duplex view in grid cells
+  */
+  export async function oligoNucleotideCellRenderer(): Promise<any> {
+    return await grok.functions.call('SequenceTranslator:OligoNucleotideCellRenderer', {});
+  }
+
+  /**
+  Modifications, lengths, conjugates and color legend for an OligoNucleotide cell
+  */
+  export async function oligoNucleotidePanel(value: any ): Promise<any> {
+    return await grok.functions.call('SequenceTranslator:OligoNucleotidePanel', { value });
+  }
+
+  /**
+  Sense and antisense full molecular structures rendered separately
+  */
+  export async function oligoNucleotideStructuresPanel(value: any ): Promise<any> {
+    return await grok.functions.call('SequenceTranslator:OligoNucleotideStructuresPanel', { value });
+  }
+
+  /**
+  Create a new column tagged as OligoNucleotide so HELM duplex cells render with the oligo view
+  */
+  export async function convertHelmToOligoNucleotide(table: DG.DataFrame , helmCol: DG.Column ): Promise<DG.Column> {
+    return await grok.functions.call('SequenceTranslator:ConvertHelmToOligoNucleotide', { table, helmCol });
+  }
+
+  /**
+  Combine separate sense + antisense HELM columns into one OligoNucleotide column
+  */
+  export async function combineSenseAntisenseToOligoNucleotide(table: DG.DataFrame , senseCol: DG.Column , antiCol: DG.Column ): Promise<DG.Column> {
+    return await grok.functions.call('SequenceTranslator:CombineSenseAntisenseToOligoNucleotide', { table, senseCol, antiCol });
+  }
+
   export async function applyNotationProviderForCyclized(col: DG.Column , separator: string ): Promise<void> {
     return await grok.functions.call('SequenceTranslator:ApplyNotationProviderForCyclized', { col, separator });
   }

package/src/package-test.ts

@@ -13,9 +13,11 @@ import './tests/polytool-convert-tests';
 import './tests/polytool-unrule-tests';
 import './tests/polytool-enumerate-tests';
 import './tests/polytool-enumerate-breadth-tests';
+import './tests/polytool-enumerate-chem-tests';
 import './tests/polytool-chain-parse-notation-tests';
 import './tests/polytool-chain-from-notation-tests';
 import './tests/toAtomicLevel-tests';
+import './tests/oligo-renderer-tests';
 
 import {OligoToolkitTestPackage} from './tests/utils';
 

package/src/package.g.ts

@@ -148,6 +148,13 @@ export async function polyToolEnumerateChemTopMenu() : Promise<void> {
   await PackageFunctions.polyToolEnumerateChemTopMenu();
 }
 
+//name: chemEnumerateReactions
+//description: Enumerate cores and R-group lists into a molecule table (Zip or Cartesian)
+//top-menu: Chem | Transform | Reactions | Enumerate...
+export async function chemEnumerateReactionsTopMenu() : Promise<void> {
+  await PackageFunctions.chemEnumerateReactionsTopMenu();
+}
+
 //input: dataframe df { description: Input data table }
 //input: column macroMolecule 
 export async function polyToolColumnChoice(df: DG.DataFrame, macroMolecule: DG.Column) : Promise<void> {
@@ -170,11 +177,12 @@ export async function ptEnumeratorHelmApp() : Promise<void> {
 
 //name: Chem Enumerator
 //tags: app
+//output: view result
 //meta.icon: img/icons/structure.png
-//meta.browsePath: Peptides | PolyTool
+//meta.browsePath: Chem | PolyTool
 //meta.role: app
-export async function ptEnumeratorChemApp() : Promise<void> {
-  await PackageFunctions.ptEnumeratorChemApp();
+export async function ptEnumeratorChemApp() {
+  return await PackageFunctions.ptEnumeratorChemApp();
 }
 
 //name: Polytool Helm Enumerator dialog
@@ -215,6 +223,51 @@ export async function getPolyToolCombineDialog() : Promise<void> {
   await PackageFunctions.getPolyToolCombineDialog();
 }
 
+//description: Renders OligoNucleotide (siRNA / ASO) duplex view in grid cells
+//tags: cellRenderer
+//output: grid_cell_renderer result
+//meta.cellType: OligoNucleotide
+//meta.columnTags: quality=OligoNucleotide
+//meta.role: cellRenderer
+export function oligoNucleotideCellRenderer() : any {
+  return PackageFunctions.oligoNucleotideCellRenderer();
+}
+
+//name: Oligo-Nucleotide
+//description: Modifications, lengths, conjugates and color legend for an OligoNucleotide cell
+//tags: panel, widgets
+//input: semantic_value value { semType: OligoNucleotide }
+//output: widget result
+export function oligoNucleotidePanel(value: DG.SemanticValue) : any {
+  return PackageFunctions.oligoNucleotidePanel(value);
+}
+
+//name: Oligo Structures
+//description: Sense and antisense full molecular structures rendered separately
+//tags: panel, widgets
+//input: semantic_value value { semType: OligoNucleotide }
+//output: widget result
+export function oligoNucleotideStructuresPanel(value: DG.SemanticValue) : any {
+  return PackageFunctions.oligoNucleotideStructuresPanel(value);
+}
+
+//description: Create a new column tagged as OligoNucleotide so HELM duplex cells render with the oligo view
+//input: dataframe table 
+//input: column helmCol { caption: HELM column; semType: Macromolecule }
+//output: column result
+export async function convertHelmToOligoNucleotide(table: DG.DataFrame, helmCol: DG.Column) : Promise<any> {
+  return await PackageFunctions.convertHelmToOligoNucleotide(table, helmCol);
+}
+
+//description: Combine separate sense + antisense HELM columns into one OligoNucleotide column
+//input: dataframe table 
+//input: column senseCol { caption: Sense; semType: Macromolecule }
+//input: column antiCol { caption: Antisense; semType: Macromolecule }
+//output: column result
+export async function combineSenseAntisenseToOligoNucleotide(table: DG.DataFrame, senseCol: DG.Column, antiCol: DG.Column) : Promise<any> {
+  return await PackageFunctions.combineSenseAntisenseToOligoNucleotide(table, senseCol, antiCol);
+}
+
 //name: applyNotationProviderForHarmonizedSequence
 //input: column col 
 //input: string separator