@jbrowse/wiggle-core 4.3.0

package/esm/symlogTicks.js

@@ -0,0 +1,92 @@
+import { linearTicks } from './vendor/d3-scale.js';
+// Tick VALUES for a symlog axis, which d3 does not have and this axis needs.
+//
+// d3's scaleSymlog is `linearish`, so `ticks()` hands back evenly spaced values
+// in SCORE space while the axis places them in TRANSFORMED space. The two
+// disagree by exactly the amount symlog exists to provide: on a [0, 1000] domain
+// with the resolved constant, d3's 0, 200, 400, 600, 800, 1000 land at 100%,
+// 23%, 13%, 7%, 3% and 0% of the plot height — five 10px labels stacked in the
+// top quarter, and two thirds of the axis carrying one tick. The plot is right
+// and the axis over it is unreadable.
+//
+// So the values are chosen in transformed space instead — evenly spaced there,
+// which is evenly spaced on screen — and each is then rounded to the nearest
+// 1/2/5 × 10^k so the labels read as numbers a person would have picked. A
+// [0, 1000] domain comes out 0, 5, 20, 200, 1000: five labels spread down the
+// whole axis.
+//
+// `vendor/d3-scale.ts` stays d3's arithmetic unchanged, and `scaleTicks` there
+// still answers what d3 answers — `scaleParity.test.ts` pins it. This is
+// `getScale`'s own choice, applied where a scale is built for drawing.
+const symlog = (x, c) => Math.sign(x) * Math.log1p(Math.abs(x / c));
+const symexp = (t, c) => Math.sign(t) * c * Math.expm1(Math.abs(t));
+// Nearest 1/2/5/10 × 10^k, compared in log space so the choice doesn't depend on
+// which decade the value happens to sit in. `toPrecision(15)` drops the binary
+// residue off `f * 10 ** k` (5e-5 comes out 0.00005000000000000001 otherwise),
+// which matters because these are rendered as label text.
+function niceMagnitude(x) {
+    const magnitude = Math.abs(x);
+    const decade = 10 ** Math.floor(Math.log10(magnitude));
+    let best = decade;
+    for (const factor of [2, 5, 10]) {
+        const candidate = factor * decade;
+        if (Math.abs(Math.log(candidate / magnitude)) <
+            Math.abs(Math.log(best / magnitude))) {
+            best = candidate;
+        }
+    }
+    return Math.sign(x) * Number(best.toPrecision(15));
+}
+/**
+ * Tick values for a symlog domain, spaced evenly down the axis rather than
+ * evenly across the scores.
+ *
+ * The domain endpoints are always ticks: symlog's whole point is that the small
+ * end stays legible, and both ends of an autoscaled domain are what tell a
+ * reader what the plot's extent is. Zero joins them when the domain crosses it —
+ * on a log-ratio track that is the one score with an absolute meaning, and
+ * rounding never lands on it.
+ *
+ * Rounding can put an interior tick on top of a neighbour (a domain crossing
+ * zero rounds its smallest magnitudes to something a pixel from the zero line),
+ * so a candidate closer than half a slot to a tick already kept is dropped
+ * rather than drawn over it. Endpoints and zero are kept in preference to any
+ * rounded value, which is the same order they are stated in above.
+ */
+export function symlogTicks(domain, constant, count = 10) {
+    const [domainMin, domainMax] = domain;
+    const descending = domainMax < domainMin;
+    const min = descending ? domainMax : domainMin;
+    const max = descending ? domainMin : domainMax;
+    const tMin = symlog(min, constant);
+    const tMax = symlog(max, constant);
+    const slots = Math.max(1, Math.floor(count));
+    if (!(constant > 0) || !(tMax - tMin > 0)) {
+        // A constant that isn't positive makes the transform undefined, and a
+        // transformed span of zero (a flat domain) has nothing to space out. Neither
+        // is this function's call to make, so hand both back to the linear ticks the
+        // rest of the module uses.
+        return linearTicks(domainMin, domainMax, count);
+    }
+    const normalized = (v) => (symlog(v, constant) - tMin) / (tMax - tMin);
+    const minGap = 0.5 / slots;
+    // Anchors first so a rounded value never displaces one of them, then the
+    // rounded candidates in ascending order; `kept` stays sorted because the
+    // anchors are the extremes and zero is between them.
+    const anchors = min < 0 && max > 0 ? [min, 0, max] : [min, max];
+    const candidates = [];
+    for (let i = 1; i < slots; i++) {
+        const value = niceMagnitude(symexp(tMin + ((tMax - tMin) * i) / slots, constant));
+        if (value > min && value < max) {
+            candidates.push(value);
+        }
+    }
+    const kept = [...anchors];
+    for (const value of candidates) {
+        if (kept.every(k => Math.abs(normalized(value) - normalized(k)) >= minGap)) {
+            kept.push(value);
+        }
+    }
+    kept.sort((a, b) => a - b);
+    return descending ? kept.reverse() : kept;
+}

