@jbrowse/core 5.0.0-beta.11 → 5.0.0-beta.14

package/esm/util/markEncodingTypes.d.ts

@@ -11,7 +11,7 @@ export type FieldRef = string;
 /**
  * #api
  * A field bound to a categorical scale: each distinct value takes one entry
- * of the channel's `range` — a colour for `color`, a shape name for
+ * of the channel's `range` — a color for `color`, a shape name for
  * `shape`. Every value derives its entry from itself (an integer takes the
  * slot it names, anything else hashes in), so every region agrees on a value
  * it shares with another at the cost of an occasional collision. A `domain`
@@ -29,7 +29,7 @@ export interface CategoricalRef {
 /**
  * #api
  * A numeric field cut into intervals: `domain` is the ascending cut points
- * and `range` holds one colour more, so a value paints the entry for the
+ * and `range` holds one color more, so a value paints the entry for the
  * number of cut points it is at or past. A value that is not a number
  * belongs to no interval.
  */
@@ -40,13 +40,15 @@ export interface ThresholdRef {
     range?: string[];
     /** What the key names each bin, one each from the lowest. */
     labels?: string[];
+    /** The key lists the bins from the highest. */
+    descending?: boolean;
 }
 /**
  * #api
  * A numeric field read through a linear or log scale into a ramp. Each end of
  * the domain is pinned by `domainMin` or `domainMax`, or is the region's own
- * extreme where unset, so pinning both keeps colours consistent across a
- * whole view. The ramp is `range`'s CSS colours, evenly spaced, where it
+ * extreme where unset, so pinning both keeps colors consistent across a
+ * whole view. The ramp is `range`'s CSS colors, evenly spaced, where it
  * lists any, else the named `scheme`; `reverse` turns it round.
  */
 export interface ContinuousRef {
@@ -67,7 +69,7 @@ export interface ContinuousRef {
 }
 /**
  * #api
- * How a mark's `color` channel resolves. A CSS colour or a `jexl:` expression
+ * How a mark's `color` channel resolves. A CSS color or a `jexl:` expression
  * returning one paints per feature with no scale; the object forms bind a
  * field to a scale, which a legend can describe, and share the config's
  * member names.
@@ -101,7 +103,7 @@ export interface LocusRef {
  * A numeric field read through a linear or log scale into a width in CSS px:
  * `range` is the px at each end of the domain (1 to 6 unset), and each end of
  * the domain is pinned by `domainMin` or `domainMax` or follows the loaded
- * regions' extremes where unset, as a colour ramp's does. A feature holding
+ * regions' extremes where unset, as a color ramp's does. A feature holding
  * no number takes the range's first px.
  */
 export interface SizeRef {
@@ -149,18 +151,18 @@ export interface MarkEncoding {
  * allocated nor transferred, and a caller that never hovers declines the
  * index, which is most of the encoder's cost after the walk.
  */
-export type LaneName = 'y' | 'color' | 'colorValue' | 'colorKey' | 'glyph' | 'row' | 'text' | 'size' | 'x2Ref' | 'index';
+export type LaneName = 'y' | 'color' | 'colorValue' | 'colorKey' | 'glyph' | 'row' | 'text' | 'size' | 'x2Ref' | 'series' | 'index';
 /**
  * #api
- * The scale a colour channel was resolved through, as the legend reads it —
- * the same table the colours in the payload came from, so the key cannot
+ * The scale a color channel was resolved through, as the legend reads it —
+ * the same table the colors in the payload came from, so the key cannot
  * disagree with the painting.
  */
 export type ColorScaleTable = {
     kind: 'categorical';
     field: string;
     domain: string[];
-    /** The declared range, the other half of what assigns a key its colour. */
+    /** The declared range, the other half of what assigns a key its color. */
     range?: string[];
     /**
      * Whether every non-empty key met here parsed as a finite number: a
@@ -180,7 +182,7 @@ export type ColorScaleTable = {
     /** The cut points, ascending, as numbers. */
     domain: number[];
     /**
-     * The declared interval colours, one more than the cuts; the default
+     * The declared interval colors, one more than the cuts; the default
      * palette fills what the declaration leaves.
      */
     range?: string[];
@@ -213,7 +215,7 @@ export type ColorScaleTable = {
      */
     domainMid?: number;
     /**
-     * The declared stops — `range`'s colours or the `scheme` — and
+     * The declared stops — `range`'s colors or the `scheme` — and
      * `reverse`, which with both ends pinned make up the whole declaration,
      * so marks declaring one ramp alike share a key on it.
      */
@@ -272,7 +274,7 @@ export interface SizeScaleTable {
 }
 /**
  * #api
- * The table behind a channel a key is drawn from: a colour's, whose `kind`
+ * The table behind a channel a key is drawn from: a color's, whose `kind`
  * names the scale it resolved through, or a shape's. A `size` channel's
  * ({@link SizeScaleTable}) draws no key and stands outside.
  */
@@ -297,7 +299,7 @@ export interface EncodedChannels {
     /**
      * Of `skipped`, the features whose `x` or `x2` read no number, such as
      * the edges a `bin` writes for a feature lacking its field. Absent where
-     * the layer placed nothing by a field, as the density sidecar's does.
+     * the layer placed nothing by a field.
      */
     skippedPosition?: number;
     x: Uint32Array;
@@ -306,20 +308,20 @@ export interface EncodedChannels {
     y?: Float32Array;
     /**
      * Each instance's packed ABGR, or one number every instance paints where
-     * the colour is a constant; {@link colorAt} reads either.
+     * the color is a constant; {@link colorAt} reads either.
      */
     color?: Uint32Array | number;
     /**
-     * The raw values of a quantitative colour channel — a ramp's or a
+     * The raw values of a quantitative color channel — a ramp's or a
      * threshold's — for a caller that named the `colorValue` lane: the scale
      * then resolves on the main thread and in the shader, a ramp against a
      * domain unioned over the loaded regions (`scale.extent` is this region's
      * contribution) and a threshold against its cuts as uniforms. Where the
-     * colour reads the field `y` plots, this IS the `y` array, not a copy.
+     * color reads the field `y` plots, this IS the `y` array, not a copy.
      */
     colorValue?: Float32Array;
     /**
-     * Each instance's index into `scale.entries` under a categorical colour, for
+     * Each instance's index into `scale.entries` under a categorical color, for
      * a caller that named the `colorKey` lane in place of `color`: the display
      * then paints each key through its own `domain` and `range`, which never
      * reach the worker.
@@ -328,6 +330,18 @@ export interface EncodedChannels {
     /** The point painter's code for each feature's `shape`. */
     glyph?: Uint8Array;
     row?: Uint32Array;
+    /**
+     * Which series of its row each instance belongs to, for a layer whose
+     * request names a {@link PathSpec}: the instances come grouped series by
+     * series, each in start order, so a path strokes each series as a run of
+     * its own.
+     */
+    series?: Uint32Array;
+    /**
+     * The stretch in bp past which a path breaks, from the request's
+     * {@link PathSpec}. Absent, a series is one run.
+     */
+    gapBp?: number;
     /**
      * Each feature's `text` channel as text, `''` where the field holds
      * nothing; a list joins its members with commas. Strings, so the lane is
@@ -343,12 +357,19 @@ export interface EncodedChannels {
      */
     x2Ref?: Uint32Array;
     x2RefNames?: string[];
+    /**
+     * Which arm each end's junction keeps, as render-core's `linkFeet` packs
+     * the two directions: the record's own `mateDirection` and the one beside
+     * a {@link LocusRef} `x2`'s position. Filled with `x2Ref`, and absent where
+     * no record states a direction.
+     */
+    feet?: Uint8Array;
     /** The finite `y` extremes, `Infinity`/`-Infinity` when nothing plotted. */
     yMin: number;
     yMax: number;
     /** A Flatbush over (x, y, x2, y), when `index` was asked for and `count` is not 0. */
     flatbushData?: ArrayBuffer;
-    /** The colour channel's table, when `color` is a scale. */
+    /** The color channel's table, when `color` is a scale. */
     scale?: ColorScaleTable;
     /** The shape channel's table, when `shape` is a scale. */
     shapeScale?: ShapeScaleTable;
@@ -371,6 +392,20 @@ export interface LayerRequest {
     lanes: LaneName[];
     /** This layer's own steps, run after the request's shared ones. */
     transform?: TransformStep[];
+    /** How a mark stroking through its instances splits them into series. */
+    path?: PathSpec;
+}
+/**
+ * #api
+ * A path's series, as Vega-Lite draws a line: one per row and, within a row,
+ * one per distinct value of `by`, a categorical color's field, each in start
+ * order. `gapBp` breaks a series where the next instance's middle lies further
+ * on than that; absent, a `window` step among the layer's steps sets it to the
+ * bases a frame spans at the median row, and with none a series is one run.
+ */
+export interface PathSpec {
+    by?: FieldRef;
+    gapBp?: number;
 }
 /**
  * #api
@@ -386,6 +421,8 @@ export interface EncodedLayersResult {
     zoomRange?: ZoomRange;
     /** What the adapter said about this answer that the features cannot show. */
     notices?: string[];
+    /** What the adapter read off the features, under names of its own. */
+    facts?: Record<string, unknown>;
 }
 /**
  * #api
@@ -459,11 +496,30 @@ export interface AggregateStep {
     groupby?: FieldRef[];
     ops: AggregateOp[];
 }
+/**
+ * #api
+ * Every row kept, each written with `ops` summarized over the rows of its
+ * group around it, Vega-Lite's window transform: a group is a distinct
+ * `groupby` value set within a section, its rows taken in `start` order, and
+ * `frame` counts rows before and after the current one, `null` running to the
+ * group's end. `[-10, 10]`, the default, is a moving average over 21 rows,
+ * whatever bases they span; `[null, 0]` a running total. A frame cut off at a
+ * group's end summarizes the rows it has. The rows come out grouped, each
+ * group in `start` order, so a `line` walks one group at a time.
+ */
+export interface WindowStep {
+    type: 'window';
+    groupby?: FieldRef[];
+    frame?: [number | null, number | null];
+    ops: AggregateOp[];
+}
 /**
  * #api
  * Replace the features with runs of constant depth: how many of them overlap
  * each stretch of the region, in a field `as` (`coverage` by default), with
- * the stretches nothing overlaps left out.
+ * the stretches nothing overlaps left out. A read counts across its whole
+ * span, deletions and introns included; gap-aware depth stays the alignments
+ * display's (ADR-118).
  */
 export interface CoverageStep {
     type: 'coverage';
@@ -541,7 +597,7 @@ export interface MateStep {
  * way GenomeSpy spells a transform; every step runs in order and the next
  * reads what the last answered.
  */
-export type TransformStep = FilterStep | FormulaStep | FlattenStep | CellsStep | BinStep | AggregateStep | CoverageStep | PileupStep | MateStep;
+export type TransformStep = FilterStep | FormulaStep | FlattenStep | CellsStep | BinStep | AggregateStep | WindowStep | CoverageStep | PileupStep | MateStep;
 export type CoreGetEncodedLayersArgs = {
     adapterConfig: Record<string, unknown>;
     region: {

package/esm/util/originCut.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The id of the piece of a feature lying past a circular sequence's origin,
+ * the feature cut there and `id` the piece before it. Only GFF3 cuts:
+ * bedToBigBed refuses an end past the contig, and on 2026-10-11 none of hg38's
+ * 35 hosted BED tabix tracks had a chrM record ending past 16569.
+ *
+ * The linear view reads across the origin with the tail and head typed as two
+ * regions, `NC_012920.1:15,000-16,569 NC_012920.1:1-2,000`, where the two
+ * pieces abut in one row. A locstring that wraps past the origin, or a menu
+ * item, would save the typing; neither was built (2026-10-14).
+ */
+export declare function originTailId(id: string): string;
+/** The id of the piece before the origin, when `id` names the one past it. */
+export declare function originHeadId(id: string): string | undefined;

package/esm/util/originCut.js

@@ -0,0 +1,19 @@
+const TAIL_SUFFIX = '-origin';
+/**
+ * The id of the piece of a feature lying past a circular sequence's origin,
+ * the feature cut there and `id` the piece before it. Only GFF3 cuts:
+ * bedToBigBed refuses an end past the contig, and on 2026-10-11 none of hg38's
+ * 35 hosted BED tabix tracks had a chrM record ending past 16569.
+ *
+ * The linear view reads across the origin with the tail and head typed as two
+ * regions, `NC_012920.1:15,000-16,569 NC_012920.1:1-2,000`, where the two
+ * pieces abut in one row. A locstring that wraps past the origin, or a menu
+ * item, would save the typing; neither was built (2026-10-14).
+ */
+export function originTailId(id) {
+    return `${id}${TAIL_SUFFIX}`;
+}
+/** The id of the piece before the origin, when `id` names the one past it. */
+export function originHeadId(id) {
+    return id.endsWith(TAIL_SUFFIX) ? id.slice(0, -TAIL_SUFFIX.length) : undefined;
+}

package/esm/util/paintLayer.d.ts

@@ -6,7 +6,7 @@ export type PaintLayerOpts = SvgRasterCanvasOpts & {
     rasterizeLayers?: boolean;
 };
 /**
- * Paint into either a 2× rasterize canvas (PNG-embedded as <image>) or an
+ * Paint into either a rasterize canvas (PNG-embedded as <image>) or an
  * SvgCanvas (serialized into a <g>). Renders one element — callers don't
  * branch on which mode was picked.
  *

package/esm/util/paintLayer.js

@@ -1,8 +1,8 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { SvgCanvas } from './SvgCanvas.js';
-import { createSvgRasterCanvas } from './createSvgRasterCanvas.js';
+import { createSvgRasterCanvas, svgRasterDataUrl, } from './createSvgRasterCanvas.js';
 /**
- * Paint into either a 2× rasterize canvas (PNG-embedded as <image>) or an
+ * Paint into either a rasterize canvas (PNG-embedded as <image>) or an
  * SvgCanvas (serialized into a <g>). Renders one element — callers don't
  * branch on which mode was picked.
  *
@@ -20,11 +20,12 @@ import { createSvgRasterCanvas } from './createSvgRasterCanvas.js';
  * canvas is blank means reading its pixels back — and it does not need one: a
  * fully transparent PNG is a couple of hundred bytes.
  */
+// eslint-disable-next-line no-restricted-syntax -- drawn inside a frozen SVG figure
 export function PaintLayer({ width, height, opts, paint, }) {
     if (opts?.rasterizeLayers && width > 0 && height > 0) {
         const { canvas, ctx } = createSvgRasterCanvas(width, height, opts);
         paint(ctx);
-        return (_jsx("image", { width: width, height: height, xlinkHref: canvas.toDataURL('image/png') }));
+        return (_jsx("image", { width: width, height: height, xlinkHref: svgRasterDataUrl(canvas) }));
     }
     const svg = new SvgCanvas();
     paint(svg);

package/esm/util/pathSeries.d.ts

@@ -0,0 +1,18 @@
+import type { FeatureTable } from './featureTable.ts';
+import type { JexlInstance } from './jexlStrings.ts';
+import type { FieldRef, PathSpec, TransformStep } from './markEncodingTypes.ts';
+type RowEncoding = FieldRef | ArrayLike<number> | undefined;
+/**
+ * #api
+ * A path layer's table in series order, as {@link PathSpec} defines a series,
+ * with each row's series beside it and the stretch past which a series breaks.
+ * `steps` are every step the layer's rows went through, which a `window` among
+ * them reads the default break from.
+ */
+export declare function pathSeries(table: FeatureTable, row: RowEncoding, path: PathSpec, steps: readonly TransformStep[], jexl?: JexlInstance): {
+    table: FeatureTable;
+    row: RowEncoding;
+    series: Uint32Array<ArrayBuffer>;
+    gapBp: number | undefined;
+};
+export {};

package/esm/util/pathSeries.js

@@ -0,0 +1,143 @@
+// A path layer's rows in series order. `layerFeatures` applies it, so the
+// table `CoreGetEncodedFeature` reads is the one `CoreGetEncodedLayers`
+// encoded and an instance's index names the same row in both. Imported by
+// relative path only.
+import { numberReaderOf, readerOf, selectRows } from './featureTable.js';
+import { fieldReader, isPlainFieldRef } from './fieldReader.js';
+import { groupKey, sortByStart } from './stepTables.js';
+import { DEFAULT_WINDOW_FRAME } from './windowStep.js';
+function reader(table, ref, jexl) {
+    if (isPlainFieldRef(ref)) {
+        return readerOf(table.column(ref));
+    }
+    const read = fieldReader(ref, jexl);
+    return (i) => read(table.row(i));
+}
+// Each row's series, numbered in the order met: one per distinct pair of the
+// row it stands in and its `by` value.
+function seriesOf(table, row, by, jexl) {
+    const n = table.length;
+    const readRow = typeof row === 'string'
+        ? reader(table, row, jexl)
+        : row
+            ? (i) => row[i]
+            : () => 0;
+    const readBy = by === undefined ? () => undefined : reader(table, by, jexl);
+    const keys = new Map();
+    const series = new Uint32Array(n);
+    let count = 0;
+    for (let i = 0; i < n; i++) {
+        const r = readRow(i);
+        let byRow = keys.get(r);
+        if (!byRow) {
+            byRow = new Map();
+            keys.set(r, byRow);
+        }
+        const key = groupKey(readBy(i));
+        let s = byRow.get(key);
+        if (s === undefined) {
+            s = count++;
+            byRow.set(key, s);
+        }
+        series[i] = s;
+    }
+    return { series, count };
+}
+// The rows grouped by series, each series in start order, and where each
+// series begins.
+function seriesOrder(starts, series, count) {
+    const n = series.length;
+    const first = new Uint32Array(count + 1);
+    for (let i = 0; i < n; i++) {
+        first[series[i] + 1]++;
+    }
+    for (let s = 0; s < count; s++) {
+        first[s + 1] += first[s];
+    }
+    const order = new Uint32Array(n);
+    const next = first.slice(0, count);
+    for (let i = 0; i < n; i++) {
+        order[next[series[i]]++] = i;
+    }
+    for (let s = 0; s < count; s++) {
+        const rows = order.subarray(first[s], first[s + 1]);
+        let sorted = true;
+        for (let k = 1; k < rows.length && sorted; k++) {
+            sorted = starts[rows[k]] >= starts[rows[k - 1]];
+        }
+        if (!sorted) {
+            sortByStart(rows, starts);
+        }
+    }
+    return { order, first };
+}
+// The bases a window's frame spans at the median row: each row's frame runs
+// from the start `before` rows back to the start `after` rows on, cut at its
+// series' ends, as the window step cut it.
+function frameSpanBp(starts, order, first, [before, after]) {
+    const spans = [];
+    for (let s = 0; s + 1 < first.length; s++) {
+        const lo = first[s];
+        const m = first[s + 1] - lo;
+        for (let j = 0; j < m; j++) {
+            const a = Math.max(0, j + before);
+            const b = Math.min(m - 1, j + after);
+            if (a <= b) {
+                spans.push(starts[order[lo + b]] - starts[order[lo + a]]);
+            }
+        }
+    }
+    if (spans.length === 0) {
+        return undefined;
+    }
+    spans.sort((x, y) => x - y);
+    return spans[spans.length >> 1];
+}
+function windowFrame(steps) {
+    const step = steps.findLast(s => s.type === 'window');
+    if (step?.type !== 'window') {
+        return undefined;
+    }
+    const [before, after] = step.frame ?? DEFAULT_WINDOW_FRAME;
+    return before === null || after === null
+        ? undefined
+        : [before, after];
+}
+/**
+ * #api
+ * A path layer's table in series order, as {@link PathSpec} defines a series,
+ * with each row's series beside it and the stretch past which a series breaks.
+ * `steps` are every step the layer's rows went through, which a `window` among
+ * them reads the default break from.
+ */
+export function pathSeries(table, row, path, steps, jexl) {
+    const n = table.length;
+    const { series, count } = seriesOf(table, row, path.by, jexl);
+    const readStart = numberReaderOf(table.column('start'));
+    const starts = new Float64Array(n);
+    for (let i = 0; i < n; i++) {
+        const s = readStart(i);
+        starts[i] = Number.isNaN(s) ? Infinity : s;
+    }
+    const { order, first } = seriesOrder(starts, series, count);
+    const ordered = new Uint32Array(n);
+    for (let k = 0; k < n; k++) {
+        ordered[k] = series[order[k]];
+    }
+    let rowOut = row;
+    if (row !== undefined && typeof row !== 'string') {
+        const permuted = new Uint32Array(n);
+        for (let k = 0; k < n; k++) {
+            permuted[k] = row[order[k]];
+        }
+        rowOut = permuted;
+    }
+    const frame = path.gapBp === undefined ? windowFrame(steps) : undefined;
+    return {
+        table: selectRows(table, order),
+        row: rowOut,
+        series: ordered,
+        gapBp: path.gapBp ??
+            (frame ? frameSpanBp(starts, order, first, frame) : undefined),
+    };
+}

package/esm/util/pressOwner.d.ts

@@ -0,0 +1,20 @@
+interface Press {
+    target: EventTarget | null;
+    currentTarget: EventTarget | null;
+}
+/**
+ * Whether an event reached a container's React handler from outside the
+ * container's DOM. React bubbles a portal's events to its React parent, so a
+ * press in a dialog or menu that a track opened arrives at every handler above
+ * the track.
+ */
+export declare function isFromPortal({ target, currentTarget }: Press): boolean;
+/**
+ * Whether a container's own drag gesture leaves a press alone: one from a
+ * portal, or one on a control that claimed it (`[data-gesture-owner]`,
+ * JBrowse's marker on the parts that drag on their own), a button, or a
+ * draggable element. `closest`, because the press usually lands on an icon
+ * inside the control.
+ */
+export declare function isClaimedPress(event: Press): boolean;
+export {};

package/esm/util/pressOwner.js

@@ -0,0 +1,26 @@
+/**
+ * Whether an event reached a container's React handler from outside the
+ * container's DOM. React bubbles a portal's events to its React parent, so a
+ * press in a dialog or menu that a track opened arrives at every handler above
+ * the track.
+ */
+export function isFromPortal({ target, currentTarget }) {
+    return (target instanceof Node &&
+        currentTarget instanceof Node &&
+        !currentTarget.contains(target));
+}
+/**
+ * Whether a container's own drag gesture leaves a press alone: one from a
+ * portal, or one on a control that claimed it (`[data-gesture-owner]`,
+ * JBrowse's marker on the parts that drag on their own), a button, or a
+ * draggable element. `closest`, because the press usually lands on an icon
+ * inside the control.
+ */
+export function isClaimedPress(event) {
+    const { target } = event;
+    return (isFromPortal(event) ||
+        (target instanceof HTMLElement && target.draggable) ||
+        (target instanceof Element &&
+            target.closest('button, [data-gesture-owner], [draggable="true"]') !==
+                null));
+}

package/esm/util/quantileExtent.d.ts

@@ -1,5 +1,7 @@
 /** The quantile "Clip outliers" clips at on a scale whose own default is the extremes. */
 export declare const DEFAULT_CLIP_QUANTILE = 0.99;
+/** The lowest `domainQuantile` a scale reads, where its two ends meet; one below reads as this. */
+export declare const MIN_DOMAIN_QUANTILE = 0.5;
 /**
  * #api
  * The quantile a clip toggle writes: a scale's declared default where that
@@ -35,10 +37,30 @@ export declare function quantileOf(a: Float32Array, n: number, quantile: number)
  * the axis nor the ramp, and a sparse tail of the other sign keeps its own
  * end. An axis that starts at 0 adds it itself. Under 0.5 reads as 0.5,
  * where the ends meet rather than cross. `scales.y.domainQuantile` and a
- * colour's `domainQuantile` both name it. `[Infinity, -Infinity]` where
+ * color's `domainQuantile` both name it. `[Infinity, -Infinity]` where
  * nothing is finite.
+ *
+ * Nearest rank keeps ties: where one value holds the rank, as on a segmented
+ * copy-number track, a ramp clipped below 1 paints nearly every value one
+ * color. A value axis fences instead ({@link fenceOutliers}); a ramp takes
+ * the same fence once a color default below 1 meets tied data.
  */
 export declare function quantileExtent(values: ArrayLike<number>, count: number, quantile?: number): [number, number];
+/**
+ * #api
+ * Where a value axis's open ends stand below a `domainQuantile` of 1: at the
+ * `extremes`, unless one would stretch the axis past twice the span the
+ * {@link quantileExtent} ends `quantiles` draw, 0 included where the axis
+ * reaches it (`zero`); that end stops at the fence. So a plot with no spike
+ * shows every value and cuts none, and a spike leaves the values under it at
+ * least half the axis. Quantiles that meet span their own size, as a flat
+ * domain widens in `getNiceDomain`.
+ */
+export declare function fenceOutliers({ extremes, quantiles, zero, }: {
+    extremes: readonly [number, number];
+    quantiles: readonly [number, number];
+    zero: boolean;
+}): [number, number];
 /**
  * #api
  * {@link quantileExtent} as a scale's open ends read it: over every finite

package/esm/util/quantileExtent.js

@@ -1,5 +1,7 @@
 /** The quantile "Clip outliers" clips at on a scale whose own default is the extremes. */
 export const DEFAULT_CLIP_QUANTILE = 0.99;
+/** The lowest `domainQuantile` a scale reads, where its two ends meet; one below reads as this. */
+export const MIN_DOMAIN_QUANTILE = 0.5;
 /**
  * #api
  * The quantile a clip toggle writes: a scale's declared default where that
@@ -109,14 +111,19 @@ function lowQuantileOf(a, n, quantile) {
  * the axis nor the ramp, and a sparse tail of the other sign keeps its own
  * end. An axis that starts at 0 adds it itself. Under 0.5 reads as 0.5,
  * where the ends meet rather than cross. `scales.y.domainQuantile` and a
- * colour's `domainQuantile` both name it. `[Infinity, -Infinity]` where
+ * color's `domainQuantile` both name it. `[Infinity, -Infinity]` where
  * nothing is finite.
+ *
+ * Nearest rank keeps ties: where one value holds the rank, as on a segmented
+ * copy-number track, a ramp clipped below 1 paints nearly every value one
+ * color. A value axis fences instead ({@link fenceOutliers}); a ramp takes
+ * the same fence once a color default below 1 meets tied data.
  */
 export function quantileExtent(values, count, quantile = 1) {
     if (!(quantile < 1)) {
         return finiteExtremes(values, count);
     }
-    const q = Math.max(0.5, quantile);
+    const q = Math.max(MIN_DOMAIN_QUANTILE, quantile);
     const positive = new Float32Array(count);
     const negative = new Float32Array(count);
     let np = 0;
@@ -139,6 +146,22 @@ export function quantileExtent(values, count, quantile = 1) {
     const high = np > 0 ? quantileOf(positive, np, q) : quantileOf(negative, nn, q);
     return [Math.min(low, high), high];
 }
+/**
+ * #api
+ * Where a value axis's open ends stand below a `domainQuantile` of 1: at the
+ * `extremes`, unless one would stretch the axis past twice the span the
+ * {@link quantileExtent} ends `quantiles` draw, 0 included where the axis
+ * reaches it (`zero`); that end stops at the fence. So a plot with no spike
+ * shows every value and cuts none, and a spike leaves the values under it at
+ * least half the axis. Quantiles that meet span their own size, as a flat
+ * domain widens in `getNiceDomain`.
+ */
+export function fenceOutliers({ extremes, quantiles, zero, }) {
+    const lo = zero ? Math.min(0, quantiles[0]) : quantiles[0];
+    const hi = zero ? Math.max(0, quantiles[1]) : quantiles[1];
+    const span = hi - lo || Math.abs(hi) || 1;
+    return [Math.max(extremes[0], lo - span), Math.min(extremes[1], hi + span)];
+}
 /**
  * #api
  * {@link quantileExtent} as a scale's open ends read it: over every finite

package/esm/util/rowStackGeometry.d.ts

@@ -9,7 +9,7 @@
  * cohort-sized track. Two rules follow, and each caller used to restate them:
  *
  * - **Ask at the pixel's centre.** Rasterization fills a pixel when its centre
- *   falls inside the rect, so the centre is the scanline the colour the reader
+ *   falls inside the rect, so the centre is the scanline the color the reader
  *   is pointing at was decided on. The top edge misses by `0.5 / rowHeight`
  *   rows — 5.4 of them on a 2,504-sample matrix at the default fit height.
  * - **Floor `mouseY` before adding `scrollTop`.** The canvas draws at

package/esm/util/rowStackGeometry.js

@@ -9,7 +9,7 @@
  * cohort-sized track. Two rules follow, and each caller used to restate them:
  *
  * - **Ask at the pixel's centre.** Rasterization fills a pixel when its centre
- *   falls inside the rect, so the centre is the scanline the colour the reader
+ *   falls inside the rect, so the centre is the scanline the color the reader
  *   is pointing at was decided on. The top edge misses by `0.5 / rowHeight`
  *   rows — 5.4 of them on a 2,504-sample matrix at the default fit height.
  * - **Floor `mouseY` before adding `scrollTop`.** The canvas draws at