@msb235/blits 0.11.0 → 0.12.1

package/CHANGELOG.md

@@ -4,6 +4,116 @@ 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.12.1
+
+### Added
+
+- `mix.close()`: takes a mix off the list debuggers read, for a host tearing it down, where it would
+  otherwise stay listed until collected. It stops every debugger watching it, and frees a debugger's
+  hold unless another listed mix shares its transport.
+
+### Fixed
+
+- An arc not yet started, cued late or under an owner yet to start, no longer shows its enter's
+  first frame from the moment it is cued.
+
+## 0.12.0
+
+### Added
+
+- `curve(easing)` and `Curve`: the function an easing stands for, from a CSS name, a `bezier`, a
+  `steps` or a function, for a host shaping its own ramps with the curves patches use.
+- `mix.arc(spec)`: an owner holding three parts that hand over in order on its clock, `enter`,
+  `active` for the `hold` and `exit`, each a voice's spec or several layered, with a `blend`
+  crossfading across each boundary. Its marks are its own: `in` as the enter ends, `coast` and
+  `out` as the hold ends and the exit begins, `end` as the exit ends, where it leaves and `done`
+  resolves. `hold: 'open'` holds until `release()` on its handle, which a seek replays; `fade`
+  takes it out with no exit. An arc with a finite hold sits in a span. It is klieg's `fire` as a
+  blits primitive, under the same part names. The schema page's "Arcs" says what each part does.
+- A span child's `earliest` and `rank`. `earliest` is the soonest it may start, a time on the
+  span's clock or an anchor; the fit never places it sooner, and the children after it are laid
+  out from where it starts. One already past when it is cued places it there, partway through, so a
+  span made afresh after a seek plays as it did. One whose anchor has no answer yet waits, with every child
+  after it under `queue` or `stagger`, and the span fits again once the anchor answers. `rank` orders the
+  children still to start, lower first, ties as cued. Together they replace astv's own change
+  order, which sorts its changes by line and starts each no sooner than its orb lands.
+- `watched()`: every mix on the page, for a debugger, in one registry that all copies of blits
+  share. Each entry can:
+  - `watch` what the host reads each frame
+  - `read` a subject the host never probes, now or back in history, through `project`
+  - `label` a subject
+  - list its kit's `channels`, and the `name` and `tags` a voice was cued with
+  - `hold` the mix's clock to pause, step and seek it, without writing to the tape, then `free`
+    it
+  
+  A mix nobody watches runs the same code as before, and one a debugger has let go of runs as fast
+  as one it never watched. `watched().history` gives history to mixes
+  made later that name none. `MixOptions.labelOf` names subjects for it.
+
+### Fixed
+
+- Replacing a voice makes less garbage again: a one-subject tween voice retargeted as it is cued,
+  while another leaves and its subject is dropped, allocates 11.4–11.7 KB, from 13.0–13.4
+  (`bench/churnwho.mjs`, 5,000 voices, teitou, three passes a side). Frame time is unchanged.
+- A voice over every subject that plays more than 60 frames costs less a frame: it now keeps a
+  record for each subject, where it kept one for them all that every read had to point at its
+  subject and back. Three `fn` voices over 1,000 subjects (`fn`) take 0.212 ms a frame against
+  0.226, eight 0.468 against 0.526 (teitou, medians of nine alternated runs of 1,500 frames against
+  `a77c5c9`). A voice cued and gone within a few frames still shares one record, which is what it
+  was for.
+- A crowd of `fn` voices writing arrays, one voice per subject, costs about a tenth less a frame
+  where nothing else writes its channels: it runs off lanes, where its subjects are walked once
+  instead of twice. A `fn` voice writing a vec for each of 10,000 subjects (`fns`) takes 1.348 ms
+  a frame against 1.519 (msb-uai, medians of nine alternated runs of one build with lanes kept
+  for it and not). So does a single `fn` voice over many subjects writing a vec, where no other
+  voice writes it: weasel's animator written as one (`weaselfn`) takes 1.734 ms against 1.823,
+  and one writing a position from each subject's own numbers (`tweenfn`) 1.163 against 1.410.
+- A mix with lanes on whose voices all run off lanes costs a probe less bookkeeping: `tweenfn`
+  takes 1.097 ms a frame against 1.172 and `weaselfn` 1.644 against 1.723 (msb-uai, medians of
+  thirteen alternated runs of one build with the change switched on and off).
+- A voice on a lane costs a call less a subject each frame: since 0.11.0 the check for a voice
+  hiding past its end left its clock read out of line. A glow weighted by a signal over 10,000
+  subjects (`glow`) takes 1.636 ms a frame against 1.696 (teitou, medians of fifteen alternated runs
+  against `11a1471`).
+- A mix keeping history costs about a fifth less a frame and allocates a third less: the copy of a
+  record that falls out of the window is written over as the next one kept, only a motion voice
+  works out how far back a read may still reach, and a stock `sum`, `mul` or `max` channel folds a
+  voice's number without calling the channel. Three voices over 10,000 subjects with 5 s of history
+  (`kept`) take 5.33 ms a frame against 6.56 and allocate 5.7 MB against 8.5; sought back and
+  returned before every sync (`seek`), 5.90 ms against 6.76; at 1,000 subjects, 0.412 against
+  0.500 and 0.540 against 0.598 (teitou, medians of nine alternated runs of 1,500 frames against
+  `00ad148`, each in its own process).
+- A `seek` back and a return to where the mix was cost about a third of what they did: a record put
+  back takes up the state of the record the seek replaced instead of stepping again from its copy,
+  is written over that record instead of copied anew, and the copy its next probe keeps is written
+  over one the seek cut; subjects keep their numbers across the seek. Three voices over 10,000
+  subjects with 5 s of history, sought 300 ms back and returned before every sync (`seek`), take
+  9.83 ms a frame against 28.60, and allocate 8.6 MB a frame against 35.2; 1,000 subjects take 0.86
+  ms against 1.88 (msb-uai, medians of nine alternated runs against `4374f34`, each in its own
+  process). The same mix never sought (`kept`) reads 7.41 ms against 7.33 at 10,000 subjects and
+  0.645 against 0.676 at 1,000. A `step` that reads `setting.weight`, `elapsed` or `pass` now shows,
+  after a seek back and return, what a mix never sought shows. A seek no longer boxes its moment
+  once per record it puts back: the `seek` row at 10,000 subjects allocates 7.9 MB a frame against
+  8.8, and takes 10.44 ms against 9.88, inside its runs' spread (msb-uai, medians of nine
+  alternated runs against `1077ab4`). A seek's relink takes each voice's record from the subject's
+  old chain where its store can tell the record is still its own, instead of looking it up by
+  subject: the `seek` row at 10,000 subjects takes 9.42 ms a frame against 9.95, and 1,000 subjects
+  0.864 against 0.884 (msb-uai, medians of nine alternated runs against `c3fe7a8`).
+- A mix sought back often no longer grows without bound: each voice kept a little for every seek
+  back to a later moment than the last, and the records subjects left with after each seek, and
+  let go of neither. Three voices sought back and returned every frame held 2.26 MB more after
+  12,000 frames; they now hold what their live records need.
+- A lane fill no longer boxes numbers it hands between its own calls, which it did for 3 to 5
+  numbers a subject in some processes and none in others, by the order V8 happened to compile in.
+  10k subjects under a `fn` voice and a signal-weighted glow over 200 of them, with 200 subjects
+  leaving the glow and 200 entering each frame (bench/reach.mjs `part:200`), allocate 1.27 MB a
+  frame against 1.89 and take 1.924 ms against 2.037 read by `probe`, and 1.255 against 1.405 by
+  `pull`; with nothing moving by `pull`, 1.108 against 1.221 (keiei). `probed` allocates 1.02 MB a
+  frame against 1.65. No steady row moves past its spread: `fn` 2.942 against 2.903, `fn^` 2.323
+  against 2.390, `keys` 1.355 against 1.342 (msb-uai); `signal` reads 3.820 against 3.578, inside
+  its spread but slower in each of three such comparisons. Medians of six alternated runs, each in
+  its own process, `bench/ab.sh` against `main` at `4374f34`.
+
 ## 0.11.0
 
 ### Breaking