package/esm/transferables.d.ts

@@ -0,0 +1,2 @@
+import type { WiggleDataResult } from './dataTypes.ts';
+export declare function collectWiggleTransferables(results: WiggleDataResult[]): ArrayBuffer[];

package/esm/transferables.js

@@ -0,0 +1,32 @@
+// Walks every result's sources once and returns each source's eight per-feature
+// TypedArray buffers as one flat list for postMessage transfer. Field set
+// matches WiggleFeatureArrays — when fields change there, update here so the
+// buffers actually transfer instead of being structured-cloned.
+//
+// The Set dedupe is load-bearing, not insurance: processFeaturesFromArrays
+// aliases fields onto one buffer whenever a copy would be identical (no summary
+// data → min/max are the scores; an all-one-sided window → the pos or neg
+// arrays are the full arrays). postMessage throws on a repeated transferable.
+//
+// Takes ALL the results rather than one, so the dedupe spans regions too — a
+// per-result Set would list a shared buffer twice.
+//
+// Aliasing the adapter's own arrays here as well, rather than copying them, is
+// costed and declined in agent-docs/reference/REJECTED_IDEAS.md: it retains 20
+// bytes a feature on the main thread where copying retains 12.
+export function collectWiggleTransferables(results) {
+    const buffers = new Set();
+    for (const result of results) {
+        for (const s of result.sources) {
+            buffers.add(s.featurePositions.buffer);
+            buffers.add(s.featureScores.buffer);
+            buffers.add(s.featureMinScores.buffer);
+            buffers.add(s.featureMaxScores.buffer);
+            buffers.add(s.posFeaturePositions.buffer);
+            buffers.add(s.posFeatureScores.buffer);
+            buffers.add(s.negFeaturePositions.buffer);
+            buffers.add(s.negFeatureScores.buffer);
+        }
+    }
+    return [...buffers];
+}

package/esm/vendor/d3-scale.d.ts

@@ -0,0 +1,33 @@
+export type ScaleKind = 'linear' | 'log' | 'symlog';
+export interface ScaleSpec {
+    kind: ScaleKind;
+    domain: readonly [number, number];
+    range: readonly [number, number];
+    /** log only; 10 when unset, and every caller here passes 2 */
+    base?: number;
+    /** symlog only; the half-width of the linear region around zero */
+    constant?: number;
+}
+/** d3-array's `ticks`: round values inside [start, stop], about `count` of them. */
+export declare function linearTicks(start: number, stop: number, count: number): number[];
+/**
+ * Where `x` lands in the range.
+ *
+ * The arithmetic is d3's bimap, expression for expression — normalize to t,
+ * then `r0 * (1 - t) + r1 * t`, with the endpoints swapped for a descending
+ * domain. The algebraically identical `r0 + t * (r1 - r0)` differs in the last
+ * bit, which `scaleParity.test.ts` compares exactly and rejects.
+ *
+ * A zero-width domain returns the range's midpoint rather than dividing by
+ * zero, which is d3's behaviour and the one a flat track wants: every score
+ * equal means every bar at the same height, not every bar at NaN.
+ */
+export declare function scaleValue(spec: ScaleSpec, x: number): number;
+/** The domain rounded out to tick boundaries — d3's `nice`. */
+export declare function niceDomain(spec: ScaleSpec, count?: number): [number, number];
+/**
+ * Tick values inside the domain. Log ticks sit at every k×base^i — 2, 4, 8 for
+ * base 2 — falling back to linear ticks when the domain spans too many powers
+ * to enumerate, or too few to fill the count.
+ */
+export declare function scaleTicks(spec: ScaleSpec, count?: number): number[];

package/esm/vendor/d3-scale.js

