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

package/esm/useRenderingBackend.js

@@ -1,5 +1,6 @@
 import { useCallback, useEffect, useRef, useState } from 'react';
 import { isAlive, isStateTreeNode } from '@jbrowse/mobx-state-tree';
+import { createGpuContextLostError, createGpuDeviceLostError, } from './gpuContextLostError.js';
 import { onDeviceLost } from './gpuDevice.js';
 import { RecoveryBudget } from './recoveryBudget.js';
 import { useTabVisibilityRerender } from './useTabVisibilityRerender.js';
@@ -23,30 +24,41 @@ const CONTEXT_RECOVER_BASE_MS = 1000;
 // causes (GPU crash, driver reset) and needs no banner at all. Nothing is
 // aborted when the window expires, so this is not a readiness cap.
 export const CONTEXT_LOST_REPORT_GRACE_MS = 400;
-const CONTEXT_LOST_MESSAGE = 'WebGL context lost. The browser reclaimed the GPU context for this display, ' +
-    'usually because too many GPU-rendered views are open at once.';
-const DEVICE_LOST_MESSAGE = 'WebGPU device lost. The GPU device backing this display went away and kept ' +
-    'going away after several attempts to rebuild on a fresh one.';
 /**
- * Flagged rather than matched by message or `instanceof`, so the error UI can
- * offer the remedy specific to a loss (switch the page to Canvas2D) without
- * offering it for render errors whose remedy differs (an over-allocation says to
- * zoom in).
+ * How far past its scroll port a canvas keeps its GPU targets, as a fraction of
+ * the port on each edge.
  *
- * A lost WebGPU device carries the same flag deliberately: the two causes
- * differ, but the remedy on offer — take the page off the GPU — is the same one.
+ * A band, where `useViewVisibility`'s hard window deliberately has none, and the
+ * reason that file gives does not reach here. There the band roughly doubles
+ * live WebGL2 contexts against a hard ceiling of 16, so it costs a resource the
+ * page runs out of; here it costs bytes, and bytes have no cliff. What the band
+ * buys is the frame: intersection callbacks are delivered after the frame that
+ * moved the canvas has painted, so a hard edge shows one blank frame on the way
+ * back in. Repainting a quarter of a port early puts the redraw several frames
+ * ahead of the pixels at any ordinary scroll speed.
  */
