@msb235/blits 0.14.0 → 0.15.0

package/dist/gather.js

@@ -1,3 +1,4 @@
+import { inside, leave, meetBound } from './bound.js';
 import { foldNumber, lerpNumber } from './channels.js';
 import { shortWay, turnFrom, turnInto, turnToward } from './turns.js';
 /** `xs`, or a copy at least `n` long where it is shorter. */
@@ -9,12 +10,12 @@ function sized(xs, n) {
     return grown;
 }
 /**
- * Every member of a locus, in voice order, gathered rather than folded: a member's delta for a
+ * Every member of a role, in voice order, gathered rather than folded: a member's delta for a
  * subject is lerped into what the members before it left there by its share of the weight
- * taken, as the general path's `foldLocus` does, so each subject's locus can fold in at its
+ * taken, as the general path's `foldRole` does, so each subject's role can fold in at its
  * first member's place in the order.
  */
-export function gatherLocus(lanes, g) {
+export function gatherRole(lanes, g) {
     const cap = lanes.cap;
     if (g.met.length < cap) {
         g.met = sized(g.met, cap);
@@ -30,6 +31,9 @@ export function gatherLocus(lanes, g) {
         if (taken !== undefined)
             g.taken[k] = sized(taken, cap);
     }
+    g.inline = inlined(g);
+    if (g.inline)
+        return;
     lanes.into = g;
     try {
         for (const lane of g.members) {
@@ -40,10 +44,18 @@ export function gatherLocus(lanes, g) {
             lanes.reset(lane);
             lane.elapsedNow = voice.elapsedAt(lanes.now);
             const list = lane.list;
+            const b = voice.bound;
+            if (b !== null)
+                meetBound(lanes, b);
+            const fills = lanes.fills;
             for (let p = 0; p < list.length; p++) {
                 const slot = list[p];
+                if (b !== null && !inside(b, slot, fills)) {
+                    leave(lanes, lane, p, slot);
+                    continue;
+                }
                 if (lanes.one(lane, p, slot)) {
-                    meetLocus(lanes, g, slot);
+                    meetRole(lanes, g, slot);
                     g.sum[slot] =
                         g.sum[slot] + lane.data[p * 8 /* Row.STRIDE */ + 2 /* Row.WEIGHT */];
                 }
@@ -56,24 +68,47 @@ export function gatherLocus(lanes, g) {
         lanes.into = null;
     }
 }
-/** The first a fill hears of a subject in a locus: from the member now gathering. */
-function meetLocus(lanes, g, slot) {
+/** The first a fill hears of a subject in a role: from the member now gathering. */
+function meetRole(lanes, g, slot) {
     if (g.met[slot] === lanes.fills)
         return;
     g.met[slot] = lanes.fills;
     g.first[slot] = lanes.intoId;
     g.sum[slot] = 0;
-    for (const taken of g.taken)
+    const takens = g.taken;
+    for (let k = 0; k < takens.length; k++) {
+        const taken = takens[k];
         if (taken !== undefined)
             taken[slot] = 0;
+    }
+}
+/**
+ * `gatherInto` for a plain scalar channel and the number at `Arg.VALUE`, which as an argument
+ * would be boxed, 16 bytes a channel a member a subject (`role`, bench/allocs.mjs, 2026-10-25).
+ */
+function gatherScalar(lanes, g, ch, slot) {
+    const arg = lanes.arg;
+    const value = arg[7 /* Arg.VALUE */];
+    const values = g.values[ch.index];
+    const takenAt = g.taken[ch.index];
+    if (values === undefined || takenAt === undefined) {
+        gatherInto(lanes, g, ch, slot, value);
+        return;
+    }
+    const w = arg[0 /* Arg.WEIGHT */];
+    meetRole(lanes, g, slot);
+    const taken = takenAt[slot];
+    const total = taken + w;
+    values[slot] = taken === 0 ? value : lerpNumber(values[slot], value, w / total);
+    takenAt[slot] = total;
 }
 /**
- * A member's value for one channel of a subject, lerped into its locus: the step of the general
- * path's `foldLocus`.
+ * A member's value for one channel of a subject, lerped into its role: the step of the general
+ * path's `foldRole`.
  */
 function gatherInto(lanes, g, ch, slot, value) {
     const w = lanes.arg[0 /* Arg.WEIGHT */];
-    meetLocus(lanes, g, slot);
+    meetRole(lanes, g, slot);
     const k = ch.index;
     let values = g.values[k];
     let takenAt = g.taken[k];
@@ -86,7 +121,7 @@ function gatherInto(lanes, g, ch, slot, value) {
     const taken = takenAt[slot];
     const total = taken + w;
     const u = w / total;
-    if (!ch.plain)
+    if (!ch.plain || !ch.straight)
         turnToward(ch, values, slot * ch.axes, value, taken, u);
     else if (ch.scalar) {
         values[slot] =
@@ -103,8 +138,8 @@ function gatherInto(lanes, g, ch, slot, value) {
     }
     takenAt[slot] = total;
 }
-/** A locus member's turn in the order: each subject it was the first member of takes the locus. */
-export function foldLocus(lanes, lane, g) {
+/** A role member's turn in the order: each subject it was the first member of takes the role. */
+export function foldRole(lanes, lane, g) {
     const id = lane.voice.id;
     const fills = lanes.fills;
     const list = lane.list;
@@ -112,28 +147,100 @@ export function foldLocus(lanes, lane, g) {
         const slot = list[p];
         if (g.met[slot] !== fills || g.first[slot] !== id)
             continue;
-        const sum = g.sum[slot];
-        if (sum <= 0)
+        if (g.sum[slot] > 0)
+            foldAt(lanes, g, slot);
+    }
+}
+/** Folds what a role gathered for the subject at `slot` into its laned values. */
+function foldAt(lanes, g, slot) {
+    for (let k = 0; k < g.values.length; k++) {
+        const takenAt = g.taken[k];
+        const taken = takenAt === undefined ? 0 : takenAt[slot];
+        if (!(taken > 0))
             continue;
-        for (let k = 0; k < g.values.length; k++) {
-            const takenAt = g.taken[k];
-            const taken = takenAt === undefined ? 0 : takenAt[slot];
-            if (!(taken > 0))
-                continue;
-            // A channel folds at the weight of the members that wrote it, not the whole locus.
-            const w = taken > 1 ? 1 : taken;
-            const ch = lanes.laned[k];
-            const values = g.values[k];
-            const into = ch.values;
-            const base = slot * ch.axes;
-            if (!ch.plain) {
-                turnFrom(ch, into, base, values, base, w);
-                continue;
+        // A channel folds at the weight of the members that wrote it, not the whole role.
+        const w = taken > 1 ? 1 : taken;
+        const ch = lanes.laned[k];
+        const values = g.values[k];
+        const into = ch.values;
+        const base = slot * ch.axes;
+        if (!ch.plain) {
+            turnFrom(ch, into, base, values, base, w);
+            continue;
+        }
+        for (let a = 0; a < ch.axes; a++)
+            into[base + a] = foldNumber(ch.op, into[base + a], values[base + a], w);
+    }
+}
+/**
+ * Whether a fill can run a role a subject at a time: every member playing, on its lane, keeping
+ * no state, and over the same subjects in the same places, with no other voice between them.
+ */
+function inlined(g) {
+    if (!g.contiguous)
+        return false;
+    const members = g.members;
+    const list = members[0].list;
+    for (const lane of members) {
+        const voice = lane.voice;
+        if (lane.idle || voice.keeping || voice.state === 'pending' || voice.state === 'done')
+            return false;
+        const own = lane.list;
+        if (own === list)
+            continue;
+        if (own.length !== list.length)
+            return false;
+        for (let p = 0; p < list.length; p++)
+            if (own[p] !== list[p])
+                return false;
+    }
+    return true;
+}
+/**
+ * An inlined role at its first member's turn: each subject's members gathered in voice order, as
+ * `gatherRole` gathers them, then folded at once, with no pass of its own and no array of sums.
+ */
+export function runRole(lanes, g) {
+    const members = g.members;
+    const arg = lanes.arg;
+    for (const lane of members) {
+        lanes.reset(lane);
+        lane.elapsedNow = lane.voice.elapsedAt(lanes.now);
+        const b = lane.voice.bound;
+        if (b !== null)
+            meetBound(lanes, b);
+    }
+    const fills = lanes.fills;
+    const list = members[0].list;
+    lanes.into = g;
+    try {
+        for (let p = 0; p < list.length; p++) {
+            const slot = list[p];
+            let sum = 0;
+            for (let i = 0; i < members.length; i++) {
+                const lane = members[i];
+                // Its patch kept state on an earlier subject: as `gatherRole` leaves it after that call.
+                if (lane.voice.keeping)
+                    continue;
+                const b = lane.voice.bound;
+                if (b !== null && !inside(b, slot, fills)) {
+                    leave(lanes, lane, p, slot);
+                    continue;
+                }
+                // Each lane's placing is numbered on its own; the last member placed left its number.
+                arg[6 /* Arg.MARK */] = lane.mark;
+                if (lanes.one(lane, p, slot)) {
+                    meetRole(lanes, g, slot);
+                    sum += lane.data[p * 8 /* Row.STRIDE */ + 2 /* Row.WEIGHT */];
+                }
             }
-            for (let a = 0; a < ch.axes; a++)
-                into[base + a] = foldNumber(ch.op, into[base + a], values[base + a], w);
+            if (sum > 0)
+                foldAt(lanes, g, slot);
         }
     }
+    finally {
+        lanes.into = null;
+    }
 }
 /** For a keys voice: the delta's value for each channel it writes, read once per phase. */
 export function gather(lane, delta) {
@@ -161,9 +268,16 @@ export function foldDelta(chans, slot, delta) {
     let ch = chans[0];
     if (n > 0) {
         const v = delta[ch.name];
-        if (typeof v === 'number' && ch.scalar && ch.plain && this.into === null) {
-            const values = ch.values;
-            values[slot] = foldNumber(ch.op, values[slot], v, arg[0 /* Arg.WEIGHT */]);
+        if (typeof v === 'number' && ch.scalar && ch.plain) {
+            const into = this.into;
+            if (into === null) {
+                const values = ch.values;
+                values[slot] = foldNumber(ch.op, values[slot], v, arg[0 /* Arg.WEIGHT */]);
+            }
+            else {
+                arg[7 /* Arg.VALUE */] = v;
+                gatherScalar(this, into, ch, slot);
+            }
         }
         else
             this.foldInto(ch, slot, v);
@@ -171,9 +285,16 @@ export function foldDelta(chans, slot, delta) {
     ch = chans[1];
     if (n > 1) {
         const v = delta[ch.name];
-        if (typeof v === 'number' && ch.scalar && ch.plain && this.into === null) {
-            const values = ch.values;
-            values[slot] = foldNumber(ch.op, values[slot], v, arg[0 /* Arg.WEIGHT */]);
+        if (typeof v === 'number' && ch.scalar && ch.plain) {
+            const into = this.into;
+            if (into === null) {
+                const values = ch.values;
+                values[slot] = foldNumber(ch.op, values[slot], v, arg[0 /* Arg.WEIGHT */]);
+            }
+            else {
+                arg[7 /* Arg.VALUE */] = v;
+                gatherScalar(this, into, ch, slot);
+            }
         }
         else
             this.foldInto(ch, slot, v);
@@ -181,9 +302,16 @@ export function foldDelta(chans, slot, delta) {
     ch = chans[2];
     if (n > 2) {
         const v = delta[ch.name];
-        if (typeof v === 'number' && ch.scalar && ch.plain && this.into === null) {
-            const values = ch.values;
-            values[slot] = foldNumber(ch.op, values[slot], v, arg[0 /* Arg.WEIGHT */]);
+        if (typeof v === 'number' && ch.scalar && ch.plain) {
+            const into = this.into;
+            if (into === null) {
+                const values = ch.values;
+                values[slot] = foldNumber(ch.op, values[slot], v, arg[0 /* Arg.WEIGHT */]);
+            }
+            else {
+                arg[7 /* Arg.VALUE */] = v;
+                gatherScalar(this, into, ch, slot);
+            }
         }
         else
             this.foldInto(ch, slot, v);
@@ -191,9 +319,16 @@ export function foldDelta(chans, slot, delta) {
     for (let i = 3; i < n; i++) {
         ch = chans[i];
         const v = delta[ch.name];
-        if (typeof v === 'number' && ch.scalar && ch.plain && this.into === null) {
-            const values = ch.values;
-            values[slot] = foldNumber(ch.op, values[slot], v, arg[0 /* Arg.WEIGHT */]);
+        if (typeof v === 'number' && ch.scalar && ch.plain) {
+            const into = this.into;
+            if (into === null) {
+                const values = ch.values;
+                values[slot] = foldNumber(ch.op, values[slot], v, arg[0 /* Arg.WEIGHT */]);
+            }
+            else {
+                arg[7 /* Arg.VALUE */] = v;
+                gatherScalar(this, into, ch, slot);
+            }
         }
         else
             this.foldInto(ch, slot, v);
@@ -211,7 +346,7 @@ export function foldRun(ch, slot, xs) {
     for (let a = 0; a < ch.axes; a++)
         values[base + a] = foldNumber(ch.op, values[base + a], xs[a], w);
 }
-/** Folds one channel's value into a subject's laned values, or its locus, at `Arg.WEIGHT`. */
+/** Folds one channel's value into a subject's laned values, or its role, at `Arg.WEIGHT`. */
 export function foldInto(ch, slot, value) {
     if (value === undefined)
         return;

package/dist/gone.js

@@ -26,7 +26,7 @@ function add(ix, voice) {
         ix.general.push(voice);
         return;
     }
-    for (const subject of voice.named) {
+    for (const subject of voice.named.list) {
         const list = ix.named.get(subject);
         if (list === undefined)
             ix.named.set(subject, [voice]);
@@ -41,7 +41,7 @@ function remove(ix, out) {
             general = true;
             continue;
         }
-        for (const subject of v.named) {
+        for (const subject of v.named.list) {
             const named = ix.named.get(subject);
             if (named === undefined)
                 continue;

package/dist/grid.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Positions side by side, `x` then `y`, by place, and a uniform grid over them built again at the
+ * first query after they move, so a circle finds the places within it without visiting the rest.
+ */
+export declare class Grid {
+    xy: Float64Array;
+    /** How many places the list had. */
+    n: number;
+    /** The cell size asked for, NaN for one from the spread; the grid widens it where the positions are spread too thin. */
+    cell: number;
+    dirty: boolean;
+    /** The grid as last built: its origin, cell size and shape. */
+    x0: number;
+    y0: number;
+    size: number;
+    cols: number;
+    rows: number;
+    /** By cell, where its entries start in `order`, one past the last cell included. */
+    starts: Int32Array<ArrayBuffer>;
+    order: Int32Array<ArrayBuffer>;
+    /** By place, the cell the last build put it in, -1 for none. */
+    home: Int32Array<ArrayBuffer>;
+    /**
+     * Places `put` moved out of their cell since the last build, which every query tests on their own
+     * and skips in the cells, and by place whether it is one. Past a sixteenth of the places, the grid
+     * is built again.
+     */
+    strays: number[];
+    stray: Uint8Array<ArrayBuffer>;
+    /** What the last `query` or `ring` found, the first `count` of it. */
+    found: Int32Array<ArrayBuffer>;
+    count: number;
+    /** Moves place `i` to (`x`, `y`) in `xy`, leaving the grid as it is where the place keeps its cell. */
+    put(i: number, x: number, y: number): void;
+    private build;
+    private push;
+    /**
+     * Leaves in `found` the places within `r` of (`cx`, `cy`), by the test `inside` makes, `r2`
+     * being `r * r`: the cells the circle touches, and one more where an edge falls a hair from one.
+     */
+    query(cx: number, cy: number, r: number, r2: number): number;
+    /**
+     * Leaves in `found` the places beyond `r` of (`cx`, `cy`) and within a cell's width more, from
+     * the cells that ring touches.
+     */
+    ring(cx: number, cy: number, r: number): number;
+}

package/dist/grid.js

@@ -0,0 +1,247 @@
+/**
+ * Positions side by side, `x` then `y`, by place, and a uniform grid over them built again at the
+ * first query after they move, so a circle finds the places within it without visiting the rest.
+ */
+export class Grid {
+    xy = new Float64Array(0);
+    /** How many places the list had. */
+    n = 0;
+    /** The cell size asked for, NaN for one from the spread; the grid widens it where the positions are spread too thin. */
+    cell = Number.NaN;
+    dirty = true;
+    /** The grid as last built: its origin, cell size and shape. */
+    x0 = 0;
+    y0 = 0;
+    size = 1;
+    cols = 0;
+    rows = 0;
+    /** By cell, where its entries start in `order`, one past the last cell included. */
+    starts = new Int32Array(1);
+    order = new Int32Array(0);
+    /** By place, the cell the last build put it in, -1 for none. */
+    home = new Int32Array(0);
+    /**
+     * Places `put` moved out of their cell since the last build, which every query tests on their own
+     * and skips in the cells, and by place whether it is one. Past a sixteenth of the places, the grid
+     * is built again.
+     */
+    strays = [];
+    stray = new Uint8Array(0);
+    /** What the last `query` or `ring` found, the first `count` of it. */
+    found = new Int32Array(64);
+    count = 0;
+    /** Moves place `i` to (`x`, `y`) in `xy`, leaving the grid as it is where the place keeps its cell. */
+    put(i, x, y) {
+        this.xy[2 * i] = x;
+        this.xy[2 * i + 1] = y;
+        if (this.dirty)
+            return;
+        if (this.cols === 0 || i >= this.home.length) {
+            this.dirty = true;
+            return;
+        }
+        const col = Math.floor((x - this.x0) / this.size);
+        const row = Math.floor((y - this.y0) / this.size);
+        const c = col >= 0 && col < this.cols && row >= 0 && row < this.rows ? row * this.cols + col : -2;
+        if (c === this.home[i] || this.stray[i] === 1)
+            return;
+        this.stray[i] = 1;
+        this.strays.push(i);
+        if (this.strays.length > Math.max(32, this.n >> 4))
+            this.dirty = true;
+    }
+    build() {
+        this.dirty = false;
+        for (const i of this.strays)
+            this.stray[i] = 0;
+        this.strays.length = 0;
+        const xy = this.xy;
+        const n = Math.min(this.n, xy.length >> 1);
+        let x0 = Number.POSITIVE_INFINITY;
+        let y0 = Number.POSITIVE_INFINITY;
+        let x1 = Number.NEGATIVE_INFINITY;
+        let y1 = Number.NEGATIVE_INFINITY;
+        for (let i = 0; i < n; i++) {
+            const x = xy[2 * i];
+            const y = xy[2 * i + 1];
+            if (x < x0)
+                x0 = x;
+            if (x > x1)
+                x1 = x;
+            if (y < y0)
+                y0 = y;
+            if (y > y1)
+                y1 = y;
+        }
+        if (!(x1 >= x0) || !(y1 >= y0)) {
+            this.cols = 0;
+            this.rows = 0;
+            return;
+        }
+        // Unasked, about two subjects a cell where they are spread evenly.
+        let size = Number.isNaN(this.cell)
+            ? Math.sqrt((2 * Math.max(x1 - x0, 1e-9) * Math.max(y1 - y0, 1e-9)) / n)
+            : this.cell;
+        // At most about four cells a subject: a few far-flung positions would otherwise ask for millions.
+        const most = 4 * n + 64;
+        if ((Math.floor((x1 - x0) / size) + 1) * (Math.floor((y1 - y0) / size) + 1) > most)
+            size = Math.max(size, Math.sqrt(((x1 - x0) * (y1 - y0)) / n), (x1 - x0 + y1 - y0) / most);
+        const cols = Math.floor((x1 - x0) / size) + 1;
+        const rows = Math.floor((y1 - y0) / size) + 1;
+        this.x0 = x0;
+        this.y0 = y0;
+        this.size = size;
+        this.cols = cols;
+        this.rows = rows;
+        const cells = cols * rows;
+        if (this.starts.length < cells + 1)
+            this.starts = new Int32Array(cells + 1);
+        else
+            this.starts.fill(0, 0, cells + 1);
+        if (this.order.length < n)
+            this.order = new Int32Array(n);
+        if (this.home.length < n) {
+            this.home = new Int32Array(n);
+            this.stray = new Uint8Array(n);
+        }
+        const starts = this.starts;
+        const order = this.order;
+        // A position that is not a number is in no cell, and no circle finds it.
+        for (let i = 0; i < n; i++) {
+            const c = cellOf(xy, i, x0, y0, size, cols);
+            this.home[i] = c;
+            if (c >= 0)
+                starts[c + 1] = starts[c + 1] + 1;
+        }
+        for (let c = 0; c < cells; c++)
+            starts[c + 1] = starts[c + 1] + starts[c];
+        const placed = starts[cells];
+        // Filled from each cell's end back to its start: `starts[c + 1]`, the end of cell c, ends at its start.
+        for (let i = n - 1; i >= 0; i--) {
+            const c = cellOf(xy, i, x0, y0, size, cols);
+            if (c < 0)
+                continue;
+            const k = starts[c + 1] - 1;
+            starts[c + 1] = k;
+            order[k] = i;
+        }
+        for (let c = 0; c < cells; c++)
+            starts[c] = starts[c + 1];
+        starts[cells] = placed;
+    }
+    push(i, count) {
+        if (count === this.found.length) {
+            const grown = new Int32Array(this.found.length * 2);
+            grown.set(this.found);
+            this.found = grown;
+        }
+        this.found[count] = i;
+        return count + 1;
+    }
+    /**
+     * Leaves in `found` the places within `r` of (`cx`, `cy`), by the test `inside` makes, `r2`
+     * being `r * r`: the cells the circle touches, and one more where an edge falls a hair from one.
+     */
+    query(cx, cy, r, r2) {
+        if (this.dirty)
+            this.build();
+        this.count = 0;
+        if (this.cols === 0 || !(r >= 0))
+            return 0;
+        const size = this.size;
+        const c0 = Math.max(0, edge((cx - r - this.x0) / size, -1));
+        const c1 = Math.min(this.cols - 1, edge((cx + r - this.x0) / size, 1));
+        const r0 = Math.max(0, edge((cy - r - this.y0) / size, -1));
+        const r1 = Math.min(this.rows - 1, edge((cy + r - this.y0) / size, 1));
+        const xy = this.xy;
+        const order = this.order;
+        const starts = this.starts;
+        const any = this.strays.length > 0;
+        let count = 0;
+        for (let row = r0; row <= r1 && c0 <= c1; row++) {
+            const from = starts[row * this.cols + c0];
+            const to = starts[row * this.cols + c1 + 1];
+            for (let k = from; k < to; k++) {
+                const i = order[k];
+                if (any && this.stray[i] === 1)
+                    continue;
+                const dx = xy[2 * i] - cx;
+                const dy = xy[2 * i + 1] - cy;
+                if (dx * dx + dy * dy <= r2)
+                    count = this.push(i, count);
+            }
+        }
+        for (const i of this.strays) {
+            const dx = xy[2 * i] - cx;
+            const dy = xy[2 * i + 1] - cy;
+            if (dx * dx + dy * dy <= r2)
+                count = this.push(i, count);
+        }
+        this.count = count;
+        return count;
+    }
+    /**
+     * Leaves in `found` the places beyond `r` of (`cx`, `cy`) and within a cell's width more, from
+     * the cells that ring touches.
+     */
+    ring(cx, cy, r) {
+        if (this.dirty)
+            this.build();
+        this.count = 0;
+        if (this.cols === 0 || !(r >= 0))
+            return 0;
+        const size = this.size;
+        const out = r + size;
+        const r2 = r * r;
+        const out2 = out * out;
+        const c0 = Math.max(0, Math.floor((cx - out - this.x0) / size));
+        const c1 = Math.min(this.cols - 1, Math.floor((cx + out - this.x0) / size));
+        const r0 = Math.max(0, Math.floor((cy - out - this.y0) / size));
+        const r1 = Math.min(this.rows - 1, Math.floor((cy + out - this.y0) / size));
+        const xy = this.xy;
+        let count = 0;
+        for (let row = r0; row <= r1; row++)
+            for (let col = c0; col <= c1; col++) {
+                // A cell wholly inside the circle holds nothing beyond it.
+                const ax = this.x0 + col * size - cx;
+                const ay = this.y0 + row * size - cy;
+                const far = Math.max(ax * ax, (ax + size) ** 2) + Math.max(ay * ay, (ay + size) ** 2);
+                if (far <= r2)
+                    continue;
+                const c = row * this.cols + col;
+                for (let k = this.starts[c]; k < this.starts[c + 1]; k++) {
+                    const i = this.order[k];
+                    if (this.stray[i] === 1)
+                        continue;
+                    const dx = xy[2 * i] - cx;
+                    const dy = xy[2 * i + 1] - cy;
+                    const d2 = dx * dx + dy * dy;
+                    if (d2 > r2 && d2 <= out2)
+                        count = this.push(i, count);
+                }
+            }
+        for (const i of this.strays) {
+            const dx = xy[2 * i] - cx;
+            const dy = xy[2 * i + 1] - cy;
+            const d2 = dx * dx + dy * dy;
+            if (d2 > r2 && d2 <= out2)
+                count = this.push(i, count);
+        }
+        this.count = count;
+        return count;
+    }
+}
+function cellOf(xy, i, x0, y0, size, cols) {
+    const x = xy[2 * i];
+    const y = xy[2 * i + 1];
+    if (!(x >= x0) || !(y >= y0))
+        return -1;
+    return Math.floor((x - x0) / size) + Math.floor((y - y0) / size) * cols;
+}
+/** The cell index `u` falls in, one further out toward `side` where it lies within 1e-6 of an edge. */
+function edge(u, side) {
+    const c = Math.floor(u);
+    if (side < 0)
+        return u - c < 1e-6 ? c - 1 : c;
+    return c + 1 - u < 1e-6 ? c + 1 : c;
+}

package/dist/handle.d.ts

@@ -23,6 +23,8 @@ export interface HandleHost<I, O> {
      * it, on the handle it is given: `h`, or a read ahead's handle on its copy of the voice.
      */
     record(h: VoiceHandle<I, O>, label: string, again: (h: VoiceHandle<I, O>) => void): void;
+    /** Whether `record` keeps a write made now, so a handle can skip making one it would drop. */
+    taping(): boolean;
 }
 /** Refuses a voice rate no clock can run at. */
 export declare function finiteRate(rate: number): void;