@jbrowse/render-core 5.0.0-beta.2 → 5.0.0-beta.4

package/esm/hal/createHal.js

@@ -1,4 +1,4 @@
-import { getGpuOverride, isGpuRenderingDisabled } from '../gpuDevice.js';
+import { getGpuOverride, isGpuRenderingDisabled, setBuiltRenderer, } from '../gpuDevice.js';
 import { getGraphicsCapabilities } from '../graphicsCapabilities.js';
 import { WebGL2Hal } from './webgl2Hal.js';
 import { WebGPUHal } from './webgpuHal.js';
@@ -17,14 +17,24 @@ function warnSoftwareRasterizerOnce(glRenderer) {
 // Ladder: WebGPU → WebGL2 → Canvas2D (null). The `?renderer=` URL param pins it
 // to a single rung for debugging — `webgpu`, `webgl`, or `canvas2d`/`canvas` —
 // and a pin never falls through to the next rung. See GPU_OVERRIDES.
-export async function createGpuHal(canvas, { passes, uniformByteSize, sampleCount, failures }) {
+//
+// Records the rung it returned on the page-wide cell, which is how
+// `effectiveRenderer` gets to report what drew rather than what the adapter
+// probe predicted — the two part when `WebGPUHal.create` throws and the ladder
+// lands on WebGL2.
+export async function createGpuHal(canvas, options) {
+    const hal = await climbLadder(canvas, options);
+    setBuiltRenderer(hal === null ? 'Canvas2D' : hal instanceof WebGPUHal ? 'WebGPU' : 'WebGL2');
+    return hal;
+}
+async function climbLadder(canvas, { passes, sampleCount, failures }) {
     if (isGpuRenderingDisabled()) {
         return null;
     }
     const override = getGpuOverride();
     if (override !== 'webgl') {
         try {
-            const webgpu = await WebGPUHal.create(canvas, passes, uniformByteSize, sampleCount);
+            const webgpu = await WebGPUHal.create(canvas, passes, sampleCount);
             if (webgpu) {
                 return webgpu;
             }
@@ -81,7 +91,7 @@ export async function createGpuHal(canvas, { passes, uniformByteSize, sampleCoun
         }
     }
     try {
-        return new WebGL2Hal(canvas, passes, uniformByteSize);
+        return new WebGL2Hal(canvas, passes);
     }
     catch (e) {
         console.warn('[GPU] WebGL2 unavailable, falling back to Canvas2D:', e);

package/esm/hal/deviceGpuCache.js

@@ -21,8 +21,8 @@
  * is the one pipeline input the descriptor cannot express, so it is the inner
  * key; see the `pipelines` field.
  *
- * The one field of a pipeline that is not on the descriptor is the uniform
- * size, and it cannot make two HALs disagree here:
+ * The descriptor's `uniformByteSize` never reaches the pipeline, so it cannot
+ * make two HALs disagree here:
  * `createUniformOnlyBindGroupLayout` declares no `minBindingSize`, so the
  * layout — and thus the pipeline built against it — is the same whatever a
  * display's `uniformByteSize` is. The size reaches the GPU through the bind

package/esm/hal/gpuHalBase.d.ts

@@ -31,6 +31,7 @@ export declare abstract class GpuHalBase<Buf extends {
     protected descriptors: Map<string, PipelineDescriptor>;
     protected regions: RegionRegistry<Buf>;
     protected oom: OomReporter;
+    readonly uniformByteSize: number;
     protected disposed: boolean;
     constructor(descriptors: PipelineDescriptor[], halName: string);
     protected abstract limits(): HalLimits;
@@ -49,7 +50,6 @@ export declare abstract class GpuHalBase<Buf extends {
     getBufferCount(regionKey: number, passId: string): number;
     deleteBuffer(regionKey: number, passId: string): void;
     deleteRegion(regionKey: number): void;
-    pruneRegions(active: Iterable<number>): void;
     uploadTexture(passId: string, data: Uint8Array, width: number, height: number): void;
     dispose(): void;
 }

package/esm/hal/gpuHalBase.js

@@ -19,11 +19,13 @@ export class GpuHalBase {
     descriptors;
     regions;
     oom;
+    uniformByteSize;
     // Guards dispose() against double invocation (pagehide + React cleanup can
     // both fire).
     disposed = false;
     constructor(descriptors, halName) {
         this.descriptors = new Map(descriptors.map(d => [d.id, d]));
+        this.uniformByteSize = Math.max(0, ...descriptors.map(d => d.uniformByteSize));
         this.oom = new OomReporter(halName);
         this.regions = new RegionRegistry(buf => {
             this.destroyBuffer(buf);
@@ -55,9 +57,6 @@ export class GpuHalBase {
     deleteRegion(regionKey) {
         this.regions.deleteRegion(regionKey);
     }
-    pruneRegions(active) {
-        this.regions.prune(active);
-    }
     uploadTexture(passId, data, width, height) {
         // Read the binding off the descriptor, so a pass with no texture is
         // answered without touching the backend's pipeline state at all.

package/esm/hal/mockHal.d.ts

@@ -102,7 +102,6 @@ export declare class MockHal extends GpuHalBase<MockBuffer> implements GpuHal {
     uploadBuffer(regionKey: number, passId: string, data: ArrayBuffer | ArrayBufferView, count: number): void;
     deleteBuffer(regionKey: number, passId: string): void;
     deleteRegion(regionKey: number): void;
-    pruneRegions(active: Iterable<number>): void;
     private noteReplaced;
     private noteRegionReplaced;
     writeUniforms(data: ArrayBuffer): void;

package/esm/hal/mockHal.js

@@ -119,16 +119,6 @@ export class MockHal extends GpuHalBase {
         this.noteRegionReplaced(regionKey);
         super.deleteRegion(regionKey);
     }
-    pruneRegions(active) {
-        const activeSet = new Set(active);
-        this.record('pruneRegions', [...activeSet]);
-        for (const regionKey of this.drawnThisFrame.keys()) {
-            if (!activeSet.has(regionKey)) {
-                this.noteRegionReplaced(regionKey);
-            }
-        }
-        super.pruneRegions(activeSet);
-    }
     noteReplaced(regionKey, passId) {
         if (this.frameOpen && this.drawnThisFrame.get(regionKey)?.has(passId)) {
             this.replacedWhileDrawnLog.push(`${regionKey}:${passId}`);

package/esm/hal/regionRegistry.d.ts

@@ -7,5 +7,4 @@ export declare class RegionRegistry<Buf> {
     deleteBuffer(regionKey: number, passId: string): void;
     deleteRegion(regionKey: number): void;
     deleteAll(): void;
-    prune(active: Iterable<number>): void;
 }

package/esm/hal/regionRegistry.js

@@ -1,9 +1,6 @@
-// Per-(region, pass) buffer registry shared by WebGL2Hal and WebGPUHal.
-// Owns the nested map and the destroy semantics so the two HALs only have to
-// supply a leaf-buffer type and its destroy hook. Both HALs used to ship
-// near-identical deleteBuffer/deleteRegion/deleteAll/prune/getOrCreate
-// implementations; centralizing avoids drift when one side's lifecycle is
-// tweaked and the other isn't. Contract pinned by regionRegistry.test.ts.
+// Per-(region, pass) buffer registry shared by WebGL2Hal and WebGPUHal: the
+// nested map plus destroy semantics, so each HAL supplies only its leaf-buffer
+// type and destroy hook.
 export class RegionRegistry {
     destroy;
     regions = new Map();
@@ -54,13 +51,4 @@ export class RegionRegistry {
         }
         this.regions.clear();
     }
-    // Delete every region whose key is NOT in `active`.
-    prune(active) {
-        const activeSet = new Set(active);
-        for (const regionKey of this.regions.keys()) {
-            if (!activeSet.has(regionKey)) {
-                this.deleteRegion(regionKey);
-            }
-        }
-    }
 }

package/esm/hal/types.d.ts

@@ -80,15 +80,20 @@ export interface PipelineDescriptor {
     glslVertex: string;
     glslFragment: string;
     instanceStride: number;
+    /** Bytes of the uniform block the shader binds; the HAL's slot is the largest over its passes. */
+    uniformByteSize: number;
     verticesPerInstance: number;
     blend: boolean;
     blendState?: BlendState;
     vertexAttributes: readonly VertexAttributeLayout[];
     topology?: 'triangle-list' | 'triangle-strip' | 'line-list';
+    coverage?: 'analytic';
     textures?: readonly [TextureBinding, ...TextureBinding[]];
     bindings?: readonly ShaderBinding[];
 }
 export interface GpuHal {
+    /** The uniform slot size, the largest block any registered pass binds. */
+    readonly uniformByteSize: number;
     /**
      * Size the canvas, and report the scale its backing store actually got.
      * Callers derive every device-px rect from THAT rather than from `getDpr()`:
@@ -101,7 +106,6 @@ export interface GpuHal {
     getBufferCount(regionKey: number, passId: string): number;
     deleteBuffer(regionKey: number, passId: string): void;
     deleteRegion(regionKey: number): void;
-    pruneRegions(active: Iterable<number>): void;
     uploadTexture(passId: string, data: Uint8Array, width: number, height: number): void;
     writeUniforms(data: ArrayBuffer): void;
     beginFrame(clearR: number, clearG: number, clearB: number, clearA?: number): void;

package/esm/hal/webgl2Hal.d.ts

@@ -17,7 +17,7 @@ export declare class WebGL2Hal extends GpuHalBase<RegionPassBuffer> implements G
     private contextLostListener;
     private contextRestoredListener;
     private checkGlError;
-    constructor(canvas: HTMLCanvasElement, descriptors: PipelineDescriptor[], uniformByteSize: number);
+    constructor(canvas: HTMLCanvasElement, descriptors: PipelineDescriptor[]);
     protected limits(): {
         maxBufferBytes: number;
         maxTextureDimensionPx: number;

package/esm/hal/webgl2Hal.js

@@ -156,7 +156,7 @@ export class WebGL2Hal extends GpuHalBase {
             console.error(`[WebGL2Hal] GL error at "${label}": ${glErrorName(this.gl, err)}`);
         }
     }
-    constructor(canvas, descriptors, uniformByteSize) {
+    constructor(canvas, descriptors) {
         super(descriptors, 'WebGL2Hal');
         this.canvas = canvas;
         this.debug = debugEnabled();
@@ -202,7 +202,7 @@ export class WebGL2Hal extends GpuHalBase {
         this.maxTextureDim = Number(gl.getParameter(gl.MAX_TEXTURE_SIZE));
         this.ubo = gl.createBuffer();
         gl.bindBuffer(gl.UNIFORM_BUFFER, this.ubo);
-        gl.bufferData(gl.UNIFORM_BUFFER, uniformByteSize, gl.DYNAMIC_DRAW);
+        gl.bufferData(gl.UNIFORM_BUFFER, this.uniformByteSize, gl.DYNAMIC_DRAW);
         this.passes = new Map();
         // Programs are built on first use (see `getPass`), not here: a renderer
         // declares every pass it could ever draw — alignments alone declares 21,

package/esm/hal/webgpuHal.d.ts

@@ -66,7 +66,7 @@ export declare class WebGPUHal extends GpuHalBase<RegionPassBuffer> implements G
      * configured context behind with nothing to release it.
      */
     private configureContext;
-    static create(canvas: HTMLCanvasElement, descriptors: PipelineDescriptor[], uniformByteSize: number, sampleCount: SampleCount): Promise<WebGPUHal | null>;
+    static create(canvas: HTMLCanvasElement, descriptors: PipelineDescriptor[], sampleCount: SampleCount): Promise<WebGPUHal | null>;
     resize(width: number, height: number): import("./types.ts").CanvasScale;
     private recreateMsaaTexture;
     /**
@@ -92,7 +92,7 @@ export declare class WebGPUHal extends GpuHalBase<RegionPassBuffer> implements G
      * {@link pendingDestroy} for why the frame decides when.
      *
      * Every buffer release routes here through the `RegionRegistry` destroy hook,
-     * so `uploadBuffer`, `deleteBuffer`, `deleteRegion`, `pruneRegions` and
+     * so `uploadBuffer`, `deleteBuffer`, `deleteRegion` and
      * `dispose` are all covered without any of them knowing a frame is open.
      */
     private destroyWhenIdle;

package/esm/hal/webgpuHal.js

@@ -15,11 +15,13 @@ class ShaderCompileError extends Error {
 // aligned slot in the uniform ring buffer.
 //
 // The ring is allocated eagerly at this many slots, as a GPU buffer AND a CPU
-// staging array, whether a renderer writes 4 slots or 1900 — so the cost is
-// per display and is the aligned uniform size that decides it, not the slot
-// count. A display whose uniform fits the 256-byte minimum alignment pays
-// 512 KB each side; alignments' 864-byte uniform aligns to 1024, so 2 MiB each
-// side. Trivial once, per-track at ten open alignments tracks.
+// staging array, whether a renderer writes 4 slots or 1900 — so the cost is per
+// display, and both terms are in it. A display whose uniform fits the 256-byte
+// minimum alignment pays 512 KB each side; alignments' 640-byte uniform aligns
+// to 768, so 1.5 MiB each side, per track. A frame is measured using 2-4 of
+// those slots, which is what makes the count above the oversized term rather
+// than any struct:
+// agent-docs/ideas/size-the-uniform-ring-to-its-measured-occupancy.md.
 //
 // Exhausting it does not throw: the write is dropped and its draws render
 // against the previous batch's uniforms, which is wrong data rather than stale
@@ -196,7 +198,7 @@ export class WebGPUHal extends GpuHalBase {
     // than once per frame, and a reconfigure that failed is not attempted again.
     warnedSwapChainLoss = false;
     swapChainUnrecoverable = false;
-    constructor(device, canvas, context, descriptors, uniformByteSize, sampleCount, pipelines, layouts) {
+    constructor(device, canvas, context, descriptors, sampleCount, pipelines, layouts) {
         super(descriptors, 'WebGPUHal');
         this.device = device;
         this.canvas = canvas;
@@ -206,7 +208,8 @@ export class WebGPUHal extends GpuHalBase {
         this.sampleCount = sampleCount;
         // Align uniform slots to device requirements for dynamic offsets
         const alignment = device.limits.minUniformBufferOffsetAlignment;
-        this.alignedUniformSize = Math.ceil(uniformByteSize / alignment) * alignment;
+        this.alignedUniformSize =
+            Math.ceil(this.uniformByteSize / alignment) * alignment;
         const ringSize = MAX_UNIFORM_SLOTS * this.alignedUniformSize;
         this.uniformRingBuffer = device.createBuffer({
             size: ringSize,
@@ -245,7 +248,7 @@ export class WebGPUHal extends GpuHalBase {
         });
         noteCanvasConfigured(this.canvas, this);
     }
-    static async create(canvas, descriptors, uniformByteSize, sampleCount) {
+    static async create(canvas, descriptors, sampleCount) {
         const device = await getGpuDevice();
         if (!device) {
             return null;
@@ -266,7 +269,7 @@ export class WebGPUHal extends GpuHalBase {
             throw canvasContextError(canvas, 'webgpu');
         }
         noteCanvasContext(canvas, 'webgpu');
-        return new WebGPUHal(device, canvas, context, descriptors, uniformByteSize, sampleCount, pipelines, layouts);
+        return new WebGPUHal(device, canvas, context, descriptors, sampleCount, pipelines, layouts);
     }
     resize(width, height) {
         const { changed, scale } = syncCanvasSize(this.canvas, width, height);
@@ -352,7 +355,7 @@ export class WebGPUHal extends GpuHalBase {
      * {@link pendingDestroy} for why the frame decides when.
      *
      * Every buffer release routes here through the `RegionRegistry` destroy hook,
-     * so `uploadBuffer`, `deleteBuffer`, `deleteRegion`, `pruneRegions` and
+     * so `uploadBuffer`, `deleteBuffer`, `deleteRegion` and
      * `dispose` are all covered without any of them knowing a frame is open.
      */
     destroyWhenIdle(resource) {
@@ -372,12 +375,12 @@ export class WebGPUHal extends GpuHalBase {
     createTexture(passId, binding, data, width, height) {
         const existing = this.passTextures.get(passId);
         if (existing) {
-            // Same hazard as a buffer, one step further from a live caller: every
-            // `uploadTexture` in tree is a colour ramp written from an upload autorun
-            // (hic's `LinearHicDisplay/model.ts`, variants' `LDDisplay/shared.ts`),
-            // which never runs inside a frame. Routing it through the same deferral
-            // costs nothing and keeps "replaced mid-frame" from being a hazard again
-            // the first time a renderer builds a texture from render state.
+            // Same hazard as a buffer, and no longer a hypothetical one: every
+            // `uploadTexture` in tree is a colour ramp, and since the ramp became a
+            // `defineMark` `texture` they are all written by `GpuMarkBackend`'s
+            // `bindRamp` from inside `drawRegion` — mid-frame, between an encoded
+            // draw and its submit. The deferral is what makes replacing one there
+            // safe.
             this.destroyWhenIdle(existing.texture);
         }
         const texture = this.device.createTexture({

package/esm/installUpload.d.ts

@@ -74,7 +74,10 @@ export declare function oneCell<K, T>(key: K, value: T | undefined | null): Read
  *
  * **Calling again only swaps the backend.** Displays wire this from
  * `startRenderingBackend`, which fires again on every context-loss recovery;
- * the diff and the encode cache live in the setup thunk and survive it.
+ * the diff and the encode memo live in the setup thunk and survive it.
+ *
+ * `encode` runs through `createEncodeMemo`. A display that needs the encoded
+ * map itself holds that memo in a `.views` closure and hands identity cells.
  *
  * @see installUpload.test.ts for the upload, encode and release counts.
  * @see ADR-078 for why this is one autorun and a diff.

package/esm/installUpload.js

@@ -1,6 +1,6 @@
 import { getType } from '@jbrowse/mobx-state-tree';
-import { computed } from 'mobx';
 import { contractReportsOn, reportContractViolation, } from './contractReports.js';
+import { createEncodeMemo } from './encodeMemo.js';
 import { createMapUploadSync } from './mapUploadSync.js';
 import { isCheckedAtTheStore } from './regionDataMap.js';
 /**
@@ -47,49 +47,17 @@ export function installUpload(self, backend, { cells, inputs, encode, render })
                 b.release(key);
             },
         });
-        if (!encode) {
-            const own = cells;
-            return {
-                upload: b => {
-                    const current = own();
-                    if (contractReportsOn()) {
-                        checkPayloads(self, current);
-                    }
-                    return sync(b, current);
-                },
-                render: b => render(b, own()),
-            };
-        }
-        const encoded = new Map();
-        const encodedFrom = new Map();
-        const props = inputs && computed(inputs);
-        let lastProps;
+        const own = encode
+            ? createEncodeMemo(cells, inputs, encode)
+            : cells;
         return {
             upload: b => {
-                const current = cells();
                 if (contractReportsOn()) {
-                    checkPayloads(self, current);
-                }
-                const p = props ? props.get() : undefined;
-                if (p !== lastProps) {
-                    lastProps = p;
-                    encodedFrom.clear();
-                }
-                for (const [key, data] of current) {
-                    if (encodedFrom.get(key) !== data) {
-                        encoded.set(key, encode(data, p, key));
-                        encodedFrom.set(key, data);
-                    }
-                }
-                for (const key of encoded.keys()) {
-                    if (!current.has(key)) {
-                        encoded.delete(key);
-                        encodedFrom.delete(key);
-                    }
+                    checkPayloads(self, cells());
                 }
-                return sync(b, encoded);
+                return sync(b, own());
             },
-            render: b => render(b, encoded),
+            render: b => render(b, own()),
         };
     });
 }

package/esm/instanceCache.d.ts

@@ -14,9 +14,8 @@ export interface InstanceCacheOpts<TData> {
     colorOffsetWords: number;
 }
 /**
- * A per-key cache of packed instance bytes with a geometry/color split: a
- * recolor patches the one color lane in place instead of re-packing every
- * other one.
+ * A cache of packed instance bytes with a geometry/color split: a recolor
+ * patches the one color lane in place instead of re-packing every other one.
  *
  * The split is worth having because the two inputs move on completely
  * different schedules — geometry on an RPC refetch, colors on a `colorBy`
@@ -32,12 +31,16 @@ export interface InstanceCacheOpts<TData> {
  * problem. `installUpload` exists for the same reason one
  * layer up — an upload memo is not a hand-rolled `let`.
  *
+ * **The geometry token is the key**, so nothing has to evict: a payload whose
+ * coordinates were replaced takes its bytes with it, and a cache shared by
+ * several displays cannot hand one display another's buffer — two displays
+ * never hold one coordinate array. That is also what lets a mark's `pack`
+ * hold one of these, a mark list being module-level and shared.
+ *
  * The GPU re-upload still happens on a recolor (no HAL does partial buffer
  * updates); what is skipped is the dominant CPU interleave.
  */
 export declare function createInstanceCache<TData>(opts: InstanceCacheOpts<TData>): {
-    /** Packed bytes for `key`, re-packing or re-coloring only as needed. */
-    get(key: number, data: TData): ArrayBuffer;
-    delete(key: number): void;
-    clear(): void;
+    /** Packed bytes for `data`, re-packing or re-coloring only as needed. */
+    get(data: TData): ArrayBuffer;
 };

package/esm/instanceCache.js

@@ -1,7 +1,6 @@
 /**
- * A per-key cache of packed instance bytes with a geometry/color split: a
- * recolor patches the one color lane in place instead of re-packing every
- * other one.
+ * A cache of packed instance bytes with a geometry/color split: a recolor
+ * patches the one color lane in place instead of re-packing every other one.
  *
  * The split is worth having because the two inputs move on completely
  * different schedules — geometry on an RPC refetch, colors on a `colorBy`
@@ -17,19 +16,25 @@
  * problem. `installUpload` exists for the same reason one
  * layer up — an upload memo is not a hand-rolled `let`.
  *
+ * **The geometry token is the key**, so nothing has to evict: a payload whose
+ * coordinates were replaced takes its bytes with it, and a cache shared by
+ * several displays cannot hand one display another's buffer — two displays
+ * never hold one coordinate array. That is also what lets a mark's `pack`
+ * hold one of these, a mark list being module-level and shared.
+ *
  * The GPU re-upload still happens on a recolor (no HAL does partial buffer
  * updates); what is skipped is the dominant CPU interleave.
  */
 export function createInstanceCache(opts) {
     const { geomToken, colors, interleave, strideWords, colorOffsetWords } = opts;
-    const cache = new Map();
+    const cache = new WeakMap();
     return {
-        /** Packed bytes for `key`, re-packing or re-coloring only as needed. */
-        get(key, data) {
+        /** Packed bytes for `data`, re-packing or re-coloring only as needed. */
+        get(data) {
             const geom = geomToken(data);
             const cols = colors(data);
-            const hit = cache.get(key);
-            if (hit?.geom === geom) {
+            const hit = cache.get(geom);
+            if (hit) {
                 if (hit.colors !== cols) {
                     const u32 = new Uint32Array(hit.buf);
                     for (let i = 0, n = cols.length; i < n; i++) {
@@ -40,14 +45,8 @@ export function createInstanceCache(opts) {
                 return hit.buf;
             }
             const buf = interleave(data);
-            cache.set(key, { geom, colors: cols, buf });
+            cache.set(geom, { colors: cols, buf });
             return buf;
         },
-        delete(key) {
-            cache.delete(key);
-        },
-        clear() {
-            cache.clear();
-        },
     };
 }

package/esm/mapUploadSync.d.ts

@@ -1,14 +1,6 @@
 export interface MapUploadTarget<K, T, B> {
     upload: (backend: B, key: K, data: T) => void;
-    /**
-     * How a key that left the map is released. `remove` deletes it by itself;
-     * `prune` is handed the keys still present and releases everything else.
-     * `installUpload` takes the first, which is the only correct shape on a
-     * canvas several displays share and does the same job on a display's own
-     * map.
-     */
     remove?: (backend: B, key: K) => void;
-    prune?: (backend: B, active: ReadonlySet<K>) => void;
 }
 /**
  * The one reference diff every keyed GPU upload in the tree runs on. Uploads

package/esm/mapUploadSync.js

@@ -39,7 +39,6 @@ export function createMapUploadSync(target) {
                 changed = true;
             }
         }
-        target.prune?.(backend, new Set(entries.keys()));
         return changed;
     };
 }

package/esm/marks/colorFill.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Packed ABGR → `rgba(...)`, and the run-tracking fill a painter wraps it in.
+ *
+ * `@jbrowse/core/util/colorBits` re-exports `abgrToCssRgba` from here: core
+ * depends on render-core, never the reverse. The direction that genuinely
+ * needs core is resolving a CSS colour to a packed number, which is why a
+ * shape takes packed colours and the display resolves them.
+ */
+export declare function abgrToCssRgba(c: number): string;
+/**
+ * A fill-style setter that only touches `ctx.fillStyle` when the colour
+ * changes. Most of a painting is runs of one colour, and both the string
+ * allocation and the context write cost more than the comparison.
+ */
+export declare function makeAbgrFill(ctx: {
+    fillStyle: string | CanvasGradient | CanvasPattern;
+}): (abgr: number) => void;

package/esm/marks/colorFill.js

@@ -0,0 +1,26 @@
+/**
+ * Packed ABGR → `rgba(...)`, and the run-tracking fill a painter wraps it in.
+ *
+ * `@jbrowse/core/util/colorBits` re-exports `abgrToCssRgba` from here: core
+ * depends on render-core, never the reverse. The direction that genuinely
+ * needs core is resolving a CSS colour to a packed number, which is why a
+ * shape takes packed colours and the display resolves them.
+ */
+export function abgrToCssRgba(c) {
+    const a = ((c >>> 24) & 255) / 255;
+    return `rgba(${c & 255},${(c >>> 8) & 255},${(c >>> 16) & 255},${a})`;
+}
+/**
+ * A fill-style setter that only touches `ctx.fillStyle` when the colour
+ * changes. Most of a painting is runs of one colour, and both the string
+ * allocation and the context write cost more than the comparison.
+ */
+export function makeAbgrFill(ctx) {
+    let last;
+    return (abgr) => {
+        if (abgr !== last) {
+            last = abgr;
+            ctx.fillStyle = abgrToCssRgba(abgr);
+        }
+    };
+}

package/esm/marks/drawAgainstHit.d.ts

@@ -0,0 +1,47 @@
+import type { RenderBlock } from '../renderBlock.ts';
+import type { MarkContext2D, MarkFrame, MarkShape } from './types.ts';
+export interface RecordedRect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    fillStyle: string;
+}
+/**
+ * A `MarkContext2D` that records every rect a painter fills, in paint order —
+ * `fillRect` and path `rect` alike, so a shape that batches by colour records
+ * the same list as one that fills per instance. A path traced with
+ * `moveTo`/`lineTo` and filled records its bounding box, which is what a
+ * shape whose hit test answers a polygon's box (the variant inversion
+ * triangle) is held to.
+ *
+ * A **stroked** path records one rect per `moveTo`/`lineTo` edge, each the
+ * edge's bounding box widened by half the current `lineWidth` — the extent a
+ * round cap reaches on all four sides. Per edge rather than per `stroke()`,
+ * because a painter that batches a colour run into one path (dotplot's) would
+ * otherwise record the run's hull as a single instance. `fillStyle` on such a
+ * record is the `strokeStyle` it went down in; the field is the colour of the
+ * ink either way.
+ */
+export declare function recordingContext(): {
+    ctx: MarkContext2D;
+    calls: RecordedRect[];
+};
+/**
+ * The draw-against-hit gate for a shape whose instances paint as rects: paint
+ * the block, then walk it in `step` px and hold `hitNearest` to what the
+ * painter recorded. A hit at distance 0 has to sit on the rect of the index it
+ * names, and a point on a rect has to answer that rect — the last-painted one
+ * where rects overlap, since the sweep hands candidates in back to front.
+ *
+ * Returns the violations rather than asserting, so a test reads as
+ * `expect(sweep(...)).toEqual([])`. `maxDistSq` is the caller's, because a
+ * shape whose hit target is wider than its ink (`point`) needs a bound that
+ * admits the whole rect.
+ */
+export declare function sweepDrawAgainstHit<C extends {
+    count: number;
+}, P>(shape: MarkShape<C, P>, channels: C, block: RenderBlock, frame: MarkFrame, params: P, { maxDistSq, step }: {
+    maxDistSq: number;
+    step?: number;
+}): string[];