@msb235/blits 0.16.0 → 0.16.1

package/CHANGELOG.md

@@ -4,6 +4,155 @@ This package follows [semver](https://semver.org). Below 1.0.0, a breaking chang
 version and everything else the patch. Each release lists its changes as **Breaking**, **Added** and
 **Fixed**, and the release workflow refuses a tag with no section here.
 
+## 0.16.1
+
+### Fixed
+
+- A child anchored to a sibling under an owner at rate 0 plays where its anchor puts it when the
+  owner is sought forward past both. Its anchor's time went through mix time on a clock standing
+  still, which maps every time it has passed to the seek's moment, so the child was placed at the
+  time sought plus its offset and never played.
+- `inert` reads false while a motion voice has a subject it met inside its `stagger` and has not
+  read since, which moves once it is probed. It read true, so a host that stops on `inert` stopped
+  a subject that had yet to start.
+- A span's child whose cue a seek back plays again waits for the span's fit, as it did when first
+  cued, so the span lays it out as before. It started at once wherever its span's clock had passed
+  the start the fit first gave it: the fit then took it for ended, so it skipped nothing else, or,
+  in a span running back, the child ran back to its start and left.
+- A child its owner's seek put back before its start stays where it was through a mix sought back to
+  after that seek: a later fit keeps it in its place, and an anchor does not place it again. The
+  seek took it for one still to start, so a span laid it out afresh, and a child anchored to a
+  sibling's end was placed again from that end, and played on as if its owner had not been sought.
+- A voice cued while the mix is paused, its `start` a host time still ahead, waits for that time
+  again when a seek back plays its cue again. It started at once, at the paused mix time, since
+  the voice was taken for one cued while the mix slept and its start was moved to the next sync.
+- A span whose budget runs out between two frames fits again from that moment, in turn with its
+  siblings' starts and ends: a child it places at a start already passed starts in that frame, and
+  one queued after it starts where it lapsed at any frame rate. The span lapsed only after the
+  frame had started its siblings, so a sibling whose old start the frame passed kept it, and one
+  placed in the past waited a frame to start.
+- An owner running back holds a child placed where its clock stands unplayed, whether or not a
+  frame lands there. An owner cued backward with a child at 0 started that child, ended it, and
+  left with it only when a frame fell exactly on the owner's start; otherwise both waited for good.
+- A read ahead that throws partway, on a call the tape holds that it cannot play, puts the tape
+  back. It left the live tape moved past the call, so a later seek restored the wrong state.
+- Under `history`, a voice faded out of one subject is let go when history lets it go. The mix
+  held every such voice for good, and each `drop` walked them all.
+- What `prepare` loads is let go once `history.ms` of mix time passes without a seek or read
+  taking it. Until one did, the mix kept every record paged since, for good.
+- `trace` of a voice sought past its end, with a `fade.out`, follows the fade from the voice's
+  start, where the mix runs it. It called the run exact and read 0 throughout.
+- `weightOf` with lanes on reports the weight a subject was given when its voice moved onto a lane
+  after the subject's probe that frame. It reported 0.
+- A `pull` right after two or more cues folds the new voices in voice order, as a probe does. It
+  folded them newest first, which on a `mul` or `sum` channel could differ in the last bit.
+- An owner's fade in counts from when the owner started, under an owner turned back or slowed.
+  It was worked out again each frame from where the outer owner's clock would next reach the
+  inner owner's start, so a clip under an inner owner with a fade in vanished when the outer
+  owner turned back, and slowing the outer owner jumped the fade to its end.
+- A fade set for now or earlier, on a voice whose owner runs back, begins then. It was put off to
+  when the owner's clock would come back to the voice's start, playing at full weight until then.
+- A fade in stands still while a fade out runs, and climbs on from there after `rise`, rather than
+  jumping to where its clock had reached. A subject's own fade out stops its fade in climbing too,
+  as the voice's does; before, the two multiplied into a rise.
+- A span child with `faster` or `slower` at `Infinity` is retimed to fill its span. It got a rate
+  of Infinity, jumping to its end, or 0, and was skipped as never fitting.
+- A `from: 'current'` voice whose stop lists fewer axes than its `vec` channel reads the missing
+  axes as the lerp does. They read NaN.
+- `spring` and `glide` throw for an infinite parameter. A glide with an infinite `ms` or
+  `stiffness` read NaN, and a spring with infinite `damping` or `mass` jumped to its target.
+- A role member at weight 0 holds its role's place whatever its patch's form, and a band switched
+  off by a frame at weight 0 stays off when the weight comes back between `off` and `on`. A `keys`
+  member at weight 0 was read and so held the role's place; any other was not, so its role folded
+  at the next member's place, which on a `last` channel changed which value won, and the role's
+  band, along with every band in a mix with a role in it, survived the frame at 0.
+- A frame with span children in it costs less than before this release's span-order fixes, which
+  had made it about 5% dearer: a child's visit reads its owners' clocks once, and the voices
+  visited every frame, which include every voice an owner holds, are kept in a list of their own
+  rather than sifted through the due queue's heap and sorted each frame. The new `spans` bench row,
+  ten staggered clips cued under one owner every four frames, reads 5.0% faster than with the
+  fixes (0.141 to 0.134 ms a frame) and 3.4% faster than before them (0.179 to 0.173 on another
+  node), 7 rounds each, U 7.
+- A voice an owner holds, first read while the owner runs back, shows at once instead of waiting
+  on its fade in. The fade in counted from where the owner's clock, running back, would next reach
+  the voice's start, a time still to come, so the voice read nothing until then.
+- An owner sought forward passes the span children it crosses as played straight through,
+  whatever its rate: they start and end in order, and their span fits from each end. Sought ahead
+  while turned back, it started them in the order its clock running back put their starts, last
+  first, and ended none; turning forward later ended them all at once, out of order, and a span
+  holding spans left in a later frame at a time still to come, so a mix sought back left it
+  fading and its clips silent. A timeline's reel jumped ahead in reverse played its scenes slowed
+  and overlapping.
+- A span child kept quiet at its start, its owner having run back to it, comes back and ends in
+  turn when a seek of the owner takes it past its end, and its span fits from that end. It stayed
+  quiet, so the children playing past it kept the rate they had before its end.
+- Under `history`, an owner another owner holds no longer leaves once none of its children plays:
+  it stays with its own owner, quiet, so turning the outer owner back brings back a clip under an
+  owner inside it, as it does a direct child.
+- A span an owner ran back over keeps the layout it made going forward. Before, each child it ran
+  back to the start of fitted the span again from there, and so did a seek back into it, counting
+  the children waiting for the clock to come back as playing: the ones still to start moved
+  earlier, and the playing ones changed speed.
+- A span lays out its children the same at any frame rate. When a child ended between two frames,
+  its span fitted again from that moment, and a sibling whose start had passed by then, but which
+  no frame had started yet, was placed again from there at a new start and rate: two children of a
+  `stagger` span read 420 stepped every 10 ms and 389.47 every 25 ms.
+- A voice under an owner whose rate ramps through 0 (from forward to back) ends where its passes
+  run out while the owner still runs forward. The time was taken as never, so it ended at the
+  frame that noticed, and a span holding it fitted again from there, its layout following the
+  frame rate.
+- A placement whose names make a loop is taken where no mark in it waits on itself: a cue whose
+  `out` is its follow's `start`, the follow starting off the cue's `coast`, was refused as waiting
+  on itself, since the check followed every name whatever mark it asked for. A voice's `start`,
+  `in`, `coast` and the marks placed inside it wait only on what places its start; its `out` and
+  `end` on that and what places its out.
+- A placement that waits on itself through a query by tag or by channel is refused at `cue`, as
+  one through names is: a voice starting after the one tagged `b`, cued beside one tagged `b`
+  starting after the one tagged `a`, was taken. A query is followed to the voices it can pick at
+  the cue, the voice being cued among them.
+- A voice no owner holds, placed by a timestamp in its anchor, stays where it was placed through a
+  seek back. Each placing read the timestamp against the mix's offset at that moment, which a seek
+  moves, so after `seek(1000)` from 2100 an owner anchored to start at 2000 had started at 900, and
+  one anchored to end at 4000 left at 0. The timestamp is now read against the offset in force when
+  the voice was cued, as a plain `start` is.
+- Under `history`, a span an owner holds no longer leaves once its budget is out and none of its
+  children plays: it stays with its owner, quiet, so turning the owner back brings back a clip
+  under a span, or under a span in a span, as it does one under an owner.
+- A child cued into a span an owner ran back over queues after the children it holds. The span
+  was fitted again at the cue, counting the children waiting for the clock to come back as
+  playing, so the new one started beside them. No fit, from a cue, an arc, a sibling leaving or a
+  seek, moves a span run back over until the clock passes it again.
+- A child whose rate a fit changed reads, run back over by an owner, what it read going forward. Its
+  clock read the new rate all the way back past where the fit changed it; it now runs back on the
+  clock it had before, and forward again the fit changes it at the same place.
+- An owner sought past a span's child fits the rest of the span from where that child ended. The
+  owner's clock now put the end before the mix began, where a span read its own clock as 0, so the
+  children still to come were laid out from the span's start: a timeline's reel jumped into its
+  fifth sequence started the third scene beside the second.
+- A span whose children end in one frame fits from each end in the order they came. They were
+  taken in cue order, so an end the frame noticed first could be one that a fit from an earlier
+  end would have moved, and two children of a `stagger` span read 509.5 stepped every 50 ms where
+  1 ms steps read 525.3.
+- A child a fit skipped reads, once its owner is sought or run back before the skip, what it read
+  going forward. One skipped while playing kept its jump to its end and read on from there, and
+  one skipped before it started, placed at its end at its start, played its passes backward from
+  its start.
+- A span child its owner ran or was sought back over takes the change a fit made to it again as
+  the owner's clock comes forward to it, as the layout made going forward stands. The span was
+  fitted again there instead, with the children it had skipped counted as still playing or left
+  out, so the ones it had skipped together with them played on, slowed, beside them.
+- An owner sought past a span lays the span out in that frame as played straight through. Its
+  children that started and ended in the frame were taken in cue order once their span had started,
+  each started and ended in one step, so a fit from one end missed the children it should have
+  moved.
+- A span its owner was sought back before keeps the layout it made going forward, as one run
+  back over does. A child's end there fitted it again with the children ahead, left quiet by the
+  seek, counted as gone, so the playing ones slowed to fill the span.
+- A mix sought back into a span plays on as it stood at that moment. A seek fitted every span
+  again from the moment sought, which a span played straight through is not, so its children's
+  rates followed where the seek landed. A span's end and `result` are now kept with its history and
+  put back by the seek.
+
 ## 0.16.0
 
 ### Added

package/README.md

@@ -151,7 +151,7 @@ do yet.
 
 ## Status
 
-v0.16.0, with five consumers. magicsmoke runs every fault on it, wod its wheel, tricks and
+v0.16.1, with five consumers. magicsmoke runs every fault on it, wod its wheel, tricks and
 transitions, weasel its animator's tweens, sherpa its seams, and
 [klieg](https://github.com/orochi235/klieg) composes all three of its systems — letter motion,
 part effects, and the environment a sign is lit by — on a mix each.

package/dist/ahead.js

@@ -20,13 +20,12 @@ import { unreached } from './unreached.js';
 export function playAhead(transport, c, copies, t, earlier) {
     const tape = transport.tape;
     const depth = tape?.undoDepth() ?? 0;
-    let played = false;
     try {
         for (;;) {
             const e = nextEvent(tape, c, t);
             if (!(e < t))
                 break;
-            played = playTo(transport, c, copies, e) || played;
+            playTo(transport, c, copies, e);
             if (!carries(c))
                 continue;
             // Placed now, as the next move would place them, while a target that has just left is here.
@@ -49,11 +48,12 @@ export function playAhead(transport, c, copies, t, earlier) {
             }
             c = next;
         }
-        played = playTo(transport, c, copies, t) || played;
+        playTo(transport, c, copies, t);
     }
     finally {
-        if (played)
-            tape?.goto(depth);
+        // A call that throws partway has moved the tape already, so this asks the tape, not `playTo`.
+        if (tape !== undefined && tape.undoDepth() !== depth)
+            tape.goto(depth);
     }
     return c;
 }
@@ -108,14 +108,13 @@ function nextEvent(tape, c, t) {
 }
 /**
  * Makes the calls the tape holds up to mix time `to` on a read ahead's copies and moves them
- * there. Answers whether it moved the tape.
+ * there.
  */
 function playTo(transport, c, copies, to) {
     const tape = transport.tape;
     const due = (at) => (c.pace === null ? at : c.pace.reading(at)) <= to;
     const next = tape?.timestampAt(tape.undoDepth());
     c.u = hostAhead(c, to);
-    let played = false;
     if (next !== undefined && due(next)) {
         // A call may write what a copy shares with the voice it was copied from.
         for (const copy of c.members)
@@ -125,7 +124,6 @@ function playTo(transport, c, copies, to) {
                 if (v.parted !== null)
                     v.parted = new Map(v.parted);
             }
-        played = true;
         const last = replay(transport, due, c, {
             transport: () => c,
             mix: (of) => copies.get(of),
@@ -136,7 +134,6 @@ function playTo(transport, c, copies, to) {
     if (!(c.now >= to))
         for (const copy of c.members)
             move(copy, to);
-    return played;
 }
 /** A transport for a read ahead's copies to go on from where those on `c` stand. */
 function restage(c) {

package/dist/clock.d.ts

@@ -9,6 +9,16 @@ export declare function passesOf(loop: boolean | number | undefined): number;
 export declare function phaseAt(elapsed: number, duration: number, passes: number): number;
 /** The pass `elapsed` voice ms falls in, held at the last once they are done. */
 export declare function passAt(elapsed: number, duration: number, passes: number): number;
+/**
+ * A fade in from `since` over `fadeIn` at mix time `now`, 0..1. It stands still where a fade out
+ * began, or the two ramps multiply into a rise, from `stop` on, and through `stalls`, pairs of mix
+ * times.
+ */
+export declare function fadeInAt(fadeIn: number, out: {
+    at: number;
+    over: number;
+    rest: boolean;
+} | null, ease: Curve | undefined, now: number, since: number, stalls: readonly number[] | null, stop?: number): number;
 /**
  * A voice's own fade this frame, 0..1: in from `since` over `fadeIn`, out along its ramp, and back
  * up the same curve where a fade out was turned around.
@@ -21,7 +31,7 @@ export declare function envelope(fadeIn: number, out: {
     from: number;
     at: number;
     over: number;
-} | null): number;
+} | null, stalls?: readonly number[] | null): number;
 /**
  * A subject's voice time `raw` once the voice's freezes apply: 0 before it starts if it freezes
  * before, else NaN, where it shows nothing; `span` once its passes end if it freezes after. A `raw`

package/dist/clock.js

@@ -21,19 +21,36 @@ export function passAt(elapsed, duration, passes) {
         return 0;
     return over(elapsed, duration, passes) ? passes - 1 : Math.floor(elapsed / duration);
 }
+/**
+ * A fade in from `since` over `fadeIn` at mix time `now`, 0..1. It stands still where a fade out
+ * began, or the two ramps multiply into a rise, from `stop` on, and through `stalls`, pairs of mix
+ * times.
+ */
+export function fadeInAt(fadeIn, out, ease, now, since, stalls, stop = Number.POSITIVE_INFINITY) {
+    let end = out && !out.rest && out.at < now ? out.at : now;
+    if (stop < end)
+        end = stop;
+    let climbed = end - since;
+    if (stalls !== null)
+        for (let i = 0; i < stalls.length; i += 2) {
+            const a = Math.max(stalls[i], since);
+            const b = Math.min(stalls[i + 1], end);
+            if (b > a)
+                climbed -= b - a;
+        }
+    const u = climbed / fadeIn;
+    if (u >= 1)
+        return 1;
+    return ease ? ease(Math.max(0, u)) : Math.max(0, u);
+}
 /**
  * A voice's own fade this frame, 0..1: in from `since` over `fadeIn`, out along its ramp, and back
  * up the same curve where a fade out was turned around.
  */
-export function envelope(fadeIn, out, ease, reduced, now, since, back = null) {
+export function envelope(fadeIn, out, ease, reduced, now, since, back = null, stalls = null) {
     let w = 1;
-    if (fadeIn > 0 && !reduced) {
-        // A fade in stops climbing where a fade out begins, or the two ramps multiply into a rise.
-        const end = out && !out.rest && out.at < now ? out.at : now;
-        const u = (end - since) / fadeIn;
-        if (u < 1)
-            w *= ease ? ease(Math.max(0, u)) : Math.max(0, u);
-    }
+    if (fadeIn > 0 && !reduced)
+        w *= fadeInAt(fadeIn, out, ease, now, since, stalls);
     if (back && !reduced) {
         const u = back.from + (now - back.at) / back.over;
         if (u < 1)
@@ -114,7 +131,9 @@ export function timeWith(c, elapsed) {
         return r.from > 0 ? c.anchorNow + (elapsed - e0) / r.from : c.anchorNow;
     const a = (r.to - r.from) / (2 * r.over);
     const atEnd = e0 + r.from * r.over + a * r.over * r.over;
-    if (elapsed <= atEnd) {
+    // A ramp that turns the clock back reads furthest where its rate crosses 0, not at its end.
+    const top = r.from > 0 && r.to < 0 ? e0 - (r.from * r.from) / (4 * a) : atEnd;
+    if (elapsed <= top) {
         const k = e0 - elapsed;
         const dt = Math.abs(a) < 1e-12
             ? -k / r.from

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/cue.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;
     }
@@ -180,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);
 }
@@ -234,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.

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;

package/dist/fade.d.ts

@@ -3,7 +3,11 @@ import type { Left, Parted, Parting } from './subject.js';
 import type { Voice } from './voice.js';
 /** Starts one subject's ramp out of a voice, or takes it out at once for a ramp of 0. */
 export declare function fadeSubject<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject: I, over?: number): void;
-/** What a subject's own ramp out of a voice leaves of its weight this frame, 0..1. */
+/**
+ * What a subject's own ramp out of a voice leaves of its weight this frame. It also holds the
+ * voice's fade in where the ramp began, as a fade out of the whole voice does, so it is a ratio to
+ * the fade in the voice's envelope gives.
+ */
 export declare function parting<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, now: number): number;
 /**
  * Takes a subject out of one voice for good, as of mix time `at`: the voice forgets its record,
@@ -34,9 +38,15 @@ export declare function beginFade<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, op
 }, at?: number): void;
 /**
  * Keeps a voice faded at the end of its passes with its owner, live and quiet, rather than letting
- * it leave; the owner leaves at `at` if it holds no child still playing.
+ * it leave; the owner, where it holds no child still playing, leaves at `at`, or stays quiet in
+ * turn where an owner holds it.
  */
 export declare function stay<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, at: number): void;
+/**
+ * Lets an owner holding no child still playing leave at `at`; under history one an owner holds
+ * stays with it instead, quiet while its children are.
+ */
+export declare function release<I, O>(mix: Mixer<I, O>, owner: Voice<I, O>, at: number): void;
 /**
  * Turns a fading voice around: it climbs back from where its fade out had got to, up the same
  * curve, at the whole curve per `over` ms. A fade waiting for rest is taken back at once. A voice