@@ -0,0 +1,249 @@
+// Derived from d3-scale 4.0.2 and d3-array 3.2.4, ISC License —
+// https://github.com/d3/d3-scale/blob/main/LICENSE
+//
+// Three scales, because `scaleType` is a stringEnum of exactly linear, log and
+// symlog. What d3 offers beyond them, and what these three offered beyond
+// `getScale`'s use of them — clamp, invert, interpolate, rangeRound, unknown,
+// tickFormat, copy, piecewise domains, quantize — is not here.
+//
+// **Pure functions over a spec**, rather than d3's chainable callable objects:
+// nothing here holds state, so a scale is a value you can compare, log and
+// build in a worker, and `scale.ts` assembles the one callable the public
+// `getScale` still returns.
+//
+// **The tick and nice arithmetic is d3's, unchanged**, and deliberately so:
+// `yScaleTicksParity.test.ts` pins the axis against what the renderer draws,
+// and a tick sequence differing in the last decimal moves a labelled line off
+// the bar it belongs to. `scaleParity.test.ts` holds it to that.
+const e10 = Math.sqrt(50);
+const e5 = Math.sqrt(10);
+const e2 = Math.sqrt(2);
+function tickSpec(start, stop, count) {
+    const step = (stop - start) / Math.max(0, count);
+    const power = Math.floor(Math.log10(step));
+    const error = step / 10 ** power;
+    const factor = error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1;
+    let i1;
+    let i2;
+    let inc;
+    if (power < 0) {
+        inc = 10 ** -power / factor;
+        i1 = Math.round(start * inc);
+        i2 = Math.round(stop * inc);
+        if (i1 / inc < start) {
+            ++i1;
+        }
+        if (i2 / inc > stop) {
+            --i2;
+        }
+        inc = -inc;
+    }
+    else {
+        inc = 10 ** power * factor;
+        i1 = Math.round(start / inc);
+        i2 = Math.round(stop / inc);
+        if (i1 * inc < start) {
+            ++i1;
+        }
+        if (i2 * inc > stop) {
+            --i2;
+        }
+    }
+    if (i2 < i1 && count >= 0.5 && count < 2) {
+        return tickSpec(start, stop, count * 2);
+    }
+    return [i1, i2, inc];
+}
+/** d3-array's `ticks`: round values inside [start, stop], about `count` of them. */
+export function linearTicks(start, stop, count) {
+    if (!(count > 0)) {
+        return [];
+    }
+    if (start === stop) {
+        return [start];
+    }
+    const reverse = stop < start;
+    const [i1, i2, inc] = reverse
+        ? tickSpec(stop, start, count)
+        : tickSpec(start, stop, count);
+    if (!(i2 >= i1)) {
+        return [];
+    }
+    // Multiply or divide by `inc` as its sign says, rather than always
+    // multiplying: for a fractional step d3 carries the reciprocal as a negative
+    // integer so the ticks land on exact decimals.
+    const at = (i) => (inc < 0 ? i / -inc : i * inc);
+    return Array.from({ length: i2 - i1 + 1 }, (_, i) => reverse ? at(i2 - i) : at(i1 + i));
+}
+const tickIncrement = (start, stop, count) => tickSpec(start, stop, count)[2];
+// Exact for the bases anyone uses. `Math.log(8) / Math.log(2)` is
+// 2.9999999999999996, and the log `nice` floors that logarithm — so the generic
+// form would round a domain endpoint down a whole decade.
+const logp = (base) => base === Math.E
+    ? Math.log
+    : base === 10
+        ? Math.log10
+        : base === 2
+            ? Math.log2
+            : (x) => Math.log(x) / Math.log(base);
+const powp = (base) => base === 10
+    ? (x) => (Number.isFinite(x) ? +`1e${x}` : Math.max(x, 0))
+    : base === Math.E
+        ? Math.exp
+        : (x) => base ** x;
+// sign(x) * log1p(|x / c|). Unlike a log scale it is defined at 0 — and either
+// side of it — which is the whole reason it is here: coverage that touches
+// zero, and log-ratio data that crosses it, have no log domain at all.
+//
+// `constant` is not decoration. At c = 1 this IS log(x + 1), which flattens any
+// data living below 1 (p-values, fractions) into the linear part of the curve
+// and throws away exactly the resolution such a track is read for. Shrinking c
+// moves the linear knee down to where the interesting values are.
+const symlog = (c) => (x) => Math.sign(x) * Math.log1p(Math.abs(x / c));
+// A wholly negative log domain is handled by reflection — d3 negates the input,
+// takes the logarithm, and negates the result — which is what lets a log scale
+// run from -100 to -1. `getNiceDomain` floors its own log domains above zero,
+// so this is for callers reaching `getScale` directly.
+const reflect = (f) => (x) => -f(-x);
+const logsFor = (spec) => {
+    const log = logp(spec.base ?? 10);
+    return spec.domain[0] < 0 ? reflect(log) : log;
+};
+const powsFor = (spec) => {
+    const pow = powp(spec.base ?? 10);
+    return spec.domain[0] < 0 ? reflect(pow) : pow;
+};
+/** The spec's transform. */
+function transformFor(spec) {
+    if (spec.kind === 'symlog') {
+        return symlog(spec.constant ?? 1);
+    }
+    if (spec.kind === 'log') {
+        // Natural log whatever the base, which is what d3 maps values through:
+        // `loggish` keeps the base-specific pair for nice() and ticks() only. The
+        // base cancels in the normalized interpolation algebraically, but log2 and
+        // log disagree in the last bit and the parity table compares exactly.
+        return spec.domain[0] < 0 ? x => -Math.log(-x) : Math.log;
+    }
+    return x => x;
+}
+/**
+ * Where `x` lands in the range.
+ *
+ * The arithmetic is d3's bimap, expression for expression — normalize to t,
+ * then `r0 * (1 - t) + r1 * t`, with the endpoints swapped for a descending
+ * domain. The algebraically identical `r0 + t * (r1 - r0)` differs in the last
+ * bit, which `scaleParity.test.ts` compares exactly and rejects.
+ *
+ * A zero-width domain returns the range's midpoint rather than dividing by
+ * zero, which is d3's behaviour and the one a flat track wants: every score
+ * equal means every bar at the same height, not every bar at NaN.
+ */
+export function scaleValue(spec, x) {
+    const transform = transformFor(spec);
+    const t0 = transform(spec.domain[0]);
+    const t1 = transform(spec.domain[1]);
+    const [r0, r1] = spec.range;
+    const [a, b, ra, rb] = t1 < t0 ? [t1, t0, r1, r0] : [t0, t1, r0, r1];
+    const span = b - a;
+    if (!span) {
+        return Number.isNaN(span) ? NaN : (ra + rb) / 2;
+    }
+    const t = (transform(x) - a) / span;
+    return ra * (1 - t) + rb * t;
+}
+/** The domain rounded out to tick boundaries — d3's `nice`. */
+export function niceDomain(spec, count = 10) {
+    if (spec.kind === 'log') {
+        const logs = logsFor(spec);
+        const pows = powsFor(spec);
+        return [
+            pows(Math.floor(logs(spec.domain[0]))),
+            pows(Math.ceil(logs(spec.domain[1]))),
+        ];
+    }
+    // d3's linearish.nice, which symlog composes too: widen to the tick step,
+    // then re-derive the step from the widened domain until it stops moving,
+    // because widening can change which step tickIncrement picks.
+    let [start, stop] = spec.domain;
+    const flip = stop < start;
+    if (flip) {
+        ;
+        [start, stop] = [stop, start];
+    }
+    // The widened endpoints are COMMITTED only where the step converges, which
+    // is d3's own control flow and not a detail: a degenerate domain — [5, 5],
+    // what a flat coverage track hands over — drives the step to -Infinity and
+    // the endpoints to NaN on the first pass. d3 leaves such a domain alone;
+    // returning the intermediate values instead gives the axis a NaN domain.
+    let prestep;
+    for (let iter = 0; iter < 10; iter++) {
+        const step = tickIncrement(start, stop, count);
+        if (step === prestep) {
+            return flip ? [stop, start] : [start, stop];
+        }
+        if (step > 0) {
+            start = Math.floor(start / step) * step;
+            stop = Math.ceil(stop / step) * step;
+        }
+        else if (step < 0) {
+            start = Math.ceil(start * step) / step;
+            stop = Math.floor(stop * step) / step;
+        }
+        else {
+            break;
+        }
+        prestep = step;
+    }
+    return [spec.domain[0], spec.domain[1]];
+}
+/**
+ * Tick values inside the domain. Log ticks sit at every k×base^i — 2, 4, 8 for
+ * base 2 — falling back to linear ticks when the domain spans too many powers
+ * to enumerate, or too few to fill the count.
+ */
+export function scaleTicks(spec, count = 10) {
+    if (spec.kind !== 'log') {
+        return linearTicks(spec.domain[0], spec.domain[1], count);
+    }
+    const base = spec.base ?? 10;
+    const logs = logsFor(spec);
+    const pows = powsFor(spec);
+    let [u, v] = spec.domain;
+    const reverse = v < u;
+    if (reverse) {
+        ;
+        [u, v] = [v, u];
+    }
+    let i = logs(u);
+    const j0 = logs(v);
+    // `!(j0 - i < count)`, not `>= count`: a negative domain makes both
+    // logarithms NaN, and every comparison against NaN is false — so the `>=`
+    // spelling falls through to the enumeration below and invents linear ticks
+    // for a domain d3 declines to tick at all.
+    if (base % 1 || !(j0 - i < count)) {
+        return linearTicks(i, j0, Math.min(j0 - i, count)).map(pows);
+    }
+    const j = Math.ceil(j0);
+    i = Math.floor(i);
+    // Ascending multipliers for a positive domain, descending for a negative one,
+    // so the ticks come out in increasing order either way.
+    const ks = Array.from({ length: base - 1 }, (_, k) => u > 0 ? k + 1 : base - 1 - k);
+    const out = [];
+    for (; i <= j; ++i) {
+        for (const k of ks) {
+            const t = (u > 0 ? i < 0 : i > 0) ? k / pows(-i) : k * pows(i);
+            if (t < u) {
+                continue;
+            }
+            if (t > v) {
+                break;
+            }
+            out.push(t);
+        }
+    }
+    if (out.length * 2 < count) {
+        return linearTicks(u, v, count);
+    }
+    return reverse ? out.reverse() : out;
+}

