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

package/esm/installUpload.js

@@ -1,5 +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';
 /**
@@ -29,7 +30,7 @@ function checkPayloads(self, cells) {
             }
             if (!named.has(key)) {
                 named.add(key);
-                console.error(`[jbrowse display contract] ${getType(self).name}: cell ${String(key)} ` +
+                reportContractViolation('display', `${getType(self).name}: cell ${String(key)} ` +
                     `handed to installUpload is \`${String(value)}\`. A fetch answers ` +
                     'a payload or nothing; leave the key out until it has one.');
             }
@@ -46,49 +47,20 @@ export function installUpload(self, backend, { cells, inputs, encode, render })
                 b.release(key);
             },
         });
-        if (!encode) {
-            const own = cells;
-            return {
-                upload: b => {
-                    const current = own();
-                    if (process.env.NODE_ENV !== 'production') {
-                        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 (process.env.NODE_ENV !== 'production') {
-                    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);
-                    }
+                if (contractReportsOn()) {
+                    checkPayloads(self, cells());
                 }
-                for (const key of encoded.keys()) {
-                    if (!current.has(key)) {
-                        encoded.delete(key);
-                        encodedFrom.delete(key);
-                    }
-                }
-                return sync(b, encoded);
+                return sync(b, own());
+            },
+            render: b => render(b, own()),
+            releaseTargets: b => {
+                b.releaseOffscreenTargets();
             },
-            render: b => render(b, encoded),
         };
     });
 }

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/instancePass.d.ts

@@ -5,7 +5,8 @@ import type { GpuHal, PipelineDescriptor } from './hal';
  * A pass id, the packer that fills its buffer, and the upload that joins them
  * are three statements of one fact, and renderers kept them in three places —
  * so a pass could be registered and drawn while nothing uploaded to it, which
- * paints nothing, silently, on the GPU backend only. Here they are one object:
+ * paints nothing, on the GPU backend only. `InstancePass`
+ * makes them one object:
  *
  * ```ts
  * export const GAP_PASS = {

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
@@ -17,8 +9,8 @@ export interface MapUploadTarget<K, T, B> {
  * re-uploads), and re-uploads everything when the backend identity changes —
  * a context-loss recovery hands a fresh backend with empty GPU buffers.
  *
- * Returns whether anything reached the backend, which is what lets the upload
- * autorun skip the redraw it would otherwise force after every run.
+ * Returns whether anything reached the backend, so the upload autorun can skip
+ * the redraw it would otherwise force after every run.
  *
  * For the skip to fire, the map must keep **stable references** for unchanged
  * entries across recomputes. With an always-fresh map every entry re-uploads,

package/esm/mapUploadSync.js

@@ -5,8 +5,8 @@
  * re-uploads), and re-uploads everything when the backend identity changes —
  * a context-loss recovery hands a fresh backend with empty GPU buffers.
  *
- * Returns whether anything reached the backend, which is what lets the upload
- * autorun skip the redraw it would otherwise force after every run.
+ * Returns whether anything reached the backend, so the upload autorun can skip
+ * the redraw it would otherwise force after every run.
  *
  * For the skip to fire, the map must keep **stable references** for unchanged
  * entries across recomputes. With an always-fresh map every entry re-uploads,
@@ -39,7 +39,6 @@ export function createMapUploadSync(target) {
                 changed = true;
             }
         }
-        target.prune?.(backend, new Set(entries.keys()));
         return changed;
     };
 }

package/esm/marks/barMark.d.ts

@@ -0,0 +1,30 @@
+import type { ColorChannel } from './markRamp.ts';
+import type { RowChannel, RowParams } from './rowLane.ts';
+import type { MarkColorScale, MarkShape } from './types.ts';
+import type { MarkValueScale } from './valueScale.ts';
+/**
+ * The `bar` shape's channels: a rectangle from `x` to `x2` standing between
+ * the baseline and `y` on the value scale, in the band of its `row`.
+ */
+export interface BarChannels extends ColorChannel, RowChannel {
+    x: Uint32Array;
+    x2: Uint32Array;
+    y: Float32Array;
+    count: number;
+}
+export interface BarParams extends RowParams, MarkValueScale {
+    /** The quantitative colour scale, for a bar whose colour is a ramp or a threshold. */
+    colorScale?: MarkColorScale;
+    /** The value bars grow from; a bar below it hangs down. */
+    origin: number;
+    /**
+     * Narrowest a bar is painted, in CSS px, grown off the start edge. Zero is
+     * a no-op for a caller whose bars tile.
+     */
+    minWidthPx: number;
+    /** CSS px the painter alone adds to the drawn width; see `SpanParams.seamPx`. */
+    seamPx: number;
+    /** CSS px each row's value scale runs over; the row's own height when absent. */
+    rowBandPx?: number;
+}
+export declare const barMark: MarkShape<BarChannels, BarParams>;

