@jbrowse/render-core 5.0.0-beta.1 → 5.0.0-beta.10

package/src/shaders/curveDistance.slang

@@ -0,0 +1,265 @@
+// Exact distances to the two curves a stroked arc is measured against - an
+// axis-aligned ellipse, and a circle whose radius dwarfs the band it is
+// clipped to - and the hull vertices that have to clear them. Shared by the
+// alignments arc band and the link mark, which draw the same half-ellipse and
+// degenerate it to the same circle.
+//
+// The fragment ramps its alpha to zero at `halfWidth + aaHalfPx`, so the hull
+// has to cover everything nearer the curve than that. Both flanks of a hull
+// sampled from the offset curve fall short of it at a clamped dome's feet.
+//! js-export: distToWideCirclePx, wideCircleLeg, wideCircleLegStep, ellipseHullPoint, wideCircleHullPoint
+//! js-skip: nearCircleDistancePx — a float32 remedy with no float64 caller. The hit tests' copy of this file's solve (marks/ellipseDistance.ts) holds the ellipse at every aspect, so nothing outside the shader has an approximation to want.
+//! oracle-skip: ellipseHullPoint — a miter between near-parallel tangent lines, so float32 and float64 part on the probe's arbitrary directions and radii; over the angles the hull steps through they agree to 0.004 px, and arcHull.test.ts referees the twin against every inked point instead
+//! oracle-skip: wideCircleHullPoint — the foot-relative frame cancels at half steps and angles the band never reaches; arcHull.test.ts referees it with the legs
+
+module curveDistance;
+
+// How near a circle an ellipse has to be before `sdEllipse` stops solving and
+// measures instead: radii within ~2.5%, as |ay² - ax²| against ay². The two
+// formulas' worst errors over a 6px stroke meet here at ~0.01px — below it the
+// solve degrades with radius (0.10px at r=4000), above it the measure degrades
+// with curvature (0.01px at r=4).
+static const float ELLIPSE_CIRCLE_TOL = 0.05;
+
+// The distance to an ellipse the solve cannot reach. Every term in it divides
+// by `l = ay² - ax²`, a difference of two nearly equal squares, so float32 has
+// lost the ellipse before the quartic is assembled: at 250px radii 1e-5 apart
+// the solve is 3.6px out and 36% of the stroke's samples flip. Not a corner —
+// a clamped dome pins ry to the band while rx tracks the pair's width, so a
+// zoom walks rx through ry and through every ratio on the way.
+//
+// The implicit field |p/ab| - 1 over its own gradient instead: exact on a true
+// circle, which is why it replaces the exact-circle branch rather than sitting
+// beside it, and first-order elsewhere.
+float nearCircleDistancePx(float qx, float qy, float ax, float ay) {
+  float kx = qx / ax;
+  float ky = qy / ay;
+  float k = sqrt(kx * kx + ky * ky);
+  float gx = qx / (ax * ax);
+  float gy = qy / (ay * ay);
+  return abs(k * (k - 1.0) / max(sqrt(gx * gx + gy * gy), 1e-20));
+}
+
+// Inigo Quilez's closed-form solve of the quartic. Chosen over the iterative
+// alternatives because the arc band produces very flat ellipses (a 25px band
+// under a 1500px pair is 44:1, and it goes past 88:1): measured against an
+// fp64 reference at fp32 precision, this stays within 0.031px out to 88:1,
+// where a seeded Newton on the parametric angle runs away entirely.
+//
+// THAT MEASUREMENT IS THE FLAT END, and the solve fails at the round one, in
+// float32 alone — the same source in float64 is exact to 1e-9. It breaks the
+// picture rather than nudging it, because the stroke reads this through a
+// half-pixel ramp: a dome at 380x249px drew as scattered dots on WebGL where
+// Canvas2D drew a line. Two guards below, each where its failure arises.
+//
+// NOT `//! js-export`ed, and the hit tests carry a float64 copy of this formula
+// (render-core marks/ellipseDistance.ts) BECAUSE of that. The reasoning is
+// worth keeping, since "lift it like linkRadiiPx" is the obvious first move and
+// it was tried:
+//
+//   - The emitter refuses float2 params, so lifting means splitting a scalar
+//     core out (the ADR-051 step-1 pattern). Necessary but NOT sufficient, and
+//     the shortfall is SILENT: the core still calls acos/cos/sin, none of which
+//     are in the emitter's MATH_BUILTINS, so the emitter refuses it — and
+//     check-oracle's `emittableOf` DROPS a refused candidate from the sweep
+//     rather than failing on it. Do the split alone and the oracle stays green
+//     on an unchanged comparison count, which reads as "the problem went away".
+//     It has not; nothing has been checked.
+//   - Add those three builtins and it does enter the sweep — which takes every
+//     declared function with an emittable scalar signature, not only the
+//     `//! js-export`ed ones, and `//! js-skip` does not exempt one either. Then
+//     it fails, at the oracle's 1e-5 relative: 90 of the 400 tuples, 42 of them
+//     on inputs with both radii positive (the sweep also generates negative
+//     radii, which `linkRadiiPx` does not produce).
+//   - And NOT because the twin is wrong. On every one of those 42 the float64
+//     twin matches a brute-force minimum over the parametric angle to 1.1e-6
+//     relative — inside the oracle's own tolerance — and slangc's float32 is the
+//     side that has drifted: `(1.5, 0, 65536, 3)` is 3.0, where the C++ answers
+//     3.3541019. float32 loses the solver, float64 does not.
+//   - So the oracle cannot referee this function at any tolerance it could keep
+//     for the rest of the tree, the same way it cannot referee `mix`/`step`
+//     (SHADER_JS_CODEGEN.md). Exporting it would have meant a suppression in
+//     the strongest gate here, to share a NUMERICAL METHOD rather than a
+//     decision.
+//
+// What actually has to agree is WHICH ELLIPSE, and that is the radii pair
+// `linkMark.slang` `//! js-export`s (`linkRadiiPx`), which is what its hit test
+// reads. Given the same two radii, the distance to them is geometry with
+// one right answer, and the copy is pinned against a brute-force reference
+// rather than against this (see ellipseDistance.test.ts), which is the
+// stronger check of the two.
+public float sdEllipse(float2 p, float2 radii) {
+  float2 q = abs(p);
+  float2 ab = radii;
+  if (q.x > q.y) { q = q.yx; ab = ab.yx; }
+  // Both radii zero is the one shape the near-circle test below cannot catch:
+  // its own threshold is `ab.y * ab.y`, so it reads `abs(l) < 0` and lets a
+  // zero `l` through to divide. A link pair whose two ends land on the same
+  // pixel reaches it (`linkRadiiPx` of a zero half-width), and the ellipse is
+  // then the point at the origin.
+  if (dot(ab, ab) <= 0.0) { return length(q); }
+  float l = ab.y * ab.y - ab.x * ab.x;
+  if (abs(l) < ELLIPSE_CIRCLE_TOL * ab.y * ab.y) {
+    return nearCircleDistancePx(q.x, q.y, ab.x, ab.y);
+  }
+  float m = ab.x * q.x / l; float m2 = m * m;
+  float n = ab.y * q.y / l; float n2 = n * n;
+  float c = (m2 + n2 - 1.0) / 3.0;
+  float c3 = c * c * c;
+  float d = c3 + m2 * n2;
+  float g = m + m * n2;
+  float co;
+  if (d < 0.0) {
+    float h = acos(clamp((c3 + m2 * n2 * 2.0) / c3, -1.0, 1.0)) / 3.0;
+    float s = cos(h);
+    float t = sin(h) * sqrt(3.0);
+    float rx = sqrt(max(-c * (s + t + 2.0) + m2, 0.0));
+    float ry = sqrt(max(-c * (s - t + 2.0) + m2, 0.0));
+    co = (ry + sign(l) * rx + abs(g) / max(rx * ry, 1e-20) - m) / 2.0;
+  } else {
+    float qq = c3 + m2 * n2 * 2.0;
+    float h = 2.0 * m * n * sqrt(d);
+    // The two cube roots are of `qq + h` and `qq - h`, whose product is c3*c3
+    // identically. So the lower one comes from that quotient rather than from
+    // the subtraction, which cancels to nothing exactly where the dome lives:
+    // at 380x249px the two agree to every float32 digit they have, `qq - h`
+    // rounds to zero, and the distance lands up to 3px off the curve.
+    float w = qq + h;
+    float aw = abs(w);
+    float s = sign(w) * pow(aw, 1.0 / 3.0);
+    float t = aw > 0.0 ? sign(w) * pow(c3 * (c3 / aw), 1.0 / 3.0) : 0.0;
+    float rx = -s - t - c * 4.0 + 2.0 * m2;
+    float ry = (s - t) * sqrt(3.0);
+    float rm = sqrt(rx * rx + ry * ry);
+    co = (ry / sqrt(max(rm - rx, 1e-20)) + 2.0 * g / max(rm, 1e-20) - m) / 2.0;
+  }
+  co = clamp(co, -1.0, 1.0);
+  float2 r = ab * float2(co, sqrt(max(1.0 - co * co, 0.0)));
+  return length(r - q);
+}
+
+// Distance from a point to a circle whose radius dwarfs the band it is clipped
+// to — the far-pair case, where r reaches millions of px. `legLocal` is the
+// point relative to the endpoint the circle meets the baseline at, x positive
+// pointing AWAY from the circle.
+//
+// Exact, but written so nothing cancels: the centre sits at (-r, 0) in that
+// frame, so |p-c|² = r² + 2r·x + x² + y² identically and
+// |p-c| - r = rk / (sqrt(1+k) + 1) with both `rk` and `k` assembled from small
+// terms. Evaluating `length(p - c) - r`, or even recovering x as
+// `abs(p.x) - r` from a centre-relative point, loses every significant digit
+// past r ≈ 1e6 px.
+//
+// Scalar core, `//! js-export`ed for the hit tests — and for the same reason
+// it is written this way at all: a hit test asking "is the cursor on this leg"
+// from `length(p - c) - r` would lose every significant digit exactly where
+// far pairs live.
+public float distToWideCirclePx(float x, float y, float r) {
+  float rk = 2.0 * x + (x * x + y * y) / r;
+  return abs(rk / (sqrt(max(1.0 + rk / r, 0.0)) + 1.0));
+}
+
+public float distToWideCircle(float2 legLocal, float r) {
+  return distToWideCirclePx(legLocal.x, legLocal.y, r);
+}
+
+// How far around a far circle each leg's hull sweeps, in radians from its foot:
+// to the band's edge and no further. Sweeping the whole quarter spends nearly
+// every segment off-screen, and at r = 3e6 px the whole band then falls inside
+// the first chord, which recedes from the near-vertical curve at a rate set by
+// the angle per segment — so the leg draws as a tapering triangle however many
+// segments there are. Clamped, so a circle small enough to apex inside the band
+// still gets its full quarter and draws as a dome.
+public float legSweepAngle(float radiusPx, float yReachPx) {
+  return asin(clamp(yReachPx / max(radiusPx, 1e-6), 0.0, 1.0));
+}
+
+// Which leg vertex pair `seg` of a `segments`-long strip builds (x: +1 the right
+// leg, -1 the left), and its angle from that leg's foot (y). The strip has
+// `segments + 1` pairs, one more than either leg needs, and at an even
+// `segments` the right leg takes it. Each leg is spread over ITS OWN count, so
+// both reach `legSweep` — and both do so in equal angular steps, which is what
+// puts a chord's sagitta below a pixel everywhere the band can show. The quad
+// between the two tips is the seam the fragment discards.
+//
+// `segments` is at least 3; below that the left leg is a single pair and has no
+// span to spread. Both callers pass a compile-time 64.
+public float2 wideCircleLeg(uint seg, uint segments, float legSweep) {
+  uint half = segments / 2u;
+  if (seg <= half) {
+    return float2(1.0, float(seg) / float(half) * legSweep);
+  }
+  return float2(-1.0,
+                float(segments - seg) / float(segments - half - 1u) * legSweep);
+}
+
+// The angle between neighbouring vertex pairs on `seg`'s leg, which is not the
+// same on both legs.
+public float wideCircleLegStep(uint seg, uint segments, float legSweep) {
+  uint half = segments / 2u;
+  return legSweep / float(seg <= half ? half : segments - half - 1u);
+}
+
+// One hull vertex at parametric angle `a` for a hull stepping `2 * halfStep`,
+// `padPx` from the half-ellipse: positive on the outer flank, negative on the
+// inner.
+//
+// Outside, the offset region is convex, so the vertex is where the offset
+// tangent lines at `a` +/- the half step meet: `p(a) * sec(halfStep)` plus the
+// miter `padPx * (n1 + n2) / (1 + n1 . n2)`. Chords through points on the
+// offset curve would sag inside it. The divisor's floor keeps a collapsed band
+// (ry 0, the foot's normals opposed) finite.
+//
+// Inside, a chord between offset points already stays clear of the ink, until
+// the curve turns tighter than the pad and the offset folds past an axis. A
+// folded vertex moves to where the fold crosses that axis, the one point there
+// exactly the pad from the curve.
+public float2 ellipseHullPoint(float cosA, float sinA, float cosHalf,
+                               float sinHalf, float rx, float ry, float padPx) {
+  float px = cosA * rx;
+  float py = sinA * ry;
+  if (padPx <= 0.0) {
+    float d = -padPx;
+    float gx = ry * cosA;
+    float gy = rx * sinA;
+    float glen = sqrt(gx * gx + gy * gy);
+    bool acrossX = ry * glen < d * rx;
+    bool acrossY = rx * glen < d * ry;
+    if (acrossX && acrossY) { return float2(0.0, 0.0); }
+    if (acrossX) {
+      float foldX = sqrt(max(ry * ry - d * d, 0.0) * max(rx * rx - ry * ry, 0.0));
+      return float2(sign(cosA) * foldX / max(ry, 1e-6), 0.0);
+    }
+    if (acrossY) {
+      float foldY = sqrt(max(rx * rx - d * d, 0.0) * max(ry * ry - rx * rx, 0.0));
+      return float2(0.0, sign(sinA) * foldY / max(rx, 1e-6));
+    }
+    float k = d / max(glen, 1e-6);
+    return float2(px - gx * k, py - gy * k);
+  }
+  float ax = ry * (cosA * cosHalf + sinA * sinHalf);
+  float ay = rx * (sinA * cosHalf - cosA * sinHalf);
+  float bx = ry * (cosA * cosHalf - sinA * sinHalf);
+  float by = rx * (sinA * cosHalf + cosA * sinHalf);
+  float al = max(sqrt(ax * ax + ay * ay), 1e-20);
+  float bl = max(sqrt(bx * bx + by * by), 1e-20);
+  float nx = ax / al + bx / bl;
+  float ny = ay / al + by / bl;
+  float m = 2.0 * padPx / max(nx * nx + ny * ny, 2e-4);
+  return float2(px / cosHalf + nx * m, py / cosHalf + ny * m);
+}
+
+// The same vertex for a far pair's leg, in the foot-relative frame
+// `distToWideCirclePx` measures in. A circle's normals are radial, so the outer
+// flank scales the offset radius by `sec(halfStep)` and the inner one takes the
+// offset point as it is. The vertex's standoff from the circle is carried as
+// `grow` rather than recovered from `r * cos(b) - r`, which cancels at the radii
+// far pairs reach.
+public float2 wideCircleHullPoint(float sinB, float sinHalfB, float cosHalf,
+                                  float radiusPx, float padPx) {
+  float sec = padPx > 0.0 ? 1.0 / max(cosHalf, 1e-6) : 1.0;
+  float grow = radiusPx * (sec - 1.0) + sec * padPx;
+  float sh2 = sinHalfB * sinHalfB;
+  return float2(grow * (1.0 - 2.0 * sh2) - 2.0 * radiusPx * sh2,
+                (radiusPx + grow) * sinB);
+}

