@jbrowse/plugin-alignments 3.7.0 → 4.0.1

package/esm/SNPCoverageAdapter/processReferenceCpGs.js

@@ -1,59 +1,61 @@
-import { doesIntersect2 } from '@jbrowse/core/util';
-import { parseCigar } from '../MismatchParser';
-import { incWithProbabilities } from './util';
-import { getMethBins } from '../ModificationParser/getMethBins';
+import { createEmptyBin, incWithProbabilities } from "./util.js";
+import { parseCigar2 } from "../MismatchParser/index.js";
+import { getMethBins } from "../ModificationParser/getMethBins.js";
+import { DELETION_TYPE } from "../shared/forEachMismatchTypes.js";
+function processCpG(bins, binIdx, fstrand, isMeth, prob, isDel) {
+    if (isMeth) {
+        const bin = (bins[binIdx] ??= createEmptyBin());
+        incWithProbabilities(bin, fstrand, 'mods', 'cpg_meth', prob);
+        bin.ref.entryDepth--;
+        bin.ref[fstrand]--;
+    }
+    else {
+        if (!isDel) {
+            const bin = (bins[binIdx] ??= createEmptyBin());
+            incWithProbabilities(bin, fstrand, 'nonmods', 'cpg_unmeth', 1 - prob);
+            bin.ref.entryDepth--;
+            bin.ref[fstrand]--;
+        }
+    }
+}
 export function processReferenceCpGs({ feature, region, bins, regionSequence, }) {
-    var _a;
     const fstart = feature.get('start');
     const fend = feature.get('end');
     const fstrand = feature.get('strand');
     const seq = feature.get('seq');
-    const mismatches = (_a = feature.get('mismatches')) !== null && _a !== void 0 ? _a : [];
     const r = regionSequence.toLowerCase();
     if (seq) {
-        const cigarOps = parseCigar(feature.get('CIGAR'));
+        const cigarOps = feature.get('NUMERIC_CIGAR') ?? parseCigar2(feature.get('CIGAR'));
         const { methBins, methProbs } = getMethBins(feature, cigarOps);
-        const dels = mismatches.filter(f => f.type === 'deletion');
-        for (let i = 0; i < fend - fstart; i++) {
+        const isDeleted = new Array(methBins.length).fill(false);
+        feature.forEachMismatch((type, start, length) => {
+            if (type === DELETION_TYPE) {
+                const end = start + length;
+                for (let i = start; i < end; i++) {
+                    isDeleted[i] = true;
+                }
+            }
+        });
+        const regionStart = region.start;
+        const regionEnd = region.end;
+        const visStart = Math.max(0, regionStart - fstart);
+        const visEnd = Math.min(fend - fstart, regionEnd - fstart);
+        for (let i = visStart; i < visEnd; i++) {
             const j = i + fstart;
-            const l1 = r[j - region.start + 1];
-            const l2 = r[j - region.start + 2];
+            const l1 = r[j - regionStart + 1];
+            const l2 = r[j - regionStart + 2];
             if (l1 === 'c' && l2 === 'g') {
-                const bin0 = bins[j - region.start];
-                const bin1 = bins[j - region.start + 1];
+                const idx0 = j - regionStart;
+                const idx1 = j - regionStart + 1;
                 const b0 = methBins[i];
                 const b1 = methBins[i + 1];
-                const p0 = methProbs[i];
-                const p1 = methProbs[i + 1];
-                if ((b0 && (p0 !== undefined ? p0 > 0.5 : true)) ||
-                    (b1 && (p1 !== undefined ? p1 > 0.5 : true))) {
-                    if (bin0) {
-                        incWithProbabilities(bin0, fstrand, 'mods', 'cpg_meth', p0 || 0);
-                        bin0.ref.entryDepth--;
-                        bin0.ref[fstrand]--;
-                    }
-                    if (bin1) {
-                        incWithProbabilities(bin1, fstrand, 'mods', 'cpg_meth', p1 || 0);
-                        bin1.ref.entryDepth--;
-                        bin1.ref[fstrand]--;
-                    }
-                }
-                else {
-                    if (bin0) {
-                        if (!dels.some(d => doesIntersect2(j, j + 1, d.start + fstart, d.start + fstart + d.length))) {
-                            incWithProbabilities(bin0, fstrand, 'nonmods', 'cpg_unmeth', 1 - (p0 || 0));
-                            bin0.ref.entryDepth--;
-                            bin0.ref[fstrand]--;
-                        }
-                    }
-                    if (bin1) {
-                        if (!dels.some(d => doesIntersect2(j + 1, j + 2, d.start + fstart, d.start + fstart + d.length))) {
-                            incWithProbabilities(bin1, fstrand, 'nonmods', 'cpg_unmeth', 1 - (p1 || 0));
-                            bin1.ref.entryDepth--;
-                            bin1.ref[fstrand]--;
-                        }
-                    }
-                }
+                const p0 = methProbs[i] || 0;
+                const p1 = methProbs[i + 1] || 0;
+                const isMeth = !!((b0 && p0 > 0.5) || (b1 && p1 > 0.5));
+                const isDel0 = isDeleted[i];
+                const isDel1 = isDeleted[i + 1];
+                processCpG(bins, idx0, fstrand, isMeth, p0, !!isDel0);
+                processCpG(bins, idx1, fstrand, isMeth, p1, !!isDel1);
             }
         }
     }

package/esm/SNPCoverageAdapter/util.d.ts

@@ -1,10 +1,14 @@
-import type { ColorBy, Mismatch, PreBaseCoverageBin, PreBaseCoverageBinSubtypes } from '../shared/types';
+import type { ColorBy, PreBaseCoverageBin, PreBaseCoverageBinSubtypes, PreBinEntry } from '../shared/types.ts';
+import type { StopToken } from '@jbrowse/core/util/stopToken';
 export interface Opts {
     bpPerPx?: number;
     colorBy?: ColorBy;
-    stopToken?: string;
+    stopToken?: StopToken;
+    statsEstimationMode?: boolean;
 }
-export declare function mismatchLen(mismatch: Mismatch): number;
-export declare function isInterbase(type: string): type is "insertion" | "hardclip" | "softclip";
-export declare function inc(bin: PreBaseCoverageBin, strand: -1 | 0 | 1, type: keyof PreBaseCoverageBinSubtypes, field: string): void;
+export declare function mismatchLen(type: number, length: number): number;
+export declare function isInterbase(type: number): boolean;
+export declare function createPreBinEntry(): PreBinEntry;
+export declare function createEmptyBin(): PreBaseCoverageBin;
+export declare function inc(bin: PreBaseCoverageBin, strand: -1 | 0 | 1, type: keyof PreBaseCoverageBinSubtypes, field: string, length?: number, sequence?: string): void;
 export declare function incWithProbabilities(bin: PreBaseCoverageBin, strand: -1 | 0 | 1, type: keyof PreBaseCoverageBinSubtypes, field: string, probability: number): void;

package/esm/SNPCoverageAdapter/util.js

@@ -1,35 +1,55 @@
-export function mismatchLen(mismatch) {
-    return !isInterbase(mismatch.type) ? mismatch.length : 1;
+import { INTERBASE_MASK } from "../shared/forEachMismatchTypes.js";
+export function mismatchLen(type, length) {
+    return ((1 << type) & INTERBASE_MASK) === 0 ? length : 1;
 }
 export function isInterbase(type) {
-    return type === 'softclip' || type === 'hardclip' || type === 'insertion';
+    return ((1 << type) & INTERBASE_MASK) !== 0;
 }
-export function inc(bin, strand, type, field) {
-    let thisBin = bin[type][field];
-    if (thisBin === undefined) {
-        thisBin = bin[type][field] = {
-            entryDepth: 0,
-            probabilities: [],
-            '-1': 0,
-            '0': 0,
-            '1': 0,
-        };
+export function createPreBinEntry() {
+    return {
+        entryDepth: 0,
+        probabilityTotal: 0,
+        probabilityCount: 0,
+        lengthTotal: 0,
+        lengthCount: 0,
+        lengthMin: Infinity,
+        lengthMax: -Infinity,
+        '-1': 0,
+        '0': 0,
+        '1': 0,
+    };
+}
+export function createEmptyBin() {
+    return {
+        depth: 0,
+        readsCounted: 0,
+        snps: {},
+        ref: createPreBinEntry(),
+        mods: {},
+        nonmods: {},
+        delskips: {},
+        noncov: {},
+    };
+}
+export function inc(bin, strand, type, field, length, sequence) {
+    const entry = (bin[type][field] ??= createPreBinEntry());
+    entry.entryDepth++;
+    entry[strand]++;
+    if (length !== undefined) {
+        entry.lengthTotal += length;
+        entry.lengthCount++;
+        entry.lengthMin = Math.min(entry.lengthMin, length);
+        entry.lengthMax = Math.max(entry.lengthMax, length);
+    }
+    if (sequence !== undefined) {
+        entry.sequenceCounts ??= new Map();
+        entry.sequenceCounts.set(sequence, (entry.sequenceCounts.get(sequence) ?? 0) + 1);
     }
-    thisBin.entryDepth++;
-    thisBin[strand]++;
 }
 export function incWithProbabilities(bin, strand, type, field, probability) {
-    let thisBin = bin[type][field];
-    if (thisBin === undefined) {
-        thisBin = bin[type][field] = {
-            entryDepth: 0,
-            probabilities: [],
-            '-1': 0,
-            '0': 0,
-            '1': 0,
-        };
-    }
-    thisBin.entryDepth++;
-    thisBin.probabilities.push(probability);
-    thisBin[strand]++;
+    const entry = (bin[type][field] ??= createPreBinEntry());
+    entry.entryDepth++;
+    entry.probabilityTotal += probability;
+    entry.probabilityCount++;
+    entry[strand]++;
 }

package/esm/SNPCoverageRenderer/SNPCoverageRenderer.d.ts

@@ -1,5 +1,15 @@
-import { WiggleBaseRenderer } from '@jbrowse/plugin-wiggle';
-import type { RenderArgsDeserializedWithFeatures } from './types';
-export default class SNPCoverageRenderer extends WiggleBaseRenderer {
-    draw(ctx: CanvasRenderingContext2D, props: RenderArgsDeserializedWithFeatures): Promise<undefined>;
+import FeatureRendererType, { type RenderArgs, type ResultsDeserialized, type ResultsSerialized } from '@jbrowse/core/pluggableElementTypes/renderers/FeatureRendererType';
+import type { RenderArgsDeserialized } from './types.ts';
+import type { Feature, SimpleFeatureSerialized } from '@jbrowse/core/util';
+interface SNPCoverageResultsSerialized extends ResultsSerialized {
+    skipFeatures?: SimpleFeatureSerialized[];
 }
+export interface SNPCoverageResultsDeserialized extends ResultsDeserialized {
+    skipFeatures: Feature[];
+}
+export default class SNPCoverageRenderer extends FeatureRendererType {
+    supportsSVG: boolean;
+    deserializeResultsInClient(result: SNPCoverageResultsSerialized, args: RenderArgs): SNPCoverageResultsDeserialized;
+    render(renderProps: RenderArgsDeserialized): Promise<import("librpc-web-mod").RpcResult>;
+}
+export {};

package/esm/SNPCoverageRenderer/SNPCoverageRenderer.js

@@ -1,10 +1,31 @@
-import { updateStatus } from '@jbrowse/core/util';
-import { WiggleBaseRenderer } from '@jbrowse/plugin-wiggle';
-export default class SNPCoverageRenderer extends WiggleBaseRenderer {
-    async draw(ctx, props) {
-        const { statusCallback = () => { } } = props;
-        const { makeImage } = await import('./makeImage');
-        await updateStatus('Rendering coverage', statusCallback, () => makeImage(ctx, props));
-        return undefined;
+import { getAdapter } from '@jbrowse/core/data_adapters/dataAdapterCache';
+import FeatureRendererType, {} from '@jbrowse/core/pluggableElementTypes/renderers/FeatureRendererType';
+import SimpleFeature from '@jbrowse/core/util/simpleFeature';
+import { firstValueFrom } from 'rxjs';
+import { toArray } from 'rxjs/operators';
+export default class SNPCoverageRenderer extends FeatureRendererType {
+    supportsSVG = true;
+    deserializeResultsInClient(result, args) {
+        const deserialized = super.deserializeResultsInClient(result, args);
+        const skipFeatures = (result.skipFeatures ?? []).map(f => SimpleFeature.fromJSON(f));
+        for (const skipFeature of skipFeatures) {
+            deserialized.features.set(skipFeature.id(), skipFeature);
+        }
+        return {
+            ...deserialized,
+            skipFeatures,
+        };
+    }
+    async render(renderProps) {
+        const { sessionId, adapterConfig, regions } = renderProps;
+        const pm = this.pluginManager;
+        const { dataAdapter } = await getAdapter(pm, sessionId, adapterConfig);
+        const region = regions[0];
+        const feats = await firstValueFrom(dataAdapter
+            .getFeatures(region, renderProps)
+            .pipe(toArray()));
+        const features = new Map(feats.map(f => [f.id(), f]));
+        const { renderSNPCoverageToCanvas } = await import("./makeImage.js");
+        return renderSNPCoverageToCanvas({ ...renderProps, features });
     }
 }

package/esm/SNPCoverageRenderer/WiggleRendering.d.ts

@@ -0,0 +1,14 @@
+import type { Feature } from '@jbrowse/core/util';
+import type { Region } from '@jbrowse/core/util/types';
+declare const WiggleRendering: (props: {
+    regions: Region[];
+    features: Map<string, Feature>;
+    bpPerPx: number;
+    width: number;
+    height: number;
+    blockKey: string;
+    onMouseLeave?: (event: React.MouseEvent) => void;
+    onMouseMove?: (event: React.MouseEvent, arg?: string) => void;
+    onFeatureClick?: (event: React.MouseEvent, arg?: string) => void;
+}) => import("react/jsx-runtime").JSX.Element;
+export default WiggleRendering;

package/esm/SNPCoverageRenderer/WiggleRendering.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useRef } from 'react';
+import { PrerenderedCanvas } from '@jbrowse/core/ui';
+import { observer } from 'mobx-react';
+const WiggleRendering = observer(function WiggleRendering(props) {
+    const { regions, features, bpPerPx, width, height, onMouseLeave, onMouseMove, onFeatureClick, } = props;
+    const region = regions[0];
+    const ref = useRef(null);
+    function getFeatureUnderMouse(eventClientX) {
+        let offset = 0;
+        if (ref.current) {
+            offset = ref.current.getBoundingClientRect().left;
+        }
+        const offsetX = eventClientX - offset;
+        const px = region.reversed ? width - offsetX : offsetX;
+        const clientBp = region.start + bpPerPx * px;
+        let featureUnderMouse;
+        for (const feature of features.values()) {
+            if (clientBp <= feature.get('end') + bpPerPx &&
+                clientBp >= feature.get('start')) {
+                featureUnderMouse = feature;
+                break;
+            }
+        }
+        return featureUnderMouse;
+    }
+    return (_jsx("div", { ref: ref, "data-testid": "wiggle-rendering-test", onMouseMove: e => onMouseMove?.(e, getFeatureUnderMouse(e.clientX)?.id()), onClick: e => onFeatureClick?.(e, getFeatureUnderMouse(e.clientX)?.id()), onMouseLeave: e => onMouseLeave?.(e), style: {
+            overflow: 'visible',
+            position: 'relative',
+            height,
+        }, children: _jsx(PrerenderedCanvas, { ...props }) }));
+});
+export default WiggleRendering;

package/esm/SNPCoverageRenderer/calculateModificationCounts.d.ts

@@ -0,0 +1,20 @@
+export interface StrandCounts {
+    readonly entryDepth: number;
+    readonly '1': number;
+    readonly '-1': number;
+    readonly '0': number;
+}
+export interface ModificationCountsParams {
+    readonly base: string;
+    readonly isSimplex: boolean;
+    readonly refbase: string | undefined;
+    readonly snps: Readonly<Record<string, Partial<StrandCounts>>>;
+    readonly ref: StrandCounts;
+    readonly score0: number;
+}
+interface ModificationCountsResult {
+    readonly modifiable: number;
+    readonly detectable: number;
+}
+export declare function calculateModificationCounts({ base, isSimplex, refbase, snps, ref, score0, }: ModificationCountsParams): ModificationCountsResult;
+export {};

package/esm/SNPCoverageRenderer/calculateModificationCounts.js

@@ -0,0 +1,22 @@
+const complementBase = {
+    C: 'G',
+    G: 'C',
+    A: 'T',
+    T: 'A',
+};
+export function calculateModificationCounts({ base, isSimplex, refbase, snps, ref, score0, }) {
+    if (base === 'N') {
+        return { modifiable: score0, detectable: score0 };
+    }
+    const cmp = complementBase[base];
+    const baseCount = (snps[base]?.entryDepth || 0) + (refbase === base ? ref.entryDepth : 0);
+    const complCount = (snps[cmp]?.entryDepth || 0) + (refbase === cmp ? ref.entryDepth : 0);
+    const modifiable = baseCount + complCount;
+    const detectable = isSimplex
+        ? (snps[base]?.['1'] || 0) +
+            (snps[cmp]?.['-1'] || 0) +
+            (refbase === base ? ref['1'] : 0) +
+            (refbase === cmp ? ref['-1'] : 0)
+        : modifiable;
+    return { modifiable, detectable };
+}

package/esm/SNPCoverageRenderer/components/SNPCoverageRendering.d.ts

@@ -0,0 +1,18 @@
+import type { ClickMapItem } from '../types.ts';
+import type { Feature } from '@jbrowse/core/util';
+import type { Region } from '@jbrowse/core/util/types';
+import type { BaseLinearDisplayModel } from '@jbrowse/plugin-linear-genome-view';
+declare const SNPCoverageRendering: (props: {
+    regions: Region[];
+    features: Map<string, Feature>;
+    bpPerPx: number;
+    width: number;
+    height: number;
+    blockKey: string;
+    displayModel?: BaseLinearDisplayModel;
+    clickMap?: {
+        flatbush: ArrayBuffer;
+        items: ClickMapItem[];
+    };
+}) => import("react/jsx-runtime").JSX.Element;
+export default SNPCoverageRendering;

package/esm/SNPCoverageRenderer/components/SNPCoverageRendering.js

@@ -0,0 +1,114 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo, useRef, useState } from 'react';
+import { PrerenderedCanvas } from '@jbrowse/core/ui';
+import { getContainingTrack, getContainingView, getSession, isSessionModelWithWidgets, } from '@jbrowse/core/util';
+import Flatbush from '@jbrowse/core/util/flatbush';
+import { observer } from 'mobx-react';
+import { clickMapItemToFeatureData } from "../types.js";
+function getItemDataJson(item, refName) {
+    if (!item) {
+        return undefined;
+    }
+    return JSON.stringify({ item, refName });
+}
+function getFeatureRefName(features) {
+    for (const feature of features.values()) {
+        const refName = feature.get('refName');
+        if (refName) {
+            return refName;
+        }
+    }
+    return undefined;
+}
+const SNPCoverageRendering = observer(function SNPCoverageRendering(props) {
+    const { regions, features, bpPerPx, width, height, clickMap, displayModel } = props;
+    const region = regions[0];
+    const ref = useRef(null);
+    const [isOverIndicator, setIsOverIndicator] = useState(false);
+    const flatbush = useMemo(() => (clickMap?.flatbush ? Flatbush.from(clickMap.flatbush) : undefined), [clickMap?.flatbush]);
+    const items = clickMap?.items;
+    function getFeatureUnderMouse(eventClientX) {
+        let offset = 0;
+        if (ref.current) {
+            offset = ref.current.getBoundingClientRect().left;
+        }
+        const offsetX = eventClientX - offset;
+        const px = region.reversed ? width - offsetX : offsetX;
+        const clientBp = region.start + bpPerPx * px;
+        let featureUnderMouse;
+        for (const feature of features.values()) {
+            if (clientBp <= feature.get('end') + bpPerPx &&
+                clientBp >= feature.get('start')) {
+                featureUnderMouse = feature;
+                break;
+            }
+        }
+        return featureUnderMouse;
+    }
+    function getInterbaseItemUnderMouse(clientX, clientY) {
+        if (!flatbush || !items || !ref.current) {
+            return undefined;
+        }
+        const rect = ref.current.getBoundingClientRect();
+        const offsetX = clientX - rect.left;
+        const offsetY = clientY - rect.top;
+        const search = flatbush.search(offsetX, offsetY, offsetX + 1.5, offsetY + 1.5);
+        if (search.length === 0) {
+            return undefined;
+        }
+        if (search.length === 1) {
+            return items[search[0]];
+        }
+        const sorted = search
+            .map(idx => items[idx])
+            .sort((a, b) => b.count / b.total - a.count / a.total);
+        return sorted[0];
+    }
+    return (_jsx("div", { ref: ref, "data-testid": "snpcoverage-rendering-test", onMouseMove: e => {
+            const item = getInterbaseItemUnderMouse(e.clientX, e.clientY);
+            const itemData = getItemDataJson(item, getFeatureRefName(features) ?? region.refName);
+            setIsOverIndicator(!!item);
+            if (itemData) {
+                displayModel?.setFeatureIdUnderMouse(undefined);
+                displayModel?.setMouseoverExtraInformation(itemData);
+            }
+            else {
+                displayModel?.setFeatureIdUnderMouse(getFeatureUnderMouse(e.clientX)?.id());
+                displayModel?.setMouseoverExtraInformation(undefined);
+            }
+        }, onClick: e => {
+            const item = getInterbaseItemUnderMouse(e.clientX, e.clientY);
+            if (item && displayModel) {
+                const session = getSession(displayModel);
+                const view = getContainingView(displayModel);
+                const featureData = clickMapItemToFeatureData(item, getFeatureRefName(features) ?? region.refName);
+                if (isSessionModelWithWidgets(session)) {
+                    const featureWidget = session.addWidget('BaseFeatureWidget', 'baseFeature', {
+                        featureData,
+                        view,
+                        track: getContainingTrack(displayModel),
+                    });
+                    session.showWidget(featureWidget);
+                }
+            }
+            else {
+                const featureId = getFeatureUnderMouse(e.clientX)?.id();
+                if (featureId) {
+                    displayModel?.selectFeatureById(featureId).catch((e) => {
+                        console.error(e);
+                        getSession(displayModel).notifyError(`${e}`, e);
+                    });
+                }
+            }
+        }, onMouseLeave: () => {
+            setIsOverIndicator(false);
+            displayModel?.setFeatureIdUnderMouse(undefined);
+            displayModel?.setMouseoverExtraInformation(undefined);
+        }, style: {
+            overflow: 'visible',
+            position: 'relative',
+            height,
+            cursor: isOverIndicator ? 'pointer' : undefined,
+        }, children: _jsx(PrerenderedCanvas, { ...props }) }));
+});
+export default SNPCoverageRendering;

package/esm/SNPCoverageRenderer/configSchema.d.ts

@@ -1,4 +1,4 @@
-declare const SNPCoverageRenderer: import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaType<{
+declare const SNPCoverageRenderer: import("node_modules/@jbrowse/core/src/configuration/configurationSchema").ConfigurationSchemaType<{
     clipColor: {
         type: string;
         description: string;
@@ -29,5 +29,5 @@ declare const SNPCoverageRenderer: import("@jbrowse/core/configuration/configura
         description: string;
         defaultValue: string;
     };
-}, import("@jbrowse/core/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
+}, import("node_modules/@jbrowse/core/src/configuration/configurationSchema").ConfigurationSchemaOptions<undefined, undefined>>;
 export default SNPCoverageRenderer;

package/esm/SNPCoverageRenderer/index.js

@@ -1,10 +1,10 @@
-import { WiggleRendering } from '@jbrowse/plugin-wiggle';
-import SNPCoverageRenderer from './SNPCoverageRenderer';
-import configSchema from './configSchema';
+import { lazy } from 'react';
+import SNPCoverageRenderer from "./SNPCoverageRenderer.js";
+import configSchema from "./configSchema.js";
 export default function register(pluginManager) {
     pluginManager.addRendererType(() => new SNPCoverageRenderer({
         name: 'SNPCoverageRenderer',
-        ReactComponent: WiggleRendering,
+        ReactComponent: lazy(() => import("./components/SNPCoverageRendering.js")),
         configSchema,
         pluginManager,
     }));

package/esm/SNPCoverageRenderer/makeImage.d.ts

@@ -1,2 +1,2 @@
-import type { RenderArgsDeserializedWithFeatures } from './types';
-export declare function makeImage(ctx: CanvasRenderingContext2D, props: RenderArgsDeserializedWithFeatures): Promise<void>;
+import type { RenderArgsDeserializedWithFeatures } from './types.ts';
+export declare function renderSNPCoverageToCanvas(props: RenderArgsDeserializedWithFeatures): Promise<import("librpc-web-mod").RpcResult>;