package/esm/visibleStatsDomain.d.ts

@@ -0,0 +1,59 @@
+/**
+ * One visible block's worth of one stats-bearing thing, carrying the block span
+ * it is clipped to: a wiggle source's feature arrays, a coverage region, a
+ * region's worker-shipped extremes.
+ */
+export interface VisibleEntry<T> {
+    visStart: number;
+    visEnd: number;
+    data: T;
+}
+/**
+ * The half of the containing view this reads.
+ *
+ * `settledDynamicBlocks` — the 500ms-debounced coarse blocks once the view has
+ * settled once, the live ones before that — so a per-bp or per-feature scan
+ * doesn't recompute on every animation frame during pan/zoom. Not
+ * `coarseDynamicBlocks`: over the empty initial coarse list every walker below
+ * yields no entries, and no entries is not a stale domain but the caller's
+ * `[0, 1]` fallback — a bigwig line track drew blank and a density track solid.
+ * ARCHITECTURE.md, "Every fetch autorun runs on the leading edge".
+ */
+export interface SettledBlocksView {
+    initialized: boolean;
+    settledDynamicBlocks: {
+        start: number;
+        end: number;
+        displayedRegionIndex?: number;
+    }[];
+}
+/**
+ * How one display gets from its per-region fetch results to a score domain. The
+ * walk, the readiness guard and the bounded nice-rounding are the same for all
+ * of them; what differs is where a region's payload lives, which pieces of it
+ * are in scope, how those pieces reduce to stats, and what an autoscale mode
+ * makes of the stats.
+ */
+export interface VisibleStatsDomainSpec<Payload, Item, Stats> {
+    /** false when the band this domain scales is not drawn: nothing is walked */
+    active: boolean;
+    view: SettledBlocksView;
+    payloadFor: (displayedRegionIndex: number) => Payload | undefined;
+    /** the payload's stats-bearing pieces, already filtered to what is shown */
+    itemsFor: (payload: Payload) => Item[];
+    accumulate: (entries: VisibleEntry<Item>[]) => Stats | undefined;
+    /** stats to a raw `[min, max]`, before bounds and nice-rounding */
+    range: (stats: Stats, entries: VisibleEntry<Item>[]) => [number, number];
+    /** `ScoreScaleMixin`'s resolved bounds; `undefined` autoscales that end */
+    bounds: readonly [number | undefined, number | undefined];
+    scaleType: string;
+}
+/**
+ * #api
+ * 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.
+ */
+export declare function visibleStatsDomain<Payload, Item, Stats>({ active, view, payloadFor, itemsFor, accumulate, range, bounds, scaleType, }: VisibleStatsDomainSpec<Payload, Item, Stats>): [number, number] | undefined;

