@jbrowse/wiggle-core 5.0.0-beta.7 → 5.0.0-beta.9

package/esm/index.d.ts

@@ -1,29 +1,33 @@
-export { scoreAxisConfigSchemaFields } from './scoreAxisConfigSchemaFields.ts';
-export type { ScoreAxisConfigModel } from './scoreAxisConfigSchemaFields.ts';
+export { scalesSchema, valueScaleSchema } from './valueScaleConfigSchema.ts';
+export type { ScalesConfigSchema, ValueScaleAutoscale, ValueScaleConfigSchema, ValueScaleOptions, } from './valueScaleConfigSchema.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 { AXIS_GUTTER_WIDTH_PX, AxisGutter, CrossHatchLines, CrossHatches, SCORE_CAPTION_HEIGHT, ScoreDomainCaption, ScoreRuleLines, ScoreRules, YSCALEBAR_LABEL_OFFSET, YScaleBar, YScaleBarOverlay, axisDrawn, axisPlotBox, clampStrokeInsideAxis, scoreToAxisY, } from '@jbrowse/display-ui';
-export type { ValueScale, YAxis, YScaleTicks } from '@jbrowse/display-ui';
+export { SCALE_TYPE_LINEAR, SCALE_TYPE_LOG, SCALE_TYPE_SYMLOG, makeScoreNormalizer, resolveSymlogConstant, } from './normalize.ts';
+export { autoscaleDomainFromSpans, autoscaleDomainFromStats, computeAutoscaleDomain, computeScoreStats, computeSpanStats, datasetSpan, domainFromStats, getEffectiveScores, } from './autoscale.ts';
+export type { Dataset, FeatureArrays, ScoreSpan, ScoreStats, } from './autoscale.ts';
+export { axisDrawn } from '@jbrowse/display-ui/axisPlacement';
+export { DEFAULT_RULE_COLOR, SCORE_CAPTION_HEIGHT, YSCALEBAR_LABEL_OFFSET, } from '@jbrowse/display-ui/yAxisConstants';
+export { AXIS_GUTTER_WIDTH_PX, axisPlotBox, clampStrokeInsideAxis, scoreToAxisY, } from '@jbrowse/display-ui/yScaleTicks';
+export type { ValueScale, ValueScaleRule, YAxis, YScaleTicks, } from '@jbrowse/display-ui';
 export { computeYTicks } from './computeYTicks.ts';
 export { resolveRenderState } from './resolveRenderState.ts';
 export { visibleStatsDomain } from './visibleStatsDomain.ts';
 export type { SettledBlocksView, VisibleEntry, VisibleStatsDomainSpec, } from './visibleStatsDomain.ts';
-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 { scoreRuleMarks, widenRangeToRules } from './scoreRuleMarks.ts';
+export type { ScoreRuleMark } from './scoreRuleMarks.ts';
 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 { makeAutoscaleTypeSubMenu, makeCrossHatchItem, makePinCurrentRangeItem, makeScaleTypeSubMenu, makeScoreSubMenu, makeSetMinMaxScoreItem, } from './scoreMenuItems.ts';
+export type { AutoscaleModel, ScoreScaleModel, ScoreSubMenuOptions, } from './scoreMenuItems.ts';
+export { ScoreAxisMixin } from './ScoreAxisMixin.ts';
 export { ScoreScaleMixin } from './ScoreScaleMixin.ts';
