@msb235/blits 0.7.1 → 0.8.0

package/dist/revive.js

@@ -1,6 +1,7 @@
 import { playable } from './cue.js';
 import { VoiceHandle } from './handle.js';
 import { handle } from './hosts.js';
+import { Leavings } from './leavings.js';
 import { packHeld, unpackHeld } from './pack.js';
 import { pageOut } from './paging.js';
 import { Voice } from './voice.js';
@@ -47,7 +48,7 @@ export function pageVoice(mix, voice, reach) {
         return false;
     const keys = mix.keys;
     const data = packVoice(voice, keys);
-    pageOut(mix, 'voice', voice.id, undefined, [{ at: voice.doneAt }], () => data, reach);
+    pageOut(mix, 'voice', voice.id, undefined, [{ at: voice.doneAt, seq: voice.doneSeq }], () => data, reach);
     const h = voice.handle;
     VoiceHandle.page(h, { weight: voice.weight, played: voice.settled.played === true });
     mix.outs.add(voice.id, voice.doneAt, h);
@@ -81,8 +82,13 @@ function packVoice(voice, keys) {
         outAt: voice.outAt,
         outOver: voice.outOver,
         outSet: voice.outSet,
+        rebuilds: voice.rebuilds,
+        past: voice.clocks?.length ?? 0,
+        clocks: voice.clocks,
         cuedAt: voice.cuedAt,
+        cuedSeq: voice.cuedSeq,
         doneAt: voice.doneAt,
+        doneSeq: voice.doneSeq,
         opened: voice.opened,
         pinned: voice.pinned,
         latest: voice.latest,
@@ -91,11 +97,18 @@ function packVoice(voice, keys) {
         log: voice.log,
         played: settled.played,
         playedAt: settled.at,
+        playedSeq: settled.seq,
         records,
         runs,
-        left: (voice.left ?? []).map((e) => [keys.key(e.subject), e.at, packHeld(voice, e.held)]),
-        parts: [...(voice.parts ?? [])].map(([s, r]) => [keys.key(s), r.at, r.over]),
-        parted: [...(voice.parted ?? [])].map(([s, at]) => [keys.key(s), at]),
+        left: (voice.left?.all() ?? []).map((e) => [
+            keys.key(e.subject),
+            e.at,
+            e.seq,
+            packHeld(voice, e.held),
+            e.sync,
+        ]),
+        parts: [...(voice.parts ?? [])].map(([s, r]) => [keys.key(s), r.at, r.over, r.seq]),
+        parted: [...(voice.parted ?? [])].map(([s, p]) => [keys.key(s), p.at, p.seq]),
     };
 }
 /** A voice a history store paged out, rebuilt from its descriptor and put back as it left. */
@@ -106,18 +119,12 @@ export function reviveVoice(mix, id, d) {
     const spec = { ...revive(d.as), as: d.as };
     playable(mix, spec);
     const voice = new Voice(id, spec, spec.patch, spec.fade ?? {}, Number.NEGATIVE_INFINITY, d.start, mix.slotOf, mix.channels, mix.opts.host, mix.send, null);
-    voice.anchorNow = d.anchorNow;
-    voice.anchorElapsed = d.anchorElapsed;
-    voice.rate = d.rate;
-    voice.ramp = d.ramp;
-    voice.weight = d.weight;
-    voice.out = d.out;
-    voice.back = d.back;
-    voice.outAt = d.outAt;
-    voice.outOver = d.outOver;
-    voice.outSet = d.outSet;
+    voice.clocks = d.clocks;
+    voice.take(d);
     voice.cuedAt = d.cuedAt;
+    voice.cuedSeq = d.cuedSeq;
     voice.doneAt = d.doneAt;
+    voice.doneSeq = d.doneSeq;
     voice.opened = d.opened;
     voice.pinned = d.pinned;
     voice.latest = d.latest;
@@ -126,7 +133,7 @@ export function reviveVoice(mix, id, d) {
     voice.log = d.log;
     voice.state = 'done';
     if (d.played !== undefined)
-        voice.play(d.played, d.playedAt);
+        voice.play(d.played, d.playedAt, d.playedSeq);
     voice.resolve();
     const keys = mix.keys;
     const subjectOf = (key) => keys.subject(key);
@@ -137,16 +144,17 @@ export function reviveVoice(mix, id, d) {
     }
     for (const [key, run] of d.runs)
         voice.motion?.unpack(subjectOf(key), run);
-    if (d.left.length > 0)
-        voice.left = d.left.map(([key, at, p]) => ({
-            subject: subjectOf(key),
-            at,
-            held: unpackHeld(voice, p),
-        }));
+    voice.left = Leavings.from(d.left.map(([key, at, seq, p, sync]) => ({
+        subject: subjectOf(key),
+        at,
+        seq,
+        sync,
+        held: unpackHeld(voice, p),
+    })));
     if (d.parts.length > 0)
-        voice.parts = new Map(d.parts.map(([key, at, over]) => [subjectOf(key), { at, over }]));
+        voice.parts = new Map(d.parts.map(([key, at, over, seq]) => [subjectOf(key), { at, over, seq }]));
     if (d.parted.length > 0)
-        voice.parted = new Map(d.parted.map(([key, at]) => [subjectOf(key), at]));
+        voice.parted = new Map(d.parted.map(([key, at, seq]) => [subjectOf(key), { at, seq }]));
     const h = mix.outs?.take(id);
     if (h === undefined)
         voice.handle = handle(mix, voice);

package/dist/roster.d.ts

@@ -0,0 +1,11 @@
+import type { Mixer } from './mixer.js';
+import type { Voice } from './voice.js';
+/** Counts a voice just put in the list into everything a sync and a fold skip work by. */
+export declare function enlist<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): void;
+/**
+ * Counts a voice leaving the list back out. A voice naming no subject stays in `general` and
+ * `sharers`, which the caller filters once for every voice leaving together.
+ */
+export declare function delist<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): void;
+/** Counts the list over from nothing, for a seek or a projection's copy. `owners` is the caller's. */
+export declare function recount<I, O>(mix: Mixer<I, O>): void;

package/dist/roster.js

@@ -0,0 +1,46 @@
+import { index, unindex } from './chain.js';
+import { detour } from './everyone.js';
+import { Store } from './store.js';
+function tally(mix, voice, by) {
+    if (voice.spec.locus !== undefined)
+        mix.loci += by;
+    if (voice.spec.anchor !== undefined)
+        mix.anchored += by;
+}
+/** Counts a voice just put in the list into everything a sync and a fold skip work by. */
+export function enlist(mix, voice) {
+    if (voice.holding !== null) {
+        mix.owners ??= [];
+        mix.owners.push(voice);
+    }
+    index(mix, voice);
+    tally(mix, voice, 1);
+    detour(mix);
+}
+/**
+ * Counts a voice leaving the list back out. A voice naming no subject stays in `general` and
+ * `sharers`, which the caller filters once for every voice leaving together.
+ */
+export function delist(mix, voice) {
+    if (voice.named !== null)
+        unindex(mix, voice);
+    if (voice.holding !== null && mix.owners !== null)
+        mix.owners = mix.owners.filter((v) => v !== voice);
+    tally(mix, voice, -1);
+    detour(mix);
+}
+/** Counts the list over from nothing, for a seek or a projection's copy. `owners` is the caller's. */
+export function recount(mix) {
+    mix.named = new Store();
+    mix.naming = 0;
+    mix.general = [];
+    mix.sharers = [];
+    mix.loci = 0;
+    mix.anchored = 0;
+    for (const voice of mix.cued) {
+        index(mix, voice);
+        tally(mix, voice, 1);
+    }
+    detour(mix);
+    mix.steps.push(null, ++mix.version);
+}

package/dist/rotation.d.ts

@@ -0,0 +1,29 @@
+import { type Vec } from './channels.js';
+import type { Channel } from './types.js';
+/**
+ * What `angle` takes.
+ *
+ * @category channel
+ */
+export interface AngleOptions {
+    /** One full turn in the channel's unit. Default 360, for degrees; `2 * Math.PI` for radians. */
+    turn?: number;
+}
+/**
+ * A rotation about one axis, which adds as `sum` does and interpolates the short way round: from
+ * 350 to 10 it passes 0, not 180. A weight below 1 fades it the short way to rest too. Its values
+ * are angles, so two a whole number of turns apart are the same value, and a fold may answer with
+ * either.
+ *
+ * @category channel
+ */
+export declare function angle(opts?: AngleOptions): Channel<number>;
+/**
+ * A rotation in space, as a unit quaternion `[x, y, z, w]`. Contributions compose by the Hamilton
+ * product in the order their voices were cued, which matters: rotations do not commute. A weight
+ * turns a contribution part of the way from no rotation, along the short arc, and `lerp` takes the
+ * short arc between two.
+ *
+ * @category channel
+ */
+export declare function quat(): Channel<Vec<4>>;

package/dist/rotation.js

@@ -0,0 +1,91 @@
+import { doubles, vouch } from './channels.js';
+import { shortWay } from './turns.js';
+/**
+ * A rotation about one axis, which adds as `sum` does and interpolates the short way round: from
+ * 350 to 10 it passes 0, not 180. A weight below 1 fades it the short way to rest too. Its values
+ * are angles, so two a whole number of turns apart are the same value, and a fold may answer with
+ * either.
+ *
+ * @category channel
+ */
+export function angle(opts) {
+    const turn = opts?.turn ?? 360;
+    if (!(turn > 0))
+        throw new RangeError('blits: an angle takes a positive turn');
+    const channel = {
+        kind: `angle(${turn})`,
+        rest: 0,
+        merge: (a, b) => a + b,
+        scale: (v, w) => shortWay(v, turn) * w,
+        lerp: (a, b, u) => a + shortWay(b - a, turn) * u,
+    };
+    vouch(channel, { op: 'sum', axes: 1, turn });
+    return channel;
+}
+/** `a` then `b`, written into `out`, which may be either. */
+function multiply(out, a, b) {
+    const ax = a[0];
+    const ay = a[1];
+    const az = a[2];
+    const aw = a[3];
+    const bx = b[0];
+    const by = b[1];
+    const bz = b[2];
+    const bw = b[3];
+    out[0] = aw * bx + ax * bw + ay * bz - az * by;
+    out[1] = aw * by - ax * bz + ay * bw + az * bx;
+    out[2] = aw * bz + ax * by - ay * bx + az * bw;
+    out[3] = aw * bw - ax * bx - ay * by - az * bz;
+    return out;
+}
+/** The short arc from `a` to `b` at `u`, a unit quaternion, written into `out`. */
+function slerp(out, a, b, u) {
+    let dot = a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
+    // `q` and `-q` are one rotation; the nearer of the two is the short way.
+    const sign = dot < 0 ? -1 : 1;
+    dot *= sign;
+    let p = 1 - u;
+    let q = u;
+    // Nearly parallel, the arc's sine is too small to divide by, and a straight line is as good.
+    if (dot < 1 - 1e-9) {
+        const theta = Math.acos(dot);
+        const s = Math.sin(theta);
+        p = Math.sin((1 - u) * theta) / s;
+        q = Math.sin(u * theta) / s;
+    }
+    q *= sign;
+    const x = p * a[0] + q * b[0];
+    const y = p * a[1] + q * b[1];
+    const z = p * a[2] + q * b[2];
+    const w = p * a[3] + q * b[3];
+    const n = Math.sqrt(x * x + y * y + z * z + w * w) || 1;
+    out[0] = x / n;
+    out[1] = y / n;
+    out[2] = z / n;
+    out[3] = w / n;
+    return out;
+}
+const IDENTITY = [0, 0, 0, 1];
+const scratch = doubles(4, 0);
+/**
+ * A rotation in space, as a unit quaternion `[x, y, z, w]`. Contributions compose by the Hamilton
+ * product in the order their voices were cued, which matters: rotations do not commute. A weight
+ * turns a contribution part of the way from no rotation, along the short arc, and `lerp` takes the
+ * short arc between two.
+ *
+ * @category channel
+ */
+export function quat() {
+    const rest = doubles(4, 0);
+    rest[3] = 1;
+    const channel = {
+        kind: 'quat',
+        rest: rest,
+        merge: (a, b) => multiply(doubles(4, 0), a, b),
+        scale: (v, w) => slerp(doubles(4, 0), IDENTITY, v, w),
+        fold: (into, v, w) => multiply(into, into, slerp(scratch, IDENTITY, v, w)),
+        lerp: (a, b, u) => slerp(doubles(4, 0), a, b, u),
+    };
+    vouch(channel, { op: 'own', axes: 4 });
+    return channel;
+}

package/dist/rows.d.ts

@@ -15,19 +15,19 @@ export declare function sameCrowds<I, O>(lanes: Lanes<I, O>, members: readonly V
  */
 export declare function regroup<I, O>(lanes: Lanes<I, O>, members: Voice<I, O>[]): void;
 /**
- * Gives a voice the next row of its channel's crowd, made if there is none: a copy of the row it
+ * Gives a voice the next row of its channels' crowd, made if there is none: a copy of the row it
  * had in `from` at `at`, or a new one. `old` holds the crowds being replaced, whose idle state a
- * new crowd on the same channel keeps. Rows stay in voice order only because voices join in it.
+ * new crowd on the same channels keeps. Rows stay in voice order only because voices join in it.
  */
 export declare function join<I, O>(lanes: Lanes<I, O>, v: Voice<I, O>, from: Crowd<I, O> | undefined, at: number | undefined, old: readonly Crowd<I, O>[]): void;
 /** A crowd row takes up its voice as it now stands: opened once it starts, its fields copied again. */
 export declare function retouchRow<I, O>(lanes: Lanes<I, O>, c: Crowd<I, O>, p: number, v: Voice<I, O>): void;
 /**
- * Compacts every crowd a quarter or more empty rows: each fill walks every row, and at half a
- * crowd replacing a voice a frame carried as many empty rows as live ones.
+ * Compacts every crowd a quarter or more empty rows, past 64 of them: each fill walks every row,
+ * and at half a crowd replacing a voice a frame carried as many empty rows as live ones.
  */
 export declare function compactSparse<I, O>(lanes: Lanes<I, O>): void;
-/** A crowd voice left: its row stays, empty, until the crowds are next rebuilt. */
+/** A crowd voice left: its row stays, empty, until the crowd is compacted or rebuilt. */
 export declare function bury<I, O>(lanes: Lanes<I, O>, c: Crowd<I, O>, p: number): void;
 /** A crowd row's weight as `reported` reads a lane position's. */
 export declare function reportedRow<I, O>(lanes: Lanes<I, O>, c: Crowd<I, O>, p: number, slot: number): number | undefined;

package/dist/rows.js

@@ -75,9 +75,9 @@ export function regroup(lanes, members) {
     }
 }
 /**
- * Gives a voice the next row of its channel's crowd, made if there is none: a copy of the row it
+ * Gives a voice the next row of its channels' crowd, made if there is none: a copy of the row it
  * had in `from` at `at`, or a new one. `old` holds the crowds being replaced, whose idle state a
- * new crowd on the same channel keeps. Rows stay in voice order only because voices join in it.
+ * new crowd on the same channels keeps. Rows stay in voice order only because voices join in it.
  */
 export function join(lanes, v, from, at, old) {
     const chans = v.slots.map((s) => lanes.bySlot[s]);
@@ -113,8 +113,8 @@ export function retouchRow(lanes, c, p, v) {
     c.hot[h + 0 /* Hot.FLAGS */] = c.hot[h + 0 /* Hot.FLAGS */] | 64 /* Flag.VOICE */;
 }
 /**
- * Compacts every crowd a quarter or more empty rows: each fill walks every row, and at half a
- * crowd replacing a voice a frame carried as many empty rows as live ones.
+ * Compacts every crowd a quarter or more empty rows, past 64 of them: each fill walks every row,
+ * and at half a crowd replacing a voice a frame carried as many empty rows as live ones.
  */
 export function compactSparse(lanes) {
     for (const c of lanes.crowds)
@@ -154,7 +154,7 @@ function compact(c) {
     c.laws.length = q;
     c.dead = 0;
 }
-/** A crowd voice left: its row stays, empty, until the crowds are next rebuilt. */
+/** A crowd voice left: its row stays, empty, until the crowd is compacted or rebuilt. */
 export function bury(lanes, c, p) {
     const v = c.voices[p];
     leaveCrowd(lanes, c, p);

package/dist/sample.d.ts

@@ -11,9 +11,10 @@ export declare function runMotion<I, O>(lanes: Lanes<I, O>, lane: Lane<I, O>, ru
  * A motion voice's value for a subject, sampled from the patch's state as its `at` would, but only
  * where that sample changes nothing: one with a change to stamp, commit or let go of goes to the
  * general path, which samples it if and when a probe asks, as it would with no lanes. A probe
- * this frame already read keeps the value it read, as the general path's record would.
+ * this frame already read keeps the value it read, as the general path's record would. The
+ * subject's voice time, delay and weight are in `Arg`.
  */
-export declare function move<I, O>(lanes: Lanes<I, O>, lane: Positions<I, O>, run: Motions<I>, p: number, slot: number, held: Subject<unknown>, elapsed: number, delay: number, w: number): void;
+export declare function move<I, O>(lanes: Lanes<I, O>, lane: Positions<I, O>, run: Motions<I>, p: number, slot: number, held: Subject<unknown>): void;
 /**
  * A probe this frame read a motion voice's value for the subject from an earlier fill: write onto
  * its record what the general path's sample would have, so a later read this frame reuses it.

package/dist/sample.js

@@ -1,6 +1,6 @@
 import { unbareLane } from './bare.js';
 import { foldNumber } from './channels.js';
-import { clampWeight, passAt, weighed } from './clock.js';
+import { clampWeight, passAt, same, weighed } from './clock.js';
 import { absent } from './numbers.js';
 import { reading } from './reading.js';
 import { between, left, progress } from './tweened.js';
@@ -26,6 +26,7 @@ export function runMotion(lanes, lane, run) {
     // On a frame's first fill no probe has read a subject yet, so none needs `move` for that.
     const probed = lanes.probes !== from;
     const whole = clampWeight(voice.weight);
+    const arg = lanes.arg;
     const n = run.n;
     const op = ch.op;
     if (n > 0) {
@@ -48,7 +49,7 @@ export function runMotion(lanes, lane, run) {
         run.watchId = voice.id;
     }
     const own = ease !== undefined && !signal && run.watcher === lanes && run.watchId === voice.id;
-    const folds = n === ch.axes;
+    const folds = n === ch.axes && ch.plain;
     for (let p = 0; p < list.length; p++) {
         // Its signal just made kept state: no further call this fill, the general path makes them.
         if (signal && voice.keeping)
@@ -64,14 +65,14 @@ export function runMotion(lanes, lane, run) {
         }
         const delay = data[o + 0 /* Row.DELAY */];
         const elapsed = elapsedNow - delay;
-        if (elapsed < 0) {
+        if (!(elapsed >= 0)) {
             unbareLane(lane, p);
             data[o + 2 /* Row.WEIGHT */] = 0;
             continue;
         }
         if (!flat) {
             const since = data[o + 1 /* Row.SINCE */];
-            if (!lane.weighed || !Object.is(since, lane.weighedSince)) {
+            if (!lane.weighed || !same(since, lane.weighedSince)) {
                 lane.fade = lanes.host.envelope(voice, since);
                 lane.weighed = true;
                 lane.weighedSince = since;
@@ -79,11 +80,14 @@ export function runMotion(lanes, lane, run) {
         }
         let w;
         if (signal) {
-            w = lanes.signalled(voice, slot, records[p], elapsed, passAt(elapsed, voice.duration, voice.passes), lane.fade);
-            if (Number.isNaN(w)) {
+            arg[1 /* Arg.ELAPSED */] = elapsed;
+            arg[3 /* Arg.PASS */] = passAt(elapsed, voice.duration, voice.passes);
+            arg[5 /* Arg.FADE */] = lane.fade;
+            if (!lanes.signalled(voice, slot, records[p])) {
                 data[o + 2 /* Row.WEIGHT */] = 0;
                 continue;
             }
+            w = arg[0 /* Arg.WEIGHT */];
         }
         else
             w = flat && !parts ? whole : weighed(voice.weight, lane.fade, lanes.parting(voice, slot));
@@ -102,7 +106,10 @@ export function runMotion(lanes, lane, run) {
             (probed &&
                 (per[q + 3 /* Per.LANE_PROBE */] > from ||
                     per[q + 4 /* Per.GENERAL_PROBE */] > from))) {
-            move(lanes, lane, run, p, slot, records[p], elapsed, delay, w);
+            arg[1 /* Arg.ELAPSED */] = elapsed;
+            arg[4 /* Arg.DELAY */] = delay;
+            arg[0 /* Arg.WEIGHT */] = w;
+            move(lanes, lane, run, p, slot, records[p]);
             continue;
         }
         const runs = run.runs;
@@ -123,7 +130,7 @@ export function runMotion(lanes, lane, run) {
             continue;
         }
         if (ease !== undefined) {
-            // A tween's closed form, read straight from its run: release time, seconds, `x0`, `to`.
+            // A tween's closed form, read straight from its run: release time, length, `x0`, `to`.
             const share = left(ease, progress(elapsed, runs[b], runs[b + 2]));
             const x = b + 3;
             const g = x + 2 * n;
@@ -146,8 +153,10 @@ export function runMotion(lanes, lane, run) {
             for (let a = 0; a < n; a++)
                 values[base + a] = foldNumber(op, values[base + a], xs[a], w);
         }
-        else
-            lanes.foldInto(ch, slot, run.value(ms, xs), w);
+        else {
+            arg[0 /* Arg.WEIGHT */] = w;
+            lanes.foldInto(ch, slot, run.value(ms, xs));
+        }
     }
     if (own) {
         lane.bareFill = fills;
@@ -159,14 +168,22 @@ export function runMotion(lanes, lane, run) {
  * A motion voice's value for a subject, sampled from the patch's state as its `at` would, but only
  * where that sample changes nothing: one with a change to stamp, commit or let go of goes to the
  * general path, which samples it if and when a probe asks, as it would with no lanes. A probe
- * this frame already read keeps the value it read, as the general path's record would.
+ * this frame already read keeps the value it read, as the general path's record would. The
+ * subject's voice time, delay and weight are in `Arg`.
  */
-export function move(lanes, lane, run, p, slot, held, elapsed, delay, w) {
+export function move(lanes, lane, run, p, slot, held) {
+    const elapsed = lanes.arg[1 /* Arg.ELAPSED */];
+    const delay = lanes.arg[4 /* Arg.DELAY */];
+    const w = lanes.arg[0 /* Arg.WEIGHT */];
     const voice = lane.voiceAt(p);
     const data = lane.data;
     const o = p * 8 /* Row.STRIDE */;
     const ch = lane.chans[0];
     settle(lanes, lane, p, slot, held);
+    // The general path never samples a voice at weight 0, so the motion neither numbers the subject
+    // nor runs on for it, and `inert` reads the same.
+    if (!(w > 0))
+        return;
     const delta = held.delta;
     if (delta === null ||
         held.probed !== lanes.now ||
@@ -200,16 +217,16 @@ export function move(lanes, lane, run, p, slot, held, elapsed, delay, w) {
             return;
         // A sample of other axes than the channel's folds as the general path folds it.
         if (n === ch.axes && run.scalar(ms) === ch.scalar)
-            lanes.foldRun(ch, slot, run.xs, w);
+            lanes.foldRun(ch, slot, run.xs);
         else
-            lanes.foldInto(ch, slot, run.value(ms, run.xs), w);
+            lanes.foldInto(ch, slot, run.value(ms, run.xs));
         return;
     }
     lane.deltas[p] = delta;
     data[o + 5 /* Row.SAMPLED */] = lanes.fills;
     data[o + 6 /* Row.SEEKS */] = voice.seeks;
     if (w > 0)
-        lanes.foldInto(ch, slot, delta[ch.name], w);
+        lanes.foldInto(ch, slot, delta[ch.name]);
 }
 /** The delta a motion voice's last sample for position `p` made, built from `samples`. */
 function sampled(lane, p) {