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

package/README.md

@@ -1,6 +1,7 @@
 # @jbrowse/wiggle-core
 
-Shared scale and autoscale utilities for wiggle and coverage displays
+Score-axis scale, autoscale, config mixins and plot chrome shared by wiggle,
+Manhattan, mark and coverage displays
 
 <!-- API_DOCS_START -->
 
@@ -8,14 +9,29 @@ Shared scale and autoscale utilities for wiggle and coverage displays
 
 Auto-generated from `#api` JSDoc tags in this package. Do not edit by hand.
 
+### autoscaleDomainFromSpans
+
+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.
+
+```js
+// type signature
+({ stats, quantile, spans, }: { stats: ScoreStats; quantile: number; spans: ScoreSpan[]; }) => [number, number]
+```
+
+[Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/wiggle-core/src/autoscale.ts)
+
 ### computeAutoscaleDomain
 
-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.
 
 ```js
 // type signature
-(autoscaleType: string, summaryScoreMode: string, numStdDev: number, visibleEntries: {…}[], numQuantile?: number) => [...] | undefined
+(quantile: number, summaryScoreMode: string, visibleEntries: { data: FeatureArrays; visStart: number; visEnd: number; }[]) => [number, number] | undefined
 ```
 
 [Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/wiggle-core/src/autoscale.ts)
@@ -50,18 +66,6 @@ exactly what it always got.
 
 [Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/wiggle-core/src/gapBreak.ts)
 
-### domainFromStats
-
-Converts score stats into a `[min, max]` domain, applying std-dev expansion for
-the `localsd` autoscale type.
-
-```js
-// type signature
-(stats: ScoreStats, autoscaleType: string, numStdDev: number) => [number, number]
-```
-
-[Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/wiggle-core/src/autoscale.ts)
-
 ### gapBreakLimit
 
 How far apart two consecutive points of an interpolated (point-to-point) line
@@ -69,12 +73,12 @@ may be before the span between them counts as a hole rather than a segment to
 draw. Returns `Infinity` when there is nothing to decide, so a caller can always
 compare against it unguarded.
 
