@jbrowse/wiggle-core 4.3.0

package/esm/computeYTicks.d.ts

@@ -0,0 +1,15 @@
+import type { YScaleTicks } from './yScaleTicks.ts';
+export declare function computeYTicks(opts: {
+    height: number;
+    domain: [number, number] | number[] | undefined;
+    scaleType: string;
+    minimalTicks: boolean;
+    offset?: number;
+    /**
+     * Raw config value for symlog; `0` means "derive from the domain". Passed
+     * through to `getScale` so the axis is built with the constant the renderer
+     * normalizes with — resolving them separately would label ticks at heights
+     * the bars are not drawn at.
+     */
+    symlogConstant?: number;
+}): YScaleTicks | undefined;

package/esm/computeYTicks.js

@@ -0,0 +1,44 @@
+import { YSCALEBAR_LABEL_OFFSET } from './constants.js';
+import { getScale } from './scale.js';
+import { axisPlotBox } from './yScaleTicks.js';
+// Builds Y-axis tick positions for a wiggle-family display: tick values come
+// from d3's scale.ticks(4) at normal heights, or fall back to the domain
+// endpoints for short tracks / when the user opts into minimal ticks.
+export function computeYTicks(opts) {
+    const { height, domain, scaleType, minimalTicks, offset = YSCALEBAR_LABEL_OFFSET, symlogConstant, } = opts;
+    const domainMin = domain?.[0];
+    const domainMax = domain?.[1];
+    if (domainMin === undefined || domainMax === undefined) {
+        return undefined;
+    }
+    // The same box the renderer paints into, so a tick lands on its own data. It
+    // used to end a pixel short of it, to keep the spine's 1px stroke inside
+    // multi-wiggle's row — that belongs in the drawing, and is now
+    // `clampStrokeInsideAxis`.
+    const { yTop, yBottom } = axisPlotBox(height, offset);
+    // A window whose scores are all one value (an all-zero coverage stretch) has
+    // a domain of no width. d3 answers the midpoint for every input there while
+    // `makeScoreNormalizer` answers 0, and the renderer is the one to agree with.
+    if (domainMin === domainMax) {
+        return { items: [{ value: domainMin, y: yBottom }], yTop, yBottom };
+    }
+    // `nice: false`: the caller's domain is the one the renderer is drawing with
+    // (every wiggle-family `domain` getter has already been through
+    // getNiceDomain), so nicing it a second time would move the axis off the
+    // plot. It was a no-op only because every caller pre-nices — hand this a raw
+    // [1, 1000] and it re-niced to [1, 1024], drawing a labelled tick at a value
+    // the data never reaches.
+    const scale = getScale({
+        scaleType,
+        domain: [domainMin, domainMax],
+        range: [yBottom, yTop],
+        symlogConstant,
+        nice: false,
+    });
+    const values = height < 100 || minimalTicks ? [domainMin, domainMax] : scale.ticks(4);
+    return {
+        items: values.map(v => ({ value: v, y: scale(v) })),
+        yTop,
+        yBottom,
+    };
+}

package/esm/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const YSCALEBAR_LABEL_OFFSET = 5;
+export declare const ONSCREEN_AXIS_LEFT_PX = 50;

package/esm/constants.js

@@ -0,0 +1,10 @@
+// Vertical inset the single-wiggle family reserves above and below the plot so
+// the top/bottom y-axis labels aren't clipped. Lives in its own module because
+// both index.ts (which re-exports computeYTicks) and computeYTicks.ts need it —
+// importing it from index.ts would close a cycle.
+export const YSCALEBAR_LABEL_OFFSET = 5;
+// Left indent of the on-screen y-axis overlay (single-wiggle / manhattan) and of
+// multi-wiggle's per-row scalebars. The axis is right-oriented on screen, so its
+// labels grow into the plot from here; the indent keeps them clear of the track
+// label. Export uses its own anchor (the content left edge).
+export const ONSCREEN_AXIS_LEFT_PX = 50;

package/esm/dataTypes.d.ts

