@datagrok/bio 2.27.6 → 2.27.8

package/package.json

@@ -5,7 +5,7 @@
     "name": "Davit Rizhinashvili",
     "email": "drizhinashvili@datagrok.ai"
   },
-  "version": "2.27.6",
+  "version": "2.27.8",
   "description": "Bioinformatics support (import/export of sequences, conversion, visualization, analysis). [See more](https://github.com/datagrok-ai/public/blob/master/packages/Bio/README.md) for details.",
   "repository": {
     "type": "git",
@@ -44,7 +44,7 @@
   ],
   "dependencies": {
     "@biowasm/aioli": "^3.1.0",
-    "@datagrok-libraries/bio": "^5.64.1",
+    "@datagrok-libraries/bio": "^5.65.1",
     "@datagrok-libraries/chem-meta": "^1.2.9",
     "@datagrok-libraries/math": "^1.2.6",
     "@datagrok-libraries/ml": "^6.10.11",

package/src/tests/to-atomic-level-tests.ts

@@ -498,6 +498,199 @@ category('toAtomicLevelHelmRna', async () => {
     expect(/S/.test(smiles), true, `expected sulfur: ${smiles}`);
     expect(/P/.test(smiles), true, `expected phosphorus: ${smiles}`);
   });
+
+  // 3'-end terminal modifier (GalNAc, R1 only). HELM puts it in the
+  // "phosphate" slot of the last triple, but it's actually a chain end.
+  // Expectations: chain ends at GalNAc (no extra OH cap), no phosphate
+  // at all, GalNAc structural features (acetamide N) are present.
+  test('rna-helm-3p-terminal-galnac', async () => {
+    const smiles = await helmRnaLinearToSmiles(`RNA1{r(T)[GalNAc]}$$$$V2.0`);
+    const pCount = (smiles.match(/P/g) || []).length;
+    expect(pCount, 0, `expected 0 phosphates (GalNAc replaces P): ${smiles}`);
+    expect(/N/.test(smiles), true, `expected nitrogen from GalNAc acetamide: ${smiles}`);
+    // Sanity: SMILES should not be RDKit's parse-failure sentinel.
+    expect(smiles !== 'MALFORMED_INPUT_VALUE' && smiles.length > 10, true,
+      `valid SMILES expected: ${smiles}`);
+  });
+
+  // 5'-end terminal modifier (Chol, R2 only) at the start of the chain.
+  // HELM puts Chol where the first sugar would be. With no trailing P,
+  // the chain is Chol → r(T)-3'-OH.
+  test('rna-helm-5p-terminal-chol', async () => {
+    const smiles = await helmRnaLinearToSmiles(`RNA1{[Chol].r(T)}$$$$V2.0`);
+    expect(smiles !== 'MALFORMED_INPUT_VALUE' && smiles.length > 10, true,
+      `valid SMILES expected: ${smiles}`);
+    // Cholesterol has 4 fused rings (3 six-membered + 1 five-membered) — sanity-check
+    // by requiring at least 4 non-aromatic ring closures (digits 1-4) in the SMILES
+    // (cholesterol fragment alone uses ring closures 1-4).
+    expect(/1/.test(smiles) && /2/.test(smiles) && /3/.test(smiles) && /4/.test(smiles), true,
+      `expected cholesterol ring fragments: ${smiles}`);
+  });
+
+  // Chol at 5' with explicit trailing phosphate (the original failing case).
+  // Chain: Chol → r(T) → P-OH. Should produce exactly 1 phosphate.
+  test('rna-helm-5p-terminal-chol-with-trailing-phosphate', async () => {
+    const smiles = await helmRnaLinearToSmiles(`RNA1{[Chol].r(T)p}$$$$V2.0`);
+    expect(smiles !== 'MALFORMED_INPUT_VALUE' && smiles.length > 10, true,
+      `valid SMILES expected: ${smiles}`);
+    const pCount = (smiles.match(/P/g) || []).length;
+    expect(pCount, 1, `expected exactly 1 phosphate: ${smiles}`);
+  });
+
+  // Both terminals at once: Chol at 5', GalNAc at 3', single nucleotide
+  // in between. No phosphates anywhere.
+  test('rna-helm-both-terminals', async () => {
+    const smiles = await helmRnaLinearToSmiles(`RNA1{[Chol].r(T)[GalNAc]}$$$$V2.0`);
+    expect(smiles !== 'MALFORMED_INPUT_VALUE' && smiles.length > 10, true,
+      `valid SMILES expected: ${smiles}`);
+    const pCount = (smiles.match(/P/g) || []).length;
+    expect(pCount, 0, `expected 0 phosphates with both terminals: ${smiles}`);
+  });
+
+  // LNA (2,4-BNA) regression. The 2,4-O-CH2 bridge sits ABOVE C1' once the
+  // sugar is oriented with R1/R2 atoms horizontal, so the natural R3 vector
+  // points sideways instead of up. Without the abnormal-sugar override the
+  // base ends up sideways from the sugar (or worse, overlapping it). The
+  // assertion here is structural: must produce a valid single-fragment
+  // SMILES with the LNA-specific bridge oxygen plus the normal nucleoside
+  // features. Coordinates aren't checked — only connectivity.
+  test('rna-helm-lna-base-above-sugar', async () => {
+    const smiles = await helmRnaLinearToSmiles(`RNA1{[lna](A)p.[lna](T)}$$$$V2.0`);
+    expect(smiles !== 'MALFORMED_INPUT_VALUE' && smiles.length > 10, true,
+      `valid SMILES expected: ${smiles}`);
+    expect(smiles.indexOf('.') === -1, true,
+      `expected single fragment: ${smiles}`);
+    // Sanity check for nitrogens — adenine brings 5 (4 ring + 1 NH2) and
+    // thymine brings 2 (both ring), so at least 7 total. Match both
+    // uppercase (N, [nH]) and lowercase aromatic (n) — N atoms in heterocyclic
+    // SMILES are written lowercase when aromatic.
+    const nCount = (smiles.match(/[Nn]/g) || []).length;
+    expect(nCount >= 7, true, `expected at least 7 nitrogens: ${smiles}`);
+    // One inter-nucleotide phosphate.
+    const pCount = (smiles.match(/P/g) || []).length;
+    expect(pCount, 1, `expected exactly 1 phosphate: ${smiles}`);
+  });
+
+  // GalNAc oxygen-count regression. Previously the R1 placeholder atom
+  // (substituted to 'O' from the "OH" cap) was left in the assembly,
+  // adding a stray OH on the chain-attach carbon. lna(T)GalNAc has known
+  // expected SMILES with exactly 10 oxygens.
+  test('rna-helm-3p-terminal-galnac-no-extra-oh', async () => {
+    const smiles = await helmRnaLinearToSmiles(`RNA1{[lna](T)[GalNAc]}$$$$V2.0`);
+    expect(smiles !== 'MALFORMED_INPUT_VALUE' && smiles.length > 10, true,
+      `valid SMILES expected: ${smiles}`);
+    // Count OXYGEN ATOMS only — uppercase O outside of brackets in standard
+    // SMILES denotes a non-aromatic oxygen. Ring-closure digits and atoms
+    // inside [] don't match this regex.
+    const oCount = (smiles.match(/O/g) || []).length;
+    expect(oCount, 10, `expected exactly 10 oxygen atoms in lna-T-GalNAc: ${smiles}`);
+  });
+
+  // sp (and similar phosphates with R-cap = H) used to disconnect the chain
+  // because the H placeholder was removed by removeHydrogen, leaving
+  // terminalNodes[0] pointing at the now-deleted atom. The result was a
+  // SMILES with two disconnected fragments separated by '.'. The fix:
+  // when the cap is H, leave terminalNodes[0] at its original
+  // setTerminalNodes value (the atom previously bonded to R1, e.g. P) so
+  // the chain bond goes there directly.
+  test('rna-helm-h-cap-phosphate-sp-connects', async () => {
+    const smiles = await helmRnaLinearToSmiles(`RNA1{r(T)[sp].r(A)}$$$$V2.0`);
+    expect(smiles !== 'MALFORMED_INPUT_VALUE' && smiles.length > 10, true,
+      `valid SMILES expected: ${smiles}`);
+    // No '.' → single connected fragment.
+    expect(smiles.indexOf('.') === -1, true,
+      `expected single fragment (no '.' separator): ${smiles}`);
+    // Exactly one phosphorus from the sp linker.
+    const pCount = (smiles.match(/P/g) || []).length;
+    expect(pCount, 1, `expected exactly 1 phosphate: ${smiles}`);
+    // sp carries a sulfur on the phosphate.
+    expect(/S/.test(smiles), true, `expected sulfur from sp: ${smiles}`);
+  });
+
+  // Regression: H-cap phosphates (sp et al.) used to drop the bridging O
+  // on the 3' side of the linkage. The previous sugar's 3'-O is removed
+  // unconditionally during sugar processing on the assumption that the
+  // following linker brings its own bridging oxygen via the R1 cap; with
+  // an H cap that assumption breaks and the chain ended up as
+  // C3'-P(=O)(SH)-O-C5' instead of the proper C3'-O-P(=O)(SH)-O-C5'.
+  // The fix promotes the H cap to an O so the bridging atom always exists.
+  // Use m(2'-OMe ribose) so we can also verify the methoxy group survives
+  // the sp chain assembly.
+  test('rna-helm-sp-bridging-o-preserved', async () => {
+    const smiles = await helmRnaLinearToSmiles(`RNA1{m(A)[sp].r(A)[sp]}$$$$V2.0`);
+    expect(smiles !== 'MALFORMED_INPUT_VALUE' && smiles.length > 10, true,
+      `valid SMILES expected: ${smiles}`);
+    // Single connected fragment.
+    expect(smiles.indexOf('.') === -1, true,
+      `expected single fragment: ${smiles}`);
+    // 2 sp linkers → 2 phosphorus atoms.
+    const pCount = (smiles.match(/P/g) || []).length;
+    expect(pCount, 2, `expected exactly 2 phosphates: ${smiles}`);
+    // 2 sulfurs (one per sp).
+    const sCount = (smiles.match(/S/g) || []).length;
+    expect(sCount, 2, `expected exactly 2 sulfurs (one per sp): ${smiles}`);
+    // No C-P bond — every P should be bordered by O on both chain sides.
+    // A P preceded directly by an aliphatic carbon (lowercase 'c' is
+    // aromatic; capital 'C' is sp3) means the bridging O was lost.
+    expect(/C\d*P|CP|cP/.test(smiles), false,
+      `expected no direct C-P bond (bridging O missing): ${smiles}`);
+    // 2' methoxy on m must survive — methyl ether oxygen plus three oxygens
+    // per nucleotide gives plenty of O atoms; the structural assertion
+    // above is the strict one. Sanity-check that a methyl ether (OC) is
+    // present somewhere.
+    expect(/OC|CO/.test(smiles), true, `expected methoxy fragment: ${smiles}`);
+  });
+
+  // R-group swap heuristic: a single-R-group terminal monomer can be placed
+  // at either end of a HELM chain, even if its R-group label "should" only
+  // belong at one end. The conversion swaps rNodes so the existing
+  // TERMINAL_5P/3P role logic still works.
+  //
+  // Bio (R1 only) — naturally a 3'-terminal, but we accept it at 5' too.
+  test('rna-helm-bio-terminal-at-end', async () => {
+    const smiles = await helmRnaLinearToSmiles(`RNA1{r(T)[Bio]}$$$$V2.0`);
+    expect(smiles !== 'MALFORMED_INPUT_VALUE' && smiles.length > 10, true,
+      `valid SMILES expected: ${smiles}`);
+    // Bio replaces the trailing P → no phosphate at all.
+    const pCount = (smiles.match(/P/g) || []).length;
+    expect(pCount, 0, `expected 0 phosphates with Bio terminal: ${smiles}`);
+    // Single connected fragment.
+    expect(smiles.indexOf('.') === -1, true,
+      `expected single fragment: ${smiles}`);
+  });
+
+  test('rna-helm-bio-terminal-at-start', async () => {
+    const smiles = await helmRnaLinearToSmiles(`RNA1{[Bio].r(T)}$$$$V2.0`);
+    expect(smiles !== 'MALFORMED_INPUT_VALUE' && smiles.length > 10, true,
+      `valid SMILES expected: ${smiles}`);
+    // Single connected fragment (Bio at start must connect to following sugar).
+    expect(smiles.indexOf('.') === -1, true,
+      `expected single fragment: ${smiles}`);
+    // No phosphates (Bio doesn't carry P, no trailing p in HELM).
+    const pCount = (smiles.match(/P/g) || []).length;
+    expect(pCount, 0, `expected 0 phosphates: ${smiles}`);
+  });
+
+  // Chol (R2 only) — naturally a 5'-terminal, but we accept it at 3' too.
+  test('rna-helm-chol-terminal-at-start', async () => {
+    // Already covered by rna-helm-5p-terminal-chol; this is the canonical case.
+    const smiles = await helmRnaLinearToSmiles(`RNA1{[Chol].r(T)}$$$$V2.0`);
+    expect(smiles !== 'MALFORMED_INPUT_VALUE' && smiles.length > 10, true,
+      `valid SMILES expected: ${smiles}`);
+    expect(smiles.indexOf('.') === -1, true, `expected single fragment: ${smiles}`);
+  });
+
+  test('rna-helm-chol-terminal-at-end', async () => {
+    const smiles = await helmRnaLinearToSmiles(`RNA1{r(T)[Chol]}$$$$V2.0`);
+    expect(smiles !== 'MALFORMED_INPUT_VALUE' && smiles.length > 10, true,
+      `valid SMILES expected: ${smiles}`);
+    // Single connected fragment.
+    expect(smiles.indexOf('.') === -1, true,
+      `expected single fragment: ${smiles}`);
+    // Chol replaces the trailing P → no phosphate.
+    const pCount = (smiles.match(/P/g) || []).length;
+    expect(pCount, 0, `expected 0 phosphates with Chol terminal: ${smiles}`);
+  });
 });
 
 

