@jbrowse/wiggle-core 4.3.0

package/esm/ScoreScaleMixin.d.ts

@@ -0,0 +1,105 @@
+import type { ScoreAxisConfigModel } from './scoreAxisConfigSchemaFields.ts';
+/**
+ * The whole of what `ScoreScaleMixin` needs a composing display to be. Exported
+ * because it is the mixin's contract and `ScoreScaleMixin.test.ts` pins it:
+ * widen it and the `@ts-expect-error`s there go unused.
+ */
+export interface ScoreScaleHost {
+    configuration: ScoreAxisConfigModel;
+}
+/**
+ * #stateModel ScoreScaleMixin
+ * #category display
+ * #crossCuttingMixin Score axis. Nothing — the config slots. Brings `scaleType` / `autoscaleType` / `minScore` / `maxScore` / `*Bound` / `numStdDev` and their setters, i.e. the whole `ScoreScaleModel` interface the shared score menu and `SetMinMaxDialog` consume
+ *
+ * The score axis every quantitative display shares: which scale, how to
+ * autoscale it, and the manual min/max bounds. This is the runtime half of
+ * {@link ScoreScaleModel} in `scoreMenuItems.ts` — that interface is what the
+ * shared Score menu, the autoscale/scale submenus and `SetMinMaxDialog` consume,
+ * and it was already the canonical contract while two displays hand-wrote
+ * identical implementations of it (`WiggleScoreConfigMixin`, and the alignments
+ * coverage band). Composing this is now how a display satisfies it, so a new
+ * score display cannot satisfy it *partially*.
+ *
+ * Deliberately just the axis. Colors, `resolution`, cross-hatches and the
+ * autoscale *computation* stay in `WiggleScoreConfigMixin` / `WiggleCommonMixin`
+ * — the alignments coverage band shares this axis but none of the rest.
+ *
+ * `minScore`/`maxScore` are the **raw** slot values with their
+ * `Number.MIN_VALUE`/`Number.MAX_VALUE` "unset" sentinels intact, because that
+ * is what the dialog round-trips; `minScoreBound`/`maxScoreBound` are the
+ * resolved bounds, where `undefined` means "autoscale this end". Every consumer
+ * that computes a domain reads the `*Bound` pair.
+ */
+export declare function ScoreScaleMixin(): import("@jbrowse/mobx-state-tree").IModelType<{}, {
+    /**
+     * #getter
+     */
+    readonly scaleType: string;
+    /**
+     * #getter
+     */
+    readonly autoscaleType: string;
+    /**
+     * #getter
+     */
+    readonly numStdDev: number;
+    /**
+     * #getter
+     * Raw slot value, sentinel intact — see the class comment.
+     */
+    readonly minScore: number;
+    /**
+     * #getter
+     * Raw slot value, sentinel intact — see the class comment.
+     */
+    readonly maxScore: number;
+    /**
+     * #getter
+     * Overridable hook: what each end of the domain falls back to where the
+     * config leaves its bound unset. `[undefined, undefined]` — the default —
+     * means autoscale both ends, which is right for a track whose scores have
+     * no absolute meaning (a bigwig's units are its own).
+     *
+     * A display whose scores are bounded *by construction* overrides it, so
+     * the axis stops being a function of what happens to be on screen: GC
+     * content is a fraction, so 0 and 1 are its real limits and mean the same
+     * thing at every locus. Autoscaled, the same GC value drew at different
+     * heights depending on where the user had panned, and the track could not
+     * be read across loci.
+     *
+     * A hook rather than a config default because the answer can depend on
+     * display state — GC's does, on `gcMode` — and rather than each display
+     * re-resolving the sentinels below, which is the one thing that must not
+     * be duplicated: config bounds still win, precisely because they are
+     * checked before this is consulted.
+     */
+    readonly defaultScoreDomain: [number | undefined, number | undefined];
+    /**
+     * #getter
+     * Resolved lower bound; `undefined` means autoscale this end.
+     */
+    readonly minScoreBound: number | undefined;
+    /**
+     * #getter
+     * Resolved upper bound; `undefined` means autoscale this end.
+     */
+    readonly maxScoreBound: number | undefined;
+} & {
+    /**
+     * #action
+     */
+    setScaleType(scaleType: string): void;
+    /**
+     * #action
+     */
+    setAutoscale(val?: string): void;
+    /**
+     * #action
+     */
+    setMinScore(val?: number): void;
+    /**
+     * #action
+     */
+    setMaxScore(val?: number): void;
+}, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;

