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

package/esm/RenderCanvas.d.ts

@@ -47,11 +47,11 @@ export default function RenderCanvas({ handle, drawn, phase, ...canvasProps }: {
     /**
      * Whether this canvas holds finished content — each view's own `settled`, the
      * same flag its `*_canvas_done` testid is built from. Published as
-     * `data-display-drawn`, which is what `PENDING_DISPLAYS`
+     * `data-display-drawn`, the attribute `PENDING_DISPLAYS`
      * (`@jbrowse/browser-test-utils`) selects on, so these views answer "has
      * everything painted?" with the same attribute every LGV display does.
      *
-     * Required, and that is the point: `PENDING_DISPLAYS` used to name
+     * The prop is required because `PENDING_DISPLAYS` used to name
      * `synteny_canvas` explicitly and simply **forgot dotplot**, so an unpainted
      * dotplot counted as finished and a capture could land on it blank. A new
      * drop-to-primitive view would have been forgotten the same way.

package/esm/RenderLifecycleMixin.d.ts

@@ -142,8 +142,8 @@ export declare function RenderLifecycleMixin(): import("@jbrowse/mobx-state-tree
      * #getter
      * **The first-paint answer every consumer outside the display should
      * read**, `canvasDrawn` being only the raw flag: a display that is
-     * deliberately not painting a canvas has finished, and saying otherwise
-     * is a lie that never resolves.
+     * deliberately not painting a canvas has finished, and reporting it
+     * unfinished leaves every waiter on it waiting forever.
      *
      * The two `rendersCanvas: false` states each had three of their four
      * consumers wired by hand — the loading scrim (`rendersCanvas` /
@@ -151,10 +151,11 @@ export declare function RenderLifecycleMixin(): import("@jbrowse/mobx-state-tree
      * while the fourth, `data-display-drawn`, went on publishing `"false"`
      * forever off the raw flag. That attribute is what `PENDING_DISPLAYS`
      * (`@jbrowse/browser-test-utils`) selects on, so a zoomed-out reference
-     * sequence track made every `waitForDisplaysDone` on the page burn its
-     * full timeout — silently, since that wait swallows its own. Same shape
-     * as `fetchInert` on the comparative side: the reader you forget is the
-     * one outside the display, so the display has to publish one name for it.
+     * sequence track made every `waitForDisplaysDone` on the page run to its
+     * full timeout, and that wait swallows its own timeout without reporting
+     * it. `fetchInert` on the comparative side has the same problem: the
+     * forgotten reader is the one outside the display, so the display has to
+     * publish one name for it.
      *
      * `paintInert` is the third term and the same argument once more, for the
      * state where a display *would* paint a canvas and never gets to — a fetch

package/esm/RenderLifecycleMixin.js

@@ -164,8 +164,8 @@ export function RenderLifecycleMixin() {
          * #getter
          * **The first-paint answer every consumer outside the display should
          * read**, `canvasDrawn` being only the raw flag: a display that is
-         * deliberately not painting a canvas has finished, and saying otherwise
-         * is a lie that never resolves.
+         * deliberately not painting a canvas has finished, and reporting it
+         * unfinished leaves every waiter on it waiting forever.
          *
          * The two `rendersCanvas: false` states each had three of their four
          * consumers wired by hand — the loading scrim (`rendersCanvas` /
@@ -173,10 +173,11 @@ export function RenderLifecycleMixin() {
          * while the fourth, `data-display-drawn`, went on publishing `"false"`
          * forever off the raw flag. That attribute is what `PENDING_DISPLAYS`
          * (`@jbrowse/browser-test-utils`) selects on, so a zoomed-out reference
-         * sequence track made every `waitForDisplaysDone` on the page burn its
-         * full timeout — silently, since that wait swallows its own. Same shape
-         * as `fetchInert` on the comparative side: the reader you forget is the
-         * one outside the display, so the display has to publish one name for it.
+         * sequence track made every `waitForDisplaysDone` on the page run to its
+         * full timeout, and that wait swallows its own timeout without reporting
+         * it. `fetchInert` on the comparative side has the same problem: the
+         * forgotten reader is the one outside the display, so the display has to
+         * publish one name for it.
          *
          * `paintInert` is the third term and the same argument once more, for the
          * state where a display *would* paint a canvas and never gets to — a fetch

package/esm/canvas2dUtils.d.ts

@@ -109,7 +109,7 @@ export interface ClipContext2D {
  * Clip to one rect, paint, unclip — the `save`/`clip`/`restore` triple with the
  * `restore` in a `finally`.
  *
- * The `finally` is the whole point, and the cost of missing it is not local: an
+ * The `finally` is required, and missing it breaks more than the one frame: an
  * on-screen ctx outlives the frame and `prepareCanvas`'s setTransform/clearRect
  * do **not** reset clip state, so one painter throwing once leaves every later
  * frame drawing through a stale clip. A transient error becomes permanent
@@ -120,7 +120,7 @@ export interface ClipContext2D {
  * own. Reach for this one for the clips *nested inside* a block — a display
  * whose bands each own a horizontal strip of the canvas (alignments clips its
  * coverage, pileup and arc bands separately within one block clip), where the
- * nesting is what makes a hand-rolled pairing easy to get wrong: an early
+ * nesting makes a hand-rolled pairing easy to get wrong: an early
  * `return` inside the band body unbalances the block's `save` too.
  */
 export declare function withClip(ctx: ClipContext2D, x: number, y: number, w: number, h: number, paint: () => void): void;
@@ -229,8 +229,31 @@ export declare function spanRect(toX: (bp: number) => number, startBp: number, e
     width: number;
 };
 export declare function makeRampFillStyleLut(ramp: Uint8Array): (t: number) => string;
-export declare function bpToScreenPx(absBp: number, regionStart: number, regionEnd: number, screenStartPx: number, screenEndPx: number, reversed?: boolean): number;
+/**
+ * A block's bp→px projection as four numbers, for a placement function reading
+ * its block off a frame object. `makeBpMapper` closes over the same four.
+ */
+export interface BpProjection {
+    originPx: number;
+    startBp: number;
+    spanBp: number;
+    signedSpanPx: number;
+}
+export declare function bpProjection(bounds: BpRegionBounds): BpProjection;
+export declare function projectBp(p: BpProjection, bp: number): number;
+/**
+ * One closure literal for both orientations. Split per orientation, a paint
+ * loop's mapper call goes megamorphic on a view mixing them, and the loop ran
+ * 1.9-2.3x slower (`benches/bpMapper.bench.ts`).
+ */
 export declare function makeBpMapper(bounds: BpRegionBounds): (bp: number) => number;
+/**
+ * Screen px one base occupies in this region: the scale factor, unsigned, with
+ * the block's direction left to `makeBpMapper` and `spanLeft`. Shared so a mark
+ * sized against it in a draw pass and hit-tested against it in a component
+ * read one number.
+ */
+export declare function pxPerBpOf(bounds: BpRegionBounds): number;
 /**
  * Left edge of the **1bp cell** covering `bp` — for painters that fill a rect
  * per base (MAF alignment cells, the alignments pileup's mismatch /
@@ -255,18 +278,6 @@ export declare function makeBpMapper(bounds: BpRegionBounds): (bp: number) => nu
  * bp-scale; the pileup floors at 1px and adds a seam fudge). Only the pivot is
  * shared.
  */
-/**
- * Screen px one base occupies in this region — the scale factor, unsigned, with
- * the block's direction deliberately left out (that lives in `makeBpMapper` and
- * `spanLeft`, and folding it in here would make a *scale* carry an orientation).
- *
- * Shared because it is usually an input to something a second painter has to
- * reproduce exactly: a mark sized against it in a draw pass and hit-tested
- * against it in a component is two spellings of one number, and the hit target
- * silently stops covering the mark if they ever drift. Trivial arithmetic, but
- * the drift is not.
- */
-export declare function pxPerBpOf(bounds: BpRegionBounds): number;
 export declare function makeCellLeftMapper(bounds: BpRegionBounds): (bp: number) => number;
 /**
  * Fill the rect covering genomic `[startBp, endBp)`, given a bare
@@ -276,7 +287,7 @@ export declare function makeCellLeftMapper(bounds: BpRegionBounds): (bp: number)
  *
  * Prefer this to `makeCellLeftMapper` + a caller-computed width for anything
  * wider than one base. The pivot in `makeCellLeftMapper` is exactly one base,
- * which is right for a 1bp cell and silently wrong for an N-bp span — it
+ * which is right for a 1bp cell and wrong for an N-bp span — it
  * anchors the rect one base from the correct edge and then grows it the wrong
  * way. `fillBpSpan(bp, bp + 1)` is *identical* to the cell-mapper spelling, so
  * a per-base painter can use this too and never think about orientation again.
@@ -333,7 +344,7 @@ export declare function fillBpSpan(ctx: {
  * `14468.9936` — and rounding the *offset* and then adding such an anchor
  * returns the anchor's fraction untouched. The result is then not a base at
  * all, and every caller that indexes one by equality (a mismatch column, a
- * coverage bin, the sort-at-this-column anchor) misses silently: the pileup
+ * coverage bin, the sort-at-this-column anchor) finds no match: the pileup
  * offered no SNP submenu over a mismatch it was drawing. Rounding
  * `whole + fraction + offset` in one step instead fixes that and hands back the
  * genome-scale addend the paragraph above exists to keep out, so the whole base
@@ -395,3 +406,33 @@ export declare function regionAtPixel<R extends {
     screenStartPx: number;
     screenEndPx: number;
 }>(regions: readonly R[], px: number): R | undefined;
+/**
+ * CSS px a Canvas2D painter adds to the drawn width of a rect whose neighbours
+ * abut it. `fillRect` antialiases each edge on its own, so two rects meeting on
+ * a fractional column each take partial coverage of it and a hairline of
+ * background shows through; abutting GPU quads share an exact clip-space edge
+ * and the rasterizer fills it once, so a shader grows no matching pad.
+ */
+export declare const CANVAS_SEAM_PX = 0.8;
+export interface PathPaintContext {
+    beginPath(): void;
+    fill(): void;
+    stroke(): void;
+}
+/**
+ * One batched Canvas2D path of many shapes, painted in pieces a browser will
+ * rasterize. Opens a path on construction; call `add()` before appending each
+ * shape and `flush()` to paint what it holds and reopen.
+ */
+export declare class CappedPath {
+    private shapes;
+    private readonly ctx;
+    private readonly paint;
+    constructor(ctx: PathPaintContext, paint: 'fill' | 'stroke');
+    /**
+     * True when the path was full and has been painted and reopened, so a
+     * polyline must `moveTo` its pen again.
+     */
+    add(): boolean;
+    flush(): void;
+}

package/esm/canvas2dUtils.js

@@ -216,7 +216,7 @@ export function clipBlockForCanvas(block, canvasWidth) {
  * Clip to one rect, paint, unclip — the `save`/`clip`/`restore` triple with the
  * `restore` in a `finally`.
  *
- * The `finally` is the whole point, and the cost of missing it is not local: an
+ * The `finally` is required, and missing it breaks more than the one frame: an
  * on-screen ctx outlives the frame and `prepareCanvas`'s setTransform/clearRect
  * do **not** reset clip state, so one painter throwing once leaves every later
  * frame drawing through a stale clip. A transient error becomes permanent
@@ -227,7 +227,7 @@ export function clipBlockForCanvas(block, canvasWidth) {
  * own. Reach for this one for the clips *nested inside* a block — a display
  * whose bands each own a horizontal strip of the canvas (alignments clips its
  * coverage, pileup and arc bands separately within one block clip), where the
- * nesting is what makes a hand-rolled pairing easy to get wrong: an early
+ * nesting makes a hand-rolled pairing easy to get wrong: an early
  * `return` inside the band body unbalances the block's `save` too.
  */
 export function withClip(ctx, x, y, w, h, paint) {
@@ -386,21 +386,36 @@ export function makeRampFillStyleLut(ramp) {
         return s;
     };
 }
-export function bpToScreenPx(absBp, regionStart, regionEnd, screenStartPx, screenEndPx, reversed) {
-    const frac = (absBp - regionStart) / (regionEnd - regionStart);
+export function bpProjection(bounds) {
+    const { start, end, screenStartPx, screenEndPx, reversed } = bounds;
     const w = screenEndPx - screenStartPx;
-    return reversed ? screenEndPx - frac * w : screenStartPx + frac * w;
+    return {
+        originPx: reversed ? screenEndPx : screenStartPx,
+        startBp: start,
+        spanBp: end - start,
+        signedSpanPx: reversed ? -w : w,
+    };
+}
+export function projectBp(p, bp) {
+    return p.originPx + ((bp - p.startBp) / p.spanBp) * p.signedSpanPx;
 }
-// Closure-style bp→screen-px mapper bound to one region. Consumers that walk
-// many bp positions inside one block (label/peptide overlays, rect/line draws)
-// want a 1-arg call instead of repeating 6 args at every site.
+/**
+ * One closure literal for both orientations. Split per orientation, a paint
+ * loop's mapper call goes megamorphic on a view mixing them, and the loop ran
+ * 1.9-2.3x slower (`benches/bpMapper.bench.ts`).
+ */
 export function makeBpMapper(bounds) {
-    const { start, end, screenStartPx, screenEndPx, reversed } = bounds;
-    const span = end - start;
-    const w = screenEndPx - screenStartPx;
-    return reversed
-        ? (bp) => screenEndPx - ((bp - start) / span) * w
-        : (bp) => screenStartPx + ((bp - start) / span) * w;
+    const { originPx, startBp, spanBp, signedSpanPx } = bpProjection(bounds);
+    return (bp) => originPx + ((bp - startBp) / spanBp) * signedSpanPx;
+}
+/**
+ * Screen px one base occupies in this region: the scale factor, unsigned, with
+ * the block's direction left to `makeBpMapper` and `spanLeft`. Shared so a mark
+ * sized against it in a draw pass and hit-tested against it in a component
+ * read one number.
+ */
+export function pxPerBpOf(bounds) {
+    return ((bounds.screenEndPx - bounds.screenStartPx) / (bounds.end - bounds.start));
 }
 /**
  * Left edge of the **1bp cell** covering `bp` — for painters that fill a rect
@@ -426,20 +441,6 @@ export function makeBpMapper(bounds) {
  * bp-scale; the pileup floors at 1px and adds a seam fudge). Only the pivot is
  * shared.
  */
-/**
- * Screen px one base occupies in this region — the scale factor, unsigned, with
- * the block's direction deliberately left out (that lives in `makeBpMapper` and
- * `spanLeft`, and folding it in here would make a *scale* carry an orientation).
- *
- * Shared because it is usually an input to something a second painter has to
- * reproduce exactly: a mark sized against it in a draw pass and hit-tested
- * against it in a component is two spellings of one number, and the hit target
- * silently stops covering the mark if they ever drift. Trivial arithmetic, but
- * the drift is not.
- */
-export function pxPerBpOf(bounds) {
-    return ((bounds.screenEndPx - bounds.screenStartPx) / (bounds.end - bounds.start));
-}
 export function makeCellLeftMapper(bounds) {
     const toX = makeBpMapper(bounds);
     const pxPerBp = pxPerBpOf(bounds);
@@ -456,7 +457,7 @@ export function makeCellLeftMapper(bounds) {
  *
  * Prefer this to `makeCellLeftMapper` + a caller-computed width for anything
  * wider than one base. The pivot in `makeCellLeftMapper` is exactly one base,
- * which is right for a 1bp cell and silently wrong for an N-bp span — it
+ * which is right for a 1bp cell and wrong for an N-bp span — it
  * anchors the rect one base from the correct edge and then grows it the wrong
  * way. `fillBpSpan(bp, bp + 1)` is *identical* to the cell-mapper spelling, so
  * a per-base painter can use this too and never think about orientation again.
@@ -515,7 +516,7 @@ export function fillBpSpan(ctx, toX, startBp, endBp, top, height, seam = 0) {
  * `14468.9936` — and rounding the *offset* and then adding such an anchor
  * returns the anchor's fraction untouched. The result is then not a base at
  * all, and every caller that indexes one by equality (a mismatch column, a
- * coverage bin, the sort-at-this-column anchor) misses silently: the pileup
+ * coverage bin, the sort-at-this-column anchor) finds no match: the pileup
  * offered no SNP submenu over a mismatch it was drawing. Rounding
  * `whole + fraction + offset` in one step instead fixes that and hands back the
  * genome-scale addend the paragraph above exists to keep out, so the whole base
@@ -589,3 +590,54 @@ export function bpAtPxExact(px, bounds) {
 export function regionAtPixel(regions, px) {
     return regions.find(r => px >= r.screenStartPx && px < r.screenEndPx);
 }
+/**
+ * CSS px a Canvas2D painter adds to the drawn width of a rect whose neighbours
+ * abut it. `fillRect` antialiases each edge on its own, so two rects meeting on
+ * a fractional column each take partial coverage of it and a hairline of
+ * background shows through; abutting GPU quads share an exact clip-space edge
+ * and the rasterizer fills it once, so a shader grows no matching pad.
+ */
+export const CANVAS_SEAM_PX = 0.8;
+/**
+ * Shapes a `CappedPath` holds before it paints and reopens. Chrome's
+ * GPU-rasterized canvas, which is desktop Chrome with a GPU and headless Chrome
+ * with the GPU blocklist off, silently paints nothing for a path past about
+ * 16 MiB: 180,000 discs, 453,000 rects or 931,000 line segments.
+ * `pnpm check-canvas-path-limits` drives the painters past it in a real browser.
+ */
+const MAX_SHAPES_PER_PATH = 10_000;
+/**
+ * One batched Canvas2D path of many shapes, painted in pieces a browser will
+ * rasterize. Opens a path on construction; call `add()` before appending each
+ * shape and `flush()` to paint what it holds and reopen.
+ */
+export class CappedPath {
+    shapes = 0;
+    ctx;
+    paint;
+    constructor(ctx, paint) {
+        this.ctx = ctx;
+        this.paint = paint;
+        ctx.beginPath();
+    }
+    /**
+     * True when the path was full and has been painted and reopened, so a
+     * polyline must `moveTo` its pen again.
+     */
+    add() {
+        if (this.shapes === MAX_SHAPES_PER_PATH) {
+            this.flush();
+            this.shapes = 1;
+            return true;
+        }
+        this.shapes++;
+        return false;
+    }
+    flush() {
+        if (this.shapes > 0) {
+            this.ctx[this.paint]();
+            this.ctx.beginPath();
+            this.shapes = 0;
+        }
+    }
+}

package/esm/computePipeline.d.ts

@@ -1,4 +1,4 @@
-import type { ShaderBinding } from './hal/index.ts';
+import type { ShaderBinding, ShaderSource } from './hal/index.ts';
 export interface ComputePipelineState {
     device: GPUDevice;
     pipeline: GPUComputePipeline;
@@ -8,6 +8,7 @@ export interface ComputePipelineState {
 /**
  * One compute pipeline per kernel, built on first use against the current
  * device and rebuilt after a device loss. Concurrent first callers share the
- * one async build.
+ * one async build, which is also when the kernel's WGSL is loaded; a failed
+ * one is retried by the next caller rather than kept.
  */
-export declare function makeComputePipelineCache(code: string, entryPoint: string, bindings: readonly ShaderBinding[]): (device: GPUDevice) => Promise<ComputePipelineState>;
+export declare function makeComputePipelineCache(source: Pick<ShaderSource, 'wgsl'>, entryPoint: string, bindings: readonly ShaderBinding[]): (device: GPUDevice) => Promise<ComputePipelineState>;

package/esm/computePipeline.js

@@ -1,5 +1,6 @@
 /// <reference types="@webgpu/types" />
 import { onDeviceLost } from './gpuDevice.js';
+import { stageVisibility } from './webgpuUtils.js';
 // Built from the kernel's own reflected binding table rather than restated by
 // the caller, so a mismatch shows up as a validation failure at pipeline
 // creation rather than as a wrong buffer under a right-looking index.
@@ -12,7 +13,7 @@ function makeBindGroupLayout(device, bindings) {
             }
             return {
                 binding: b.index,
-                visibility: GPUShaderStage.COMPUTE,
+                visibility: stageVisibility(b.stages),
                 buffer: { type: b.kind },
             };
         }),
@@ -21,9 +22,10 @@ function makeBindGroupLayout(device, bindings) {
 /**
  * One compute pipeline per kernel, built on first use against the current
  * device and rebuilt after a device loss. Concurrent first callers share the
- * one async build.
+ * one async build, which is also when the kernel's WGSL is loaded; a failed
+ * one is retried by the next caller rather than kept.
  */
-export function makeComputePipelineCache(code, entryPoint, bindings) {
+export function makeComputePipelineCache(source, entryPoint, bindings) {
     let state = null;
     let statePromise = null;
     onDeviceLost(() => {
@@ -38,17 +40,22 @@ export function makeComputePipelineCache(code, entryPoint, bindings) {
             return statePromise;
         }
         statePromise = (async () => {
-            const module = device.createShaderModule({ code });
-            const bindGroupLayout = makeBindGroupLayout(device, bindings);
-            const pipeline = await device.createComputePipelineAsync({
-                layout: device.createPipelineLayout({
-                    bindGroupLayouts: [bindGroupLayout],
-                }),
-                compute: { module, entryPoint },
-            });
-            state = { device, pipeline, bindGroupLayout, bindings };
-            statePromise = null;
-            return state;
+            try {
+                const { WGSL_SOURCE } = await source.wgsl();
+                const module = device.createShaderModule({ code: WGSL_SOURCE });
+                const bindGroupLayout = makeBindGroupLayout(device, bindings);
+                const pipeline = await device.createComputePipelineAsync({
+                    layout: device.createPipelineLayout({
+                        bindGroupLayouts: [bindGroupLayout],
+                    }),
+                    compute: { module, entryPoint },
+                });
+                state = { device, pipeline, bindGroupLayout, bindings };
+                return state;
+            }
+            finally {
+                statePromise = null;
+            }
         })();
         return statePromise;
     };

package/esm/coverageBand.d.ts

@@ -80,7 +80,7 @@ export interface CoverageBandUniformValues {
     covHeight: number;
     covYOffset: number;
     covTop: number;
-    /** The region's own peak depth, which is what the buffers' `relDepth` is a fraction of. */
+    /** The region's peak depth; the buffers' `relDepth` is a fraction of it. */
     regionMaxDepth: number;
     /** The display's autoscaled depth domain. `undefined` max = not resolved yet. */
     domainMin: number;
@@ -98,8 +98,8 @@ export interface CoverageBandUniformValues {
  * Fill the coverage band's uniform buffer. Total-write (the generated packer),
  * so a field left out is a compile error rather than last frame's value.
  *
- * `hpZero` is derived here rather than at each call site because getting it
- * wrong is a silently wrong band, not a broken one: it MUST be 0, since the HP
+ * `hpZero` is derived here rather than at each call site because a wrong value
+ * draws a plausible but wrong band and raises no error: it MUST be 0, since the HP
  * math materializes +inf as `1/hpZero` to stop the compiler folding the hi/lo
  * split it exists to preserve.
  */

package/esm/coverageBand.js

@@ -69,8 +69,8 @@ export const COVERAGE_INDICATOR_PASS = {
  * Fill the coverage band's uniform buffer. Total-write (the generated packer),
  * so a field left out is a compile error rather than last frame's value.
  *
- * `hpZero` is derived here rather than at each call site because getting it
- * wrong is a silently wrong band, not a broken one: it MUST be 0, since the HP
+ * `hpZero` is derived here rather than at each call site because a wrong value
+ * draws a plausible but wrong band and raises no error: it MUST be 0, since the HP
  * math materializes +inf as `1/hpZero` to stop the compiler folding the hi/lo
  * split it exists to preserve.
  */

package/esm/coverageBandBuffers.d.ts

@@ -7,9 +7,8 @@
  *
  * Structural rather than nominal, and named after the layout rather than after
  * either display: the alignments worker's `CoverageUploadData` and the MAF
- * worker's `MafCoverageRegion` both satisfy it, which is what lets the passes
- * in `coverageBand.ts` carry their own packers instead of each plugin
- * restating four field reads.
+ * worker's `MafCoverageRegion` both satisfy it, so the passes in
+ * `coverageBand.ts` carry the packers and no plugin restates four field reads.
  *
  * Its own module, apart from the GPU passes in `coverageBand.ts`: a state
  * model reaching for just this shape has no reason to statically pull in

package/esm/createRenderingBackend.d.ts

@@ -19,7 +19,7 @@ export interface RenderingBackendOptions<TRenderingBackend> {
      * panel hold 109.7 MiB nothing counts (ARCHITECTURAL_LIMITS.md §"The MSAA
      * target is the largest per-display allocation"); 1 allocates none. Whether a
      * display's pixels survive the flip is a look-at-the-pixels decision taken
-     * one display at a time; `ideas/arc-antialiasing-without-msaa.md` is the
+     * one display at a time; `ideas/ready/arc-antialiasing-without-msaa.md` is the
      * survey and the captures.
      */
     sampleCount?: SampleCount;