package/dist/arcs.d.ts

@@ -0,0 +1,40 @@
+import type { Mixer } from './mixer.js';
+import type { ArcHandle, ArcSpec } from './types.js';
+import type { Voice } from './voice.js';
+/** What an arc keeps beside its owner: how long its enter and exit last, which parts it has, its blend. */
+export declare class Arc {
+    readonly enter: number;
+    readonly exit: number;
+    readonly blend: number;
+    /** By part, whether it has one. */
+    readonly has: readonly boolean[];
+    /** How long its hold lasts as cued; Infinity for one held open. */
+    readonly hold: number;
+    constructor(enter: number, exit: number, blend: number, 
+    /** By part, whether it has one. */
+    has: readonly boolean[], 
+    /** How long its hold lasts as cued; Infinity for one held open. */
+    hold: number);
+}
+/** Where an arc ends on its own clock: Infinity while its hold is open. */
+export declare function arcEnd<I, O>(voice: Voice<I, O>): number;
+/**
+ * What an arc multiplies into the weight of a voice it holds at mix time `now`: its part's ramp,
+ * scaled down where a hold shorter than the blend leaves all three ramps up at once and their sum
+ * would pass 1.
+ */
+export declare function arcShare<I, O>(arcVoice: Voice<I, O>, child: Voice<I, O>, now: number, reduced: boolean): number;
+/** Cues an arc: its owner, then each part's voices on its clock. */
+export declare function cueArc<I, O>(mix: Mixer<I, O>, spec: ArcSpec<I, O>): ArcHandle<I>;
+/**
+ * Ends an arc's hold at mix time now, so its exit begins half a blend later and its blend starts
+ * now; where the enter is still playing, the exit follows it. Nothing where the exit has begun.
+ */
+export declare function release<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): void;
+/**
+ * Lets each arc's parts leave once the blend after them is over, and the arc itself at its end:
+ * played, as a voice that ran its passes is.
+ */
+export declare function settleArcs<I, O>(mix: Mixer<I, O>, now: number): void;
+/** An arc's marks: when its enter ends, its hold ends and its exit begins and ends. */
+export declare function arcMark<I, O>(voice: Voice<I, O>, start: number, mark: 'in' | 'coast' | 'out' | 'end'): number | undefined;