package/esm/ScoreScaleMixin.js

@@ -0,0 +1,136 @@
+import { getConf, setConf } from '@jbrowse/core/configuration';
+import { types } from '@jbrowse/mobx-state-tree';
+// The mixin composes onto a display that declares this, not the other way
+// round, so its own `self` isn't typed with it. Cast once, narrowed to the
+// field table beside it rather than `AnyConfigurationModel`, which is what keeps
+// the slot names below checked.
+const confNode = (self) => self;
+/**
+ * #stateModel ScoreScaleMixin
+ * #category display
+ * #crossCuttingMixin Score axis. Nothing — the config slots. Brings `scaleType` / `autoscaleType` / `minScore` / `maxScore` / `*Bound` / `numStdDev` and their setters, i.e. the whole `ScoreScaleModel` interface the shared score menu and `SetMinMaxDialog` consume
+ *
+ * The score axis every quantitative display shares: which scale, how to
+ * autoscale it, and the manual min/max bounds. This is the runtime half of
+ * {@link ScoreScaleModel} in `scoreMenuItems.ts` — that interface is what the
+ * shared Score menu, the autoscale/scale submenus and `SetMinMaxDialog` consume,
+ * and it was already the canonical contract while two displays hand-wrote
+ * identical implementations of it (`WiggleScoreConfigMixin`, and the alignments
+ * coverage band). Composing this is now how a display satisfies it, so a new
+ * score display cannot satisfy it *partially*.
+ *
+ * Deliberately just the axis. Colors, `resolution`, cross-hatches and the
+ * autoscale *computation* stay in `WiggleScoreConfigMixin` / `WiggleCommonMixin`
+ * — the alignments coverage band shares this axis but none of the rest.
+ *
+ * `minScore`/`maxScore` are the **raw** slot values with their
+ * `Number.MIN_VALUE`/`Number.MAX_VALUE` "unset" sentinels intact, because that
+ * is what the dialog round-trips; `minScoreBound`/`maxScoreBound` are the
+ * resolved bounds, where `undefined` means "autoscale this end". Every consumer
+ * that computes a domain reads the `*Bound` pair.
+ */
+export function ScoreScaleMixin() {
+    return types
+        .model('ScoreScaleMixin', {})
+        .views(self => ({
+        /**
+         * #getter
+         */
+        get scaleType() {
+            return getConf(confNode(self), 'scaleType');
+        },
+        /**
+         * #getter
+         */
+        get autoscaleType() {
+            return getConf(confNode(self), 'autoscale');
+        },
+        /**
+         * #getter
+         */
+        get numStdDev() {
+            return getConf(confNode(self), 'numStdDev');
+        },
+        /**
+         * #getter
+         * Raw slot value, sentinel intact — see the class comment.
+         */
+        get minScore() {
+            return getConf(confNode(self), 'minScore');
+        },
+        /**
+         * #getter
+         * Raw slot value, sentinel intact — see the class comment.
+         */
+        get maxScore() {
+            return getConf(confNode(self), 'maxScore');
+        },
+        /**
+         * #getter
+         * Overridable hook: what each end of the domain falls back to where the
+         * config leaves its bound unset. `[undefined, undefined]` — the default —
+         * means autoscale both ends, which is right for a track whose scores have
+         * no absolute meaning (a bigwig's units are its own).
+         *
+         * A display whose scores are bounded *by construction* overrides it, so
+         * the axis stops being a function of what happens to be on screen: GC
+         * content is a fraction, so 0 and 1 are its real limits and mean the same
+         * thing at every locus. Autoscaled, the same GC value drew at different
+         * heights depending on where the user had panned, and the track could not
+         * be read across loci.
+         *
+         * A hook rather than a config default because the answer can depend on
+         * display state — GC's does, on `gcMode` — and rather than each display
+         * re-resolving the sentinels below, which is the one thing that must not
+         * be duplicated: config bounds still win, precisely because they are
+         * checked before this is consulted.
+         */
+        get defaultScoreDomain() {
+            return [undefined, undefined];
+        },
+        /**
+         * #getter
+         * Resolved lower bound; `undefined` means autoscale this end.
+         */
+        get minScoreBound() {
+            return this.minScore === Number.MIN_VALUE
+                ? this.defaultScoreDomain[0]
+                : this.minScore;
+        },
+        /**
+         * #getter
+         * Resolved upper bound; `undefined` means autoscale this end.
+         */
+        get maxScoreBound() {
+            return this.maxScore === Number.MAX_VALUE
+                ? this.defaultScoreDomain[1]
+                : this.maxScore;
+        },
+    }))
+        .actions(self => ({
+        /**
+         * #action
+         */
+        setScaleType(scaleType) {
+            setConf(confNode(self), 'scaleType', scaleType);
+        },
+        /**
+         * #action
+         */
+        setAutoscale(val) {
+            setConf(confNode(self), 'autoscale', val);
+        },
+        /**
+         * #action
+         */
+        setMinScore(val) {
+            setConf(confNode(self), 'minScore', val);
+        },
+        /**
+         * #action
+         */
+        setMaxScore(val) {
+            setConf(confNode(self), 'maxScore', val);
+        },
+    }));
+}

