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

package/esm/RenderCanvas.d.ts

@@ -25,7 +25,7 @@ export interface RenderCanvasHandle {
  * render-prop body on the same value for the displays on the chrome, which it
  * does *not* get for free from the `renderError` unmount (that covers only a
  * reported loss — see the `canvasKey` note in useRenderingBackend.ts).
- * GPU_RENDERING.md said so and ended with "any new consumer rendering its own
+ * GPU_DISPLAY_LIFECYCLE.md said so and ended with "any new consumer rendering its own
  * banner must too" — a rule enforced by remembering to read the doc. Rendering
  * the element here makes it structural instead: there is no way to mount this
  * canvas without the key.

package/esm/RenderCanvas.js

@@ -16,7 +16,7 @@ import { jsx as _jsx } from "react/jsx-runtime";
  * render-prop body on the same value for the displays on the chrome, which it
  * does *not* get for free from the `renderError` unmount (that covers only a
  * reported loss — see the `canvasKey` note in useRenderingBackend.ts).
- * GPU_RENDERING.md said so and ended with "any new consumer rendering its own
+ * GPU_DISPLAY_LIFECYCLE.md said so and ended with "any new consumer rendering its own
  * banner must too" — a rule enforced by remembering to read the doc. Rendering
  * the element here makes it structural instead: there is no way to mount this
  * canvas without the key.

package/esm/canvas2dUtils.js

@@ -139,7 +139,7 @@ export function prepareCanvas(canvas, ctx, canvasWidth, canvasHeight) {
 // `getContext('2d')` + null-guard + `prepareCanvas` ritual that every
 // standalone 2D overlay otherwise hand-rolls in its draw effect — and the
 // `prepareCanvas` DPR step is easy to omit, which renders blurry on Retina
-// (see agent-docs/reference/GPU_RENDERING.md §"Canvas scaling & hi-DPI").
+// (see agent-docs/reference/GPU_SHADERS.md §"Canvas scaling & hi-DPI").
 // Returning the
 // prepared ctx structurally prevents that omission.
 export function getPreparedCanvas2D(canvas, width, height) {

package/esm/createRenderingBackend.d.ts

@@ -40,9 +40,9 @@ export declare function createRenderingBackend<TRenderingBackend>(canvas: HTMLCa
  * `DisplayChrome` machinery as a GPU display — the lifecycle is backend-
  * agnostic, so nothing downstream knows or cares there's no HAL.
  *
- * Reference: `plugins/sequence`'s `SequenceRenderer`. Promote to the dual-path
+ * No in-tree display uses it. Promote to the dual-path
  * `createRenderingBackend` only once a profile shows Canvas2D can't keep 60fps
  * at the display's real feature counts (≳100K features/frame — see
- * RFC-001 §3a).
+ * agent-docs/reference/PLUGIN_ABI_STABILITY.md §Canvas2D or GPU).
  */
 export declare function createCanvas2DBackend<TRenderingBackend>(canvas: HTMLCanvasElement, createCanvas2DRenderingBackend: (canvas: HTMLCanvasElement) => TRenderingBackend): Promise<TRenderingBackend>;

package/esm/createRenderingBackend.js

@@ -50,10 +50,10 @@ export async function createRenderingBackend(canvas, { passes, sampleCount = der
  * `DisplayChrome` machinery as a GPU display — the lifecycle is backend-
  * agnostic, so nothing downstream knows or cares there's no HAL.
  *
- * Reference: `plugins/sequence`'s `SequenceRenderer`. Promote to the dual-path
+ * No in-tree display uses it. Promote to the dual-path
  * `createRenderingBackend` only once a profile shows Canvas2D can't keep 60fps
  * at the display's real feature counts (≳100K features/frame — see
- * RFC-001 §3a).
+ * agent-docs/reference/PLUGIN_ABI_STABILITY.md §Canvas2D or GPU).
  */
 export function createCanvas2DBackend(canvas, createCanvas2DRenderingBackend) {
     return Promise.resolve(createCanvas2DRenderingBackend(canvas));

package/esm/graphicsCapabilities.js

@@ -54,7 +54,7 @@ async function probeWebgpu() {
  * moment this returns and the browser reclaims the context on GC, the same
  * release the HAL relies on. A page that then reaches the 16-context ceiling
  * evicts this one first (it is the oldest, and nothing draws to it or
- * re-acquires it), so the eviction cascade in GPU_CONTEXT_BUDGET.md cannot
+ * re-acquires it), so the eviction cascade in GPU_PORTABILITY.md cannot
  * start here.
  *
  * The driver string comes off the same context, so it is free where it matters:

package/esm/hal/createHal.js

@@ -64,7 +64,7 @@ async function climbLadder(canvas, { passes, sampleCount, failures }) {
     // volvox tracks, and *no scroll churn at all* — headless Chrome (SwiftShader),
     // three runs each: WebGL2 blocks the main thread for 1.3-5.5 s in a single
     // task and 2.1-8.8 s in total, while Canvas2D never exceeds 339 ms and never
-    // once produces a task over 500 ms. GPU_CONTEXT_BUDGET.md has the churn case
+    // once produces a task over 500 ms. GPU_PORTABILITY.md has the churn case
     // at ~25x; this is the floor, and it is the load-time pipeline build rather
     // than the per-pass rebuild the churn number measures.
     //

package/esm/hal/deviceGpuCache.js

@@ -28,21 +28,18 @@ export function bindGroupLayoutEntries(bindings) {
     });
 }
 function gpuBlendState(bs) {
-    // WebGPU rejects any factor but 'one' under max and min, which ignore them.
-    // Alpha takes the same equation, as webgl2Hal's applyBlendState does.
+    // WebGPU rejects any factor but 'one' under max, which ignores them. Alpha
+    // accumulates as webgl2Hal's applyBlendState does.
     const max = { srcFactor: 'one', dstFactor: 'one', operation: 'max' };
-    const min = { srcFactor: 'one', dstFactor: 'one', operation: 'min' };
     const behind = { srcFactor: 'one-minus-dst-alpha', dstFactor: 'one' };
     return bs.op === 'max'
         ? { color: max, alpha: max }
-        : bs.op === 'min'
-            ? { color: min, alpha: min }
-            : bs.op === 'behind'
-                ? { color: behind, alpha: behind }
-                : {
-                    color: { srcFactor: bs.srcFactor, dstFactor: bs.dstFactor },
-                    alpha: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha' },
-                };
+        : bs.op === 'behind'
+            ? { color: behind, alpha: behind }
+            : {
+                color: { srcFactor: bs.srcFactor, dstFactor: bs.dstFactor },
+                alpha: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha' },
+            };
 }
 export function pipelineRecipe(desc, wgslSource, sampleCount) {
     return {

package/esm/hal/types.d.ts

@@ -38,8 +38,6 @@ export type BlendState = {
     dstFactor: BlendFactor;
 } | {
     op: 'max';
-} | {
-    op: 'min';
 } | {
     op: 'behind';
 };

package/esm/hal/webgl2Hal.d.ts

@@ -43,7 +43,7 @@ export declare class WebGL2Hal extends GpuHalBase<RegionPassBuffer> implements G
      * owns (`antialias` above one sample), so this HAL holds no separate target —
      * releasing its samples means dropping the context, which costs a re-acquire
      * against a hard 16-context ceiling and a full shader recompile per display.
-     * `agent-docs/reference/GPU_CONTEXT_BUDGET.md` measured that trade and
+     * `agent-docs/reference/GPU_PORTABILITY.md` measured that trade and
      * declined it; what makes the WebGPU side worth doing is that it pays
      * neither.
      */

package/esm/hal/webgl2Hal.js

@@ -308,7 +308,7 @@ export class WebGL2Hal extends GpuHalBase {
      * owns (`antialias` above one sample), so this HAL holds no separate target —
      * releasing its samples means dropping the context, which costs a re-acquire
      * against a hard 16-context ceiling and a full shader recompile per display.
-     * `agent-docs/reference/GPU_CONTEXT_BUDGET.md` measured that trade and
+     * `agent-docs/reference/GPU_PORTABILITY.md` measured that trade and
      * declined it; what makes the WebGPU side worth doing is that it pays
      * neither.
      */
@@ -458,9 +458,6 @@ export class WebGL2Hal extends GpuHalBase {
         if (bs?.op === 'max') {
             gl.blendEquation(gl.MAX);
         }
-        else if (bs?.op === 'min') {
-            gl.blendEquation(gl.MIN);
-        }
         else if (bs?.op === 'behind') {
             gl.blendEquation(gl.FUNC_ADD);
             gl.blendFuncSeparate(gl.ONE_MINUS_DST_ALPHA, gl.ONE, gl.ONE_MINUS_DST_ALPHA, gl.ONE);

package/esm/hal/webgpuHal.js

@@ -60,9 +60,8 @@ async function buildPipeline(device, recipe, passId) {
         multisample: recipe.sampleCount === 1 ? undefined : { count: recipe.sampleCount },
     });
 }
-// Every declared pass up front, unlike WebGL2's first-draw link; see
-// ARCHITECTURAL_LIMITS.md §"Every WebGPU display resolves its whole pass list
-// before it can paint". Each pass compiles as soon as its own WGSL arrives.
+// Every declared pass up front, unlike WebGL2's first-draw link. Each pass
+// compiles as soon as its own WGSL arrives.
 async function resolvePipelines(device, descriptors, sampleCount) {
     const built = await Promise.all(descriptors.map(async (desc) => {
         const { WGSL_SOURCE } = await desc.source.wgsl();

package/esm/marks/index.d.ts

@@ -14,7 +14,7 @@ export { appendGlyph, pointInsetPx } from './glyphPaint.ts';
 export { recordPath } from './pathRecorder.ts';
 export { abgrToCssRgba, makeAbgrFill } from './colorFill.ts';
 export { RAMP_NOT_A_NUMBER_COLOR, RAMP_NO_VALUE_BITS, RAMP_NO_VALUE_COLOR, } from '../shaders/markColor.generated.ts';
-export { instanceColor, isThreshold, keepRampValues, rampUniforms, rampValueBits, thresholdBandOf, } from './markRamp.ts';
+export { instanceColor, isThreshold, keepRampValues, paintColors, rampUniforms, rampValueBits, thresholdBandOf, } from './markRamp.ts';
 export { HIDDEN_ROW, NO_ROW_COLOR, RowKeys, buildRowTable } from './rowTable.ts';
 export { keySlot, rowColor, rowSlot } from './rowLane.ts';
 export { rowSpanIndex, spansInRow } from './rowSpanIndex.ts';

package/esm/marks/index.js

@@ -14,7 +14,7 @@ export { appendGlyph, pointInsetPx } from './glyphPaint.js';
 export { recordPath } from './pathRecorder.js';
 export { abgrToCssRgba, makeAbgrFill } from './colorFill.js';
 export { RAMP_NOT_A_NUMBER_COLOR, RAMP_NO_VALUE_BITS, RAMP_NO_VALUE_COLOR, } from '../shaders/markColor.generated.js';
-export { instanceColor, isThreshold, keepRampValues, rampUniforms, rampValueBits, thresholdBandOf, } from './markRamp.js';
+export { instanceColor, isThreshold, keepRampValues, paintColors, rampUniforms, rampValueBits, thresholdBandOf, } from './markRamp.js';
 export { HIDDEN_ROW, NO_ROW_COLOR, RowKeys, buildRowTable } from './rowTable.js';
 export { keySlot, rowColor, rowSlot } from './rowLane.js';
 export { rowSpanIndex, spansInRow } from './rowSpanIndex.js';

package/esm/marks/markRamp.d.ts

@@ -56,8 +56,10 @@ export declare function rampValueBits(values: Float32Array): Uint32Array<ArrayBu
  */
 export declare function keepRampValues(values: Float32Array, keep: (value: number, index: number) => boolean): Float32Array<ArrayBuffer>;
 /**
- * The interval a value is in on a threshold: how many of the ascending cuts it
- * is at or past, `thresholdIndex`'s rule and the shader's `thresholdBand`.
+ * The interval a lane value is in on a threshold: how many of the ascending
+ * cuts it is at or past, `thresholdIndex`'s rule and the shader's
+ * `thresholdBand`. The value is a float32 and so is each cut in the shader's
+ * uniform, so a cut compares as one here: 0.7 off a lane is at a cut of 0.7.
  */
 export declare function thresholdBandOf(value: number, cuts: readonly number[]): number;
 /**

package/esm/marks/markRamp.js

@@ -99,13 +99,15 @@ export function keepRampValues(values, keep) {
     return new Float32Array(kept.buffer, kept.byteOffset, kept.length);
 }
 /**
- * The interval a value is in on a threshold: how many of the ascending cuts it
- * is at or past, `thresholdIndex`'s rule and the shader's `thresholdBand`.
+ * The interval a lane value is in on a threshold: how many of the ascending
+ * cuts it is at or past, `thresholdIndex`'s rule and the shader's
+ * `thresholdBand`. The value is a float32 and so is each cut in the shader's
+ * uniform, so a cut compares as one here: 0.7 off a lane is at a cut of 0.7.
  */
 export function thresholdBandOf(value, cuts) {
     let band = 0;
     for (const cut of cuts) {
-        if (value >= cut) {
+        if (value >= Math.fround(cut)) {
             band++;
         }
     }
@@ -150,9 +152,7 @@ export function paintColors(c, count, scale) {
     const colors = new Uint32Array(count);
     const bits = rampValueBits(colorValue);
     const colorOf = isThreshold(scale)
-        ? (value) => Number.isFinite(value)
-            ? scale.colors[thresholdBandOf(value, scale.cuts)]
-            : scale.colors[value > 0 ? scale.cuts.length : 0]
+        ? thresholdColorOf(scale)
         : rampColorOf(scale);
     for (let i = 0; i < count; i++) {
         const value = colorValue[i];
@@ -175,6 +175,14 @@ function constantColors(c, color, count) {
     c.constantBake = colors;
     return colors;
 }
+// The cuts the shader's uniform block holds, so Canvas2D paints a value past
+// the last of them in the band the GPU does.
+function thresholdColorOf(scale) {
+    const cuts = scale.cuts.slice(0, MAX_COLOR_CUTS);
+    return (value) => Number.isFinite(value)
+        ? scale.colors[thresholdBandOf(value, cuts)]
+        : scale.colors[value > 0 ? cuts.length : 0];
+}
 function rampColorOf(ramp) {
     const [min, max] = ramp.domain;
     const log = ramp.scale === 'log';

package/esm/marks/rowSpanIndex.d.ts

@@ -16,8 +16,9 @@ export interface RowSpanIndex {
 }
 /**
  * The index over `count` spans from `x` to `x2`, each in the row `row` names
- * (row 0 where there is no lane). A counting sort by row, a sort of each row
- * the input left out of start order, and one pass for the reach.
+ * (row 0 where there is no lane), less those on `HIDDEN_ROW`, which no row
+ * holds. A counting sort by row, a sort of each row the input left out of
+ * start order, and one pass for the reach.
  */
 export declare function rowSpanIndex(x: Uint32Array, x2: Uint32Array, row: Uint32Array | undefined, count?: number): RowSpanIndex;
 /**

package/esm/marks/rowSpanIndex.js

@@ -1,3 +1,4 @@
+import { HIDDEN_ROW } from './rowTable.js';
 const lowEnd = (x, x2, i) => Math.min(x[i], x2[i]);
 const highEnd = (x, x2, i) => Math.max(x[i], x2[i]);
 // A row that arrived nearly in start order, as `cells` writes one (an
@@ -53,22 +54,27 @@ function sortRow(order, from, to, x, x2) {
 }
 /**
  * The index over `count` spans from `x` to `x2`, each in the row `row` names
- * (row 0 where there is no lane). A counting sort by row, a sort of each row
- * the input left out of start order, and one pass for the reach.
+ * (row 0 where there is no lane), less those on `HIDDEN_ROW`, which no row
+ * holds. A counting sort by row, a sort of each row the input left out of
+ * start order, and one pass for the reach.
  */
 export function rowSpanIndex(x, x2, row, count = x.length) {
     let rows = 1;
     if (row) {
         for (let i = 0; i < count; i++) {
-            if (row[i] + 1 > rows) {
-                rows = row[i] + 1;
+            const r = row[i];
+            if (r !== HIDDEN_ROW && r + 1 > rows) {
+                rows = r + 1;
             }
         }
     }
     const rowStart = new Uint32Array(rows + 1);
     if (row) {
         for (let i = 0; i < count; i++) {
-            rowStart[row[i] + 1]++;
+            const r = row[i];
+            if (r !== HIDDEN_ROW) {
+                rowStart[r + 1]++;
+            }
         }
         for (let r = 0; r < rows; r++) {
             rowStart[r + 1] = rowStart[r + 1] + rowStart[r];
@@ -77,11 +83,15 @@ export function rowSpanIndex(x, x2, row, count = x.length) {
     else {
         rowStart[1] = count;
     }
-    const order = new Uint32Array(count);
+    const placed = rowStart[rows];
+    const order = new Uint32Array(placed);
     if (row) {
         const next = rowStart.slice(0, rows);
         for (let i = 0; i < count; i++) {
-            order[next[row[i]]++] = i;
+            const r = row[i];
+            if (r !== HIDDEN_ROW) {
+                order[next[r]++] = i;
+            }
         }
     }
     else {
@@ -89,7 +99,7 @@ export function rowSpanIndex(x, x2, row, count = x.length) {
             order[i] = i;
         }
     }
-    const reach = new Uint32Array(count);
+    const reach = new Uint32Array(placed);
     for (let r = 0; r < rows; r++) {
         const from = rowStart[r];
         const to = rowStart[r + 1];

package/esm/slangPass.d.ts

@@ -20,12 +20,11 @@ export interface ShaderModule {
  *
  * - `verticesPerInstance` — the canvas chevron pass, whose count is the
  *   shader's `CHEVRON_VERTS` times a cap the *renderer* chooses.
- * - `blendState` / `topology` — the synteny fill is the one module drawn under
- *   two blends: its strongest-ribbon passes take min or max where the stacking
- *   pass inherits src-over, since one uniform switches the fragment between
- *   the two outputs. Wiggle's step line and center line each have their own
- *   module instead, and the center line states `//! blend: max` itself. A
- *   shader whose passes disagree declares neither and says which at each pass.
+ * - `blendState` / `topology` — no pass in the tree overrides these. Wiggle's
+ *   step line and center line did while they shared one module and blended
+ *   differently (src-over against max); each record now has its own module,
+ *   and the center line's states `//! blend: max` itself. A shader whose passes
+ *   disagree declares neither and says which at each pass.
  * - `blend: false` — nothing disables blending today, which is why there is no
  *   `//! blend: none` to inherit it from.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/render-core",
-  "version": "5.0.0-beta.10",
+  "version": "5.0.0-beta.11",
   "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": [
@@ -95,7 +95,7 @@
     "./useTabVisibilityRerender": "./esm/useTabVisibilityRerender.js"
   },
   "dependencies": {
-    "@jbrowse/mobx-state-tree": "^6.6.1",
+    "@jbrowse/mobx-state-tree": "^6.7.0",
     "mobx": "^7.0.5"
   },
   "peerDependencies": {

package/src/shaders/capsule.slang

@@ -2,7 +2,7 @@
 // `capsuleDist` and nowhere else: the edge ramp over that distance is
 // `antialias`'s one `edgeCoverage`, shared with every butt-capped stroke in the
 // tree. Consumers, and which half each takes:
-// agent-docs/reference/SHADER_SHAPE_LIBRARY.md.
+// agent-docs/reference/SHADER_JS_CODEGEN.md.
 //
 // `capsuleQuadLocal` pads by exactly `aaHalfPx(dpr)` past the ink. Pad less and
 // the ramp is clipped at the quad edge — coverage falls to 0.5 at the boundary,

package/src/shaders/rowRect.slang

@@ -17,7 +17,7 @@
 // are sparse intervals with nothing beside them, so it floors; MAF's cells
 // never gap and it passes 0; wiggle density tiles at most zooms and gaps where
 // its source does, so it floors and pays nothing for it on the tiling. Both
-// halves measured — `agent-docs/reference/MAF_SUBPIXEL_CELLS.md`.
+// halves measured — `agent-docs/reference/MAF_LARGE_BLOCKS.md`.
 //! export-consts: MIN_DRAWN_ROW_PX, MULTI_ROW_MIN_CELL_PX
 //! js-export: drawnRowHeightPx, rowBandOffsetPx
 module rowRect;
@@ -68,7 +68,7 @@ public struct RowRectVsOut {
 // There is no X-axis twin. A row is a container the reader is counting, so
 // losing one loses a species; a cell is a sample of a tiling, so losing one to
 // the blend is the honest answer and flooring it invents ink
-// (`agent-docs/reference/MAF_SUBPIXEL_CELLS.md`). The caller that does want an X
+// (`agent-docs/reference/MAF_LARGE_BLOCKS.md`). The caller that does want an X
 // floor names its own width, below.
 static const float MIN_DRAWN_ROW_PX = 1.0;