@msb235/blits 0.7.0 → 0.8.0

package/dist/fold.js

@@ -1,12 +1,16 @@
 import { frozenTime, passAt, phaseAt, silent } from './clock.js';
 import { copy as copyValue } from './clone.js';
+import { open as openRecord, shut as shutRecord, weighAt } from './everyone.js';
 import { recordHost, remember } from './history.js';
 import { stateful } from './hosts.js';
 import { locusScratch } from './locus.js';
+import { moved } from './moved.js';
 import { readKeys } from './patch.js';
 import { reading } from './reading.js';
 // V8 reads a local const as a constant, where it reads an import from its module on every call.
 const copy = copyValue;
+const open = openRecord;
+const shut = shutRecord;
 /** A record's band state, made when a rest-less channel first asks. */
 function bandsFor(held, n) {
     const bands = new Uint8Array(n);
@@ -25,7 +29,7 @@ export function near(a, b) {
  * new array: `b` belongs to a patch or the mix's scratch, and a host may edit the pose. `acc` is a
  * value this fold made.
  */
-function merged(channel, acc, b) {
+export function merged(channel, acc, b) {
     const r = channel.merge(acc, b);
     if (r !== b || !Array.isArray(r))
         return r;
@@ -35,6 +39,24 @@ function merged(channel, acc, b) {
         acc[i] = r[i];
     return acc;
 }
+/**
+ * A record after a seek that rebuilds: fresh state, stepped again from where the voice's clock now
+ * puts this subject's start, which under `stepMs` lands where a voice cued fresh would.
+ */
+function rebuild(mix, voice, subject, now, held) {
+    held.rebuilt = voice.rebuilds;
+    const patch = voice.patch;
+    if (patch.state === undefined && patch.step === undefined && held.kept === null)
+        return;
+    held.state = patch.state ? patch.state(subject) : undefined;
+    held.kept = null;
+    held.unkept = undefined;
+    held.since = mix.sinceOf(voice, held.delay);
+    held.shown = mix.shownOf(voice, held.since);
+    held.ticks = 0;
+    held.stepped = held.since < now ? held.since : now;
+    held.probed = Number.NaN;
+}
 /**
  * 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`.
@@ -45,12 +67,16 @@ export function contribution(voice, subject, now, held) {
         return null;
     if (voice.out?.rest && held.rested)
         return null;
+    if (held.rebuilt !== voice.rebuilds)
+        rebuild(this, voice, subject, now, held);
     const raw = voice.elapsedAt(now) - held.delay;
-    if (raw < 0 && !voice.freezesBefore)
+    // Not `raw < 0`: see `frozenTime` for the clock that reads NaN before its start.
+    const early = !(raw >= 0);
+    if (early && !voice.freezesBefore)
         return null;
     const elapsed = frozenTime(raw, voice.freezesBefore, voice.freezesAfter, voice.span);
     // A frozen subject's clock stands still at the edge it freezes at: -1 before, 1 after, 0 playing.
-    const still = raw < 0 ? -1 : voice.freezesAfter && raw > voice.span ? 1 : 0;
+    const still = early ? -1 : voice.freezesAfter && raw > voice.span ? 1 : 0;
     const duration = voice.duration;
     const phase = phaseAt(elapsed, duration, voice.passes);
     const pass = passAt(elapsed, duration, voice.passes);
@@ -79,6 +105,10 @@ export function contribution(voice, subject, now, held) {
     if (voice.patch.step && held.probed !== now && still >= 0) {
         // Frozen after, it steps once more to where its last pass ended, and no further.
         const to = still === 1 ? voice.timeAt(held.delay + voice.span) : now;
+        if (held.stepped < held.since) {
+            held.stepped = held.since;
+            setting.dt = this.capped(now - held.since);
+        }
         if (tick !== undefined && tick > 0 && !this.reducedNow)
             this.tick(voice, subject, held, tick, to);
         else if (still === 0 ? now !== held.stepped : to > held.stepped) {
@@ -102,6 +132,9 @@ export function contribution(voice, subject, now, held) {
         held.phase = phase;
         delta = this.keyed(voice, subject, held);
     }
+    else if (voice.motion !== undefined) {
+        delta = moved(voice.motion, voice.patch.writes[0], subject, setting, held);
+    }
     else {
         delta = voice.patch.at(phase, subject, setting);
     }
@@ -230,6 +263,14 @@ export function isRest(delta) {
     }
     return true;
 }
+/**
+ * A record's band state once its voice is skipped at weight 0: off, as `passes` would have said, so
+ * a weight that comes back inside the band does not find it still on.
+ */
+export function unband(held) {
+    if (held?.bands)
+        held.bands.fill(2);
+}
 /** Whether a rest-less channel's contribution is switched on, across a band rather than an edge. */
 export function passes(was, w) {
     const { on, off } = this.band;
@@ -263,19 +304,56 @@ export function apply(pose, voice, held, delta, weight) {
 /** Clamps every bounded channel of a folded pose into its range, in place. */
 export function clamp(pose) {
     for (const slot of this.bounded) {
-        const [lo, hi] = this.channels[slot].bounds;
         const key = this.names[slot];
-        const v = pose[key];
-        if (typeof v === 'number')
-            pose[key] = v < lo ? lo : v > hi ? hi : v;
-        else if (Array.isArray(v))
-            for (let i = 0; i < v.length; i++) {
-                const x = v[i];
-                v[i] = x < lo ? lo : x > hi ? hi : x;
-            }
+        pose[key] = bound(this.channels[slot], pose[key]);
     }
     return pose;
 }
+/** A folded value held to its channel's bounds: a number clamped, an array clamped in place. */
+export function bound(channel, v) {
+    const [lo, hi] = channel.bounds;
+    if (typeof v === 'number')
+        return v < lo ? lo : v > hi ? hi : v;
+    if (Array.isArray(v))
+        for (let i = 0; i < v.length; i++) {
+            const x = v[i];
+            v[i] = x < lo ? lo : x > hi ? hi : x;
+        }
+    return v;
+}
+/**
+ * Whether a fold's next voice is its chain's next record, `held`, and not the next voice sharing
+ * one record, `sharers[q]`: the two lists are each in voice order, and a fold takes them as one.
+ */
+export function chainFirst(held, sharers, q) {
+    if (held === null)
+        return false;
+    if (q >= sharers.length || held.voice === null)
+        return true;
+    const next = sharers[q];
+    return next.id > held.voice.id;
+}
+/**
+ * After a fold read a sharing voice for the subject numbered `slot`: keeps the weight it gave and
+ * what the read left on its record, and gives the fold's place in `sharers`, which moves back where
+ * the read made the voice share no more.
+ */
+export function shared(voice, slot, rec, q) {
+    if (voice.sharing) {
+        // A projection numbers no subject, and keeps nothing by subject.
+        if (slot < 0)
+            return q;
+        const cap = this.lanes.cap;
+        weighAt(voice, slot, rec.weight, cap);
+        shut(voice, rec, slot, cap);
+        return q;
+    }
+    const sharers = this.sharers;
+    let i = 0;
+    while (i < sharers.length && sharers[i].id < voice.id)
+        i++;
+    return i;
+}
 export function fold(subject, out, dry = false, except) {
     const pose = this.folded(subject, out, dry, except);
     return (this.bounded.length === 0 ? pose : this.clamp(pose));
@@ -296,20 +374,29 @@ export function linked(subject) {
 }
 /** The fold after a subject's chain is linked and its lanes asked whether it reads from them. */
 export function foldWith(subject, out, head, laned, dry, except) {
-    const now = this.now;
     const pose = out;
     const lanes = this.lanes;
     const skip = laned ? lanes.copies : null;
     for (let i = 0; i < this.names.length; i++) {
         if (skip?.[i])
             continue;
-        const rest = this.channels[i].rest;
+        const channel = this.channels[i];
+        const rest = channel.rest;
         const key = this.names[i];
         // Never `delete`: it drops a reused out object into dictionary mode for good.
-        if (rest !== undefined)
-            pose[key] = copy(rest);
-        else if (pose[key] !== undefined)
-            pose[key] = undefined;
+        if (rest === undefined) {
+            if (pose[key] !== undefined)
+                pose[key] = undefined;
+            continue;
+        }
+        // A stock array channel never keeps the pose's array, so one a last fold left in `out` is ours.
+        const held = this.lerpsInto[i] === undefined ? undefined : pose[key];
+        if (Array.isArray(held) && held !== rest && held.length === rest.length) {
+            for (let a = 0; a < held.length; a++)
+                held[a] = rest[a];
+        }
+        else
+            pose[key] = channel.copy ? channel.copy(rest) : copy(rest);
     }
     if (head === null)
         return pose;
@@ -323,7 +410,8 @@ export function foldWith(subject, out, head, laned, dry, except) {
         else if (l.whole)
             return pose;
     }
-    if (this.loci === 0) {
+    if (this.detours === 0) {
+        const now = this.now;
         for (let held = head; held !== null; held = held.next) {
             const voice = held.voice;
             if (voice === null || (laned && voice.laned && !this.owedBy(owed, voice)))
@@ -333,13 +421,82 @@ export function foldWith(subject, out, head, laned, dry, except) {
             const delta = this.read(voice, subject, now, dry, held);
             if (owed >= 0 && voice.laned)
                 lanes.paid(voice.id, owed, held.weight);
+            if (!(held.weight > 0))
+                unband(held);
             if (delta === null || this.w <= 0)
                 continue;
             this.apply(pose, voice, held, delta, this.w);
         }
         return pose;
     }
-    return this.foldLoci(subject, pose, head, laned, dry, except, owed);
+    return this.foldDetour(subject, pose, head, laned, dry, except, owed);
+}
+/**
+ * `foldWith`'s voices in a mix with a locus or a voice sharing one record in it. The chain is taken
+ * again where a voice stopped sharing since it was linked, as a patch call in this probe's fill can
+ * make one do. With no locus, the chain's records fold in voice order, and each voice sharing one
+ * record, which is in no chain, before the first chain record that comes after it.
+ */
+export function foldDetour(subject, pose, linkedHead, laned, dry, except, owed) {
+    const head = linkedHead.version === this.version ? linkedHead : this.chain(subject);
+    if (this.loci !== 0)
+        return this.foldLoci(subject, pose, head, laned, dry, except, owed);
+    const now = this.now;
+    const lanes = this.lanes;
+    const sharers = this.sharers;
+    let q = 0;
+    for (let held = head; held !== null; held = held.next) {
+        const voice = held.voice;
+        if (voice === null)
+            continue;
+        if (q < sharers.length && sharers[q].id < voice.id)
+            q = this.foldSharers(pose, subject, head, q, voice.id, laned, dry, except, owed);
+        if (laned && voice.laned && !this.owedBy(owed, voice))
+            continue;
+        if (voice.id === except || voice.state === 'done')
+            continue;
+        const delta = this.read(voice, subject, now, dry, held);
+        if (owed >= 0 && voice.laned)
+            lanes.paid(voice.id, owed, held.weight);
+        if (!(held.weight > 0))
+            unband(held);
+        if (delta === null || this.w <= 0)
+            continue;
+        this.apply(pose, voice, held, delta, this.w);
+    }
+    if (q < sharers.length)
+        this.foldSharers(pose, subject, head, q, Number.MAX_SAFE_INTEGER, laned, dry, except, owed);
+    return pose;
+}
+/**
+ * Folds the voices sharing one record from `sharers[q]` up to the first whose id is `before` or
+ * more, as `foldWith` folds a chain's records, and gives the place it stopped at.
+ */
+export function foldSharers(pose, subject, head, q, before, laned, dry, except, owed) {
+    const sharers = this.sharers;
+    const now = this.now;
+    while (q < sharers.length) {
+        const voice = sharers[q];
+        if (voice.id >= before)
+            break;
+        q++;
+        const rec = voice.state === 'pending' ? null : voice.everyone;
+        if (rec === null)
+            continue;
+        if (laned && voice.laned && !this.owedBy(owed, voice))
+            continue;
+        if (voice.id === except || voice.state === 'done')
+            continue;
+        open(voice, rec, head.slot);
+        const delta = this.read(voice, subject, now, dry, rec);
+        if (owed >= 0 && voice.laned)
+            this.lanes.paid(voice.id, owed, rec.weight);
+        q = this.shared(voice, head.slot, rec, q);
+        if (delta === null || this.w <= 0)
+            continue;
+        this.apply(pose, voice, rec, delta, this.w);
+    }
+    return q;
 }
 /** Whether the subject numbered `owed` reads laned `voice` from the general path this fill. */
 export function owedBy(owed, voice) {
@@ -359,15 +516,36 @@ export function foldLoci(subject, pose, head, laned, dry, except, owed) {
         k.n = 0;
         k.m = 0;
         k.names.length = 0;
-        for (let held = head; held !== null; held = held.next) {
-            const voice = held.voice;
-            if (voice === null || (laned && voice.laned && !this.owedBy(owed, voice)))
+        const sharers = this.sharers;
+        let q = 0;
+        let at = head;
+        while (at !== null || q < sharers.length) {
+            const mine = chainFirst(at, sharers, q);
+            let voice;
+            let rec;
+            if (mine) {
+                rec = at;
+                voice = rec.voice;
+                at = rec.next;
+            }
+            else {
+                voice = sharers[q++];
+                rec = voice.state === 'pending' ? null : voice.everyone;
+            }
+            if (voice === null || rec === null)
+                continue;
+            if (laned && voice.laned && !this.owedBy(owed, voice))
                 continue;
             if (voice.id === except || voice.state === 'done')
                 continue;
+            const held = rec;
+            if (!mine)
+                open(voice, held, head.slot);
             const delta = this.read(voice, subject, now, dry, held);
             if (owed >= 0 && voice.laned)
                 this.lanes.paid(voice.id, owed, held.weight);
+            if (!mine)
+                q = this.shared(voice, head.slot, held, q);
             if (delta === null)
                 continue;
             const locus = voice.spec.locus;
@@ -404,12 +582,16 @@ export function foldLoci(subject, pose, head, laned, dry, except, owed) {
                 const weight = k.weights[n];
                 if (weight > 0)
                     this.apply(pose, k.voices[n], k.helds[n], k.deltas[n], weight);
+                else
+                    unband(k.helds[n]);
                 continue;
             }
             const weight = this.foldLocus(k, group);
-            if (weight <= 0)
-                continue;
             const name = k.names[group];
+            if (!(weight > 0)) {
+                bands.get(name)?.fill(2);
+                continue;
+            }
             let on = bands.get(name);
             if (on === undefined) {
                 on = new Uint8Array(this.channels.length);
@@ -421,15 +603,18 @@ export function foldLoci(subject, pose, head, laned, dry, except, owed) {
                 k.values[slot] = undefined;
                 const key = this.names[slot];
                 const channel = this.channels[slot];
+                // A channel folds at the weight of the members that wrote it, not the whole locus.
+                const taken = k.taken[slot];
+                const w = taken > 1 ? 1 : taken;
                 if (channel.rest !== undefined && channel.scale) {
                     // pose[key] is the copy of rest this fold made, so it is ours to write into.
                     pose[key] = channel.fold
-                        ? channel.fold(pose[key], value, weight)
-                        : merged(channel, pose[key], channel.scale(value, weight));
+                        ? channel.fold(pose[key], value, w)
+                        : merged(channel, pose[key], channel.scale(value, w));
                     continue;
                 }
                 const band = on[slot];
-                const passes = this.passes(band === 0 ? undefined : band === 1, weight);
+                const passes = this.passes(band === 0 ? undefined : band === 1, w);
                 on[slot] = passes ? 1 : 2;
                 if (passes)
                     pose[key] = pose[key] === undefined ? copy(value) : merged(channel, pose[key], value);

package/dist/gather.d.ts

@@ -11,20 +11,26 @@ export declare function gatherLocus<I, O>(lanes: Lanes<I, O>, g: Locus<I, O>): v
 export declare function foldLocus<I, O>(lanes: Lanes<I, O>, lane: Lane<I, O>, g: Locus<I, O>): void;
 /** For a keys voice: the delta's value for each channel it writes, read once per phase. */
 export declare function gather<I, O>(this: Lanes<I, O>, lane: Lane<I, O>, delta: Record<string, unknown>): void;
-/** Folds what `gather` read into a subject's laned values. */
-export declare function fold<I, O>(this: Lanes<I, O>, lane: Lane<I, O>, slot: number, w: number): void;
+/** Folds what `gather` read into a subject's laned values, at `Arg.WEIGHT`. */
+export declare function fold<I, O>(this: Lanes<I, O>, lane: Lane<I, O>, slot: number): void;
 /**
- * Folds a delta a patch returned into a subject's laned values. The first few channels are read
- * at a site of their own, which in most mixes sees one channel name and stays fast, where one
- * site reading every name in turn slows every read.
+ * Folds a delta a patch returned into a subject's laned values, at `Arg.WEIGHT`. The first few
+ * channels are read at a site of their own, which in most mixes sees one channel name and stays
+ * fast, where one site reading every name in turn slows every read.
  */
-export declare function foldDelta<I, O>(this: Lanes<I, O>, chans: readonly Laned[], slot: number, delta: Record<string, unknown>, w: number): void;
+export declare function foldDelta<I, O>(this: Lanes<I, O>, chans: readonly Laned[], slot: number, delta: Record<string, unknown>): void;
 /** Folds a motion sample's axes, kept apart from `foldInto` so neither reads two array kinds. */
-export declare function foldRun<I, O>(this: Lanes<I, O>, ch: Laned, slot: number, xs: Float64Array, w: number): void;
-export declare function foldInto<I, O>(this: Lanes<I, O>, ch: Laned, slot: number, value: unknown, w: number): void;
+export declare function foldRun<I, O>(this: Lanes<I, O>, ch: Laned, slot: number, xs: Float64Array): void;
+/** Folds one channel's value into a subject's laned values, or its locus, at `Arg.WEIGHT`. */
+export declare function foldInto<I, O>(this: Lanes<I, O>, ch: Laned, slot: number, value: unknown): void;
 /**
  * Whether a rest-less channel's contribution passes the band, for the record `one` is folding: the
  * general path's `apply` decides it from the same band state on the same record, so a subject
  * moving between the paths carries it.
  */
-export declare function gate<I, O>(this: Lanes<I, O>, ch: Laned, w: number): boolean;
+export declare function gate<I, O>(this: Lanes<I, O>, ch: Laned): boolean;
+/**
+ * `foldInto` for a channel that is not plain, at `Arg.WEIGHT`. A rest-less one asks its band, and
+ * true is a pass, which `foldInto` then folds; a rotation is folded here, so false.
+ */
+export declare function unplain<I, O>(this: Lanes<I, O>, ch: Laned, slot: number, value: unknown): boolean;

package/dist/gather.js

@@ -1,4 +1,5 @@
 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. */
 function sized(xs, n) {
     if (xs.length >= n)
@@ -37,13 +38,11 @@ export function gatherLocus(lanes, g) {
                 continue;
             lanes.intoId = voice.id;
             lanes.reset(lane);
-            const elapsed = voice.elapsedAt(lanes.now);
-            const duration = voice.duration;
-            const passes = voice.passes;
+            lane.elapsedNow = voice.elapsedAt(lanes.now);
             const list = lane.list;
             for (let p = 0; p < list.length; p++) {
                 const slot = list[p];
-                if (lanes.one(lane, p, slot, elapsed, duration, passes)) {
+                if (lanes.one(lane, p, slot)) {
                     meetLocus(lanes, g, slot);
                     g.sum[slot] =
                         g.sum[slot] + lane.data[p * 8 /* Row.STRIDE */ + 2 /* Row.WEIGHT */];
@@ -68,8 +67,12 @@ function meetLocus(lanes, g, slot) {
         if (taken !== undefined)
             taken[slot] = 0;
 }
-/** A member's value for one channel of a subject, lerped into its locus: `foldLocus`'s step. */
-function gatherInto(lanes, g, ch, slot, value, w) {
+/**
+ * A member's value for one channel of a subject, lerped into its locus: the step of the general
+ * path's `foldLocus`.
+ */
+function gatherInto(lanes, g, ch, slot, value) {
+    const w = lanes.arg[0 /* Arg.WEIGHT */];
     meetLocus(lanes, g, slot);
     const k = ch.index;
     let values = g.values[k];
@@ -83,7 +86,9 @@ function gatherInto(lanes, g, ch, slot, value, w) {
     const taken = takenAt[slot];
     const total = taken + w;
     const u = w / total;
-    if (ch.scalar) {
+    if (!ch.plain)
+        turnToward(ch, values, slot * ch.axes, value, taken, u);
+    else if (ch.scalar) {
         values[slot] =
             taken === 0 ? value : lerpNumber(values[slot], value, u);
     }
@@ -110,15 +115,21 @@ export function foldLocus(lanes, lane, g) {
         const sum = g.sum[slot];
         if (sum <= 0)
             continue;
-        const w = sum > 1 ? 1 : sum;
         for (let k = 0; k < g.values.length; k++) {
             const takenAt = g.taken[k];
-            if (takenAt === undefined || !(takenAt[slot] > 0))
+            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;
+            }
             for (let a = 0; a < ch.axes; a++)
                 into[base + a] = foldNumber(ch.op, into[base + a], values[base + a], w);
         }
@@ -130,49 +141,56 @@ export function gather(lane, delta) {
     for (let i = 0; i < chans.length; i++)
         lane.values[i] = delta[chans[i].name];
 }
-/** Folds what `gather` read into a subject's laned values. */
-export function fold(lane, slot, w) {
+/** Folds what `gather` read into a subject's laned values, at `Arg.WEIGHT`. */
+export function fold(lane, slot) {
     const chans = lane.chans;
     for (let i = 0; i < chans.length; i++)
-        this.foldInto(chans[i], slot, lane.values[i], w);
+        this.foldInto(chans[i], slot, lane.values[i]);
 }
 /**
- * Folds a delta a patch returned into a subject's laned values. The first few channels are read
- * at a site of their own, which in most mixes sees one channel name and stays fast, where one
- * site reading every name in turn slows every read.
+ * Folds a delta a patch returned into a subject's laned values, at `Arg.WEIGHT`. The first few
+ * channels are read at a site of their own, which in most mixes sees one channel name and stays
+ * fast, where one site reading every name in turn slows every read.
  */
-export function foldDelta(chans, slot, delta, w) {
+export function foldDelta(chans, slot, delta) {
     const n = chans.length;
     let ch = chans[0];
     if (n > 0)
-        this.foldInto(ch, slot, delta[ch.name], w);
+        this.foldInto(ch, slot, delta[ch.name]);
     ch = chans[1];
     if (n > 1)
-        this.foldInto(ch, slot, delta[ch.name], w);
+        this.foldInto(ch, slot, delta[ch.name]);
     ch = chans[2];
     if (n > 2)
-        this.foldInto(ch, slot, delta[ch.name], w);
+        this.foldInto(ch, slot, delta[ch.name]);
     for (let i = 3; i < n; i++) {
         ch = chans[i];
-        this.foldInto(ch, slot, delta[ch.name], w);
+        this.foldInto(ch, slot, delta[ch.name]);
     }
 }
 /** Folds a motion sample's axes, kept apart from `foldInto` so neither reads two array kinds. */
-export function foldRun(ch, slot, xs, w) {
+export function foldRun(ch, slot, xs) {
+    if (!ch.plain) {
+        this.unplain(ch, slot, ch.scalar ? xs[0] : xs);
+        return;
+    }
+    const w = this.arg[0 /* Arg.WEIGHT */];
     const values = ch.values;
     const base = slot * ch.axes;
     for (let a = 0; a < ch.axes; a++)
         values[base + a] = foldNumber(ch.op, values[base + a], xs[a], w);
 }
-export function foldInto(ch, slot, value, w) {
+/** Folds one channel's value into a subject's laned values, or its locus, at `Arg.WEIGHT`. */
+export function foldInto(ch, slot, value) {
     if (value === undefined)
         return;
     if (this.into !== null) {
-        gatherInto(this, this.into, ch, slot, value, w);
+        gatherInto(this, this.into, ch, slot, value);
         return;
     }
-    if (ch.op === 'last' && !this.gate(ch, w))
+    if (!ch.plain && !this.unplain(ch, slot, value))
         return;
+    const w = this.arg[0 /* Arg.WEIGHT */];
     const values = ch.values;
     if (ch.scalar) {
         values[slot] = foldNumber(ch.op, values[slot], value, w);
@@ -191,7 +209,8 @@ export function foldInto(ch, slot, value, w) {
  * general path's `apply` decides it from the same band state on the same record, so a subject
  * moving between the paths carries it.
  */
-export function gate(ch, w) {
+export function gate(ch) {
+    const w = this.arg[0 /* Arg.WEIGHT */];
     const lane = this.folding;
     const rec = this.rec;
     const i = lane.chans.indexOf(ch);
@@ -202,3 +221,19 @@ export function gate(ch, w) {
     bands[i] = on ? 1 : 2;
     return on;
 }
+/**
+ * `foldInto` for a channel that is not plain, at `Arg.WEIGHT`. A rest-less one asks its band, and
+ * true is a pass, which `foldInto` then folds; a rotation is folded here, so false.
+ */
+export function unplain(ch, slot, value) {
+    if (ch.op === 'last')
+        return this.gate(ch);
+    const w = this.arg[0 /* Arg.WEIGHT */];
+    const values = ch.values;
+    // An angle here and not through `turnInto`, where its weight would cross a call as a boxed double.
+    if (ch.turn > 0)
+        values[slot] = values[slot] + shortWay(value, ch.turn) * w;
+    else
+        turnInto(ch, values, slot * ch.axes, value, w);
+    return false;
+}

package/dist/gone.d.ts

@@ -0,0 +1,32 @@
+import type { Mixer } from './mixer.js';
+import { Store } from './store.js';
+import type { Voice } from './voice.js';
+/**
+ * A mix's gone voices as `drop` and a freed slot look for them: those over every subject, and the
+ * rest by each subject they name. Kept in step with `gone`, which only grows by push and is
+ * otherwise replaced whole, so it catches up lazily and rebuilds only on a replacement it did not
+ * make itself. Under history a churning mix holds thousands, too many to walk per subject dropped.
+ */
+export declare class GoneIndex<I, O> {
+    /** The `gone` list it was built over, and how much of it. */
+    of: readonly Voice<I, O>[] | null;
+    count: number;
+    general: Voice<I, O>[];
+    named: Store<I, Voice<I, O>[]>;
+    /** The latest `doneAt` in `of`, and how far any voice finished before one listed ahead of it. */
+    latest: number;
+    slack: number;
+}
+/** The index caught up with `mix.gone`. */
+export declare function goneIndex<I, O>(mix: Mixer<I, O>): GoneIndex<I, O>;
+/**
+ * Keeps the gone voices `keep` says yes to, asking it once each, and takes the rest out of the
+ * index one by one. Leaves `gone` as it was when every one stays.
+ */
+export declare function keepGone<I, O>(mix: Mixer<I, O>, keep: (v: Voice<I, O>) => boolean): void;
+/**
+ * Lets go of the gone voices that finished before `reach`. Voices go in about the order they
+ * finish, so only the front can hold one: past the point where a voice finished `slack` after
+ * `reach`, none behind it finished before `reach`.
+ */
+export declare function expireGone<I, O>(mix: Mixer<I, O>, reach: number): void;