@datagrok/bio 2.25.1 → 2.25.2

package/src/package-api.ts

@@ -12,6 +12,13 @@ export namespace scripts {
     return await grok.functions.call('Bio:Embed', { molecule });
   }
 
+  /**
+  Converts molecules to HELM notation based on monomer library
+  */
+  export async function molToHelmConverterPy(moleculesDataframe: DG.DataFrame , moleculesColumn: DG.Column , libraryJSON: string ): Promise<DG.DataFrame> {
+    return await grok.functions.call('Bio:MolToHelmConverterPy', { moleculesDataframe, moleculesColumn, libraryJSON });
+  }
+
   /**
   Create the model peptides/DNA sequences with peptides data
   */
@@ -172,6 +179,13 @@ export namespace funcs {
     return await grok.functions.call('Bio:SequenceSpaceTopMenu', { table, molecules, methodName, similarityMetric, plotEmbeddings, preprocessingFunction, options, clusterEmbeddings, isDemo });
   }
 
+  /**
+  Converts Peptide molecules to HELM notation by matching with monomer library
+  */
+  export async function moleculesToHelmTopMenu(table: DG.DataFrame , molecules: DG.Column ): Promise<void> {
+    return await grok.functions.call('Bio:MoleculesToHelmTopMenu', { table, molecules });
+  }
+
   /**
   Converts sequences to molblocks
   */

package/src/package.g.ts

@@ -264,6 +264,15 @@ export async function sequenceSpaceTopMenu(table: DG.DataFrame, molecules: DG.Co
   return await PackageFunctions.sequenceSpaceTopMenu(table, molecules, methodName, similarityMetric, plotEmbeddings, preprocessingFunction, options, clusterEmbeddings, isDemo);
 }
 
+//name: Molecules to HELM
+//description: Converts Peptide molecules to HELM notation by matching with monomer library
+//input: dataframe table { description: Input data table }
+//input: column molecules { semType: Molecule; description: Molecule column }
+//top-menu: Bio | Transform | Molecules to HELM...
+export async function moleculesToHelmTopMenu(table: DG.DataFrame, molecules: DG.Column) : Promise<void> {
+  await PackageFunctions.moleculesToHelmTopMenu(table, molecules);
+}
+
 //name: To Atomic Level
 //description: Converts sequences to molblocks
 //input: dataframe table { description: Input data table }

package/src/package.ts

@@ -78,10 +78,12 @@ import {molecular3DStructureWidget, toAtomicLevelWidget} from './widgets/to-atom
 import {handleSequenceHeaderRendering} from './widgets/sequence-scrolling-widget';
 import {PolymerType} from '@datagrok-libraries/js-draw-lite/src/types/org';
 import {BilnNotationProvider} from './utils/biln';
-import {MonomerLibFromFilesProvider} from './utils/monomer-lib/library-file-manager/monomers-lib-provider';
+
+import * as api from './package-api';
 export const _package = new BioPackage(/*{debug: true}/**/);
 export * from './package.g';
 
+
 // /** Avoid reassigning {@link monomerLib} because consumers subscribe to {@link IMonomerLib.onChanged} event */
 // let monomerLib: MonomerLib | null = null;
 let initBioPromise: Promise<void> | null = null;
@@ -617,6 +619,30 @@ export class PackageFunctions {
     return res;
   }
 
