@msb235/blits 0.7.1 → 0.8.1

package/dist/fold.js

@@ -1,12 +1,16 @@
 import { frozenTime, passAt, phaseAt, silent } from './clock.js';
-import { copy as copyValue } from './clone.js';
+import { copy as copyValue, first } 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;
@@ -257,25 +298,62 @@ export function apply(pose, voice, held, delta, weight) {
         const on = this.passes(band === 0 ? undefined : band === 1, weight);
         bands[i] = on ? 1 : 2;
         if (on)
-            pose[key] = pose[key] === undefined ? copy(value) : merged(channel, pose[key], value);
+            pose[key] = pose[key] === undefined ? first(value) : merged(channel, pose[key], value);
     }
 }
 /** 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,18 +603,21 @@ 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);
+                    pose[key] = pose[key] === undefined ? first(value) : merged(channel, pose[key], value);
             }
         }
         return pose;

package/dist/frames.d.ts

@@ -0,0 +1,21 @@
+import type { Frame } from './transport.js';
+/**
+ * The frames a transport's history can still reach, oldest first. A frame leaves the front on
+ * most syncs, so the front is an index that moves and the array closes up only now and then.
+ */
+export declare class Frames {
+    private list;
+    private head;
+    get length(): number;
+    push(frame: Frame): void;
+    /** Lets go of every frame before the last one at or before `reach`, giving each to `each`. */
+    shed(reach: number, each?: (frame: Frame) => void): void;
+    /**
+     * The frame a seek or read to mix time `t` lands on: the last one standing at or before `t`,
+     * since rate 0 can hold the clock at `t` for many.
+     */
+    at(t: number): Frame | undefined;
+    /** Every frame held, oldest first. */
+    all(): Frame[];
+    set(frames: Frame[]): void;
+}

package/dist/frames.js

@@ -0,0 +1,59 @@
+/** Past this many frames let go of at the front, the list is closed up, once they are half of it. */
+const SLACK = 512;
+/**
+ * The frames a transport's history can still reach, oldest first. A frame leaves the front on
+ * most syncs, so the front is an index that moves and the array closes up only now and then.
+ */
+export class Frames {
+    list = [];
+    head = 0;
+    get length() {
+        return this.list.length - this.head;
+    }
+    push(frame) {
+        this.list.push(frame);
+    }
+    /** Lets go of every frame before the last one at or before `reach`, giving each to `each`. */
+    shed(reach, each) {
+        const list = this.list;
+        let head = this.head;
+        while (head + 1 < list.length && list[head + 1].at <= reach) {
+            each?.(list[head]);
+            head++;
+        }
+        if (head >= SLACK && head * 2 >= list.length) {
+            list.splice(0, head);
+            head = 0;
+        }
+        this.head = head;
+    }
+    /**
+     * The frame a seek or read to mix time `t` lands on: the last one standing at or before `t`,
+     * since rate 0 can hold the clock at `t` for many.
+     */
+    at(t) {
+        const list = this.list;
+        let lo = this.head;
+        let hi = list.length - 1;
+        let found;
+        while (lo <= hi) {
+            const mid = (lo + hi) >> 1;
+            const f = list[mid];
+            if (f.at <= t) {
+                found = f;
+                lo = mid + 1;
+            }
+            else
+                hi = mid - 1;
+        }
+        return found;
+    }
+    /** Every frame held, oldest first. */
+    all() {
+        return this.list.slice(this.head);
+    }
+    set(frames) {
+        this.list = frames;
+        this.head = 0;
+    }
+}

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;