@jbrowse/wiggle-core 4.3.0 → 5.0.0-beta.10

package/esm/ScoreScaleMixin.js

@@ -1,110 +1,159 @@
-import { getConf, setConf } from '@jbrowse/core/configuration';
-import { types } from '@jbrowse/mobx-state-tree';
+import { getConf, getSlotDefinition, readConfObject, setConf, } from '@jbrowse/core/configuration';
+import { noticeLines, scaleEndProblems } from '@jbrowse/core/util/colorScale';
+import { clipQuantileOf } from '@jbrowse/core/util/quantileExtent';
+import { rulesABand } from '@jbrowse/display-ui/axisPlacement';
+import { ScoreAxisMixin } from './ScoreAxisMixin.js';
 // 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.
+// factory's schema rather than `AnyConfigurationModel`, which is what keeps the
+// member 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
+ * #crossCuttingMixin Value scale, written in `scales.y`. `valueScaleSchema` / `scalesSchema`. Brings `ScoreAxisMixin` plus `scaleType` / `scaleZero` / `domainQuantile` / `clipQuantile` / `symlogConstant` / `manual*` 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*.
+ * The value scale of every quantitative display: wiggle, the alignments
+ * coverage band and the mark display, Manhattan among them, each declare
+ * `scales.y` through {@link valueScaleSchema} and compose this. It backs
+ * {@link ScoreAxisMixin}'s three overridable members off that object and adds
+ * the setters that write it, so composing this is how a display satisfies
+ * {@link ScoreScaleModel} in `scoreMenuItems.ts` — the interface the shared
+ * Score menu, the scale and autoscale submenus and `SetMinMaxDialog` consume.
  *
