@datagrok/helm 3.0.0 → 3.0.2

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Helm changelog
 
+## v.next
+
+* Moved the Helm Playwright E2E suite into the package (playwright/); helpers from @datagrok-libraries/test/src/playwright
+
+## 3.0.1 (2026-06-20)
+
+### Features
+
+* Migration to Datagrok Helm Web Editor
+* Support for new Helm Service, editor, parsing and rendering
+* Helm editor panes including molecular structure, composition and conversion
+* Monomer highlighting in HELM grid cells: cells respond to macromolecule highlight events, drawing a translucent overlay around the highlighted monomers
+* Improved RNA splitting: support for complex RNA and complex triplets, and more inclusive matching
+
+### Bug Fixes
+
+* Fixed async renderer invalidation
+
 ## 2.13.4 (2026-03-31)
 
 ### Features

package/CLAUDE.md

@@ -2,111 +2,102 @@
 
 ## Overview
 
-**Helm** (`@datagrok/helm`) is a Datagrok plugin providing full support for **HELM notation** (Hierarchical Editing Language for Macromolecules) — importing, detecting, rendering, editing, and conversion. It wraps the Pistoia HELM Web Editor and Scilligence JSDraw2 libraries, integrating them into the Datagrok platform with custom cell renderers, input widgets, and monomer library management.
+**Helm** (`@datagrok/helm`) is a Datagrok plugin providing full support for **HELM notation** (Hierarchical Editing Language for Macromolecules) — importing, detecting, rendering, editing, and conversion. It is built on the **standalone Datagrok HELM Web Editor** (`@datagrok-libraries/hwe`), integrating it into the platform with a custom grid cell renderer, an input widget, a property panel, and HELM↔other-notation conversion.
+
+The legacy forked Pistoia HELM Web Editor + Scilligence JSDraw2 + Dojo toolkit stack has been **fully removed** (HWE migration, package v3.0). There are no more bundled `vendor/dojo-1.10.10/` or `helm/JSDraw/` sources and no `org.helm.webeditor` / `JSDraw2` / `scil` / `dojo` globals.
 
 Category: **Bioinformatics**.
 
