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

package/esm/util/layouts/GranularRectLayout.js

@@ -56,39 +56,64 @@ export default class GranularRectLayout {
      *  out the rect would exceed maxHeight
      */
     addRect(id, left, right, height, lower) {
-        const pitchX = this.pitchX;
-        const pitchY = this.pitchY;
-        // if we have already laid it out, return its layout
         const storedRec = this.rectangles.get(id);
         if (storedRec) {
-            return storedRec.top === null ? null : storedRec.top * pitchY;
+            return storedRec.top === null ? null : storedRec.top * this.pitchY;
+        }
+        const placement = this.placement(left, right, height, lower);
+        return this.commit(id, placement, this.firstFit(placement, 0));
+    }
+    /**
+     * Lays out rects, none of them placed yet, at one shared top: the lowest
+     * where every one fits. For the pieces of one feature drawn apart.
+     */
+    addRectsAtOneTop(rects) {
+        const placements = rects.map(r => this.placement(r.left, r.right, r.height, r.lower));
+        let top = 0;
+        for (let i = 0; i < placements.length && top <= this.maxHeight;) {
+            const fit = this.firstFit(placements[i], top);
+            if (fit === top) {
+                i += 1;
+            }
+            else {
+                top = fit;
+                i = 0;
+            }
+        }
+        let result = null;
+        for (const [i, rect] of rects.entries()) {
+            result = this.commit(rect.id, placements[i], top);
         }
-        // Use Math.trunc for fast floor operation that works with large coordinates
-        // (bitwise | 0 overflows above 2^31, causing layout issues with large genomic coordinates)
-        const pLeft = Math.trunc(left / pitchX);
-        const pRight = Math.trunc(right / pitchX);
-        const pHeight = Math.ceil(height / pitchY);
-        const pLowerTop = lower ? Math.ceil(lower.top / pitchY) : pHeight;
+        return result;
+    }
+    placement(left, right, height, lower) {
+        const pitchX = this.pitchX;
+        const pitchY = this.pitchY;
+        // Math.trunc, not `| 0`, which overflows above 2^31 genomic coordinates
         const rectangle = {
-            l: pLeft,
-            r: pRight,
+            l: Math.trunc(left / pitchX),
+            r: Math.trunc(right / pitchX),
             top: null,
-            h: pHeight,
+            h: Math.ceil(height / pitchY),
         };
-        const lowerSpan = lower
-            ? {
-                l: Math.trunc(lower.left / pitchX),
-                r: Math.trunc(lower.right / pitchX),
-            }
-            : rectangle;
-        // Allow features to start at any position up to maxHeight
-        // Features starting at maxHeight or beyond are filtered out, but features
-        // that start below maxHeight and extend past it are allowed
+        return {
+            rectangle,
+            lowerTop: lower ? Math.ceil(lower.top / pitchY) : rectangle.h,
+            lowerSpan: lower
+                ? {
+                    l: Math.trunc(lower.left / pitchX),
+                    r: Math.trunc(lower.right / pitchX),
+                }
+                : rectangle,
+        };
+    }
+    // The first top at or past `fromTop` where the rect fits, maxHeight + 1
+    // when none does. A rect starting below maxHeight may extend past it.
+    firstFit({ rectangle, lowerTop: pLowerTop, lowerSpan }, fromTop) {
+        const { l: pLeft, r: pRight, h: pHeight } = rectangle;
         const maxTop = this.maxHeight;
-        let top = 0;
-        // OPTIMIZATION: Inline collision checking for hot path
-        // Eliminates function call overhead which is critical at 100k+ features
         const bitmap = this.bitmap;
+        let top = fromTop;
         // On a collision at row y, the next top worth trying is y + 1, not top + 1.
         // Rows top..y-1 are clear (y is the first hit walking upward) and every top'
         // between them still spans y, because y < top + pHeight — so nothing between
@@ -99,11 +124,9 @@ export default class GranularRectLayout {
         // blocks every top to y, and a hit in the lower span blocks just the tops
         // keeping y there: the jump goes to the first top putting y above it.
         outer: for (; top <= maxTop; top += 1) {
-            // Check all rows that this rectangle would occupy
             const maxY = top + pHeight;
             for (let y = top; y < maxY; y += 1) {
                 const row = bitmap[y];
-                // Fast path: no row created yet
                 if (!row) {
                     continue;
                 }
@@ -115,7 +138,6 @@ export default class GranularRectLayout {
                     const r = inLower ? lowerSpan.r : pRight;
                     const blockedTop = inLower ? y - pLowerTop : y;
                     if (len < 40) {
-                        // Linear scan for small arrays
                         for (let i = 0; i < len; i += 2) {
                             const start = intervals[i];
                             const end = intervals[i + 1];
@@ -126,7 +148,6 @@ export default class GranularRectLayout {
                         }
                     }
                     else {
-                        // Binary search for larger arrays
                         let low = 0;
                         let high = len >> 1;
                         while (low < high) {
@@ -150,19 +171,21 @@ export default class GranularRectLayout {
                     }
                 }
             }
-            // No collision found in any row
             break;
         }
+        return top;
+    }
+    commit(id, { rectangle, lowerTop, lowerSpan }, top) {
         this.rectangles.set(id, rectangle);
-        if (top > maxTop) {
+        if (top > this.maxHeight) {
             return null;
         }
         rectangle.top = top;
-        const yEnd = top + pHeight;
+        const yEnd = top + rectangle.h;
         for (let y = top; y < yEnd; y += 1) {
-            this.getOrCreateRow(y).addRect(y - top >= pLowerTop ? lowerSpan : rectangle);
+            this.getOrCreateRow(y).addRect(y - top >= lowerTop ? lowerSpan : rectangle);
         }
-        return top * pitchY;
+        return top * this.pitchY;
     }
     getOrCreateRow(y) {
         let row = this.bitmap[y];

package/esm/util/leadingEdgeAutorun.d.ts

@@ -4,6 +4,14 @@ export interface LeadingEdgeAutorunOptions {
     name: string;
     /** how long to coalesce reruns once the body has started work once */
     delay: number;
+    /**
+     * Run on the leading edge again once the last run that started work is at
+     * least `delay` old. A change that arrives after the autorun has sat idle,
+     * such as a jump to a new locus, has nothing to coalesce with, so waiting the
+     * delay out only adds latency. A change within `delay` of that work is
+     * coalesced as before.
+     */
+    idleLeading?: boolean;
 }
 /**
  * An autorun that runs on the leading edge until its body reports having
@@ -37,4 +45,4 @@ export interface LeadingEdgeAutorunOptions {
  * The debounce is per-installation, so two autoruns on one model coalesce
  * independently.
  */
-export declare function leadingEdgeAutorun(self: IAnyStateTreeNode, body: () => boolean | void, { name, delay }: LeadingEdgeAutorunOptions): import("mobx").IReactionDisposer;
+export declare function leadingEdgeAutorun(self: IAnyStateTreeNode, body: () => boolean | void, { name, delay, idleLeading }: LeadingEdgeAutorunOptions): import("mobx").IReactionDisposer;

package/esm/util/leadingEdgeAutorun.js

@@ -31,16 +31,19 @@ import { namedAutorun } from '@jbrowse/render-core/namedReactions';
  * The debounce is per-installation, so two autoruns on one model coalesce
  * independently.
  */
-export function leadingEdgeAutorun(self, body, { name, delay }) {
+export function leadingEdgeAutorun(self, body, { name, delay, idleLeading = false }) {
     let primed = false;
+    let lastWork = Number.NEGATIVE_INFINITY;
     return namedAutorun(self, () => {
         if (body()) {
             primed = true;
+            lastWork = performance.now();
         }
     }, {
         name,
         scheduler: run => {
-            if (primed) {
+            const idle = idleLeading && performance.now() - lastWork >= delay;
+            if (primed && !idle) {
                 setTimeout(run, delay);
             }
             else {

package/esm/util/markEncoding.d.ts

@@ -4,7 +4,7 @@ import type { JexlInstance } from './jexlStrings.ts';
 import type { ColorEncoding, ColorScaleTable, ContinuousRef, Encoded, EncodedChannels, FieldRef, LocusRef, ShapeEncoding, SizeEncoding, LaneName } from './markEncodingTypes.ts';
 import type { ProgressReporter } from './progress.ts';
 import type { Feature } from './simpleFeature.ts';
-export type { AggregateOp, AggregateStep, BinStep, CategoricalRef, ColorEncoding, ContinuousRef, CoverageStep, ColorScaleTable, CoreGetEncodedLayersArgs, Encoded, EncodedChannels, EncodedLayersResult, FacetSection, FacetSpec, FieldRef, FilterStep, FormulaStep, LocusRef, MateStep, ShapeEncoding, ShapeName, ShapeScaleTable, SizeEncoding, SizeRef, SizeScaleTable, LaneName, LayerRequest, MarkEncoding, ScaleTable, ThresholdRef, TransformStep, } from './markEncodingTypes.ts';
+export type { AggregateOp, AggregateStep, BinStep, CategoricalRef, ColorEncoding, ContinuousRef, CoverageStep, ColorScaleTable, CoreGetEncodedLayersArgs, Encoded, EncodedChannels, EncodedLayersResult, FacetSection, FacetSpec, FieldRef, FilterStep, FormulaStep, LocusRef, MateStep, PathSpec, ShapeEncoding, ShapeName, ShapeScaleTable, SizeEncoding, SizeRef, SizeScaleTable, LaneName, LayerRequest, MarkEncoding, ScaleTable, ThresholdRef, TransformStep, WindowStep, } from './markEncodingTypes.ts';
 export type { ColorSchemeName } from './colorSchemes.ts';
 export { COLOR_SCHEMES } from './colorSchemes.ts';
 export { NO_VALUE_LABEL } from './categoricalField.ts';
@@ -12,7 +12,7 @@ export declare const DEFAULT_MARK_COLOR = "#0068d1";
 export declare const DEFAULT_SIZE_RANGE_PX: [number, number];
 /**
  * #api
- * The misconfiguration grey packed as the encoder paints it: a `jexl:` colour
+ * The misconfiguration grey packed as the encoder paints it: a `jexl:` color
  * that answered no string, a ramp value that is no number, text a threshold
  * cannot read.
  */
@@ -44,6 +44,8 @@ export interface MarkEncodingInput {
     x2?: FieldRef | LocusRef | ChannelReader;
     y?: FieldRef | ChannelReader;
     row?: FieldRef | ChannelReader | ArrayLike<number>;
+    /** Each row's series, what the `series` lane is filled from. */
+    series?: ArrayLike<number>;
     color?: ColorEncoding | ChannelReader<number>;
     shape?: ShapeEncoding | ChannelReader<number>;
     text?: FieldRef | ChannelReader;
@@ -97,12 +99,12 @@ export declare function withHitIndex<T extends EncodedChannels>(channels: T): Hi
 export declare function encodeFeatures<L extends LaneName>(input: readonly Feature[] | FeatureTable, encoding: MarkEncodingInput, lanes: readonly L[], ctx?: EncodeContext): Encoded<L>;
 /**
  * #api
- * A continuous colour scale over `extent`, the values it met: the domain its
+ * A continuous color scale over `extent`, the values it met: the domain its
  * declared ends and the extent make, the straight table its stops bake to and
- * where its middle stop sits, and the packed colour a value paints through
+ * where its middle stop sits, and the packed color a value paints through
  * them: an infinity the end on its side, as a threshold places it, and NaN,
  * text that is no number, the misconfiguration grey. The encoder and every
- * display painting a ramp itself read it, so a value takes one colour whoever
+ * display painting a ramp itself read it, so a value takes one color whoever
  * paints it.
  */
 export declare function continuousColorScale(encoding: ContinuousRef, extent: readonly [number, number]): {
@@ -125,7 +127,7 @@ export declare function rampOverExtent(table: Extract<ColorScaleTable, {
 }>;
 /**
  * #api
- * A CSS colour or `jexl:` colour expression as a per-feature packed ABGR —
+ * A CSS color or `jexl:` color expression as a per-feature packed ABGR —
  * the unscaled arm of {@link ColorEncoding}, on its own for a display that
  * carries a plain `color` slot.
  */
@@ -138,8 +140,8 @@ export declare function colorEvaluator(color: string, jexl: JexlInstance | undef
 export declare function featureIndexAt(channels: Pick<EncodedChannels, 'featureIndex'>, i: number): number;
 /**
  * #api
- * The packed colour instance `i` of `channels` paints: `color[i]`, or `color`
- * itself where the colour is a constant and so shipped as one number.
+ * The packed color instance `i` of `channels` paints: `color[i]`, or `color`
+ * itself where the color is a constant and so shipped as one number.
  */
 export declare function colorAt(channels: Pick<EncodedChannels, 'color'>, i: number): number | undefined;
 /**

package/esm/util/markEncoding.js

@@ -1,3 +1,4 @@
+import { linkFeet } from '@jbrowse/render-core/linkFeet';
 import { makeScoreNormalizer, rampMidNorm, scaleTypeCode, } from '@jbrowse/render-core/scoreScale';
 import { rampMidT } from '@jbrowse/render-core/shaders/colorRampLut';
 import { RAMP_NO_VALUE_BITS } from '@jbrowse/render-core/shaders/markColorConsts';
@@ -23,7 +24,7 @@ export const DEFAULT_MARK_COLOR = '#0068d1';
 export const DEFAULT_SIZE_RANGE_PX = [1, 6];
 /**
  * #api
- * The misconfiguration grey packed as the encoder paints it: a `jexl:` colour
+ * The misconfiguration grey packed as the encoder paints it: a `jexl:` color
  * that answered no string, a ramp value that is no number, text a threshold
  * cannot read.
  */
@@ -74,6 +75,25 @@ function numberChannelReader(table, ref, jexl) {
     const read = channelReader(table, ref, jexl);
     return i => numericValue(read(i));
 }
+// A far end stated as `mate.start` carries its direction as
+// `mate.mateDirection`, beside the record's own.
+function feetLane(table, farPos, count, rowAt, jexl) {
+    const dot = farPos.lastIndexOf('.');
+    const farDirection = `${farPos.slice(0, dot)}.mateDirection`;
+    if (dot === -1 || isJexl(farPos)) {
+        return undefined;
+    }
+    const own = numberChannelReader(table, 'mateDirection', jexl);
+    const far = numberChannelReader(table, farDirection, jexl);
+    const feet = new Uint8Array(count);
+    let any = false;
+    for (let k = 0; k < count; k++) {
+        const r = rowAt(k);
+        feet[k] = linkFeet(own(r), far(r));
+        any ||= feet[k] !== 0;
+    }
+    return any ? feet : undefined;
+}
 function isShapeName(shape) {
     return shape in SHAPE_CODES;
 }
@@ -439,6 +459,9 @@ export function encodeFeatures(input, encoding, lanes, ctx = {}) {
             x2Ref[k] = ref;
         }
     }
+    const feet = x2Ref && x2Locus
+        ? feetLane(table, x2Locus.pos, count, rowAt, jexl)
+        : undefined;
     const sizeRef = has('size') &&
         sizeEncoding !== undefined &&
         typeof sizeEncoding !== 'number'
@@ -467,6 +490,13 @@ export function encodeFeatures(input, encoding, lanes, ctx = {}) {
         typeof rowEncoding !== 'object') {
         fillNumbers(row, rowSource(table, rowEncoding, jexl), kept, count);
     }
+    const seriesOf = encoding.series;
+    const series = has('series') ? new Uint32Array(count) : undefined;
+    if (series && seriesOf) {
+        for (let k = 0; k < count; k++) {
+            series[k] = seriesOf[rowAt(k)];
+        }
+    }
     const text = has('text') ? new Array(count) : undefined;
     if (text) {
         if (textEncoding === undefined) {
@@ -518,11 +548,11 @@ export function encodeFeatures(input, encoding, lanes, ctx = {}) {
         ? declaredScale
         : undefined;
     const thresholdEncoding = declaredScale?.scale === 'threshold' ? declaredScale : undefined;
-    // Which side of the wire a quantitative colour resolves on is the caller's
+    // Which side of the wire a quantitative color resolves on is the caller's
     // lane choice: a mark that reads the scale itself names `colorValue` and
     // gets the raw values, so a ramp's domain unions over the regions and a
     // threshold's cuts move as uniforms. Anything else names `color` and the
-    // encoder resolves per region. A colour over the field `y` plots is the `y`
+    // encoder resolves per region. A color over the field `y` plots is the `y`
     // lane itself, aliased rather than copied.
     const quantitative = rampEncoding ?? thresholdEncoding;
     const colorReadsY = quantitative !== undefined &&
@@ -581,7 +611,7 @@ export function encodeFeatures(input, encoding, lanes, ctx = {}) {
     else if (scaled && quantitative) {
         // The raw values, where they are kept: a ramp's always, a threshold's
         // where the caller resolves it; the encoder resolves a threshold into
-        // packed colours only for a caller naming `color` alone.
+        // packed colors only for a caller naming `color` alone.
         const values = colorValue ?? (rampEncoding ? new Float32Array(count) : undefined);
         const read = channelReader(table, quantitative.field, jexl);
         if (values && !colorReadsY) {
@@ -689,7 +719,7 @@ export function encodeFeatures(input, encoding, lanes, ctx = {}) {
         encoded.color = color;
     }
     if (colorValue) {
-        // the y view itself where the colour reads y, so a reader can tell
+        // the y view itself where the color reads y, so a reader can tell
         encoded.colorValue = colorValue;
     }
     if (colorKey) {
@@ -698,6 +728,9 @@ export function encodeFeatures(input, encoding, lanes, ctx = {}) {
     if (glyph) {
         encoded.glyph = glyph;
     }
+    if (series) {
+        encoded.series = series;
+    }
     if (text) {
         encoded.text = text;
     }
@@ -708,6 +741,9 @@ export function encodeFeatures(input, encoding, lanes, ctx = {}) {
         encoded.x2Ref = x2Ref;
         encoded.x2RefNames = x2RefNames;
     }
+    if (feet) {
+        encoded.feet = feet;
+    }
     if (sizeScale) {
         encoded.sizeScale = sizeScale;
     }
@@ -756,12 +792,12 @@ function rampScale(rampEncoding, values, count, color, met) {
 }
 /**
  * #api
- * A continuous colour scale over `extent`, the values it met: the domain its
+ * A continuous color scale over `extent`, the values it met: the domain its
  * declared ends and the extent make, the straight table its stops bake to and
- * where its middle stop sits, and the packed colour a value paints through
+ * where its middle stop sits, and the packed color a value paints through
  * them: an infinity the end on its side, as a threshold places it, and NaN,
  * text that is no number, the misconfiguration grey. The encoder and every
- * display painting a ramp itself read it, so a value takes one colour whoever
+ * display painting a ramp itself read it, so a value takes one color whoever
  * paints it.
  */
 export function continuousColorScale(encoding, extent) {
@@ -799,14 +835,14 @@ function keysAreNumeric(entries) {
 // extents passes over.
 /**
  * #api
- * A CSS colour or `jexl:` colour expression as a per-feature packed ABGR —
+ * A CSS color or `jexl:` color expression as a per-feature packed ABGR —
  * the unscaled arm of {@link ColorEncoding}, on its own for a display that
  * carries a plain `color` slot.
  */
 export function colorEvaluator(color, jexl) {
     if (isJexl(color)) {
         const expr = jexlExpression(color, jexl);
-        // A jexl colour answers from a handful of strings over a million
+        // A jexl color answers from a handful of strings over a million
         // features; parsing each answer once is a third of the arm's cost
         // (packages/core/benches/encodeFeatures.bench.ts).
         const packed = new Map();
@@ -847,8 +883,8 @@ export function featureIndexAt(channels, i) {
 }
 /**
  * #api
- * The packed colour instance `i` of `channels` paints: `color[i]`, or `color`
- * itself where the colour is a constant and so shipped as one number.
+ * The packed color instance `i` of `channels` paints: `color[i]`, or `color`
+ * itself where the color is a constant and so shipped as one number.
  */
 export function colorAt(channels, i) {
     const { color } = channels;
@@ -867,12 +903,14 @@ export function encodedChannelTransferables(c) {
         c.featureIndex,
         c.y,
         c.row,
+        c.series,
         typeof c.color === 'number' ? undefined : c.color,
         c.colorValue,
         c.colorKey,
         c.glyph,
         c.size,
         c.x2Ref,
+        c.feet,
     ]) {
         if (lane) {
             buffers.add(lane.buffer);

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,6 +496,23 @@ 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
@@ -543,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: {