@@ -0,0 +1,26 @@
+export interface SourceInfo {
+    name: string;
+    color?: string;
+    labelColor?: string;
+    label?: string;
+    group?: string;
+    baseUri?: string;
+}
+export interface WiggleFeatureArrays {
+    featurePositions: Uint32Array;
+    featureScores: Float32Array;
+    featureMinScores: Float32Array;
+    featureMaxScores: Float32Array;
+    numFeatures: number;
+    hasSummaryScores: boolean;
+    posFeaturePositions: Uint32Array;
+    posFeatureScores: Float32Array;
+    posNumFeatures: number;
+    negFeaturePositions: Uint32Array;
+    negFeatureScores: Float32Array;
+    negNumFeatures: number;
+}
+export type WiggleSourceData = SourceInfo & WiggleFeatureArrays;
+export interface WiggleDataResult {
+    sources: WiggleSourceData[];
+}

package/esm/dataTypes.js

@@ -0,0 +1 @@
+export {};

package/esm/displayModel.d.ts

@@ -0,0 +1,24 @@
+import type { WiggleDataResult } from './dataTypes.ts';
+import type { WiggleRenderingBackend } from './renderingBackendTypes.ts';
+import type { YScaleTicks } from './yScaleTicks.ts';
+import type { RegionHost } from '@jbrowse/display-kit/regionHost';
+import type { DisplayPhase } from '@jbrowse/render-core/displayPhase';
+import type { RenderLifecycleModel } from '@jbrowse/render-core/useRenderingBackend';
+export interface WiggleGpuDisplayModel<TRenderingBackend = WiggleRenderingBackend, TData = WiggleDataResult> extends RenderLifecycleModel<TRenderingBackend> {
+    rpcDataMap: ReadonlyMap<number, TData>;
+    host: RegionHost;
+    ticks?: YScaleTicks;
+    canvasDrawn: boolean;
+    painted: boolean;
+    height: number;
+    canvasWidthPx: number;
+    error: unknown;
+    displayPhase: DisplayPhase;
+    statusMessage?: string;
+    reload: () => void;
+    regionTooLarge: boolean;
+    regionTooLargeReason: string;
+    zoomCanReleaseGate: boolean;
+    forceLoad: () => void;
+    showCrossHatches: boolean;
+}

package/esm/displayModel.js

@@ -0,0 +1 @@
+export {};

package/esm/formatNumber.d.ts

@@ -0,0 +1 @@
+export declare function toP(s?: number, precision?: number): number;

package/esm/formatNumber.js

@@ -0,0 +1,6 @@
+// Format a number to `precision` significant figures, coercing the result back
+// to a number so trailing zeros are dropped (5.000 -> 5, 0.8500 -> 0.85).
+// Shared by the wiggle and GWAS tooltips so score/r² formatting stays uniform.
+export function toP(s = 0, precision = 6) {
+    return +s.toPrecision(precision);
+}

package/esm/gapBreak.d.ts

@@ -0,0 +1,59 @@
+/**
+ * #api
+ * How far apart two consecutive points of an interpolated (point-to-point) line
+ * 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.
+ *
+ * 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
+ * *less* — a line that stays connected is the status quo, whereas a spuriously
+ * broken one destroys data the user can see nowhere else. Sorting for a true
+ * median would cost O(n log n) per source per region on the encode path, for a
+ * threshold this coarse.
+ *
+ * `count < 3` returns Infinity: two points have no "typical" spacing to be
+ * unusual against, so there is nothing to call a hole.
+ */
+export declare function gapBreakLimit({ first, last, count, multiple, }: {
+    /** position of the first point, in whatever space the caller measures gaps */
+    first: number;
+    /** position of the last point, same space */
+    last: number;
+    /** number of points in the series */
+    count: number;
+    /** how many mean spacings a gap must exceed; <= 0 disables breaking */
+    multiple: number;
+}): number;
+/**
+ * #api
+ * Default `multiple` for the wiggle interpolated line — the `maxGapMultiple`
+ * config slot's default. 0 means the line never breaks: one connected polyline
+ * across every hole, which is how the interpolated line behaved before gap
+ * breaking existed.
+ *
+ * OFF BY DEFAULT, deliberately and after having been on. It shipped at 20 and
+ * the calibration behind that number still holds — a hole worth breaking on runs
+ * orders of magnitude past the mean, and bbi's reduced zoom levels emit
+ * fixed-width bins so the series tiles (measured on volvox_microarray.bw at
+ * three zooms: 500 bins, every gap exactly 1.0x the mean, no break at any
+ * threshold). What changed is the call about whether a reader wants the break at
+ * all: "we added this feature awhile back but i dont think i like it now. might
+ * consider going back to not skipping". A broken line reads as missing data
+ * whether or not
+ * data is missing there, and the chord across a hole is at least continuous with
+ * what the neighbouring points say.
+ *
+ * The mechanism stays, whole, because it is the only way to get the other
+ * behavior back: set `maxGapMultiple` on the track, 20 being the calibrated
+ * value. Nothing about `gapBreakLimit` itself changes — a caller passing a
+ * positive multiple gets exactly what it always got.
+ */
+export declare const DEFAULT_GAP_BREAK_MULTIPLE = 0;