+## The hwe library — `@datagrok-libraries/hwe`
+
+Every editor / parse / render / calculation path routes through the self-contained `@datagrok-libraries/hwe` package. It is an **external npm dependency** (not under this repo's `libraries/`) and injects no global scripts. The package consumes from it:
+
+| Export | Purpose |
+|---|---|
+| `HelmService` | Parses HELM, renders **synchronously** to a canvas (`renderToCanvas`), and computes molfiles / molecular properties. Reads monomers through `bridgeMonomerLib(...)` |
+| `HelmHelperAdapter` | Wraps a `HelmService` to expose Datagrok's `IHelmHelper` plus a legacy-compatible Pistoia `App` shape (`createWebEditorApp`), so existing dialog consumers swap in unchanged |
+| `bridgeMonomerLib(lib)` | Adapts Bio's `IMonomerLib` so the editor resolves exactly the same monomers as the rest of the platform |
+| `buildHelmMolView(mol)` | Builds a legacy-shaped (`atoms[].p` in model space) laid-out molecule used for hover hit-testing and the highlight overlay |
+| `PolymerTypes`; types `IMonomerLibBaseLike`, `MonomersFuncsLike`, `CanvasBounds` | Constants / type shims for the adapter and renderer |
+| `@datagrok-libraries/hwe/styles.css` | The editor's `.hw-*` stylesheet. **Must be imported** (hwe ships CSS as a bundler import only — no runtime injection) or the editor renders unstyled. Imported once in `src/package.ts` |
+
 ## Architecture
 
 ### Entry Point — `src/package.ts`
 
-`PackageFunctions` class registers all platform-visible functions via `@grok.decorators`:
-- `initHelm` — `@init`: loads RdKit, SeqHelper, MonomerLibHelper, initializes HELMWebEditor, creates `HelmHelper` singleton, patches Pistoia monomer system
-- `getHelmService` — `@func`: returns `HelmServiceBase` singleton for off-screen HELM rendering
+Imports `@datagrok-libraries/hwe/styles.css`. `PackageFunctions` class registers all platform-visible functions via `@grok.decorators`:
+- `initHelm` — `@init`: loads the RDKit module, `SeqHelper`, `MonomerLibHelper`; creates the `HelmHelper` singleton (passing `seqHelper`, logger, `rdKitModule`); then `_package.completeInit(helmHelper, libHelper)`. No Dojo/editor bootstrapping or Pistoia monomer patching.
 - `helmCellRenderer` — `@func` (role: `cellRenderer`): returns `HelmGridCellRenderer` for columns with `quality=Macromolecule, units=helm`
-- `editMoleculeCell` — `@func` (role: `cellEditor`): opens full-screen HELM Web Editor dialog for cell editing
-- `openEditor` (`Edit Helm...`) — `@func` (action): context-menu editor for Macromolecule columns, converts non-HELM notations to HELM before editing
-- `propertiesWidget` (`Properties`) — `@panel`: shows molecular formula, weight, extinction coefficient for Macromolecule values
-- `getMolfiles` — `@func`: converts a Macromolecule column to molfile strings
-- `helmInput` — `@func` (role: `valueEditor`): creates `HelmInput` widget for Macromolecule/HELM semtype
-- `getHelmHelper` — `@func`: returns `IHelmHelper` singleton
-- `measureCellRenderer` — `@func`: performance measurement utility for cell rendering
-- `highlightMonomers` — `@func`: test app that loads peptide data and calls `Bio:toAtomicLevel` with highlight
+- `editMoleculeCell` — `@func` (role: `cellEditor`): opens the full-screen HELM editor app dialog for cell editing (`openWebEditor`)
+- `openEditor` (`Edit Helm...`) — `@func` (action): context-menu editor for Macromolecule columns; converts non-HELM notations to HELM first, then writes the edited value back in the column's original notation
+- `propertiesWidget` (`Properties`) — `@panel`: molecular formula, weight, extinction coefficient for a Macromolecule value
+- `getMolfiles` — `@func`: converts a Macromolecule column to molfile strings via `helmHelper.getMolfiles()`
+- `helmInput` — `@func` (role: `valueEditor`): creates the `HelmInput` widget for Macromolecule/HELM semType
+- `getHelmHelper` — `@func`: returns the `IHelmHelper` singleton
+- `measureCellRenderer` — `@func`: cell-render performance benchmark
+- `highlightMonomers` (`Highlight Monomers`) — `@func`: test app that loads peptide data and calls `Bio:toAtomicLevel` with `highlight: true`
+
+> The legacy `getHelmService` function is **gone** — the off-screen render service now lives inside hwe and is owned by the helper's adapter.
 
 **Exports**: `_package` (instance of `HelmPackage`), auto-generated function wrappers from `package.g.ts`
 
 ### Detector — `detectors.js`
 
 `HelmPackageDetectors` class:
-- `autostart` — registers `ui.input.helmAsync` polyfill so other packages can create HELM inputs before this package fully loads
+- `autostart` (meta.role: autostart) — Helm bootstrap; registers the `ui.input.helmAsync` polyfill (delegates to `Helm:helmInput`) so other packages can create HELM inputs before this package fully loads. No semantic-type detector — HELM detection lives in Bio's `detectMacromolecule`.
 
-### Package Utilities — `src/package-utils.ts`
+### Package Singleton — `src/package-utils.ts`
 
 `HelmPackage` class (extends `DG.Package`) — the package singleton managing:
-- `helmHelper` / `seqHelper` — accessors for initialized helpers
-- `_libHelper` — monomer library helper
-- `monomerLib` — accessor for current `IMonomerLib`
-- `initHELMWebEditor()` — loads Dojo toolkit (bundled), JSDraw2 + HELM Web Editor, patches `dojox.gfx.svg.Text.getTextWidth` for hang prevention
-- `initHelmPatchScilAlert()` — suppresses Scilligence alert popups for missing monomers
-- `initHelmPatchPistoia()` — overrides `org.helm.webeditor.Monomers.getMonomer` to use Datagrok's monomer library instead of built-in dictionaries
-- `completeInit()` — ties helmHelper + libHelper together, rewrites Pistoia monomer dictionaries, subscribes to monomer lib changes
-- `monomerLibOnChangedHandler()` — resyncs Pistoia dictionaries when monomer library updates
-
-`initHelmLoadAndPatchDojo()` — complex initialization:
-1. Configures and loads bundled Dojo 1.10.10 with custom `loaderPatch.injectUrl`
-2. Requires Dojo modules (dojo/window, dojox/gfx, dijit/*, etc.)
-3. Waits for all modules to be ready
-4. Patches `dojox.gfx.svg.Text.prototype.getTextWidth` to prevent infinite loops
+- `helmHelper` / `seqHelper` — accessors for the initialized helpers
+- `_libHelper` — monomer library helper; `monomerLib` — accessor for the current `IMonomerLib`
+- `completeInit(helmHelper, libHelper)` — stores the helpers and subscribes to `monomerLib.onChanged`
+- `monomerLibOnChangedHandler()` — logs the new library summary and shows a "Monomer lib updated" info toast
 
-### HELM Helper — `src/helm-helper.ts`
+The legacy Dojo/JSDraw2 loader (`initHELMWebEditor`, `initHelmLoadAndPatchDojo`) and the `org.helm.webeditor.Monomers` patching (`initHelmPatchScilAlert`, `initHelmPatchPistoia`) are **gone** — hwe is self-contained and reads Bio's monomer library directly via `bridgeMonomerLib`.
 
-`HelmHelper` (implements `IHelmHelper`) — singleton providing:
-- `createHelmInput()` — creates `HelmInput` widget
-- `createHelmWebEditor()` — creates `HelmWebEditor` viewer instance
-- `createWebEditorApp()` — creates full HELM Web Editor app (with monomer explorer, tabs, sequence/notation views) for dialog-based editing. Includes custom "Placeholders" tab
-- `overrideMonomersFuncs()` / `revertOriginalMonomersFuncs()` — swap Pistoia's `getMonomer`/`getMonomerSet` with custom implementations
-- `buildMonomersFuncsFromLib()` — builds `getMonomer` function that reads from Datagrok's `IMonomerLib`
-- `getMolfiles()` — batch converts HELM strings to molfile format using a cached off-screen JSDraw2 editor
-- `parse()` — parses HELM string into `HelmMol` object model
-- `removeGaps()` — removes gap monomers from HELM, re-links bonds, returns mapping of old→new monomer positions
-- `getHoveredAtom()` — hit-tests a point against a `HelmMol` to find the nearest atom
+### HELM Helper — `src/helm-helper.ts`
 
-### HELM Web Editor Wrapper — `src/helm-web-editor.ts`
+`HelmHelper` (implements `IHelmHelper`) — singleton. Every editor / parse / calculation path runs through hwe via a lazily-built `HelmHelperAdapter` over a `HelmService` (the `editorAdapter` getter). The service is constructed with `bridgeMonomerLib(monomerLib)`, the RDKit module (for monomer-structure rendering), and an `extraPanes` map providing the editor's package-contributed tabs:
 
-`HelmWebEditor` (implements `IHelmWebEditor`) — lightweight wrapper around `JSDraw2.Editor`:
-- Creates a viewonly editor in a host div
-- Handles resize events to keep editor synced with container size
-- Exposes `editor` (the JSDraw2 `HelmEditor` instance) and `host` div
+| Pane | Source |
+|---|---|
+| **FASTA** / **BILN** | Read-only converted text via the seq handler's notation converters (BILN only for peptide chains; FASTA only for a single linear chain) |
+| **Molecular Structure** | `Bio:toAtomicLevelPanel` widget |
+| **Composition Analysis** | `Bio:compositionAnalysisWidget` widget |
+
+Methods:
+- `createHelmInput()` — creates the `HelmInput` widget
+- `createHelmWebEditor(host, options)` — view-only editor instance (`IHelmWebEditor`) from the adapter
+- `createWebEditorApp(host, helm)` — full editor app (palette + toolbar + canvas + built-in tabs + the extra panes above), wrapped in hwe's `LegacyAppWrapper` so it presents the legacy Pistoia `App` shape (`canvas.getHelm(true)`, `canvas.helm.jsd.m.atoms[i].selected`, …) — existing dialog consumers work unchanged
+- `getMolfiles()`, `parse(helm, origin)`, `removeGaps(srcHelm)` — delegate to the adapter
+- `getHoveredAtom(x, y, mol, height)` — delegates to `getHoveredMonomerFromEditorMol`
+- `originalMonomersFuncs` / `revertOriginalMonomersFuncs()` / `overrideMonomersFuncs()` / `buildMonomersFuncsFromLib()` — thin pass-throughs to the adapter, kept only for the `IHelmHelper` contract (hwe reads `bridgeMonomerLib(...)` directly, so there is no global monomer registry to patch)
+- private `_getSingleHelmDf()` / `_getSingleHelmDfSh()` — build a cached single-row HELM dataframe (tagged Macromolecule/helm; sets `.toAtomicWidgetWidth` to ~60% of window width) used by the Molecular-Structure / Composition / FASTA / BILN pane providers
 
 ## Utilities (`src/utils/`)
 
 | File | Purpose |
 |---|---|
-| `helm-grid-cell-renderer.ts` | `HelmGridCellRenderer` + `HelmGridCellRendererBack`: async cell renderer using SVG→image pipeline. Renders HELM structures in grid cells with LRU caching, handles mouse hover for monomer tooltips and hover links |
-| `helm-service.ts` | `HelmService` (extends `HelmServiceBase`): off-screen rendering service. Uses hidden JSDraw2 editors (LRU-cached per monomer lib) to render HELM→SVG→ImageData. Handles scaling/fitting within cell bounds |
-| `get-monomer.ts` | `rewriteLibraries()`: syncs Datagrok monomer library → Pistoia `org.helm.webeditor.Monomers` dictionary. `getMonomerOverrideAndLogAlert()`: temporary getMonomer override with alert suppression |
-| `get-hovered.ts` | `getHoveredMonomerFromEditorMol()`: nearest-atom hit testing in editor molecule coordinates. `getSeqMonomerFromHelmAtom()`: converts `HelmAtom` to `ISeqMonomer` with canonical symbol |
-| `index.ts` | HELM string parsing utilities: `parseHelm()` (extracts monomer symbols), `removeGapsFromHelm()` (regex gap removal), `findMonomers()` (finds missing monomers), `split()` / `detachAnnotation()` (HELM section tokenizer) |
-| `err-info.ts` | `defaultErrorHandler()`: logs errors via package logger + `grok.shell.error` |
+| `helm-grid-cell-renderer.ts` | `HelmGridCellRenderer` + `HelmGridCellRendererBack`: **synchronous** grid cell renderer painting straight into the grid canvas via hwe `HelmService.renderToCanvas` (no async SVG→image / ImageData round-trip). Keeps one hwe service per monomer-library source (`serviceByLib`) and per-cell-value layout bookkeeping (`auxList`) for hover + highlight. Subscribes to monomer-lib changes (invalidate all) and to `MACROMOLECULE_HIGHLIGHT_EVENT_ID`; `drawHighlightOverlay` paints translucent rings around highlighted monomers. `onMouseMove` hit-tests the laid-out mol and shows the monomer tooltip + hover links |
+| `get-hovered.ts` | `getHoveredMonomerFromEditorMol()`: nearest-atom hit testing (model coordinates) against a `HelmMol`. `getSeqMonomerFromHelmAtom()`: converts a `HelmAtom` to `ISeqMonomer` with canonical symbol (DNA/RNA sugar + phosphate aware) |
+| `index.ts` | HELM string utilities: `parseHelm()` (extracts monomer symbols, bracket/paren aware), `removeGapsFromHelm()` (regex gap removal), `findMonomers()` (resolves via `monomerLib.getMonomer`), `getParts()`, and the `split()` / `detachAnnotation()` HELM section tokenizer |
+| `err-info.ts` | `defaultErrorHandler()`: logs via the package logger + `grok.shell.error` |
 
 ## Widgets (`src/widgets/`)
 
 | File | Purpose |
 |---|---|
-| `helm-input.ts` | `HelmInput` (extends `HelmInputBase`): interactive HELM sequence input widget. Embeds a viewonly `HelmWebEditor`, shows monomer tooltips on hover, "Click to edit" hint opens full editor dialog. Supports `SeqValueBase` get/set, string get/set, `molValue` access. Handles mouse events for hover/click/tooltip |
-| `properties-widget.ts` | `getPropertiesWidget()`: property panel showing molecular formula, weight, and extinction coefficient. Uses off-screen JSDraw2 editor to compute properties. Limits to sequences <1000 chars |
+| `helm-input.ts` | `HelmInput` (extends `HelmInputBase`): interactive HELM input widget embedding a **view-only hwe editor** (`IHelmWebEditor`). Defaults to a compact 250×250 box; shows monomer tooltips on hover; "Click to edit" opens the full hwe editor app in a full-screen dialog and reads back the edited HELM + monomer selection (via the legacy `App` canvas shape). Re-fits the canvas on resize (`ui.onSizeChanged`). Supports `SeqValueBase`/string get/set and `molValue` |
+| `properties-widget.ts` | `getPropertiesWidget()` / `getPropertiesDict()`: **async** property panel — molecular formula, weight, extinction coefficient computed from an off-screen hwe editor (obtained via the async `getHelmHelper()` factory, replacing the old off-screen JSDraw2 editor). Limited to sequences <1000 chars |
 
 ## Constants — `src/constants.ts`
 
 - `jsonSdfMonomerLibDict` — mapping between SDF monomer fields and internal property names
-- `SMILES`, `RGROUPS`, `MONOMER_SYMBOL`, `RGROUP_*` — field name constants for monomer data
-- `SDF_MONOMER_NAME` — SDF field name
+- `SMILES`, `RGROUPS`, `MONOMER_SYMBOL`, `RGROUP_*`, `SDF_MONOMER_NAME` — field-name constants for monomer data
 - `TAGS.cellRendererRenderError` — tag for tracking render errors
 
-## Types — `src/types/index.ts`
-
-Re-exports from `@datagrok-libraries/bio/src/helm/types`:
-- `ScilModule` — Scilligence utility module (`scil.*`)
-- `JSDraw2Module` — JSDraw2 editor module (`JSDraw2.*`)
-- `OrgHelmModule` — Pistoia HELM module (`org.helm.*`)
-
-## Vendor Libraries
-
-### `vendor/dojo-1.10.10/`
-Bundled Dojo Toolkit (dijit, dojo, dojox) required by JSDraw2 and HELM Web Editor. Loaded via custom `dojoConfig.loaderPatch.injectUrl` to work within webpack bundle.
-
-### `helm/JSDraw/`
-Legacy uncompressed sources of Scilligence JSDraw2 Lite and Pistoia HELM Web Editor. Currently replaced by `@datagrok-libraries/helm-web-editor` npm package.
+> HELM types (`HelmType`, `HelmMol`, `HelmAtom`, `App`, `Point`, `MonomersFuncs`, `IHelmWebEditor`, …) are imported directly from `@datagrok-libraries/bio/src/helm/types`. The old `src/types/` re-export module (`ScilModule` / `JSDraw2Module` / `OrgHelmModule`) was removed in the migration.
 
 ## Tests (`src/tests/`)
 
@@ -115,38 +106,34 @@ Test entry point: `src/package-test.ts` — imports all test files, exports `tes
 | File | What it tests |
 |---|---|
 | `_first-tests.ts` | Package import sanity check |
-| `helm-tests.ts` | HELM parsing, parseHelm utility |
+| `helm-tests.ts` | HELM parsing, `parseHelm` utility |
 | `findMonomers-tests.ts` | Missing monomer detection |
-| `helm-service-tests.ts` | HelmService rendering |
 | `renderers-tests.ts` | Cell renderer behavior |
 | `get-molfiles-tests.ts` | HELM → molfile conversion |
 | `properties-widget-tests.ts` | Properties panel (formula, MW, ext. coeff.) |
-| `get-monomer-tests.ts` | Monomer lookup and library integration |
 | `parse-helm-tests.ts` | HELM string parsing edge cases |
-| `helm-web-editor-tests.ts` | Web editor widget creation |
-| `helm-input-tests.ts` | HelmInput widget behavior |
-| `helm-helper-tests.ts` | HelmHelper methods (parse, removeGaps, getMolfiles) |
+| `helm-web-editor-tests.ts` | hwe editor / web-editor widget creation |
+| `helm-input-tests.ts` | `HelmInput` widget behavior |
+| `helm-helper-tests.ts` | `HelmHelper` methods (parse, removeGaps, getMolfiles) |
 | `helm-substructure-filter.ts` | Substructure filtering for HELM |
 | `helm-activity-cliffs.ts` | Activity cliffs computation for HELM |
 | `to-atomic-level-ui-non-linear.ts` | Non-linear HELM → atomic level conversion |
+| `utils.ts` | Shared test helpers (not a `test()` suite) |
 
 ## Initialization Flow
 
-1. `detectors.js` `autostart` runs first — registers `ui.input.helmAsync` polyfill
-2. `initHelm()` called on package init → loads RdKit, SeqHelper, MonomerLibHelper
-3. `initHELMWebEditor()` → loads bundled Dojo, waits for all Dojo modules, patches SVG text width
-4. Loads `@datagrok-libraries/helm-web-editor` bundle, waits for `helmWebEditor$.initPromise`
-5. Creates `HelmHelper` singleton
-6. `completeInit()` → rewrites Pistoia monomer dictionaries from Datagrok lib, patches `getMonomer`, subscribes to lib changes
+1. `detectors.js` `autostart` runs first — registers the `ui.input.helmAsync` polyfill
+2. `initHelm()` on package init → loads the RDKit module, `SeqHelper`, `MonomerLibHelper`; creates `HelmHelper(seqHelper, logger, rdKitModule)`
+3. `completeInit(helmHelper, libHelper)` → wires the helpers and subscribes to monomer-library changes
+4. The hwe `HelmHelperAdapter` / `HelmService` is built **lazily** on first editor / parse / calculation use (after the library is available), reading Bio's monomer library via `bridgeMonomerLib`
 
 ## Key Dependencies
 
-- `@datagrok-libraries/bio` — macromolecule types, HELM types (`HelmType`, `HelmAtom`, `HelmMol`, `IHelmHelper`, `ISeqHelper`, `IMonomerLib`), cell renderer base classes, monomer hover links
-- `@datagrok-libraries/helm-web-editor` — bundled JSDraw2 + Pistoia HELM Web Editor
-- `@datagrok-libraries/chem-meta` — chemistry metadata
-- `@datagrok-libraries/utils` — SVG utilities (`svgToImage`), console helpers
+- `@datagrok-libraries/hwe` — the standalone Datagrok HELM Web Editor: HELM parsing, synchronous canvas rendering, molfile / property calculators, and the editor app (`HelmService`, `HelmHelperAdapter`, `bridgeMonomerLib`, `buildHelmMolView`, `PolymerTypes`, `styles.css`)
+- `@datagrok-libraries/bio` — macromolecule + HELM types (`HelmType`, `HelmAtom`, `HelmMol`, `IHelmHelper`, `ISeqHelper`, `IMonomerLib`), cell-renderer base classes, monomer hover links, macromolecule-highlight events/consts
+- `@datagrok-libraries/chem-meta` — RDKit API types (`RDModule`)
+- `@datagrok-libraries/utils` — error / console helpers
 - `cash-dom` — jQuery-like DOM manipulation
-- `lru-cache` — LRU caching for editors and rendered images
 - `wu` — lazy iteration
 - `rxjs` — reactive subscriptions
 
@@ -155,18 +142,17 @@ Test entry point: `src/package-test.ts` — imports all test files, exports `tes
 | Looking for... | Check first |
 |---|---|
 | Function/panel/renderer registration | `src/package.ts` |
-| Package singleton, Dojo/HWE loading | `src/package-utils.ts` (`HelmPackage`) |
-| HELM helper (parse, convert, getMolfiles) | `src/helm-helper.ts` |
-| Web editor wrapper | `src/helm-web-editor.ts` |
-| Grid cell renderer (async SVG→image) | `src/utils/helm-grid-cell-renderer.ts` |
-| Off-screen render service | `src/utils/helm-service.ts` |
-| Monomer library sync with Pistoia | `src/utils/get-monomer.ts` |
+| Package singleton, init wiring | `src/package-utils.ts` (`HelmPackage`) |
+| HELM helper + hwe adapter (parse, convert, getMolfiles, editor app, panes) | `src/helm-helper.ts` (`HelmHelper.editorAdapter`) |
+| The hwe editor / service / adapter | `@datagrok-libraries/hwe` (external) |
+| Grid cell renderer (synchronous canvas) | `src/utils/helm-grid-cell-renderer.ts` |
+| Monomer highlight overlay (event-driven) | `src/utils/helm-grid-cell-renderer.ts` (`handleHighlightEvent` / `drawHighlightOverlay`) |
 | Mouse hover / hit testing | `src/utils/get-hovered.ts` |
 | HELM string parsing | `src/utils/index.ts` |
 | HELM input widget | `src/widgets/helm-input.ts` |
 | Properties panel (MW, formula) | `src/widgets/properties-widget.ts` |
 | Constants (field names, tags) | `src/constants.ts` |
-| Type re-exports (Scil, JSDraw2, Org) | `src/types/index.ts` |
+| HELM types (`HelmMol`, `HelmAtom`, `App`, …) | `@datagrok-libraries/bio/src/helm/types` |
 | Auto-generated function wrappers | `src/package.g.ts` / `src/package-api.ts` |
 | Autostart / input polyfill | `detectors.js` |
 | Test entry point | `src/package-test.ts` |

package/css/helm.css

@@ -1,3 +1,43 @@
 .d4-g-cell[semType="Macromolecule"] * {
     pointer-events: none !important;
 }
+
+.hw-pane--extra>div[data-testid="extra-pane-content-molecular-structure"]>div.d4-accordion {
+    display: flex;
+    flex-direction: row;
+    gap: 24px;
+}
+
+.hw-pane--extra>div[data-testid="extra-pane-content-molecular-structure"]>div.d4-accordion>div.d4-accordion-pane[d4-title="Explore"] {
+    flex-grow: 1;
+    max-height: 280px;
+    overflow-y: scroll;
+    overflow-x: hidden;
+    max-width: calc(100% - 400px);
+}
+
+.hw-pane--extra>div[data-testid="extra-pane-content-molecular-structure"] {
+    height: 280px;
+    overflow: hidden;
+}
+
+.hw-pane--extra>div[data-testid="extra-pane-content-molecular-structure"]>div.d4-accordion>div.d4-accordion-pane[d4-title="Explore"] .d4-accordion-pane-header {
+    height: 30px;
+}
+
+.hw-pane--extra>div[data-testid="extra-pane-content-molecular-structure"]>div.d4-accordion>div.d4-accordion-pane[d4-title="Explore"] .d4-accordion {
+    width: 100%;
+}
+
+.hw-pane__extra>.macromolecule-cell-comp-analysis-host>table {
+    margin: 0;
+}
+
+.hw-pane__extra>.macromolecule-cell-comp-analysis-host>table>tbody {
+    width: 100%;
+    display: flex;
+    flex-direction: column;
+    flex-wrap: wrap;
+    max-height: 260px;
+    column-gap: 24px;
+}