@jbrowse/plugin-dotplot-view 3.6.5 → 4.0.0

package/esm/ComparativeRenderer/index.d.ts

@@ -1,22 +1,22 @@
 import RpcMethodType from '@jbrowse/core/pluggableElementTypes/RpcMethodType';
-import type { RenderArgs as ComparativeRenderArgs, RenderArgsSerialized as ComparativeRenderArgsSerialized, RenderResults, ResultsSerialized } from '@jbrowse/core/pluggableElementTypes/renderers/ComparativeServerSideRendererType';
-import type ComparativeRenderer from '@jbrowse/core/pluggableElementTypes/renderers/ComparativeServerSideRendererType';
-interface RenderArgs extends ComparativeRenderArgs {
-    adapterConfig: Record<string, unknown>;
+import type { DotplotRenderArgs, RenderArgsSerialized, ResultsSerialized } from '../DotplotRenderer/DotplotRenderer.ts';
+import type DotplotRenderer from '../DotplotRenderer/DotplotRenderer.ts';
+import type { RenderResults } from '@jbrowse/core/pluggableElementTypes/renderers/ServerSideRendererType';
+interface RenderArgs extends DotplotRenderArgs {
     rendererType: string;
 }
-interface RenderArgsSerialized extends ComparativeRenderArgsSerialized {
+interface RenderArgsSerializedWithRenderer extends RenderArgsSerialized {
     adapterConfig: Record<string, unknown>;
     rendererType: string;
 }
 export default class ComparativeRender extends RpcMethodType {
     name: string;
-    renameRegionsIfNeeded(args: RenderArgs, rend: ComparativeRenderer): Promise<ComparativeRenderArgs>;
-    getRenderer(rendererType: string): ComparativeRenderer;
-    serializeArguments(args: RenderArgs, rpcDriver: string): Promise<ComparativeRenderArgs | import("@jbrowse/core/pluggableElementTypes/renderers/ServerSideRendererType").RenderArgsSerialized>;
-    execute(args: RenderArgsSerialized & {
+    renameRegionsIfNeeded(args: RenderArgs, rend: DotplotRenderer): Promise<DotplotRenderArgs>;
+    getRenderer(rendererType: string): DotplotRenderer;
+    serializeArguments(args: RenderArgs, rpcDriver: string): Promise<import("@jbrowse/core/pluggableElementTypes/renderers/ServerSideRendererType").RenderArgsSerialized>;
+    execute(args: RenderArgsSerializedWithRenderer & {
         stopToken?: string;
-    }, rpcDriver: string): Promise<RenderResults | import("@jbrowse/core/pluggableElementTypes/renderers/ServerSideRendererType").ResultsSerialized>;
+    }, rpcDriver: string): Promise<import("@jbrowse/core/pluggableElementTypes/renderers/ServerSideRendererType").ResultsSerialized>;
     deserializeReturn(val: RenderResults | ResultsSerialized, args: RenderArgs, rpcDriver: string): Promise<unknown>;
 }
 export {};

package/esm/ComparativeRenderer/index.js

@@ -1,10 +1,7 @@
 import RpcMethodType from '@jbrowse/core/pluggableElementTypes/RpcMethodType';
 import { checkStopToken } from '@jbrowse/core/util/stopToken';
 export default class ComparativeRender extends RpcMethodType {
-    constructor() {
-        super(...arguments);
-        this.name = 'ComparativeRender';
-    }
+    name = 'ComparativeRender';
     async renameRegionsIfNeeded(args, rend) {
         return rend.renameRegionsIfNeeded(args);
     }
@@ -17,30 +14,20 @@ export default class ComparativeRender extends RpcMethodType {
         const renderer = this.getRenderer(rendererType);
         const n = (await super.serializeArguments(args, rpcDriver));
         const result = await this.renameRegionsIfNeeded(n, renderer);
-        return rpcDriver === 'MainThreadRpcDriver'
-            ? result
-            : renderer.serializeArgsInClient(result);
+        return renderer.serializeArgsInClient(result);
     }
     async execute(args, rpcDriver) {
-        let deserializedArgs = args;
-        if (rpcDriver !== 'MainThreadRpcDriver') {
-            deserializedArgs = await this.deserializeArguments(args, rpcDriver);
-        }
+        const deserializedArgs = await this.deserializeArguments(args, rpcDriver);
         const { sessionId, rendererType, stopToken } = deserializedArgs;
         if (!sessionId) {
             throw new Error('must pass a unique session id');
         }
         checkStopToken(stopToken);
         const renderer = this.getRenderer(rendererType);
-        return rpcDriver === 'MainThreadRpcDriver'
-            ? renderer.render(deserializedArgs)
-            : renderer.renderInWorker(deserializedArgs);
+        return renderer.renderInWorker(deserializedArgs);
     }
     async deserializeReturn(val, args, rpcDriver) {
         const ret = (await super.deserializeReturn(val, args, rpcDriver));
-        if (rpcDriver === 'MainThreadRpcDriver') {
-            return ret;
-        }
         const renderer = this.getRenderer(args.rendererType);
         return renderer.deserializeResultsInClient(ret, args);
     }

package/esm/DiagonalizeDotplotRpc.d.ts

@@ -0,0 +1,30 @@
+import RpcMethodTypeWithFiltersAndRenameRegions from '@jbrowse/core/pluggableElementTypes/RpcMethodTypeWithFiltersAndRenameRegions';
+import type { Region } from '@jbrowse/core/util';
+interface DiagonalizationResult {
+    newRegions: Region[];
+    stats: {
+        totalAlignments: number;
+        regionsProcessed: number;
+        regionsReordered: number;
+        regionsReversed: number;
+    };
+}
+interface DiagonalizeDotplotArgs {
+    sessionId: string;
+    view: {
+        hview: {
+            displayedRegions: Region[];
+        };
+        vview: {
+            displayedRegions: Region[];
+        };
+    };
+    adapterConfig: Record<string, unknown>;
+    stopToken?: string;
+    statusCallback?: (message: string) => void;
+}
+export default class DiagonalizeDotplotRpc extends RpcMethodTypeWithFiltersAndRenameRegions {
+    name: string;
+    execute(args: DiagonalizeDotplotArgs, rpcDriverClassName: string): Promise<DiagonalizationResult>;
+}
+export {};

package/esm/DiagonalizeDotplotRpc.js

@@ -0,0 +1,147 @@
+import RpcMethodTypeWithFiltersAndRenameRegions from '@jbrowse/core/pluggableElementTypes/RpcMethodTypeWithFiltersAndRenameRegions';
+import { checkStopToken } from '@jbrowse/core/util/stopToken';
+import { Dotplot1DView } from "./DotplotView/model.js";
+async function diagonalizeRegions(alignments, currentRegions, progressCallback) {
+    const updateProgress = (progress, message) => {
+        if (progressCallback) {
+            progressCallback(progress, message);
+        }
+    };
+    updateProgress(20, `Grouping ${alignments.length} alignments...`);
+    const queryGroups = new Map();
+    for (const aln of alignments) {
+        const targetRefName = aln.refRefName;
+        if (!queryGroups.has(targetRefName)) {
+            queryGroups.set(targetRefName, {
+                refAlignments: new Map(),
+                strandWeightedSum: 0,
+            });
+        }
+        const group = queryGroups.get(targetRefName);
+        const alnLength = Math.abs(aln.queryEnd - aln.queryStart);
+        if (!group.refAlignments.has(aln.queryRefName)) {
+            group.refAlignments.set(aln.queryRefName, {
+                bases: 0,
+                positions: [],
+            });
+        }
+        const refData = group.refAlignments.get(aln.queryRefName);
+        refData.bases += alnLength;
+        refData.positions.push((aln.queryStart + aln.queryEnd) / 2);
+        const direction = aln.strand >= 0 ? 1 : -1;
+        group.strandWeightedSum += direction * alnLength;
+    }
+    updateProgress(50, 'Determining optimal ordering and orientation...');
+    const queryOrdering = [];
+    for (const [targetRefName, group] of queryGroups) {
+        let bestRefName = '';
+        let maxBases = 0;
+        let bestPositions = [];
+        for (const [firstViewRefName, data] of group.refAlignments) {
+            if (data.bases > maxBases) {
+                maxBases = data.bases;
+                bestRefName = firstViewRefName;
+                bestPositions = data.positions;
+            }
+        }
+        const bestRefPos = bestPositions.reduce((a, b) => a + b, 0) / bestPositions.length;
+        const shouldReverse = group.strandWeightedSum < 0;
+        queryOrdering.push({
+            refName: targetRefName,
+            bestRefName,
+            bestRefPos,
+            shouldReverse,
+        });
+    }
+    updateProgress(70, `Sorting ${queryOrdering.length} query regions...`);
+    queryOrdering.sort((a, b) => {
+        if (a.bestRefName !== b.bestRefName) {
+            return a.bestRefName.localeCompare(b.bestRefName);
+        }
+        return a.bestRefPos - b.bestRefPos;
+    });
+    updateProgress(85, 'Building new region layout...');
+    const newQueryRegions = [];
+    let regionsReversed = 0;
+    for (const { refName, shouldReverse } of queryOrdering) {
+        const region = currentRegions.find(r => r.refName === refName);
+        if (region) {
+            newQueryRegions.push({
+                ...region,
+                reversed: shouldReverse,
+            });
+            if (shouldReverse !== region.reversed) {
+                regionsReversed++;
+            }
+        }
+    }
+    const regionsWithoutAlignments = currentRegions.filter(r => !newQueryRegions.some(nr => nr.refName === r.refName));
+    updateProgress(100, 'Diagonalization complete!');
+    return {
+        newRegions: [...newQueryRegions, ...regionsWithoutAlignments],
+        stats: {
+            totalAlignments: alignments.length,
+            regionsProcessed: queryOrdering.length,
+            regionsReordered: newQueryRegions.length,
+            regionsReversed,
+        },
+    };
+}
+export default class DiagonalizeDotplotRpc extends RpcMethodTypeWithFiltersAndRenameRegions {
+    name = 'DiagonalizeDotplot';
+    async execute(args, rpcDriverClassName) {
+        const deserializedArgs = await this.deserializeArguments(args, rpcDriverClassName);
+        const { view, sessionId, adapterConfig, stopToken, statusCallback } = deserializedArgs;
+        if (!sessionId) {
+            throw new Error('must pass a unique session id');
+        }
+        statusCallback?.('Initializing diagonalization...');
+        const dimensions = [800, 800];
+        const views = [view.hview, view.vview].map((snap, idx) => {
+            const v = Dotplot1DView.create(snap);
+            v.setVolatileWidth(dimensions[idx]);
+            return v;
+        });
+        const targetView = views[0];
+        checkStopToken(stopToken);
+        statusCallback?.('Getting renderer...');
+        const rendererType = this.pluginManager.getRendererType('DotplotRenderer');
+        if (!rendererType) {
+            throw new Error('DotplotRenderer not found');
+        }
+        checkStopToken(stopToken);
+        statusCallback?.('Fetching features...');
+        const feats = await rendererType.getFeatures({
+            regions: targetView.dynamicBlocks.contentBlocks,
+            adapterConfig,
+            sessionId,
+        });
+        checkStopToken(stopToken);
+        statusCallback?.('Extracting alignment data...');
+        const alignments = [];
+        for (const feat of feats.values()) {
+            const mate = feat.get('mate');
+            if (mate) {
+                alignments.push({
+                    queryRefName: feat.get('refName'),
+                    refRefName: mate.refName,
+                    queryStart: feat.get('start'),
+                    queryEnd: feat.get('end'),
+                    refStart: mate.start,
+                    refEnd: mate.end,
+                    strand: feat.get('strand') || 1,
+                });
+            }
+        }
+        if (alignments.length === 0) {
+            throw new Error('No alignments found to diagonalize');
+        }
+        statusCallback?.(`Running diagonalization on ${alignments.length} alignments...`);
+        const result = await diagonalizeRegions(alignments, view.vview.displayedRegions, (progress, message) => {
+            checkStopToken(stopToken);
+            statusCallback?.(message);
+        });
+        statusCallback?.('Diagonalization complete!');
+        return result;
+    }
+}

package/esm/DotplotDisplay/components/DotplotDisplay.d.ts

@@ -1,4 +1,4 @@
-import type { DotplotDisplayModel } from '../stateModelFactory';
+import type { DotplotDisplayModel } from '../stateModelFactory.tsx';
 declare const DotplotDisplay: (props: {
     model: DotplotDisplayModel;
     children?: React.ReactNode;

package/esm/DotplotDisplay/index.d.ts

@@ -1,5 +1,5 @@
 import type PluginManager from '@jbrowse/core/PluginManager';
 export default function DotplotDisplayF(pm: PluginManager): void;
-export declare function configSchemaFactory(pm: any): import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
-    renderer: import("mobx-state-tree").IOptionalIType<any, [undefined]>;
-}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, "displayId">>;
+export declare function configSchemaFactory(pm: any): import("node_modules/@jbrowse/core/src/configuration/configurationSchema.ts").ConfigurationSchemaType<{
+    renderer: import("@jbrowse/mobx-state-tree").IOptionalIType<any, [undefined]>;
+}, import("node_modules/@jbrowse/core/src/configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, "displayId">>;

package/esm/DotplotDisplay/index.js

@@ -1,8 +1,8 @@
+import { lazy } from 'react';
 import { ConfigurationSchema } from '@jbrowse/core/configuration';
 import DisplayType from '@jbrowse/core/pluggableElementTypes/DisplayType';
-import { types } from 'mobx-state-tree';
-import ReactComponent from './components/DotplotDisplay';
-import { stateModelFactory } from './stateModelFactory';
+import { types } from '@jbrowse/mobx-state-tree';
+import { stateModelFactory } from "./stateModelFactory.js";
 export default function DotplotDisplayF(pm) {
     pm.addDisplayType(() => {
         const configSchema = configSchemaFactory(pm);
@@ -13,7 +13,7 @@ export default function DotplotDisplayF(pm) {
             stateModel: stateModelFactory(configSchema),
             trackType: 'SyntenyTrack',
             viewType: 'DotplotView',
-            ReactComponent,
+            ReactComponent: lazy(() => import("./components/DotplotDisplay.js")),
         });
     });
 }

package/esm/DotplotDisplay/renderDotplotBlock.d.ts

@@ -1,8 +1,9 @@
-import type { IAnyStateTreeNode } from 'mobx-state-tree';
+import type { IAnyStateTreeNode } from '@jbrowse/mobx-state-tree';
 export declare function renderBlockData(self: IAnyStateTreeNode): {
     rendererType: any;
     rpcManager: import("@jbrowse/core/rpc/RpcManager").default;
     renderProps: any;
+    renderingProps: Record<string, unknown> | undefined;
 } | undefined;
 export declare function renderBlockEffect(props?: ReturnType<typeof renderBlockData>): Promise<{
     reactElement: any;

package/esm/DotplotDisplay/renderDotplotBlock.js

@@ -1,7 +1,7 @@
 import { readConfObject } from '@jbrowse/core/configuration';
-import { getContainingView, getSession } from '@jbrowse/core/util';
+import { getContainingTrack, getContainingView, getSession, } from '@jbrowse/core/util';
 import { getRpcSessionId } from '@jbrowse/core/util/tracks';
-import { getSnapshot } from 'mobx-state-tree';
+import { getSnapshot } from '@jbrowse/mobx-state-tree';
 export function renderBlockData(self) {
     const { rpcManager } = getSession(self);
     const { rendererType } = self;
@@ -25,8 +25,13 @@ export function renderBlockData(self) {
                 adapterConfig,
                 rendererType: rendererType.name,
                 sessionId: getRpcSessionId(self),
+                trackInstanceId: getContainingTrack(self).id,
                 timeout: 1000000,
+                alpha: self.alpha,
+                minAlignmentLength: self.minAlignmentLength,
+                colorBy: self.colorBy,
             },
+            renderingProps: self.renderingProps?.(),
         };
     }
     return undefined;
@@ -35,8 +40,8 @@ export async function renderBlockEffect(props) {
     if (!props) {
         return;
     }
-    const { rendererType, rpcManager, renderProps } = props;
-    const { reactElement, ...data } = await rendererType.renderInClient(rpcManager, renderProps);
+    const { rendererType, rpcManager, renderProps, renderingProps } = props;
+    const { reactElement, ...data } = await rendererType.renderInClient(rpcManager, { ...renderProps, renderingProps });
     return {
         reactElement,
         data,

package/esm/DotplotDisplay/stateModelFactory.d.ts

@@ -1,37 +1,39 @@
-import type { ExportSvgOptions } from '../DotplotView/model';
+import type { ExportSvgOptions } from '../DotplotView/model.ts';
 import type { AnyConfigurationSchemaType } from '@jbrowse/core/configuration';
+import type { StopToken } from '@jbrowse/core/util/stopToken';
+import type { Instance } from '@jbrowse/mobx-state-tree';
 import type { ThemeOptions } from '@mui/material';
-import type { Instance } from 'mobx-state-tree';
-export declare function stateModelFactory(configSchema: AnyConfigurationSchemaType): import("mobx-state-tree").IModelType<{
-    id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
-    type: import("mobx-state-tree").ISimpleType<string>;
-    rpcDriverName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+export declare function stateModelFactory(configSchema: AnyConfigurationSchemaType): import("@jbrowse/mobx-state-tree").IModelType<{
+    id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
+    type: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+    rpcDriverName: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
 } & {
-    type: import("mobx-state-tree").ISimpleType<"DotplotDisplay">;
+    type: import("@jbrowse/mobx-state-tree").ISimpleType<"DotplotDisplay">;
     configuration: AnyConfigurationSchemaType;
+    colorBy: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
 }, {
     rendererTypeName: string;
     error: unknown;
-    message: string | undefined;
+    statusMessage: string | undefined;
 } & {
     readonly RenderingComponent: React.FC<{
         model: {
             id: string;
             type: string;
             rpcDriverName: string | undefined;
-        } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+        } & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & {
             rendererTypeName: string;
             error: unknown;
-            message: string | undefined;
-        } & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IModelType<{
-            id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
-            type: import("mobx-state-tree").ISimpleType<string>;
-            rpcDriverName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+            statusMessage: string | undefined;
+        } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("@jbrowse/mobx-state-tree").IModelType<{
+            id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
+            type: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+            rpcDriverName: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
         }, {
             rendererTypeName: string;
             error: unknown;
-            message: string | undefined;
-        }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>;
+            statusMessage: string | undefined;
+        }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>>;
         onHorizontalScroll?: () => void;
         blockState?: Record<string, any>;
     }>;
@@ -40,35 +42,147 @@ export declare function stateModelFactory(configSchema: AnyConfigurationSchemaTy
             id: string;
             type: string;
             rpcDriverName: string | undefined;
-        } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+        } & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & {
             rendererTypeName: string;
             error: unknown;
-            message: string | undefined;
-        } & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IModelType<{
-            id: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").ISimpleType<string>, [undefined]>;
-            type: import("mobx-state-tree").ISimpleType<string>;
-            rpcDriverName: import("mobx-state-tree").IMaybe<import("mobx-state-tree").ISimpleType<string>>;
+            statusMessage: string | undefined;
+        } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("@jbrowse/mobx-state-tree").IModelType<{
+            id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
+            type: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+            rpcDriverName: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
         }, {
             rendererTypeName: string;
             error: unknown;
-            message: string | undefined;
-        }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>;
+            statusMessage: string | undefined;
+        }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>>;
     }> | null;
     readonly adapterConfig: any;
-    readonly parentTrack: any;
+    readonly parentTrack: import("@jbrowse/core/util").AbstractTrackModel;
+    readonly parentDisplay: any;
+    readonly effectiveRpcDriverName: any;
+} & {
     renderProps(): any;
+    renderingProps(): {
+        displayModel: {
+            id: string;
+            type: string;
+            rpcDriverName: string | undefined;
+        } & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & {
+            rendererTypeName: string;
+            error: unknown;
+            statusMessage: string | undefined;
+        } & {
+            readonly RenderingComponent: React.FC<{
+                model: {
+                    id: string;
+                    type: string;
+                    rpcDriverName: string | undefined;
+                } & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & {
+                    rendererTypeName: string;
+                    error: unknown;
+                    statusMessage: string | undefined;
+                } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("@jbrowse/mobx-state-tree").IModelType<{
+                    id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
+                    type: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+                    rpcDriverName: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
+                }, {
+                    rendererTypeName: string;
+                    error: unknown;
+                    statusMessage: string | undefined;
+                }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>>;
+                onHorizontalScroll?: () => void;
+                blockState?: Record<string, any>;
+            }>;
+            readonly DisplayBlurb: React.FC<{
+                model: {
+                    id: string;
+                    type: string;
+                    rpcDriverName: string | undefined;
+                } & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & {
+                    rendererTypeName: string;
+                    error: unknown;
+                    statusMessage: string | undefined;
+                } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("@jbrowse/mobx-state-tree").IModelType<{
+                    id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
+                    type: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+                    rpcDriverName: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
+                }, {
+                    rendererTypeName: string;
+                    error: unknown;
+                    statusMessage: string | undefined;
+                }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>>;
+            }> | null;
+            readonly adapterConfig: any;
+            readonly parentTrack: import("@jbrowse/core/util").AbstractTrackModel;
+            readonly parentDisplay: any;
+            readonly effectiveRpcDriverName: any;
+        } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("@jbrowse/mobx-state-tree").IModelType<{
+            id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
+            type: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+            rpcDriverName: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
+        }, {
+            rendererTypeName: string;
+            error: unknown;
+            statusMessage: string | undefined;
+        } & {
+            readonly RenderingComponent: React.FC<{
+                model: {
+                    id: string;
+                    type: string;
+                    rpcDriverName: string | undefined;
+                } & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & {
+                    rendererTypeName: string;
+                    error: unknown;
+                    statusMessage: string | undefined;
+                } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("@jbrowse/mobx-state-tree").IModelType<{
+                    id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
+                    type: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+                    rpcDriverName: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
+                }, {
+                    rendererTypeName: string;
+                    error: unknown;
+                    statusMessage: string | undefined;
+                }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>>;
+                onHorizontalScroll?: () => void;
+                blockState?: Record<string, any>;
+            }>;
+            readonly DisplayBlurb: React.FC<{
+                model: {
+                    id: string;
+                    type: string;
+                    rpcDriverName: string | undefined;
+                } & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject & {
+                    rendererTypeName: string;
+                    error: unknown;
+                    statusMessage: string | undefined;
+                } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("@jbrowse/mobx-state-tree").IModelType<{
+                    id: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
+                    type: import("@jbrowse/mobx-state-tree").ISimpleType<string>;
+                    rpcDriverName: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
+                }, {
+                    rendererTypeName: string;
+                    error: unknown;
+                    statusMessage: string | undefined;
+                }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>>;
+            }> | null;
+            readonly adapterConfig: any;
+            readonly parentTrack: import("@jbrowse/core/util").AbstractTrackModel;
+            readonly parentDisplay: any;
+            readonly effectiveRpcDriverName: any;
+        }, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>>;
+    };
     readonly rendererType: import("@jbrowse/core/pluggableElementTypes").RendererType;
     readonly DisplayMessageComponent: undefined | React.FC<any>;
     trackMenuItems(): import("@jbrowse/core/ui").MenuItem[];
     readonly viewMenuActions: import("@jbrowse/core/ui").MenuItem[];
     regionCannotBeRendered(): null;
 } & {
-    setMessage(arg?: string): void;
+    setStatusMessage(arg?: string): void;
     setError(error?: unknown): void;
     setRpcDriverName(rpcDriverName: string): void;
     reload(): void;
 } & {
-    stopToken: string | undefined;
+    stopToken: StopToken | undefined;
     warnings: {
         message: string;
         effect: string;
@@ -79,6 +193,8 @@ export declare function stateModelFactory(configSchema: AnyConfigurationSchemaTy
     message: string | undefined;
     renderingComponent: any;
     ReactComponent2: React.FC<any>;
+    alpha: number;
+    minAlignmentLength: number;
 } & {
     readonly shouldDisplay: boolean;
     readonly rendererTypeName: any;
@@ -89,7 +205,7 @@ export declare function stateModelFactory(configSchema: AnyConfigurationSchemaTy
     }): Promise<import("react/jsx-runtime").JSX.Element | null>;
 } & {
     afterAttach(): void;
-    setLoading(stopToken?: string): void;
+    setLoading(stopToken?: StopToken): void;
     setMessage(messageText: string): void;
     setRendered(args?: {
         data: any;
@@ -97,6 +213,9 @@ export declare function stateModelFactory(configSchema: AnyConfigurationSchemaTy
         renderingComponent: React.Component;
     }): void;
     setError(error: unknown): void;
-}, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
+    setAlpha(value: number): void;
+    setMinAlignmentLength(value: number): void;
+    setColorBy(value: string): void;
+}, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;
 export type DotplotDisplayStateModel = ReturnType<typeof stateModelFactory>;
 export type DotplotDisplayModel = Instance<DotplotDisplayStateModel>;