package/esm/gapBreak.js

@@ -0,0 +1,58 @@
+/**
+ * #api
+ * How far apart two consecutive points of an interpolated (point-to-point) line
+ * 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.
+ *
+ * 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
+ * *less* — a line that stays connected is the status quo, whereas a spuriously
+ * broken one destroys data the user can see nowhere else. Sorting for a true
+ * median would cost O(n log n) per source per region on the encode path, for a
+ * threshold this coarse.
+ *
+ * `count < 3` returns Infinity: two points have no "typical" spacing to be
+ * unusual against, so there is nothing to call a hole.
+ */
+export function gapBreakLimit({ first, last, count, multiple, }) {
+    if (multiple <= 0 || count < 3) {
+        return Number.POSITIVE_INFINITY;
+    }
+    const meanSpacing = (last - first) / (count - 1);
+    // A degenerate series (every point at the same position) has no spacing to
+    // scale by, and a limit of 0 would break every segment.
+    return meanSpacing > 0 ? meanSpacing * multiple : Number.POSITIVE_INFINITY;
+}
+/**
+ * #api
+ * Default `multiple` for the wiggle interpolated line — the `maxGapMultiple`
+ * config slot's default. 0 means the line never breaks: one connected polyline
+ * across every hole, which is how the interpolated line behaved before gap
+ * breaking existed.
+ *
+ * OFF BY DEFAULT, deliberately and after having been on. It shipped at 20 and
+ * the calibration behind that number still holds — a hole worth breaking on runs
+ * orders of magnitude past the mean, and bbi's reduced zoom levels emit
+ * fixed-width bins so the series tiles (measured on volvox_microarray.bw at
+ * three zooms: 500 bins, every gap exactly 1.0x the mean, no break at any
+ * threshold). What changed is the call about whether a reader wants the break at
+ * all: "we added this feature awhile back but i dont think i like it now. might
+ * consider going back to not skipping". A broken line reads as missing data
+ * whether or not
+ * data is missing there, and the chord across a hole is at least continuous with
+ * what the neighbouring points say.
+ *
+ * The mechanism stays, whole, because it is the only way to get the other
+ * behavior back: set `maxGapMultiple` on the track, 20 being the calibrated
+ * value. Nothing about `gapBreakLimit` itself changes — a caller passing a
+ * positive multiple gets exactly what it always got.
+ */
+export const DEFAULT_GAP_BREAK_MULTIPLE = 0;

package/esm/index.d.ts