package/esm/SetMinMaxDialog.d.ts

@@ -0,0 +1,11 @@
+declare const _default: (props: {
+    model: {
+        minScore: number;
+        maxScore: number;
+        scaleType: string;
+        setMinScore: (arg?: number) => void;
+        setMaxScore: (arg?: number) => void;
+    };
+    handleClose: () => void;
+}) => import("react").JSX.Element;
+export default _default;

package/esm/SetMinMaxDialog.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { NumberTextField, SubmitDialog } from '@jbrowse/core/ui';
+import { Typography } from '@mui/material';
+import { observer } from 'mobx-react';
+export default observer(function SetMinMaxDialog(props) {
+    const { model, handleClose } = props;
+    const { minScore, maxScore, scaleType } = model;
+    const [min, setMin] = useState(minScore === Number.MIN_VALUE ? undefined : minScore);
+    const [max, setMax] = useState(maxScore === Number.MAX_VALUE ? undefined : maxScore);
+    const rangeOk = min === undefined || max === undefined || max > min;
+    const logOk = !(scaleType === 'log' && min !== undefined && min <= 0);
+    return (_jsxs(SubmitDialog, { open: true, title: "Set min/max score for track", submitDisabled: !rangeOk || !logOk, onCancel: handleClose, onSubmit: () => {
+            model.setMinScore(min);
+            model.setMaxScore(max);
+            handleClose();
+        }, children: [_jsx(Typography, { children: "Enter min/max score: " }), !rangeOk ? (_jsx(Typography, { color: "error", children: "Max must be greater than min" })) : null, !logOk ? (_jsx(Typography, { color: "error", children: "Min score should be greater than 0 for log scale" })) : null, _jsx(NumberTextField, { defaultValue: min, onValueChange: setMin, placeholder: "Enter min score" }), _jsx(NumberTextField, { defaultValue: max, onValueChange: setMax, placeholder: "Enter max score" })] }));
+});

package/esm/YScaleBar.d.ts