- * 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.
+ * Deliberately just the scale and the guides it owns. Colors, `resolution`
+ * and the autoscale *computation* stay in `WiggleScoreConfigMixin` /
+ * `WiggleCommonMixin` — the alignments coverage band shares this scale but
+ * none of the rest.
  */
 export function ScoreScaleMixin() {
-    return types
-        .model('ScoreScaleMixin', {})
+    return ScoreAxisMixin()
+        .volatile(() => ({
+        unclippedQuantile: undefined,
+    }))
         .views(self => ({
         /**
          * #getter
          */
         get scaleType() {
-            return getConf(confNode(self), 'scaleType');
+            return getConf(confNode(self), ['scales', 'y', 'type']);
+        },
+        /**
+         * #getter
+         * `scales.y.zero`: whether an autoscaled linear or symlog axis reaches
+         * 0.
+         */
+        get scaleZero() {
+            return getConf(confNode(self), ['scales', 'y', 'zero']);
+        },
+        /**
+         * #getter
+         * `scales.y.domainQuantile`: what an unpinned end follows, 1 the
+         * extremes and below it that quantile of each sign.
+         */
+        get domainQuantile() {
+            return getConf(confNode(self), ['scales', 'y', 'domainQuantile']);
+        },
+        /**
+         * #getter
+         * The quantile "Clip outliers" clips at: the one an untick this session
+         * wrote over, else the scale's own default where that is below 1, else
+         * 0.99.
+         */
+        get clipQuantile() {
+            return (self.unclippedQuantile ??
+                clipQuantileOf(getSlotDefinition(confNode(self).configuration.scales.y, 'domainQuantile').defaultValue));
         },
         /**
          * #getter
+         * Raw slot; `0` means "derive from the domain". Resolve it with
+         * `resolveSymlogConstant` once the domain is known.
          */
-        get autoscaleType() {
-            return getConf(confNode(self), 'autoscale');
+        get symlogConstant() {
+            return getConf(confNode(self), ['scales', 'y', 'symlogConstant']);
         },
         /**
          * #getter
+         * The lower bound the config pins, `undefined` where it pins none.
          */
-        get numStdDev() {
-            return getConf(confNode(self), 'numStdDev');
+        get manualMinScore() {
+            return getConf(confNode(self), ['scales', 'y', 'domainMin']);
         },
         /**
          * #getter
-         * Raw slot value, sentinel intact — see the class comment.
+         * The upper bound the config pins, `undefined` where it pins none.
          */
-        get minScore() {
-            return getConf(confNode(self), 'minScore');
+        get manualMaxScore() {
+            return getConf(confNode(self), ['scales', 'y', 'domainMax']);
         },
         /**
          * #getter
-         * Raw slot value, sentinel intact — see the class comment.
+         * What `scales.y`'s ends say together that the axis cannot draw as
+         * written, as corner-notice lines, by the rule a colour ramp's ends
+         * answer to. The mark display reports them through its rule list.
          */
-        get maxScore() {
-            return getConf(confNode(self), 'maxScore');
+        get valueScaleNotices() {
+            return noticeLines('scales.y', scaleEndProblems({
+                domainMin: this.manualMinScore,
+                domainMax: this.manualMaxScore,
+                domainQuantile: this.domainQuantile,
+            }));
         },
         /**
          * #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];
+         * `scales.y.autoscaleGroup`, `undefined` while it names none.
+         */
+        get autoscaleGroup() {
+            return (getConf(confNode(self), ['scales', 'y', 'autoscaleGroup']) ||
+                undefined);
         },
         /**
          * #getter
-         * Resolved lower bound; `undefined` means autoscale this end.
+         * `scales.y.title`, `''` while unset
          */
-        get minScoreBound() {
-            return this.minScore === Number.MIN_VALUE
-                ? this.defaultScoreDomain[0]
-                : this.minScore;
+        get scaleTitle() {
+            return getConf(confNode(self), ['scales', 'y', 'title']) ?? '';
         },
         /**
          * #getter
-         * Resolved upper bound; `undefined` means autoscale this end.
+         * `scales.y.grid`
          */
-        get maxScoreBound() {
-            return this.maxScore === Number.MAX_VALUE
-                ? this.defaultScoreDomain[1]
-                : this.maxScore;
+        get grid() {
+            return getConf(confNode(self), ['scales', 'y', 'grid']);
+        },
+        /**
+         * #getter
+         * `scales.y.minimalTicks`
+         */
+        get minimalTicks() {
+            return getConf(confNode(self), ['scales', 'y', 'minimalTicks']);
+        },
+        /**
+         * #getter
+         * Whether this display draws `scales.y.rules`, which is whether the
+         * score menu offers the reference lines: a scale it places y through
+         * rules a band for them to cross, which a density plot's colour-mapped
+         * rows and a colour ramp do not.
+         */
+        get scoreRulesDrawn() {
+            return self.valueScales.some(rulesABand);
+        },
+        /**
+         * #getter
+         * `scales.y.rules`, read off the live nodes: a snapshot strips a slot at
+         * its default, and a rule at 0 is one.
+         */
+        get scoreRules() {
+            const { rules } = confNode(self).configuration.scales.y;
+            return rules.map((rule) => {
+                const label = readConfObject(rule, 'label');
+                const color = readConfObject(rule, 'color');
+                return {
+                    value: readConfObject(rule, 'value'),
+                    ...(color ? { color } : {}),
+                    ...(label ? { label } : {}),
+                };
+            });
         },
     }))
         .actions(self => ({
@@ -112,25 +161,54 @@ export function ScoreScaleMixin() {
          * #action
          */
         setScaleType(scaleType) {
-            setConf(confNode(self), 'scaleType', scaleType);
+            setConf(confNode(self), ['scales', 'y', 'type'], scaleType);
         },
         /**
          * #action
          */
-        setAutoscale(val) {
-            setConf(confNode(self), 'autoscale', val);
+        setScaleZero(zero) {
+            setConf(confNode(self), ['scales', 'y', 'zero'], zero);
+        },
+        /**
+         * #action
+         */
+        setDomainQuantile(quantile) {
+            if (!(quantile < 1) && self.domainQuantile < 1) {
+                self.unclippedQuantile = self.domainQuantile;
+            }
+            setConf(confNode(self), ['scales', 'y', 'domainQuantile'], quantile);
         },
         /**
          * #action
          */
         setMinScore(val) {
-            setConf(confNode(self), 'minScore', val);
+            setConf(confNode(self), ['scales', 'y', 'domainMin'], val);
         },
         /**
          * #action
          */
         setMaxScore(val) {
-            setConf(confNode(self), 'maxScore', val);
+            setConf(confNode(self), ['scales', 'y', 'domainMax'], val);
+        },
+        /**
+         * #action
+         */
+        setAutoscaleGroup(group) {
+            setConf(confNode(self), ['scales', 'y', 'autoscaleGroup'], group);
+        },
+        /**
+         * #action
+         */
+        setGrid(grid) {
+            setConf(confNode(self), ['scales', 'y', 'grid'], grid);
+        },
+        /**
+         * #action
+         * Replaces `scales.y.rules` whole, each entry in a form the config
+         * takes: a number, or `{ value, color, label }`.
+         */
+        setScoreRules(rules) {
+            setConf(confNode(self), ['scales', 'y', 'rules'], rules);
         },
     }));
 }

package/esm/SetMinMaxDialog.d.ts

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

package/esm/SetMinMaxDialog.js

@@ -1,18 +1,32 @@
 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 { Button, Typography } from '@mui/material';
 import { observer } from 'mobx-react';
+// The two fields open on what the config really pins, which is the mixin's
+// `manual*` pair rather than the raw slots — the sentinel comparison is one
+// answer per end and lives there. Submitting `undefined` writes the sentinel
+// back, so an emptied field is how autoscale resumes.
 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 { model, domain, handleClose } = props;
+    const { manualMinScore, manualMaxScore, scaleType } = model;
+    const [min, setMin] = useState(manualMinScore);
+    const [max, setMax] = useState(manualMaxScore);
+    // The fields own their text, so filling them from the button remounts them.
+    const [fill, setFill] = useState(0);
     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" })] }));
+        }, children: [_jsx(Typography, { children: "Enter min/max score, or leave a field empty to autoscale that end" }), !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" }, `min-${fill}`), _jsx(NumberTextField, { defaultValue: max, onValueChange: setMax, placeholder: "Enter max score" }, `max-${fill}`), _jsxs("div", { children: [domain ? (_jsx(Button, { onClick: () => {
+                            setMin(domain[0]);
+                            setMax(domain[1]);
+                            setFill(n => n + 1);
+                        }, children: "Use current range" })) : null, _jsx(Button, { disabled: min === undefined && max === undefined, onClick: () => {
+                            setMin(undefined);
+                            setMax(undefined);
+                            setFill(n => n + 1);
+                        }, children: "Clear" })] })] }));
 });