@@ -0,0 +1,36 @@
+export { scoreAxisConfigSchemaFields } from './scoreAxisConfigSchemaFields.ts';
+export type { ScoreAxisConfigModel } from './scoreAxisConfigSchemaFields.ts';
+export { getNiceDomain, getNiceScale, getScale } from './scale.ts';
+export type { ScaleOpts } from './scale.ts';
+export { toP } from './formatNumber.ts';
+export { SCALE_TYPE_LINEAR, SCALE_TYPE_LOG, SCALE_TYPE_SYMLOG, makeScoreNormalizer, resolveSymlogConstant, scaleTypeFromString, } from './normalize.ts';
+export type { WiggleScaleType } from './normalize.ts';
+export { autoscaleDomainFromStats, computeAutoscaleDomain, computeScoreStats, domainFromStats, getEffectiveScores, } from './autoscale.ts';
+export type { Dataset, FeatureArrays, ScoreStats } from './autoscale.ts';
+export { ONSCREEN_AXIS_LEFT_PX, YSCALEBAR_LABEL_OFFSET } from './constants.ts';
+export { computeYTicks } from './computeYTicks.ts';
+export { resolveRenderState } from './resolveRenderState.ts';
+export { visibleStatsDomain } from './visibleStatsDomain.ts';
+export type { SettledBlocksView, VisibleEntry, VisibleStatsDomainSpec, } from './visibleStatsDomain.ts';
+export { AXIS_GUTTER_WIDTH_PX, axisPlotBox, clampStrokeInsideAxis, leftAxisSpineX, scoreToAxisY, } from './yScaleTicks.ts';
+export type { YScaleTicks } from './yScaleTicks.ts';
+export { CrossHatchLines, default as CrossHatches } from './CrossHatches.tsx';
+export { ScoreRuleLines, default as ScoreRules } from './ScoreRules.tsx';
+export { parseScoreRules, scoreRuleMarks, widenRangeToRules, } from './scoreRuleMarks.ts';
+export type { ScoreRule, ScoreRuleMark } from './scoreRuleMarks.ts';
+export { makeResolutionSubMenuItem } from './ResolutionStepper.tsx';
+export { makeScatterPointSizeMenuItem } from './pointSizeMenu.tsx';
+export { SMALL_POINT_MAX_DIAMETER_PX, appendPointMarker, } from './pointMarker.ts';
+export { default as SetMinMaxDialog } from './SetMinMaxDialog.tsx';
+export { DEFAULT_AUTOSCALE_OPTIONS } from './autoscale.ts';
+export { makeAutoscaleTypeSubMenu, makeCrossHatchItem, makeScaleTypeSubMenu, makeScoreSubMenu, makeSetMinMaxScoreItem, } from './scoreMenuItems.ts';
+export type { ScoreScaleModel } from './scoreMenuItems.ts';
+export { ScoreScaleMixin } from './ScoreScaleMixin.ts';
+export { default as YScaleBar } from './YScaleBar.tsx';
+export { default as YScaleBarOverlay } from './YScaleBarOverlay.tsx';
+export { MIN_FILL_WIDTH_PX, NO_PREV_START, RENDERING_TYPE_DENSITY, RENDERING_TYPE_LINE, RENDERING_TYPE_LINE_CENTER, RENDERING_TYPE_SCATTER, RENDERING_TYPE_XYPLOT, } from './renderingBackendTypes.ts';
+export type { SourceRenderData, WiggleGPURenderState, WiggleRenderingBackend, WiggleRenderingType, } from './renderingBackendTypes.ts';
+export type { SourceInfo, WiggleDataResult, WiggleFeatureArrays, WiggleSourceData, } from './dataTypes.ts';
+export { type WiggleGpuDisplayModel } from './displayModel.ts';
+export { collectWiggleTransferables } from './transferables.ts';
+export { DEFAULT_GAP_BREAK_MULTIPLE, gapBreakLimit } from './gapBreak.ts';

package/esm/index.js

@@ -0,0 +1,26 @@
+export { scoreAxisConfigSchemaFields } from './scoreAxisConfigSchemaFields.js';
+export { getNiceDomain, getNiceScale, getScale } from './scale.js';
+export { toP } from './formatNumber.js';
+export { SCALE_TYPE_LINEAR, SCALE_TYPE_LOG, SCALE_TYPE_SYMLOG, makeScoreNormalizer, resolveSymlogConstant, scaleTypeFromString, } from './normalize.js';
+export { autoscaleDomainFromStats, computeAutoscaleDomain, computeScoreStats, domainFromStats, getEffectiveScores, } from './autoscale.js';
+export { ONSCREEN_AXIS_LEFT_PX, YSCALEBAR_LABEL_OFFSET } from './constants.js';
+export { computeYTicks } from './computeYTicks.js';
+export { resolveRenderState } from './resolveRenderState.js';
+export { visibleStatsDomain } from './visibleStatsDomain.js';
+export { AXIS_GUTTER_WIDTH_PX, axisPlotBox, clampStrokeInsideAxis, leftAxisSpineX, scoreToAxisY, } from './yScaleTicks.js';
+export { CrossHatchLines, default as CrossHatches } from './CrossHatches.js';
+export { ScoreRuleLines, default as ScoreRules } from './ScoreRules.js';
+export { parseScoreRules, scoreRuleMarks, widenRangeToRules, } from './scoreRuleMarks.js';
+export { makeResolutionSubMenuItem } from './ResolutionStepper.js';
+export { makeScatterPointSizeMenuItem } from './pointSizeMenu.js';
+export { SMALL_POINT_MAX_DIAMETER_PX, appendPointMarker, } from './pointMarker.js';
+export { default as SetMinMaxDialog } from './SetMinMaxDialog.js';
+export { DEFAULT_AUTOSCALE_OPTIONS } from './autoscale.js';
+export { makeAutoscaleTypeSubMenu, makeCrossHatchItem, makeScaleTypeSubMenu, makeScoreSubMenu, makeSetMinMaxScoreItem, } from './scoreMenuItems.js';
+export { ScoreScaleMixin } from './ScoreScaleMixin.js';
+export { default as YScaleBar } from './YScaleBar.js';
+export { default as YScaleBarOverlay } from './YScaleBarOverlay.js';
+export { MIN_FILL_WIDTH_PX, NO_PREV_START, RENDERING_TYPE_DENSITY, RENDERING_TYPE_LINE, RENDERING_TYPE_LINE_CENTER, RENDERING_TYPE_SCATTER, RENDERING_TYPE_XYPLOT, } from './renderingBackendTypes.js';
+export {} from './displayModel.js';
+export { collectWiggleTransferables } from './transferables.js';
+export { DEFAULT_GAP_BREAK_MULTIPLE, gapBreakLimit } from './gapBreak.js';