@@ -0,0 +1,6 @@
+import type { YScaleTicks } from './yScaleTicks.ts';
+export default function YScaleBar({ ticks, orientation, insetLabels, }: {
+    ticks: YScaleTicks | undefined;
+    orientation?: 'left' | 'right';
+    insetLabels?: boolean;
+}): import("react").JSX.Element | null;

package/esm/YScaleBar.js

@@ -0,0 +1,46 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { usePalette } from '@jbrowse/core/ui/PaletteContext';
+import { clampStrokeInsideAxis } from './yScaleTicks.js';
+// Not an `observer`, and deliberately: there is nothing here to observe. Every
+// caller already reads `model.ticks` inside its own observer and hands the
+// resolved plain object down, and `usePalette` is a React context, not MobX.
+// Wrapping it anyway allocated a Reaction per instance — multi-wiggle renders
+// one per sample row, on screen as well as in export — and, per CLAUDE.md, put
+// the component out of `babel-plugin-react-compiler`'s reach, so it got neither
+// the MobX tracking it doesn't need nor the memoization it does. Its sibling
+// `CrossHatchLines`, consuming the same ticks, is already plain.
+// Half the vertical space a 10px label needs, halo included: digits reach about
+// 3.6px above the centered baseline and the 2.5px-wide background stroke another
+// 1.25px past that.
+const LABEL_HALF_HEIGHT_PX = 5;
+export default function YScaleBar({ ticks, orientation, insetLabels, }) {
+    const palette = usePalette();
+    if (!ticks) {
+        return null;
+    }
+    const { items, yTop, yBottom } = ticks;
+    const bg = palette.background.default;
+    const fg = palette.text.primary;
+    const isLeft = orientation !== 'right';
+    const k = isLeft ? -1 : 1;
+    const tickLength = 6;
+    // Crispen to `y + 0.5` so each 1px stroke fills one pixel instead of
+    // straddling two, then clamp, which only bites at the bottom edge: there the
+    // stroke goes on the last pixel inside the box rather than the first one
+    // below it.
+    const strokeY = (y) => clampStrokeInsideAxis(y + 0.5, yBottom);
+    // The tick keeps the group transform; only the text moves off it, and only
+    // under `insetLabels` within half a label of an end. A tick is where the data
+    // is, so it never moves — the label is then drawn against the tick rather than
+    // across it, which is what any axis does at the edge of its own frame.
+    // `undefined` rather than 0 for the labels that don't move, so the markup this
+    // emits is unchanged wherever the inset doesn't apply.
+    const labelDy = (sy) => {
+        if (!insetLabels) {
+            return undefined;
+        }
+        const inset = Math.min(Math.max(sy, yTop + LABEL_HALF_HEIGHT_PX), yBottom - LABEL_HALF_HEIGHT_PX);
+        return inset === sy ? undefined : inset - sy;
+    };
+    return (_jsxs("g", { fontSize: 10, textAnchor: isLeft ? 'end' : 'start', stroke: fg, strokeWidth: 1, children: [_jsx("path", { fill: "none", d: `M${k * tickLength} ${strokeY(yTop)}H0.5V${strokeY(yBottom)}H${k * tickLength}` }), items.map(({ value, y, label }) => (_jsxs("g", { transform: `translate(0,${strokeY(y)})`, children: [_jsx("line", { x2: k * tickLength }), _jsx("text", { stroke: bg, strokeWidth: 2.5, paintOrder: "stroke", fill: fg, y: labelDy(strokeY(y)), dy: "0.32em", x: k * 9, children: label ?? value })] }, `${value}-${y}`)))] }));
+}

package/esm/YScaleBarOverlay.d.ts

@@ -0,0 +1,6 @@
+import type { YScaleTicks } from './yScaleTicks.ts';
+export default function YScaleBarOverlay({ ticks, height, width, }: {
+    ticks: YScaleTicks;
+    height: number;
+    width: number;
+}): import("react").JSX.Element;