-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 { ScoreScaleHost } from './ScoreScaleMixin.ts';
+export { WiggleScoreConfigMixin, wiggleScoreConfigExtraSlots, } from './WiggleScoreConfigMixin.ts';
+export type { WiggleScoreConfigHost } from './WiggleScoreConfigMixin.ts';
+export { ScoreFieldConfigMixin } from './ScoreFieldConfigMixin.ts';
+export { DEFAULT_SCORE_FIELD, scoreFieldConfigSchemaFields, } from './scoreFieldConfigSchemaFields.ts';
+export { MAX_WIGGLE_CUTS, 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';

package/esm/index.js

@@ -1,24 +1,28 @@
-export { scoreAxisConfigSchemaFields } from './scoreAxisConfigSchemaFields.js';
+export { scalesSchema, valueScaleSchema } from './valueScaleConfigSchema.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';
-// The y-axis primitives live in `@jbrowse/display-ui`, where the chrome
-// places them for any display declaring `valueScales`; re-exported here so
-// their published names hold.
-export { AXIS_GUTTER_WIDTH_PX, AxisGutter, CrossHatchLines, CrossHatches, SCORE_CAPTION_HEIGHT, ScoreDomainCaption, ScoreRuleLines, ScoreRules, YSCALEBAR_LABEL_OFFSET, YScaleBar, YScaleBarOverlay, axisDrawn, axisPlotBox, clampStrokeInsideAxis, scoreToAxisY, } from '@jbrowse/display-ui';
+export { SCALE_TYPE_LINEAR, SCALE_TYPE_LOG, SCALE_TYPE_SYMLOG, makeScoreNormalizer, resolveSymlogConstant, } from './normalize.js';
+export { autoscaleDomainFromSpans, autoscaleDomainFromStats, computeAutoscaleDomain, computeScoreStats, computeSpanStats, datasetSpan, domainFromStats, getEffectiveScores, } from './autoscale.js';
+// The y-axis geometry, named at its own subpaths rather than through the
+// `@jbrowse/display-ui` barrel: the barrel reaches react-dom, and reaching it
+// from here put the score math and the three config mixins behind a worker
+// stub. The components that draw the axis are `./chrome`.
+export { axisDrawn } from '@jbrowse/display-ui/axisPlacement';
+export { DEFAULT_RULE_COLOR, SCORE_CAPTION_HEIGHT, YSCALEBAR_LABEL_OFFSET, } from '@jbrowse/display-ui/yAxisConstants';
+export { AXIS_GUTTER_WIDTH_PX, axisPlotBox, clampStrokeInsideAxis, scoreToAxisY, } from '@jbrowse/display-ui/yScaleTicks';
 export { computeYTicks } from './computeYTicks.js';
 export { resolveRenderState } from './resolveRenderState.js';
 export { visibleStatsDomain } from './visibleStatsDomain.js';
-export { parseScoreRules, scoreRuleMarks, widenRangeToRules, } from './scoreRuleMarks.js';
-export { makeResolutionSubMenuItem } from './ResolutionStepper.js';
-export { makeScatterPointSizeMenuItem } from './pointSizeMenu.js';
+export { scoreRuleMarks, widenRangeToRules } from './scoreRuleMarks.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 { makeAutoscaleTypeSubMenu, makeCrossHatchItem, makePinCurrentRangeItem, makeScaleTypeSubMenu, makeScoreSubMenu, makeSetMinMaxScoreItem, } from './scoreMenuItems.js';
+export { ScoreAxisMixin } from './ScoreAxisMixin.js';
 export { ScoreScaleMixin } from './ScoreScaleMixin.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 { WiggleScoreConfigMixin, wiggleScoreConfigExtraSlots, } from './WiggleScoreConfigMixin.js';
+export { ScoreFieldConfigMixin } from './ScoreFieldConfigMixin.js';
+export { DEFAULT_SCORE_FIELD, scoreFieldConfigSchemaFields, } from './scoreFieldConfigSchemaFields.js';
+export { MAX_WIGGLE_CUTS, 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

@@ -1,13 +1,4 @@
-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;
+export { SCALE_TYPE_LINEAR, SCALE_TYPE_LOG, SCALE_TYPE_SYMLOG, makeScoreNormalizer, } from '@jbrowse/render-core/scoreScale';
 /**
  * #api
  * The symlog constant actually used for a domain. `0` (the config default)
@@ -22,19 +13,3 @@ export declare function scaleTypeFromString(scaleType: string): WiggleScaleType;
  * 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

@@ -1,24 +1,4 @@
-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;
-}
+export { SCALE_TYPE_LINEAR, SCALE_TYPE_LOG, SCALE_TYPE_SYMLOG, makeScoreNormalizer, } from '@jbrowse/render-core/scoreScale';
 /**
  * #api
  * The symlog constant actually used for a domain. `0` (the config default)
@@ -39,68 +19,3 @@ export function resolveSymlogConstant(min, max, 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/pointSizeMenu.d.ts

@@ -1,5 +1,9 @@
 import type { ConfigModelForFields } from '@jbrowse/core/configuration';
 import type { MenuItem } from '@jbrowse/core/ui';
+/**
+ * The point-size slider row over `WiggleScoreConfigMixin`'s
+ * `scatterPointSize`, so every score plot's menu resets and clamps alike.
+ */
 export declare function makeScatterPointSizeMenuItem(self: {
     scatterPointSize: number;
     setScatterPointSize: (n?: number) => void;
@@ -12,3 +16,12 @@ export declare function makeScatterPointSizeMenuItem(self: {
 }, opts: {
     label: string;
 }): MenuItem;
+/**
+ * A top-level submenu holding the point-size row, or nothing where the plot
+ * draws no points. Top-level rather than under Score because the size
+ * describes the mark, not the axis.
+ */
+export declare function makePointSizeSubMenu(self: Parameters<typeof makeScatterPointSizeMenuItem>[0], { label, applies }: {
+    label: string;
+    applies: boolean;
+}): MenuItem[];

package/esm/pointSizeMenu.js

@@ -1,8 +1,10 @@
 import { getSlotDefinition } from '@jbrowse/core/configuration';
 import { makeSizeMenu } from '@jbrowse/core/ui';
-// Wires a display's shared `scatterPointSize`/`setScatterPointSize` (from
-// WiggleScoreConfigMixin) to makeSizeMenu. Used by both the wiggle scatter and
-// GWAS Manhattan track menus so the slider/reset behavior can't drift.
+import ScatterPlotIcon from '@mui/icons-material/ScatterPlot';
+/**
+ * The point-size slider row over `WiggleScoreConfigMixin`'s
+ * `scatterPointSize`, so every score plot's menu resets and clamps alike.
+ */
 export function makeScatterPointSizeMenuItem(self, opts) {
     return makeSizeMenu({
         label: opts.label,
@@ -18,3 +20,19 @@ export function makeScatterPointSizeMenuItem(self, opts) {
         },
     });
 }
+/**
+ * A top-level submenu holding the point-size row, or nothing where the plot
+ * draws no points. Top-level rather than under Score because the size
+ * describes the mark, not the axis.
+ */
+export function makePointSizeSubMenu(self, { label, applies }) {
+    return applies
+        ? [
+            {
+                label,
+                icon: ScatterPlotIcon,
+                subMenu: [makeScatterPointSizeMenuItem(self, { label })],
+            },
+        ]
+        : [];
+}

package/esm/renderingBackendTypes.d.ts

@@ -1,5 +1,5 @@
-import type { WiggleScaleType } from './normalize.ts';
 import type { PerRegionRenderingBackend } from '@jbrowse/render-core/perRegionRenderingBackend';
+import type { ScaleTypeCode } from '@jbrowse/render-core/scoreScale';
 export type WiggleRenderingType = 0 | 1 | 2 | 3 | 4;
 export declare const RENDERING_TYPE_XYPLOT: WiggleRenderingType;
 export declare const RENDERING_TYPE_DENSITY: WiggleRenderingType;
@@ -8,9 +8,10 @@ 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 declare const MAX_WIGGLE_CUTS = 8;
 export interface WiggleGPURenderState {
     domainY: [number, number];
-    scaleType: WiggleScaleType;
+    scaleType: ScaleTypeCode;
     /**
      * symlog's linear-region width, already resolved from the domain by
      * `resolveSymlogConstant`. Both backends read this one number so the axis,
@@ -24,7 +25,11 @@ export interface WiggleGPURenderState {
     scatterPointSize: number;
     lineWidth: number;
     origin: number;
-    densityColorRamp?: string;
+    pivot: number;
+    cuts: number[];
+    innerColors: [number, number, number][];
+    rampMid?: number;
+    rampLut?: Uint8Array;
 }
 export interface SourceRenderData {
     featurePositions: Uint32Array;
@@ -34,6 +39,10 @@ export interface SourceRenderData {
     rowIndex: number;
     renderingType: WiggleRenderingType;
     colorsAbgr?: Uint32Array;
+    negColor?: [number, number, number];
     gapLimitBp?: number;
+    band?: {
+        minScores: Float32Array;
+    };
 }
 export type WiggleRenderingBackend = PerRegionRenderingBackend<SourceRenderData[], WiggleGPURenderState>;

package/esm/renderingBackendTypes.js

@@ -1,4 +1,4 @@
-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';
+import { MAX_WIGGLE_CUTS as GENERATED_MAX_WIGGLE_CUTS, 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
@@ -27,3 +27,6 @@ export const NO_PREV_START = GENERATED_NO_PREV_START;
 // 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;
+// The most cuts a threshold colour parts a plot at: the shader's uniform
+// block holds this many.
+export const MAX_WIGGLE_CUTS = GENERATED_MAX_WIGGLE_CUTS;

package/esm/scale.d.ts

@@ -20,7 +20,7 @@ export interface ScaleOpts {
     symlogConstant?: number;
     /**
      * Round the domain to nice endpoints before building the scale. Defaults to
-     * true, which is what a caller handing over raw data wants. Pass false when
+     * true, for a caller handing over raw data. Pass false when
      * the domain is already the one something else is drawing with — nicing it
      * again moves the axis off that drawing, and can invent an endpoint outside
      * it (a raw `[1, 1000]` nices to `[1, 1024]`, so the axis labels a tick at a

package/esm/scoreFieldConfigSchemaFields.d.ts

@@ -0,0 +1,10 @@
+import type { ConfigModelForFields } from '@jbrowse/core/configuration';
+export declare const DEFAULT_SCORE_FIELD = "score";
+export declare const scoreFieldConfigSchemaFields: {
+    readonly scoreField: {
+        readonly type: 'string';
+        readonly defaultValue: "score";
+        readonly description: "Feature field plotted on the score axis, read natively off each feature. The default `score` is the field every adapter serves — including the value a BED adapter's `scoreColumn` rewrote it to — so an explicit name here reaches a raw column the adapter left alone (a BED extra column, a GFF attribute) and takes precedence over that adapter-tier rewrite. The Manhattan plot skips a feature with no finite value in the field; the wiggle renderings plot it at 0";
+    };
+};
+export type ScoreFieldConfigModel = ConfigModelForFields<typeof scoreFieldConfigSchemaFields>;

package/esm/scoreFieldConfigSchemaFields.js

@@ -0,0 +1,11 @@
+export const DEFAULT_SCORE_FIELD = 'score';
+// One declaration for the three displays that plot a feature field on a score
+// axis — the two wiggle displays and the Manhattan plot — so the slot has one
+// name, one default and one description wherever it appears.
+export const scoreFieldConfigSchemaFields = {
+    scoreField: {
+        type: 'string',
+        defaultValue: DEFAULT_SCORE_FIELD,
+        description: "Feature field plotted on the score axis, read natively off each feature. The default `score` is the field every adapter serves — including the value a BED adapter's `scoreColumn` rewrote it to — so an explicit name here reaches a raw column the adapter left alone (a BED extra column, a GFF attribute) and takes precedence over that adapter-tier rewrite. The Manhattan plot skips a feature with no finite value in the field; the wiggle renderings plot it at 0",
+    },
+};

package/esm/scoreMenuItems.d.ts

@@ -1,20 +1,30 @@
-import type { MenuItem } from '@jbrowse/core/ui';
+import type { MenuItem, NormalMenuItem } from '@jbrowse/core/ui';
+import type { ValueScaleRule } from '@jbrowse/display-ui';
 import type { IStateTreeNode } from '@jbrowse/mobx-state-tree';
 export interface ScoreScaleModel extends IStateTreeNode {
     scaleType: string;
-    autoscaleType: string;
+    scaleTypeChoices: string[];
     manualMinScore: number | undefined;
     manualMaxScore: number | undefined;
     minScoreBound: number | undefined;
     maxScoreBound: number | undefined;
     hasManualScoreBounds: boolean;
     setScaleType: (v: string) => void;
-    setAutoscale: (v?: string) => void;
     setMinScore: (n?: number) => void;
     setMaxScore: (n?: number) => void;
 }
+export interface AutoscaleModel {
+    autoscaleType: string | undefined;
+    setAutoscale: (v?: string) => void;
+}
+export interface ScoreRulesModel {
+    scoreRulesDrawn: boolean;
+    scoreRules: ValueScaleRule[];
+    setScoreRules: (rules: ValueScaleRule[]) => void;
+}
 export declare function makeScaleTypeSubMenu(self: {
     scaleType: string;
+    scaleTypeChoices: string[];
     setScaleType: (v: string) => void;
 }): MenuItem;
 export declare function makeAutoscaleTypeSubMenu(self: {
@@ -22,17 +32,19 @@ export declare function makeAutoscaleTypeSubMenu(self: {
     setAutoscale: (v?: string) => void;
 }, options?: [string, string][]): MenuItem;
 export declare function makeSetMinMaxScoreItem(self: ScoreScaleModel): MenuItem;
+export declare function makePinCurrentRangeItem(self: ScoreScaleModel, domain: [number, number]): NormalMenuItem;
 export declare function makeCrossHatchItem(self: {
     displayCrossHatches: boolean;
     toggleCrossHatches: () => void;
 }): MenuItem;
-export declare function makeScoreSubMenu(self: ScoreScaleModel, opts?: {
+export interface ScoreSubMenuOptions {
     label?: string;
-    scaleType?: boolean;
-    autoscale?: boolean;
     autoscaleOptions?: [string, string][];
+    domain?: [number, number];
     leadingItems?: MenuItem[];
     trailingItems?: MenuItem[];
     disabled?: boolean;
     disabledHelpText?: string;
-}): MenuItem;
+}
+export declare function makeSetScoreRulesItem(self: IStateTreeNode & ScoreRulesModel): MenuItem;
+export declare function makeScoreSubMenu(self: ScoreScaleModel & Partial<AutoscaleModel> & Partial<ScoreRulesModel>, opts?: ScoreSubMenuOptions): MenuItem;

package/esm/scoreMenuItems.js

@@ -2,21 +2,26 @@ import { lazy } from 'react';
 import { checkboxItem, radioItems } from '@jbrowse/core/ui/menuItems';
 import { getDialogHost } from '@jbrowse/core/util';
 import EqualizerIcon from '@mui/icons-material/Equalizer';
+import HorizontalRuleIcon from '@mui/icons-material/HorizontalRule';
 import { DEFAULT_AUTOSCALE_OPTIONS } from './autoscale.js';
 const SetMinMaxDialog = lazy(() => import('./SetMinMaxDialog.js'));
-// All three scales, so a display offering this menu at all must hold all three
-// in its own `scaleType` enum. `scoreAxisConfigSchemaFields` deliberately does
-// not — symlog is widened in by whoever implements it — so a display that spreads
-// the shared axis fields unchanged has to opt out with `scaleType: false` the way
-// manhattan does, or the radio writes a value its enumeration rejects.
+const SetScoreRulesDialog = lazy(() => import('./SetScoreRulesDialog.js'));
+const SCALE_TYPE_LABELS = {
+    linear: 'Linear scale',
+    log: 'Log scale',
+    symlog: 'Symlog scale (allows zero)',
+};
+// The radio offers exactly what the display's own `scales.y.type` enum admits,
+// read back through `scaleTypeChoices`. Offering a fixed three wrote values an
+// enumeration rejected, which is why Manhattan and the mark display each used to
+// drop the radio by hand.
 export function makeScaleTypeSubMenu(self) {
     return {
         label: 'Scale type',
-        subMenu: radioItems([
-            { value: 'linear', label: 'Linear scale' },
-            { value: 'log', label: 'Log scale' },
-            { value: 'symlog', label: 'Symlog scale (allows zero)' },
-        ], self.scaleType, v => {
+        subMenu: radioItems(self.scaleTypeChoices.map(value => ({
+            value,
+            label: SCALE_TYPE_LABELS[value] ?? value,
+        })), self.scaleType, v => {
             self.setScaleType(v);
         }),
     };
@@ -51,8 +56,23 @@ export function makeSetMinMaxScoreItem(self) {
         },
     };
 }
-// Only offered when a manual bound is set; resets both to the sentinel (same
-// path the dialog takes when its fields are cleared) so autoscale resumes.
+// Freezes the axis where it is drawn, so a pan or a zoom no longer moves it:
+// the drawn domain, never the resolved `*Bound` pair, which on an autoscaled
+// track is `undefined` at both ends and would pin nothing. The caller hands
+// the domain in, since each display names its own (`coverageDomain` on the
+// alignments band), and `makeScoreSubMenu` offers the row only while it is
+// known.
+export function makePinCurrentRangeItem(self, domain) {
+    return {
+        label: 'Pin current min/max',
+        onClick: () => {
+            self.setMinScore(domain[0]);
+            self.setMaxScore(domain[1]);
+        },
+    };
+}
+// Only offered when a manual bound is set; clears both (same path the dialog
+// takes when its fields are cleared) so autoscale resumes.
 function makeClearMinMaxScoreItem(self) {
     return {
         label: 'Clear manual min/max',
@@ -67,22 +87,28 @@ export function makeCrossHatchItem(self) {
         self.toggleCrossHatches();
     });
 }
-// The single Score submenu used by every wiggle-family display. Composition is
-// capability-driven: `leadingItems` lets wiggle prepend its Resolution/Summary
-// submenus, `trailingItems` appends what belongs after the range controls rather
-// than before them (the alignments band's allele-fraction floor); `scaleType` is
-// dropped by manhattan (linear-only); `autoscaleOptions` is overridden by
-// coverage's reduced + dynamic-σ list.
-//
-// `autoscale` is the same kind of opt-out as `scaleType`, and exists for the
-// same reason: a display whose domain doesn't consult `autoscaleType` must not
-// offer radios for it. Manhattan takes plain min/max over the loaded regions and
-// applies only the manual bounds, so its Autoscale-type radios wrote the config
-// slot and changed nothing on screen — a control that lies is worse than a
-// missing one. Opt-out rather than opt-in so a display that grows a domain
-// without wiring autoscale keeps the menu it already had.
+function drawsScoreRules(self) {
+    return (self.scoreRulesDrawn === true &&
+        self.scoreRules !== undefined &&
+        self.setScoreRules !== undefined);
+}
+// The count is in the label, as the min/max row carries its bounds: a dashed
+// line across a plot means nothing until the reader knows it was put there.
+export function makeSetScoreRulesItem(self) {
+    const count = self.scoreRules.length;
+    return {
+        label: count > 0 ? `Reference lines (${count})...` : 'Reference lines...',
+        icon: HorizontalRuleIcon,
+        onClick: () => {
+            getDialogHost(self).queueDialog(handleClose => [
+                SetScoreRulesDialog,
+                { model: self, handleClose },
+            ]);
+        },
+    };
+}
 export function makeScoreSubMenu(self, opts = {}) {
-    const { label = 'Score', scaleType = true, autoscale = true, autoscaleOptions, leadingItems = [], trailingItems = [], disabled, disabledHelpText, } = opts;
+    const { label = 'Score', autoscaleOptions, domain, leadingItems = [], trailingItems = [], disabled, disabledHelpText, } = opts;
     return {
         label,
         icon: EqualizerIcon,
@@ -90,10 +116,19 @@ export function makeScoreSubMenu(self, opts = {}) {
         disabledHelpText,
         subMenu: [
             ...leadingItems,
-            ...(scaleType ? [makeScaleTypeSubMenu(self)] : []),
-            ...(autoscale ? [makeAutoscaleTypeSubMenu(self, autoscaleOptions)] : []),
+            ...(self.scaleTypeChoices.length > 1 ? [makeScaleTypeSubMenu(self)] : []),
+            ...(self.autoscaleType !== undefined && self.setAutoscale
+                ? [
+                    makeAutoscaleTypeSubMenu({
+                        autoscaleType: self.autoscaleType,
+                        setAutoscale: self.setAutoscale,
+                    }, autoscaleOptions),
+                ]
+                : []),
             makeSetMinMaxScoreItem(self),
+            ...(domain ? [makePinCurrentRangeItem(self, domain)] : []),
             ...(self.hasManualScoreBounds ? [makeClearMinMaxScoreItem(self)] : []),
+            ...(drawsScoreRules(self) ? [makeSetScoreRulesItem(self)] : []),
             ...trailingItems,
         ],
     };