package/esm/SetScoreRulesDialog.d.ts

@@ -0,0 +1,14 @@
+import type { ValueScaleRule } from '@jbrowse/display-ui';
+/**
+ * The score menu's editor for `scales.y.rules`: one row per reference line,
+ * its value on the plot's own scale, its label and its colour. An empty colour
+ * is the display's default, and removing every row removes every line.
+ */
+declare const _default: ({ model, handleClose, }: {
+    model: {
+        scoreRules: ValueScaleRule[];
+        setScoreRules: (rules: ValueScaleRule[]) => void;
+    };
+    handleClose: () => void;
+}) => import("react").JSX.Element;
+export default _default;

package/esm/SetScoreRulesDialog.js

@@ -0,0 +1,45 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { SubmitDialog } from '@jbrowse/core/ui';
+import { isCssColor } from '@jbrowse/core/util/colorBits';
+import DeleteIcon from '@mui/icons-material/Delete';
+import { Button, IconButton, TextField, Typography } from '@mui/material';
+import { observer } from 'mobx-react';
+function rowOf({ value, label = '', color = '' }) {
+    return { value: String(value), label, color };
+}
+function valueOk({ value }) {
+    return value.trim() !== '' && Number.isFinite(Number(value));
+}
+function colorOk({ color }) {
+    return color.trim() === '' || isCssColor(color);
+}
+/**
+ * The score menu's editor for `scales.y.rules`: one row per reference line,
+ * its value on the plot's own scale, its label and its colour. An empty colour
+ * is the display's default, and removing every row removes every line.
+ */
+export default observer(function SetScoreRulesDialog({ model, handleClose, }) {
+    const [rows, setRows] = useState(() => model.scoreRules.map(rowOf));
+    const setRow = (index, patch) => {
+        setRows(rows.map((row, i) => (i === index ? { ...row, ...patch } : row)));
+    };
+    return (_jsxs(SubmitDialog, { open: true, title: "Reference lines", submitDisabled: !rows.every(row => valueOk(row) && colorOk(row)), onCancel: handleClose, onSubmit: () => {
+            model.setScoreRules(rows.map(row => ({
+                value: Number(row.value),
+                ...(row.label ? { label: row.label } : {}),
+                ...(row.color.trim() ? { color: row.color.trim() } : {}),
+            })));
+            handleClose();
+        }, children: [_jsx(Typography, { children: "A horizontal line at each value, on the same scale as the plot" }), rows.map((row, index) => (_jsxs("div", { style: { display: 'flex', gap: 8, marginTop: 8 }, children: [_jsx(TextField, { label: "Value", value: row.value, error: !valueOk(row), onChange: event => {
+                            setRow(index, { value: event.target.value });
+                        } }), _jsx(TextField, { label: "Label", value: row.label, onChange: event => {
+                            setRow(index, { label: event.target.value });
+                        } }), _jsx(TextField, { label: "Color", value: row.color, error: !colorOk(row), onChange: event => {
+                            setRow(index, { color: event.target.value });
+                        } }), _jsx(IconButton, { "aria-label": "remove line", onClick: () => {
+                            setRows(rows.filter((_, i) => i !== index));
+                        }, children: _jsx(DeleteIcon, {}) })] }, index))), _jsx(Button, { onClick: () => {
+                    setRows([...rows, { value: '', label: '', color: '' }]);
+                }, children: "Add line" })] }));
+});