package/dist/arcs.js

@@ -0,0 +1,241 @@
+import { retire } from './fade.js';
+import { noted } from './history.js';
+import { ownerReading } from './owner.js';
+import { startAt } from './place.js';
+import { refit } from './spans.js';
+/** An arc's parts in the order they play: its enter, its active and its exit. */
+const PARTS = ['enter', 'active', 'exit'];
+/** What an arc keeps beside its owner: how long its enter and exit last, which parts it has, its blend. */
+export class Arc {
+    enter;
+    exit;
+    blend;
+    has;
+    hold;
+    constructor(enter, exit, blend, 
+    /** By part, whether it has one. */
+    has, 
+    /** How long its hold lasts as cued; Infinity for one held open. */
+    hold) {
+        this.enter = enter;
+        this.exit = exit;
+        this.blend = blend;
+        this.has = has;
+        this.hold = hold;
+    }
+}
+/** Where each part an arc has starts and ends on its clock, for a hold of `hold`; null for a part it lacks. */
+function segments(arc, hold) {
+    const bounds = [0, arc.enter, arc.enter + hold, arc.enter + hold + arc.exit];
+    const end = bounds[3];
+    const out = [null, null, null];
+    for (let p = 0; p < 3; p++) {
+        if (!arc.has[p])
+            continue;
+        let next = p + 1;
+        while (next < 3 && !arc.has[next])
+            next++;
+        out[p] = [bounds[p], next < 3 ? bounds[next] : end];
+    }
+    return out;
+}
+/** Where an arc ends on its own clock: Infinity while its hold is open. */
+export function arcEnd(voice) {
+    const arc = voice.arc;
+    return arc.enter + voice.hold + arc.exit;
+}
+/**
+ * A part's weight at `t` on its arc's clock, klieg's: up over the blend centered on where it
+ * starts and down over the one where it ends, except at the arc's own start and end, where it
+ * holds full weight.
+ */
+function rampOf(s, e, end, blend, t) {
+    if (e <= s)
+        return 0;
+    const half = blend / 2;
+    const first = s === 0;
+    const last = e === end;
+    if ((!first && t < s - half) || (!last && t >= e + half))
+        return 0;
+    const up = first ? 1 : blend > 0 ? Math.min(1, (t - s + half) / blend) : 1;
+    const down = last ? 1 : blend > 0 ? Math.min(1, (e + half - t) / blend) : 1;
+    return Math.min(up, down);
+}
+/**
+ * What an arc multiplies into the weight of a voice it holds at mix time `now`: its part's ramp,
+ * scaled down where a hold shorter than the blend leaves all three ramps up at once and their sum
+ * would pass 1.
+ */
+export function arcShare(arcVoice, child, now, reduced) {
+    const arc = arcVoice.arc;
+    const t = ownerReading(arcVoice, now);
+    // Its parts freeze on their first frames, so an arc yet to start has to silence them itself.
+    if (!(t >= 0))
+        return 0;
+    const segs = segments(arc, arcVoice.hold);
+    const end = arc.enter + arcVoice.hold + arc.exit;
+    const blend = reduced ? 0 : arc.blend;
+    const mine = segs[child.part];
+    if (mine == null)
+        return 0;
+    const own = rampOf(mine[0], mine[1], end, blend, t);
+    if (own <= 0)
+        return 0;
+    let total = 0;
+    for (const s of segs)
+        if (s !== null)
+            total += rampOf(s[0], s[1], end, blend, t);
+    return total > 1 ? own / total : own;
+}
+/** How long a part lasts: its longest voice's `duration`, or patch duration times passes. */
+function lengthOf(part) {
+    let most = 0;
+    for (const v of part) {
+        const loop = v.loop;
+        const passes = loop === undefined || loop === false ? 1 : loop === true ? Infinity : loop;
+        const own = v.duration ?? (v.patch.duration > 0 ? v.patch.duration * passes : 0);
+        if (!(own >= 0))
+            throw new RangeError(`blits: an arc's part lasts 0 ms or more, not ${own}`);
+        if (own > most)
+            most = own;
+    }
+    return most;
+}
+const listOf = (part) => part === undefined ? undefined : Array.isArray(part) ? part : [part];
+/** Cues an arc: its owner, then each part's voices on its clock. */
+export function cueArc(mix, spec) {
+    if ((spec.rate ?? 1) < 0)
+        throw new Error('blits: an arc plays its parts forward from its start, so it is not cued backward');
+    if (spec.freeze !== undefined)
+        throw new Error('blits: an arc holds each part’s first and last frames itself, so it takes no freeze');
+    const { enter, active, exit, hold, blend, ...own } = spec;
+    const parts = [listOf(enter), listOf(active), listOf(exit)];
+    const lengths = parts.map((p) => (p === undefined ? 0 : lengthOf(p)));
+    for (const p of [0, 2])
+        if (!Number.isFinite(lengths[p]))
+            throw new Error(`blits: an arc's ${PARTS[p]} has to end, so it cannot loop for good`);
+    const held = hold === 'open' ? Number.POSITIVE_INFINITY : (hold ?? lengths[1] ?? 0);
+    if (!(held >= 0))
+        throw new RangeError(`blits: an arc holds for 0 ms or more, not ${hold}`);
+    const fade = blend ?? 0;
+    if (!(fade >= 0 && Number.isFinite(fade)))
+        throw new RangeError(`blits: an arc blends over 0 ms or more, not ${blend}`);
+    const arc = new Arc(lengths[0], lengths[2], fade, parts.map((p) => p !== undefined), held);
+    mix.arcing = arc;
+    let handle;
+    try {
+        handle = mix.owns(own);
+    }
+    finally {
+        mix.arcing = null;
+    }
+    const starts = [0, arc.enter, arc.enter + held];
+    parts.forEach((part, p) => {
+        for (const v of part ?? []) {
+            const { duration: _, ...rest } = v;
+            const child = {
+                ...rest,
+                owner: handle,
+                start: starts[p],
+                freeze: 'both',
+            };
+            // The hold, not the patch, says how long the active plays, so it loops unless told otherwise.
+            if (p === 1 && hold !== undefined && v.loop === undefined)
+                child.loop = true;
+            mix.cue(child);
+            mix.cued[mix.cued.length - 1].part = p;
+        }
+    });
+    return handle;
+}
+/**
+ * Ends an arc's hold at mix time now, so its exit begins half a blend later and its blend starts
+ * now; where the enter is still playing, the exit follows it. Nothing where the exit has begun.
+ */
+export function release(mix, voice) {
+    const arc = voice.arc;
+    if (arc === null)
+        throw new Error('blits: release ends an arc’s hold, and this is no arc');
+    if (voice.state === 'done' || voice.state === 'fading')
+        return;
+    const local = ownerReading(voice, mix.now);
+    const lead = arc.exit > 0 && !mix.reduced ? arc.blend / 2 : 0;
+    const at = Math.max(arc.enter, local + lead);
+    if (!(at < arc.enter + voice.hold))
+        return;
+    voice.hold = at - arc.enter;
+    for (const child of voice.holding?.children ?? [])
+        if (child.part === 2 && child.state === 'pending')
+            startAt(mix, child, at);
+    noteArc(mix, voice);
+}
+/** Records an arc's new hold, and has the span holding it fit again. */
+function noteArc(mix, voice) {
+    noted(mix, voice);
+    if (voice.owner?.fitting)
+        refit(mix, voice.owner);
+    mix.lanes?.refill();
+}
+/**
+ * Lets each arc's parts leave once the blend after them is over, and the arc itself at its end:
+ * played, as a voice that ran its passes is.
+ */
+export function settleArcs(mix, now) {
+    for (const voice of mix.owners ?? []) {
+        const arc = voice.arc;
+        if (arc === null || voice.state === 'done' || voice.state === 'pending')
+            continue;
+        const local = ownerReading(voice, now);
+        if (!Number.isFinite(local))
+            continue;
+        const end = arcEnd(voice);
+        if (local >= end) {
+            const at = voice.timeAt(end);
+            voice.play(true, at, mix.transport.seq);
+            retire(mix, voice, at);
+            continue;
+        }
+        const segs = segments(arc, voice.hold);
+        const half = mix.reduced ? 0 : arc.blend / 2;
+        for (const child of [...(voice.holding?.children ?? [])]) {
+            const s = segs[child.part];
+            if (s == null || s[1] === end || child.state === 'done')
+                continue;
+            if (local >= s[1] + half)
+                retire(mix, child, voice.timeAt(s[1] + half));
+        }
+    }
+}
+/** An arc's marks: when its enter ends, its hold ends and its exit begins and ends. */
+export function arcMark(voice, start, mark) {
+    const arc = voice.arc;
+    const at = (t) => {
+        const u = voice.timeAt(t);
+        return Number.isFinite(u) ? Math.max(start, u) : undefined;
+    };
+    if (mark === 'in') {
+        const t = at(arc.enter);
+        return t === undefined ? t : Math.max(t, start + (voice.fade.in ?? 0));
+    }
+    const coast = at(arc.enter + voice.hold);
+    // Faded, or set to fade, before its hold ended: it left with no exit.
+    const out = voice.out;
+    const cut = out !== null ? out.at : Number.isFinite(voice.outAt) ? voice.outAt : undefined;
+    const cutShort = cut !== undefined && (coast === undefined || cut < coast);
+    if (mark === 'coast')
+        return cutShort ? undefined : coast;
+    if (mark === 'out') {
+        if (cutShort)
+            return cut;
+        return voice.state === 'done' && coast === undefined ? voice.doneAt : coast;
+    }
+    if (voice.state === 'done')
+        return voice.doneAt;
+    if (cutShort) {
+        if (out !== null)
+            return out.at + out.over;
+        const over = Number.isNaN(voice.outOver) ? (voice.fade.out ?? 0) : voice.outOver;
+        return cut + over;
+    }
+    return at(arcEnd(voice));
+}

