@msb235/blits 0.15.1 → 0.16.1

package/dist/color.js

@@ -1,4 +1,6 @@
-import { lerpNumber, numericOf, sum, vec, vouch, widen } from './channels.js';
+import { doubles, lerpNumber, numericOf, sum, vec, vouch, widen } from './channels.js';
+import { HUES, lchPair, shortWay } from './lch.js';
+import { warnOnce } from './warn.js';
 const mix = lerpNumber;
 const LINEAR = Array.from({ length: 256 }, (_, c) => {
     const v = c / 255;
@@ -25,8 +27,6 @@ const toByte = (v) => {
     const c = FIRST[(v * BINS) | 0];
     return c < 255 && v >= ROUNDS_UP[c + 1] ? c + 1 : c;
 };
-/** Below this chroma a color is gray and its hue is noise, so the lerp takes the other end's. */
-const GRAY = 1e-4;
 /**
  * Colors already turned into OKLCH, direct-mapped on a byte of their hash: a mix reads the same
  * few keyframe colors every frame, and the table stays 256 colors however many it meets.
@@ -104,46 +104,107 @@ export function mixHex(a, b, u) {
 }
 /** The hue `u` of the way from `ah` to `bh` the short way round, a gray end taking the other's. */
 function hueAt(ah, ac, bh, bc, u) {
-    const from = ac < GRAY ? bh : ah;
-    const to = bc < GRAY ? ah : bh;
-    let turn = to - from;
-    if (turn > Math.PI)
-        turn -= 2 * Math.PI;
-    else if (turn < -Math.PI)
-        turn += 2 * Math.PI;
-    return from + turn * u;
+    shortWay(ah, ac, bh, bc);
+    return HUES[0] + HUES[1] * u;
 }
+const LERP = {};
+const PAIR = new Float64Array(8);
 /** Two OKLab colors with coverage, interpolated in OKLCH: color by `u`, coverage by `u` alongside. */
 function lerpLch(x, y, u) {
-    const xw = x[3] ?? 0;
-    const yw = y[3] ?? 0;
-    const w = mix(xw, yw, u);
-    // A color with no coverage has none of its own to keep, so the lerp takes the other end's.
-    const ys = yw > 0 ? 1 / yw : 0;
-    const yL = (y[0] ?? 0) * ys;
-    const yA = (y[1] ?? 0) * ys;
-    const yB = (y[2] ?? 0) * ys;
-    const xs = xw > 0 ? 1 / xw : 0;
-    const xL = xw > 0 ? (x[0] ?? 0) * xs : yL;
-    const xA = xw > 0 ? (x[1] ?? 0) * xs : yA;
-    const xB = xw > 0 ? (x[2] ?? 0) * xs : yB;
-    const toL = yw > 0 ? yL : xL;
-    const toA = yw > 0 ? yA : xA;
-    const toB = yw > 0 ? yB : xB;
-    const xc = Math.sqrt(xA * xA + xB * xB);
-    const yc = Math.sqrt(toA * toA + toB * toB);
-    const C = mix(xc, yc, u);
-    const h = hueAt(Math.atan2(xB, xA), xc, Math.atan2(toB, toA), yc, u);
-    return [mix(xL, toL, u) * w, C * Math.cos(h) * w, C * Math.sin(h) * w, w];
+    const p = PAIR;
+    lchPair(x, 0, y, 0, p);
+    const w = mix(p[3], p[7], u);
+    const C = mix(p[1], p[5], u);
+    const h = p[2] + HUES[1] * u;
+    return [mix(p[0], p[4], u) * w, C * Math.cos(h) * w, C * Math.sin(h) * w, w];
+}
+/** Below this, an ink pose's summed `(a, b)` has canceled out and shows no hue. */
+const CANCEL = 1e-9;
+/**
+ * A color value, `oklab()`'s four numbers or ink's five, into `out` at `o` as `[L, C, h, w]`, its
+ * coverage divided out. Five numbers show their own chroma, the fourth, at the hue of their `(a, b)`.
+ */
+function lchOf(v, out, o) {
+    const five = v.length > 4;
+    const w = (five ? v[4] : v[3]) ?? 0;
+    const s = w > 0 ? 1 / w : 0;
+    const a = (v[1] ?? 0) * s;
+    const b = (v[2] ?? 0) * s;
+    const r = Math.sqrt(a * a + b * b);
+    out[o] = (v[0] ?? 0) * s;
+    out[o + 1] = !five ? r : r < CANCEL ? 0 : (v[3] ?? 0) * s;
+    out[o + 2] = Math.atan2(b, a);
+    out[o + 3] = w;
+}
+/** A color value as ink's five numbers, `[w·L, w·a, w·b, w·C, w]` times `k`, into `out`. */
+function inked(v, k, out) {
+    const a = v[1] ?? 0;
+    const b = v[2] ?? 0;
+    const five = v.length > 4;
+    out[0] = (v[0] ?? 0) * k;
+    out[1] = a * k;
+    out[2] = b * k;
+    out[3] = (five ? (v[3] ?? 0) : Math.sqrt(a * a + b * b)) * k;
+    out[4] = ((five ? v[4] : v[3]) ?? 0) * k;
+    return out;
+}
+/** Two colors, four numbers or five, interpolated round the hue into ink's five. */
+function lerpInk(x, y, u) {
+    if (u === 0)
+        return inked(x, 1, doubles(5, 0));
+    if (u === 1)
+        return inked(y, 1, doubles(5, 0));
+    const p = PAIR;
+    lchOf(x, p, 0);
+    lchOf(y, p, 4);
+    // A color with no coverage has none of its own to keep, so it takes the other end's.
+    const from = p[3] > 0 ? 0 : 4;
+    const to = p[7] > 0 ? 4 : 0;
+    const xc = p[from + 1];
+    const yc = p[to + 1];
+    shortWay(p[from + 2], xc, p[to + 2], yc);
+    const w = mix(p[3], p[7], u);
+    const Cw = mix(xc, yc, u) * w;
+    const h = HUES[0] + HUES[1] * u;
+    return [
+        mix(p[from], p[to], u) * w,
+        Math.cos(h) * Cw,
+        Math.sin(h) * Cw,
+        Cw,
+        w,
+    ];
+}
+/**
+ * Whether `channel` travels round the hue, as `ink` does, so a motion patch cued on it moves round
+ * the hue too.
+ */
+export function roundsHue(channel) {
+    const lerp = channel.lerp;
+    return lerp === lerpLch || lerp === lerpInk;
+}
+/** Whether `of` asks a color channel to average: absent, or a stock `sum` with no turn or bounds. */
+function averages(of) {
+    if (of === undefined)
+        return true;
+    const stock = numericOf(of);
+    return stock?.op === 'sum' && stock.turn === undefined && of.bounds === undefined;
+}
+const refuse = (name, of) => new Error(`${name} takes sum() to average or last() to replace, not ${of.kind ?? 'a channel of its own'}`);
+/** A `last` color channel, which replaces and travels by `lerp`. */
+function replacing(kind, lerp) {
+    const channel = { kind, merge: (_a, b) => b, lerp };
+    widen(channel, 4);
+    vouch(channel, { op: 'last', axes: 4 });
+    return channel;
 }
 export function color(ofOrOpts, maybe) {
     const of = ofOrOpts !== undefined && 'merge' in ofOrOpts ? ofOrOpts : undefined;
     const opts = of === undefined ? ofOrOpts : maybe;
+    if (opts?.lerp !== undefined)
+        warnOnce(LERP, "color({ lerp }) is deprecated: 'oklch' is ink(), which also blends overlapping voices round the hue, and 'oklab' is color()");
     const round = opts?.lerp === 'oklch';
     const space = round ? ', oklch' : '';
-    const stock = of === undefined ? undefined : numericOf(of);
-    if (of === undefined ||
-        (stock?.op === 'sum' && stock.turn === undefined && of.bounds === undefined)) {
+    if (averages(of)) {
         const channel = vec(4, sum());
         channel.kind = `color(sum${space})`;
         if (!round)
@@ -152,20 +213,59 @@ export function color(ofOrOpts, maybe) {
         vouch(turning, { op: 'own', axes: 4, folds: 'sum' });
         return turning;
     }
-    if (of.kind === 'last') {
-        const channel = {
-            kind: `color(last${space})`,
-            merge: (_a, b) => b,
-            lerp: round ? lerpLch : vec(4, sum()).lerp,
-        };
-        widen(channel, 4);
-        vouch(channel, { op: 'last', axes: 4 });
-        return channel;
+    const own = of;
+    if (own.kind === 'last')
+        return replacing(`color(last${space})`, round ? lerpLch : vec(4, sum()).lerp);
+    throw refuse('color', own);
+}
+/** Where `ink`'s merge and fold widen a contribution, which neither keeps. */
+const WIDE = doubles(5, 0);
+/**
+ * Color standing for a meaning, a status, a level or a team, rather than for a physical
+ * phenomenon: choose it over `color` when the colors are symbols. People picture the midpoint
+ * between red and blue as purple, reached by turning the hue, not as the grayed mix light makes,
+ * and `ink` gives them that. It travels round the hue the short way, in a motion, between keys
+ * and in a role's handoff, and `ink()` blends overlapping voices round the hue too: each voice
+ * sums as `[w·L, w·a, w·b, w·C, w]`, C its chroma, so a pose shows lightness `ΣwL/Σw`, the hue of
+ * `Σw·(a, b)`, which a gray voice pulls on not at all, and chroma `ΣwC/Σw`, so two vivid colors
+ * stay vivid. Near-opposite hues overlapping swing round the wheel as their weights cross, with
+ * no tiebreak, and exactly opposite ones cancel to gray. A patch writes it the `oklab()` values a
+ * `color` takes, and `toHex` and `css` read either. `ink(last())` replaces, traveling round the
+ * hue, and holds the four numbers it was written, since it never sums.
+ *
+ * @category channel
+ */
+export function ink(of) {
+    if (!averages(of)) {
+        const own = of;
+        if (own.kind === 'last')
+            return replacing('ink(last)', lerpLch);
+        throw refuse('ink', own);
     }
-    throw new Error(`color takes sum() to average or last() to replace, not ${of.kind ?? 'a channel of its own'}`);
+    const channel = {
+        kind: 'ink(sum)',
+        rest: doubles(5, 0),
+        merge: (x, y) => {
+            const out = inked(x, 1, doubles(5, 0));
+            const add = inked(y, 1, WIDE);
+            for (let i = 0; i < 5; i++)
+                out[i] = out[i] + add[i];
+            return out;
+        },
+        scale: (v, w) => inked(v, w, doubles(5, 0)),
+        fold: (into, v, w) => {
+            const add = inked(v, w, WIDE);
+            for (let i = 0; i < 5; i++)
+                into[i] = (into[i] ?? 0) + add[i];
+            return into;
+        },
+        lerp: lerpInk,
+    };
+    vouch(channel, { op: 'own', axes: 5 });
+    return channel;
 }
 /**
- * Converts 0xrrggbb to a `color` value. The value is OKLab `[L, a, b]` at full coverage. Convert
+ * Converts 0xrrggbb to a `color` or `ink` value. The value is OKLab `[L, a, b]` at full coverage. Convert
  * keyframe stops once when authoring them, and call it outside the hot path in an `fn` patch.
  *
  * @category channel
@@ -174,36 +274,64 @@ export function oklab(rgb) {
     lab(rgb);
     return [LAB[0], LAB[1], LAB[2], 1];
 }
+/** The color the last `shows` call read, `[L, a, b]` with its coverage divided out. */
+const SHOWN = [0, 0, 0];
+/**
+ * A `color` pose's or an `ink` pose's color into `SHOWN`, returning its coverage. Ink's shows the
+ * hue of its `(a, b)` at the chroma its fourth number holds, and gray where `(a, b)` cancels.
+ */
+function shows(pose) {
+    if (pose.length <= 4) {
+        const w = pose[3] ?? 0;
+        if (!(w > 0))
+            return w;
+        const s = 1 / w;
+        SHOWN[0] = (pose[0] ?? 0) * s;
+        SHOWN[1] = (pose[1] ?? 0) * s;
+        SHOWN[2] = (pose[2] ?? 0) * s;
+        return w;
+    }
+    const w = pose[4] ?? 0;
+    if (!(w > 0))
+        return w;
+    const s = 1 / w;
+    const a = (pose[1] ?? 0) * s;
+    const b = (pose[2] ?? 0) * s;
+    const r = Math.sqrt(a * a + b * b);
+    const k = r < CANCEL ? 0 : ((pose[3] ?? 0) * s) / r;
+    SHOWN[0] = (pose[0] ?? 0) * s;
+    SHOWN[1] = a * k;
+    SHOWN[2] = b * k;
+    return w;
+}
 /**
- * A `color` pose as 0xrrggbb, laid over `under`. Its color is divided out of its coverage, the
- * coverage capped at 1 and laid over `under` in OKLab, then clipped to sRGB per channel. No
- * coverage gives `under`.
+ * A `color` or `ink` pose as 0xrrggbb, laid over `under`. Its color is divided out of its
+ * coverage, the coverage capped at 1 and laid over `under` in OKLab, then clipped to sRGB per
+ * channel. No coverage gives `under`.
  *
  * @category channel
  */
 export function toHex(pose, under = 0x000000) {
-    const w = pose[3] ?? 0;
+    const w = shows(pose);
     if (!(w > 0))
         return under;
-    const s = 1 / w;
-    const L = (pose[0] ?? 0) * s;
-    const A = (pose[1] ?? 0) * s;
-    const B = (pose[2] ?? 0) * s;
+    const L = SHOWN[0];
+    const A = SHOWN[1];
+    const B = SHOWN[2];
     if (w >= 1)
         return fromLab(L, A, B);
     lab(under);
     return fromLab(mix(LAB[0], L, w), mix(LAB[1], A, w), mix(LAB[2], B, w));
 }
 /**
- * A `color` pose as a CSS `oklab()` color, its coverage as the alpha. The coverage is capped at 1.
- * For a host that lets the browser lay it over what is under it.
+ * A `color` or `ink` pose as a CSS `oklab()` color, its coverage as the alpha. The coverage is
+ * capped at 1. For a host that lets the browser lay it over what is under it.
  *
  * @category channel
  */
 export function css(pose) {
-    const w = pose[3] ?? 0;
+    const w = shows(pose);
     if (!(w > 0))
         return 'oklab(0 0 0 / 0)';
-    const s = 1 / w;
-    return `oklab(${(pose[0] ?? 0) * s} ${(pose[1] ?? 0) * s} ${(pose[2] ?? 0) * s} / ${w < 1 ? w : 1})`;
+    return `oklab(${SHOWN[0]} ${SHOWN[1]} ${SHOWN[2]} / ${w < 1 ? w : 1})`;
 }

package/dist/columns.d.ts

@@ -1,15 +1,5 @@
 import type { Lanes } from './lanes.js';
-/** One channel `pull` writes: where in the kit, how many numbers a subject, and its rest. */
-export interface Column {
-    key: string;
-    slot: number;
-    axes: number;
-    out: Float64Array;
-    /** The rest, clamped, or NaN for a channel with none. */
-    rest: Float64Array;
-    bounds: readonly [number, number] | undefined;
-}
-export declare function clampRun(out: Float64Array, at: number, n: number, [lo, hi]: readonly [number, number]): void;
+import { type Column } from './pull.js';
 /**
  * For a `pull` of a list it read last time in the same order, with every voice on a lane, where
  * each position's remembered chain head was current when the mix's `relinks` read `since`: what

package/dist/columns.js

@@ -1,9 +1,4 @@
-export function clampRun(out, at, n, [lo, hi]) {
-    for (let i = at; i < at + n; i++) {
-        const x = out[i];
-        out[i] = x < lo ? lo : x > hi ? hi : x;
-    }
-}
+import { clampRun } from './pull.js';
 /**
  * For a `pull` of a list it read last time in the same order, with every voice on a lane, where
  * each position's remembered chain head was current when the mix's `relinks` read `since`: what

package/dist/contribution.js

@@ -41,6 +41,7 @@ function sentBack(mix, voice, held) {
 function phaseOf(elapsed, duration, passes) {
     return elapsed < 0 ? phaseBefore(elapsed, duration) : phaseAt(elapsed, duration, passes);
 }
+const NOTHING = Object.freeze({});
 /**
  * One live voice's delta for one subject this frame, through its record for the subject, or null
  * when it does not reach. Its weight is left in `w`.
@@ -139,9 +140,11 @@ export function contribution(voice, subject, now, held) {
             own(voice, held);
     }
     let delta = null;
-    // A keys voice in a role reads at weight 0 too: having a delta makes it a member, and the
-    // role folds at its first member's place.
+    // A voice in a role is a member at weight 0 too, and the role folds at its first member's
+    // place. A keys member reads; any other is not asked, and contributes nothing.
+    let member = false;
     if (silent(voice, weight) && (voice.built === null || voice.spec.role === undefined)) {
+        member = voice.spec.role !== undefined;
         // A `from: 'current'` voice takes its base on its first read, silent or not.
         if (voice.built && voice.spec.from === 'current' && held.base === undefined) {
             held.base = this.baseFor(voice, subject);
@@ -168,8 +171,12 @@ export function contribution(voice, subject, now, held) {
         remember(this, voice, subject, held);
     if (reading.kept !== keptBefore && !voice.keeping)
         stateful(this, voice);
-    if (delta === null)
-        return null;
+    if (delta === null) {
+        if (!member)
+            return null;
+        this.w = weight;
+        return NOTHING;
+    }
     if (voice.out?.rest && this.isRest(delta)) {
         held.weight = 0;
         held.restedAt = now;

package/dist/crowd.d.ts

@@ -6,12 +6,6 @@ import type { Motions } from './motions.js';
 import type { Scratch } from './patch.js';
 import type { Subject } from './subject.js';
 import type { Voice } from './voice.js';
-/**
- * Whether a laned voice belongs in a crowd: one naming a single subject, which shares nothing
- * across subjects for a lane to save. A motion voice writes one channel; a keys or fn voice may
- * write several, and joins the crowd of voices writing those same channels.
- */
-export declare function crowdable<I, O>(v: Voice<I, O>): boolean;
 /** The law of a row that has none, a keys or fn voice's. */
 export declare const none: Float64Array<ArrayBuffer>;
 /** Per row of a crowd's `hot`: what the fill reads of the row's voice and its current stretch. */

package/dist/crowd.js

@@ -4,17 +4,6 @@ import { closed } from './closed.js';
 import { KeyRows } from './keyrows.js';
 import { keepProbed, SPARSE } from './lane.js';
 import { move } from './sample.js';
-/**
- * Whether a laned voice belongs in a crowd: one naming a single subject, which shares nothing
- * across subjects for a lane to save. A motion voice writes one channel; a keys or fn voice may
- * write several, and joins the crowd of voices writing those same channels.
- */
-export function crowdable(v) {
-    return (v.named !== null &&
-        v.named.size === 1 &&
-        v.spec.role === undefined &&
-        (v.slots.length === 1 || v.motion === undefined));
-}
 /** The law of a row that has none, a keys or fn voice's. */
 export const none = new Float64Array(0);
 /** Whether a row's flags let `bareRows` take it. */

package/dist/cue.js

@@ -3,8 +3,8 @@ import { checkHits } from './book.js';
 import { bind, checkWithin } from './bound.js';
 import { changed } from './chain.js';
 import { copyable } from './clone.js';
+import { roundsHue } from './color.js';
 import { schedule } from './due.js';
-import { shares } from './everyone.js';
 import { finiteRate, plainWeight, VoiceHandle } from './handle.js';
 import { begin } from './held.js';
 import { handle } from './hosts.js';
@@ -52,6 +52,7 @@ export function cue(mix, given) {
                             ? Number.POSITIVE_INFINITY
                             : mix.now;
     const voice = new Voice(mix.nextId++, spec, patch, spec.fade ?? noFade, local, start, mix.slotOf, mix.channels, mix.opts.host, mix.send, owner);
+    voice.offset = mix.offset;
     if (patch === ownerPatch && mix.fitting !== null)
         voice.fitting = mix.fitting;
     if (patch === ownerPatch && mix.arcing !== null) {
@@ -62,7 +63,10 @@ export function cue(mix, given) {
         checkChild(spec, voice);
     if (mix.pace !== null && owner === null && spec.start !== undefined && voice.state === 'pending')
         voice.pinned = spec.start - mix.offset;
-    if (start === Number.POSITIVE_INFINITY && !anchored && !owner?.fitting) {
+    if (start === Number.POSITIVE_INFINITY &&
+        !anchored &&
+        !owner?.fitting &&
+        Number.isNaN(voice.pinned)) {
         voice.waking = true;
         mix.waking = true;
     }
@@ -158,11 +162,14 @@ export function playable(mix, spec) {
     const motion = motionOf(patch);
     if (motion !== undefined) {
         const channel = patch.writes[0];
-        const rest = mix.kit[channel].rest;
+        const ch = mix.kit[channel];
+        const rest = ch.rest;
         if (typeof rest === 'number')
             motion.cuedOn(String(channel), true);
         else if (Array.isArray(rest) || ArrayBuffer.isView(rest))
-            motion.cuedOn(String(channel), false);
+            motion.cuedOn(String(channel), false, roundsHue(ch));
+        else if (roundsHue(ch))
+            motion.cuedOn(String(channel), false, true);
     }
     if (patch.reads) {
         const host = mix.opts.host;
@@ -177,10 +184,13 @@ export function playable(mix, spec) {
     if (spec.as !== undefined && mix.transport.pager !== null && !mix.opts.history?.revive)
         throw new Error('blits: a voice cued with as needs history.revive to rebuild it from');
 }
-/** A voice parked by a seek, cued again as the mix plays past its cue, on the handle it had. */
+/**
+ * A voice parked by a seek, cued again as the mix plays past its cue, on the handle it had. A span's
+ * child waits for the fit its cue makes again, as it did when first cued: its start is the last fit's.
+ */
 function recue(mix, voice) {
     const owner = voice.owner;
-    if ((owner === null ? mix.now : ownerReading(owner, mix.now)) >= voice.start)
+    if (!owner?.fitting && (owner === null ? mix.now : ownerReading(owner, mix.now)) >= voice.start)
         voice.state = 'live';
     enter(mix, voice);
 }
@@ -231,6 +241,8 @@ function enter(mix, voice) {
         voice.cuedAt = mix.now;
         voice.cuedSeq = mix.transport.seq;
         voice.opened = mix.now;
+        if (voice.state !== 'pending')
+            voice.begunSeq = mix.transport.seq;
     }
     voice.placing = anchored;
     // A start the host gave by its own clock, where the mix's rate puts it.
@@ -250,7 +262,7 @@ function enter(mix, voice) {
         i--;
     cued.splice(i, 0, voice);
     scoredAdd(mix, voice);
-    voice.sharing = shares(mix, voice);
+    voice.sharing = mix.share?.shares(mix, voice) === true;
     enlist(mix, voice);
     changed(mix, voice);
     mix.stir();

package/dist/due.d.ts

@@ -7,6 +7,17 @@ import type { Voice } from './voice.js';
  */
 export declare class DueQueue<I, O> {
     size: number;
+    /**
+     * The entries due every frame, -Infinity, kept out of the heap in the order they came: an owned
+     * voice is filed so each frame, and sifting each to the top and off again cost more than its visit.
+     */
+    private every;
+    private everyTokens;
+    /** The list `takeEvery` last handed out, and its tokens: the next one fills it again. */
+    private spare;
+    private spareTokens;
+    /** Whether the list `takeEvery` last handed out was in id order. */
+    everySorted: boolean;
     private at;
     private tokens;
     private voices;
@@ -15,6 +26,11 @@ export declare class DueQueue<I, O> {
     push(at: number, voice: Voice<I, O>, token: number): void;
     /** The earliest entry's time, Infinity while empty. */
     first(): number;
+    /**
+     * The current entries due every frame, in the order they came, leaving none; `everySorted` says
+     * whether that was id order. The list is the queue's own, good until the next call.
+     */
+    takeEvery(): Voice<I, O>[];
     /** Takes off the earliest entry, giving its voice where it is current and undefined where stale. */
     pop(): Voice<I, O> | undefined;
     clear(): void;
@@ -22,6 +38,8 @@ export declare class DueQueue<I, O> {
     /** Puts an entry in the hole at `i` and sifts it down to where it belongs. */
     private sink;
     private grow;
+    /** Drops the entries due every frame made stale by a later one. */
+    private pruneEvery;
     /** Drops the entries made stale by a later one and heapifies what is left. */
     private prune;
 }

package/dist/due.js

@@ -5,12 +5,30 @@
  */
 export class DueQueue {
     size = 0;
+    /**
+     * The entries due every frame, -Infinity, kept out of the heap in the order they came: an owned
+     * voice is filed so each frame, and sifting each to the top and off again cost more than its visit.
+     */
+    every = [];
+    everyTokens = [];
+    /** The list `takeEvery` last handed out, and its tokens: the next one fills it again. */
+    spare = [];
+    spareTokens = [];
+    /** Whether the list `takeEvery` last handed out was in id order. */
+    everySorted = true;
     at = new Float64Array(64);
     tokens = new Float64Array(64);
     voices = [];
     /** The size past which stale entries are pruned, so a voice rescheduled often cannot grow it. */
     limit = 64;
     push(at, voice, token) {
+        if (at === Number.NEGATIVE_INFINITY) {
+            if (this.every.length >= this.limit)
+                this.pruneEvery();
+            this.every.push(voice);
+            this.everyTokens.push(token);
+            return;
+        }
         if (this.size >= this.limit)
             this.prune();
         if (this.size === this.at.length)
@@ -30,8 +48,41 @@ export class DueQueue {
     }
     /** The earliest entry's time, Infinity while empty. */
     first() {
+        if (this.every.length > 0)
+            return Number.NEGATIVE_INFINITY;
         return this.size > 0 ? this.at[0] : Number.POSITIVE_INFINITY;
     }
+    /**
+     * The current entries due every frame, in the order they came, leaving none; `everySorted` says
+     * whether that was id order. The list is the queue's own, good until the next call.
+     */
+    takeEvery() {
+        const every = this.every;
+        const tokens = this.everyTokens;
+        let n = 0;
+        let sorted = true;
+        let last = Number.NEGATIVE_INFINITY;
+        for (let i = 0; i < every.length; i++) {
+            const voice = every[i];
+            if (tokens[i] !== voice.dueToken || voice.state === 'done')
+                continue;
+            // A voice filed twice keeps its last entry, so it is taken once.
+            voice.dueToken++;
+            if (voice.id < last)
+                sorted = false;
+            last = voice.id;
+            every[n++] = voice;
+        }
+        every.length = n;
+        tokens.length = 0;
+        this.spare.length = 0;
+        this.every = this.spare;
+        this.everyTokens = this.spareTokens;
+        this.spare = every;
+        this.spareTokens = tokens;
+        this.everySorted = sorted;
+        return every;
+    }
     /** Takes off the earliest entry, giving its voice where it is current and undefined where stale. */
     pop() {
         const voice = this.voices[0];
@@ -44,6 +95,10 @@ export class DueQueue {
     }
     clear() {
         this.size = 0;
+        this.every.length = 0;
+        this.everyTokens.length = 0;
+        this.spare.length = 0;
+        this.spareTokens.length = 0;
         this.voices = [];
         this.limit = 64;
     }
@@ -84,6 +139,22 @@ export class DueQueue {
         tokens.set(this.tokens);
         this.tokens = tokens;
     }
+    /** Drops the entries due every frame made stale by a later one. */
+    pruneEvery() {
+        const every = this.every;
+        const tokens = this.everyTokens;
+        let n = 0;
+        for (let i = 0; i < every.length; i++) {
+            const voice = every[i];
+            if (tokens[i] !== voice.dueToken)
+                continue;
+            every[n] = voice;
+            tokens[n++] = tokens[i];
+        }
+        every.length = n;
+        tokens.length = n;
+        this.limit = Math.max(this.limit, 2 * n);
+    }
     /** Drops the entries made stale by a later one and heapifies what is left. */
     prune() {
         let n = 0;
@@ -169,7 +240,9 @@ export function schedule(mix, voice) {
 /** Takes every current entry due by `now` off the queue, in cue order. */
 export function popDue(mix, now) {
     const queue = mix.due;
-    const out = [];
+    const out = queue.takeEvery();
+    const sorted = queue.everySorted;
+    const every = out.length;
     while (queue.first() <= now) {
         const voice = queue.pop();
         if (voice === undefined)
@@ -177,7 +250,33 @@ export function popDue(mix, now) {
         voice.dueToken++;
         out.push(voice);
     }
-    return byId(out);
+    if (every === 0 || !sorted)
+        return byId(out);
+    return every === out.length ? out : merged(out, every);
+}
+/** `list` in id order, its first `n` already so and the rest few: those sorted, then merged in. */
+function merged(list, n) {
+    const rest = byId(list.slice(n));
+    const out = [];
+    let i = 0;
+    let k = 0;
+    while (i < n && k < rest.length) {
+        const a = list[i];
+        const b = rest[k];
+        if (b.id < a.id) {
+            out.push(b);
+            k++;
+        }
+        else {
+            out.push(a);
+            i++;
+        }
+    }
+    while (i < n)
+        out.push(list[i++]);
+    while (k < rest.length)
+        out.push(rest[k++]);
+    return out;
 }
 /** Past this many voices the built-in sort, which makes working arrays however few it is given. */
 const SHORT = 8;