package/src/utils/monomer-lib/consts.ts

@@ -9,5 +9,5 @@ export const LIB_SETTINGS_FOR_TESTS: UserLibSettings =
   {explicit: ['HELMCoreLibrary.json', 'polytool-lib.json'], exclude: [], duplicateMonomerPreferences: {}};
 
 /** Summary for settings {@link LIB_SETTINGS_FOR_TESTS} */
-export const monomerLibForTestsSummary: MonomerLibSummaryType = {'PEPTIDE': 334, 'RNA': 383, 'CHEM': 0};
+export const monomerLibForTestsSummary: MonomerLibSummaryType = {'PEPTIDE': 334, 'RNA': 390, 'CHEM': 0};
 

package/src/utils/monomer-lib/monomer-lib-base.ts

@@ -167,10 +167,11 @@ export class MonomerLibBase implements IMonomerLibBase {
 
     /** Get or create {@link Monomer} object (in case it is missing in monomer library current config) */
     let m: Monomer | null = this.getMonomer(pt, elem);
-    if (m && biotype == HelmTypes.LINKER && (m[REQ.RGROUPS]?.length ?? 0) < 2) {
-      // Web Editor expects null
-      return null;
-    }
+    // there can be linkers that have 1 rgroup that are terminal, so we allow that.
+    // if (m && biotype == HelmTypes.LINKER && (m[REQ.RGROUPS]?.length ?? 0) < 2) {
+    //   // Web Editor expects null
+    //   return null;
+    // }
     if (m && biotype == HelmTypes.SUGAR && (m[REQ.RGROUPS]?.length ?? 0) < 3) {
       // Web Editor expects null
       return null;

package/src/widgets/to-atomic-level-widget.ts

@@ -24,8 +24,16 @@ export async function toAtomicLevelSingle(sequence: DG.SemanticValue): Promise<{
       errorText = 'No sequence handler found';
       return {errorText, mol: ''};
     }
-    if ((seqSh.getSplitted(sequence.cell.rowIndex, 60)?.length ?? 100) > 50) {
-      errorText = 'Maximum number of monomers is 50';
+
+    let maxLength = 50;
+    if (seqSh.isHelm()) {
+      const splitted = seqSh.getSplitted(sequence.cell.rowIndex);
+      if (!splitted.graphInfo?.polymerTypes?.some((pt) => pt !== 'RNA'))
+        maxLength = 150;
+    }
+
+    if ((seqSh.getSplitted(sequence.cell.rowIndex)?.length ?? 100) > maxLength) {
+      errorText = 'Maximum number of monomers is ' + maxLength;
       return {errorText, mol: ''};
     }
     const singleValCol = DG.Column.fromStrings('singleVal', [sequence.value]);
@@ -73,8 +81,11 @@ export async function toAtomicLevelWidget(sequence: DG.SemanticValue): Promise<D
     const molSemanticValue = DG.SemanticValue.fromValueType(res.mol, DG.SEMTYPE.MOLECULE);
     const panel = ui.panels.infoPanel(molSemanticValue);
     let molPanel: DG.Widget | null = null;
-    if (panel)
-      molPanel = DG.Widget.fromRoot(panel.root);
+    if (panel) {
+      const acc = ui.accordion('Sequence Molfile details');
+      acc.addPane('Explore', () => panel.root);
+      molPanel = DG.Widget.fromRoot(acc.root);
+    }
 
 
     const root = grok.chem.drawMolecule(res.mol, 300, 300, false);