package/esm/normalize.d.ts

@@ -0,0 +1,40 @@
+export type WiggleScaleType = 0 | 1 | 2;
+export declare const SCALE_TYPE_LINEAR: WiggleScaleType;
+export declare const SCALE_TYPE_LOG: WiggleScaleType;
+export declare const SCALE_TYPE_SYMLOG: WiggleScaleType;
+/**
+ * #api
+ * Maps the `'log'`/`'symlog'`/`'linear'` string to the numeric
+ * `WiggleScaleType`.
+ */
+export declare function scaleTypeFromString(scaleType: string): WiggleScaleType;
+/**
+ * #api
+ * The symlog constant actually used for a domain. `0` (the config default)
+ * means "pick one from the domain": a thousandth of its largest magnitude, so
+ * the log-ish part of the curve covers the top three decades of whatever the
+ * track holds and the linear knee sits below the data rather than through it.
+ *
+ * The alternative — d3's default of 1 — is `log(x + 1)`, which is fine for read
+ * depth and useless for anything living below 1, because the entire domain then
+ * falls in the linear part of the curve. A p-value track configured that way is
+ * just a linear track wearing a log label, which is the reason this is resolved
+ * rather than hard-coded.
+ */
+export declare function resolveSymlogConstant(min: number, max: number, configured: number): number;
+/**
+ * #api
+ * 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 {@link 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.
+ */
+export declare function makeScoreNormalizer(min: number, max: number, scaleType: WiggleScaleType, symlogConstant?: number): (score: number) => number;

package/esm/normalize.js