package/esm/marks/barMark.js

@@ -0,0 +1,149 @@
+import { bpRangeXTuple } from '../blockClipUtils.js';
+import { getDpr, makeBpMapper, spanLeft } from '../canvas2dUtils.js';
+import * as shader from '../shaders/barMark.generated.js';
+import { CLIP_STRIP_COLOR, CLIP_STRIP_PX, } from '../shaders/clipStrip.generated.js';
+import { clipSide } from '../shaders/clipStrip.js.generated.js';
+import { valueToYPxScaled } from '../shaders/pointMark.js.generated.js';
+import { rowBandTopPx } from '../shaders/rowTable.js.generated.js';
+import { slangPass } from '../slangPass.js';
+import { makeAbgrFill } from './colorFill.js';
+import { colorBits, paintColors, rampUniforms } from './markRamp.js';
+import { valueWindow } from './nearestMarkHit.js';
+import { bandHeightPx, rowColor, rowLane, rowSlot, rowTableKeys, rowTableTextures, } from './rowLane.js';
+import { valueScaleUniforms } from './valueScale.js';
+// Where a slot's value scale sits: its top and height, in the frame's CSS px.
+function barBand(params, canvasHeight, slot) {
+    const pitch = bandHeightPx(params, canvasHeight);
+    return {
+        top: rowBandTopPx(params.rowOffsetPx ?? 0, pitch, slot),
+        band: params.rowBandPx ?? pitch,
+    };
+}
+// Where the baseline sits inside a band, in CSS px below its top.
+function originYPx(params, band, { valueScaleType: st, valueSymlogConstant: c }) {
+    const [domainMin, domainMax] = params.domain;
+    return valueToYPxScaled(params.origin, domainMin, domainMax, band, st, c);
+}
+// The x span one instance paints, floored at `minWidthPx` off its start edge.
+function barSpan(bpToPx, x, x2, params) {
+    const xa = bpToPx(x);
+    const xb = bpToPx(x2);
+    const width = Math.max(params.minWidthPx, Math.abs(xb - xa));
+    return { left: spanLeft(xa, xb, width), width };
+}
+// The rect one instance paints, in the frame's CSS px, or undefined for a bar
+// with no height — which draws nothing and so cannot be hovered.
+function barRect(bpToPx, x, x2, y, bandTop, band, params, yScale) {
+    const { valueScaleType: st, valueSymlogConstant: c } = yScale;
+    const { left, width } = barSpan(bpToPx, x, x2, params);
+    const [domainMin, domainMax] = params.domain;
+    const valueY = bandTop + valueToYPxScaled(y, domainMin, domainMax, band, st, c);
+    const originY = bandTop + originYPx(params, band, yScale);
+    const top = Math.min(valueY, originY);
+    const height = Math.abs(valueY - originY);
+    return height === 0 ? undefined : { left, top, width, height };
+}
+// The clip strip's rect, or undefined for a bar the domain holds (ADR-183).
+function stripRect(bpToPx, x, x2, y, bandTop, band, params, yScale) {
+    const [domainMin, domainMax] = params.domain;
+    const side = clipSide(y, domainMin, domainMax, yScale.valueScaleType);
+    if (side === 0) {
+        return undefined;
+    }
+    const { left, width } = barSpan(bpToPx, x, x2, params);
+    return {
+        left,
+        top: side > 0 ? bandTop : bandTop + band - CLIP_STRIP_PX,
+        width,
+        height: CLIP_STRIP_PX,
+    };
+}
+export const barMark = {
+    id: 'bar',
+    pass: {
+        ...slangPass({ id: 'bar', mod: shader }),
+        pack: c => shader.packInstances({ ...c, color: colorBits(c, c.count), row: rowLane(c.row, c.count) }, c.count),
+    },
+    writeUniforms(scratch, clip, block, frame, params) {
+        const yScale = valueScaleUniforms(params);
+        const band = params.rowBandPx ?? bandHeightPx(params, frame.canvasHeight);
+        shader.writeUniforms(scratch, {
+            bpRangeX: bpRangeXTuple(clip, block.reversed),
+            canvasHeight: frame.canvasHeight,
+            domainMin: params.domain[0],
+            domainMax: params.domain[1],
+            ...yScale,
+            ...rampUniforms(params.colorScale),
+            originYPx: originYPx(params, band, yScale),
+            rowHeight: bandHeightPx(params, frame.canvasHeight),
+            rowBandPx: band,
+            rowOffsetPx: params.rowOffsetPx ?? 0,
+            zero: 0,
+            minCellDenomPx: clip.scissorW,
+            minWidthPx: params.minWidthPx,
+            devicePixelRatio: getDpr(),
+            rowTableKeys: rowTableKeys(params),
+        });
+    },
+    textures: rowTableTextures,
+    paintBlock(ctx, channels, block, frame, params) {
+        const { x, x2, y, row, count } = channels;
+        const color = paintColors(channels, count, params.colorScale);
+        const bpToPx = makeBpMapper(block);
+        const setFill = makeAbgrFill(ctx);
+        const yScale = valueScaleUniforms(params);
+        const table = params.rowTable;
+        const [domainMin, domainMax] = params.domain;
+        let clipped = false;
+        for (let i = 0; i < count; i++) {
+            const slot = rowSlot(row, i, table);
+            if (slot === undefined) {
+                continue;
+            }
+            const { top, band } = barBand(params, frame.canvasHeight, slot);
+            const r = barRect(bpToPx, x[i], x2[i], y[i], top, band, params, yScale);
+            if (r) {
+                setFill(rowColor(color[i], row, i, table));
+                ctx.fillRect(r.left, r.top, r.width + params.seamPx, r.height);
+            }
+            clipped ||=
+                clipSide(y[i], domainMin, domainMax, yScale.valueScaleType) !== 0;
+        }
+        if (!clipped) {
+            return;
+        }
+        // The strips go on after every bar, as the shader's second quad does, so
+        // a neighbour widened to the min-width floor cannot paint over one.
+        setFill(CLIP_STRIP_COLOR);
+        for (let i = 0; i < count; i++) {
+            const slot = rowSlot(row, i, table);
+            if (slot === undefined) {
+                continue;
+            }
+            const { top, band } = barBand(params, frame.canvasHeight, slot);
+            const s = stripRect(bpToPx, x[i], x2[i], y[i], top, band, params, yScale);
+            if (s) {
+                ctx.fillRect(s.left, s.top, s.width + params.seamPx, s.height);
+            }
+        }
+    },
+    ink(channels, block, frame, params, i) {
+        const { x, x2, y, row } = channels;
+        const slot = rowSlot(row, i, params.rowTable);
+        if (slot === undefined) {
+            return undefined;
+        }
+        // A bar cut to no height, its origin on the edge that cut it, paints only
+        // its strip, which is then what answers a hover.
+        const { top, band } = barBand(params, frame.canvasHeight, slot);
+        const bpToPx = makeBpMapper(block);
+        const yScale = valueScaleUniforms(params);
+        return (barRect(bpToPx, x[i], x2[i], y[i], top, band, params, yScale) ??
+            stripRect(bpToPx, x[i], x2[i], y[i], top, band, params, yScale));
+    },
+    valueWindow(yPx, radiusPx, frame, params) {
+        return params.rowBandPx === undefined
+            ? valueWindow(yPx, radiusPx, frame, { ...params, edgePx: CLIP_STRIP_PX })
+            : [-Infinity, Infinity];
+    },
+};

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,113 @@
+import type { RenderBlock } from '../renderBlock.ts';
+import type { Mark, MarkContext2D, MarkFrame } from './types.ts';
+export interface RecordedRect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    fillStyle: MarkContext2D['fillStyle'];
+}
+export declare function recordingContext(): {
+    ctx: {
+        fillStyle: string;
+        strokeStyle: string;
+        lineWidth: number;
+        lineCap: "butt";
+        lineJoin: "miter";
+        save(): void;
+        restore(): void;
+        translate(x: number, y: number): void;
+        scale(x: number, y: number): void;
+        rotate(angle: number): void;
+        beginPath(): void;
+        clip(): void;
+        setLineDash(_segments: number[]): void;
+        moveTo(x: number, y: number): void;
+        lineTo(x: number, y: number): void;
+        bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;
+        arc(x: number, y: number, radius: number, start?: number, end?: number): void;
+        ellipse(x: number, y: number, radiusX: number, radiusY: number, _rotation?: number, start?: number, end?: number): void;
+        closePath(): void;
+        fill(): void;
+        stroke(): void;
+        rect(x: number, y: number, w: number, h: number): void;
+        fillRect(x: number, y: number, w: number, h: number): void;
+        strokeRect(x: number, y: number, w: number, h: number): void;
+    };
+    calls: RecordedRect[];
+};
+/** The extent of a painting, in canvas px. */
+export interface Box {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+interface Counted {
+    count: number;
+}
+export interface SweepOptions<C> {
+    maxDistSq?: number;
+    step?: number;
+    sliceOne?: (channels: C, index: number) => C;
+    inkSlackPx?: number;
+    contains?: (index: number, xPx: number, yPx: number) => boolean;
+}
+/**
+ * The ink clause of {@link sweepMarkAgainstHit} alone, for a mark with no
+ * `hitNearest`: `boxes[i]` is what the painter recorded for instance `i`.
+ */
+export declare function inkViolations<C, S extends MarkFrame>(mark: Mark<C, S>, channels: C, block: RenderBlock, state: S, boxes: readonly (Box | undefined)[], inkSlackPx: number): string[];
+/**
+ * The draw-against-hit gate: paint the block, then walk it in `step` px and
+ * hold `hitNearest` to what the painter actually put on the canvas.
+ *
+ * **What the painter drew for instance `i` has to be attributed to `i`,** and
+ * there are two ways to get that. A mark whose every instance is one `fillRect`
+ * gets it positionally, which is the default and needs nothing. A mark that
+ * batches a colour run into one path (`point`'s glyphs), or that skips an
+ * instance the view has scrolled past (`cell`'s off-canvas rows), cannot be read
+ * that way at all — the batch has fewer rects than instances, or the wrong ones.
+ * `sliceOne` is the way in for those: hand back one instance's channels and the
+ * sweep paints it alone, so the attribution holds by construction and a culled
+ * instance is visibly an empty painting.
+ *
+ * Four claims, all of them one-directional and true of every mark:
+ *
+ * - an instance that painted nothing is never the answer,
+ * - `hit.x`/`hit.y` — where the mark says its ink is — lies inside the box the
+ *   painter drew for the instance the hit names,
+ * - `hit.distSq` is no smaller than the distance to that box, since the box
+ *   contains the ink and cannot be farther than it,
+ * - `hit.distSq` IS the distance to `hit.x`/`hit.y`, which is `MarkHit`'s own
+ *   contract rather than a fact about the painting: a mark that answers a
+ *   distance its own reported point does not support has two spellings of where
+ *   its ink is, and the nearest-wins walk is resolved by the one the caller
+ *   cannot see.
+ *
+ * The fifth is the containment rule: **a point the rule contains answers the
+ * nearest painted instance it contains**, the last-painted where tied, since the
+ * sweep hands candidates back to front. The default rule is the painted box, so
+ * a point on a box answers that box, and off every box a hit target wider than
+ * its ink may still answer. The default holds only where the box IS the hit
+ * target — every `fillRect` mark, and `cell`'s inversion triangle, which answers
+ * as its bounding box on purpose — and not for a glyph, whose box is a superset
+ * of its ink, so it runs exactly when the batch painted one rect per instance. A
+ * mark whose hit rule is not its box (the pileup's bp containment) passes
+ * `contains`, which is then the whole rule: the sweep covers the whole canvas,
+ * and a point the rule contains nowhere answers nothing.
+ *
+ * A mark declaring `ink` is held to one more clause, per instance: the box the
+ * painter recorded for `i` lies inside `ink(i)`, and each edge of `ink(i)` lies
+ * within `inkSlackPx` (default 1) of the painting's — so the rect is tight to
+ * the ink within a pixel on every side, which admits a seam overdraw or a pixel
+ * snap and rejects a rect that is the wrong row, the wrong width or the whole
+ * canvas. An instance that painted nothing must answer no ink, and one with ink
+ * must have painted.
+ *
+ * Returns the violations rather than asserting, so a test reads as
+ * `expect(sweep(...)).toEqual([])`. `maxDistSq` is the bound the hit test is
+ * asked with, `Infinity` unless the caller's differs.
+ */
+export declare function sweepMarkAgainstHit<C extends Counted, S extends MarkFrame>(mark: Mark<NoInfer<C>, S>, channels: C, block: RenderBlock, state: S, { maxDistSq, step, sliceOne, inkSlackPx, contains: rule, }?: SweepOptions<C>): string[];
+export {};