package/esm/visibleStatsDomain.js

@@ -0,0 +1,33 @@
+import { getNiceDomain } from './scale.js';
+/**
+ * #api
+ * 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.
+ */
+export function visibleStatsDomain({ active, view, payloadFor, itemsFor, accumulate, range, bounds, scaleType, }) {
+    let domain;
+    if (active && view.initialized) {
+        const entries = view.settledDynamicBlocks.flatMap(block => {
+            const payload = block.displayedRegionIndex === undefined
+                ? undefined
+                : payloadFor(block.displayedRegionIndex);
+            const visStart = Math.floor(block.start);
+            const visEnd = Math.ceil(block.end);
+            return payload
+                ? itemsFor(payload).map(data => ({ visStart, visEnd, data }))
+                : [];
+        });
+        const stats = accumulate(entries);
+        if (stats) {
+            domain = getNiceDomain({
+                domain: range(stats, entries),
+                bounds,
+                scaleType,
+            });
+        }
+    }
+    return domain;
+}

package/esm/wiggleRenderModes.generated.d.ts

@@ -0,0 +1,9 @@
+export declare const RENDERING_TYPE_XYPLOT = 0;
+export declare const RENDERING_TYPE_DENSITY = 1;
+export declare const RENDERING_TYPE_LINE = 2;
+export declare const RENDERING_TYPE_SCATTER = 3;
+export declare const RENDERING_TYPE_LINE_CENTER = 4;
+export declare const SCALE_TYPE_LOG = 1;
+export declare const SCALE_TYPE_SYMLOG = 2;
+export declare const NO_PREV_START = 4294967295;
+export declare const MIN_FILL_WIDTH_PX = 1.5;