@@ -0,0 +1,106 @@
+import { SCALE_TYPE_LOG as GENERATED_SCALE_TYPE_LOG, SCALE_TYPE_SYMLOG as GENERATED_SCALE_TYPE_SYMLOG, } from './wiggleRenderModes.generated.js';
+export const SCALE_TYPE_LINEAR = 0;
+// The values the `scaleType` uniform is compared against, so they are
+// wiggle.slang's own — generated in by `pnpm gen:shaders` (adr-051). LINEAR is
+// simply "neither of these".
+export const SCALE_TYPE_LOG = GENERATED_SCALE_TYPE_LOG;
+export const SCALE_TYPE_SYMLOG = GENERATED_SCALE_TYPE_SYMLOG;
+/**
+ * #api
+ * Maps the `'log'`/`'symlog'`/`'linear'` string to the numeric
+ * `WiggleScaleType`.
+ */
+export function scaleTypeFromString(scaleType) {
+    if (scaleType === 'log') {
+        return SCALE_TYPE_LOG;
+    }
+    if (scaleType === 'symlog') {
+        return SCALE_TYPE_SYMLOG;
+    }
+    return SCALE_TYPE_LINEAR;
+}
+/**
+ * #api
+ * The symlog constant actually used for a domain. `0` (the config default)
+ * means "pick one from the domain": a thousandth of its largest magnitude, so
+ * the log-ish part of the curve covers the top three decades of whatever the
+ * track holds and the linear knee sits below the data rather than through it.
+ *
+ * The alternative — d3's default of 1 — is `log(x + 1)`, which is fine for read
+ * depth and useless for anything living below 1, because the entire domain then
+ * falls in the linear part of the curve. A p-value track configured that way is
+ * just a linear track wearing a log label, which is the reason this is resolved
+ * rather than hard-coded.
+ */
+export function resolveSymlogConstant(min, max, configured) {
+    if (configured > 0) {
+        return configured;
+    }
+    const magnitude = Math.max(Math.abs(min), Math.abs(max));
+    return magnitude > 0 ? magnitude / 1000 : 1;
+}
+/** sign(x) * log1p(|x / c|) — the transform d3's scaleSymlog applies. */
+function symlog(x, c) {
+    return Math.sign(x) * Math.log1p(Math.abs(x / c));
+}
+/**
+ * #api
+ * 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 {@link 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.
+ */
+export function makeScoreNormalizer(min, max, scaleType, symlogConstant = 1) {
+    if (scaleType === SCALE_TYPE_SYMLOG) {
+        // No flooring, and no clamp of the domain away from zero: symlog is defined
+        // across the whole real line, which is the point of offering it.
+        const c = symlogConstant;
+        const tMin = symlog(min, c);
+        const tMax = symlog(max, c);
+        const tRange = tMax - tMin;
+        if (tRange <= 0) {
+            return () => 0;
+        }
+        const invRange = 1 / tRange;
+        return (score) => Math.max(0, Math.min(1, (symlog(score, c) - tMin) * invRange));
+    }
+    if (scaleType === SCALE_TYPE_LOG) {
+        // Floor at the domain's own min, not at 1. A log domain can sit entirely
+        // below 1 — a mappability track, a methylation fraction, any normalized
+        // ratio — and `getNiceDomain` deliberately keeps it there, pinning min to 1
+        // only when max > 1 (an explicit `minScore` bound can also land under 1 at
+        // any max). Flooring at 1 collapsed logMin and logMax to 0 for all of
+        // those, so `logRange === 0` and every score in the track normalized to 0:
+        // a plot flat on the baseline under an axis that, reading the same domain
+        // through d3, spread its ticks down the full height.
+        //
+        // Callers passing min = 0 — the four coverage draws, whose domain starts at
+        // no reads — still floor at 1, which is where a depth axis starts.
+        const floor = min > 0 ? min : 1;
+        const logMin = Math.log2(floor);
+        const logMax = Math.log2(Math.max(max, floor));
+        const logRange = logMax - logMin;
+        if (logRange <= 0) {
+            return () => 0;
+        }
+        const invLogRange = 1 / logRange;
+        return (score) => {
+            const logScore = Math.log2(Math.max(score, floor));
+            return Math.max(0, Math.min(1, (logScore - logMin) * invLogRange));
+        };
+    }
+    const range = max - min;
+    if (range <= 0) {
+        return () => 0;
+    }
+    const invRange = 1 / range;
+    return (score) => Math.max(0, Math.min(1, (score - min) * invRange));
+}

package/esm/pointMarker.d.ts

@@ -0,0 +1,3 @@
+import type { Ctx2D } from '@jbrowse/core/util/paintLayer';
+export declare const SMALL_POINT_MAX_DIAMETER_PX = 3;
+export declare function appendPointMarker(ctx: Ctx2D, cx: number, y: number, diameter: number): void;

package/esm/pointMarker.js

@@ -0,0 +1,27 @@
+import { crispSquareTopLeftPx } from '@jbrowse/render-core/shaders/pointGlyph';
+import { SMALL_POINT_MAX_DIAMETER } from '@jbrowse/render-core/shaders/pointGlyphConsts';
+// At/below a 3px diameter an antialiased disc reads as a blurry blob, so scatter
+// points draw as a crisp filled square below this threshold and an AA disc
+// above it. The value comes from pointGlyph.slang via `//! export-consts`, so
+// the two backends can't disagree about where the square/disc split is; the
+// alias keeps this module's long-standing public name.
+export const SMALL_POINT_MAX_DIAMETER_PX = SMALL_POINT_MAX_DIAMETER;
+// Append one scatter point marker to the current path, centered on (cx, y): a
+// crisp filled square at/below SMALL_POINT_MAX_DIAMETER_PX, else an antialiased
+// disc. Shared by the wiggle scatter and GWAS Manhattan Canvas2D paths so the
+// square/disc threshold can't drift between them or from the shader. The caller
+// owns ctx.beginPath()/ctx.fill() so many markers batch into one fill.
+export function appendPointMarker(ctx, cx, y, diameter) {
+    const radius = diameter / 2;
+    if (diameter <= SMALL_POINT_MAX_DIAMETER_PX) {
+        // Snap the top-left to the pixel grid (round-half-up) so the crisp square's
+        // fill lands on whole pixels instead of AA-blurring across columns/rows.
+        // `crispSquareTopLeftPx` is generated from pointGlyph.slang (adr-051), so
+        // this is the shader's snap rather than a re-derivation of it.
+        ctx.rect(crispSquareTopLeftPx(cx, diameter), crispSquareTopLeftPx(y, diameter), diameter, diameter);
+    }
+    else {
+        ctx.moveTo(cx + radius, y);
+        ctx.arc(cx, y, radius, 0, Math.PI * 2);
+    }
+}