package/dist/chain.d.ts

@@ -8,8 +8,13 @@ import type { Subject, Voice } from './voice.js';
  */
 export declare function chain<I, O>(this: Mixer<I, O>, subject: I): Subject<unknown>;
 export declare function relink<I, O>(this: Mixer<I, O>, subject: I, was: Subject<unknown> | undefined): Subject<unknown>;
+/**
+ * The subject's chain as last linked; undefined where it has none, as for a chain a seek kept only
+ * for its number and not linked since, whose records are those from before the seek.
+ */
+export declare function headOf<I, O>(mix: Mixer<I, O>, subject: I): Subject<unknown> | undefined;
 /** A voice's record for a subject where its chain links it: the voice plays or freezes, and reaches it. */
-export declare function linkable<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, slot: number): Subject<unknown> | null;
+export declare function linkable<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, slot: number, guess?: Subject<unknown> | null): Subject<unknown> | null;
 /** Whether a voice reaches a subject by what its spec says: the subjects it names, or its `target`. */
 export declare function aims<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I): boolean;
 /**

package/dist/chain.js

@@ -16,30 +16,46 @@ export function chain(subject) {
 }
 // Apart from `chain`, which stays small enough for V8 to inline where a probe links.
 export function relink(subject, was) {
-    const slot = was !== undefined ? was.slot : this.lanes !== null ? this.lanes.number(subject) : -1;
+    const lanes = this.lanes;
+    const slot = was !== undefined ? was.slot : lanes !== null ? lanes.number(subject) : -1;
+    // A chain a seek kept for its number alone links afresh, as a subject first seen does.
+    const sought = was !== undefined && slot >= 0 && lanes?.renew(slot) === true;
     // Where only voices over every subject changed since, those alone are taken off or put on.
-    let first = was === undefined
+    let first = was === undefined || sought
         ? undefined
         : this.steps.patch(was.voice === null ? null : was, was.version, this, subject, slot);
     if (first === undefined)
-        first = linkAll(this, subject, slot);
+        first = linkAll(this, subject, slot, was ?? null);
     const head = first ?? stub();
     head.version = this.version;
     if (was !== undefined && was !== head) {
-        head.loci = was.loci;
+        if (!sought)
+            head.loci = was.loci;
         was.loci = null;
-        head.slot = was.slot;
         was.slot = -1;
     }
-    else if (was === undefined)
-        head.slot = slot;
+    head.slot = slot;
     if (was !== head)
         this.chains.set(subject, head);
     return head;
 }
-/** A subject's chain linked afresh through every voice that reaches it, in voice order. */
-function linkAll(mix, subject, slot) {
+/**
+ * The subject's chain as last linked; undefined where it has none, as for a chain a seek kept only
+ * for its number and not linked since, whose records are those from before the seek.
+ */
+export function headOf(mix, subject) {
+    const head = mix.chains.get(subject);
+    return head !== undefined && head.slot >= 0 && mix.lanes?.sought(head.slot) === true
+        ? undefined
+        : head;
+}
+/**
+ * A subject's chain linked afresh through every voice that reaches it, in voice order; `was` is its
+ * chain as last linked, whose records each voice's store is asked whether it still holds.
+ */
+function linkAll(mix, subject, slot, was) {
     let first = null;
+    let old = was;
     let prev = null;
     const named = mix.naming === 0 ? undefined : mix.named.get(subject);
     let j = 0;
@@ -54,7 +70,11 @@ function linkAll(mix, subject, slot) {
                 break;
             if (next === mine)
                 j++;
-            const held = mix.linkable(next, subject, slot);
+            // Taken before linking, which writes over `next`.
+            const guess = old !== null && old.voice === next ? old : null;
+            if (guess !== null)
+                old = guess.next;
+            const held = mix.linkable(next, subject, slot, guess);
             if (held !== null) {
                 held.voice = next;
                 held.next = null;
@@ -71,7 +91,7 @@ function linkAll(mix, subject, slot) {
     return first;
 }
 /** A voice's record for a subject where its chain links it: the voice plays or freezes, and reaches it. */
-export function linkable(voice, subject, slot) {
+export function linkable(voice, subject, slot, guess = null) {
     const state = voice.state;
     if (state === 'done' || (state === 'pending' && !voice.freezesBefore))
         return null;
@@ -82,7 +102,7 @@ export function linkable(voice, subject, slot) {
             sight(voice, slot, this.lanes.cap);
         return null;
     }
-    const held = this.held(voice, subject, slot);
+    const held = this.held(voice, subject, slot, guess);
     return held.reaches ? held : null;
 }
 /** Whether a voice reaches a subject by what its spec says: the subjects it names, or its `target`. */
@@ -124,7 +144,7 @@ export function changed(mix, voice) {
         return;
     }
     for (const subject of voice.named) {
-        const head = mix.chains.get(subject);
+        const head = headOf(mix, subject);
         if (head !== undefined)
             unlink(mix, head);
     }

package/dist/channels.d.ts

@@ -38,6 +38,8 @@ export declare function axesOf(channel: Channel<unknown>): number;
  * `'own'` channel, and an angle's `v` is taken the short way round first.
  */
 export declare function foldNumber(op: Numeric['op'], acc: number, v: number, w: number): number;
+/** The arithmetic `foldNumber` can apply for a channel in place of its `scale` and `merge`, if any. */
+export declare function scalarOp(channel: Channel<unknown>): 'sum' | 'mul' | 'max' | undefined;
 /**
  * What a stock numeric channel takes.
  *

package/dist/channels.js

@@ -49,7 +49,18 @@ export function foldNumber(op, acc, v, w) {
         return product(acc, toward(v, w));
     if (op === 'max')
         return larger(acc, times(v, w));
-    return v;
+    // A double on every branch: where `v` arrives untyped, a branch returning it as it came makes V8
+    // box each other branch's result to merge them, 16 bytes a fold (bench/allocs.mjs, 2026-10-20).
+    return +v;
+}
+/** The arithmetic `foldNumber` can apply for a channel in place of its `scale` and `merge`, if any. */
+export function scalarOp(channel) {
+    const n = numericOf(channel);
+    if (n === undefined || n.axes !== 1 || n.turn !== undefined || channel.fold !== undefined)
+        return undefined;
+    if (typeof channel.rest !== 'number')
+        return undefined;
+    return n.op === 'sum' || n.op === 'mul' || n.op === 'max' ? n.op : undefined;
 }
 /** Bounds change how a value folds at its edges, so they are part of the kind. */
 const kindOf = (name, bounds) => bounds === undefined ? name : `${name}[${bounds[0]}, ${bounds[1]}]`;

package/dist/clone.js

@@ -6,19 +6,31 @@ const slow = Symbol('slow');
  */
 export function clone(v) {
     const quick = copied(v, 2);
-    met.length = 0;
+    for (let i = 0; i < metCount; i++)
+        met[i] = undefined;
+    metCount = 0;
     return quick === slow ? structuredClone(v) : quick;
 }
-/** The objects one `clone` has met: one met twice is shared, which `structuredClone` keeps. */
+/**
+ * The objects one `clone` has met: one met twice is shared, which `structuredClone` keeps. Cleared
+ * by hand, as `length = 0` frees the array's storage and the next push allocates it again.
+ */
 const met = [];
+let metCount = 0;
+function hasMet(v) {
+    for (let i = 0; i < metCount; i++)
+        if (met[i] === v)
+            return true;
+    return false;
+}
 function copied(v, depth) {
     if (typeof v === 'symbol' || typeof v === 'function')
         return slow;
     if (typeof v !== 'object' || v === null)
         return v;
-    if (depth === 0 || met.includes(v))
+    if (depth === 0 || hasMet(v))
         return slow;
-    met.push(v);
+    met[metCount++] = v;
     if (Array.isArray(v)) {
         if (Object.getPrototypeOf(v) !== Array.prototype)
             return slow;

package/dist/cue.js

@@ -44,9 +44,13 @@ export function cue(mix, spec) {
                 : Number.isNaN(mix.now)
                     ? 0
                     : mix.now;
-    const voice = new Voice(mix.nextId++, spec, patch, spec.fade ?? {}, local, start, mix.slotOf, mix.channels, mix.opts.host, mix.send, owner);
+    const voice = new Voice(mix.nextId++, spec, patch, spec.fade ?? noFade, local, start, mix.slotOf, mix.channels, mix.opts.host, mix.send, owner);
     if (patch === ownerPatch && mix.fitting !== null)
         voice.fitting = mix.fitting;
+    if (patch === ownerPatch && mix.arcing !== null) {
+        voice.arc = mix.arcing;
+        voice.hold = mix.arcing.hold;
+    }
     if (owner?.fitting)
         checkChild(spec, voice);
     if (mix.pace !== null && owner === null && spec.start !== undefined && voice.state === 'pending')
@@ -54,6 +58,12 @@ export function cue(mix, spec) {
     enter(mix, voice);
     const h = handle(mix, voice);
     voice.handle = h;
+    recordCue(mix, h);
+    return h;
+}
+const noFade = Object.freeze({});
+// Apart from `cue`, whose body would otherwise make this closure's context on every call.
+function recordCue(mix, h) {
     // By its handle, so a voice a history store paged out and a seek revived is the one cued again.
     record(mix, 'cue', (stage) => {
         const parked = VoiceHandle.voiceOf(h) ?? lost(h);
@@ -63,7 +73,6 @@ export function cue(mix, spec) {
         else if (to !== undefined)
             recue(to, aheadOf(to, parked));
     });
-    return h;
 }
 /** Refuses a patch writing a channel `kit` lacks, or holds as another kind than it was written for. */
 export function fitsKit(patch, kit) {

package/dist/departed.d.ts

@@ -24,11 +24,15 @@ export interface Departed {
  * owner, the first and the last to leave. It grows with those, never with how many voices left.
  */
 export declare class DepartedIndex {
-    private readonly ends;
+    private readonly scopes;
     readonly all: Set<Departed>;
     add<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): void;
     /** Lets go of the voices an owner that has left held: nothing can be cued beside them again. */
     dropOwner(owner: number): void;
+    private scopeOf;
+    private keep;
+    private hold;
+    private forget;
     private release;
 }
 /** Whether a departed voice answers `q`, asked by a voice of `owner` (-1 for none) on `score`. */