package/esm/YScaleBarOverlay.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import YScaleBar from './YScaleBar.js';
+import { ONSCREEN_AXIS_LEFT_PX } from './constants.js';
+// Y-axis tick labels positioned absolutely, indented from the track's left edge
+// so a right-oriented axis reads inside the plot. The SVG export instead anchors
+// a left-oriented axis at the content edge, putting the labels in the export
+// margin — see WiggleFamilySvgFrame.
+//
+// `width` is the track's, not a fixed strip: an <svg> clips to its own box, and
+// the hardcoded 70px this used to carry silently truncated any label past ~11
+// characters. Not hypothetical on a log axis — a domain under 1 nices to
+// negative powers of two, so `0.0009765625` is an ordinary tick on a
+// mappability track and the labels grow exactly where the numbers get small.
+// The track's own right edge is the real boundary.
+export default function YScaleBarOverlay({ ticks, height, width, }) {
+    return (_jsx("svg", { style: {
+            position: 'absolute',
+            top: 0,
+            left: ONSCREEN_AXIS_LEFT_PX,
+            pointerEvents: 'none',
+            height,
+            width: Math.max(0, width - ONSCREEN_AXIS_LEFT_PX),
+        }, children: _jsx(YScaleBar, { ticks: ticks, orientation: "right" }) }));
+}

package/esm/autoscale.d.ts

@@ -0,0 +1,55 @@
+export declare const DEFAULT_AUTOSCALE_OPTIONS: [string, string][];
+export interface FeatureArrays {
+    featurePositions: Uint32Array;
+    featureScores: Float32Array;
+    featureMinScores: Float32Array;
+    featureMaxScores: Float32Array;
+    numFeatures: number;
+    hasSummaryScores: boolean;
+}
+export interface Dataset {
+    data: FeatureArrays;
+    visStart?: number;
+    visEnd?: number;
+}
+export interface ScoreStats {
+    scoreMin: number;
+    scoreMax: number;
+    scoreMean: number;
+    scoreStdDev: number;
+}
+/**
+ * #api
+ * Per-feature scalar score array for a summary mode: the min/max summary array
+ * for `'min'`/`'max'`, otherwise the average score.
+ */
+export declare function getEffectiveScores(data: {
+    featureScores: Float32Array;
+    featureMinScores: Float32Array;
+    featureMaxScores: Float32Array;
+}, summaryScoreMode: string): Float32Array<ArrayBufferLike>;
+export declare function computeScoreStats(summaryScoreMode: string, datasets: Dataset[]): ScoreStats | undefined;
+/**
+ * #api
+ * Converts score stats into a `[min, max]` domain, applying std-dev
+ * expansion for the `localsd` autoscale type.
+ */
+export declare function domainFromStats(stats: ScoreStats, autoscaleType: string, numStdDev: number): [number, number];
+export declare function autoscaleDomainFromStats({ stats, autoscaleType, summaryScoreMode, numStdDev, numQuantile, visibleEntries, }: {
+    stats: ScoreStats;
+    autoscaleType: string;
+    summaryScoreMode: string;
+    numStdDev: number;
+    numQuantile?: number;
+    visibleEntries: Dataset[];
+}): [number, number];
+/**
+ * #api
+ * Computes a score domain from the visible feature arrays for the `local` /
+ * `localsd` / `localpercentile` autoscale types.
+ */
+export declare function computeAutoscaleDomain(autoscaleType: string, summaryScoreMode: string, numStdDev: number, visibleEntries: {
+    data: FeatureArrays;
+    visStart: number;
+    visEnd: number;
+}[], numQuantile?: number): [number, number] | undefined;

package/esm/autoscale.js

