@datagrok/bio 2.22.6 → 2.22.7

package/src/package.ts

@@ -2,7 +2,7 @@
 /* eslint-disable rxjs/no-nested-subscribe */
 /* eslint-disable max-params */
 /* eslint-disable max-len */
-/* eslint max-lines: "off" */
+/* eslint max-lines: 'off' */
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
@@ -77,437 +77,339 @@ import {_toAtomicLevel} from '@datagrok-libraries/bio/src/monomer-works/to-atomi
 import {molecular3DStructureWidget, toAtomicLevelWidget} from './widgets/to-atomic-level-widget';
 import {handleSequenceHeaderRendering} from './widgets/sequence-scrolling-widget';
 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;
 
-//name: getMonomerLibHelper
-//description: Returns an instance of the monomer library helper
-//output: object result
-export async function getMonomerLibHelper(): Promise<IMonomerLibHelper> {
-  return await MonomerLibManager.getInstance();
-}
+export class PackageFunctions {
+  @grok.decorators.func({description: 'Returns an instance of the monomer library helper', outputs: [{type: 'object', name: 'result'}]})
+  static async getMonomerLibHelper(): Promise<IMonomerLibHelper> {
+    return await MonomerLibManager.getInstance();
+  }
 
-//export let hydrophobPalette: SeqPaletteCustom | null = null;
+  @grok.decorators.init({})
+  static async initBio(): Promise<void> {
+    if (initBioPromise === null)
+      initBioPromise = initBioInt();
 
-export class SeqPaletteCustom implements SeqPalette {
-  private readonly _palette: { [m: string]: string };
-
-  constructor(palette: { [m: string]: string }) {
-    this._palette = palette;
+    await initBioPromise;
   }
 
-  public get(m: string): string {
-    return this._palette[m];
+  @grok.decorators.func({tags: ['tooltip']})
+  static sequenceTooltip(
+    @grok.decorators.param({options: {semType: 'Macromolecule'}}) col: DG.Column): DG.Widget<any> {
+    const resWidget = new MacromoleculeColumnWidget(col, _package.seqHelper);
+    const _resPromise = resWidget.init().then(() => { })
+      .catch((err: any) => {
+        const errMsg = err instanceof Error ? err.message : err.toString();
+        grok.shell.error(errMsg);
+      });
+    return resWidget;
   }
-}
-
-let initBioPromise: Promise<void> | null = null;
-
-//tags: init
-export async function initBio(): Promise<void> {
-  if (initBioPromise === null)
-    initBioPromise = initBioInt();
-
-  await initBioPromise;
-}
 
-async function initBioInt() {
-  const logPrefix = 'Bio: _package.initBio()';
-  _package.logger.debug(`${logPrefix}, start`);
-  const t1: number = window.performance.now();
-  // very important that loading should happen in correct order!
-  // first make sure chem and rdkit module are loaded
-  const rdKitModule = await getRdKitModule();
-  // then load package settings
-  const pkgProps = await _package.getProperties();
-  const bioPkgProps = new BioPackageProperties(pkgProps);
-  _package.properties = bioPkgProps;
-  // then load monomer lib
-  const libHelper = await MonomerLibManager.getInstance();
-  // Fix user lib settings for explicit stuck from a terminated test
-  const libSettings = await getUserLibSettings();
-  if (libSettings.explicit) {
-    libSettings.explicit = [];
-    await setUserLibSettings(libSettings);
+  // Keep for backward compatibility
+  @grok.decorators.func({outputs: [{type: 'object', name: 'monomerLib'}]})
+  static getBioLib(): IMonomerLib {
+    return _package.monomerLib;
   }
-  await libHelper.awaitLoaded(Infinity);
-  if (!libHelper.initialLoadCompleted)
-    await libHelper.loadMonomerLib();
-  // Do not wait for monomers and sets loaded
-  libHelper.loadMonomerSets();
-  const monomerLib = libHelper.getMonomerLib();
-  const monomerSets = libHelper.getMonomerSets();
-  // finally log
-  const t2: number = window.performance.now();
-  _package.logger.debug(`${logPrefix}, loading ET: ${t2 - t1} ms`);
-
-  // const monomers: string[] = [];
-  // const logPs: number[] = [];
 
-  const seqHelper = new SeqHelper(libHelper, rdKitModule);
-  _package.completeInit(seqHelper, monomerLib, monomerSets, rdKitModule);
-
-  // NB! do not delete the code below. not used now but in future we might use hydrophobicity palette
-  // const series = monomerLib!.getMonomerMolsByPolymerType('PEPTIDE')!;
-  // Object.keys(series).forEach((symbol) => {
-  //   monomers.push(symbol);
-  //   const block = series[symbol].replaceAll('#R', 'O ');
-  //   const mol = rdKitModule.get_mol(block);
-  //   const logP = JSON.parse(mol.get_descriptors()).CrippenClogP;
-  //   logPs.push(logP);
-  //   mol?.delete();
-  // });
-
-  // const sum = logPs.reduce((a, b) => a + b, 0);
-  // const avg = (sum / logPs.length) || 0;
+  @grok.decorators.func({outputs: [{type: 'object', name: 'result'}]})
+  static getSeqHandler(
+    @grok.decorators.param({type: 'column', options: {semType: 'Macromolecule'}}) sequence: DG.Column<string>): ISeqHandler {
+    return _package.seqHelper.getSeqHandler(sequence);
+  }
 
-  // const palette: { [monomer: string]: string } = {};
-  // for (let i = 0; i < monomers.length; i++)
-  //   palette[monomers[i]] = logPs[i] < avg ? '#4682B4' : '#DC143C';
+  // -- Panels --
+
+  @grok.decorators.panel({name: 'Bioinformatics | Get Region', description: 'Creates a new column with sequences of the region between start and end'})
+  static getRegionPanel(
+    @grok.decorators.param({type: 'column', options: {semType: 'Macromolecule'}}) seqCol: DG.Column<string>): DG.Widget {
+    const funcName: string = 'getRegionTopMenu';
+    const funcList = DG.Func.find({package: _package.name, name: funcName});
+    if (funcList.length !== 1) throw new Error(`Package '${_package.name}' func '${funcName}' not found`);
+    const func = funcList[0];
+    const funcCall = func.prepare({table: seqCol.dataFrame, sequence: seqCol});
+    const funcEditor = new GetRegionFuncEditor(funcCall, _package.seqHelper);
+    return funcEditor.widget();
+  }
 
-  // hydrophobPalette = new SeqPaletteCustom(palette);
+  @grok.decorators.panel({name: 'Bioinformatics | Manage Monomer Libraries', tags: ['exclude-actions-panel']})
+  static async libraryPanel(
+    @grok.decorators.param({name: 'seqColumn', options: {semType: 'Macromolecule'}}) _seqColumn: DG.Column): Promise<DG.Widget> {
+    // return getLibraryPanelUI();
+    return getMonomerLibraryManagerLink();
+  }
 
-  _package.logger.debug(`${logPrefix}, end`);
-  handleSequenceHeaderRendering();
-}
+  // -- Func Editors --
 
-//name: sequenceTooltip
-//tags: tooltip
-//input: column col {semType: Macromolecule}
-//output: widget result
-export function sequenceTooltip(col: DG.Column): DG.Widget<any> {
-  const resWidget = new MacromoleculeColumnWidget(col, _package.seqHelper);
-  const _resPromise = resWidget.init().then(() => { })
-    .catch((err: any) => {
+  @grok.decorators.editor({})
+  static GetRegionEditor(call: DG.FuncCall): void {
+    try {
+      const funcEditor = new GetRegionFuncEditor(call, _package.seqHelper);
+      funcEditor.dialog();
+    } catch (err: any) {
       const errMsg = err instanceof Error ? err.message : err.toString();
-      grok.shell.error(errMsg);
-    });
-  return resWidget;
-}
-
-// Keep for backward compatibility
-//name: getBioLib
-//output: object monomerLib
-export function getBioLib(): IMonomerLib {
-  return _package.monomerLib;
-}
-
-//name: getSeqHandler
-//input: column sequence { semType: Macromolecule }
-//output: object result
-export function getSeqHandler(sequence: DG.Column<string>): ISeqHandler {
-  return _package.seqHelper.getSeqHandler(sequence);
-}
-
-// -- Panels --
-
-//name: Bioinformatics | Get Region
-//description: Creates a new column with sequences of the region between start and end
-//tags: panel
-//input: column seqCol {semType: Macromolecule}
-//output: widget result
-export function getRegionPanel(seqCol: DG.Column<string>): DG.Widget {
-  const funcName: string = 'getRegionTopMenu';
-  const funcList = DG.Func.find({package: _package.name, name: funcName});
-  if (funcList.length !== 1) throw new Error(`Package '${_package.name}' func '${funcName}' not found`);
-  const func = funcList[0];
-  const funcCall = func.prepare({table: seqCol.dataFrame, sequence: seqCol});
-  const funcEditor = new GetRegionFuncEditor(funcCall, _package.seqHelper);
-  return funcEditor.widget();
-}
-
-//name: Bioinformatics | Manage Monomer Libraries
-//description:
-//tags: panel, exclude-actions-panel
-//input: column seqColumn {semType: Macromolecule}
-//output: widget result
-export async function libraryPanel(_seqColumn: DG.Column): Promise<DG.Widget> {
-  // return getLibraryPanelUI();
-  return getMonomerLibraryManagerLink();
-}
-
-// -- Func Editors --
-
-//name: GetRegionEditor
-//tags: editor
-//input: funccall call
-export function GetRegionEditor(call: DG.FuncCall): void {
-  try {
-    const funcEditor = new GetRegionFuncEditor(call, _package.seqHelper);
-    funcEditor.dialog();
-  } catch (err: any) {
-    const errMsg = err instanceof Error ? err.message : err.toString();
-    const errStack = err instanceof Error ? err.stack : undefined;
-    grok.shell.error(`Get region editor error: ${errMsg}`);
-    _package.logger.error(errMsg, undefined, errStack);
+      const errStack = err instanceof Error ? err.stack : undefined;
+      grok.shell.error(`Get region editor error: ${errMsg}`);
+      _package.logger.error(errMsg, undefined, errStack);
+    }
   }
-}
-
-//name: SplitToMonomersEditor
-//tags: editor
-//input: funccall call
-export function SplitToMonomersEditor(call: DG.FuncCall): void {
-  const funcEditor = new SplitToMonomersFunctionEditor();
-  ui.dialog({title: 'Split to Monomers'})
-    .add(funcEditor.paramsUI)
-    .onOK(async () => {
-      return call.func.prepare(funcEditor.funcParams).call(true);
-    })
-    .show();
-}
-
-//name: SequenceSpaceEditor
-//tags: editor
-//input: funccall call
-export function SequenceSpaceEditor(call: DG.FuncCall) {
-  const funcEditor = new DimReductionBaseEditor({semtype: DG.SEMTYPE.MACROMOLECULE});
-  const dialog = ui.dialog({title: 'Sequence Space'})
-    .add(funcEditor.getEditor())
-    .onOK(async () => {
-      const params = funcEditor.getParams();
-      return call.func.prepare({
-        molecules: params.col,
-        table: params.table,
-        methodName: params.methodName,
-        similarityMetric: params.similarityMetric,
-        plotEmbeddings: params.plotEmbeddings,
-        options: params.options,
-        preprocessingFunction: params.preprocessingFunction,
-        clusterEmbeddings: params.clusterEmbeddings,
-      }).call();
-    });
-  dialog.history(() => ({editorSettings: funcEditor.getStringInput()}), (x: any) => funcEditor.applyStringInput(x['editorSettings']));
-  dialog.show();
-}
-
-//name: SeqActivityCliffsEditor
-//tags: editor
-//input: funccall call
-export function SeqActivityCliffsEditor(call: DG.FuncCall) {
-  const funcEditor = new ActivityCliffsEditor({semtype: DG.SEMTYPE.MACROMOLECULE});
-  const dialog = ui.dialog({title: 'Activity Cliffs'})
-    .add(funcEditor.getEditor())
-    .onOK(async () => {
-      const params = funcEditor.getParams();
-      return call.func.prepare({
-        table: params.table,
-        molecules: params.col,
-        activities: params.activities,
-        similarity: params.similarityThreshold,
-        methodName: params.methodName,
-        similarityMetric: params.similarityMetric,
-        preprocessingFunction: params.preprocessingFunction,
-        options: params.options,
-      }).call();
-    });
-  dialog.history(() => ({editorSettings: funcEditor.getStringInput()}), (x: any) => funcEditor.applyStringInput(x['editorSettings']));
-  dialog.show();
-}
 
-// -- Package settings editor --
-
-// //name: packageSettingsEditor
-// //description: The database connection
-// //tags: packageSettingsEditor
-// //input: object propList
-// //output: widget result
-// export function packageSettingsEditor(propList: DG.Property[]): DG.Widget {
-//   const widget = new PackageSettingsEditorWidget(propList);
-//   widget.init().then(); // Ignore promise returned
-//   return widget as DG.Widget;
-// }
+  @grok.decorators.editor({})
+  static SplitToMonomersEditor(call: DG.FuncCall): void {
+    const funcEditor = new SplitToMonomersFunctionEditor();
+    ui.dialog({title: 'Split to Monomers'})
+      .add(funcEditor.paramsUI)
+      .onOK(async () => {
+        return call.func.prepare(funcEditor.funcParams).call(true);
+      })
+      .show();
+  }
 
-// -- Cell renderers --
+  @grok.decorators.editor({})
+  static SequenceSpaceEditor(call: DG.FuncCall) {
+    const funcEditor = new DimReductionBaseEditor({semtype: DG.SEMTYPE.MACROMOLECULE});
+    const dialog = ui.dialog({title: 'Sequence Space'})
+      .add(funcEditor.getEditor())
+      .onOK(async () => {
+        const params = funcEditor.getParams();
+        return call.func.prepare({
+          molecules: params.col,
+          table: params.table,
+          methodName: params.methodName,
+          similarityMetric: params.similarityMetric,
+          plotEmbeddings: params.plotEmbeddings,
+          options: params.options,
+          preprocessingFunction: params.preprocessingFunction,
+          clusterEmbeddings: params.clusterEmbeddings,
+        }).call();
+      });
+    dialog.history(() => ({editorSettings: funcEditor.getStringInput()}), (x: any) => funcEditor.applyStringInput(x['editorSettings']));
+    dialog.show();
+  }
 
-//name: customSequenceCellRenderer
-//tags: cellRenderer
-//meta.cellType: sequence
-//meta.columnTags: quality=Macromolecule, units=custom
-//output: grid_cell_renderer result
-export function customSequenceCellRenderer(): DG.GridCellRenderer {
-  return new MacromoleculeSequenceCellRenderer();
-}
+  @grok.decorators.editor({})
+  static SeqActivityCliffsEditor(call: DG.FuncCall) {
+    const funcEditor = new ActivityCliffsEditor({semtype: DG.SEMTYPE.MACROMOLECULE});
+    const dialog = ui.dialog({title: 'Activity Cliffs'})
+      .add(funcEditor.getEditor())
+      .onOK(async () => {
+        const params = funcEditor.getParams();
+        return call.func.prepare({
+          table: params.table,
+          molecules: params.col,
+          activities: params.activities,
+          similarity: params.similarityThreshold,
+          methodName: params.methodName,
+          similarityMetric: params.similarityMetric,
+          preprocessingFunction: params.preprocessingFunction,
+          options: params.options,
+        }).call();
+      });
+    dialog.history(() => ({editorSettings: funcEditor.getStringInput()}), (x: any) => funcEditor.applyStringInput(x['editorSettings']));
+    dialog.show();
+  }
 
-//name: fastaSequenceCellRenderer
-//tags: cellRenderer
-//meta.cellType: sequence
-//meta.columnTags: quality=Macromolecule, units=fasta
-//output: grid_cell_renderer result
-export function fastaSequenceCellRenderer(): MacromoleculeSequenceCellRenderer {
-  return new MacromoleculeSequenceCellRenderer();
-}
 
-//name: separatorSequenceCellRenderer
-//tags: cellRenderer
-//meta.cellType: sequence
-//meta.columnTags: quality=Macromolecule, units=separator
-//output: grid_cell_renderer result
-export function separatorSequenceCellRenderer(): MacromoleculeSequenceCellRenderer {
-  return new MacromoleculeSequenceCellRenderer();
-}
+  // -- Cell renderers --
 
-// -- Property panels --
+  @grok.decorators.func({
+    name: 'customSequenceCellRenderer',
+    tags: ['cellRenderer'],
+    meta: {
+      cellType: 'sequence',
+      columnTags: 'quality=Macromolecule, units=custom'
+    },
+    outputs: [{type: 'grid_cell_renderer', name: 'result'}]
+  })
+  static customSequenceCellRenderer(): DG.GridCellRenderer {
+    return new MacromoleculeSequenceCellRenderer();
+  }
 
-//name:  Bioinformatics | Sequence Renderer
-//input: column molColumn {semType: Macromolecule}
-//tags: panel
-//output: widget result
-export function macroMolColumnPropertyPanel(molColumn: DG.Column): DG.Widget {
-  return getMacromoleculeColumnPropertyPanel(molColumn);
-}
+  @grok.decorators.func({
+    name: 'fastaSequenceCellRenderer',
+    tags: ['cellRenderer'],
+    meta: {
+      cellType: 'sequence',
+      columnTags: 'quality=Macromolecule, units=fasta'
+    },
+    outputs: [{type: 'grid_cell_renderer', name: 'result'}]
+  })
+  static fastaSequenceCellRenderer(): MacromoleculeSequenceCellRenderer {
+    return new MacromoleculeSequenceCellRenderer();
+  }
 
-//name: Composition analysis
-//tags: panel, bio, widgets
-//input: semantic_value sequence { semType: Macromolecule }
-//output: widget result
-export function compositionAnalysisWidget(sequence: DG.SemanticValue): DG.Widget {
-  return getCompositionAnalysisWidget(sequence, _package.monomerLib, _package.seqHelper);
-}
+  @grok.decorators.func({
+    name: 'separatorSequenceCellRenderer',
+    tags: ['cellRenderer'],
+    meta: {
+      cellType: 'sequence',
+      columnTags: 'quality=Macromolecule, units=separator'
+    },
+    outputs: [{type: 'grid_cell_renderer', name: 'result'}]
+  })
+  static separatorSequenceCellRenderer(): MacromoleculeSequenceCellRenderer {
+    return new MacromoleculeSequenceCellRenderer();
+  }
 
-//name: MacromoleculeDifferenceCellRenderer
-//tags: cellRenderer
-//meta.cellType: MacromoleculeDifference
-//meta.columnTags: quality=MacromoleculeDifference
-//output: grid_cell_renderer result
-export function macromoleculeDifferenceCellRenderer(): MacromoleculeDifferenceCellRenderer {
-  return new MacromoleculeDifferenceCellRenderer();
-}
+  // // -- Property panels --
 
+  @grok.decorators.panel({name: 'Bioinformatics | Sequence Renderer'})
+  static macroMolColumnPropertyPanel(
+    @grok.decorators.param({options: {semType: 'Macromolecule'}}) molColumn: DG.Column): DG.Widget {
+    return getMacromoleculeColumnPropertyPanel(molColumn);
+  }
 
-//name: sequenceAlignment
-//input: string alignType {choices: ['Local alignment', 'Global alignment']}
-//input: string alignTable {choices: ['AUTO', 'NUCLEOTIDES', 'BLOSUM45', 'BLOSUM50', 'BLOSUM62','BLOSUM80','BLOSUM90','PAM30','PAM70','PAM250','SCHNEIDER','TRANS']}
-//input: double gap
-//input: string seq1
-//input: string seq2
-//output: object res
-export function sequenceAlignment(alignType: string, alignTable: string, gap: number, seq1: string, seq2: string) {
-  const toAlign = new SequenceAlignment(seq1, seq2, gap, alignTable);
-  const res = alignType == 'Local alignment' ? toAlign.smithWaterman() : toAlign.needlemanWunsch();
-  return res;
-}
+  @grok.decorators.panel({name: 'Composition analysis', tags: ['bio', 'widgets']})
+  static compositionAnalysisWidget(
+    @grok.decorators.param({options: {semType: 'Macromolecule'}}) sequence: DG.SemanticValue): DG.Widget {
+    return getCompositionAnalysisWidget(sequence, _package.monomerLib, _package.seqHelper);
+  }
 
-// -- Viewers --
+  @grok.decorators.func({
+    name: 'MacromoleculeDifferenceCellRenderer',
+    tags: ['cellRenderer'],
+    meta: {
+      cellType: 'MacromoleculeDifference',
+      columnTags: 'quality=MacromoleculeDifference'
+    },
+    outputs: [{type: 'grid_cell_renderer', name: 'result'}]
+  })
+  static macromoleculeDifferenceCellRenderer(): MacromoleculeDifferenceCellRenderer {
+    return new MacromoleculeDifferenceCellRenderer();
+  }
 
-//name: WebLogo
-//description: WebLogo
-//tags: viewer, panel
-//output: viewer result
-//meta.icon: files/icons/weblogo-viewer.svg
-export function webLogoViewer() {
-  return new WebLogoViewer();
-}
+  @grok.decorators.func({outputs: [{type: 'object', name: 'result'}]})
+  static sequenceAlignment(
+    @grok.decorators.param({options: {choices: ['Local alignment', 'Global alignment']}}) alignType: string,
+    @grok.decorators.param({options: {choices: ['AUTO', 'NUCLEOTIDES', 'BLOSUM45', 'BLOSUM50', 'BLOSUM62', 'BLOSUM80', 'BLOSUM90', 'PAM30', 'PAM70', 'PAM250', 'SCHNEIDER', 'TRANS']}}) alignTable: string,
+      gap: number,
+      seq1: string,
+      seq2: string) {
+    const toAlign = new SequenceAlignment(seq1, seq2, gap, alignTable);
+    const res = alignType == 'Local alignment' ? toAlign.smithWaterman() : toAlign.needlemanWunsch();
+    return res;
+  }
 
-//name: VdRegions
-//description: V-Domain regions viewer
-//tags: viewer, panel
-//meta.icon: files/icons/vdregions-viewer.svg
-//output: viewer result
-export function vdRegionsViewer() {
-  return new VdRegionsViewer();
-}
+  // -- Viewers --
+
+  @grok.decorators.panel({
+    name: 'WebLogo',
+    description: 'WebLogo',
+    tags: ['viewer'],
+    meta: {icon: 'files/icons/weblogo-viewer.svg'},
+    outputs: [{type: 'viewer', name: 'result'}]
+  })
+  static webLogoViewer() {
+    return new WebLogoViewer();
+  }
 
+  @grok.decorators.panel({
+    name: 'VdRegions',
+    description: 'V-Domain regions viewer',
+    tags: ['viewer'],
+    meta: {icon: 'files/icons/vdregions-viewer.svg'},
+    outputs: [{type: 'viewer', name: 'result'}],
+  })
+  static vdRegionsViewer() {
+    return new VdRegionsViewer();
+  }
 
-// -- Top menu --
-
-//name: getRegion
-//description: Gets a new column with sequences of the region between start and end
-//input: column sequence
-//input: string start  {optional: true}
-//input: string end    {optional: true}
-//input: string name   {optional: true} [Name of the column to be created]
-//output: column result
-export function getRegion(
-  sequence: DG.Column<string>, start: string | undefined, end: string | undefined, name: string | undefined
-): DG.Column<string> {
-  return getRegionDo(sequence,
-    start ?? null, end ?? null, name ?? null);
-}
+  // -- Top menu --
 
-//top-menu: Bio | Calculate | Get Region...
-//name: Get Region Top Menu
-//description: Get sequences for a region specified from a Macromolecule
-//input: dataframe table                           [Input data table]
-//input: column sequence  {semType: Macromolecule} [Sequence column]
-//input: string start     {optional: true}         [Region start position name]
-//input: string end       {optional: true}         [Region end position name]
-//input: string name      {optional: true}         [Region column name]
-//editor: Bio:GetRegionEditor
-export async function getRegionTopMenu(
-  table: DG.DataFrame, sequence: DG.Column,
-  start: string | undefined, end: string | undefined, name: string | undefined
-): Promise<void> {
-  const regCol = getRegionDo(sequence, start ?? null, end ?? null, name ?? null);
-  sequence.dataFrame.columns.add(regCol);
-  await grok.data.detectSemanticTypes(sequence.dataFrame); // to set renderer
-}
+  @grok.decorators.func({name: 'getRegion', description: 'Gets a new column with sequences of the region between start and end'})
+  static getRegion(
+    @grok.decorators.param({type: 'column'})sequence: DG.Column<string>,
+    @grok.decorators.param({type: 'string', options: {optional: true}}) start: string | undefined,
+    @grok.decorators.param({type: 'string', options: {optional: true}}) end: string | undefined,
+    @grok.decorators.param({type: 'string', options: {optional: true, description: 'Name of the column to be created'}}) name: string | undefined): DG.Column<string> {
+    return getRegionDo(sequence,
+      start ?? null, end ?? null, name ?? null);
+  }
 
-//top-menu: Bio | Analyze | Activity Cliffs...
-//name: Sequence Activity Cliffs
-//description: Detects pairs of molecules with similar structure and significant difference in any given property
-//input: dataframe table [Input data table]
-//input: column molecules {semType: Macromolecule}
-//input: column activities
-//input: double similarity = 80 [Similarity cutoff]
-//input: string methodName { choices:["UMAP", "t-SNE"] }
-//input: string similarityMetric { choices:["Hamming", "Levenshtein", "Monomer chemical distance"] }
-//input: func preprocessingFunction
-//input: object options {optional: true}
-//input: bool demo {optional: true}
-//editor: Bio:SeqActivityCliffsEditor
-export async function activityCliffs(table: DG.DataFrame, molecules: DG.Column<string>, activities: DG.Column,
-  similarity: number, methodName: DimReductionMethods,
-  similarityMetric: MmDistanceFunctionsNames | BitArrayMetrics, preprocessingFunction: DG.Func,
-  options?: (IUMAPOptions | ITSNEOptions) & Options, demo?: boolean): Promise<DG.Viewer | undefined> {
-  //workaround for functions which add viewers to tableView (can be run only on active table view)
-  if (table !== grok.shell.tv.dataFrame) {
-    grok.shell.error(`Table ${table.name} is not a current table view`);
-    return;
-  }
-  const tv = grok.shell.tv;
-  if (!checkInputColumnUI(molecules, 'Activity Cliffs'))
-    return;
-  const axesNames = getEmbeddingColsNames(table);
-  const tags = {
-    'units': molecules.meta.units!,
-    'aligned': molecules.getTag(bioTAGS.aligned),
-    'separator': molecules.getTag(bioTAGS.separator),
-    'alphabet': molecules.getTag(bioTAGS.alphabet),
-  };
-  const columnDistanceMetric: MmDistanceFunctionsNames | BitArrayMetrics = similarityMetric;
-  const seqCol = molecules;
-
-  const runCliffs = async () => {
-    const sp = await getActivityCliffs(
-      table,
-      seqCol,
-      axesNames,
-      'Activity cliffs', //scatterTitle
-      activities,
-      similarity,
-      columnDistanceMetric, //similarityMetric
-      methodName,
-      {...(options ?? {})},
-      DG.SEMTYPE.MACROMOLECULE,
-      tags,
-      preprocessingFunction,
-      createTooltipElement,
-      createPropPanelElement,
-      createLinesGrid,
-      undefined,
-      demo
-    );
-    return sp;
-  };
-
-  const allowedRowCount = methodName === DimReductionMethods.UMAP ? 200_000 : 20_000;
-  const fastRowCount = methodName === DimReductionMethods.UMAP ? 5_000 : 2_000;
-  if (table.rowCount > allowedRowCount) {
-    grok.shell.warning(`Too many rows, maximum for sequence activity cliffs is ${allowedRowCount}`);
-    return;
+  @grok.decorators.func({
+    name: 'Get Region Top Menu',
+    description: 'Get sequences for a region specified from a Macromolecule',
+    'top-menu': 'Bio | Calculate | Get Region...',
+    editor: 'Bio:GetRegionEditor'})
+  static async getRegionTopMenu(
+    @grok.decorators.param({options: {description: 'Input data table'}})table: DG.DataFrame,
+    @grok.decorators.param({options: {semType: 'Macromolecule', description: 'Sequence column'}}) sequence: DG.Column,
+    @grok.decorators.param({type: 'string', options: {optional: true, description: 'Region start position name'}}) start: string | undefined,
+    @grok.decorators.param({type: 'string', options: {optional: true, description: 'Region end position name'}}) end: string | undefined,
+    @grok.decorators.param({type: 'string', options: {optional: true, description: 'Region column name'}}) name: string | undefined
+  ): Promise<void> {
+    const regCol = getRegionDo(sequence, start ?? null, end ?? null, name ?? null);
+    sequence.dataFrame.columns.add(regCol);
+    await grok.data.detectSemanticTypes(sequence.dataFrame); // to set renderer
   }
 
+  @grok.decorators.func({
+    name: 'Sequence Activity Cliffs',
+    description: 'Detects pairs of molecules with similar structure and significant difference in any given property',
+    'top-menu': 'Bio | Analyze | Activity Cliffs...',
+    editor: 'Bio:SeqActivityCliffsEditor',
+    outputs: []
+  })
+  static async activityCliffs(
+    @grok.decorators.param({options: {description: 'Input data table'}})table: DG.DataFrame,
+    @grok.decorators.param({type: 'string', options: {semType: 'Macromolecule', description: 'Input data table'}}) molecules: DG.Column<string>,
+    activities: DG.Column,
+    @grok.decorators.param({options: {initialValue: '80', description: 'Similarity cutoff'}}) similarity: number,
+    @grok.decorators.param({type: 'string', options: {choices: ['UMAP', 't-SNE']}}) methodName: DimReductionMethods,
+    @grok.decorators.param({type: 'string', options: {choices: ['Hamming', 'Levenshtein', 'Monomer chemical distance']}}) similarityMetric: MmDistanceFunctionsNames | BitArrayMetrics,
+    @grok.decorators.param({type: 'func'}) preprocessingFunction: DG.Func,
+    @grok.decorators.param({type: 'object', options: {optional: true}}) options?: (IUMAPOptions | ITSNEOptions) & Options,
+    @grok.decorators.param({options: {optional: true}}) demo?: boolean): Promise<DG.Viewer | undefined> {
+    //workaround for functions which add viewers to tableView (can be run only on active table view)
+    if (table.name !== grok.shell.tv.dataFrame.name) {
+      grok.shell.error(`Table ${table.name} is not a current table view`);
+      return;
+    }
+    if (!checkInputColumnUI(molecules, 'Activity Cliffs'))
+      return;
+    const axesNames = getEmbeddingColsNames(table);
+    const tags = {
+      'units': molecules.meta.units!,
+      'aligned': molecules.getTag(bioTAGS.aligned),
+      'separator': molecules.getTag(bioTAGS.separator),
+      'alphabet': molecules.getTag(bioTAGS.alphabet),
+    };
+    const columnDistanceMetric: MmDistanceFunctionsNames | BitArrayMetrics = similarityMetric;
+    const seqCol = molecules;
+
+    const runCliffs = async () => {
+      const sp = await getActivityCliffs(
+        table,
+        seqCol,
+        axesNames,
+        'Activity cliffs', //scatterTitle
+        activities,
+        similarity,
+        columnDistanceMetric, //similarityMetric
+        methodName,
+        {...(options ?? {})},
+        DG.SEMTYPE.MACROMOLECULE,
+        tags,
+        preprocessingFunction,
+        createTooltipElement,
+        createPropPanelElement,
+        createLinesGrid,
+        undefined,
+        demo
+      );
+      return sp;
+    };
+
+    const allowedRowCount = methodName === DimReductionMethods.UMAP ? 200_000 : 20_000;
+    const fastRowCount = methodName === DimReductionMethods.UMAP ? 5_000 : 2_000;
+    if (table.rowCount > allowedRowCount) {
+      grok.shell.warning(`Too many rows, maximum for sequence activity cliffs is ${allowedRowCount}`);
+      return;
+    }
+
   const pi = DG.TaskBarProgressIndicator.create(`Running sequence activity cliffs ...`);
   const scRes = (await new Promise<DG.Viewer | undefined>((resolve, reject) => {
     if (table.rowCount > fastRowCount && !options?.[BYPASS_LARGE_DATA_WARNING]) {
@@ -533,745 +435,912 @@ export async function activityCliffs(table: DG.DataFrame, molecules: DG.Column<s
   return scRes;
 }
 
-//name: Encode Sequences
-//tags: dim-red-preprocessing-function
-//meta.supportedSemTypes: Macromolecule
-//meta.supportedTypes: string
-//meta.supportedDistanceFunctions: Hamming,Levenshtein,Monomer chemical distance,Needlemann-Wunsch
-//input: column col {semType: Macromolecule}
-//input: string metric
-//input: double gapOpen = 1 {caption: Gap open penalty; default: 1; optional: true}
-//input: double gapExtend = 0.6 {caption: Gap extension penalty; default: 0.6; optional: true}
-// eslint-disable-next-line max-len
-//input: string fingerprintType = 'Morgan' {caption: Fingerprint type; choices: ['Morgan', 'RDKit', 'Pattern', 'AtomPair', 'MACCS', 'TopologicalTorsion']; optional: true}
-//output: object result
-export async function macromoleculePreprocessingFunction(
-  col: DG.Column, metric: MmDistanceFunctionsNames, gapOpen: number = 1, gapExtend: number = 0.6,
-  fingerprintType = 'Morgan'): Promise<PreprocessFunctionReturnType> {
-  if (col.semType !== DG.SEMTYPE.MACROMOLECULE)
-    return {entries: col.toList(), options: {}};
-
-  const {seqList, options} = await getEncodedSeqSpaceCol(col, metric, fingerprintType, gapOpen, gapExtend);
-  return {entries: seqList, options};
-}
+  @grok.decorators.func({
+    name: 'Encode Sequences',
+    tags: ['dim-red-preprocessing-function'],
+    meta: {
+      supportedSemTypes: 'Macromolecule',
+      supportedTypes: 'string',
+      supportedDistanceFunctions: 'Hamming,Levenshtein,Monomer chemical distance,Needlemann-Wunsch'
+    },
+    outputs: [{type: 'object', name: 'result'}],
+  })
+  static async macromoleculePreprocessingFunction(
+    @grok.decorators.param({options: {semType: 'Macromolecule'}})col: DG.Column,
+    @grok.decorators.param({type: 'string'}) metric: MmDistanceFunctionsNames,
+    @grok.decorators.param({options: {initialValue: '1', caption: 'Gap open penalty', optional: true}}) gapOpen: number = 1,
+    @grok.decorators.param({options: {initialValue: '0.6', caption: 'Gap extension penalty', optional: true}}) gapExtend: number = 0.6,
+    @grok.decorators.param({options: {caption: 'Fingerprint type', initialValue: 'Morgan', choices: ['Morgan', 'RDKit', 'Pattern', 'AtomPair', 'MACCS', 'TopologicalTorsion'], optional: true}}) fingerprintType : string = 'Morgan'): Promise<PreprocessFunctionReturnType> {
+    if (col.semType !== DG.SEMTYPE.MACROMOLECULE)
+      return {entries: col.toList(), options: {}};
+
+    const {seqList, options} = await getEncodedSeqSpaceCol(col, metric, fingerprintType, gapOpen, gapExtend);
+    return {entries: seqList, options};
+  }
 
-//name: Helm Fingerprints
-//meta.supportedSemTypes: Macromolecule
-//meta.supportedTypes: string
-//meta.supportedUnits: helm
-//meta.supportedDistanceFunctions: Tanimoto,Asymmetric,Cosine,Sokal
-//input: column col {semType: Macromolecule}
-//input: string _metric
-//output: object result
-export async function helmPreprocessingFunction(
-  col: DG.Column<string>, _metric: BitArrayMetrics): Promise<PreprocessFunctionReturnType> {
-  if (col.version !== col.temp[MONOMERIC_COL_TAGS.LAST_INVALIDATED_VERSION])
-    await invalidateMols(col, _package.seqHelper, false);
-  const molCol = col.temp[MONOMERIC_COL_TAGS.MONOMERIC_MOLS];
-  const fingerPrints: DG.Column<DG.BitSet | null> =
-    await grok.functions.call('Chem:getMorganFingerprints', {molColumn: molCol});
-
-  const entries: Array<BitArray | null> = new Array(fingerPrints.length).fill(null);
-  for (let i = 0; i < fingerPrints.length; i++) {
-    if (fingerPrints.isNone(i) || !fingerPrints.get(i))
-      continue;
-    const fp = fingerPrints.get(i)!;
-    entries[i] = BitArray.fromUint32Array(fp.length, new Uint32Array(fp.getBuffer().buffer));
-  }
-  return {entries, options: {}};
-}
+  @grok.decorators.func({name: 'Helm Fingerprints',
+    meta: {
+      supportedSemTypes: 'Macromolecule',
+      supportedTypes: 'string',
+      supportedUnits: 'helm',
+      supportedDistanceFunctions: 'Tanimoto,Asymmetric,Cosine,Sokal'
+    },
+    outputs: [{type: 'object', name: 'result'}],
+  })
+  static async helmPreprocessingFunction(
+    @grok.decorators.param({type: 'column', options: {semType: 'Macromolecule'}}) col: DG.Column<string>,
+    @grok.decorators.param({type: 'string'})_metric: BitArrayMetrics): Promise<PreprocessFunctionReturnType> {
+    if (col.version !== col.temp[MONOMERIC_COL_TAGS.LAST_INVALIDATED_VERSION])
+      await invalidateMols(col, _package.seqHelper, false);
+    const molCol = col.temp[MONOMERIC_COL_TAGS.MONOMERIC_MOLS];
+    const fingerPrints: DG.Column<DG.BitSet | null> =
+      await grok.functions.call('Chem:getMorganFingerprints', {molColumn: molCol});
+
+    const entries: Array<BitArray | null> = new Array(fingerPrints.length).fill(null);
+    for (let i = 0; i < fingerPrints.length; i++) {
+      if (fingerPrints.isNone(i) || !fingerPrints.get(i))
+        continue;
+      const fp = fingerPrints.get(i)!;
+      entries[i] = BitArray.fromUint32Array(fp.length, new Uint32Array(fp.getBuffer().buffer));
+    }
+    return {entries, options: {}};
+  }
 
-//top-menu: Bio | Analyze | Sequence Space...
-//name: Sequence Space
-//description: Creates 2D sequence space with projected sequences by pairwise distance
-//input: dataframe table
-//input: column molecules { semType: Macromolecule }
-//input: string methodName { choices:["UMAP", "t-SNE"] }
-//input: string similarityMetric { choices:["Hamming", "Levenshtein", "Monomer chemical distance"] }
-//input: bool plotEmbeddings = true
-//input: func preprocessingFunction {optional: true}
-//input: object options {optional: true}
-//input: bool clusterEmbeddings = true { optional: true }
-//input: bool isDemo {optional: true}
-//editor: Bio:SequenceSpaceEditor
-export async function sequenceSpaceTopMenu(table: DG.DataFrame, molecules: DG.Column,
-  methodName: DimReductionMethods, similarityMetric: BitArrayMetrics | MmDistanceFunctionsNames,
-  plotEmbeddings: boolean, preprocessingFunction?: DG.Func, options?: (IUMAPOptions | ITSNEOptions) & Options,
-  clusterEmbeddings?: boolean, isDemo?: boolean
-): Promise<DG.ScatterPlotViewer | undefined> {
-  //workaround for functions which add viewers to tableView (can be run only on active table view)
-  if (table.name !== grok.shell.tv.dataFrame.name) {
-    grok.shell.error(`Table ${table.name} is not a current table view`);
-    return;
-  }
-  const tableView =
-    grok.shell.tv.dataFrame == table ? grok.shell.tv : undefined;
-  if (!checkInputColumnUI(molecules, 'Sequence Space'))
-    return;
-  if (!preprocessingFunction)
-    preprocessingFunction = DG.Func.find({name: 'macromoleculePreprocessingFunction', package: 'Bio'})[0];
-  options ??= {};
-  const res = await multiColReduceDimensionality(table, [molecules], methodName,
-    [similarityMetric as KnownMetrics], [1], [preprocessingFunction], 'MANHATTAN',
-    plotEmbeddings, clusterEmbeddings ?? false,
-    /* dimRedOptions */ {...options, preprocessingFuncArgs: [options.preprocessingFuncArgs ?? {}]},
-    /* uiOptions */{
-      fastRowCount: 10000,
-      scatterPlotName: 'Sequence space',
-      bypassLargeDataWarning: options?.[BYPASS_LARGE_DATA_WARNING],
-      tableView: tableView,
-    });
-  return res;
-}
+  @grok.decorators.func({
+    name: 'Sequence Space',
+    description: 'Creates 2D sequence space with projected sequences by pairwise distance',
+    'top-menu': 'Bio | Analyze | Sequence Space...',
+    editor: 'Bio:SequenceSpaceEditor',
+    outputs: [],
+  })
+  static async sequenceSpaceTopMenu(
+    table: DG.DataFrame,
+    @grok.decorators.param({options: {semType: 'Macromolecule'}}) molecules: DG.Column,
+    @grok.decorators.param({type: 'string', options: {choices: ['UMAP', 't-SNE']}}) methodName: DimReductionMethods,
+    @grok.decorators.param({type: 'string', options: {choices: ['Hamming', 'Levenshtein', 'Monomer chemical distance']}}) similarityMetric: BitArrayMetrics | MmDistanceFunctionsNames,
+    @grok.decorators.param({options: {initialValue: 'true'}}) plotEmbeddings: boolean,
+    @grok.decorators.param({type: 'func', options: {optional: true}}) preprocessingFunction?: DG.Func,
+    @grok.decorators.param({type: 'object', options: {optional: true}}) options?: (IUMAPOptions | ITSNEOptions) & Options,
+    @grok.decorators.param({options: {optional: true, initialValue: 'true'}}) clusterEmbeddings?: boolean,
+    @grok.decorators.param({options: {optional: true}}) isDemo?: boolean
+  ): Promise<DG.ScatterPlotViewer | undefined> {
+    //workaround for functions which add viewers to tableView (can be run only on active table view)
+    if (table.name !== grok.shell.tv.dataFrame.name) {
+      grok.shell.error(`Table ${table.name} is not a current table view`);
+      return;
+    }
+    const tableView =
+      grok.shell.tv.dataFrame == table ? grok.shell.tv : undefined;
+    if (!checkInputColumnUI(molecules, 'Sequence Space'))
+      return;
+    if (!preprocessingFunction)
+      preprocessingFunction = DG.Func.find({name: 'macromoleculePreprocessingFunction', package: 'Bio'})[0];
+    options ??= {};
+    const res = await multiColReduceDimensionality(table, [molecules], methodName,
+      [similarityMetric as KnownMetrics], [1], [preprocessingFunction], 'MANHATTAN',
+      plotEmbeddings, clusterEmbeddings ?? false,
+      /* dimRedOptions */ {...options, preprocessingFuncArgs: [options.preprocessingFuncArgs ?? {}]},
+      /* uiOptions */{
+        fastRowCount: 10000,
+        scatterPlotName: 'Sequence space',
+        bypassLargeDataWarning: options?.[BYPASS_LARGE_DATA_WARNING],
+        tableView: tableView,
+      });
+    return res;
+  }
 
-//top-menu: Bio | Transform | To Atomic Level...
-//name: To Atomic Level
-//description: Converts sequences to molblocks
-//input: dataframe table [Input data table]
-//input: column seqCol {caption: Sequence; semType: Macromolecule}
-//input: bool nonlinear =false {caption: Non-linear; description: Slower mode for cycling/branching HELM structures}
-//input: bool highlight =false {caption: Highlight monomers; description: Highlight monomers' substructures of the molecule }
-export async function toAtomicLevel(
-  table: DG.DataFrame, seqCol: DG.Column, nonlinear: boolean, highlight: boolean = false
-): Promise<void> {
-  const pi = DG.TaskBarProgressIndicator.create('Converting to atomic level ...');
-  try {
-    await initBioPromise;
-    const monomerLib = seqCol.temp[MmcrTemps.overriddenLibrary] ?? _package.monomerLib;
-    const seqHelper = _package.seqHelper;
-    const rdKitModule = _package.rdKitModule;
-    await sequenceToMolfile(table, seqCol, nonlinear, highlight, monomerLib, seqHelper, rdKitModule);
-  } finally {
-    pi.close();
+  @grok.decorators.func({
+    name: 'To Atomic Level',
+    description: 'Converts sequences to molblocks',
+    'top-menu': 'Bio | Transform | To Atomic Level...',
+  })
+  static async toAtomicLevel(
+    @grok.decorators.param({options: {description: 'Input data table'}})table: DG.DataFrame,
+    @grok.decorators.param({options: {semType: 'Macromolecule', caption: 'Sequence'}})seqCol: DG.Column,
+    @grok.decorators.param({options: {initialValue: 'false', caption: 'Non-linear', description: 'Slower mode for cycling/branching HELM structures'}}) nonlinear: boolean,
+    @grok.decorators.param({options: {initialValue: 'false', caption: 'Highlight monomers', description: 'Highlight monomers\' substructures of the molecule'}}) highlight: boolean = false
+  ): Promise<void> {
+    const pi = DG.TaskBarProgressIndicator.create('Converting to atomic level ...');
+    try {
+      await initBioPromise;
+      const monomerLib = seqCol.temp[MmcrTemps.overriddenLibrary] ?? _package.monomerLib;
+      const seqHelper = _package.seqHelper;
+      const rdKitModule = _package.rdKitModule;
+      await sequenceToMolfile(table, seqCol, nonlinear, highlight, monomerLib, seqHelper, rdKitModule);
+    } finally {
+      pi.close();
+    }
   }
-}
 
-//name: To Atomic Level...
-//input: column seqCol {semType: Macromolecule}
-//meta.action: to atomic level
-export async function toAtomicLevelAction(seqCol: DG.Column) {
-  if (!seqCol?.dataFrame)
-    throw new Error('Sequence column is not found or its data frame is not empty');
-  const func = DG.Func.find({name: 'toAtomicLevel', package: 'Bio'})[0];
-  if (!func) throw new Error('To Atomic level Function not found');
-  func.prepare({table: seqCol.dataFrame, seqCol: seqCol}).edit();
-}
+  @grok.decorators.func({
+    name: 'To Atomic Level...',
+    meta: {action: 'to atomic level'}
+  })
+  static async toAtomicLevelAction(
+    @grok.decorators.param({options: {semType: 'Macromolecule'}}) seqCol: DG.Column) {
+    if (!seqCol?.dataFrame)
+      throw new Error('Sequence column is not found or its data frame is not empty');
+    const func = DG.Func.find({name: 'toAtomicLevel', package: 'Bio'})[0];
+    if (!func) throw new Error('To Atomic level Function not found');
+    func.prepare({table: seqCol.dataFrame, seqCol: seqCol}).edit();
+  }
 
-//name: Molecular Structure
-//tags: panel, bio, widgets
-//input: semantic_value sequence { semType: Macromolecule }
-//output: widget result
-export async function toAtomicLevelPanel(sequence: DG.SemanticValue): Promise<DG.Widget> {
-  return toAtomicLevelWidget(sequence);
-}
+  @grok.decorators.panel({
+    name: 'Molecular Structure',
+    tags: ['bio', 'widgets']
+  })
+  static async toAtomicLevelPanel(
+    @grok.decorators.param({name: 'sequence', type: 'semantic_value', options: {semType: 'Macromolecule'}})
+      sequence: DG.SemanticValue
+  ) : Promise<DG.Widget> {
+    return toAtomicLevelWidget(sequence);
+  }
 
-//name: Molecular 3D Structure
-//tags: panel, bio, widgets
-//input: semantic_value sequence { semType: Macromolecule }
-//output: widget result
-export async function sequence3dStructureWidget(sequence: DG.SemanticValue): Promise<DG.Widget> {
-  return molecular3DStructureWidget(sequence);
-}
+  @grok.decorators.panel({
+    name: 'Molecular 3D Structure',
+    tags: ['bio', 'widgets']
+  })
+  static async sequence3dStructureWidget(
+    @grok.decorators.param({
+      type: 'semantic_value',
+      options: {semType: 'Macromolecule'}
+    })
+      sequence: DG.SemanticValue
+  ): Promise<DG.Widget> {
+    return molecular3DStructureWidget(sequence);
+  }
 
-//top-menu: Bio | Analyze | MSA...
-//name: MSA
-//description: Performs multiple sequence alignment
-//tags: bio, panel
-export function multipleSequenceAlignmentDialog(): void {
-  multipleSequenceAlignmentUI({}, _package.seqHelper)
-    .catch((err: any) => {
-      const [errMsg, errStack] = errInfo(err);
-      if (err instanceof MsaWarning) {
-        grok.shell.warning((err as MsaWarning).element);
-        _package.logger.warning(errMsg);
-        return;
-      }
-      grok.shell.error(errMsg);
-      _package.logger.error(errMsg, undefined, errStack);
-      // throw err; // This error throw is not handled
-    });
-}
+  @grok.decorators.panel({
+    name: 'MSA',
+    description: 'Performs multiple sequence alignment',
+    tags: ['bio'],
+    'top-menu': 'Bio | Analyze | MSA...'
+  })
+  static multipleSequenceAlignmentDialog(): void {
+    multipleSequenceAlignmentUI({}, _package.seqHelper)
+      .catch((err: any) => {
+        const [errMsg, errStack] = errInfo(err);
+        if (err instanceof MsaWarning) {
+          grok.shell.warning((err as MsaWarning).element);
+          _package.logger.warning(errMsg);
+          return;
+        }
+        grok.shell.error(errMsg);
+        _package.logger.error(errMsg, undefined, errStack);
+        // throw err; // This error throw is not handled
+      });
+  }
 
-//name: Multiple Sequence Alignment
-//description: Multiple sequence alignment
-//tags: bio
-//input: column sequenceCol {semType: Macromolecule}
-//input: column clustersCol
-//input: object options = undefined { optional: true }
-//output: column result
-export async function alignSequences(
-  sequenceCol: DG.Column<string> | null = null, clustersCol: DG.Column | null = null, options?: any
-): Promise<DG.Column<string>> {
-  return multipleSequenceAlignmentUI({col: sequenceCol, clustersCol: clustersCol, ...options}, _package.seqHelper);
-}
+  @grok.decorators.func({
+    name: 'Multiple Sequence Alignment',
+    description: 'Multiple sequence alignment',
+    tags: ['bio']
+  })
+  static async alignSequences(
+    @grok.decorators.param({type: 'column', options: {semType: 'Macromolecule'}}) sequenceCol: DG.Column<string> | null = null,
+    @grok.decorators.param({type: 'column'}) clustersCol: DG.Column | null = null,
+    @grok.decorators.param({type: 'object', options: {optional: true}}) options?: any
+  ): Promise<DG.Column<string>> {
+    return multipleSequenceAlignmentUI({col: sequenceCol, clustersCol: clustersCol, ...options}, _package.seqHelper);
+  }
 
-//top-menu: Bio | Analyze | Composition
-//name: Composition Analysis
-//description: Visualizes sequence composition on a WebLogo plot
-//meta.icon: files/icons/composition-analysis.svg
-//output: viewer result
-export async function compositionAnalysis(): Promise<void> {
-  // Higher priority for columns with MSA data to show with WebLogo.
-  const tv = grok.shell.tv;
-  const df = tv.dataFrame;
-  //@ts-ignore
-  const colList: DG.Column[] = df.columns.toList().filter((col) => {
-    if (col.semType != DG.SEMTYPE.MACROMOLECULE)
-      return false;
-
-    const _colSh = _package.seqHelper.getSeqHandler(col);
-    // TODO: prevent for cyclic, branched or multiple chains in Helm
-    return true;
-  });
-
-  const handler = async (col: DG.Column) => {
-    if (!checkInputColumnUI(col, 'Composition'))
-      return;
+  @grok.decorators.func({
+    name: 'Composition Analysis',
+    description: 'Visualizes sequence composition on a WebLogo plot',
+    'top-menu': 'Bio | Analyze | Composition',
+    meta: {
+      icon: 'files/icons/composition-analysis.svg'
+    },
+    outputs: [{name: 'result', type: 'viewer'}]
+  })
+  static async compositionAnalysis(): Promise<void> {
+    // Higher priority for columns with MSA data to show with WebLogo.
+    const tv = grok.shell.tv;
+    const df = tv.dataFrame;
+    //@ts-ignore
+    const colList: DG.Column[] = df.columns.toList().filter((col) => {
+      if (col.semType != DG.SEMTYPE.MACROMOLECULE)
+        return false;
+
+      const _colSh = _package.seqHelper.getSeqHandler(col);
+      // TODO: prevent for cyclic, branched or multiple chains in Helm
+      return true;
+    });
 
-    const wlViewer = tv.addViewer('WebLogo', {sequenceColumnName: col.name});
-    grok.shell.tv.dockManager.dock(wlViewer, DG.DOCK_TYPE.DOWN, null, 'Composition analysis', 0.25);
-  };
-
-  let col: DG.Column | null = null;
-  if (colList.length == 0) {
-    grok.shell.error('Current table does not contain sequences');
-    return;
-  } else if (colList.length > 1) {
-    const colListNames: string [] = colList.map((col) => col.name);
-    const selectedCol = colList.find((c) => { return _package.seqHelper.getSeqHandler(c).isMsa(); });
-    const colInput: DG.InputBase = ui.input.choice(
-      'Column', {value: selectedCol ? selectedCol.name : colListNames[0], items: colListNames});
-    ui.dialog({
-      title: 'Composition Analysis',
-      helpUrl: 'https://datagrok.ai/help/datagrok/solutions/domains/bio/#sequence-composition',
-    })
-      .add(ui.div([
-        colInput,
-      ]))
-      .onOK(async () => {
-        const col: DG.Column | null = colList.find((col) => col.name == colInput.value) ?? null;
+    const handler = async (col: DG.Column) => {
+      if (!checkInputColumnUI(col, 'Composition'))
+        return;
+
+      const wlViewer = tv.addViewer('WebLogo', {sequenceColumnName: col.name});
+      grok.shell.tv.dockManager.dock(wlViewer, DG.DOCK_TYPE.DOWN, null, 'Composition analysis', 0.25);
+    };
 
-        if (col)
-          await handler(col);
+    let col: DG.Column | null = null;
+    if (colList.length == 0) {
+      grok.shell.error('Current table does not contain sequences');
+      return;
+    } else if (colList.length > 1) {
+      const colListNames: string [] = colList.map((col) => col.name);
+      const selectedCol = colList.find((c) => { return _package.seqHelper.getSeqHandler(c).isMsa(); });
+      const colInput: DG.InputBase = ui.input.choice(
+        'Column', {value: selectedCol ? selectedCol.name : colListNames[0], items: colListNames});
+      ui.dialog({
+        title: 'Composition Analysis',
+        helpUrl: 'https://datagrok.ai/help/datagrok/solutions/domains/bio/#sequence-composition',
       })
-      .show();
-  } else
-    col = colList[0];
+        .add(ui.div([
+          colInput,
+        ]))
+        .onOK(async () => {
+          const col: DG.Column | null = colList.find((col) => col.name == colInput.value) ?? null;
 
-  if (!col)
-    return;
+          if (col)
+            await handler(col);
+        })
+        .show();
+    } else
+      col = colList[0];
 
-  await handler(col);
-}
+    if (!col)
+      return;
 
-//name: importFasta
-//description: Opens FASTA file
-//tags: file-handler
-//meta.ext: fasta, fna, ffn, faa, frn, fa, fst
-//input: string fileContent
-//output: list tables
-export function importFasta(fileContent: string): DG.DataFrame [] {
-  const ffh = new FastaFileHandler(fileContent);
-  return ffh.importFasta();
-}
+    await handler(col);
+  }
 
-//name: importBam
-//description: Opens Bam file
-//tags: file-handler
-//meta.ext: bam, bai
-//input: string fileContent
-//output: list tables
-export function importBam(fileContent: string): DG.DataFrame [] {
-  console.log(fileContent);
-  return [];
-}
+  // -- Package settings editor --
 
-//top-menu: Bio | Transform | Convert Notation...
-//name: convertDialog
-export function convertDialog() {
-  const col: DG.Column<string> | undefined = getMacromoleculeColumns()[0];
-  convert(col, _package.seqHelper);
-}
 
-//name: Convert Notation...
-//input: column col {semType: Macromolecule}
-//meta.action: Convert Notation...
-export function convertColumnAction(col: DG.Column) {
-  convert(col, _package.seqHelper);
-}
+  @grok.decorators.fileHandler({
+    name: 'importFasta',
+    description: 'Opens FASTA file',
+    ext: 'fasta, fna, ffn, faa, frn, fa, fst',
+  })
+  static importFasta(
+    fileContent: string
+  ): DG.DataFrame[] {
+    const ffh = new FastaFileHandler(fileContent);
+    return ffh.importFasta();
+  }
 
-//name: monomerCellRenderer
-//tags: cellRenderer
-//meta.cellType: Monomer
-//meta.columnTags: quality=Monomer
-//output: grid_cell_renderer result
-export function monomerCellRenderer(): MonomerCellRenderer {
-  return new MonomerCellRenderer();
-}
+  @grok.decorators.fileHandler({
+    name: 'importBam',
+    description: 'Opens Bam file',
+    ext: 'bam, bai',
+  })
+  static importBam(fileContent: string): DG.DataFrame[] {
+    console.log(fileContent);
+    return [];
+  }
 
-//name: testDetectMacromolecule
-//input: string path {choices: ['Demo:Files/', 'System:AppData/']}
-//output: dataframe result
-export async function testDetectMacromolecule(path: string): Promise<DG.DataFrame> {
-  const pi = DG.TaskBarProgressIndicator.create('Test detectMacromolecule...');
+  @grok.decorators.func({
+    name: 'convertDialog',
+    'top-menu': 'Bio | Transform | Convert Notation...'
+  })
+  static convertDialog() {
+    const col: DG.Column<string> | undefined = getMacromoleculeColumns()[0];
+    convert(col, _package.seqHelper);
+  }
 
-  const fileList = await grok.dapi.files.list(path, true, '');
-  //@ts-ignore
-  const fileListToTest = fileList.filter((fi) => fi.fileName.endsWith('.csv'));
+  @grok.decorators.func({
+    name: 'Convert Notation...',
+    meta: {
+      action: 'Convert Notation...'
+    }
+  })
+  static convertColumnAction(
+    @grok.decorators.param({
+      options: {semType: 'Macromolecule'}
+    })
+      col: DG.Column
+  ) {
+    convert(col, _package.seqHelper);
+  }
 
-  let readyCount = 0;
-  const res = [];
+  @grok.decorators.func({
+    name: 'monomerCellRenderer',
+    tags: ['cellRenderer'],
+    meta: {
+      cellType: 'Monomer',
+      columnTags: 'quality=Monomer'
+    },
+    outputs: [{type: 'grid_cell_renderer', name: 'result'}]
+  })
+  static monomerCellRenderer(): MonomerCellRenderer {
+    return new MonomerCellRenderer();
+  }
 
-  for (const fileInfo of fileListToTest) {
-    try {
-      const csv = await grok.dapi.files.readAsText(path + fileInfo.fullPath);
-      const df = DG.DataFrame.fromCsv(csv);
-
-      for (const col of df.columns) {
-        const semType = await grok.functions.call('Bio:detectMacromolecule', {col: col});
-        if (semType === DG.SEMTYPE.MACROMOLECULE) {
-          //console.warn(`file: ${fileInfo.path}, column: ${col.name}, ` +
-          //  `semType: ${semType}, units: ${col.meta.units}`);
-          // console.warn('file: "' + fileInfo.path + '", semType: "' + semType + '", ' +
-          //   'units: "' + col.meta.units + '"');
-
-          res.push({
-            file: fileInfo.path, result: 'detected', column: col.name,
-            message: `units: ${col.meta.units}`,
-          });
+  @grok.decorators.func({
+    name: 'testDetectMacromolecule',
+  })
+  static async testDetectMacromolecule(
+    @grok.decorators.param({
+      options: {choices: ['Demo:Files/', 'System:AppData/']}
+    })
+      path: string
+  ): Promise<DG.DataFrame> {
+    const pi = DG.TaskBarProgressIndicator.create('Test detectMacromolecule...');
+
+    const fileList = await grok.dapi.files.list(path, true, '');
+    //@ts-ignore
+    const fileListToTest = fileList.filter((fi) => fi.fileName.endsWith('.csv'));
+
+    let readyCount = 0;
+    const res = [];
+
+    for (const fileInfo of fileListToTest) {
+      try {
+        const csv = await grok.dapi.files.readAsText(path + fileInfo.fullPath);
+        const df = DG.DataFrame.fromCsv(csv);
+
+        for (const col of df.columns) {
+          const semType = await grok.functions.call('Bio:detectMacromolecule', {col: col});
+          if (semType === DG.SEMTYPE.MACROMOLECULE) {
+            //console.warn(`file: ${fileInfo.path}, column: ${col.name}, ` +
+            //  `semType: ${semType}, units: ${col.meta.units}`);
+            // console.warn('file: '' + fileInfo.path + '', semType: '' + semType + '', ' +
+            //   'units: '' + col.meta.units + ''');
+
+            res.push({
+              file: fileInfo.path, result: 'detected', column: col.name,
+              message: `units: ${col.meta.units}`,
+            });
+          }
         }
+      } catch (err: unknown) {
+        // console.error('file: ' + fileInfo.path + ', error: ' + ex.toString());
+        res.push({
+          file: fileInfo.path, result: 'error', column: null,
+          message: err instanceof Error ? err.message : (err as Object).toString(),
+        });
+      } finally {
+        readyCount += 1;
+        pi.update(100 * readyCount / fileListToTest.length, `Test ${fileInfo.fileName}`);
       }
-    } catch (err: unknown) {
-      // console.error('file: ' + fileInfo.path + ', error: ' + ex.toString());
-      res.push({
-        file: fileInfo.path, result: 'error', column: null,
-        message: err instanceof Error ? err.message : (err as Object).toString(),
-      });
-    } finally {
-      readyCount += 1;
-      pi.update(100 * readyCount / fileListToTest.length, `Test ${fileInfo.fileName}`);
     }
+
+    grok.shell.info('Test Demo:Files for detectMacromolecule finished.');
+    pi.close();
+    const resDf = DG.DataFrame.fromObjects(res)!;
+    resDf.name = `datasets_detectMacromolecule_${path}`;
+    return resDf;
   }
 
-  grok.shell.info('Test Demo:Files for detectMacromolecule finished.');
-  pi.close();
-  const resDf = DG.DataFrame.fromObjects(res)!;
-  resDf.name = `datasets_detectMacromolecule_${path}`;
-  return resDf;
-}
+  @grok.decorators.func({
+    name: 'Split to Monomers',
+    'top-menu': 'Bio | Transform | Split to Monomers...',
+    editor: 'Bio:SplitToMonomersEditor',
+  })
+  static async splitToMonomersTopMenu(
+    table: DG.DataFrame,
+    @grok.decorators.param({
+      options: {semType: 'Macromolecule'}
+    })
+    sequence: DG.Column
+  ): Promise<DG.DataFrame> {
+    return await splitToMonomersUI(table, sequence);
+  }
 
-//top-menu: Bio | Transform | Split to Monomers...
-//name: Split to Monomers
-//input: dataframe table
-//input: column sequence { semType: Macromolecule }
-//output: dataframe result
-//editor: Bio:SplitToMonomersEditor
-export async function splitToMonomersTopMenu(table: DG.DataFrame, sequence: DG.Column): Promise<DG.DataFrame> {
-  return await splitToMonomersUI(table, sequence);
-}
+  @grok.decorators.func({
+    name: 'Bio: getHelmMonomers',
+    outputs: [{name: 'result', type: 'object'}]
+  })
+  static getHelmMonomers(
+    @grok.decorators.param({type: 'column', options: {semType: 'Macromolecule'}})
+      sequence: DG.Column<string>
+  ): string[] {
+    return _package.seqHelper.getSeqMonomers(sequence);
+  }
 
-//name: Bio: getHelmMonomers
-//input: column sequence {semType: Macromolecule}
-//output: object result
-export function getHelmMonomers(sequence: DG.Column<string>): string[] {
-  return _package.seqHelper.getSeqMonomers(sequence);
-}
+  @grok.decorators.func({
+    name: 'Sequence Similarity Search',
+    tags: ['viewer'],
+    meta: {
+      icon: 'files/icons/sequence-similarity-viewer.svg'
+    },
+    outputs: [{name: 'result', type: 'viewer'}]
+  })
+  static similaritySearchViewer(): SequenceSimilarityViewer {
+    return new SequenceSimilarityViewer(_package.seqHelper);
+  }
 
+  @grok.decorators.func({
+    name: 'similaritySearch',
+    description: 'Finds similar sequences',
+    'top-menu': 'Bio | Search | Similarity Search',
+    outputs: [{name: 'result', type: 'viewer'}]
+  })
+  static similaritySearchTopMenu(): void {
+    const view = (grok.shell.v as DG.TableView);
+    const viewer = view.addViewer('Sequence Similarity Search');
+    view.dockManager.dock(viewer, 'down');
+  }
 
-//name: Sequence Similarity Search
-//tags: viewer
-//meta.icon: files/icons/sequence-similarity-viewer.svg
-//output: viewer result
-export function similaritySearchViewer(): SequenceSimilarityViewer {
-  return new SequenceSimilarityViewer(_package.seqHelper);
-}
+  @grok.decorators.func({
+    name: 'Sequence Diversity Search',
+    tags: ['viewer'],
+    meta: {
+      icon: 'files/icons/sequence-diversity-viewer.svg'
+    },
+    outputs: [{name: 'result', type: 'viewer'}]
+  })
+  static diversitySearchViewer(): SequenceDiversityViewer {
+    return new SequenceDiversityViewer(_package.seqHelper);
+  }
 
-//top-menu: Bio | Search | Similarity Search
-//name: similaritySearch
-//description: Finds similar sequences
-//output: viewer result
-export function similaritySearchTopMenu(): void {
-  const view = (grok.shell.v as DG.TableView);
-  const viewer = view.addViewer('Sequence Similarity Search');
-  view.dockManager.dock(viewer, 'down');
-}
+  @grok.decorators.func({
+    name: 'diversitySearch',
+    description: 'Finds the most diverse sequences',
+    'top-menu': 'Bio | Search | Diversity Search',
+    outputs: [{name: 'result', type: 'viewer'}]
+  })
+  static diversitySearchTopMenu() {
+    const view = (grok.shell.v as DG.TableView);
+    const viewer = view.addViewer('Sequence Diversity Search');
+    view.dockManager.dock(viewer, 'down');
+  }
 
-//name: Sequence Diversity Search
-//tags: viewer
-//meta.icon: files/icons/sequence-diversity-viewer.svg
-//output: viewer result
-export function diversitySearchViewer(): SequenceDiversityViewer {
-  return new SequenceDiversityViewer(_package.seqHelper);
-}
+  @grok.decorators.editor({
+    name: 'SearchSubsequenceEditor'
+  })
+  static searchSubsequenceEditor(call: DG.FuncCall) {
+    const columns = getMacromoleculeColumns();
+    if (columns.length === 1)
+      call.func.prepare({macromolecules: columns[0]}).call(true);
+    else
+      new SubstructureSearchDialog(columns, _package.seqHelper);
+  }
 
-//top-menu: Bio | Search | Diversity Search
-//name: diversitySearch
-//description: Finds the most diverse sequences
-//output: viewer result
-export function diversitySearchTopMenu() {
-  const view = (grok.shell.v as DG.TableView);
-  const viewer = view.addViewer('Sequence Diversity Search');
-  view.dockManager.dock(viewer, 'down');
-}
+  @grok.decorators.func({
+    name: 'Subsequence Search',
+    'top-menu': 'Bio | Search | Subsequence Search ...',
+    editor: 'Bio:SearchSubsequenceEditor'
+  })
+  static SubsequenceSearchTopMenu(macromolecules: DG.Column): void {
+    grok.shell.tv.getFiltersGroup({createDefaultFilters: false}).updateOrAdd({
+      type: 'Bio:bioSubstructureFilter',
+      column: macromolecules.name,
+      columnName: macromolecules.name,
+    });
+    grok.shell.tv.grid.scrollToCell(macromolecules, 0);
+  }
 
-//name: SearchSubsequenceEditor
-//tags: editor
-//input: funccall call
-export function searchSubsequenceEditor(call: DG.FuncCall) {
-  const columns = getMacromoleculeColumns();
-  if (columns.length === 1)
-    call.func.prepare({macromolecules: columns[0]}).call(true);
-  else
-    new SubstructureSearchDialog(columns, _package.seqHelper);
-}
+  @grok.decorators.func({
+    name: 'Identity Scoring',
+    description: 'Adds a column with fraction of matching monomers',
+    'top-menu': 'Bio | Calculate | Identity...',
+  })
+  static async sequenceIdentityScoring(
+    @grok.decorators.param({options: {description: 'Table containing Macromolecule column'}})table: DG.DataFrame,
+    @grok.decorators.param({options: {semType: 'Macromolecule', description: 'Sequences to score'}}) macromolecule: DG.Column,
+    @grok.decorators.param({options: {description: 'Sequence,matching column format'}})reference: string
+  ): Promise<DG.Column<number>> {
+    const seqHelper = _package.seqHelper;
+    const scores = calculateScoresWithEmptyValues(table, macromolecule, reference, SCORE.IDENTITY, seqHelper);
+    return scores;
+  }
 
-//top-menu: Bio | Search | Subsequence Search ...
-//name: Subsequence Search
-//input: column macromolecules
-//editor: Bio:SearchSubsequenceEditor
-export function SubsequenceSearchTopMenu(macromolecules: DG.Column): void {
-  grok.shell.tv.getFiltersGroup({createDefaultFilters: false}).updateOrAdd({
-    type: 'Bio:bioSubstructureFilter',
-    column: macromolecules.name,
-    columnName: macromolecules.name,
-  });
-  grok.shell.tv.grid.scrollToCell(macromolecules, 0);
-}
+  @grok.decorators.func({
+    name: 'Similarity Scoring',
+    description: 'Adds a column with similarity scores, calculated as sum of monomer fingerprint similarities',
+    'top-menu': 'Bio | Calculate | Similarity...',
+  })
+  static async sequenceSimilarityScoring(
+    @grok.decorators.param({options: {description: 'Table containing Macromolecule column'}})table: DG.DataFrame,
+    @grok.decorators.param({options: {semType: 'Macromolecule', description: 'Sequences to score'}}) macromolecule: DG.Column,
+    @grok.decorators.param({options: {description: 'Sequence,matching column format'}})reference: string
+  ): Promise<DG.Column<number>> {
+    const seqHelper = _package.seqHelper;
+    const scores = calculateScoresWithEmptyValues(table, macromolecule, reference, SCORE.SIMILARITY, seqHelper);
+    return scores;
+  }
 
-//top-menu: Bio | Calculate | Identity...
-//name: Identity Scoring
-//description: Adds a column with fraction of matching monomers
-//input: dataframe table [Table containing Macromolecule column]
-//input: column macromolecule {semType: Macromolecule} [Sequences to score]
-//input: string reference [Sequence, matching column format]
-//output: column scores
-export async function sequenceIdentityScoring(
-  table: DG.DataFrame, macromolecule: DG.Column, reference: string
-): Promise<DG.Column<number>> {
-  const seqHelper = _package.seqHelper;
-  const scores = calculateScoresWithEmptyValues(table, macromolecule, reference, SCORE.IDENTITY, seqHelper);
-  return scores;
-}
+  @grok.decorators.func({
+    name: 'Manage Monomer Libraries',
+    description: 'Manage HELM monomer libraries'
+  })
+  static async manageMonomerLibraries(): Promise<void> {
+    showManageLibrariesDialog();
+  }
 
-//top-menu: Bio | Calculate | Similarity...
-//name: Similarity Scoring
-//description: Adds a column with similarity scores, calculated as sum of monomer fingerprint similarities
-//input: dataframe table [Table containing Macromolecule column]
-//input: column macromolecule {semType: Macromolecule} [Sequences to score]
-//input: string reference [Sequence, matching column format]
-//output: column scores
-export async function sequenceSimilarityScoring(
-  table: DG.DataFrame, macromolecule: DG.Column, reference: string
-): Promise<DG.Column<number>> {
-  const seqHelper = _package.seqHelper;
-  const scores = calculateScoresWithEmptyValues(table, macromolecule, reference, SCORE.SIMILARITY, seqHelper);
-  return scores;
-}
+  @grok.decorators.func({
+    name: 'Manage Monomer Libraries View',
+    'top-menu': 'Bio | Manage | Monomer Libraries'
+  })
+  static async manageLibrariesView(): Promise<void> {
+    await showManageLibrariesView();
+  }
 
+  @grok.decorators.func({
+    name: 'manageMonomersView',
+    description: 'Edit and create monomers',
+    'top-menu': 'Bio | Manage | Monomers'
+  })
+  static async manageMonomersView() {
+    const monomerManager = await MonomerManager.getInstance();
+    await monomerManager.getViewRoot();
+  }
 
-//name: Manage Monomer Libraries
-//description: Manage HELM monomer libraries
-export async function manageMonomerLibraries(): Promise<void> {
-  showManageLibrariesDialog();
-}
+  @grok.decorators.app({
+    name: 'Manage Monomer Libraries',
+    browsePath: 'Peptides',
+    icon: 'files/icons/monomers.png',
+  })
+  static async manageMonomerLibrariesView(): Promise<DG.View> {
+    return await showManageLibrariesView(false);
+  }
 
-//top-menu: Bio | Manage | Monomer Libraries
-//name: Manage Monomer Libraries View
-export async function manageLibrariesView(): Promise<void> {
-  await showManageLibrariesView();
-}
+  @grok.decorators.func({name: 'Monomer Manager Tree Browser'})
+  static async manageMonomerLibrariesViewTreeBrowser(treeNode: DG.TreeViewGroup, browsePanel: DG.BrowsePanel) {
+    const libraries = (await (await MonomerLibManager.getInstance()).getFileManager()).getValidLibraryPaths();
+    libraries.forEach((libName) => {
+      const nodeName = libName.endsWith('.json') ? libName.substring(0, libName.length - 5) : libName;
+      const libNode = treeNode.item(nodeName);
+      // eslint-disable-next-line rxjs/no-ignored-subscription, rxjs/no-async-subscribe
+      libNode.onSelected.subscribe(async () => {
+        const monomerManager = await MonomerManager.getInstance();
+        await monomerManager.getViewRoot(libName, true);
+        monomerManager.resetCurrentRowFollowing();
+      });
+    });
+  }
 
-//top-menu: Bio | Manage | Monomers
-//name: manageMonomersView
-//description: Edit and create monomers
-export async function manageMonomersView() {
-  const monomerManager = await MonomerManager.getInstance();
-  await monomerManager.getViewRoot();
-}
+  @grok.decorators.fileExporter({description: 'As FASTA...'})
+  static saveAsFasta() {
+    saveAsFastaUI();
+  }
 
-//name: Manage Monomer Libraries
-//tags: app
-//meta.browsePath: Peptides
-//meta.icon: files/icons/monomers.png
-//output: view v
-export async function manageMonomerLibrariesView(): Promise<DG.View> {
-  return await showManageLibrariesView(false);
-}
+  @grok.decorators.func({
+    name: 'Bio Substructure Filter',
+    description: 'Substructure filter for macromolecules',
+    tags: ['filter'],
+    meta: {semType: 'Macromolecule'},
+    outputs: [{type: 'filter', name: 'result'}],
+  })
+  static bioSubstructureFilter(): BioSubstructureFilter {
+    return new BioSubstructureFilter(_package.seqHelper, _package.logger);
+  }
 
-//name: Monomer Manager Tree Browser
-//input: dynamic treeNode
-//input: dynamic browsePanel
-export async function manageMonomerLibrariesViewTreeBrowser(treeNode: DG.TreeViewGroup, browsePanel: DG.BrowsePanel) {
-  const libraries = (await (await MonomerLibManager.getInstance()).getFileManager()).getValidLibraryPaths();
-  libraries.forEach((libName) => {
-    const nodeName = libName.endsWith('.json') ? libName.substring(0, libName.length - 5) : libName;
-    const libNode = treeNode.item(nodeName);
-    // eslint-disable-next-line rxjs/no-ignored-subscription, rxjs/no-async-subscribe
-    libNode.onSelected.subscribe(async () => {
-      const monomerManager = await MonomerManager.getInstance();
-      await monomerManager.getViewRoot(libName, true);
-      monomerManager.resetCurrentRowFollowing();
-    });
-  });
-}
+  @grok.decorators.func({
+    name: 'Bio Substructure Filter Test',
+    description: 'Substructure filter for Helm package tests',
+    outputs: [{name: 'result', type: 'object'}]
+  })
+  static bioSubstructureFilterTest(): BioSubstructureFilter {
+    return new BioSubstructureFilter(_package.seqHelper, _package.logger);
+  }
 
-//name: saveAsFasta
-//description: As FASTA...
-//tags: fileExporter
-export function saveAsFasta() {
-  saveAsFastaUI();
-}
+  // -- Test apps --
 
-//name: Bio Substructure Filter
-//description: Substructure filter for macromolecules
-//tags: filter
-//output: filter result
-//meta.semType: Macromolecule
-export function bioSubstructureFilter(): BioSubstructureFilter {
-  return new BioSubstructureFilter(_package.seqHelper, _package.logger);
-}
+  @grok.decorators.func()
+  static async webLogoLargeApp(): Promise<void> {
+    const pi = DG.TaskBarProgressIndicator.create('WebLogo');
+    try {
+      const urlParams = new URLSearchParams(window.location.search);
+      const app = new WebLogoApp(urlParams, 'webLogoLargeApp');
+      const df: DG.DataFrame = await _package.files.readCsv('data/sample_PT_100000x5.csv');
+      await grok.data.detectSemanticTypes(df);
+      await app.init(df);
+    } finally {
+      pi.close();
+    }
+  }
 
-//name: Bio Substructure Filter Test
-//description: Substructure filter for Helm package tests
-//output: object result
-export function bioSubstructureFilterTest(): BioSubstructureFilter {
-  return new BioSubstructureFilter(_package.seqHelper, _package.logger);
-}
+  @grok.decorators.func()
+  static async webLogoAggApp(): Promise<void> {
+    const pi = DG.TaskBarProgressIndicator.create('WebLogo ...');
+    try {
+      const urlParams = new URLSearchParams(window.location.search);
+      const app = new WebLogoApp(urlParams, 'webLogoAggApp');
+      const df: DG.DataFrame = await _package.files.readCsv('samples/FASTA_PT_activity.csv');
+      await grok.data.detectSemanticTypes(df);
+      await app.init(df);
+    } finally {
+      pi.close();
+    }
+  }
 
-// -- Test apps --
-
-//name: webLogoLargeApp
-export async function webLogoLargeApp(): Promise<void> {
-  const pi = DG.TaskBarProgressIndicator.create('WebLogo');
-  try {
-    const urlParams = new URLSearchParams(window.location.search);
-    const app = new WebLogoApp(urlParams, 'webLogoLargeApp');
-    const df: DG.DataFrame = await _package.files.readCsv('data/sample_PT_100000x5.csv');
-    await grok.data.detectSemanticTypes(df);
-    await app.init(df);
-  } finally {
-    pi.close();
+  @grok.decorators.func()
+  static async getRegionApp(): Promise<void> {
+    const pi = DG.TaskBarProgressIndicator.create('getRegion ...');
+    try {
+      const urlParams = new URLSearchParams(window.location.search);
+      const app = new GetRegionApp(urlParams, 'getRegionApp');
+      await app.init();
+    } finally {
+      pi.close();
+    }
   }
-}
 
-//name: webLogoAggApp
-export async function webLogoAggApp(): Promise<void> {
-  const pi = DG.TaskBarProgressIndicator.create('WebLogo ...');
-  try {
-    const urlParams = new URLSearchParams(window.location.search);
-    const app = new WebLogoApp(urlParams, 'webLogoAggApp');
-    const df: DG.DataFrame = await _package.files.readCsv('samples/FASTA_PT_activity.csv');
-    await grok.data.detectSemanticTypes(df);
-    await app.init(df);
-  } finally {
-    pi.close();
+  @grok.decorators.func()
+  static async getRegionHelmApp(): Promise<void> {
+    const pi = DG.TaskBarProgressIndicator.create('getRegion ...');
+    try {
+      const urlParams = new URLSearchParams(window.location.search);
+      const df = await _package.files.readCsv('samples/HELM_empty_vals.csv');
+      const app = new GetRegionApp(urlParams, 'getRegionHelmApp');
+      await app.init({df: df, colName: 'HELM'});
+    } finally {
+      pi.close();
+    }
   }
-}
 
-//name: getRegionApp
-export async function getRegionApp(): Promise<void> {
-  const pi = DG.TaskBarProgressIndicator.create('getRegion ...');
-  try {
-    const urlParams = new URLSearchParams(window.location.search);
-    const app = new GetRegionApp(urlParams, 'getRegionApp');
-    await app.init();
-  } finally {
-    pi.close();
+  // -- Tests long seq --
+
+  //name: longSeqTableSeparator
+  @grok.decorators.func()
+  static longSeqTableSeparator(): void {
+    const df = DG.DataFrame.fromColumns(generateLongSequence());
+    grok.shell.addTableView(df);
   }
-}
 
-//name: getRegionHelmApp
-export async function getRegionHelmApp(): Promise<void> {
-  const pi = DG.TaskBarProgressIndicator.create('getRegion ...');
-  try {
-    const urlParams = new URLSearchParams(window.location.search);
-    const df = await _package.files.readCsv('samples/HELM_empty_vals.csv');
-    const app = new GetRegionApp(urlParams, 'getRegionHelmApp');
-    await app.init({df: df, colName: 'HELM'});
-  } finally {
-    pi.close();
+  //name: longSeqTableFasta
+  @grok.decorators.func()
+  static longSeqTableFasta(): void {
+    const df = DG.DataFrame.fromColumns([generateLongSequence2(_package.seqHelper, NOTATION.FASTA)]);
+    grok.shell.addTableView(df);
   }
-}
 
-// -- Tests long seq --
+  //name: longSeqTableHelm
+  @grok.decorators.func()
+  static longSeqTableHelm(): void {
+    const df = DG.DataFrame.fromColumns([generateLongSequence2(_package.seqHelper, NOTATION.HELM)]);
+    grok.shell.addTableView(df);
+  }
 
-//name: longSeqTableSeparator
-export function longSeqTableSeparator(): void {
-  const df = DG.DataFrame.fromColumns(generateLongSequence());
-  grok.shell.addTableView(df);
-}
+  // -- Handle context menu --
 
-//name: longSeqTableFasta
-export function longSeqTableFasta(): void {
-  const df = DG.DataFrame.fromColumns([generateLongSequence2(_package.seqHelper, NOTATION.FASTA)]);
-  grok.shell.addTableView(df);
-}
+  @grok.decorators.func()
+  static addCopyMenu(
+    @grok.decorators.param({type: 'object'})cell: DG.Cell,
+    @grok.decorators.param({type: 'object'}) menu: DG.Menu): void {
+    addCopyMenuUI(cell, menu, _package.seqHelper);
+  }
 
-//name: longSeqTableHelm
-export function longSeqTableHelm(): void {
-  const df = DG.DataFrame.fromColumns([generateLongSequence2(_package.seqHelper, NOTATION.HELM)]);
-  grok.shell.addTableView(df);
-}
+  // -- Demo --
+  // demoBio01
+
+  @grok.decorators.demo({
+    description: 'Sequence similarity tracking and evaluation dataset diversity',
+    demoPath: 'Bioinformatics | Similarity, Diversity',
+    path: '/apps/Tutorials/Demo/Bioinformatics/Similarity,%20Diversity',
+    demoSkip: 'GROK-14320'
+  })
+  static async demoBioSimilarityDiversity(): Promise<void> {
+    await demoBioSimDiv();
+  }
 
-// -- Handle context menu --
+  @grok.decorators.demo({
+    description: 'Exploring sequence space of Macromolecules, comparison with hierarchical clustering results',
+    demoPath: 'Bioinformatics | Sequence Space',
+    path: '/apps/Tutorials/Demo/Bioinformatics/Sequence%20Space',
+    demoSkip: 'GROK-14320'
+  })
+  static async demoBioSequenceSpace(): Promise<void> {
+    await demoSeqSpace();
+  }
 
-//name: addCopyMenu
-//input: object cell
-//input: object menu
-export function addCopyMenu(cell: DG.Cell, menu: DG.Menu): void {
-  addCopyMenuUI(cell, menu, _package.seqHelper);
-}
+  @grok.decorators.demo({
+    description: 'Activity Cliffs analysis on Macromolecules data',
+    demoPath: 'Bioinformatics | Activity Cliffs',
+    path: '/apps/Tutorials/Demo/Bioinformatics/Activity%20Cliffs',
+    demoSkip: 'GROK-14320'
+  })
+  static async demoBioActivityCliffs(): Promise<void> {
+    await demoActivityCliffsCyclic();
+  }
 
-// -- Demo --
+  @grok.decorators.demo({
+    description: 'Atomic level structure of Macromolecules',
+    demoPath: 'Bioinformatics | Atomic Level',
+    path: '/apps/Tutorials/Demo/Bioinformatics/Atomic%20Level',
+    demoSkip: 'GROK-14320'
+  })
+  static async demoBioAtomicLevel(): Promise<void> {
+    await demoToAtomicLevel();
+  }
 
-// demoBio01
-//name: demoBioSimilarityDiversity
-//meta.demoPath: Bioinformatics | Similarity, Diversity
-//description: Sequence similarity tracking and evaluation dataset diversity
-//meta.path: /apps/Tutorials/Demo/Bioinformatics/Similarity,%20Diversity
-//meta.demoSkip: GROK-14320
-export async function demoBioSimilarityDiversity(): Promise<void> {
-  await demoBioSimDiv();
-}
+  @grok.decorators.func({name: 'SDF to JSON Library'})
+  static async sdfToJsonLib(table: DG.DataFrame) {
+    const _jsonMonomerLibrary = createJsonMonomerLibFromSdf(table);
+    const jsonMonomerLibrary = JSON.stringify(_jsonMonomerLibrary);
+    DG.Utils.download(`${table.name}.json`, jsonMonomerLibrary);
+  }
 
-// demoBio01a
-//name:demoBioSequenceSpace
-//meta.demoPath: Bioinformatics | Sequence Space
-//description: Exploring sequence space of Macromolecules, comparison with hierarchical clustering results
-//meta.path: /apps/Tutorials/Demo/Bioinformatics/Sequence%20Space
-//meta.demoSkip: GROK-14320
-export async function demoBioSequenceSpace(): Promise<void> {
-  await demoSeqSpace();
-}
+  // -- Utils --
+
+  @grok.decorators.func({
+    friendlyName: 'seq2atomic',
+    description: 'Converts a `Macromolecule` sequence to its atomic level `Molecule` representation',
+    outputs: [{name: 'molfile', type: 'string', options: {semType: 'Molecule'}}]
+  })
+  static async seq2atomic(
+    @grok.decorators.param({options: {semType: 'Macromolecule'}})
+      seq: string,
+      nonlinear: boolean
+  ): Promise<string | undefined> {
+    if (!(seq.trim())) return '';
+    try {
+      const seqCol = DG.Column.fromList(DG.COLUMN_TYPE.STRING, `helm`, [seq]);
+      const df = DG.DataFrame.fromColumns([seqCol]);
+      const semType = await grok.functions.call('Bio:detectMacromolecule', {col: seqCol});
+      if (semType) seqCol.semType = semType;
+
+      const monomerLib = (await PackageFunctions.getMonomerLibHelper()).getMonomerLib();
+      const seqHelper = _package.seqHelper;
+      const rdKitModule = await getRdKitModule();
+      const res = (await sequenceToMolfile(df, seqCol, nonlinear, false, monomerLib, seqHelper, rdKitModule))?.molCol?.get(0);
+      return res ?? undefined;
+    } catch (err: any) {
+      const [errMsg, errStack] = errInfo(err);
+      _package.logger.error(errMsg, undefined, errStack);
+      throw err;
+    }
+  }
 
-// demoBio01b
-//name: demoBioActivityCliffs
-//meta.demoPath: Bioinformatics | Activity Cliffs
-//description: Activity Cliffs analysis on Macromolecules data
-//meta.path: /apps/Tutorials/Demo/Bioinformatics/Activity%20Cliffs
-//meta.demoSkip: GROK-14320
-export async function demoBioActivityCliffs(): Promise<void> {
-  await demoActivityCliffsCyclic();
-}
+  // //description: Gets similarity to a reference sequence
+  // //input: string seq { semType: Macromolecule }
+  // //input: string ref { semType: Macromolecule }
+  // //output: double result
+  // export async function seqSimilarity(seq: string, ref: string): Promise<number> {
+  //   // if (!(seq.trim())) return null;
+  //   try {
+  //     const seqCol = DG.Column.fromList(DG.COLUMN_TYPE.STRING, `seq`, [seq]);
+  //     const df = DG.DataFrame.fromColumns([seqCol]);
+  //     const semType = await grok.functions.call('Bio:detectMacromolecule', {col: seqCol});
+  //     if (semType) seqCol.semType = semType;
+  //
+  //     const resCol = await calculateScoresWithEmptyValues(df, seqCol, ref, SCORE.SIMILARITY);
+  //     return resCol.get(0)!;
+  //   } catch (err: any) {
+  //     const [errMsg, errStack] = errInfo(err);
+  //     _package.logger.error(errMsg, undefined, errStack);
+  //     throw err;
+  //   }
+  // }
+
+  @grok.decorators.func({
+    name: 'seqIdentity',
+    friendlyName: 'seqIdentity',
+    description: 'Gets identity to a reference sequence',
+  })
+  static async seqIdentity(
+    @grok.decorators.param({options: {semType: 'Macromolecule'}})
+      seq: string,
+    @grok.decorators.param({options: {semType: 'Macromolecule'}})
+      ref: string
+  ): Promise<number | null> {
+    if (!(seq.trim())) return null;
+    try {
+      const seqCol = DG.Column.fromList(DG.COLUMN_TYPE.STRING, `seq`, [seq]);
+      const df = DG.DataFrame.fromColumns([seqCol]);
+      const semType = await grok.functions.call('Bio:detectMacromolecule', {col: seqCol});
+      if (!semType) throw new Error('Macromolecule required');
+
+      const resCol = await calculateScoresWithEmptyValues(df, seqCol, ref, SCORE.IDENTITY, _package.seqHelper);
+      return resCol.get(0);
+    } catch (err: any) {
+      const [errMsg, errStack] = errInfo(err);
+      _package.logger.error(errMsg, undefined, errStack);
+      throw err;
+    }
+  }
 
-// demoBio03
-//name: demoBioAtomicLevel
-//meta.demoPath: Bioinformatics | Atomic Level
-//description: Atomic level structure of Macromolecules
-//meta.path: /apps/Tutorials/Demo/Bioinformatics/Atomic%20Level
-//meta.demoSkip: GROK-14320
-export async function demoBioAtomicLevel(): Promise<void> {
-  await demoToAtomicLevel();
-}
+  @grok.decorators.func()
+  static async detectMacromoleculeProbe(
+    file: DG.FileInfo,
+    colName: string = '',
+    @grok.decorators.param({options: {initialValue: '100'}})
+    probeCount: number = 100
+  ): Promise<void> {
+    const csv: string = await file.readAsString();
+    await detectMacromoleculeProbeDo(csv, colName, probeCount);
+  }
 
-//name: SDF to JSON Library
-//input: dataframe table
-export async function sdfToJsonLib(table: DG.DataFrame) {
-  const _jsonMonomerLibrary = createJsonMonomerLibFromSdf(table);
-  const jsonMonomerLibrary = JSON.stringify(_jsonMonomerLibrary);
-  DG.Utils.download(`${table.name}.json`, jsonMonomerLibrary);
-}
+  @grok.decorators.func({outputs: [{type: 'object', name: 'result'}]})
+  static async getSeqHelper(): Promise<ISeqHelper> {
+    await PackageFunctions.initBio();
+    return _package.seqHelper;
+  }
 
-// -- Utils --
-
-//name: seq2atomic
-//friendlyName: seq2atomic
-//description: Converts a `Macromolecule` sequence to its atomic level `Molecule` representation
-//input: string seq { semType: Macromolecule }
-//input: bool nonlinear
-//output: string molfile { semType: Molecule }
-export async function seq2atomic(seq: string, nonlinear: boolean): Promise<string | undefined> {
-  if (!(seq.trim())) return '';
-  try {
-    const seqCol = DG.Column.fromList(DG.COLUMN_TYPE.STRING, `helm`, [seq]);
-    const df = DG.DataFrame.fromColumns([seqCol]);
-    const semType = await grok.functions.call('Bio:detectMacromolecule', {col: seqCol});
-    if (semType) seqCol.semType = semType;
-
-    const monomerLib = (await getMonomerLibHelper()).getMonomerLib();
-    const seqHelper = _package.seqHelper;
-    const rdKitModule = await getRdKitModule();
-    const res = (await sequenceToMolfile(df, seqCol, nonlinear, false, monomerLib, seqHelper, rdKitModule))?.molCol?.get(0);
-    return res ?? undefined;
-  } catch (err: any) {
-    const [errMsg, errStack] = errInfo(err);
-    _package.logger.error(errMsg, undefined, errStack);
-    throw err;
+  @grok.decorators.func()
+  static async getMolFromHelm(
+    df: DG.DataFrame,
+    @grok.decorators.param({type: 'column'})helmCol: DG.Column<string>,
+    @grok.decorators.param({options: {initialValue: 'true'}})
+    chiralityEngine: boolean = true
+  ): Promise<DG.Column<string>> {
+    return getMolColumnFromHelm(df, helmCol, chiralityEngine, _package.monomerLib);
   }
 }
 
-// //description: Gets similarity to a reference sequence
-// //input: string seq { semType: Macromolecule }
-// //input: string ref { semType: Macromolecule }
-// //output: double result
-// export async function seqSimilarity(seq: string, ref: string): Promise<number> {
-//   // if (!(seq.trim())) return null;
-//   try {
-//     const seqCol = DG.Column.fromList(DG.COLUMN_TYPE.STRING, `seq`, [seq]);
-//     const df = DG.DataFrame.fromColumns([seqCol]);
-//     const semType = await grok.functions.call('Bio:detectMacromolecule', {col: seqCol});
-//     if (semType) seqCol.semType = semType;
-//
-//     const resCol = await calculateScoresWithEmptyValues(df, seqCol, ref, SCORE.SIMILARITY);
-//     return resCol.get(0)!;
-//   } catch (err: any) {
-//     const [errMsg, errStack] = errInfo(err);
-//     _package.logger.error(errMsg, undefined, errStack);
-//     throw err;
-//   }
-// }
 
-//name: seqIdentity
-//friendlyName: seqIdentity
-//description: Gets identity to a reference sequence
-//input: string seq { semType: Macromolecule }
-//input: string ref { semType: Macromolecule }
-//output: double result
-export async function seqIdentity(seq: string, ref: string): Promise<number | null> {
-  if (!(seq.trim())) return null;
-  try {
-    const seqCol = DG.Column.fromList(DG.COLUMN_TYPE.STRING, `seq`, [seq]);
-    const df = DG.DataFrame.fromColumns([seqCol]);
-    const semType = await grok.functions.call('Bio:detectMacromolecule', {col: seqCol});
-    if (!semType) throw new Error('Macromolecule required');
-
-    const resCol = await calculateScoresWithEmptyValues(df, seqCol, ref, SCORE.IDENTITY, _package.seqHelper);
-    return resCol.get(0);
-  } catch (err: any) {
-    const [errMsg, errStack] = errInfo(err);
-    _package.logger.error(errMsg, undefined, errStack);
-    throw err;
+//export let hydrophobPalette: SeqPaletteCustom | null = null;
+
+export class SeqPaletteCustom implements SeqPalette {
+  private readonly _palette: { [m: string]: string };
+
+  constructor(palette: { [m: string]: string }) {
+    this._palette = palette;
+  }
+
+  public get(m: string): string {
+    return this._palette[m];
   }
 }
 
+async function initBioInt() {
+  const logPrefix = 'Bio: _package.initBio()';
+  _package.logger.debug(`${logPrefix}, start`);
+  const t1: number = window.performance.now();
+  // very important that loading should happen in correct order!
+  // first make sure chem and rdkit module are loaded
+  const rdKitModule = await getRdKitModule();
+  // then load package settings
+  const pkgProps = await _package.getProperties();
+  const bioPkgProps = new BioPackageProperties(pkgProps);
+  _package.properties = bioPkgProps;
+  // then load monomer lib
+  const libHelper = await MonomerLibManager.getInstance();
+  // Fix user lib settings for explicit stuck from a terminated test
+  const libSettings = await getUserLibSettings();
+  if (libSettings.explicit) {
+    libSettings.explicit = [];
+    await setUserLibSettings(libSettings);
+  }
+  await libHelper.awaitLoaded(Infinity);
+  if (!libHelper.initialLoadCompleted)
+    await libHelper.loadMonomerLib();
+  // Do not wait for monomers and sets loaded
+  libHelper.loadMonomerSets();
+  const monomerLib = libHelper.getMonomerLib();
+  const monomerSets = libHelper.getMonomerSets();
+  // finally log
+  const t2: number = window.performance.now();
+  _package.logger.debug(`${logPrefix}, loading ET: ${t2 - t1} ms`);
+
+  // const monomers: string[] = [];
+  // const logPs: number[] = [];
 
-//name: detectMacromoleculeProbe
-//input: file file
-//input: string colName = ''
-//input: int probeCount = 100
-export async function detectMacromoleculeProbe(file: DG.FileInfo, colName: string, probeCount: number): Promise<void> {
-  const csv: string = await file.readAsString();
-  await detectMacromoleculeProbeDo(csv, colName, probeCount);
-}
+  const seqHelper = new SeqHelper(libHelper, rdKitModule);
+  _package.completeInit(seqHelper, monomerLib, monomerSets, rdKitModule);
 
-//name: getSeqHelper
-//output: object result
-export async function getSeqHelper(): Promise<ISeqHelper> {
-  await initBio();
-  return _package.seqHelper;
-}
+  // NB! do not delete the code below. not used now but in future we might use hydrophobicity palette
+  // const series = monomerLib!.getMonomerMolsByPolymerType('PEPTIDE')!;
+  // Object.keys(series).forEach((symbol) => {
+  //   monomers.push(symbol);
+  //   const block = series[symbol].replaceAll('#R', 'O ');
+  //   const mol = rdKitModule.get_mol(block);
+  //   const logP = JSON.parse(mol.get_descriptors()).CrippenClogP;
+  //   logPs.push(logP);
+  //   mol?.delete();
+  // });
+
+  // const sum = logPs.reduce((a, b) => a + b, 0);
+  // const avg = (sum / logPs.length) || 0;
 
-//name: getMolFromHelm
-//input: dataframe df
-//input: column helmCol
-//input: bool chiralityEngine = true
-//output: column result
-export function getMolFromHelm(
-  df: DG.DataFrame, helmCol: DG.Column<string>, chiralityEngine: boolean
-): Promise<DG.Column<string>> {
-  return getMolColumnFromHelm(df, helmCol, chiralityEngine, _package.monomerLib);
+  // const palette: { [monomer: string]: string } = {};
+  // for (let i = 0; i < monomers.length; i++)
+  //   palette[monomers[i]] = logPs[i] < avg ? '#4682B4' : '#DC143C';
+
+  // hydrophobPalette = new SeqPaletteCustom(palette);
+
+  _package.logger.debug(`${logPrefix}, end`);
+  handleSequenceHeaderRendering();
 }
 
+// -- Package settings editor --
+
+// //name: packageSettingsEditor
+// //description: The database connection
+// //tags: packageSettingsEditor
+// //input: object propList
+// //output: widget result
+// export function packageSettingsEditor(propList: DG.Property[]): DG.Widget {
+//   const widget = new PackageSettingsEditorWidget(propList);
+//   widget.init().then(); // Ignore promise returned
+//   return widget as DG.Widget;
+// }
+
 //name: test1
 //output: object result
 export function test1(): any {