package/esm/pointSizeMenu.d.ts

@@ -0,0 +1,13 @@
+import type { ConfigModelForFields, ResolvableDisplay } from '@jbrowse/core/configuration';
+import type { MenuItem } from '@jbrowse/core/ui';
+export declare function makeScatterPointSizeMenuItem(self: {
+    scatterPointSize: number;
+    setScatterPointSize: (n?: number) => void;
+} & ResolvableDisplay<ConfigModelForFields<{
+    scatterPointSize: {
+        type: 'maybeNumber';
+        promotedBase: number;
+    };
+}>>, opts: {
+    label: string;
+}): MenuItem;

package/esm/pointSizeMenu.js

@@ -0,0 +1,21 @@
+import { makePromotableSizeMenu } from '@jbrowse/core/ui';
+// Wires a display's shared `scatterPointSize`/`setScatterPointSize` (from
+// WiggleScoreConfigMixin) to makePromotableSizeMenu. Used by both the wiggle
+// scatter and GWAS Manhattan track menus so the slider/reset/pin behavior can't
+// drift. The `scatterPointSize` slot is promotable, so the row carries the
+// "default for all tracks of this type" pin.
+export function makeScatterPointSizeMenuItem(self, opts) {
+    return makePromotableSizeMenu({
+        label: opts.label,
+        title: 'Point size',
+        display: self,
+        slot: 'scatterPointSize',
+        getValue: () => self.scatterPointSize,
+        onChange: n => {
+            self.setScatterPointSize(n);
+        },
+        onReset: () => {
+            self.setScatterPointSize(undefined);
+        },
+    });
+}

package/esm/renderingBackendTypes.d.ts

@@ -0,0 +1,39 @@
+import type { WiggleScaleType } from './normalize.ts';
+import type { PerRegionRenderingBackend } from '@jbrowse/render-core/perRegionRenderingBackend';
+export type WiggleRenderingType = 0 | 1 | 2 | 3 | 4;
+export declare const RENDERING_TYPE_XYPLOT: WiggleRenderingType;
+export declare const RENDERING_TYPE_DENSITY: WiggleRenderingType;
+export declare const RENDERING_TYPE_LINE: WiggleRenderingType;
+export declare const RENDERING_TYPE_SCATTER: WiggleRenderingType;
+export declare const RENDERING_TYPE_LINE_CENTER: WiggleRenderingType;
+export declare const NO_PREV_START = 4294967295;
+export declare const MIN_FILL_WIDTH_PX = 1.5;
+export interface WiggleGPURenderState {
+    domainY: [number, number];
+    scaleType: WiggleScaleType;
+    /**
+     * symlog's linear-region width, already resolved from the domain by
+     * `resolveSymlogConstant`. Both backends read this one number so the axis,
+     * the shader and the Canvas2D fallback agree; unread by the other scales.
+     */
+    symlogConstant: number;
+    renderingType: WiggleRenderingType;
+    canvasWidth: number;
+    canvasHeight: number;
+    numRows: number;
+    scatterPointSize: number;
+    lineWidth: number;
+    origin: number;
+    densityColorRamp?: string;
+}
+export interface SourceRenderData {
+    featurePositions: Uint32Array;
+    featureScores: Float32Array;
+    numFeatures: number;
+    color: [number, number, number];
+    rowIndex: number;
+    renderingType: WiggleRenderingType;
+    colorsAbgr?: Uint32Array;
+    gapLimitBp?: number;
+}
+export type WiggleRenderingBackend = PerRegionRenderingBackend<SourceRenderData[], WiggleGPURenderState>;

package/esm/renderingBackendTypes.js