-The limit is a multiple of the series' own _mean_ spacing rather than an
-absolute distance, which is what makes one number work across zoom levels and
-data types: reduced BigWig bins get wider as you zoom out, so any fixed bp
-threshold would be either useless at one end or destructive at the other. It
-also lets the same rule serve a bp axis (wiggle's linecenter) and a px one — the
-caller picks the space, this only cares that the units are consistent.
+The limit is a multiple of the series' _mean_ spacing rather than an absolute
+distance, so one number works across zoom levels and data types: reduced BigWig
+bins get wider as you zoom out, so any fixed bp threshold would be either
+useless at one end or destructive at the other. It also lets the same rule serve
+a bp axis (wiggle's linecenter) and a px one — the caller picks the space, this
+only cares that the units are consistent.
 
 Mean, not median: it is O(1) from the endpoints, and it errs the safe way. A
 series' holes inflate their own mean, which raises the limit and so breaks
@@ -107,16 +111,19 @@ Per-feature scalar score array for a summary mode: the min/max summary array for
 
 ### getNiceDomain
 
-Rounds a domain to "nice" endpoints, clamped to the origin. An end given an
-explicit `bounds` value keeps that value exactly — only an autoscaled end is
-rounded. A log scale's floor still outranks a bound it cannot hold.
+Rounds a domain to "nice" endpoints. `zero` reaches a linear or symlog domain to
+0 (`scales.y.zero`, ADR-182); a log domain has no 0 and floors at 1 instead. An
+end given an explicit `bounds` value keeps that value exactly — only an
+autoscaled end is rounded. A log scale's floor still outranks a bound it cannot
+hold.
 
-The result never descends: a bound that would put `min` above `max` widens the
-other end instead, so no consumer has to guess what a backwards domain means.
+The result never descends and never collapses: a bound that would put `min`
+above `max` widens the other end instead, and one value in view widens away from
+itself, so no consumer has to guess what a backwards or a flat domain means.
 
 ```js
 // type signature
-({ scaleType, domain, bounds, }: { scaleType: string; domain: readonly [number, number]; bounds: readonly [number | undefined, number | undefined]; }) => [number, number]
+({…}: { scaleType: string; domain: readonly [number, number]; bounds: readonly [number | undefined, number | undefined]; zero: boolean; }) => [number, number]
 ```
 
 [Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/wiggle-core/src/scale.ts)
@@ -145,41 +152,6 @@ unless `nice: false` says it is already the one being drawn with.
 
 [Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/wiggle-core/src/scale.ts)
 
-### makeScoreNormalizer
-
-Returns a loop-hoistable function normalizing a score to [0,1].
-
-`symlogConstant` is only read for `SCALE_TYPE_SYMLOG`, and is expected to be
-already resolved by resolveSymlogConstant — the shader gets the same resolved
-number as a uniform, so the "auto" rule lives on this side only and the two
-backends compare like for like.
-
-A range that is zero **or negative** normalizes everything to 0, which is the
-rule `scoreScale.slang` spells as `range <= 0.0`. Testing `range === 0` here
-instead let a descending domain through to a negative `1 / range`, so every
-score saturated to 1 on this side while the shader flattened them all to 0 — one
-view, opposite plots. `normalizeScoreParity.test.ts` sweeps the two.
-
-```js
-// type signature
-(min: number, max: number, scaleType: WiggleScaleType, symlogConstant?: number) => (score: number) => number
-```
-
-[Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/wiggle-core/src/normalize.ts)
-
-### parseScoreRules
-
-Normalizes whatever a `scoreRules` config slot holds into `ScoreRule`s, dropping
-entries that are not usable. Config is user-authored JSON, so a bare number, a
-missing value or a non-numeric one all have to survive being read.
-
-```js
-// type signature
-(value: unknown) => ScoreRule[]
-```
-
-[Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/wiggle-core/src/scoreRuleMarks.ts)
-
 ### resolveSymlogConstant
 
 The symlog constant actually used for a domain. `0` (the config default) means
@@ -200,30 +172,6 @@ rather than hard-coded.
 
 [Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/wiggle-core/src/normalize.ts)
 
-### scaleTypeFromString
-
-Maps the `'log'`/`'symlog'`/`'linear'` string to the numeric `WiggleScaleType`.
-
-```js
-// type signature
-(scaleType: string) => WiggleScaleType
-```
-
-[Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/wiggle-core/src/normalize.ts)
-
-### ScoreRule
-
-One horizontal rule across a score plot, at a score the user chose.
-
-`label` is free text and carries no meaning this package assigns. That is
-deliberate: the obvious use is reading a coverage or CNV track against copy
-number, and there is no ploidy JBrowse could assume on the user's behalf. A
-whole-genome triplication is not diploid, plenty of genomes are not diploid to
-begin with, and a cancer sample can be neither — so "2 copies" is a claim only
-the person looking at the track can make.
-
-[Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/wiggle-core/src/scoreRuleMarks.ts)
-
 ### scoreRuleMarks
 
 Screen y for each rule that falls inside the plotted domain, dropping the rest.
@@ -240,28 +188,50 @@ because the axis need not be linear: on a log or symlog track, placing a rule at
 read against is not.
 
 `box` is likewise the caller's own — hand it the same `{yTop, yBottom}` the
-display's ticks were built with (a `YScaleTicks` satisfies it). Recomputing a
-box here would silently disagree with any band that lays its axis out
+display's ticks were built with (a `YScaleTicks` satisfies it). A box recomputed
+here would place rules off the ticks of any band that lays its axis out
 differently, and the alignments coverage band does.
 
 ```js
 // type signature
-({…}: { rules: readonly ScoreRule[]; domain: [number, number] | undefined; box: { yTop: number; yBottom: number; }; normalize: (score: number) => number; }) => ScoreRuleMark[]
+({…}: { rules: readonly ValueScaleRule[]; domain: [number, number] | undefined; box: { yTop: number; yBottom: number; }; normalize: (score: number) => number; }) => ScoreRuleMark[]
 ```
 
 [Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/wiggle-core/src/scoreRuleMarks.ts)
 
+### ScoreSpan
+
+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.
+
+[Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/wiggle-core/src/autoscale.ts)
+
 ### visibleStatsDomain
 
-The visible score domain four displays derive identically: walk the settled
-blocks, accumulate the stats of what each one shows, and nice-round the
-autoscaled range inside the configured bounds. `undefined` while there is
-nothing to scale against — no data, a hidden band, or a view that has not
-initialized — which every caller distinguishes from a domain.
+visibleStatsRange nice-rounded inside the configured bounds: the domain of a
+display whose range is its own alone.
 
 ```js
 // type signature
-<Payload, Item, Stats>({ active, view, payloadFor, itemsFor, accumulate, range, bounds, scaleType, }: VisibleStatsDomainSpec<Payload, Item, Stats>) => [number, number] | undefined
+<Payload, Item, Stats>({ bounds, scaleType, zero, ...spec }: VisibleStatsDomainSpec<Payload, Item, Stats>) => [number, number] | undefined
+```
+
+[Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/wiggle-core/src/visibleStatsDomain.ts)
+
+### visibleStatsRange
+
+The raw autoscaled range the displays with a value scale derive identically:
+walk the settled blocks, accumulate the stats of what each one shows, and reduce
+them to `[min, max]` before any bound or nice-rounding. `undefined` while there
+is nothing to scale against — no data, a hidden band, or a view that has not
+initialized — which every caller distinguishes from a range.
+
+```js
+// type signature
+<Payload, Item, Stats>({ active, view, payloadFor, itemsFor, accumulate, range, }: VisibleStatsRangeSpec<Payload, Item, Stats>) => [number, number] | undefined
 ```
 
 [Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/wiggle-core/src/visibleStatsDomain.ts)
@@ -270,17 +240,16 @@ initialized — which every caller distinguishes from a domain.
 
 Widens an autoscaled range so every configured rule stays on the axis.
 
-Without this a rule silently disappears in exactly the window that makes it
-worth having. Autoscale follows the visible data, so over a homozygous deletion
-a coverage domain collapses to about `[0, 1]` and a rule at the diploid depth
-falls outside it — and "2 copies would be up there" is the most informative
-thing that view can say. The reader has no menu to check either: `scoreRules` is
-set by whoever wrote the config, so a rule that vanishes leaves nothing behind
-to notice.
-
-Applied to the raw range, before `getNiceDomain` takes the `minScore` /
-`maxScore` bounds. Those still win: a rule outside an explicitly bounded axis is
-one the config asked not to be shown, and it drops as before.
+Without this a rule is dropped from the plot in the views where it is most
+useful. Autoscale follows the visible data, so over a homozygous deletion a
+coverage domain collapses to about `[0, 1]` and a rule at the diploid depth
+falls outside it, though the rule's position above the data is the most
+informative mark in that view, and a rule that vanishes leaves nothing behind to
+notice.
+
+Applied to the raw range, before `getNiceDomain` takes the `scales.y` domain
+bounds. Those still win: a rule outside an explicitly bounded axis is one the
+config asked not to be shown, and it drops as before.
 
 ```js
 // type signature

package/esm/AutoscaleGroupDialog.d.ts

@@ -0,0 +1,7 @@
+import type { AutoscalePeer } from './autoscaleGroup.ts';
+import type { IStateTreeNode } from '@jbrowse/mobx-state-tree';
+declare const _default: ({ model, handleClose, }: {
+    model: AutoscalePeer & IStateTreeNode;
+    handleClose: () => void;
+}) => import("react").JSX.Element;
+export default _default;

package/esm/AutoscaleGroupDialog.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { LabeledCheckbox, SubmitDialog } from '@jbrowse/core/ui';
+import { Typography } from '@mui/material';
+import { observer } from 'mobx-react';
+import { autoscalePeers, autoscaleWith } from './autoscaleGroup.js';
+export default observer(function AutoscaleGroupDialog({ model, handleClose, }) {
+    const peers = autoscalePeers(model);
+    const group = model.autoscaleGroup;
+    const [chosen, setChosen] = useState(() => new Set(group === undefined
+        ? []
+        : peers.map(p => p.display).filter(d => d.autoscaleGroup === group)));
+    return (_jsxs(SubmitDialog, { open: true, title: "Autoscale with other tracks", submitText: "Apply", onCancel: handleClose, onSubmit: () => {
+            autoscaleWith(model, peers.map(p => p.display), chosen);
+            handleClose();
+        }, children: [_jsx(Typography, { color: "text.secondary", children: "The tracks ticked here share this track's axis: each end nobody pinned spans all of their data, and follows it as the view moves." }), peers.map(({ display, key, name }) => (_jsx("div", { children: _jsx(LabeledCheckbox, { checked: chosen.has(display), label: name, onChange: checked => {
+                        const next = new Set(chosen);
+                        if (checked) {
+                            next.add(display);
+                        }
+                        else {
+                            next.delete(display);
+                        }
+                        setChosen(next);
+                    } }) }, key)))] }));
+});

package/esm/ScoreAxisMixin.d.ts

@@ -0,0 +1,134 @@
+import type { ValueScale, YAxis } from '@jbrowse/display-ui';
+/**
+ * #stateModel ScoreAxisMixin
+ * #category display
+ * Not a cross-cutting mixin any more: {@link ScoreScaleMixin} is its one
+ * composer, and a display takes the axis by taking that. The two stay apart
+ * because the halves answer different questions — this one derives, the other
+ * says where the answer is written.
+ *
+ * The axis contract apart from where it is written down. `scaleType`,
+ * `manualMinScore` and `manualMaxScore` are declared here with neutral answers
+ * and a composing display overrides them, so the bounds, the "is anything
+ * pinned" question, the ticks and the cross-hatches derive the same way
+ * wherever the declaration lives. {@link ScoreScaleMixin} is the one composer
+ * in the tree, backing them with the `scales.y` object every quantitative
+ * display declares; the split stays because the derived half is what a display
+ * writing its scale down somewhere else would answer.
+ *
+ * The setters are not here. A display cannot set what it has not said where to
+ * put, so `setScaleType`/`setMinScore`/`setMaxScore` belong to whichever
+ * composer owns the declaration — one owner, whichever it is.
+ */
+export declare function ScoreAxisMixin(): import("@jbrowse/mobx-state-tree").IModelType<{}, {
+    /**
+     * #getter
+     * Overridable: where this display's scale type is written down.
+     */
+    readonly scaleType: string;
+    /**
+     * #getter
+     * Overridable: where `scales.y.zero` is written down, whether an
+     * autoscaled linear or symlog axis reaches 0.
+     */
+    readonly scaleZero: boolean;
+    /**
+     * #getter
+     * Overridable: the lower bound the config really pins, `undefined`
+     * where nothing does.
+     */
+    readonly manualMinScore: number | undefined;
+    /**
+     * #getter
+     * Overridable: the upper bound the config really pins.
+     */
+    readonly manualMaxScore: number | undefined;
+    /**
+     * #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
+     * the data — the wiggle display reads the bounds its adapter declares,
+     * a GC content track's [0, 1] — and rather than each display
+     * re-resolving the sentinels, 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
+     * Overridable hook (default none): the scales this display draws its y
+     * through. A display that answers it gets an axis per band of each,
+     * with its cross-hatches, placed by `DisplayChrome` and
+     * `renderDisplaySvg`, and the ticks derived below.
+     */
+    readonly valueScales: ValueScale[];
+    /**
+     * #getter
+     * Overridable: the group this display's unpinned ends autoscale in,
+     * beside every display in its view naming the same one.
+     */
+    readonly autoscaleGroup: string | undefined;
+    /**
+     * #getter
+     * Overridable: what this display's own data spans, before any bound,
+     * nice-rounding or group widens it; what a group unions.
+     */
+    readonly autoscaleRange: [number, number] | undefined;
+} & {
+    /**
+     * #getter
+     * Overridable: whether the autoscaled domain reaches 0, `scaleZero`
+     * unless the display maps its score to something with no axis.
+     */
+    readonly axisReachesZero: boolean;
+} & {
+    /**
+     * #getter
+     * The domain an autoscaled axis draws: `autoscaleRange`, widened to
+     * every range its `autoscaleGroup` holds, nice-rounded inside this
+     * display's own bounds. Each member unions the others' own ranges and
+     * never their domains, so a pinned end stays the display's that pinned
+     * it. `undefined` while this display has nothing of its own to scale.
+     */
+    readonly autoscaledDomain: [number, 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;
+    /**
+     * #getter
+     * Whether the user has pinned either end, which is a different question
+     * from whether either end resolved to a number: `defaultScoreDomain` fills
+     * the unset ends in, so a GC content track answers yes to the second with
+     * nothing configured. The score menu asks this one — it captions the
+     * min/max row with the range in force, and a caption off the resolved
+     * pair named a range on every freshly opened GC content track.
+     */
+    readonly hasManualScoreBounds: boolean;
+    /**
+     * #getter
+     * The axes, one per declared scale whose domain resolved: where each
+     * tick lands in the band's own pixel space, through `computeYTicks`
+     * unless the scale brought its own ladder, and where each of the
+     * scale's `rules` inside the domain lands in that same box, through the
+     * scale type the renderer places its values by.
+     */
+    readonly axes: YAxis[];
+}, import("@jbrowse/mobx-state-tree")._NotCustomized, import("@jbrowse/mobx-state-tree")._NotCustomized>;

package/esm/ScoreAxisMixin.js

@@ -0,0 +1,213 @@
+import { types } from '@jbrowse/mobx-state-tree';
+import { scaleTypeCode } from '@jbrowse/render-core/scoreScale';
+import { autoscaleGroupMembers, unionRanges } from './autoscaleGroup.js';
+import { computeYTicks } from './computeYTicks.js';
+import { makeScoreNormalizer, resolveSymlogConstant } from './normalize.js';
+import { getNiceDomain } from './scale.js';
+import { scoreRuleMarks } from './scoreRuleMarks.js';
+/**
+ * #stateModel ScoreAxisMixin
+ * #category display
+ * Not a cross-cutting mixin any more: {@link ScoreScaleMixin} is its one
+ * composer, and a display takes the axis by taking that. The two stay apart
+ * because the halves answer different questions — this one derives, the other
+ * says where the answer is written.
+ *
+ * The axis contract apart from where it is written down. `scaleType`,
+ * `manualMinScore` and `manualMaxScore` are declared here with neutral answers
+ * and a composing display overrides them, so the bounds, the "is anything
+ * pinned" question, the ticks and the cross-hatches derive the same way
+ * wherever the declaration lives. {@link ScoreScaleMixin} is the one composer
+ * in the tree, backing them with the `scales.y` object every quantitative
+ * display declares; the split stays because the derived half is what a display
+ * writing its scale down somewhere else would answer.
+ *
+ * The setters are not here. A display cannot set what it has not said where to
+ * put, so `setScaleType`/`setMinScore`/`setMaxScore` belong to whichever
+ * composer owns the declaration — one owner, whichever it is.
+ */
+export function ScoreAxisMixin() {
+    return types
+        .model('ScoreAxisMixin', {})
+        .views(() => ({
+        /**
+         * #getter
+         * Overridable: where this display's scale type is written down.
+         */
+        get scaleType() {
+            return 'linear';
+        },
+        /**
+         * #getter
+         * Overridable: where `scales.y.zero` is written down, whether an
+         * autoscaled linear or symlog axis reaches 0.
+         */
+        get scaleZero() {
+            return true;
+        },
+        /**
+         * #getter
+         * Overridable: the lower bound the config really pins, `undefined`
+         * where nothing does.
+         */
+        get manualMinScore() {
+            return undefined;
+        },
+        /**
+         * #getter
+         * Overridable: the upper bound the config really pins.
+         */
+        get manualMaxScore() {
+            return undefined;
+        },
+        /**
+         * #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
+         * the data — the wiggle display reads the bounds its adapter declares,
+         * a GC content track's [0, 1] — and rather than each display
+         * re-resolving the sentinels, 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
+         * Overridable hook (default none): the scales this display draws its y
+         * through. A display that answers it gets an axis per band of each,
+         * with its cross-hatches, placed by `DisplayChrome` and
+         * `renderDisplaySvg`, and the ticks derived below.
+         */
+        get valueScales() {
+            return [];
+        },
+        /**
+         * #getter
+         * Overridable: the group this display's unpinned ends autoscale in,
+         * beside every display in its view naming the same one.
+         */
+        get autoscaleGroup() {
+            return undefined;
+        },
+        /**
+         * #getter
+         * Overridable: what this display's own data spans, before any bound,
+         * nice-rounding or group widens it; what a group unions.
+         */
+        get autoscaleRange() {
+            return undefined;
+        },
+    }))
+        .views(self => ({
+        /**
+         * #getter
+         * Overridable: whether the autoscaled domain reaches 0, `scaleZero`
+         * unless the display maps its score to something with no axis.
+         */
+        get axisReachesZero() {
+            return self.scaleZero;
+        },
+    }))
+        .views(self => ({
+        /**
+         * #getter
+         * The domain an autoscaled axis draws: `autoscaleRange`, widened to
+         * every range its `autoscaleGroup` holds, nice-rounded inside this
+         * display's own bounds. Each member unions the others' own ranges and
+         * never their domains, so a pinned end stays the display's that pinned
+         * it. `undefined` while this display has nothing of its own to scale.
+         */
+        get autoscaledDomain() {
+            const own = self.autoscaleRange;
+            const group = self.autoscaleGroup;
+            const range = own && group
+                ? unionRanges([
+                    own,
+                    ...autoscaleGroupMembers(self, group).map(m => m.autoscaleRange),
+                ])
+                : own;
+            return range
+                ? getNiceDomain({
+                    domain: range,
+                    bounds: [this.minScoreBound, this.maxScoreBound],
+                    scaleType: self.scaleType,
+                    zero: self.axisReachesZero,
+                })
+                : undefined;
+        },
+        /**
+         * #getter
+         * Resolved lower bound; `undefined` means autoscale this end.
+         */
+        get minScoreBound() {
+            return self.manualMinScore ?? self.defaultScoreDomain[0];
+        },
+        /**
+         * #getter
+         * Resolved upper bound; `undefined` means autoscale this end.
+         */
+        get maxScoreBound() {
+            return self.manualMaxScore ?? self.defaultScoreDomain[1];
+        },
+        /**
+         * #getter
+         * Whether the user has pinned either end, which is a different question
+         * from whether either end resolved to a number: `defaultScoreDomain` fills
+         * the unset ends in, so a GC content track answers yes to the second with
+         * nothing configured. The score menu asks this one — it captions the
+         * min/max row with the range in force, and a caption off the resolved
+         * pair named a range on every freshly opened GC content track.
+         */
+        get hasManualScoreBounds() {
+            return (self.manualMinScore !== undefined || self.manualMaxScore !== undefined);
+        },
+        /**
+         * #getter
+         * The axes, one per declared scale whose domain resolved: where each
+         * tick lands in the band's own pixel space, through `computeYTicks`
+         * unless the scale brought its own ladder, and where each of the
+         * scale's `rules` inside the domain lands in that same box, through the
+         * scale type the renderer places its values by.
+         */
+        get axes() {
+            return self.valueScales.flatMap(scale => {
+                const { domain, rules = [] } = scale;
+                const ticks = scale.ticks ??
+                    computeYTicks({
+                        height: scale.height,
+                        offset: scale.offset,
+                        domain,
+                        scaleType: scale.scaleType,
+                        minimalTicks: scale.minimalTicks ?? false,
+                        symlogConstant: scale.symlogConstant,
+                    });
+                if (!domain || !ticks) {
+                    return [];
+                }
+                const [min, max] = domain;
+                const ruleMarks = rules.length > 0
+                    ? scoreRuleMarks({
+                        rules,
+                        domain,
+                        box: ticks,
+                        normalize: makeScoreNormalizer(min, max, scaleTypeCode(scale.scaleType), resolveSymlogConstant(min, max, scale.symlogConstant ?? 0)),
+                    })
+                    : [];
+                return [{ ...scale, domain, ticks, ruleMarks }];
+            });
+        },
+    }));
+}