package/esm/WiggleScoreConfigMixin.d.ts

@@ -0,0 +1,89 @@
+import type { scalesSchema } from './valueScaleConfigSchema.ts';
+import type { ConfigModelForFields } from '@jbrowse/core/configuration';
+/** The slots its composers each declare, with their own defaults. */
+export declare const wiggleScoreConfigExtraSlots: {
+    readonly size: {
+        readonly type: 'number';
+        readonly defaultValue: 2;
+    };
+};
+export interface WiggleScoreConfigHost {
+    configuration: ConfigModelForFields<{
+        scales: ReturnType<typeof scalesSchema>;
+    } & typeof wiggleScoreConfigExtraSlots>;
+}
+/**
+ * #stateModel WiggleScoreConfigMixin
+ * #category display
+ *
+ * The score-plot config every display with a score axis shares: the axis
+ * and its guides (`ScoreScaleMixin`) and the scatter point size. A
+ * display plotting one configured field composes `ScoreFieldConfigMixin`,
+ * which adds `scoreField`.
+ */
+export declare function WiggleScoreConfigMixin(): import("@jbrowse/mobx-state-tree").IModelType<Omit<{}, never>, {
+    readonly scaleType: string;
+    readonly scaleZero: boolean;
+    readonly manualMinScore: number | undefined;
+    readonly manualMaxScore: number | undefined;
+    readonly defaultScoreDomain: [number | undefined, number | undefined];
+    readonly valueScales: import("@jbrowse/display-ui").ValueScale[];
+    readonly autoscaleGroup: string | undefined;
+    readonly autoscaleRange: [number, number] | undefined;
+} & {
+    readonly axisReachesZero: boolean;
+} & {
+    readonly autoscaledDomain: [number, number] | undefined;
+    readonly minScoreBound: number | undefined;
+    readonly maxScoreBound: number | undefined;
+    readonly hasManualScoreBounds: boolean;
+    readonly axes: import("@jbrowse/display-ui").YAxis[];
+} & {
+    unclippedQuantile: number | undefined;
+} & {
+    readonly scaleType: string;
+    readonly scaleZero: boolean;
+    readonly domainQuantile: number;
+    readonly clipQuantile: number;
+    readonly symlogConstant: number;
+    readonly manualMinScore: number | undefined;
+    readonly manualMaxScore: number | undefined;
+    readonly valueScaleNotices: string[];
+    readonly autoscaleGroup: string | undefined;
+    readonly scaleTitle: string;
+    readonly grid: boolean;
+    readonly minimalTicks: boolean;
+    readonly scoreRulesDrawn: boolean;
+    readonly scoreRules: import("@jbrowse/display-ui").ValueScaleRule[];
+} & {
+    setScaleType(scaleType: string): void;
+    setScaleZero(zero: boolean): void;
+    setDomainQuantile(quantile: number): void;
+    setMinScore(val?: number): void;
+    setMaxScore(val?: number): void;
+    setAutoscaleGroup(group?: string): void;
+    setGrid(grid: boolean): void;
+    setScoreRules(rules: (number | import("@jbrowse/display-ui").ValueScaleRule)[]): void;
+} & {
+    /**
+     * #getter
+     */
+    readonly size: number;
+    /**
+     * #getter
+     * Whether score maps to color instead of height; a display overrides it.
+     */
+    readonly isDensityMode: boolean;
+} & {
+    /**
+     * #getter
+     * A density row maps score to colour and has no axis to start at 0, so
+     * its domain spans the values whatever `scales.y.zero` says.
+     */
+    readonly axisReachesZero: boolean;
+} & {
+    /**
+     * #action
+     */
+    setSize(val?: number): void;
+}, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;