package/esm/wiggleRenderModes.generated.js

@@ -0,0 +1,11 @@
+// AUTO-GENERATED by packages/shader-tools/src/shader-codegen from wiggleCommon.slang.
+// Do not edit. Run `pnpm gen:shaders` to regenerate.
+export const RENDERING_TYPE_XYPLOT = 0;
+export const RENDERING_TYPE_DENSITY = 1;
+export const RENDERING_TYPE_LINE = 2;
+export const RENDERING_TYPE_SCATTER = 3;
+export const RENDERING_TYPE_LINE_CENTER = 4;
+export const SCALE_TYPE_LOG = 1;
+export const SCALE_TYPE_SYMLOG = 2;
+export const NO_PREV_START = 4294967295;
+export const MIN_FILL_WIDTH_PX = 1.5;

package/esm/yScaleTicks.d.ts

@@ -0,0 +1,59 @@
+export interface YScaleTicks {
+    items: {
+        value: number;
+        y: number;
+        label?: string;
+    }[];
+    yTop: number;
+    yBottom: number;
+}
+/**
+ * The plot box a wiggle-family display insets inside its own height, for both
+ * sides of the contract above: the renderer positions its canvas at `yTop` and
+ * draws `plotHeight` tall, and the axis puts domain-max at `yTop` and
+ * domain-min at `yBottom`.
+ *
+ * One function because the two have to agree exactly, and `height - 2 * offset`
+ * spelled out at each end is how they stopped: `computeYTicks` derived its own
+ * bottom as `height - offset - 1`, and every tick above it inherited a fraction
+ * of that pixel.
+ */
+export declare function axisPlotBox(height: number, offset?: number): {
+    yTop: number;
+    yBottom: number;
+    plotHeight: number;
+};
+/**
+ * Screen y for an already-normalized ([0,1], 0 at domain-min) score. The
+ * composition of {@link axisPlotBox} with a `makeScoreNormalizer` result, which
+ * is what a tick at that score must land on.
+ */
+export declare function scoreToAxisY(normalized: number, box: ReturnType<typeof axisPlotBox>): number;
+/**
+ * Width of the gutter a left-oriented {@link YScaleBar} is drawn in, and the x
+ * inside that gutter its spine goes at.
+ *
+ * `YScaleBar` grows its ticks and numbers *away* from the spine, so a
+ * left-oriented axis has to inset its spine by the label width or the labels
+ * land at negative x — which is what once put an exported coverage axis off the
+ * image entirely. Both numbers live here, beside the component whose own
+ * geometry (`x = ±9`, `fontSize 10`, `textAnchor: end`) is what makes them the
+ * right ones: the alignments coverage axis and the MAF band axes had each
+ * arrived at this same 50/45 pair independently, so a change to the labels moved
+ * neither.
+ *
+ * An axis drawn over its own plot rather than in reserved space may narrow the
+ * gutter — every px of it is a px of data hidden. Such an axis still places its
+ * spine at `width - 1`, the same rule stated against its own width.
+ */
+export declare const AXIS_GUTTER_WIDTH_PX = 50;
+export declare function leftAxisSpineX(gutterLeft?: number): number;
+/**
+ * Keep a 1px stroke's center inside the axis box. At `yBottom` — the box's own
+ * bottom edge — the stroke has to cover the pixel *above* the boundary, since
+ * the one below belongs to whatever is drawn next; in multi-wiggle, where rows
+ * stack edge to edge, that is literally the next sample's first row of pixels.
+ * Callers pass whatever stroke center their own convention gives (the axis
+ * crispens to `y + 0.5`, the guide lines don't); only the bottom edge moves.
+ */
+export declare function clampStrokeInsideAxis(strokeY: number, yBottom: number): number;