-export function createGpuContextLostError(message = CONTEXT_LOST_MESSAGE) {
-    return Object.assign(new Error(message), {
-        gpuContextLost: true,
-    });
-}
-export function createGpuDeviceLostError() {
-    return createGpuContextLostError(DEVICE_LOST_MESSAGE);
-}
-export function isGpuContextLostError(error) {
-    return (typeof error === 'object' && error !== null && 'gpuContextLost' in error);
+export const OFFSCREEN_RELEASE_BAND = '25%';
+/**
+ * The nearest ancestor that scrolls `el`, which is what the observer has to be
+ * rooted at. Rooting at the viewport would make {@link OFFSCREEN_RELEASE_BAND}
+ * inert: an observer clips the target against every scrolling ancestor before
+ * it intersects the root box the margin expands, and JBrowse's views scroll
+ * inside a container in all three hosts (the classic stack, a workspace panel,
+ * a bounded embed). Null where nothing above it scrolls, which is the page-
+ * scrolling embed, and there the viewport root takes the margin directly.
+ */
+function scrollPortOf(el) {
+    let node = el.parentElement;
+    while (node) {
+        const { overflowY } = getComputedStyle(node);
+        if (overflowY === 'auto' || overflowY === 'scroll') {
+            return node;
+        }
+        node = node.parentElement;
+    }
+    return null;
 }
+export { createGpuContextLostError, createGpuDeviceLostError, createGpuSurfaceLostError, isGpuContextLostError, } from './gpuContextLostError.js';
 /**
  * The display's recovery budget, created on first read. Reached through the ref
  * at every use site rather than unwrapped once in the hook body: the unwrapped
@@ -375,6 +387,32 @@ export function useRenderingBackend(factory, model) {
         }
         return undefined;
     }, [canvas, contextVersion, factory, model]);
+    // Watch the canvas rather than the track container: the canvas is the element
+    // whose size the released targets were allocated for, so this is the one
+    // signal for every display in every view, with no view-level plumbing. Where
+    // `IntersectionObserver` is missing (jsdom, SSR) nothing ever sets the flag
+    // and the display draws exactly as it did before.
+    useEffect(() => {
+        if (canvas && typeof IntersectionObserver !== 'undefined') {
+            const observer = new IntersectionObserver(entries => {
+                const entry = entries.at(-1);
+                if (entry && nodeAlive(model)) {
+                    model.setOffScreen(!entry.isIntersecting);
+                }
+            }, {
+                root: scrollPortOf(canvas),
+                rootMargin: `${OFFSCREEN_RELEASE_BAND} 0px`,
+            });
+            observer.observe(canvas);
+            return () => {
+                observer.disconnect();
+                if (nodeAlive(model)) {
+                    model.setOffScreen(false);
+                }
+            };
+        }
+        return undefined;
+    }, [canvas, model]);
     useTabVisibilityRerender(() => {
         if (nodeAlive(model)) {
             model.renderNow();

package/esm/webgpuUtils.d.ts

@@ -1,15 +1,7 @@
+import type { ShaderStage } from './hal/types.ts';
 export declare const STANDARD_BLEND_STATE: GPUBlendState;
-/**
- * Creates a bind group for uniforms at binding 1.
- * This bind group is intended for use with shaders generated by Slang,
- * which typically place uniforms at binding index 1.
- * @param device - The GPUDevice.
- * @param layout - `DeviceLayouts.uniformOnlyBindGroupLayout`.
- * @param uniformBuffer - The GPUBuffer containing the uniform data.
- * @param uniformVisibleSize - The visible size of the uniform buffer.
- * @returns The GPUBindGroup.
- */
-export declare function createUniformOnlyBindGroup(device: GPUDevice, layout: GPUBindGroupLayout, uniformBuffer: GPUBuffer, uniformVisibleSize: number): GPUBindGroup;
+/** A layout entry's `visibility`: the stages its shader reads the binding in. */
+export declare function stageVisibility(stages: readonly ShaderStage[]): number;
 export declare function createVertexBuffer(device: GPUDevice, data: ArrayBuffer | ArrayBufferView): GPUBuffer;
 /**
  * Converts one entry of a pass's vertex input layout to a WebGPU vertex format

package/esm/webgpuUtils.js

@@ -19,39 +19,18 @@ export const STANDARD_BLEND_STATE = {
         operation: 'add',
     },
 };
-// Per-instance data is always fed through a vertex buffer (matching Slang's
-// vertex-attribute input semantics). The bind group carries only the uniform
-// at binding 1 (and, optionally, a texture + sampler at 2/3). Binding index 1
-// matches what the codegen emits so shaders share the same @binding(1)
-// annotation regardless of whether they sample textures, and
-// `assertRenderBindingShape` is what checks that rather than promising it.
-//
-// The layouts themselves are built once per device in `hal/deviceGpuCache.ts`;
-// a bind GROUP is per-HAL, because it names that HAL's uniform ring buffer.
-/**
- * Creates a bind group for uniforms at binding 1.
- * This bind group is intended for use with shaders generated by Slang,
- * which typically place uniforms at binding index 1.
- * @param device - The GPUDevice.
- * @param layout - `DeviceLayouts.uniformOnlyBindGroupLayout`.
- * @param uniformBuffer - The GPUBuffer containing the uniform data.
- * @param uniformVisibleSize - The visible size of the uniform buffer.
- * @returns The GPUBindGroup.
- */
-export function createUniformOnlyBindGroup(device, layout, uniformBuffer, uniformVisibleSize) {
-    return device.createBindGroup({
-        layout,
-        entries: [
-            {
-                binding: 1, // Standard binding for uniforms generated by Slang codegen.
-                resource: {
-                    buffer: uniformBuffer,
-                    offset: 0,
-                    size: uniformVisibleSize,
-                },
-            },
-        ],
-    });
+const STAGE_FLAG = {
+    vertex: 'VERTEX',
+    fragment: 'FRAGMENT',
+    compute: 'COMPUTE',
+};
+/** A layout entry's `visibility`: the stages its shader reads the binding in. */
+export function stageVisibility(stages) {
+    let mask = 0;
+    for (const stage of stages) {
+        mask |= GPUShaderStage[STAGE_FLAG[stage]];
+    }
+    return mask;
 }
 export function createVertexBuffer(device, data) {
     const buf = device.createBuffer({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/render-core",
-  "version": "4.3.0",
+  "version": "5.0.0-beta.10",
   "type": "module",
   "description": "GPU/Canvas2D rendering primitives for JBrowse displays: the HAL, the draw-lifecycle mixin, per-region/global backend bases, and the React backend hooks",
   "keywords": [
@@ -19,7 +19,7 @@
     "directory": "packages/render-core"
   },
   "author": "JBrowse Team",
-  "//files": "src/shaders ships the shared .slang modules (hpmath, antialias, capsule, colorPack, coverageBand, diagonalGrid, pointGlyph, rowRect, scoreScale) that any shader imports, plus the coverage-band entry-point passes drawn by two plugins. @jbrowse/shader-tools resolves its include path here, so an out-of-tree plugin can compile its own .slang against them.",
+  "//files": "src/shaders ships the shared .slang modules (hpmath, antialias, capsule, colorPack, coverageBand, diagonalGrid, markColor, pointGlyph, rowRect, scoreScale, valueScale) that any shader imports, plus the coverage-band entry-point passes drawn by two plugins. @jbrowse/shader-tools resolves its include path here, so an out-of-tree plugin can compile its own .slang against them.",
   "files": [
     "esm",
     "src/shaders"
@@ -31,47 +31,72 @@
     "./canvas2dUtils": "./esm/canvas2dUtils.js",
     "./canvasContext": "./esm/canvasContext.js",
     "./colorRampLut": "./esm/colorRampLut.js",
+    "./contractReports": "./esm/contractReports.js",
     "./coverageBand": "./esm/coverageBand.js",
+    "./computePipeline": "./esm/computePipeline.js",
     "./coverageBandBuffers": "./esm/coverageBandBuffers.js",
     "./createRenderingBackend": "./esm/createRenderingBackend.js",
     "./displayPhase": "./esm/displayPhase.js",
-    "./globalRenderingBackend": "./esm/globalRenderingBackend.js",
+    "./encodeMemo": "./esm/encodeMemo.js",
     "./gpuDevice": "./esm/gpuDevice.js",
     "./graphicsCapabilities": "./esm/graphicsCapabilities.js",
     "./hal": "./esm/hal/index.js",
     "./installUpload": "./esm/installUpload.js",
     "./instanceCache": "./esm/instanceCache.js",
     "./instancePass": "./esm/instancePass.js",
-    "./keyedRenderingBackend": "./esm/keyedRenderingBackend.js",
+    "./marks": "./esm/marks/index.js",
+    "./marks/ellipseDistance": "./esm/marks/ellipseDistance.js",
+    "./marks/backend": "./esm/marks/markBackend.js",
+    "./marks/colorFill": "./esm/marks/colorFill.js",
+    "./marks/drawAgainstHit": "./esm/marks/drawAgainstHit.js",
+    "./marks/glyphPaint": "./esm/marks/glyphPaint.js",
+    "./marks/hit": "./esm/marks/markHit.js",
     "./namedReactions": "./esm/namedReactions.js",
     "./OverlayCanvas": "./esm/OverlayCanvas.js",
     "./perRegionRenderingBackend": "./esm/perRegionRenderingBackend.js",
     "./regionDataMap": "./esm/regionDataMap.js",
     "./renderBlock": "./esm/renderBlock.js",
     "./renderingBackendBase": "./esm/renderingBackendBase.js",
+    "./scoreScale": "./esm/scoreScale.js",
     "./ScrollLockedOverlay": "./esm/ScrollLockedOverlay.js",
+    "./sharedBackendKey": "./esm/sharedBackendKey.js",
     "./shaders/antialias": "./esm/shaders/antialias.js.generated.js",
+    "./shaders/barMarkIface": "./esm/shaders/barMark.iface.generated.js",
+    "./shaders/capsule": "./esm/shaders/capsule.js.generated.js",
     "./shaders/capsuleConsts": "./esm/shaders/capsule.generated.js",
-    "./shaders/colorRampLutConsts": "./esm/shaders/colorRampLut.generated.js",
+    "./shaders/clipStrip": "./esm/shaders/clipStrip.js.generated.js",
+    "./shaders/clipStripConsts": "./esm/shaders/clipStrip.generated.js",
+    "./shaders/colorRampLut": "./esm/shaders/colorRampLut.js.generated.js",
     "./shaders/coverageBar": "./esm/shaders/coverageBar.generated.js",
     "./shaders/coverageIndicator": "./esm/shaders/coverageIndicator.generated.js",
     "./shaders/coverageInterbase": "./esm/shaders/coverageInterbase.generated.js",
     "./shaders/coverageMod": "./esm/shaders/coverageMod.generated.js",
     "./shaders/coverageSnp": "./esm/shaders/coverageSnp.generated.js",
+    "./shaders/curveDistance": "./esm/shaders/curveDistance.js.generated.js",
     "./shaders/hpmath": "./esm/shaders/hpmath.js.generated.js",
+    "./shaders/linkMark": "./esm/shaders/linkMark.js.generated.js",
+    "./shaders/lineCenterMarkIface": "./esm/shaders/lineCenterMark.iface.generated.js",
+    "./shaders/lineCommonConsts": "./esm/shaders/lineCommon.generated.js",
+    "./shaders/lineStepMarkIface": "./esm/shaders/lineStepMark.iface.generated.js",
+    "./shaders/linkMarkConsts": "./esm/shaders/linkMark.consts.generated.js",
     "./shaders/pointGlyph": "./esm/shaders/pointGlyph.js.generated.js",
     "./shaders/pointGlyphConsts": "./esm/shaders/pointGlyph.generated.js",
+    "./shaders/pointMark": "./esm/shaders/pointMark.js.generated.js",
+    "./shaders/pointMarkIface": "./esm/shaders/pointMark.iface.generated.js",
+    "./shaders/markColorConsts": "./esm/shaders/markColor.generated.js",
+    "./shaders/pointMarkConsts": "./esm/shaders/pointMark.consts.generated.js",
     "./shaders/rowRect": "./esm/shaders/rowRect.js.generated.js",
     "./shaders/rowRectConsts": "./esm/shaders/rowRect.generated.js",
     "./shaders/scoreScale": "./esm/shaders/scoreScale.js.generated.js",
+    "./shaders/spanMarkIface": "./esm/shaders/spanMark.iface.generated.js",
     "./slangPass": "./esm/slangPass.js",
     "./useGraphicsCapabilities": "./esm/useGraphicsCapabilities.js",
     "./useRenderingBackend": "./esm/useRenderingBackend.js",
     "./useTabVisibilityRerender": "./esm/useTabVisibilityRerender.js"
   },
   "dependencies": {
-    "@jbrowse/mobx-state-tree": "^6.5.1",
-    "mobx": "^7.0.3"
+    "@jbrowse/mobx-state-tree": "^6.6.1",
+    "mobx": "^7.0.5"
   },
   "peerDependencies": {
     "react": ">=19.0.0"

package/src/shaders/antialias.slang

@@ -52,6 +52,8 @@
 // and then agreeing with its own copy, which is what dotplotCapsulePad.test.ts
 // and syntenyFillPad.test.ts each did.
 //! js-export: aaPx, aaHalfPx, aaRamp, edgeCoverage
+//! js-skip: dashCoverageAt — one axis along: the other two backends dash through setLineDash and stroke-dasharray, which take the period rather than a coverage, so what they must agree on is each mark's dash and gap lengths
+//! js-skip: dashCoverage — the dpr wrapper over dashCoverageAt, so it inherits that entry's reason exactly
 module antialias;
 
 // Width of a ramp covering exactly one output pixel, in CSS px. THE conversion
@@ -110,3 +112,47 @@ public float edgeCoverage(float signedInkCssPx, float dpr) {
 public float glyphEdgeAlpha(float coverage) {
   return aaRamp(coverage, aaGradient(coverage));
 }
+
+// Coverage of a `dashPx` on / `gapPx` off pattern at `coord` CSS px along the
+// mark, with the ON run starting at coord 0 — the phase `ctx.setLineDash` and
+// `stroke-dasharray` give, so the three backends dash alike.
+//
+// The rotation is what makes both ends soft, and both halves of it were got
+// wrong here before. Measuring `min(phase, dashPx - phase)` straight off the
+// wrap ramps a dash's TRAILING edge and steps its LEADING edge 0 -> 0.5 in no
+// distance at all; rotating the run to the middle of the period fixes that but
+// then ramping over a constant 1 CSS px is two device px on a dpr=2 display —
+// twice the softness of the sides of the very same line. Centring the run at
+// half a period puts the wrap deep in the gap where nothing is drawn, and
+// `aaPx(dpr)` is the sides' own ramp.
+//
+// The reduction is `t - period * floor(t / period)` rather than the obvious
+// `frac(t / period) * period`, which are the same number only in exact
+// arithmetic. `frac` drops the integer part BEFORE multiplying back, so what
+// the quotient lost to rounding survives and gets scaled by the period;
+// subtracting the floored multiple keeps it, because THAT subtraction is exact
+// — its operands are within a period of each other, so nothing falls off the
+// end. Same op count, once `frac`'s own `floor` is counted.
+//
+// This is not a visible fix and don't sell it as one: swept against the old
+// spelling in float32 over both passes' whole coordinate range at dpr 1-4, the
+// two differ by at most 9.8e-4 of alpha and not one 8-bit pixel changes.
+//
+// It is a refereeable one, which the old spelling was not. check-oracle takes
+// every emittable scalar signature, not only the `//! js-export`ed ones, so a
+// scalar core here is swept whether or not anything imports it — and the `frac`
+// spelling missed the 1e-5 relative on 18 of its 2400 tuples, including
+// in-domain ones like `(255, 2.5, 0.5, 0.25)`, a real screen px at dpr=4. The
+// choice was a function nobody can check or a one-line change that costs
+// nothing, so: the dash geometry is now under the CI gate.
+public float dashCoverageAt(
+    float coord, float dashPx, float gapPx, float aaPx) {
+  float period = dashPx + gapPx;
+  float shifted = coord + gapPx * 0.5;
+  float phase = shifted - period * floor(shifted / period);
+  return aaRamp(dashPx * 0.5 - abs(phase - period * 0.5), aaPx);
+}
+
+public float dashCoverage(float coord, float dashPx, float gapPx, float dpr) {
+  return dashCoverageAt(coord, dashPx, gapPx, aaPx(dpr));
+}

package/src/shaders/arcHull.test.ts

@@ -0,0 +1,267 @@
+// The arc hull has to cover every point the fragment paints above the band's
+// anchor, or the rasterizer hard-cuts ink that no sample count is left to
+// smooth — `linkMark.slang` declares `//! coverage: analytic`. Ink is sampled
+// along the curve's normals, which reach every point within the pad, and each
+// sample is tested against the strip's triangles as `linkMark.slang` emits
+// them. The vertices come from `curveDistance.slang`'s
+// own emitted twins.
+import { ellipseDistance } from '../marks/ellipseDistance.ts'
+import { aaHalfPx, edgeCoverage } from './antialias.js.generated.ts'
+import {
+  distToWideCirclePx,
+  ellipseHullPoint,
+  wideCircleHullPoint,
+  wideCircleLeg,
+  wideCircleLegStep,
+} from './curveDistance.js.generated.ts'
+import { LINK_CURVE_SEGMENTS } from './linkMark.consts.generated.ts'
+
+type Pt = readonly [number, number]
+type Tri = readonly [Pt, Pt, Pt]
+
+// Float64 rounding, and the band's anchor row: `sin(PI)` leaves the far foot's
+// vertices 1e-15 px off the baseline, and no pixel centre sits that low.
+const EXACT = 1e-9
+
+// `arcStrokeHalfPx` / `linkStrokeWidthPx`: no arc is thinner than 1.5 device px.
+const strokeHalfPx = (dpr: number, lineWidthPx: number) =>
+  Math.max(lineWidthPx, 1.5 / dpr) / 2
+
+function inTri(p: Pt, [a, b, c]: Tri) {
+  const d1 = (p[0] - b[0]) * (a[1] - b[1]) - (a[0] - b[0]) * (p[1] - b[1])
+  const d2 = (p[0] - c[0]) * (b[1] - c[1]) - (b[0] - c[0]) * (p[1] - c[1])
+  const d3 = (p[0] - a[0]) * (c[1] - a[1]) - (c[0] - a[0]) * (p[1] - a[1])
+  return !((d1 < 0 || d2 < 0 || d3 < 0) && (d1 > 0 || d2 > 0 || d3 > 0))
+}
+
+// Vertex pairs in the order `vs_main` emits them, inner flank first.
+function stripTriangles(pairs: (readonly [Pt, Pt])[]) {
+  const verts = pairs.flat()
+  const tris: Tri[] = []
+  for (let i = 0; i + 2 < verts.length; i++) {
+    tris.push([verts[i]!, verts[i + 1]!, verts[i + 2]!])
+  }
+  return tris
+}
+
+// Buckets the triangles by x so a sample tests only its neighbours.
+function coverIndex(tris: Tri[]) {
+  const xs = tris.flatMap(t => t.map(p => p[0]))
+  const lo = Math.min(...xs)
+  const width = Math.max((Math.max(...xs) - lo) / 4096, 1e-9)
+  const buckets = new Map<number, Tri[]>()
+  for (const t of tris) {
+    const tx = t.map(p => p[0])
+    const b0 = Math.floor((Math.min(...tx) - lo) / width)
+    const b1 = Math.floor((Math.max(...tx) - lo) / width)
+    for (let b = b0; b <= b1; b++) {
+      const list = buckets.get(b) ?? []
+      list.push(t)
+      buckets.set(b, list)
+    }
+  }
+  return (p: Pt) =>
+    (buckets.get(Math.floor((p[0] - lo) / width)) ?? []).some(t => inTri(p, t))
+}
+
+function worstUncovered(
+  covered: (p: Pt) => boolean,
+  samples: Iterable<Pt>,
+  alpha: (p: Pt) => number,
+) {
+  let worst = 0
+  for (const p of samples) {
+    if (!covered(p)) {
+      worst = Math.max(worst, alpha(p))
+    }
+  }
+  return worst
+}
+
+// A far leg's chords sag by thousandths of a px, so the offsets close in on
+// both edges of the ink as well as crossing it.
+const OFFSETS = [
+  ...Array.from({ length: 21 }, (_, j) => j / 10 - 1),
+  ...Array.from({ length: 24 }, (_, k) => 1 - 2 ** -(k + 1)).flatMap(t => [
+    t,
+    -t,
+  ]),
+]
+
+function* alongNormals(
+  count: number,
+  pad: number,
+  at: (u: number) => readonly [Pt, Pt],
+  keep: (p: Pt) => boolean,
+) {
+  for (let i = 0; i <= count; i++) {
+    const [p, n] = at(i / count)
+    for (const offset of OFFSETS) {
+      const t = pad * offset
+      const q = [p[0] + n[0] * t, p[1] + n[1] * t] as const
+      if (keep(q)) {
+        yield q
+      }
+    }
+  }
+}
+
+function worstOnDome(
+  rx: number,
+  ry: number,
+  dpr: number,
+  lineWidthPx: number,
+  segs: number,
+) {
+  const half = strokeHalfPx(dpr, lineWidthPx)
+  const pad = half + aaHalfPx(dpr)
+  const h = Math.PI / (2 * segs)
+  const vertex = (seg: number, flankPad: number) => {
+    const a = (seg / segs) * Math.PI
+    return ellipseHullPoint(
+      Math.cos(a),
+      Math.sin(a),
+      Math.cos(h),
+      Math.sin(h),
+      rx,
+      ry,
+      flankPad,
+    )
+  }
+  const pairs: (readonly [Pt, Pt])[] = []
+  for (let seg = 0; seg <= segs; seg++) {
+    pairs.push([vertex(seg, -pad), vertex(seg, pad)])
+  }
+  const samples = alongNormals(
+    2000,
+    pad,
+    u => {
+      const a = u * Math.PI
+      const g = Math.hypot(ry * Math.cos(a), rx * Math.sin(a)) || 1
+      return [
+        [rx * Math.cos(a), ry * Math.sin(a)],
+        [(ry * Math.cos(a)) / g, (rx * Math.sin(a)) / g],
+      ]
+    },
+    p => p[1] > EXACT,
+  )
+  return worstUncovered(coverIndex(stripTriangles(pairs)), samples, p =>
+    edgeCoverage(half - ellipseDistance(p[0], p[1], rx, ry), dpr),
+  )
+}
+
+// Each leg in its own foot frame, which is how `vs_main` mirrors them.
+function worstOnLegs(
+  r: number,
+  reachPx: number,
+  dpr: number,
+  lineWidthPx: number,
+  segs: number,
+) {
+  const half = strokeHalfPx(dpr, lineWidthPx)
+  const pad = half + aaHalfPx(dpr)
+  const sweep = Math.asin(Math.min(1, (reachPx + pad) / r))
+  const legs = new Map<number, (readonly [Pt, Pt])[]>()
+  for (let seg = 0; seg <= segs; seg++) {
+    const [side, b] = wideCircleLeg(seg, segs, sweep)
+    const cosHalf = Math.cos(0.5 * wideCircleLegStep(seg, segs, sweep))
+    const at = (flankPad: number) =>
+      wideCircleHullPoint(Math.sin(b), Math.sin(b / 2), cosHalf, r, flankPad)
+    legs.set(side, [...(legs.get(side) ?? []), [at(-pad), at(pad)]])
+  }
+  let worst = 0
+  for (const pairs of legs.values()) {
+    const samples = alongNormals(
+      2000,
+      pad,
+      u => {
+        const b = u * sweep
+        return [
+          [-2 * r * Math.sin(b / 2) ** 2, r * Math.sin(b)],
+          [Math.cos(b), Math.sin(b)],
+        ]
+      },
+      p => p[1] > EXACT && p[1] <= reachPx,
+    )
+    worst = Math.max(
+      worst,
+      worstUncovered(coverIndex(stripTriangles(pairs)), samples, p =>
+        edgeCoverage(half - distToWideCirclePx(p[0], p[1], r), dpr),
+      ),
+    )
+  }
+  return worst
+}
+
+// Flat domes fold the inner offset at their feet, tall ones at their apex:
+// `linkRadiiPx` ties ry to the band and rx to the pair, so either can win.
+const DOMES = [
+  [1266, 25],
+  [1900, 12],
+  [633, 25],
+  [200, 25],
+  [1266, 114],
+  [3000, 8],
+  [1266, 0.5],
+  [40, 25],
+  [10, 10],
+  [10, 75],
+  [1, 100],
+] as const
+
+test.each(DOMES)('a %sx%s dome covers all of its ink', (rx, ry) => {
+  for (const dpr of [1, 1.5, 2]) {
+    for (const lineWidthPx of [0.5, 2, 6]) {
+      expect(
+        worstOnDome(rx, ry, dpr, lineWidthPx, LINK_CURVE_SEGMENTS),
+      ).toBeLessThan(EXACT)
+    }
+  }
+})
+
+test.each([32, 128])('the dome is covered at %i segments too', segs => {
+  for (const [rx, ry] of DOMES) {
+    expect(worstOnDome(rx, ry, 2, 1, segs)).toBeLessThan(EXACT)
+  }
+})
+
+test.each([
+  [1900, 150],
+  [1900, 500],
+  [20000, 500],
+  [3e6, 150],
+] as const)(
+  'a far pair at r=%s through a %spx reach covers its legs',
+  (r, reach) => {
+    for (const dpr of [1, 2]) {
+      for (const lineWidthPx of [1, 6]) {
+        expect(
+          worstOnLegs(r, reach, dpr, lineWidthPx, LINK_CURVE_SEGMENTS),
+        ).toBeLessThan(EXACT)
+      }
+    }
+  },
+)
+
+// A collapsed band (`arcAvailH` floors at 0) hands the dome ry 0, where the
+// foot's two normals are exactly opposed.
+test('a zero-height dome stays finite', () => {
+  const h = Math.PI / (2 * LINK_CURVE_SEGMENTS)
+  for (let seg = 0; seg <= LINK_CURVE_SEGMENTS; seg++) {
+    const a = (seg / LINK_CURVE_SEGMENTS) * Math.PI
+    for (const pad of [0.625, -0.625]) {
+      const [x, y] = ellipseHullPoint(
+        Math.cos(a),
+        Math.sin(a),
+        Math.cos(h),
+        Math.sin(h),
+        1266,
+        0,
+        pad,
+      )
+      expect(Number.isFinite(x)).toBe(true)
+      expect(Number.isFinite(y)).toBe(true)
+      expect(Math.abs(x)).toBeLessThan(1e4)
+    }
+  }
+})

package/src/shaders/barMark.generated.ts

@@ -0,0 +1,11 @@
+// AUTO-GENERATED by packages/shader-tools/src/shader-codegen from barMark.slang.
+// Do not edit. Run `pnpm gen:shaders` to regenerate.
+
+import type { ShaderSource } from '@jbrowse/render-core/hal'
+
+export * from './barMark.iface.generated.ts'
+
+export const SOURCE: ShaderSource = {
+  wgsl: () => import('./barMark.wgsl.generated.ts'),
+  glsl: () => import('./barMark.glsl.generated.ts'),
+}

package/src/shaders/barMark.glsl.generated.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED by packages/shader-tools/src/shader-codegen from barMark.slang.
+// Do not edit. Run `pnpm gen:shaders` to regenerate.
+
+export const GLSL_VERTEX = "#version 300 es\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\n\n\nlayout(std140) uniform Uniforms\n{\n    vec3 bpRangeX_0;\n    float canvasHeight_0;\n    float domainMin_0;\n    float domainMax_0;\n    int valueScaleType_0;\n    float valueSymlogConstant_0;\n    int rampMode_0;\n    float rampMin_0;\n    float rampMax_0;\n    float rampMidNorm_0;\n    int colorCutCount_0;\n    vec4  colorCuts_0[2];\n    vec4  colorBands_0[9];\n    float originYPx_0;\n    float rowHeight_0;\n    float rowBandPx_0;\n    float rowOffsetPx_0;\n    float zero_0;\n    float minCellDenomPx_0;\n    float minWidthPx_0;\n    float devicePixelRatio_0;\n    int rowTableKeys_0;\n}u_0;\n\nuniform sampler2D u_colorRamp;\n\n\nuniform sampler2D u_rowTable;\n\n\nvec4 unpackRGBA_0(uint c_0)\n{\n\n    return vec4(float((c_0 >> 0U) & 255U), float((c_0 >> 8U) & 255U), float((c_0 >> 16U) & 255U), float((c_0 >> 24U) & 255U)) / 255.0;\n}\n\n\nfloat rampMidT_0(float t_0, float mid_0)\n{\n\n    float _S1 = max(mid_0, 1.0 - mid_0);\n    return clamp((t_0 + (_S1 - mid_0)) / (2.0 * _S1), 0.0, 1.0);\n}\n\n\nfloat colorCutAt_0(int i_0, vec4 cutsLo_0, vec4 cutsHi_0)\n{\n\n    float _S2;\n    if(i_0 < 4)\n    {\n\n        _S2 = cutsLo_0[i_0];\n\n    }\n    else\n    {\n\n        _S2 = cutsHi_0[i_0 - 4];\n\n    }\n\n    return _S2;\n}\n\n\nint thresholdBand_0(float value_0, int cutCount_0, vec4 cutsLo_1, vec4 cutsHi_1)\n{\n\n    int band_0 = 0;\n\n    int i_1 = 0;\n\n    for(;;)\n    {\n\n        if(i_1 < cutCount_0)\n        {\n        }\n        else\n        {\n\n            break;\n        }\n\n        if(value_0 >= (colorCutAt_0(i_1, cutsLo_1, cutsHi_1)))\n        {\n\n            band_0 = i_1 + 1;\n\n        }\n\n        i_1 = i_1 + 1;\n\n    }\n\n    return band_0;\n}\n\n\nfloat log1pf_0(float x_0)\n{\n\n    float u_1 = 1.0 + x_0;\n\n    float _S3;\n    if(u_1 == 1.0)\n    {\n\n        _S3 = x_0;\n\n    }\n    else\n    {\n\n        _S3 = log(u_1) * (x_0 / (u_1 - 1.0));\n\n    }\n\n    return _S3;\n}\n\nfloat symlogTransform_0(float x_1, float c_1)\n{\n\n    return float((int(sign((x_1))))) * log1pf_0(abs(x_1 / c_1));\n}\n\n\nfloat normalizeScoreUnclamped_0(float score_0, float domainMin_1, float domainMax_1, int scaleType_0, float symlogConstant_0)\n{\n\n    float tMax_0;\n\n    float tMin_0;\n\n    float t_1;\n\n\n\n    if(scaleType_0 == 2)\n    {\n\n        float _S4 = symlogTransform_0(score_0, symlogConstant_0);\n        float _S5 = symlogTransform_0(domainMin_1, symlogConstant_0);\n\n        tMax_0 = symlogTransform_0(domainMax_1, symlogConstant_0);\n\n        tMin_0 = _S5;\n\n        t_1 = _S4;\n\n    }\n    else\n    {\n\n        if(scaleType_0 == 1)\n        {\n            if(domainMin_1 > 0.0)\n            {\n\n                tMax_0 = domainMin_1;\n\n            }\n            else\n            {\n\n                tMax_0 = 1.0;\n\n            }\n            float _S6 = log2(max(score_0, tMax_0));\n            float _S7 = log2(tMax_0);\n\n            tMax_0 = log2(max(domainMax_1, tMax_0));\n\n            tMin_0 = _S7;\n\n            t_1 = _S6;\n\n        }\n        else\n        {\n\n            tMax_0 = domainMax_1;\n\n            tMin_0 = domainMin_1;\n\n            t_1 = score_0;\n\n        }\n\n    }\n\n    float tRange_0 = tMax_0 - tMin_0;\n    if(tRange_0 <= 0.0)\n    {\n\n        if(t_1 > tMin_0)\n        {\n\n            tMax_0 = 1.0;\n\n        }\n        else\n        {\n\n            tMax_0 = 0.0;\n\n        }\n\n        return tMax_0;\n    }\n    return (t_1 - tMin_0) / tRange_0;\n}\n\nfloat normalizeScore_0(float score_1, float domainMin_2, float domainMax_2, int scaleType_1, float symlogConstant_1)\n{\n\n    return clamp(normalizeScoreUnclamped_0(score_1, domainMin_2, domainMax_2, scaleType_1, symlogConstant_1), 0.0, 1.0);\n}\n\n\nuint rowTableWidth_0(uint keys_0)\n{\n\n    return max(min(keys_0, 2048U), 1U);\n}\n\nuint rowTablePlaneHeight_0(uint keys_1)\n{\n\n    uint w_0 = rowTableWidth_0(keys_1);\n    uint _S8 = (keys_1 + w_0 - 1U) / w_0;\n\n    return max(_S8, 1U);\n}\n\nuint rowTableTexelX_0(uint key_0, uint keys_2)\n{\n\n    uint _S9 = key_0 % rowTableWidth_0(keys_2);\n\n    return _S9;\n}\n\n\nuint rowTableTexelY_0(uint key_1, uint keys_3)\n{\n\n    uint _S10 = key_1 / rowTableWidth_0(keys_3);\n\n    return _S10;\n}\n\n\nuint byteOf_0(float channel_0)\n{\n\n    return uint(channel_0 * 255.0 + 0.5);\n}\n\n\nvec2 hpSplitUint_0(uint value_1)\n{\n\n    uint lo_0 = value_1 & 4095U;\n\n    return vec2(float(value_1 - lo_0), float(lo_0));\n}\n\n\nfloat hpToClipX_0(vec2 splitPos_0, vec3 bpRange_0, float hpZero_0)\n{\n\n    float floorBp_0 = -3.00000000549775576e+38 + hpZero_0;\n    float step_0 = 2.0 / bpRange_0.z;\n\n\n    return dot(vec3(-1.0, max(splitPos_0.x - bpRange_0.x, floorBp_0), max(splitPos_0.y - bpRange_0.y, floorBp_0)), vec3(1.0, step_0, step_0));\n}\n\n\nfloat pxToClipLen_0(float px_0, float size_0)\n{\n\n    return px_0 * 2.0 / size_0;\n}\n\n\nfloat extendToMinWidthPx_0(float x1_0, float x2_0, float minWidth_0)\n{\n\n    float dx_0 = x2_0 - x1_0;\n\n    float _S11;\n    if((abs(dx_0)) < minWidth_0)\n    {\n\n        if(dx_0 < 0.0)\n        {\n\n            _S11 = - minWidth_0;\n\n        }\n        else\n        {\n\n            _S11 = minWidth_0;\n\n        }\n\n        _S11 = x1_0 + _S11;\n\n    }\n    else\n    {\n\n        _S11 = x2_0;\n\n    }\n\n    return _S11;\n}\n\nfloat extendToMinWidthX_0(float x1_1, float x2_1, float minWidthPx_1, float canvasWidth_0)\n{\n\n    return extendToMinWidthPx_0(x1_1, x2_1, pxToClipLen_0(minWidthPx_1, canvasWidth_0));\n}\n\n\nvec2 quadLocal_0(uint vid_0)\n{\n\n    uint v_0 = vid_0 % 6U;\n\n    bool _S12 = v_0 == 0U;\n\n    bool _S13;\n\n    if(_S12)\n    {\n\n        _S13 = true;\n\n    }\n    else\n    {\n\n        _S13 = v_0 == 2U;\n\n    }\n\n    if(_S13)\n    {\n\n        _S13 = true;\n\n    }\n    else\n    {\n\n        _S13 = v_0 == 3U;\n\n    }\n\n    float _S14;\n\n    if(_S13)\n    {\n\n        _S14 = 0.0;\n\n    }\n    else\n    {\n\n        _S14 = 1.0;\n\n    }\n    if(_S12)\n    {\n\n        _S13 = true;\n\n    }\n    else\n    {\n\n        _S13 = v_0 == 1U;\n\n    }\n\n    if(_S13)\n    {\n\n        _S13 = true;\n\n    }\n    else\n    {\n\n        _S13 = v_0 == 4U;\n\n    }\n\n    float _S15;\n\n    if(_S13)\n    {\n\n        _S15 = 0.0;\n\n    }\n    else\n    {\n\n        _S15 = 1.0;\n\n    }\n\n    return vec2(_S14, _S15);\n}\n\n\nfloat rowBandTopPx_0(float rowOffsetPx_1, float rowHeight_1, uint slot_0)\n{\n\n    return rowOffsetPx_1 + rowHeight_1 * float(slot_0);\n}\n\n\nfloat aaPx_0(float dpr_0)\n{\n\n    return 1.0 / max(dpr_0, 1.0);\n}\n\n\nfloat aaHalfPx_0(float dpr_1)\n{\n\n    return 0.5 * aaPx_0(dpr_1);\n}\n\n\nfloat barAaPx_0()\n{\n\n    return 2.0 * aaHalfPx_0(u_0.devicePixelRatio_0);\n}\n\n\nint clipSide_0(float value_2, float domainMin_3, float domainMax_3, int scaleType_2)\n{\n\n    float tolerance_0 = (domainMax_3 - domainMin_3) * 0.00000999999974738;\n    if(value_2 > (domainMax_3 + tolerance_0))\n    {\n\n        return 1;\n    }\n\n    bool _S16;\n\n    if(value_2 < (domainMin_3 - tolerance_0))\n    {\n\n        _S16 = scaleType_2 != 1;\n\n    }\n    else\n    {\n\n        _S16 = false;\n\n    }\n\n    if(_S16)\n    {\n\n        return -1;\n    }\n    return 0;\n}\n\n\nfloat yPxToClipY_0(float yPx_0, float canvasHeight_1)\n{\n\n    return 1.0 - yPx_0 / canvasHeight_1 * 2.0;\n}\n\n\nfloat valueToYPxScaled_0(float value_3, float domainMin_4, float domainMax_4, float h_0, int scaleType_3, float symlogConstant_2)\n{\n\n    return (1.0 - normalizeScore_0(value_3, domainMin_4, domainMax_4, scaleType_3, symlogConstant_2)) * h_0;\n}\n\n\nout vec4 v_color;\n\n\nout vec2 v_barInkPx;\n\n\nlayout(location = 0)\nin uint a_x;\n\n\nlayout(location = 1)\nin uint a_x2;\n\n\nlayout(location = 2)\nin float a_y;\n\n\nlayout(location = 3)\nin uint a_color;\n\n\nlayout(location = 4)\nin uint a_row;\n\n\nstruct VsOut_0\n{\n    vec4 position_0;\n    vec4 color_0;\n    vec2 barInkPx_0;\n};\n\n\nvec4 rampColor_0(float _S17)\n{\n\n    return (textureLod((u_colorRamp), (vec2((clamp(_S17, 0.0, 1.0) * 255.0 + 0.5) / 256.0, 0.5)), (0.0)));\n}\n\n\nvec4 markScaleColor_0(uint _S18, int _S19, float _S20, float _S21, float _S22, int _S23, vec4 _S24, vec4 _S25)\n{\n\n    if(_S19 == 0)\n    {\n\n        return unpackRGBA_0(_S18);\n    }\n    if(_S18 == 2143289345U)\n    {\n\n        return unpackRGBA_0(4289703855U);\n    }\n\n    int scaleType_4;\n\n    if((_S18 & 2139095040U) == 2139095040U)\n    {\n\n        if((_S18 & 8388607U) != 0U)\n        {\n\n            return unpackRGBA_0(4286611584U);\n        }\n\n        bool negative_0 = (_S18 & 2147483648U) != 0U;\n        if(_S19 == 3)\n        {\n\n            if(negative_0)\n            {\n\n                scaleType_4 = 0;\n\n            }\n            else\n            {\n\n                scaleType_4 = _S23;\n\n            }\n\n            return u_0.colorBands_0[scaleType_4];\n        }\n\n        float _S26;\n\n        if(negative_0)\n        {\n\n            _S26 = 0.0;\n\n        }\n        else\n        {\n\n            _S26 = 1.0;\n\n        }\n\n        return rampColor_0(rampMidT_0(_S26, _S22));\n    }\n    float value_4 = uintBitsToFloat(_S18);\n    if(_S19 == 3)\n    {\n\n        return u_0.colorBands_0[thresholdBand_0(value_4, _S23, _S24, _S25)];\n    }\n    if(_S19 == 2)\n    {\n\n        scaleType_4 = 1;\n\n    }\n    else\n    {\n\n        scaleType_4 = 0;\n\n    }\n    return rampColor_0(rampMidT_0(normalizeScore_0(value_4, _S20, _S21, scaleType_4, 1.0), _S22));\n}\n\n\nstruct RowPlacement_0\n{\n    bool hidden_0;\n    uint slot_1;\n    vec4 color_1;\n};\n\n\nRowPlacement_0 rowTableLookup_0(uint _S27, int _S28, vec4 _S29)\n{\n\n    RowPlacement_0 p_0;\n    p_0.hidden_0 = false;\n    p_0.slot_1 = _S27;\n    p_0.color_1 = _S29;\n    if(_S28 < 0)\n    {\n\n        return p_0;\n    }\n    uint n_0 = uint(_S28);\n    if(_S27 >= n_0)\n    {\n\n        p_0.hidden_0 = true;\n        return p_0;\n    }\n    uint h_1 = rowTablePlaneHeight_0(n_0);\n    uint _S30 = rowTableTexelX_0(_S27, n_0);\n\n    float u_2 = (float(_S30) + 0.5) / float(rowTableWidth_0(n_0));\n    float rows_0 = float(2U * h_1);\n    uint y_0 = rowTableTexelY_0(_S27, n_0);\n    vec4 s_0 = (textureLod((u_rowTable), (vec2(u_2, (float(y_0) + 0.5) / rows_0)), (0.0)));\n    if((s_0.w) < 0.5)\n    {\n\n        p_0.hidden_0 = true;\n        return p_0;\n    }\n    p_0.slot_1 = ((byteOf_0(s_0.x)) | ((byteOf_0(s_0.y)) << 8)) | ((byteOf_0(s_0.z)) << 16);\n    vec4 c_2 = (textureLod((u_rowTable), (vec2(u_2, (float(y_0 + h_1) + 0.5) / rows_0)), (0.0)));\n\n    vec4 _S31;\n    if((c_2.w) > 0.0)\n    {\n\n        _S31 = c_2;\n\n    }\n    else\n    {\n\n        _S31 = _S29;\n\n    }\n\n    p_0.color_1 = _S31;\n    return p_0;\n}\n\n\nfloat bpToClipX_0(uint _S32)\n{\n\n    return hpToClipX_0(hpSplitUint_0(_S32), u_0.bpRangeX_0, u_0.zero_0);\n}\n\n\nvoid main()\n{\n\n    VsOut_0 o_0;\n\n    RowPlacement_0 _S33 = rowTableLookup_0(a_row, u_0.rowTableKeys_0, markScaleColor_0(a_color, u_0.rampMode_0, u_0.rampMin_0, u_0.rampMax_0, u_0.rampMidNorm_0, u_0.colorCutCount_0, u_0.colorCuts_0[0], u_0.colorCuts_0[1]));\n\n\n    if(_S33.hidden_0)\n    {\n\n        o_0.position_0 = vec4(2.0, 2.0, 0.0, 1.0);\n        o_0.color_0 = vec4(0.0);\n        o_0.barInkPx_0 = vec2(0.0);\n        VsOut_0 _S34 = o_0;\n\n        gl_Position = o_0.position_0;\n\n        v_color = _S34.color_0;\n\n        v_barInkPx = _S34.barInkPx_0;\n\n        return;\n    }\n\n    float _S35 = bpToClipX_0(a_x);\n\n\n\n    float sx2_0 = extendToMinWidthX_0(_S35, bpToClipX_0(a_x2), u_0.minWidthPx_0, u_0.minCellDenomPx_0);\n    vec2 q_0 = quadLocal_0(uint(gl_VertexID));\n\n    float bandTop_0 = rowBandTopPx_0(u_0.rowOffsetPx_0, u_0.rowHeight_0, _S33.slot_1);\n    float padPx_0 = barAaPx_0();\n\n    if(uint(gl_VertexID) >= 6U)\n    {\n\n        int side_0 = clipSide_0(a_y, u_0.domainMin_0, u_0.domainMax_0, u_0.valueScaleType_0);\n        if(side_0 == 0)\n        {\n\n            o_0.position_0 = vec4(2.0, 2.0, 0.0, 1.0);\n            o_0.color_0 = vec4(0.0);\n            o_0.barInkPx_0 = vec2(0.0);\n            VsOut_0 _S36 = o_0;\n\n            gl_Position = o_0.position_0;\n\n            v_color = _S36.color_0;\n\n            v_barInkPx = _S36.barInkPx_0;\n\n            return;\n        }\n\n        float stripTop_0;\n\n        if(side_0 > 0)\n        {\n\n            stripTop_0 = bandTop_0;\n\n        }\n        else\n        {\n\n            stripTop_0 = bandTop_0 + u_0.rowBandPx_0 - 2.0;\n\n        }\n        float stripBot_0 = stripTop_0 + 2.0;\n        float sy_0 = mix(stripBot_0 + padPx_0, stripTop_0 - padPx_0, q_0.y);\n        o_0.position_0 = vec4(mix(_S35, sx2_0, q_0.x), yPxToClipY_0(sy_0, u_0.canvasHeight_0), 0.0, 1.0);\n        o_0.color_0 = vec4(unpackRGBA_0(4280821958U).xyz, 1.0);\n        o_0.barInkPx_0 = vec2(sy_0 - stripTop_0, sy_0 - stripBot_0);\n        VsOut_0 _S37 = o_0;\n\n        gl_Position = o_0.position_0;\n\n        v_color = _S37.color_0;\n\n        v_barInkPx = _S37.barInkPx_0;\n\n        return;\n    }\n\n    float valueY_0 = bandTop_0 + valueToYPxScaled_0(a_y, u_0.domainMin_0, u_0.domainMax_0, u_0.rowBandPx_0, u_0.valueScaleType_0, u_0.valueSymlogConstant_0);\n    float originY_0 = bandTop_0 + u_0.originYPx_0;\n    float _S38 = min(valueY_0, originY_0);\n    float _S39 = max(valueY_0, originY_0);\n    float vy_0 = mix(_S39 + padPx_0, _S38 - padPx_0, q_0.y);\n\n    o_0.position_0 = vec4(mix(_S35, sx2_0, q_0.x), yPxToClipY_0(vy_0, u_0.canvasHeight_0), 0.0, 1.0);\n    o_0.color_0 = _S33.color_1;\n    o_0.barInkPx_0 = vec2(vy_0 - _S38, vy_0 - _S39);\n    VsOut_0 _S40 = o_0;\n\n    gl_Position = o_0.position_0;\n\n    v_color = _S40.color_0;\n\n    v_barInkPx = _S40.barInkPx_0;\n\n    return;\n}\n\n"
+
+export const GLSL_FRAGMENT = "#version 300 es\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\n\n\nlayout(std140) uniform Uniforms\n{\n    vec3 bpRangeX_0;\n    float canvasHeight_0;\n    float domainMin_0;\n    float domainMax_0;\n    int valueScaleType_0;\n    float valueSymlogConstant_0;\n    int rampMode_0;\n    float rampMin_0;\n    float rampMax_0;\n    float rampMidNorm_0;\n    int colorCutCount_0;\n    vec4  colorCuts_0[2];\n    vec4  colorBands_0[9];\n    float originYPx_0;\n    float rowHeight_0;\n    float rowBandPx_0;\n    float rowOffsetPx_0;\n    float zero_0;\n    float minCellDenomPx_0;\n    float minWidthPx_0;\n    float devicePixelRatio_0;\n    int rowTableKeys_0;\n}u_0;\n\nfloat aaPx_0(float dpr_0)\n{\n\n    return 1.0 / max(dpr_0, 1.0);\n}\n\n\nfloat aaHalfPx_0(float dpr_1)\n{\n\n    return 0.5 * aaPx_0(dpr_1);\n}\n\n\nfloat barAaPx_0()\n{\n\n    return 2.0 * aaHalfPx_0(u_0.devicePixelRatio_0);\n}\n\n\nfloat aaRamp_0(float signedInk_0, float widthPx_0)\n{\n\n    return clamp(signedInk_0 / widthPx_0 + 0.5, 0.0, 1.0);\n}\n\n\nlayout(location = 0)\nout vec4 entryPointParam_fs_main_0;\n\n\nin vec4 v_color;\n\n\nin vec2 v_barInkPx;\n\n\nvoid main()\n{\n\n    float aaPx_1 = barAaPx_0();\n    float alpha_0 = aaRamp_0(v_barInkPx.x, aaPx_1) - aaRamp_0(v_barInkPx.y, aaPx_1);\n    if(alpha_0 <= 0.0)\n    {\n\n        discard;\n\n    }\n\n    entryPointParam_fs_main_0 = vec4(v_color.xyz, v_color.w * alpha_0);\n\n    return;\n}\n\n"