package/esm/WiggleScoreConfigMixin.js

@@ -0,0 +1,54 @@
+import { getConf, setConf } from '@jbrowse/core/configuration';
+import { types } from '@jbrowse/mobx-state-tree';
+import { ScoreScaleMixin } from './ScoreScaleMixin.js';
+/** The slots its composers each declare, with their own defaults. */
+export const wiggleScoreConfigExtraSlots = {
+    size: { type: 'number', defaultValue: 2 },
+};
+const confNode = (self) => self;
+/**
+ * #stateModel WiggleScoreConfigMixin
+ * #category display
+ *
+ * The score-plot config every display with a score axis shares: the axis
+ * and its guides (`ScoreScaleMixin`) and the scatter point size. A
+ * display plotting one configured field composes `ScoreFieldConfigMixin`,
+ * which adds `scoreField`.
+ */
+export function WiggleScoreConfigMixin() {
+    return types
+        .compose('WiggleScoreConfigMixin', ScoreScaleMixin(), types.model({}))
+        .views(self => ({
+        /**
+         * #getter
+         */
+        get size() {
+            return getConf(confNode(self), 'size');
+        },
+        /**
+         * #getter
+         * Whether score maps to color instead of height; a display overrides it.
+         */
+        get isDensityMode() {
+            return false;
+        },
+    }))
+        .views(self => ({
+        /**
+         * #getter
+         * A density row maps score to colour and has no axis to start at 0, so
+         * its domain spans the values whatever `scales.y.zero` says.
+         */
+        get axisReachesZero() {
+            return self.scaleZero && !self.isDensityMode;
+        },
+    }))
+        .actions(self => ({
+        /**
+         * #action
+         */
+        setSize(val) {
+            setConf(confNode(self), 'size', val);
+        },
+    }));
+}

package/esm/autoscale.d.ts