@@ -0,0 +1,252 @@
+// Default autoscale modes shared by wiggle / multi-wiggle. The alignments
+// coverage band exposes only a subset and a dynamic σ value, so it passes its
+// own option list.
+//
+// Here rather than beside the menu that renders it because a `[value, label]`
+// table is the one thing a menu holds that something outside the app needs to
+// read: the website's figure recipes name these labels in a click path, and a
+// module importing React or a lazy .tsx cannot be loaded by the node script
+// that builds them. A leaf module makes the recipe import the label instead of
+// retyping it, which is the difference between a copy that drifts and one that
+// cannot.
+export const DEFAULT_AUTOSCALE_OPTIONS = [
+    ['local', 'Local'],
+    ['localpercentile', 'Local (99th percentile)'],
+    ['localsd', 'Local ± 3σ'],
+];
+/**
+ * #api
+ * Per-feature scalar score array for a summary mode: the min/max summary array
+ * for `'min'`/`'max'`, otherwise the average score.
+ */
+export function getEffectiveScores(data, summaryScoreMode) {
+    return summaryScoreMode === 'min'
+        ? data.featureMinScores
+        : summaryScoreMode === 'max'
+            ? data.featureMaxScores
+            : data.featureScores;
+}
+// Half-open overlap test between a feature span and the visible window.
+function overlaps(fStart, fEnd, visStart, visEnd) {
+    return fEnd > visStart && fStart < visEnd;
+}
+// Which per-feature array each end of the domain comes from. Whiskers spreads
+// the two ends across the min/max summary arrays; every other mode draws both
+// from a single scalar. One table because `computeScoreStats` and the
+// percentile histogram have to agree — a domain whose extent and whose clipped
+// bound were measured off different arrays is a domain that clips its own data.
+function boundArrays(summaryScoreMode) {
+    const useWhiskers = summaryScoreMode === 'whiskers';
+    return {
+        low: (data) => useWhiskers
+            ? data.featureMinScores
+            : getEffectiveScores(data, summaryScoreMode),
+        high: (data) => useWhiskers
+            ? data.featureMaxScores
+            : getEffectiveScores(data, summaryScoreMode),
+    };
+}
+// Bin count for the approximate percentile histogram. 1024 bins gives ~0.1%
+// resolution on the domain, which is finer than any autoscale needs and keeps
+// the second pass O(n) with a fixed, trivial allocation.
+const NUM_HISTOGRAM_BINS = 1024;
+// First index whose feature STARTS at or after `bp`. `featurePositions` is
+// sorted by start — the same property `findFeatureAtBp` binary-searches on.
+function lowerBoundByStart(featurePositions, numFeatures, bp) {
+    let lo = 0;
+    let hi = numFeatures;
+    while (lo < hi) {
+        const mid = (lo + hi) >> 1;
+        if (featurePositions[mid * 2] >= bp) {
+            hi = mid;
+        }
+        else {
+            lo = mid + 1;
+        }
+    }
+    return lo;
+}
+/**
+ * The half-open index range that can overlap `[visStart, visEnd)`.
+ *
+ * A fetch covers `bufferedVisibleRegions` — the viewport plus half a screen on
+ * each side — so roughly half of what these passes walk is off-screen, and
+ * `localpercentile` (the default) walks it two or three times over. Both bounds
+ * come from a binary search on the sorted starts instead.
+ *
+ * The upper bound needs nothing but that sortedness: a feature starting at or
+ * after `visEnd` cannot reach back into the window. The lower bound also leans
+ * on wiggle features being non-overlapping bins — bigWig summary levels and
+ * bedGraph both are — walking back over any run that does reach in. The callers
+ * still test `overlaps` per feature inside the range, so a dataset that broke
+ * that assumption could only lose a long early feature, never gain one.
+ */
+function visibleIndexRange(featurePositions, numFeatures, visStart, visEnd) {
+    if (visStart === undefined || visEnd === undefined) {
+        return { from: 0, to: numFeatures };
+    }
+    const to = lowerBoundByStart(featurePositions, numFeatures, visEnd);
+    let from = lowerBoundByStart(featurePositions, numFeatures, visStart);
+    while (from > 0 && featurePositions[(from - 1) * 2 + 1] > visStart) {
+        from--;
+    }
+    return { from, to };
+}
+// Min/max/mean/stddev of the visible features for a summary mode, in one pass.
+// Exported (not #api — internal plumbing shared with the wiggle displays) so a
+// caller needing both a domain and the raw extent computes the stats once and
+// feeds them to autoscaleDomainFromStats instead of walking the arrays twice.
+export function computeScoreStats(summaryScoreMode, datasets) {
+    const { low, high } = boundArrays(summaryScoreMode);
+    let min = Infinity;
+    let max = -Infinity;
+    let sum = 0;
+    let sumSq = 0;
+    let count = 0;
+    for (const { data, visStart, visEnd } of datasets) {
+        const { featureScores, featurePositions, numFeatures } = data;
+        // Selecting the arrays once per dataset keeps the mode check out of the
+        // per-feature loop.
+        const minScores = low(data);
+        const maxScores = high(data);
+        const { from, to } = visibleIndexRange(featurePositions, numFeatures, visStart, visEnd);
+        for (let i = from; i < to; i++) {
+            if (visStart !== undefined &&
+                visEnd !== undefined &&
+                !overlaps(featurePositions[i * 2], featurePositions[i * 2 + 1], visStart, visEnd)) {
+                continue;
+            }
+            min = Math.min(min, minScores[i]);
+            max = Math.max(max, maxScores[i]);
+            // Mean/stddev always use featureScores (the average) regardless of
+            // summaryScoreMode; min/max for the domain bounds come from the mode-
+            // selected arrays above. Intentional: sd-based autoscale centers on the
+            // average-value distribution even in whiskers/min/max summary modes.
+            const avg = featureScores[i];
+            sum += avg;
+            sumSq += avg * avg;
+            count++;
+        }
+    }
+    if (count === 0 || !Number.isFinite(min) || !Number.isFinite(max)) {
+        return undefined;
+    }
+    const mean = sum / count;
+    const stdDev = Math.sqrt(Math.max(0, sumSq / count - mean * mean));
+    return { scoreMin: min, scoreMax: max, scoreMean: mean, scoreStdDev: stdDev };
+}
+/**
+ * #api
+ * Converts score stats into a `[min, max]` domain, applying std-dev
+ * expansion for the `localsd` autoscale type.
+ */
+export function domainFromStats(stats, autoscaleType, numStdDev) {
+    if (autoscaleType === 'localsd') {
+        const { scoreMean, scoreStdDev, scoreMin } = stats;
+        return [
+            scoreMin >= 0 ? 0 : scoreMean - numStdDev * scoreStdDev,
+            scoreMean + numStdDev * scoreStdDev,
+        ];
+    }
+    return [stats.scoreMin, stats.scoreMax];
+}
+// The `quantile`-th percentile magnitude of one signed side of the score
+// distribution: features are filtered to a single sign (`positiveSide`), their
+// magnitudes binned over `[0, maxMag]`, and the magnitude below which `quantile`
+// of that side's mass falls is returned — clipping the outermost `1 - quantile`
+// as outliers. Returns 0 when the side is empty. A fixed histogram keeps this an
+// O(n) pass with no sort, approximate to ~1/NUM_HISTOGRAM_BINS of maxMag, far
+// finer than the display needs.
+function sideMagnitudePercentile(datasets, scoresFor, positiveSide, maxMag, quantile) {
+    if (maxMag <= 0) {
+        return 0;
+    }
+    const bins = new Int32Array(NUM_HISTOGRAM_BINS);
+    const scale = NUM_HISTOGRAM_BINS / maxMag;
+    let count = 0;
+    for (const { data, visStart, visEnd } of datasets) {
+        const { featurePositions, numFeatures } = data;
+        const scores = scoresFor(data);
+        const { from, to } = visibleIndexRange(featurePositions, numFeatures, visStart, visEnd);
+        for (let i = from; i < to; i++) {
+            if (visStart !== undefined &&
+                visEnd !== undefined &&
+                !overlaps(featurePositions[i * 2], featurePositions[i * 2 + 1], visStart, visEnd)) {
+                continue;
+            }
+            const mag = positiveSide ? scores[i] : -scores[i];
+            if (mag > 0) {
+                const bin = Math.min(NUM_HISTOGRAM_BINS - 1, Math.floor(mag * scale));
+                bins[bin]++;
+                count++;
+            }
+        }
+    }
+    if (count === 0) {
+        return 0;
+    }
+    const target = quantile * count;
+    let cumulative = 0;
+    for (let bin = 0; bin < NUM_HISTOGRAM_BINS; bin++) {
+        cumulative += bins[bin];
+        // +1 so the target bin is included rather than clipped.
+        if (cumulative >= target) {
+            return ((bin + 1) / NUM_HISTOGRAM_BINS) * maxMag;
+        }
+    }
+    return maxMag;
+}
+// Builds a `[low, high]` domain by clipping each side of the score distribution
+// to its central `quantile` fraction (e.g. 0.99 → clip the outermost 1% of each
+// sign). Unlike localsd it makes no normality assumption, so it stays robust on
+// the heavily skewed score distributions typical of coverage/wiggle data.
+//
+// The two signs are clipped INDEPENDENTLY, anchored at 0. A single combined
+// percentile spends its whole budget on the dominant side, so on strongly
+// one-sided signed data (e.g. phyloP: mostly-positive conservation with a
+// sparse, small negative tail) the minority tail's 1st percentile lands at or
+// above 0 and the negative extent collapses to a flat band. Measuring each
+// side's percentile from 0 outward keeps a small-but-real opposite tail visible.
+function percentileDomainFromHistogram(stats, summaryScoreMode, quantile, datasets) {
+    const { scoreMin, scoreMax } = stats;
+    if (scoreMax - scoreMin <= 0) {
+        return [scoreMin, scoreMax];
+    }
+    const arrays = boundArrays(summaryScoreMode);
+    const high = scoreMax > 0
+        ? sideMagnitudePercentile(datasets, arrays.high, true, scoreMax, quantile)
+        : 0;
+    const negExtent = scoreMin < 0
+        ? sideMagnitudePercentile(datasets, arrays.low, false, -scoreMin, quantile)
+        : 0;
+    // Anchor the low bound at 0 for all-positive data (matching localsd's origin
+    // convention); otherwise extend it to the negative side's clipped extent.
+    return [scoreMin < 0 ? -negExtent : 0, high];
+}
+// Turns already-computed stats into the displayed domain for the `local` /
+// `localsd` / `localpercentile` autoscale types. `localpercentile` re-walks the
+// entries to build its histogram; the other types read the stats alone.
+// computeAutoscaleDomain (#api) is the one-shot form.
+export function autoscaleDomainFromStats({ stats, autoscaleType, summaryScoreMode, numStdDev, numQuantile = 0.99, visibleEntries, }) {
+    return autoscaleType === 'localpercentile'
+        ? percentileDomainFromHistogram(stats, summaryScoreMode, numQuantile, visibleEntries)
+        : domainFromStats(stats, autoscaleType, numStdDev);
+}
+/**
+ * #api
+ * Computes a score domain from the visible feature arrays for the `local` /
+ * `localsd` / `localpercentile` autoscale types.
+ */
+export function computeAutoscaleDomain(autoscaleType, summaryScoreMode, numStdDev, visibleEntries, numQuantile = 0.99) {
+    const stats = computeScoreStats(summaryScoreMode, visibleEntries);
+    return stats
+        ? autoscaleDomainFromStats({
+            stats,
+            autoscaleType,
+            summaryScoreMode,
+            numStdDev,
+            numQuantile,
+            visibleEntries,
+        })
+        : undefined;
+}