@jbrowse/render-core 5.0.0-beta.8 → 5.0.0-beta.9

package/esm/marks/drawAgainstHit.js

@@ -1,12 +1,12 @@
-import { inkOnRect, shapeHitNearest } from './markHit.js';
+import { inkOnRect } from './markHit.js';
 const IDENTITY = [1, 0, 0, 1, 0, 0];
 /**
  * A `MarkContext2D` that records every rect a painter fills, in paint order and
  * in CANVAS coordinates — `fillRect` and path `rect` alike, so a shape that
  * batches by colour records the same list as one that fills per instance. A
  * path traced with `moveTo`/`lineTo`/`bezierCurveTo` and filled records its
- * bounding box, which is what a shape whose hit test answers a polygon's box
- * (the variant inversion triangle) is held to; a curve contributes its control
+ * bounding box, the extent a shape whose hit test answers a polygon's box
+ * (the variant inversion triangle) is checked against; a curve contributes its control
  * points, whose hull contains it.
  *
  * A **stroked** path records one rect per `moveTo`/`lineTo` edge, each the
@@ -209,64 +209,125 @@ function unionBox(rs) {
 // arithmetic over the same projection, so a real disagreement is orders of
 // magnitude above this and a rounding one is below it.
 const EPS = 1e-9;
+const MAX_VIOLATIONS = 10;
+/**
+ * The ink clause of {@link sweepMarkAgainstHit} alone, for a mark with no
+ * `hitNearest`: `boxes[i]` is what the painter recorded for instance `i`.
+ */
+export function inkViolations(mark, channels, block, state, boxes, inkSlackPx) {
+    const violations = [];
+    if (!mark.ink) {
+        return violations;
+    }
+    for (let i = 0; i < boxes.length; i++) {
+        const r = mark.ink(channels, block, state, i);
+        const b = boxes[i];
+        if (r && !b) {
+            violations.push(`${i} painted nothing but has ink`);
+        }
+        else if (b && !r) {
+            violations.push(`${i} painted but has no ink`);
+        }
+        else if (b && r) {
+            const gaps = [
+                b.x - r.left,
+                r.left + r.width - (b.x + b.w),
+                b.y - r.top,
+                r.top + r.height - (b.y + b.h),
+            ];
+            if (gaps.some(g => g < -EPS)) {
+                violations.push(`${i} painted (${b.x}, ${b.y}, ${b.w}, ${b.h}) outside its ink (${r.left}, ${r.top}, ${r.width}, ${r.height})`);
+            }
+            else if (gaps.some(g => g > inkSlackPx + EPS)) {
+                violations.push(`${i}'s ink (${r.left}, ${r.top}, ${r.width}, ${r.height}) is more than ${inkSlackPx}px outside its painting (${b.x}, ${b.y}, ${b.w}, ${b.h})`);
+            }
+        }
+        if (violations.length >= MAX_VIOLATIONS) {
+            return violations;
+        }
+    }
+    return violations;
+}
+function hitViolations(hit, boxes, x, y) {
+    const violations = [];
+    const box = hit && boxes[hit.index];
+    if (hit && !box) {
+        violations.push(`(${x}, ${y}) answered ${hit.index}, which painted nothing`);
+    }
+    else if (hit && box) {
+        if (!contains(box, hit.x, hit.y, EPS)) {
+            violations.push(`(${x}, ${y}) answered ${hit.index} with ink at (${hit.x}, ${hit.y}), off its painting`);
+        }
+        const toBox = inkOnRect(x, y, box.x, box.y, box.w, box.h).distSq;
+        if (hit.distSq < toBox - EPS) {
+            violations.push(`(${x}, ${y}) answered ${hit.index} at ${hit.distSq}, nearer than its painting (${toBox})`);
+        }
+        const toPoint = (x - hit.x) ** 2 + (y - hit.y) ** 2;
+        if (Math.abs(hit.distSq - toPoint) > EPS * Math.max(1, toPoint)) {
+            violations.push(`(${x}, ${y}) answered ${hit.index} at ${hit.distSq}, which is not the distance to the ink it named (${toPoint})`);
+        }
+    }
+    return violations;
+}
 /**
  * The draw-against-hit gate: paint the block, then walk it in `step` px and
  * hold `hitNearest` to what the painter actually put on the canvas.
  *
  * **What the painter drew for instance `i` has to be attributed to `i`,** and
- * there are two ways to get that. A shape whose every instance is one
- * `fillRect` gets it positionally, which is the default and needs nothing. A
- * shape that batches a colour run into one path (`point`'s glyphs), or that
- * skips an instance the view has scrolled past (`cell`'s off-canvas rows),
- * cannot be read that way at all — the batch has fewer rects than instances, or
- * the wrong ones. `sliceOne` is the way in for those: hand back one instance's
- * channels and the sweep paints it alone, so the attribution holds by
- * construction and a culled instance is visibly an empty painting.
+ * there are two ways to get that. A mark whose every instance is one `fillRect`
+ * gets it positionally, which is the default and needs nothing. A mark that
+ * batches a colour run into one path (`point`'s glyphs), or that skips an
+ * instance the view has scrolled past (`cell`'s off-canvas rows), cannot be read
+ * that way at all — the batch has fewer rects than instances, or the wrong ones.
+ * `sliceOne` is the way in for those: hand back one instance's channels and the
+ * sweep paints it alone, so the attribution holds by construction and a culled
+ * instance is visibly an empty painting.
  *
- * Four claims, all of them one-directional and true of every shape:
+ * Four claims, all of them one-directional and true of every mark:
  *
  * - an instance that painted nothing is never the answer,
- * - `hit.x`/`hit.y` — where the shape says its ink is — lies inside the box the
+ * - `hit.x`/`hit.y` — where the mark says its ink is — lies inside the box the
  *   painter drew for the instance the hit names,
  * - `hit.distSq` is no smaller than the distance to that box, since the box
  *   contains the ink and cannot be farther than it,
  * - `hit.distSq` IS the distance to `hit.x`/`hit.y`, which is `MarkHit`'s own
- *   contract rather than a fact about the painting: a shape that answers a
+ *   contract rather than a fact about the painting: a mark that answers a
  *   distance its own reported point does not support has two spellings of where
  *   its ink is, and the nearest-wins walk is resolved by the one the caller
  *   cannot see.
  *
- * The fourth claim is the strongest and is not universal: **a point on the box
- * has to answer that box**, the last-painted one where boxes overlap, since the
- * sweep hands candidates back to front. It holds only where the painted box IS
- * the hit target — every `fillRect` shape, and `cell`'s inversion triangle,
- * which answers as its bounding box on purpose — and not for a glyph, whose box
- * is a superset of its ink. So it runs exactly when the batch painted one rect
- * per instance, which is that set.
+ * The fifth is the containment rule: **a point the rule contains answers the
+ * nearest painted instance it contains**, the last-painted where tied, since the
+ * sweep hands candidates back to front. The default rule is the painted box, so
+ * a point on a box answers that box, and off every box a hit target wider than
+ * its ink may still answer. The default holds only where the box IS the hit
+ * target — every `fillRect` mark, and `cell`'s inversion triangle, which answers
+ * as its bounding box on purpose — and not for a glyph, whose box is a superset
+ * of its ink, so it runs exactly when the batch painted one rect per instance. A
+ * mark whose hit rule is not its box (the pileup's bp containment) passes
+ * `contains`, which is then the whole rule: the sweep covers the whole canvas,
+ * and a point the rule contains nowhere answers nothing.
  *
- * A shape declaring `ink` is held to a second clause, per instance: the box
- * the painter recorded for `i` lies inside `ink(i)`, and each edge of `ink(i)`
- * lies within `inkSlackPx` (default 1) of the painting's — so the rect is
- * tight to the ink within a pixel on every side, which admits a seam overdraw
- * or a pixel snap and rejects a rect that is the wrong row, the wrong width or
- * the whole canvas. An instance that painted nothing must answer no ink, and
- * one with ink must have painted.
+ * A mark declaring `ink` is held to one more clause, per instance: the box the
+ * painter recorded for `i` lies inside `ink(i)`, and each edge of `ink(i)` lies
+ * within `inkSlackPx` (default 1) of the painting's — so the rect is tight to
+ * the ink within a pixel on every side, which admits a seam overdraw or a pixel
+ * snap and rejects a rect that is the wrong row, the wrong width or the whole
+ * canvas. An instance that painted nothing must answer no ink, and one with ink
+ * must have painted.
  *
  * Returns the violations rather than asserting, so a test reads as
- * `expect(sweep(...)).toEqual([])`. `maxDistSq` is the caller's, because a
- * shape whose hit target is wider than its ink (`point`) needs a bound that
- * admits the whole rect.
+ * `expect(sweep(...)).toEqual([])`. `maxDistSq` is the bound the hit test is
+ * asked with, `Infinity` unless the caller's differs.
  */