@@ -0,0 +1,29 @@
+import { MIN_FILL_WIDTH_PX as GENERATED_MIN_FILL_WIDTH_PX, NO_PREV_START as GENERATED_NO_PREV_START, RENDERING_TYPE_DENSITY as GENERATED_RENDERING_TYPE_DENSITY, RENDERING_TYPE_LINE as GENERATED_RENDERING_TYPE_LINE, RENDERING_TYPE_LINE_CENTER as GENERATED_RENDERING_TYPE_LINE_CENTER, RENDERING_TYPE_SCATTER as GENERATED_RENDERING_TYPE_SCATTER, RENDERING_TYPE_XYPLOT as GENERATED_RENDERING_TYPE_XYPLOT, } from './wiggleRenderModes.generated.js';
+// The `renderingType` uniform's vocabulary. These are wiggle.slang's own
+// numbers, generated in by `pnpm gen:shaders` (adr-051): the Canvas2D path
+// branches on them to pick a draw function while the GPU path branches on them
+// inside vs_main, so a renumbering that reached only one side would quietly
+// draw a different plot type on each backend. Declared here rather than in the
+// plugin because this is where `WiggleRenderingType` lives, and the annotations
+// are what pin each generated value into that union.
+export const RENDERING_TYPE_XYPLOT = GENERATED_RENDERING_TYPE_XYPLOT;
+export const RENDERING_TYPE_DENSITY = GENERATED_RENDERING_TYPE_DENSITY;
+export const RENDERING_TYPE_LINE = GENERATED_RENDERING_TYPE_LINE;
+export const RENDERING_TYPE_SCATTER = GENERATED_RENDERING_TYPE_SCATTER;
+// Point-to-point line: connects the score at each feature's bp midpoint to its
+// neighbor's, instead of tracing the stepped bar tops that RENDERING_TYPE_LINE
+// draws. Better for sparse/discrete data where the plateaus look wrong.
+export const RENDERING_TYPE_LINE_CENTER = GENERATED_RENDERING_TYPE_LINE_CENTER;
+// `prevStartEnd.x` sentinel meaning "no previous feature" — the source start,
+// or a hole wider than `gapLimitBp`. Larger than any genomic coordinate, so it
+// cannot collide with a real start, and the shader collapses that quad to
+// nothing. wiggle.slang's, generated in, because the encoder writes it and the
+// shader tests for it.
+export const NO_PREV_START = GENERATED_NO_PREV_START;
+// Narrowest an xyplot bar / density column paints, in CSS px, so a bin under a
+// pixel wide still shows. wiggle.slang's, generated in, because both backends
+// apply it: the shader through `extendToMinWidthX` and Canvas2D through
+// `Math.max(WIGGLE_MIN_PX, …)`, which is what re-exports this under that name.
+// It was a `1.5` in each, kept together by a comment in each pointing at the
+// other.
+export const MIN_FILL_WIDTH_PX = GENERATED_MIN_FILL_WIDTH_PX;

package/esm/resolveRenderState.d.ts

@@ -0,0 +1 @@
+export declare function resolveRenderState<T>(domain: [number, number] | undefined, build: (domain: [number, number]) => T): T;

package/esm/resolveRenderState.js

@@ -0,0 +1,20 @@
+// A region with data but no scores (empty / not covered by the file) has no
+// score range to autoscale, yet it must still render — `renderBlocks` has to run
+// to clear the canvas and flip `canvasDrawn`, or the display spins on the
+// loading overlay forever. The GPU render-state can't be *built* without a
+// domain (it encodes one for vertical scaling), so this stands in. It's inert:
+// nothing is ever plotted against it (there's no data), and every axis/legend a
+// caller draws is gated on the *real* `domain`, so it never surfaces as a fake
+// scale. The specific numbers are irrelevant — [0,1] is just a valid range.
+const EMPTY_PLOT_DOMAIN = [0, 1];
+// The render-state a wiggle-family GPU display builds from its score `domain`,
+// always resolvable (real domain, else EMPTY_PLOT_DOMAIN). This is NOT the
+// loading gate — "no fetch has completed yet" is answered by the boolean
+// `renderBlocks` returns (did a region actually draw), not by a nullable render
+// state and no longer by a per-display size check. `build` absorbs each
+// display's render-state shape (wiggle's encoded WiggleGPURenderState vs
+// manhattan's { domainY, canvasWidth, canvasHeight }), so only the empty-plot
+// domain is shared, not the construction.
+export function resolveRenderState(domain, build) {
+    return build(domain ?? EMPTY_PLOT_DOMAIN);
+}