+  @grok.decorators.func({
+    name: 'Molecules to HELM',
+    'top-menu': 'Bio | Transform | Molecules to HELM...',
+    description: 'Converts Peptide molecules to HELM notation by matching with monomer library',
+  })
+  static async moleculesToHelmTopMenu(
+    @grok.decorators.param({name: 'table', options: {description: 'Input data table'}})table: DG.DataFrame,
+    @grok.decorators.param({name: 'molecules', options: {semType: 'Molecule', description: 'Molecule column'}})molecules: DG.Column,
+  ) {
+    // collect current monomer library
+    const monomerLib = _package.monomerLib;
+    const libJSON = JSON.stringify(monomerLib.toJSON());
+    await api.scripts.molToHelmConverterPy(table, molecules, libJSON);
+
+    // semtype is not automatically set, so we set it manually
+    const newCol = table.columns.toList().find((c) => c.name.toLowerCase().includes('regenerated sequence') && c.semType !== DG.SEMTYPE.MACROMOLECULE);
+    if (newCol) {
+      newCol.meta.units = NOTATION.HELM;
+      newCol.semType = DG.SEMTYPE.MACROMOLECULE;
+      newCol.setTag('cell.renderer', 'helm');
+    }
+  }
+
+
   @grok.decorators.func({
     name: 'To Atomic Level',
     description: 'Converts sequences to molblocks',

package/src/utils/monomer-lib/library-file-manager/ui.ts

@@ -1,3 +1,5 @@
+/* eslint-disable rxjs/no-async-subscribe */
+/* eslint-disable rxjs/no-ignored-subscription */
 /* eslint-disable max-lines */
 /* Do not change these import lines to match external modules in webpack configuration */
 import * as grok from 'datagrok-api/grok';

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

@@ -62,24 +62,44 @@ export async function standardiseMonomers(monomers: Monomer[]) {
 
 /// matches molecules in the dataframe with monomers in the library by canonical smiles
 export async function matchMoleculesWithMonomers(molDf: DG.DataFrame, molColName: string, monomerLib: IMonomerLib, polymerType: PolymerType = 'PEPTIDE'): Promise<DG.DataFrame> {
+  const duplicates = monomerLib.duplicateMonomers?.[polymerType] ?? {};
   const converterFunc = DG.Func.find({package: 'Chem', name: 'convertMoleculeNotation'})[0];
   if (!converterFunc)
     throw new Error('Function convertMoleculeNotation not found, please install Chem package');
   // first: stamdardize monomers
   const monomers = monomerLib.getMonomerSymbolsByType(polymerType).map((s) => monomerLib.getMonomer(polymerType, s)!).filter((m) => m && (m.smiles || m.molfile));
   const fixedMonomers = await standardiseMonomers(monomers);
-  const cappedSmilse = fixedMonomers.map((m, i) => ({sym: m.symbol, smiles: capSmiles(m.smiles ?? '', m.rgroups ?? []), original: m.smiles, source: monomers[i]?.lib?.source})).filter((s) => !!s?.smiles && !s.smiles.includes('[*:'));
+  const unCappedMonomerSmilesMap = fixedMonomers.filter((m) => !!m.smiles).reduce((acc, m) => {
+    acc[m.smiles] = {symbol: m.symbol, smiles: m.smiles, original: m.smiles, source: m.lib?.source}; return acc;
+  }, {} as {[smiles: string]: {symbol: string, smiles: string, original: string | undefined, source: string | undefined}});
+  const cappedMonomerSmiles = fixedMonomers.map((m, i) => ({symbol: m.symbol, smiles: capSmiles(m.smiles ?? '', m.rgroups ?? []), original: m.smiles, source: monomers[i]?.lib?.source}))
+    .filter((s) => !!s?.smiles && !s.smiles.includes('[*:'));
+
   // canonicalize all monomer smiles
-  const monomerSmilesCol = DG.Column.fromList(DG.COLUMN_TYPE.STRING, 'MonomerSmiles', cappedSmilse.map((m) => m.smiles!));
+  const monomerSmilesCol = DG.Column.fromList(DG.COLUMN_TYPE.STRING, 'MonomerSmiles', cappedMonomerSmiles.map((m) => m.smiles!));
   monomerSmilesCol.semType = DG.SEMTYPE.MOLECULE;
   const canonicalizedMonomersSmilesCol: DG.Column = await converterFunc.apply({molecule: monomerSmilesCol, targetNotation: DG.chem.Notation.Smiles});
   if (!canonicalizedMonomersSmilesCol || canonicalizedMonomersSmilesCol.length !== monomerSmilesCol.length)
     throw new Error('Error canonicalizing monomer smiles');
-  canonicalizedMonomersSmilesCol.toList().forEach((s, i) => cappedSmilse[i].smiles = s);
+  canonicalizedMonomersSmilesCol.toList().forEach((s, i) => cappedMonomerSmiles[i].smiles = s);
+  const cappedMonomerSmilesMap = cappedMonomerSmiles.reduce((acc, m) => { acc[m.smiles] = m; return acc; }, {} as {[smiles: string]: {symbol: string, smiles: string, original: string | undefined, source: string | undefined}});
 
-  const molecules = molDf.col(molColName)!;
-  const canonicalizedMoleculesCol: DG.Column = await converterFunc.apply({molecule: molecules, targetNotation: DG.chem.Notation.Smiles});
-  if (!canonicalizedMoleculesCol || canonicalizedMoleculesCol.length !== molecules.length)
+  const moleculesOriginalCol = molDf.col(molColName)!;
+  const correctedOriginalList = moleculesOriginalCol.toList().map((s) => {
+    if (!s) return s;
+    try {
+      const isMolBlock = s.includes('\n');
+      return getCorrectedSmiles([], isMolBlock ? undefined : s, isMolBlock ? s : undefined);
+    } catch (_e) {
+      return s;
+    }
+  });
+  const moleculesOriginalColCorrected = DG.Column.fromList(DG.COLUMN_TYPE.STRING, 'MoleculesOriginalCorrected', correctedOriginalList);
+  // create dummy df
+  moleculesOriginalColCorrected.semType = DG.SEMTYPE.MOLECULE;
+  const _ddf = DG.DataFrame.fromColumns([moleculesOriginalColCorrected]);
+  const canonicalizedMoleculesCol: DG.Column = await converterFunc.apply({molecule: moleculesOriginalColCorrected, targetNotation: DG.chem.Notation.Smiles});
+  if (!canonicalizedMoleculesCol || canonicalizedMoleculesCol.length !== moleculesOriginalColCorrected.length)
     throw new Error('Error canonicalizing molecules');
 
   const canonicalizedMolecules = canonicalizedMoleculesCol.toList();
@@ -95,13 +115,14 @@ export async function matchMoleculesWithMonomers(molDf: DG.DataFrame, molColName
   for (let i = 0; i < canonicalizedMolecules.length; i++) {
     const mol = canonicalizedMolecules[i];
     if (!mol) continue;
-    for (let j = 0; j < cappedSmilse.length; j++) {
-      if (cappedSmilse[j].smiles === mol) {
-        matchingMonomerSmilesCol.set(i, cappedSmilse[j].original!, false);
-        matchingMonomerSymbolCol.set(i, cappedSmilse[j].sym, false);
-        sourceLibCol.set(i, cappedSmilse[j].source ?? '', false);
-        break;
-      }
+    const match = cappedMonomerSmilesMap[mol] ?? unCappedMonomerSmilesMap[mol];
+    if (match) {
+      const matchSymbol = match.symbol;
+      const sources = (duplicates[matchSymbol]?.length ?? 0) > 0 ? duplicates[matchSymbol].map((m) => m?.lib?.source).filter((s) => !!s).join(', ') : (match.source ?? '');
+      const originalSmiles = match.original ?? match.smiles;
+      matchingMonomerSmilesCol.set(i, originalSmiles, false);
+      matchingMonomerSymbolCol.set(i, matchSymbol, false);
+      sourceLibCol.set(i, sources, false);
     }
   }
   return resultDf;

package/src/widgets/sequence-scrolling-widget.ts

@@ -1,3 +1,4 @@
+/* eslint-disable max-params */
 /* eslint-disable rxjs/no-ignored-subscription */
 /* eslint-disable max-lines */
 /* eslint-disable max-len */
@@ -11,7 +12,7 @@ import {MonomerPlacer} from '@datagrok-libraries/bio/src/utils/cell-renderer-mon
 import {ALPHABET, TAGS as bioTAGS} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {_package} from '../package';
 import {ISeqHandler} from '@datagrok-libraries/bio/src/utils/macromolecule/seq-handler';
-import * as RxJs from 'rxjs';
+import * as rxjs from 'rxjs';
 import {filter} from 'rxjs/operators';
 import {IMonomerLib, getMonomerLibHelper} from '@datagrok-libraries/bio/src/types/monomer-library';
 import wu from 'wu';
@@ -322,6 +323,9 @@ class LazyConservationTrack extends ConservationTrack {
 //  MAIN HANDLER
 // ============================================================================
 
+export const MSA_HEADER_INITIALIZED_FLAG = '__msa-scroller-initialized';
+export const MSA_SCROLLER_GRID_SUBSCRIPTION = '__msa-scroller-subscription';
+
 export function handleSequenceHeaderRendering() {
   const handleGrid = (grid: DG.Grid) => {
     setTimeout(() => {
@@ -332,213 +336,221 @@ export function handleSequenceHeaderRendering() {
 
       const seqCols = df.columns.bySemTypeAll(DG.SEMTYPE.MACROMOLECULE);
 
+      grid.temp[MSA_SCROLLER_GRID_SUBSCRIPTION]?.unsubscribe();
+      grid.temp[MSA_SCROLLER_GRID_SUBSCRIPTION] = DG.debounce(rxjs.merge(df.onColumnsAdded, df.onSemanticTypeDetected), 200).subscribe(() => handleGrid(grid));
+      grid.sub(grid.temp[MSA_SCROLLER_GRID_SUBSCRIPTION]);
+
       for (const seqCol of seqCols) {
+        // first check if the column was already processed
+        const gCol = grid.col(seqCol.name);
+        if (!gCol) continue;
+
+        if (gCol.temp[MSA_HEADER_INITIALIZED_FLAG])
+          continue;
+        gCol.temp[MSA_HEADER_INITIALIZED_FLAG] = true;
+
+
         let sh: ISeqHandler | null = null;
 
         try {
           sh = _package.seqHelper.getSeqHandler(seqCol);
         } catch (_e) {
+          console.warn(`Failed to get SeqHandler for column ${seqCol.name}`);
           continue;
         }
-        if (!sh) continue;
-        if (sh.isHelm() || sh.alphabet === ALPHABET.UN) continue;
-
-        const gCol = grid.col(seqCol.name);
-        if (!gCol) continue;
+        if (!sh)
+          continue;
+        if (sh.isHelm() || sh.alphabet === ALPHABET.UN)
+          continue; // Skip HELM and unknown alphabet, only works for sequences where we know positions of each monomers
 
         let positionStatsViewerAddedOnce = !!grid.tableView &&
           Array.from(grid.tableView.viewers).some((v) => v.type === 'Sequence Position Statistics');
 
-        const isMSA = sh.isMsa();
-
-        if (isMSA) {
-          const ifNan = (a: number, els: number) => (Number.isNaN(a) ? els : a);
-          const getStart = () => ifNan(Math.max(Number.parseInt(seqCol.getTag(bioTAGS.positionShift) ?? '0'), 0), 0) + 1;
-          const getCurrent = () => ifNan(Number.parseInt(seqCol.getTag(bioTAGS.selectedPosition) ?? '-2'), -2);
-          const getFontSize = () => MonomerPlacer.getFontSettings(seqCol).fontWidth;
-
-          // Get maximum sequence length. since this scroller is only applicable to Single character monomeric sequences,
-          // we do not need to check every single sequence and split it, instead, max length will coorelate with length of the longest string
-          let pseudoMaxLenIndex = 0;
-          let pseudoMaxLength = 0;
-          const cats = seqCol.categories;
-          for (let i = 0; i < cats.length; i++) {
-            const seq = cats[i];
-            if (seq && seq.length > pseudoMaxLength) {
-              pseudoMaxLength = seq.length;
-              pseudoMaxLenIndex = i;
-            }
+
+        const ifNan = (a: number, els: number) => (Number.isNaN(a) || a == null ? els : a);
+        const getStart = () => ifNan(Math.max(Number.parseInt(seqCol.getTag(bioTAGS.positionShift) ?? '0'), 0), 0) + 1;
+        const getCurrent = () => ifNan(Number.parseInt(seqCol.getTag(bioTAGS.selectedPosition) ?? '-2'), -2);
+        const getFontSize = () => MonomerPlacer.getFontSettings(seqCol).fontWidth;
+
+        // Get maximum sequence length. since this scroller is only applicable to Single character monomeric sequences,
+        // we do not need to check every single sequence and split it, instead, max length will coorelate with length of the longest string
+        let pseudoMaxLenIndex = 0;
+        let pseudoMaxLength = 0;
+        const cats = seqCol.categories;
+        for (let i = 0; i < cats.length; i++) {
+          const seq = cats[i];
+          if (seq && seq.length > pseudoMaxLength) {
+            pseudoMaxLength = seq.length;
+            pseudoMaxLenIndex = i;
+          }
+        }
+        const seq = cats[pseudoMaxLenIndex];
+        const split = sh.splitter(seq);
+        const maxSeqLen = split ? split.length : 30;
+
+        // Do not Skip if sequences are too short, rather, just don't render the tracks by default
+
+        const STRICT_THRESHOLDS = {
+          WITH_TITLE: 58, // BASE + TITLE_HEIGHT(16) + TRACK_GAP(4)
+          WITH_WEBLOGO: 107, // WITH_TITLE + DEFAULT_TRACK_HEIGHT(45) + TRACK_GAP(4)
+          WITH_BOTH: 156 // WITH_WEBLOGO + DEFAULT_TRACK_HEIGHT(45) + TRACK_GAP(4)
+        };
+
+        let initialHeaderHeight: number;
+        if (seqCol.length > 100_000 || maxSeqLen < 50) {
+          // Single sequence: just dotted cells
+          initialHeaderHeight = STRICT_THRESHOLDS.WITH_TITLE;
+        } else {
+          if (seqCol.length > 50_000)
+            initialHeaderHeight = STRICT_THRESHOLDS.WITH_WEBLOGO;
+          else
+            initialHeaderHeight = STRICT_THRESHOLDS.WITH_BOTH;
+        }
+
+        let webLogoTrackRef: LazyWebLogoTrack | null = null;
+        let conservationTrackRef: LazyConservationTrack | null = null;
+        const filterChangeSub = DG.debounce(
+          rxjs.merge(df.onFilterChanged, df.onDataChanged.pipe(filter((a) => a?.args?.column === seqCol))), 100
+        ).subscribe(() => {
+          MSAViewportManager.clearAllCaches();
+
+          if (webLogoTrackRef) {
+            webLogoTrackRef.resetViewportTracking();
+            webLogoTrackRef.forceUpdate();
+          }
+          if (conservationTrackRef) {
+            conservationTrackRef.resetViewportTracking();
+            conservationTrackRef.forceUpdate();
           }
-          const seq = cats[pseudoMaxLenIndex];
-          const split = sh.splitter(seq);
-          const maxSeqLen = split ? split.length : 30;
-
-          // Do not Skip if sequences are too short, rather, just don't render the tracks by default
-
-          const STRICT_THRESHOLDS = {
-            WITH_TITLE: 58, // BASE + TITLE_HEIGHT(16) + TRACK_GAP(4)
-            WITH_WEBLOGO: 107, // WITH_TITLE + DEFAULT_TRACK_HEIGHT(45) + TRACK_GAP(4)
-            WITH_BOTH: 156 // WITH_WEBLOGO + DEFAULT_TRACK_HEIGHT(45) + TRACK_GAP(4)
-          };
-
-          let initialHeaderHeight: number;
-          if (seqCol.length > 100_000 || maxSeqLen < 50) {
-            // Single sequence: just dotted cells
-            initialHeaderHeight = STRICT_THRESHOLDS.WITH_TITLE;
-          } else {
-            if (seqCol.length > 50_000)
-              initialHeaderHeight = STRICT_THRESHOLDS.WITH_WEBLOGO;
-            else
-              initialHeaderHeight = STRICT_THRESHOLDS.WITH_BOTH;
+          setTimeout(() => {
+            if (!grid.isDetached)
+              grid.invalidate();
+          }, 50);
+        });
+
+        grid.sub(filterChangeSub);
+
+        const initializeHeaders = (monomerLib: IMonomerLib) => {
+          const tracks: { id: string, track: MSAHeaderTrack, priority: number }[] = [];
+
+          // Create lazy tracks only for MSA sequences
+
+          // OPTIMIZED: Pass seqHandler directly instead of column/splitter
+          const conservationTrack = new LazyConservationTrack(
+            sh,
+            maxSeqLen,
+            45, // DEFAULT_TRACK_HEIGHT
+            'default',
+            'Conservation'
+          );
+          conservationTrackRef = conservationTrack; // Store reference
+          tracks.push({id: 'conservation', track: conservationTrack, priority: 1});
+
+          // OPTIMIZED: Pass seqHandler directly
+          const webLogoTrack = new LazyWebLogoTrack(
+            sh,
+            maxSeqLen,
+            45, // DEFAULT_TRACK_HEIGHT
+            'WebLogo'
+          );
+          webLogoTrackRef = webLogoTrack; // Store reference
+
+          if (monomerLib) {
+            webLogoTrack.setMonomerLib(monomerLib);
+            webLogoTrack.setBiotype(sh.defaultBiotype || 'HELM_AA');
           }
 
-          let webLogoTrackRef: LazyWebLogoTrack | null = null;
-          let conservationTrackRef: LazyConservationTrack | null = null;
-          const filterChangeSub = DG.debounce(
-            RxJs.merge(df.onFilterChanged, df.onDataChanged.pipe(filter((a) => a?.args?.column === seqCol))), 100
-          ).subscribe(() => {
-            MSAViewportManager.clearAllCaches();
-
-            if (webLogoTrackRef) {
-              webLogoTrackRef.resetViewportTracking();
-              webLogoTrackRef.forceUpdate();
-            }
-            if (conservationTrackRef) {
-              conservationTrackRef.resetViewportTracking();
-              conservationTrackRef.forceUpdate();
-            }
-            setTimeout(() => {
-              if (!grid.isDetached)
-                grid.invalidate();
-            }, 50);
+          webLogoTrack.setupDefaultTooltip();
+          tracks.push({id: 'weblogo', track: webLogoTrack, priority: 2});
+
+          // Create the scrolling header
+          const scroller = new MSAScrollingHeader({
+            canvas: grid.overlay,
+            headerHeight: initialHeaderHeight,
+            totalPositions: maxSeqLen + 1,
+            onPositionChange: (scrollerCur, scrollerRange) => {
+              setTimeout(() => {
+                const start = getStart();
+                const cur = getCurrent();
+                if (start !== scrollerRange.start)
+                  seqCol.setTag(bioTAGS.positionShift, (scrollerRange.start - 1).toString());
+
+                if (cur !== scrollerCur) {
+                  seqCol.setTag(bioTAGS.selectedPosition, (scrollerCur).toString());
+                  if (scrollerCur >= 0 && !positionStatsViewerAddedOnce && grid.tableView && wu(grid.dataFrame?.columns.numerical).find((_c) => true)) {
+                    positionStatsViewerAddedOnce = true;
+                    const v = grid.tableView.addViewer('Sequence Position Statistics', {sequenceColumnName: seqCol.name});
+                    grid.tableView.dockManager.dock(v, DG.DOCK_TYPE.DOWN, null, 'Sequence Position Statistics', 0.4);
+                  }
+                }
+              });
+            },
+            onHeaderHeightChange: (_newHeight) => {
+              // Update grid header height
+              if (grid.isDetached || _newHeight < STRICT_THRESHOLDS.WITH_TITLE) return;
+              setTimeout(() => grid.props.colHeaderHeight = _newHeight);
+            },
+          }, gCol);
+
+          scroller.setupTooltipHandling();
+
+          // Add tracks to scroller
+          tracks.forEach(({id, track}) => {
+            scroller.addTrack(id, track);
           });
 
-          grid.sub(filterChangeSub);
+          scroller.setSelectionData(df, seqCol, sh);
 
-          const initializeHeaders = (monomerLib: IMonomerLib) => {
-            const tracks: { id: string, track: MSAHeaderTrack, priority: number }[] = [];
+          if (maxSeqLen > 50) {
+            grid.props.colHeaderHeight = initialHeaderHeight;
 
-            // Create lazy tracks only for MSA sequences
+            // Set column width
+            setTimeout(() => {
+              if (grid.isDetached) return;
+              gCol.width = 400;
+            }, 300);
+          }
 
-            // OPTIMIZED: Pass seqHandler directly instead of column/splitter
-            const conservationTrack = new LazyConservationTrack(
-              sh,
-              maxSeqLen,
-              45, // DEFAULT_TRACK_HEIGHT
-              'default',
-              'Conservation'
-            );
-            conservationTrackRef = conservationTrack; // Store reference
-            tracks.push({id: 'conservation', track: conservationTrack, priority: 1});
-
-            // OPTIMIZED: Pass seqHandler directly
-            const webLogoTrack = new LazyWebLogoTrack(
-              sh,
-              maxSeqLen,
-              45, // DEFAULT_TRACK_HEIGHT
-              'WebLogo'
-            );
-            webLogoTrackRef = webLogoTrack; // Store reference
-
-            if (monomerLib) {
-              webLogoTrack.setMonomerLib(monomerLib);
-              webLogoTrack.setBiotype(sh.defaultBiotype || 'HELM_AA');
-            }
-
-            webLogoTrack.setupDefaultTooltip();
-            tracks.push({id: 'weblogo', track: webLogoTrack, priority: 2});
-
-            // Create the scrolling header
-            const scroller = new MSAScrollingHeader({
-              canvas: grid.overlay,
-              headerHeight: initialHeaderHeight,
-              totalPositions: maxSeqLen + 1,
-              onPositionChange: (scrollerCur, scrollerRange) => {
-                setTimeout(() => {
-                  const start = getStart();
-                  const cur = getCurrent();
-                  if (start !== scrollerRange.start)
-                    seqCol.setTag(bioTAGS.positionShift, (scrollerRange.start - 1).toString());
-
-                  if (cur !== scrollerCur) {
-                    seqCol.setTag(bioTAGS.selectedPosition, (scrollerCur).toString());
-                    if (scrollerCur >= 0 && !positionStatsViewerAddedOnce && grid.tableView && wu(grid.dataFrame?.columns.numerical).find((_c) => true)) {
-                      positionStatsViewerAddedOnce = true;
-                      const v = grid.tableView.addViewer('Sequence Position Statistics', {sequenceColumnName: seqCol.name});
-                      grid.tableView.dockManager.dock(v, DG.DOCK_TYPE.DOWN, null, 'Sequence Position Statistics', 0.4);
-                    }
-                  }
-                });
-              },
-              onHeaderHeightChange: (_newHeight) => {
-                // Update grid header height
-                if (grid.isDetached || _newHeight < STRICT_THRESHOLDS.WITH_TITLE) return;
-                setTimeout(() => grid.props.colHeaderHeight = _newHeight);
-              },
-            }, gCol);
+          // Handle cell rendering for MSA
+          grid.sub(grid.onCellRender.subscribe((e) => {
+            const cell = e.cell;
+            if (!cell || !cell.isColHeader || cell?.gridColumn?.name !== gCol?.name)
+              return;
 
-            scroller.setupTooltipHandling();
+            const cellBounds = e.bounds;
+            if (!cellBounds) return;
 
-            // Add tracks to scroller
-            tracks.forEach(({id, track}) => {
-              scroller.addTrack(id, track);
-            });
+            // Set dynamic properties
+            scroller.headerHeight = cellBounds.height;
+            const font = getFontSize();
+            scroller.positionWidth = font + 8; // MSA always has padding
 
-            scroller.setSelectionData(df, seqCol, sh);
+            const start = getStart();
 
-            if (maxSeqLen > 50) {
-              grid.props.colHeaderHeight = initialHeaderHeight;
 
-              // Set column width
-              setTimeout(() => {
-                if (grid.isDetached) return;
-                gCol.width = 400;
-              }, 300);
-            }
-
-            // Handle cell rendering for MSA
-            grid.sub(grid.onCellRender.subscribe((e) => {
-              const cell = e.cell;
-              if (!cell || !cell.isColHeader || cell?.gridColumn?.name !== gCol?.name)
-                return;
-
-              const cellBounds = e.bounds;
-              if (!cellBounds) return;
-
-              // Set dynamic properties
-              scroller.headerHeight = cellBounds.height;
-              const font = getFontSize();
-              scroller.positionWidth = font + 8; // MSA always has padding
-
-              const start = getStart();
-
-
-              scroller.draw(
-                cellBounds.x,
-                cellBounds.y,
-                cellBounds.width,
-                cellBounds.height,
-                getCurrent(),
-                start,
-                e,
-                seqCol.name
-              );
-            }));
-          };
-
-          // Initialize with monomer library for MSA sequences
-          getMonomerLibHelper()
-            .then((libHelper) => {
-              const monomerLib = libHelper.getMonomerLib();
-              initializeHeaders(monomerLib);
-            })
-            .catch((error) => {
-              grok.shell.warning(`Failed to initialize monomer library`);
-              console.error('Failed to initialize monomer library:', error);
-            });
-        } else {
-          // For non-MSA sequences, just use standard sequence rendering.
-        }
+            scroller.draw(
+              cellBounds.x,
+              cellBounds.y,
+              cellBounds.width,
+              cellBounds.height,
+              getCurrent(),
+              start,
+              e,
+              seqCol.name
+            );
+          }));
+        };
+
+        // Initialize with monomer library for MSA sequences
+        getMonomerLibHelper()
+          .then((libHelper) => {
+            const monomerLib = libHelper.getMonomerLib();
+            initializeHeaders(monomerLib);
+          })
+          .catch((error) => {
+            grok.shell.warning(`Failed to initialize monomer library`);
+            console.error('Failed to initialize monomer library:', error);
+          });
       }
     }, 1000);
   };