-export function sweepDrawAgainstHit(shape, channels, block, frame, params, { maxDistSq, step = 0.5, sliceOne, inkSlackPx = 1, }) {
+export function sweepMarkAgainstHit(mark, channels, block, state, { maxDistSq = Infinity, step = 0.5, sliceOne, inkSlackPx = 1, contains: rule, } = {}) {
     const { count } = channels;
-    const violations = [];
     const paint = (c) => {
         const { ctx, calls } = recordingContext();
-        shape.paintBlock(ctx, c, block, frame, params);
+        mark.paintBlock(ctx, c, block, state);
         return calls;
     };
     const rects = paint(channels);
-    // Positional attribution, and the licence for the containment claim below.
     const perRect = rects.length === count;
     if (!perRect && !sliceOne) {
         return [`painted ${rects.length} rects for ${count} instances`];
@@ -274,40 +335,6 @@ export function sweepDrawAgainstHit(shape, channels, block, frame, params, { max
     const boxes = sliceOne
         ? Array.from({ length: count }, (_, i) => unionBox(paint(sliceOne(channels, i))))
         : rects.map(r => ({ x: r.x, y: r.y, w: r.w, h: r.h }));
-    if (shape.ink) {
-        for (let i = 0; i < count; i++) {
-            const r = shape.ink(channels, block, frame, params, i);
-            const b = boxes[i];
-            if (r && !b) {
-                violations.push(`${i} painted nothing but has ink`);
-            }
-            else if (b && !r) {
-                violations.push(`${i} painted but has no ink`);
-            }
-            else if (b && r) {
-                const gaps = [
-                    b.x - r.left,
-                    r.left + r.width - (b.x + b.w),
-                    b.y - r.top,
-                    r.top + r.height - (b.y + b.h),
-                ];
-                if (gaps.some(g => g < -EPS)) {
-                    violations.push(`${i} painted (${b.x}, ${b.y}, ${b.w}, ${b.h}) outside its ink (${r.left}, ${r.top}, ${r.width}, ${r.height})`);
-                }
-                else if (gaps.some(g => g > inkSlackPx + EPS)) {
-                    violations.push(`${i}'s ink (${r.left}, ${r.top}, ${r.width}, ${r.height}) is more than ${inkSlackPx}px outside its painting (${b.x}, ${b.y}, ${b.w}, ${b.h})`);
-                }
-            }
-            if (violations.length >= 10) {
-                return violations;
-            }
-        }
-    }
-    const hitNearest = shapeHitNearest(shape);
-    if (!hitNearest) {
-        return [`${shape.id} has no hit test`];
-    }
-    const candidates = Array.from({ length: count }, (_, k) => count - 1 - k);
     let yMin = Infinity;
     let yMax = -Infinity;
     for (const b of boxes) {
@@ -319,44 +346,57 @@ export function sweepDrawAgainstHit(shape, channels, block, frame, params, { max
     if (yMin === Infinity) {
         return [`painted nothing for ${count} instances`];
     }
+    const violations = inkViolations(mark, channels, block, state, boxes, inkSlackPx);
+    if (violations.length >= MAX_VIOLATIONS) {
+        return violations;
+    }
+    if (!mark.hitNearest) {
+        return ['no hit test'];
+    }
+    const claims = rule ??
+        (perRect
+            ? (k, x, y) => contains(boxes[k], x, y)
+            : undefined);
+    const candidates = Array.from({ length: count }, (_, k) => count - 1 - k);
     const x0 = Math.min(block.screenStartPx, block.screenEndPx) - 1;
     const x1 = Math.max(block.screenStartPx, block.screenEndPx) + 1;
-    for (let y = Math.floor(yMin) - 1; y <= yMax + 1; y += step) {
+    const y0 = rule ? -1 : Math.floor(yMin) - 1;
+    const y1 = rule ? state.canvasHeight + 1 : yMax + 1;
+    let answered = 0;
+    for (let y = y0; y <= y1; y += step) {
         for (let x = x0; x <= x1; x += step) {
             let expected = -1;
-            if (perRect) {
-                for (let k = count - 1; k >= 0; k--) {
-                    if (contains(boxes[k], x, y)) {
-                        expected = k;
-                        break;
+            let expectedDistSq = maxDistSq;
+            if (claims) {
+                for (const k of candidates) {
+                    const b = boxes[k];
+                    if (b && claims(k, x, y)) {
+                        const distSq = inkOnRect(x, y, b.x, b.y, b.w, b.h).distSq;
+                        if (expected === -1
+                            ? distSq < maxDistSq
+                            : distSq < expectedDistSq - EPS) {
+                            expected = k;
+                            expectedDistSq = distSq;
+                        }
                     }
                 }
             }
-            const hit = hitNearest(channels, block, frame, params, x, y, candidates, maxDistSq);
-            const box = hit && boxes[hit.index];
-            if (hit && !box) {
-                violations.push(`(${x}, ${y}) answered ${hit.index}, which painted nothing`);
+            const hit = mark.hitNearest(channels, block, state, x, y, candidates, maxDistSq);
+            if (hit) {
+                answered++;
             }
-            else if (hit && box) {
-                if (!contains(box, hit.x, hit.y, EPS)) {
-                    violations.push(`(${x}, ${y}) answered ${hit.index} with ink at (${hit.x}, ${hit.y}), off its painting`);
-                }
-                const toBox = inkOnRect(x, y, box.x, box.y, box.w, box.h).distSq;
-                if (hit.distSq < toBox - EPS) {
-                    violations.push(`(${x}, ${y}) answered ${hit.index} at ${hit.distSq}, nearer than its painting (${toBox})`);
-                }
-                const toPoint = (x - hit.x) ** 2 + (y - hit.y) ** 2;
-                if (Math.abs(hit.distSq - toPoint) > EPS * Math.max(1, toPoint)) {
-                    violations.push(`(${x}, ${y}) answered ${hit.index} at ${hit.distSq}, which is not the distance to the ink it named (${toPoint})`);
-                }
+            violations.push(...hitViolations(hit, boxes, x, y));
+            if (expected === -1
+                ? rule !== undefined && hit !== undefined
+                : hit?.index !== expected) {
+                violations.push(`(${x}, ${y}) should answer ${expected === -1 ? 'nothing' : expected}, answered ${hit?.index ?? 'nothing'}`);
             }
-            if (expected !== -1 && hit?.index !== expected) {
-                violations.push(`(${x}, ${y}) is on rect ${expected}, answered ${hit?.index ?? 'nothing'}`);
-            }
-            if (violations.length >= 10) {
+            if (violations.length >= MAX_VIOLATIONS) {
                 return violations;
             }
         }
     }
-    return violations;
+    return answered === 0 && violations.length === 0
+        ? [`no swept point answered any of ${count} instances`]
+        : violations;
 }

package/esm/marks/glyphPaint.d.ts

@@ -7,8 +7,8 @@ export type GlyphPath = Pick<MarkContext2D, 'moveTo' | 'lineTo' | 'closePath' |
  *
  * The disc/crisp-square split and the square's snap are pointGlyph.slang's
  * (adr-051), so the painter cannot drift from the shader about where the split
- * is. The caller owns `beginPath`/`fill`, which is what lets a run of one
- * colour batch into a single fill.
+ * is. The caller owns `beginPath`/`fill`, so a run of one colour can batch into
+ * a single fill.
  *
  * Its own module, not `pointMark.ts`'s: this is the half of the shape a
  * consumer can want without the pass, and importing it through the shape would
@@ -16,6 +16,18 @@ export type GlyphPath = Pick<MarkContext2D, 'moveTo' | 'lineTo' | 'closePath' |
  * is that consumer.
  */
 export declare function appendGlyph(ctx: GlyphPath, glyph: number, cx: number, y: number, diameter: number): void;
+/**
+ * Room a glyph needs at each end of a plot whose display wants its topmost and
+ * bottommost points drawn whole: a bar's datum is its top edge and never
+ * overshoots, a glyph's is its centre, so one at domain max loses its top half
+ * off the canvas. The diamond's scale, since that is the largest thing the
+ * shape draws and `glyphBox` measures it the same way.
+ *
+ * A display passes this as the point shape's `insetPx` and gives its axis the
+ * same number as an offset, so domain max goes on labelling the row the
+ * topmost glyph centres on.
+ */
+export declare function pointInsetPx(diameter: number): number;
 /**
  * The box `appendGlyph` paints inside, by the same split and snap: the
  * diamond is scaled by `DIAMOND_GLYPH_SCALE` and the small square snaps to

package/esm/marks/glyphPaint.js

@@ -7,8 +7,8 @@ import { DIAMOND_GLYPH_SCALE, GLYPH_DIAMOND, GLYPH_TRIANGLE, } from '../shaders/
  *
  * The disc/crisp-square split and the square's snap are pointGlyph.slang's
  * (adr-051), so the painter cannot drift from the shader about where the split
- * is. The caller owns `beginPath`/`fill`, which is what lets a run of one
- * colour batch into a single fill.
+ * is. The caller owns `beginPath`/`fill`, so a run of one colour can batch into
+ * a single fill.
  *
  * Its own module, not `pointMark.ts`'s: this is the half of the shape a
  * consumer can want without the pass, and importing it through the shape would
@@ -39,6 +39,20 @@ export function appendGlyph(ctx, glyph, cx, y, diameter) {
         ctx.arc(cx, y, r, 0, Math.PI * 2);
     }
 }
+/**
+ * Room a glyph needs at each end of a plot whose display wants its topmost and
+ * bottommost points drawn whole: a bar's datum is its top edge and never
+ * overshoots, a glyph's is its centre, so one at domain max loses its top half
+ * off the canvas. The diamond's scale, since that is the largest thing the
+ * shape draws and `glyphBox` measures it the same way.
+ *
+ * A display passes this as the point shape's `insetPx` and gives its axis the
+ * same number as an offset, so domain max goes on labelling the row the
+ * topmost glyph centres on.
+ */
+export function pointInsetPx(diameter) {
+    return (diameter / 2) * DIAMOND_GLYPH_SCALE;
+}
 /**
  * The box `appendGlyph` paints inside, by the same split and snap: the
  * diamond is scaled by `DIAMOND_GLYPH_SCALE` and the small square snaps to

package/esm/marks/index.d.ts

@@ -2,13 +2,15 @@ export { defineMark } from './types.ts';
 export { paintMarkBlocks } from './markPaint.ts';
 export { planMarks } from './markPlan.ts';
 export { inkOfInstances } from './markInk.ts';
+export { backToFront, nearestMarkHit, valueWindow } from './nearestMarkHit.ts';
 export { barMark } from './barMark.ts';
 export { pointMark } from './pointMark.ts';
-export { blockPx, spanMark } from './spanMark.ts';
-export { appendGlyph } from './glyphPaint.ts';
+export { spanMark } from './spanMark.ts';
+export { appendGlyph, pointInsetPx } from './glyphPaint.ts';
 export { abgrToCssRgba, makeAbgrFill } from './colorFill.ts';
 export type { MarkPlan } from './markPlan.ts';
 export type { MarkInstance } from './markInk.ts';
+export type { HitWindow, NearestMarkHit } from './nearestMarkHit.ts';
 export type { Mark, MarkBand, MarkContext2D, MarkFrame, MarkImage, MarkRamp, MarkTexture, MarkValueScaleType, InkRect, MarkHit, MarkShape, PlannedPass, StagedUniforms, } from './types.ts';
 export type { BarChannels, BarParams } from './barMark.ts';
 export type { PointChannels, PointParams } from './pointMark.ts';

package/esm/marks/index.js

@@ -2,8 +2,9 @@ export { defineMark } from './types.js';
 export { paintMarkBlocks } from './markPaint.js';
 export { planMarks } from './markPlan.js';
 export { inkOfInstances } from './markInk.js';
+export { backToFront, nearestMarkHit, valueWindow } from './nearestMarkHit.js';
 export { barMark } from './barMark.js';
 export { pointMark } from './pointMark.js';
-export { blockPx, spanMark } from './spanMark.js';
-export { appendGlyph } from './glyphPaint.js';
+export { spanMark } from './spanMark.js';
+export { appendGlyph, pointInsetPx } from './glyphPaint.js';
 export { abgrToCssRgba, makeAbgrFill } from './colorFill.js';

package/esm/marks/markBackend.d.ts

@@ -81,8 +81,8 @@ export declare class Canvas2DMarkBackend<TRegion, TState extends FrameDimensions
  * are the marks' own and each backend walks the same list.
  *
  * One uniform buffer serves every mark because each writes its own layout into
- * the scratch immediately before its own `drawPass`, which is what the HAL's
- * write-then-draw ordering already guarantees for a multi-pass renderer — or
+ * the scratch immediately before its `drawPass`, the ordering the HAL's
+ * write-then-draw contract already guarantees for a multi-pass renderer — or
  * draws off the struct the previous mark of the same block already staged, per
  * `StagedUniforms`.
  */

package/esm/marks/markBackend.js

@@ -151,8 +151,8 @@ export class Canvas2DMarkBackend extends Canvas2DPerRegionRenderingBackend {
  * are the marks' own and each backend walks the same list.
  *
  * One uniform buffer serves every mark because each writes its own layout into
- * the scratch immediately before its own `drawPass`, which is what the HAL's
- * write-then-draw ordering already guarantees for a multi-pass renderer — or
+ * the scratch immediately before its `drawPass`, the ordering the HAL's
+ * write-then-draw contract already guarantees for a multi-pass renderer — or
  * draws off the struct the previous mark of the same block already staged, per
  * `StagedUniforms`.
  */

package/esm/marks/markHit.d.ts

@@ -15,8 +15,8 @@ export declare function inkAtPoint(xPx: number, yPx: number, x: number, y: numbe
  * This is the whole of every shape's `hitNearest` but the geometry: `inkAt`
  * answers where instance `i` put ink and how far that is, and this keeps the
  * closest. Only a STRICTLY nearer candidate replaces the best, so on a tie the
- * first wins — which is what makes a caller that iterates back to front get the
- * mark on top, and it is a rule that used to be spelled out five times over.
+ * first wins, so a caller that iterates back to front gets the mark on top.
+ * Five shapes used to spell that rule out separately.
  *
  * `inkAt` may answer `undefined` for an instance that drew nothing at all, as
  * against one that drew somewhere far away: a bar clipped out of its band has

package/esm/marks/markHit.js

@@ -22,8 +22,8 @@ export function inkAtPoint(xPx, yPx, x, y) {
  * This is the whole of every shape's `hitNearest` but the geometry: `inkAt`
  * answers where instance `i` put ink and how far that is, and this keeps the
  * closest. Only a STRICTLY nearer candidate replaces the best, so on a tie the
- * first wins — which is what makes a caller that iterates back to front get the
- * mark on top, and it is a rule that used to be spelled out five times over.
+ * first wins, so a caller that iterates back to front gets the mark on top.
+ * Five shapes used to spell that rule out separately.
  *
  * `inkAt` may answer `undefined` for an instance that drew nothing at all, as
  * against one that drew somewhere far away: a bar clipped out of its band has

package/esm/marks/markPlan.d.ts

@@ -19,7 +19,7 @@ export interface MarkPlan<TRegion, TState extends MarkFrame> {
 /**
  * Resolve which marks draw this frame. Throws for an enabled mark the plan
  * form cannot carry — one with a `band` or a `paintsBlock` — since a plan
- * neither scissors nor asks the block anything, and dropping the gate silently
- * would draw on the GPU what Canvas2D declines.
+ * neither scissors nor asks the block anything, and without the throw the GPU
+ * would draw what Canvas2D declines.
  */
 export declare function planMarks<TRegion, TState extends MarkFrame>(marks: readonly Mark<TRegion, TState>[], state: TState): MarkPlan<TRegion, TState>;

package/esm/marks/markPlan.js

@@ -1,8 +1,8 @@
 /**
  * Resolve which marks draw this frame. Throws for an enabled mark the plan
  * form cannot carry — one with a `band` or a `paintsBlock` — since a plan
- * neither scissors nor asks the block anything, and dropping the gate silently
- * would draw on the GPU what Canvas2D declines.
+ * neither scissors nor asks the block anything, and without the throw the GPU
+ * would draw what Canvas2D declines.
  */
 export function planMarks(marks, state) {
     const enabled = [];

package/esm/marks/markRamp.d.ts

@@ -1,4 +1,4 @@
-import type { MarkRamp, MarkValueScaleType } from './types.ts';
+import type { MarkRamp } from './types.ts';
 /**
  * A colour channel as a shape reads it: `color`, the packed ABGR the worker
  * resolved, or `colorValue`, the raw values a frame's {@link MarkRamp} turns
@@ -18,8 +18,6 @@ interface RampBake {
     lut: Uint8Array;
     colors: Uint32Array;
 }
-/** `scoreScale`'s scale-type code for a declared value scale. */
-export declare function valueScaleTypeCode(scale: MarkValueScaleType | undefined): 0 | 1;
 /** `markColor.slang`'s three uniforms for a frame's ramp, or for none. */
 export declare function rampUniforms(ramp: MarkRamp | undefined): {
     rampMode: number;

package/esm/marks/markRamp.js

@@ -1,11 +1,7 @@
+import { SCALE_TYPE_LOG } from '../scoreScale.js';
 import { RAMP_LINEAR, RAMP_LOG, RAMP_NONE, } from '../shaders/markColor.generated.js';
-import { SCALE_TYPE_LOG } from '../shaders/scoreScale.generated.js';
 import { normalizeScore } from '../shaders/scoreScale.js.generated.js';
 const NO_COLORS = new Uint32Array(0);
-/** `scoreScale`'s scale-type code for a declared value scale. */
-export function valueScaleTypeCode(scale) {
-    return scale === 'log' ? SCALE_TYPE_LOG : 0;
-}
 /** `markColor.slang`'s three uniforms for a frame's ramp, or for none. */
 export function rampUniforms(ramp) {
     return ramp

package/esm/marks/nearestMarkHit.d.ts

@@ -0,0 +1,49 @@
+import type { RenderBlock } from '../renderBlock.ts';
+import type { RowParams } from './rowLane.ts';
+import type { Mark, MarkFrame, MarkHit, MarkValueScaleType } from './types.ts';
+/**
+ * What a cursor's grab radius spans in one block for one mark: the bp, and
+ * the values the mark's shape can put ink at, every value for a shape with no
+ * `valueWindow`.
+ */
+export interface HitWindow {
+    block: RenderBlock;
+    bpMin: number;
+    bpMax: number;
+    valueMin: number;
+    valueMax: number;
+}
+/** A {@link MarkHit}, with the mark, block and region it was found in. */
+export interface NearestMarkHit<TRegion> extends MarkHit {
+    mark: number;
+    block: RenderBlock;
+    region: TRegion;
+}
+/**
+ * The instance nearest `(xPx, yPx)` within `radiusPx`, over the blocks the
+ * radius reaches. Marks are asked last to first and only a strictly nearer hit
+ * replaces the best, so a tie goes to the mark on top. `candidates` names what
+ * a mark is asked about in a block: what an index finds in the reach, or
+ * `backToFront` over every instance. `undefined` leaves the mark out, as a
+ * closed gate does.
+ */
+export declare function nearestMarkHit<TRegion, TState extends MarkFrame>(marks: readonly Mark<TRegion, TState>[], blocks: readonly RenderBlock[], regionOf: (displayedRegionIndex: number) => TRegion | undefined, state: TState, xPx: number, yPx: number, { radiusPx, candidates, }: {
+    radiusPx: number;
+    candidates: (region: TRegion, mark: number, reach: HitWindow) => Iterable<number> | undefined;
+}): NearestMarkHit<TRegion> | undefined;
+/** `[end - 1 .. start]`: every instance as candidates, back to front. */
+export declare function backToFront(start: number, end: number): Iterable<number>;
+/**
+ * A value-scaled shape's `valueWindow`, read back through `denormalizeScore`
+ * inside each `rowHeight` band the radius touches — the whole canvas for a
+ * shape with no rows. An end within reach of a band edge opens to infinity,
+ * where an out-of-domain value clamps, so a cursor near the seam reaches the
+ * neighbouring band too. A point passes its `insetPx`; a bar passes its
+ * `origin`, and its window opens away from the origin on the cursor's side.
+ */
+export declare function valueWindow(yPx: number, radiusPx: number, { canvasHeight }: MarkFrame, scale: RowParams & {
+    domain: [number, number];
+    scaleType?: MarkValueScaleType;
+    insetPx?: number;
+    origin?: number;
+}): [number, number];