package/src/shaders/hpClampFloor.test.ts

@@ -0,0 +1,87 @@
+// `hpToClipX` and `hpScaleLinear` clamp each half of the hi/lo split to a floor
+// nothing can reach, and the clamp is there so no backend folds the split into
+// one large subtraction. The floor used to be `-1.0 / hpZero`, and `hpZero` is
+// uploaded as exactly 0 — a division by zero in every emitted backend, which
+// WGSL lets an implementation answer with an indeterminate value rather than an
+// infinity. (`coverageBandMarks.test.ts`, `coverageBandUboParity.test.ts` and
+// maf's `coverageBandDraw.test.ts` are what hold the uploaded value at 0.)
+//
+// So: the floor must be a finite literal, the two clamps must survive, and
+// `hpZero` must reach neither as a divisor.
+import { GLSL_VERTEX as barMarkGlsl } from './barMark.glsl.generated.ts'
+import { WGSL_SOURCE as barMarkWgsl } from './barMark.wgsl.generated.ts'
+import { GLSL_VERTEX as coverageBarGlsl } from './coverageBar.glsl.generated.ts'
+import { WGSL_SOURCE as coverageBarWgsl } from './coverageBar.wgsl.generated.ts'
+import { GLSL_VERTEX as coverageIndicatorGlsl } from './coverageIndicator.glsl.generated.ts'
+import { WGSL_SOURCE as coverageIndicatorWgsl } from './coverageIndicator.wgsl.generated.ts'
+import { GLSL_VERTEX as coverageInterbaseGlsl } from './coverageInterbase.glsl.generated.ts'
+import { WGSL_SOURCE as coverageInterbaseWgsl } from './coverageInterbase.wgsl.generated.ts'
+import { GLSL_VERTEX as coverageModGlsl } from './coverageMod.glsl.generated.ts'
+import { WGSL_SOURCE as coverageModWgsl } from './coverageMod.wgsl.generated.ts'
+import { GLSL_VERTEX as coverageSnpGlsl } from './coverageSnp.glsl.generated.ts'
+import { WGSL_SOURCE as coverageSnpWgsl } from './coverageSnp.wgsl.generated.ts'
+import { GLSL_VERTEX as pointMarkGlsl } from './pointMark.glsl.generated.ts'
+import { WGSL_SOURCE as pointMarkWgsl } from './pointMark.wgsl.generated.ts'
+import { GLSL_VERTEX as spanMarkGlsl } from './spanMark.glsl.generated.ts'
+import { WGSL_SOURCE as spanMarkWgsl } from './spanMark.wgsl.generated.ts'
+
+const SOURCES = {
+  'barMark wgsl': barMarkWgsl,
+  'barMark glsl': barMarkGlsl,
+  'coverageBar wgsl': coverageBarWgsl,
+  'coverageBar glsl': coverageBarGlsl,
+  'coverageIndicator wgsl': coverageIndicatorWgsl,
+  'coverageIndicator glsl': coverageIndicatorGlsl,
+  'coverageInterbase wgsl': coverageInterbaseWgsl,
+  'coverageInterbase glsl': coverageInterbaseGlsl,
+  'coverageMod wgsl': coverageModWgsl,
+  'coverageMod glsl': coverageModGlsl,
+  'coverageSnp wgsl': coverageSnpWgsl,
+  'coverageSnp glsl': coverageSnpGlsl,
+  'pointMark wgsl': pointMarkWgsl,
+  'pointMark glsl': pointMarkGlsl,
+  'spanMark wgsl': spanMarkWgsl,
+  'spanMark glsl': spanMarkGlsl,
+}
+
+function bodyOf(source: string, name: string) {
+  const open = source.indexOf('{', source.indexOf(`${name}(`))
+  const close = source.indexOf('}', open)
+  return source.slice(open + 1, close)
+}
+
+// The bp coordinates the split carries are uint32, so no difference of two of
+// them reaches -2^33.
+const BP_REACH = -(2 ** 33)
+
+const CASES = Object.entries(SOURCES).flatMap(([where, source]) =>
+  ['hpToClipX_0', 'hpScaleLinear_0']
+    .filter(name => source.includes(`${name}(`))
+    .map(name => [`${where} ${name}`, bodyOf(source, name)] as const),
+)
+
+test('every hp conversion the emitted backends carry is covered', () => {
+  expect(CASES.length).toBe(Object.keys(SOURCES).length)
+})
+
+describe.each(CASES)('%s', (_where, body) => {
+  test('never divides by the hpZero uniform', () => {
+    expect(body).toMatch(/hpZero_\d+/)
+    expect(body).not.toMatch(/\/\s*(-\s*)?\(?\s*hpZero_\d+/)
+  })
+
+  test('clamps both halves against a finite floor below any bp difference', () => {
+    const floors = [...body.matchAll(/max\([^,]+,\s*(\w+)\)/g)].map(m => m[1])
+    expect(floors).toHaveLength(2)
+    expect(new Set(floors).size).toBe(1)
+
+    const assigned = new RegExp(`${floors[0]}[^=]*=\\s*([^;]+);`).exec(body)
+    const literal = /-?\d[\d.]*e[+-]\d+/.exec(assigned?.[1] ?? '')?.[0]
+    expect(literal).toBeDefined()
+
+    const floor = Number(literal)
+    expect(Number.isFinite(floor)).toBe(true)
+    expect(floor).toBeLessThan(BP_REACH)
+    expect(Math.fround(floor)).toBe(floor)
+  })
+})

package/src/shaders/hpmath.js.generated.ts

@@ -26,8 +26,12 @@ export function snapBoxHeightPx(heightPx: number): number {
   return _t1
 }
 
-export function snapBoxCenterYPx(centerY: number, heightPx: number, scrollY: number): number {
-  return ((Math.floor((((centerY - (heightPx * 0.5)) - scrollY) + 0.5)) + Math.floor((snapBoxHeightPx(heightPx) * 0.5))) + 0.5)
+export function snapBoxTopPx(topY: number, heightPx: number, scrollY: number): number {
+  return Math.floor((((((topY + (heightPx * 0.5)) - (snapBoxHeightPx(heightPx) * 0.5)) - scrollY) + 0.5) + 0.015625))
+}
+
+export function snapBoxCenterYPx(centerY: number, scrollY: number): number {
+  return (Math.floor(((centerY - scrollY) + 0.015625)) + 0.5)
 }
 
 export function extendToMinWidthPx(x1: number, x2: number, minWidth: number): number {

package/src/shaders/hpmath.slang

@@ -8,7 +8,14 @@
 // must make identically to the GPU — which pixel row a glyph centers on, how a
 // sub-pixel span is widened. `pnpm gen:shaders` transliterates them into
 // hpmath.js.generated.ts; nothing downstream re-derives them by hand.
-//! js-export: snapBoxHeightPx, snapBoxCenterYPx, extendToMinWidthPx
+//
+// `expandToMinWidthLeftPx`/`RightPx` are exported too, but by `coverageBar.slang`, into
+// @jbrowse/alignments-core — the twin's consumer (`fillSpanRect`) lives in a
+// package that cannot import render-core, and this file's own redirect would
+// move every export above with it. adr-051 §"a shader may also export a
+// function it only imports" is the mechanism; grep the name before assuming it
+// is unlifted.
+//! js-export: snapBoxHeightPx, snapBoxTopPx, snapBoxCenterYPx, extendToMinWidthPx
 //! js-skip: hpSplitUint — the hi/lo float32 precision split exists because a GPU has no float64; the Canvas2D path just uses a number
 //! js-skip: quadLocal — maps a vertex id to a quad corner — Canvas2D has no vertices, it calls fillRect
 //! js-skip: yPxToClipY — clip space is the GPU coordinate system; the px-space decision it wraps is what gets exported (snapBoxCenterYPx and friends)
@@ -17,13 +24,14 @@
 //! js-skip: pxToClipLen — the length half of the same conversion; a px dimension is already in px on the Canvas2D side, so there is nothing to convert
 //! js-skip: clipLenToPx — the inverse of pxToClipLen, same reason
 //! js-skip: extendToMinWidthX — clip-space wrapper over the exported extendToMinWidthPx, which is the decision
-//! js-skip: expandToMinWidthPx — the midpoint rule has no Canvas2D counterpart: the pileup floors a cell width one-sidedly and adds a seam fudge the shader deliberately omits (rendererTypes.ts pileupCellWidth), and the variant matrix floors in physical px against a canvas the Canvas2D twin sizes itself. A different rule, not a twin
 //! js-skip: expandToMinWidthX — clip-space wrapper over expandToMinWidthPx, same reason as extendToMinWidthX
+//! js-skip: expandToMinWidthPx — the float2 over expandToMinWidthLeftPx and RightPx, which coverageBar.slang exports as the twins; a float2 twin is a tuple per call, and the pileup walk allocating one per span measured 0.85x against 0.78x of its hand painter
 //! js-skip: snapToPixelX — clip in, clip out; its px core is `floor(x + 0.5)`, which is Math.round and needs no twin
 //! js-skip: snapBoxCenterY — clip-space wrapper over the exported snapBoxCenterYPx
 module hpmath;
 
 public static const uint HP_LOW_MASK = 0xFFFu;
+public static const float HP_LOW_SPAN = 4096.0;
 
 public float2 hpSplitUint(uint value) {
   uint lo = value & HP_LOW_MASK;
@@ -31,33 +39,52 @@ public float2 hpSplitUint(uint value) {
   return float2(float(hi), float(lo));
 }
 
-// `max(-inf)` and `dot()` exist to thwart the compiler — without them it
-// collapses (hi_a+lo_a)-(hi_b+lo_b) into one large subtraction and the
-// float32 precision the hi/lo split exists to preserve is gone. `hpZero` is
-// a tiny CPU-supplied number; `-1/hpZero` is smaller than any real diff.
+// A floor no bp difference can reach, so clamping to it changes no result.
+// The clamp is there for the compiler: `max()` and `dot()` together stop it
+// collapsing (hi_a+lo_a)-(hi_b+lo_b) into one large subtraction, which loses
+// the float32 precision the hi/lo split exists to preserve. `hpZero` arrives
+// as exactly 0 and carries no magnitude of its own — it makes the floor a
+// runtime value, which is what a backend cannot fold the `max` against. The
+// earlier spelling built the floor as `-1.0 / hpZero`, an infinity WGSL lets
+// an implementation answer with an indeterminate value instead.
+static const float HP_CLAMP_FLOOR = -3.0e38;
+
+// Add a bp offset to an already-split position, keeping the lo lane inside the
+// 0..4095 band the split exists for. Dropping the offset straight into lo makes
+// it carry genomic magnitude, and `hpToClipX` then multiplies two cancelling
+// large terms by `step` — the catastrophic subtraction the split avoids, moved
+// one line later.
+public float2 hpAddBp(float2 splitPos, float offsetBp) {
+  float hi = floor(offsetBp / HP_LOW_SPAN) * HP_LOW_SPAN;
+  return float2(splitPos.x + hi, splitPos.y + (offsetBp - hi));
+}
 public float hpToClipX(float2 splitPos, float3 bpRange, float hpZero) {
-  float inf = 1.0 / hpZero;
+  float floorBp = HP_CLAMP_FLOOR + hpZero;
   float step = 2.0 / bpRange.z;
-  float hi = max(splitPos.x - bpRange.x, -inf);
-  float lo = max(splitPos.y - bpRange.y, -inf);
+  float hi = max(splitPos.x - bpRange.x, floorBp);
+  float lo = max(splitPos.y - bpRange.y, floorBp);
   return dot(float3(-1.0, hi, lo), float3(1.0, step, step));
 }
 
 public float hpScaleLinear(float2 splitPos, float3 bpRange, float hpZero) {
-  float inf = 1.0 / hpZero;
+  float floorBp = HP_CLAMP_FLOOR + hpZero;
   float step = 1.0 / bpRange.z;
-  float hi = max(splitPos.x - bpRange.x, -inf);
-  float lo = max(splitPos.y - bpRange.y, -inf);
+  float hi = max(splitPos.x - bpRange.x, floorBp);
+  float lo = max(splitPos.y - bpRange.y, floorBp);
   return dot(float2(hi, lo), float2(step, step));
 }
 
 // Exact-as-possible bp offset from a split position to the viewport start
-// stored in bpRange.xy. Subtracts the hi/lo components separately (same
-// ordering as hpToClipX) so the result stays precise at high genomic
-// coordinates — recombining bpStartHi+bpStartLo first would lose ~256bp near
-// 3e9. Unlike hpToClipX this returns bp, not clip space.
-public float hpViewportOffsetBp(float2 splitPos, float3 bpRange) {
-  return (bpRange.x - splitPos.x) + (bpRange.y - splitPos.y);
+// stored in bpRange.xy. Subtracts the hi/lo components separately so the result
+// stays precise at high genomic coordinates — recombining bpStartHi+bpStartLo
+// first would lose ~256bp near 3e9 — and takes `hpZero` for the same clamp
+// hpToClipX does, which is what stops the compiler recombining them. Unlike
+// hpToClipX this returns bp, not clip space.
+public float hpViewportOffsetBp(float2 splitPos, float3 bpRange, float hpZero) {
+  float floorBp = HP_CLAMP_FLOOR + hpZero;
+  float hi = max(bpRange.x - splitPos.x, floorBp);
+  float lo = max(bpRange.y - splitPos.y, floorBp);
+  return hi + lo;
 }
 
 public float snapToPixelX(float clipX, float canvasWidth) {
@@ -91,30 +118,44 @@ public float snapBoxHeightPx(float heightPx) {
   return even && hPx >= 2.0 && hPx <= THIN_BOX_PX ? hPx + 1.0 : hPx;
 }
 
-// Center a thin glyph on the *drawn* middle row of the box it annotates, given
-// the box's real center `centerY` and height `heightPx`. The box is rasterized
-// with the rect shader's edge snapping (top = floor(top+0.5), height =
-// snapBoxHeightPx(h)); reproducing that here lands the line/chevron exactly on
-// the box's center row instead of the ~1px bias a plain pixel-center snap
-// (`floor(centerY - scrollY + 0.5) + 0.5`) gives. Thin boxes are drawn at an odd
-// height precisely so that center row exists; a taller even box still has none,
-// and stays consistent (just below the seam).
+// A whole-pixel box centered in a whole-pixel row puts the center of an
+// odd-height box exactly on a row boundary, where float error in how each
+// caller sums its center would otherwise pick the row above or below.
+static const float SNAP_TIE_BIAS_PX = 1.0 / 64.0;
+
+// The pixel row a box's top edge lands on. Snapped about the box's CENTER, not
+// its top: `snapBoxHeightPx` rounds the height and sometimes nudges it a whole
+// pixel, and anchoring the top spends all of that off the BOTTOM edge. A box the
+// layout deliberately centered inside its row then isn't — a UTR is
+// center-shrunk to 0.65 of the transcript body, so at superCompact's 3px row its
+// 1.95px box rounded up to 3px and drew a full pixel below the CDS beside it,
+// while the intron line and strand arrow (which snap to the row's center row)
+// sat on its top edge. Top-anchored and center-anchored agree wherever the
+// height survives the snap unchanged, which is every full-height feature box.
+public float snapBoxTopPx(float topY, float heightPx, float scrollY) {
+  float centerY = topY + heightPx * 0.5;
+  return floor(
+    centerY - snapBoxHeightPx(heightPx) * 0.5 - scrollY + 0.5 + SNAP_TIE_BIAS_PX
+  );
+}
+
+// The pixel row holding the box's center, which a thin glyph (intron line,
+// chevron, strand arrow) draws on. It is the middle row of every odd-height box
+// with that center, so a center-shrunk UTR and its transcript's arrow agree
+// whatever their parities; an even-height box's center row is whichever of its
+// two middle rows the center falls in. Taking the lower middle row of an even
+// box instead put the arrow a pixel under the UTR on an isoform stack, whose
+// rows sit at fractional tops.
 //
-// Split in two on purpose. The decision — which pixel row is the center — is
-// resolution math the Canvas2D and SVG paths need in *screen px*; only the
-// clip-space conversion is GPU-specific. `//! js-export` lifts the px half into
-// TypeScript, so the two backends share the rule instead of the Canvas2D twin
-// re-deriving it (see adr-051). Keep new shared decisions in this shape: pure
-// px-in/px-out below, the `yPxToClipY` wrapper above it.
-public float snapBoxCenterYPx(float centerY, float heightPx, float scrollY) {
-  float topPx = floor(centerY - heightPx * 0.5 - scrollY + 0.5);
-  return topPx + floor(snapBoxHeightPx(heightPx) * 0.5) + 0.5;
-}
-
-public float snapBoxCenterY(
-  float centerY, float heightPx, float scrollY, float canvasHeight
-) {
-  return yPxToClipY(snapBoxCenterYPx(centerY, heightPx, scrollY), canvasHeight);
+// Split from `snapBoxCenterY` because the Canvas2D and SVG paths need this
+// decision in screen px; only the clip-space conversion is GPU-specific
+// (adr-051).
+public float snapBoxCenterYPx(float centerY, float scrollY) {
+  return floor(centerY - scrollY + SNAP_TIE_BIAS_PX) + 0.5;
+}
+
+public float snapBoxCenterY(float centerY, float scrollY, float canvasHeight) {
+  return yPxToClipY(snapBoxCenterYPx(centerY, scrollY), canvasHeight);
 }
 
 // Extend the free edge `x2` away from the anchor `x1` so the span is at least
@@ -138,7 +179,7 @@ public float extendToMinWidthPx(float x1, float x2, float minWidth) {
 public float extendToMinWidthX(
   float x1, float x2, float minWidthPx, float canvasWidth
 ) {
-  return extendToMinWidthPx(x1, x2, minWidthPx * 2.0 / canvasWidth);
+  return extendToMinWidthPx(x1, x2, pxToClipLen(minWidthPx, canvasWidth));
 }
 
 // The other min-width rule: widen a [x1, x2] span about its MIDPOINT, so both
@@ -154,18 +195,29 @@ public float extendToMinWidthX(
 // what lets the alignments passes (clip space, a 1 CSS px floor) and the variant
 // matrix (physical px, its own MIN_COL_PX) run one rule instead of two spellings
 // of it.
+// The two edges as scalars, which is what the Canvas2D twins export: a
+// `float2` twin comes back as a tuple, and the pileup walk allocating one per
+// span measured 0.85x against 0.78x of its hand painter
+// (plugins/alignments/benches/rectWalker.bench.ts).
+public float expandToMinWidthLeftPx(float x1, float x2, float minWidth) {
+  return x2 - x1 < minWidth ? (x1 + x2) * 0.5 - minWidth * 0.5 : x1;
+}
+
+public float expandToMinWidthRightPx(float x1, float x2, float minWidth) {
+  return x2 - x1 < minWidth ? (x1 + x2) * 0.5 + minWidth * 0.5 : x2;
+}
+
 public float2 expandToMinWidthPx(float x1, float x2, float minWidth) {
-  if (x2 - x1 < minWidth) {
-    float mid = (x1 + x2) * 0.5;
-    return float2(mid - minWidth * 0.5, mid + minWidth * 0.5);
-  }
-  return float2(x1, x2);
+  return float2(
+    expandToMinWidthLeftPx(x1, x2, minWidth),
+    expandToMinWidthRightPx(x1, x2, minWidth)
+  );
 }
 
 public float2 expandToMinWidthX(
   float x1, float x2, float minWidthPx, float canvasWidth
 ) {
-  return expandToMinWidthPx(x1, x2, minWidthPx * 2.0 / canvasWidth);
+  return expandToMinWidthPx(x1, x2, pxToClipLen(minWidthPx, canvasWidth));
 }
 
 // vid%6: 0→(0,0)  1→(1,0)  2→(0,1)  3→(0,1)  4→(1,0)  5→(1,1)

package/src/shaders/insetValueScale.test.ts

@@ -0,0 +1,67 @@
+import * as linkGlsl from './linkMark.glsl.generated.ts'
+import { linkValuePx } from './linkMark.js.generated.ts'
+import * as linkWgsl from './linkMark.wgsl.generated.ts'
+import * as pointGlsl from './pointMark.glsl.generated.ts'
+import { pointYPx } from './pointMark.js.generated.ts'
+import * as pointWgsl from './pointMark.wgsl.generated.ts'
+import { SCALE_TYPE_LOG, SCALE_TYPE_SYMLOG } from './scoreScale.generated.ts'
+
+// `valueScale.slang`'s `insetValueYPx` — the value scale over a range inset at
+// both ends — with the two anchors its consumers add. A point measures down
+// from the top of its row band, a link measures up from the band's baseline,
+// so the two are reflections of one number and were two open-coded copies of
+// it until they shared one.
+
+const HEIGHTS = [8, 12, 20, 40, 100]
+const INSETS = [0, 1, 2.5, 5, 9]
+const DOMAINS: [number, number][] = [
+  [0, 1],
+  [-1, 1],
+  [0, 100],
+  [1, 1024],
+  [0.01, 0.5],
+  [5, 5],
+]
+const SCALES = [0, SCALE_TYPE_LOG, SCALE_TYPE_SYMLOG]
+
+test('a link measures the same value up that a point measures down', () => {
+  for (const h of HEIGHTS) {
+    for (const insetPx of INSETS) {
+      for (const [min, max] of DOMAINS) {
+        for (const scale of SCALES) {
+          for (const v of [min, max, (min + max) / 2, min - 1, max + 1, 0.02]) {
+            expect(linkValuePx(v, min, max, h, scale, insetPx, 1)).toBeCloseTo(
+              h - pointYPx(v, min, max, h, scale, insetPx, 1),
+              9,
+            )
+          }
+        }
+      }
+    }
+  }
+})
+
+// The half-height clamp, which is the part of this that is not obvious. A band
+// shorter than its two insets has no range left, and without the clamp the
+// range goes negative and the scale runs backwards — an edge value drawn on
+// the wrong side of the plot rather than merely squeezed.
+test('a band shorter than two insets collapses to its midline, never inverts', () => {
+  for (const scale of SCALES) {
+    expect(pointYPx(0, 0, 100, 8, scale, 5, 1)).toBe(4)
+    expect(pointYPx(100, 0, 100, 8, scale, 5, 1)).toBe(4)
+    expect(linkValuePx(0, 0, 100, 8, scale, 5, 1)).toBe(4)
+    expect(linkValuePx(100, 0, 100, 8, scale, 5, 1)).toBe(4)
+  }
+})
+
+// The numbers above pin what the inset scale is. This pins that both shapes
+// reach it on both backends: a numeric test of a function a shader has quietly
+// stopped calling passes whatever that shader draws.
+test.each([
+  ['pointMark', pointWgsl.WGSL_SOURCE, pointGlsl.GLSL_VERTEX],
+  ['linkMark', linkWgsl.WGSL_SOURCE, linkGlsl.GLSL_VERTEX],
+])('%s reads the shared inset scale on every backend', (_name, wgsl, glsl) => {
+  for (const src of [wgsl, glsl]) {
+    expect(src).toContain('insetValueYPx_0(')
+  }
+})