@@ -1,4 +1,3 @@
-export declare const DEFAULT_AUTOSCALE_OPTIONS: [string, string][];
 export interface FeatureArrays {
     featurePositions: Uint32Array;
     featureScores: Float32Array;
@@ -15,9 +14,42 @@ export interface Dataset {
 export interface ScoreStats {
     scoreMin: number;
     scoreMax: number;
-    scoreMean: number;
-    scoreStdDev: number;
 }
+/**
+ * #api
+ * One block's worth of values to fold into a domain, whatever packed them: a
+ * wiggle source's interleaved `featurePositions` and its summary arrays, or a
+ * mark layer's separate `x`/`x2` and its one `y` lane. `starts[i * stride]` and
+ * `ends[i * stride + endOffset]` give instance `i`'s span, and `low` and `high`
+ * the two ends of its value, one array where the packer ships a single scalar.
+ */
+export interface ScoreSpan {
+    count: number;
+    starts: Uint32Array;
+    ends: Uint32Array;
+    stride: number;
+    endOffset: number;
+    low: Float32Array;
+    high: Float32Array;
+    visStart?: number;
+    visEnd?: number;
+    /**
+     * Whether the instances are bins sorted by start that never overlap, as a
+     * wiggle source's are, so a binary search finds the window's. A mark
+     * layer's features overlap and arrive source after source or section after
+     * section, so each is tested against the window instead.
+     */
+    sortedBins: boolean;
+    /**
+     * Instance `i`'s row key, and 1 at each key that draws: an instance whose
+     * key draws nothing, or lies past the end, folds into no domain. Absent,
+     * every instance folds in.
+     */
+    row?: Uint32Array;
+    drawnKeys?: Uint8Array;
+}
+/** The wiggle packer's arrays as a span, under a summary mode. */
+export declare function datasetSpan({ data, visStart, visEnd }: Dataset, summaryScoreMode: string): ScoreSpan;
 /**
  * #api
  * Per-feature scalar score array for a summary mode: the min/max summary array
@@ -28,28 +60,36 @@ export declare function getEffectiveScores(data: {
     featureMinScores: Float32Array;
     featureMaxScores: Float32Array;
 }, summaryScoreMode: string): Float32Array<ArrayBufferLike>;
+export declare function computeSpanStats(spans: ScoreSpan[]): ScoreStats | undefined;
+/** `computeSpanStats` over the wiggle packer's datasets. */
 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.
+ * The domain the visible instances autoscale to: at a `quantile` of 1 their
+ * extremes, `stats`; below it `quantileExtent`'s ends, the bottom read off
+ * the `low`s and the top off the `high`s less the zeros where any is
+ * positive, so whiskers open to their spread, a sparse window's empty bins
+ * lower no top, and a window of nothing above 0 keeps the top it has.
  */
-export declare function domainFromStats(stats: ScoreStats, autoscaleType: string, numStdDev: number): [number, number];
-export declare function autoscaleDomainFromStats({ stats, autoscaleType, summaryScoreMode, numStdDev, numQuantile, visibleEntries, }: {
+export declare function autoscaleDomainFromSpans({ stats, quantile, spans, }: {
+    stats: ScoreStats;
+    quantile: number;
+    spans: ScoreSpan[];
+}): [number, number];
+/** `autoscaleDomainFromSpans` over the wiggle packer's datasets. */
+export declare function autoscaleDomainFromStats({ stats, quantile, summaryScoreMode, visibleEntries, }: {
     stats: ScoreStats;
-    autoscaleType: string;
+    quantile: number;
     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.
+ * The score domain of the visible feature arrays, following `quantile` as
+ * `scales.y.domainQuantile` says.
  */
-export declare function computeAutoscaleDomain(autoscaleType: string, summaryScoreMode: string, numStdDev: number, visibleEntries: {
+export declare function computeAutoscaleDomain(quantile: number, summaryScoreMode: string, visibleEntries: {
     data: FeatureArrays;
     visStart: number;
     visEnd: number;
-}[], numQuantile?: number): [number, number] | undefined;
+}[]): [number, number] | undefined;