package/esm/yScaleTicks.js

@@ -0,0 +1,59 @@
+import { YSCALEBAR_LABEL_OFFSET } from './constants.js';
+/**
+ * The plot box a wiggle-family display insets inside its own height, for both
+ * sides of the contract above: the renderer positions its canvas at `yTop` and
+ * draws `plotHeight` tall, and the axis puts domain-max at `yTop` and
+ * domain-min at `yBottom`.
+ *
+ * One function because the two have to agree exactly, and `height - 2 * offset`
+ * spelled out at each end is how they stopped: `computeYTicks` derived its own
+ * bottom as `height - offset - 1`, and every tick above it inherited a fraction
+ * of that pixel.
+ */
+export function axisPlotBox(height, offset = YSCALEBAR_LABEL_OFFSET) {
+    return {
+        yTop: offset,
+        yBottom: height - offset,
+        plotHeight: height - 2 * offset,
+    };
+}
+/**
+ * Screen y for an already-normalized ([0,1], 0 at domain-min) score. The
+ * composition of {@link axisPlotBox} with a `makeScoreNormalizer` result, which
+ * is what a tick at that score must land on.
+ */
+export function scoreToAxisY(normalized, box) {
+    return box.yTop + (1 - normalized) * box.plotHeight;
+}
+/**
+ * Width of the gutter a left-oriented {@link YScaleBar} is drawn in, and the x
+ * inside that gutter its spine goes at.
+ *
+ * `YScaleBar` grows its ticks and numbers *away* from the spine, so a
+ * left-oriented axis has to inset its spine by the label width or the labels
+ * land at negative x — which is what once put an exported coverage axis off the
+ * image entirely. Both numbers live here, beside the component whose own
+ * geometry (`x = ±9`, `fontSize 10`, `textAnchor: end`) is what makes them the
+ * right ones: the alignments coverage axis and the MAF band axes had each
+ * arrived at this same 50/45 pair independently, so a change to the labels moved
+ * neither.
+ *
+ * An axis drawn over its own plot rather than in reserved space may narrow the
+ * gutter — every px of it is a px of data hidden. Such an axis still places its
+ * spine at `width - 1`, the same rule stated against its own width.
+ */
+export const AXIS_GUTTER_WIDTH_PX = 50;
+export function leftAxisSpineX(gutterLeft = 0) {
+    return gutterLeft + AXIS_GUTTER_WIDTH_PX - YSCALEBAR_LABEL_OFFSET;
+}
+/**
+ * Keep a 1px stroke's center inside the axis box. At `yBottom` — the box's own
+ * bottom edge — the stroke has to cover the pixel *above* the boundary, since
+ * the one below belongs to whatever is drawn next; in multi-wiggle, where rows
+ * stack edge to edge, that is literally the next sample's first row of pixels.
+ * Callers pass whatever stroke center their own convention gives (the axis
+ * crispens to `y + 0.5`, the guide lines don't); only the bottom edge moves.
+ */
+export function clampStrokeInsideAxis(strokeY, yBottom) {
+    return Math.min(strokeY, yBottom - 0.5);
+}