@msb235/blits 0.7.0 → 0.8.0

package/dist/patch.js

@@ -1,5 +1,5 @@
-import { lerpInto } from './channels.js';
-import { curve } from './easing.js';
+import { lerpInto, lerpNumber } from './channels.js';
+import { curve, startSlope } from './easing.js';
 /**
  * The procedural form. Flicker, roving, a hash walk, a starter strike.
  *
@@ -12,7 +12,6 @@ export function patch(duration, at, opts) {
     return {
         form: 'fn',
         duration,
-        period: duration,
         writes,
         kit: opts.kit,
         reads: opts.reads,
@@ -23,11 +22,6 @@ export function patch(duration, at, opts) {
         unpack: opts.unpack,
     };
 }
-const options = new WeakMap();
-/** The options a `keys` patch was built with, for an engine reading its stops rather than calling it. */
-export function keysOptionsOf(p) {
-    return options.get(p);
-}
 const linear = (a, b, u) => a + (b - a) * u;
 function interpolate(a, b, u) {
     if (typeof a === 'number' && typeof b === 'number')
@@ -64,6 +58,10 @@ function build(stops, writes, duration, opts) {
         }
         all.sort((x, y) => x.at - y.at);
         const tail = all.filter((pt) => pt.at !== 0);
+        const lerp = opts.lerpBy?.(channel) ?? opts.kit?.[channel]?.lerp;
+        const plain = all.length > 0 &&
+            (lerp === undefined || lerp === lerpNumber) &&
+            all.every((pt) => typeof pt.value === 'number');
         tracks.push({
             channel: channel,
             all,
@@ -71,7 +69,14 @@ function build(stops, writes, duration, opts) {
             ats: all.map((pt) => pt.at),
             tailAts: null,
             delay: opts.delayBy?.(channel) ?? 0,
-            lerp: opts.lerpBy?.(channel) ?? opts.kit?.[channel]?.lerp,
+            lerp,
+            numbers: plain
+                ? {
+                    ats: Float64Array.from(all, (pt) => pt.at),
+                    values: Float64Array.from(all, (pt) => pt.value),
+                    eases: all.map((pt) => pt.ease),
+                }
+                : null,
         });
     }
     return { tracks, duration };
@@ -100,12 +105,17 @@ export function shifted(track, phase, duration) {
 }
 /** A phase once a channel's delay of `delay` ms in a duration of `duration` applies. */
 export function shift(delay, phase, duration) {
-    return delay === 0 || duration === 0 ? phase : Math.max(0, (phase * duration - delay) / duration);
+    if (delay === 0 || duration === 0)
+        return phase;
+    // The channel travels in what is left after its wait, so it lands with the rest at phase 1.
+    if (delay >= duration)
+        return phase >= 1 ? 1 : 0;
+    return Math.max(0, (phase * duration - delay) / (duration - delay));
 }
 /**
  * Where `phase` falls among `n` stop phases `ats[off + k * stride]`, in order: -2 for no stops, -1
  * at or before the first, `n` at or past the last, and otherwise the first stop past it, where the
- * segment from the one before ends. With `segment`'s, the one copy of the search.
+ * segment from the one before ends. `segment` and `readNumber` make the same search.
  */
 export function locate(ats, off, stride, n, phase) {
     if (n === 0)
@@ -132,8 +142,8 @@ export function fraction(phase, a, b) {
     return (phase - a) / (b - a);
 }
 /**
- * Finds where one track is at a phase, into `seg`: the one copy of the search, which `read` and a
- * lane folding stops straight into a subject's values both make. `base` stands in for the value at
+ * Finds where one track is at a phase, into `seg`: the search `read` and a lane folding stops
+ * straight into a subject's values both make. `base` stands in for the value at
  * phase 0, which is how `from: 'current'` starts a voice wherever the subject already is.
  */
 export function segment(track, phase, base) {
@@ -179,10 +189,44 @@ export function segment(track, phase, base) {
     seg.ease = b.ease;
     return BETWEEN;
 }
+/**
+ * A plain-number track at a phase, in exactly `segment`'s and `read`'s arithmetic: the stop at or
+ * past the phase by binary search, the fraction before easing, then a straight lerp.
+ */
+function readNumber(t, phase) {
+    const ats = t.ats;
+    const values = t.values;
+    const n = ats.length;
+    if (phase <= ats[0])
+        return values[0];
+    if (phase >= ats[n - 1])
+        return values[n - 1];
+    let lo = 1;
+    let hi = n - 1;
+    while (lo < hi) {
+        const mid = (lo + hi) >> 1;
+        if (ats[mid] >= phase)
+            hi = mid;
+        else
+            lo = mid + 1;
+    }
+    const a = ats[lo - 1];
+    const u = (phase - a) / (ats[lo] - a);
+    const ease = t.eases[lo];
+    const eased = ease ? ease(u) : u;
+    const from = values[lo - 1];
+    return from + (values[lo] - from) * eased;
+}
 /** Reads one track at a phase; `base` as `segment` takes it. */
 function read(track, phase, base, lerp, 
 /** Units per ms, for a retarget's first segment. */
 slope, duration, into, reuse) {
+    const numbers = track.numbers;
+    if (numbers !== null &&
+        base === undefined &&
+        slope === undefined &&
+        (lerp === undefined || lerp === lerpNumber || track.lerp !== undefined))
+        return readNumber(numbers, phase);
     const found = segment(track, phase, base);
     if (found === NOTHING)
         return undefined;
@@ -208,7 +252,9 @@ slope, duration, into, reuse) {
     // add c·u(1−u)², which is 0 at both ends, flat at the end, and fixes the slope at the start.
     if (slope === undefined || !first)
         return value;
-    const e0 = ease ? ease(1e-6) / 1e-6 : 1;
+    const e0 = ease ? startSlope(ease) : 1;
+    if (e0 === Number.POSITIVE_INFINITY)
+        return value;
     const bend = (s, a, z) => (s * duration * len - (z - a) * e0) * u * (1 - u) * (1 - u);
     if (typeof value === 'number' && typeof slope === 'number')
         return value + bend(slope, aValue, bValue);
@@ -262,14 +308,15 @@ slopes, intos, scratch) {
     }
     return out;
 }
-/** A patch's `duration`, or the deprecated `period` where only that is set. */
-export const durationOf = (p) => p.duration ?? p.period ?? 0;
 const cache = new WeakMap();
-/** The built form of a patch's stops, made on first ask for a patch `keys()` did not build. */
+/**
+ * The built form of a patch's stops, made on first ask for a patch `keys()` did not build: a copy
+ * of one, or one another copy of blits made, each read by the fields it carries.
+ */
 export function builtOf(p) {
     let held = cache.get(p);
     if (held === undefined) {
-        held = build(p.keys, p.writes, durationOf(p), keysOptionsOf(p) ?? {});
+        held = build(p.keys, p.writes, p.duration, p);
         cache.set(p, held);
     }
     return held;
@@ -289,13 +336,28 @@ export function keys(duration, stops, opts = {}) {
     const p = {
         form: 'keys',
         duration,
-        period: duration,
         writes,
         kit: opts.kit,
         keys: stops,
-        at: (phase) => readKeys(made, phase, {}),
+        ...given(opts),
+        // A copy of the patch carries this `at` with fields of its own, which it is read by.
+        at(phase) {
+            return readKeys(this === p ? made : builtOf(this), phase, {});
+        },
     };
-    options.set(p, opts);
     cache.set(p, made);
     return p;
 }
+/** The `keys` options a patch carries as fields, those given only: an absent one adds no key. */
+function given(opts) {
+    const out = {};
+    if (opts.ease !== undefined)
+        out.ease = opts.ease;
+    if (opts.easeBy !== undefined)
+        out.easeBy = opts.easeBy;
+    if (opts.delayBy !== undefined)
+        out.delayBy = opts.delayBy;
+    if (opts.lerpBy !== undefined)
+        out.lerpBy = opts.lerpBy;
+    return out;
+}

package/dist/place.js

@@ -1,6 +1,9 @@
+import { departedMatches } from './departed.js';
+import { reorigin } from './held.js';
 import { noted } from './history.js';
 import { markOf } from './marks.js';
 import { mixTime, ownerReading } from './owner.js';
+import { holders, scored, scoredGone, scoreVersion, unhold } from './scored.js';
 import { none } from './voice.js';
 /** What a voice's own owner's clock reads now: the mix clock for a voice no owner holds. */
 export function localNow(mix, voice) {
@@ -36,6 +39,10 @@ function startAt(mix, voice, start) {
     voice.start = start;
     voice.anchorNow = start;
     voice.anchorElapsed = 0;
+    voice.clocks = null;
+    // A clock moved outright, as a seek moves it: what a record computed at this mix time is stale.
+    voice.seeks++;
+    reorigin(mix, voice, mix.now);
     noted(mix, voice);
     return true;
 }
@@ -178,7 +185,7 @@ function resolve(mix, a, self) {
         mark = 'start';
         by = -by;
     }
-    const t = timeOf(mix, typeof query === 'string' ? { name: query } : query, mark, self);
+    const t = timeOf(mix, query, mark, self);
     if (t === undefined)
         return undefined;
     if (o === null)
@@ -200,46 +207,197 @@ function member(mix, a, self) {
     }
     return t;
 }
+/** Picks among the times a query meets, as its resolver says, in the order they are met. */
+class Pick {
+    resolver;
+    now;
+    any = false;
+    firstOrder = Number.POSITIVE_INFINITY;
+    lastOrder = Number.NEGATIVE_INFINITY;
+    first;
+    last;
+    pick;
+    constructor(resolver, now) {
+        this.resolver = resolver;
+        this.now = now;
+    }
+    take(order, t) {
+        this.any = true;
+        if (order < this.firstOrder) {
+            this.firstOrder = order;
+            this.first = t;
+        }
+        if (order > this.lastOrder) {
+            this.lastOrder = order;
+            this.last = t;
+        }
+        if (t !== undefined)
+            this.consider(t);
+    }
+    /** Takes what `o` picked as though its times had been met here. */
+    merge(o) {
+        if (!o.any)
+            return;
+        this.any = true;
+        if (o.firstOrder < this.firstOrder) {
+            this.firstOrder = o.firstOrder;
+            this.first = o.first;
+        }
+        if (o.lastOrder > this.lastOrder) {
+            this.lastOrder = o.lastOrder;
+            this.last = o.last;
+        }
+        if (o.pick !== undefined)
+            this.consider(o.pick);
+    }
+    consider(t) {
+        const p = this.pick;
+        if (this.resolver === 'earliest'
+            ? p === undefined || t < p
+            : this.resolver === 'latest'
+                ? p === undefined || t > p
+                : this.resolver === 'next' && t >= this.now && (p === undefined || t < p))
+            this.pick = t;
+    }
+    answer() {
+        if (!this.any)
+            return undefined;
+        if (this.resolver === 'first')
+            return this.first;
+        if (this.resolver === 'last')
+            return this.last;
+        return this.pick;
+    }
+}
 /**
  * The mix time a query answers: `mark` of the voice it picks, among those cued and those that have
  * left, never the asker; or a mark the host announced on the score, which is the same time for
- * any of the four. Undefined while what it picks has no such time. A query naming no score looks
+ * any mark. Undefined while what it picks has no such time. A query naming no score looks
  * among the asker's siblings, the voices its owner holds.
  */
-function timeOf(mix, q, mark, self) {
+function timeOf(mix, key, mark, self) {
+    const q = typeof key === 'string' ? { name: key } : key;
     const score = q.score ?? self.spec.score;
     const anywhere = q.score !== undefined;
-    const found = [];
-    // A query naming a score looks in every mix on the transport; one naming none, in its own.
-    const mixes = anywhere ? mix.transport.members : [mix];
-    for (const m of mixes)
-        for (const v of [...m.gone, ...m.cued])
-            if (v !== self &&
-                v.spec.score === score &&
-                (anywhere || v.owner === self.owner) &&
-                (q.name === undefined || v.spec.name === q.name) &&
-                (q.tag === undefined || (v.spec.tags ?? none).includes(q.tag)) &&
-                (q.writes === undefined || v.patch.writes.includes(q.writes)))
-                found.push({ order: v.id, t: markOf(m, v, mark) });
+    const resolver = q.resolver ?? 'last';
+    const now = Number.isNaN(mix.now) ? Number.NEGATIVE_INFINITY : mix.now;
+    const picked = new Pick(resolver, now);
+    const matches = (v) => v !== self &&
+        v.spec.score === score &&
+        (anywhere || v.owner === self.owner) &&
+        (q.name === undefined || v.spec.name === q.name) &&
+        (q.tag === undefined || (v.spec.tags ?? none).includes(q.tag)) &&
+        (q.writes === undefined || v.patch.writes.includes(q.writes));
+    // A query naming a score looks in every mix on the transport that holds a voice on it; one
+    // naming none, in its own.
+    const listed = anywhere && score !== undefined && !mix.projecting;
+    const mixes = !anywhere
+        ? [mix]
+        : listed
+            ? holders(mix, score)
+            : mix.transport.members;
+    // Voices forgotten on leaving answer only where no voice the mix still knows does.
+    const owner = self.owner?.id ?? -1;
+    const forgotten = new Pick(resolver, now);
+    for (let i = 0; i < mixes.length; i++) {
+        const m = mixes[i];
+        let departed = false;
+        for (const d of m.departed.all)
+            if (departedMatches(d, q, score, anywhere, owner)) {
+                forgotten.take(d.id, d.marks[mark]);
+                departed = true;
+            }
+        if (score === undefined || m.projecting || mix.projecting) {
+            for (const v of [...m.gone, ...m.cued])
+                if (matches(v))
+                    picked.take(v.id, markOf(m, v, mark));
+            continue;
+        }
+        const cued = scored(m, score);
+        const list = scoredGone(m, score);
+        if (cued.size === 0 && list.length === 0 && !departed) {
+            if (listed) {
+                unhold(m, score);
+                i--;
+            }
+            continue;
+        }
+        // `next` asks what is still ahead of now, which a running pick cannot keep.
+        if (resolver === 'next') {
+            for (const v of cued)
+                if (matches(v))
+                    picked.take(v.id, markOf(m, v, mark));
+            for (const v of list)
+                if (matches(v))
+                    picked.take(v.id, markOf(m, v, mark));
+            continue;
+        }
+        const fold = foldOf(m, list, key, mark, self, resolver);
+        const version = scoreVersion(m, score);
+        const reduced = m.reduced;
+        if (fold.live === null ||
+            fold.liveOf !== m.cued ||
+            fold.liveVersion !== version ||
+            fold.liveReduced !== reduced) {
+            const live = new Pick(resolver, Number.NEGATIVE_INFINITY);
+            let keeps = true;
+            for (const v of cued) {
+                if (!matches(v))
+                    continue;
+                if (v.owner !== null || v.holding !== null || v.fitting !== null)
+                    keeps = false;
+                live.take(v.id, markOf(m, v, mark));
+            }
+            fold.live = live;
+            fold.liveOf = keeps ? m.cued : null;
+            fold.liveVersion = version;
+            fold.liveReduced = reduced;
+        }
+        picked.merge(fold.live);
+        for (; fold.seen < list.length; fold.seen++) {
+            const v = list[fold.seen];
+            if (!matches(v))
+                continue;
+            if (v.owner === null)
+                fold.pick.take(v.id, markOf(m, v, mark));
+            else
+                fold.owned.push(v);
+        }
+        picked.merge(fold.pick);
+        for (const v of fold.owned)
+            picked.take(v.id, markOf(m, v, mark));
+    }
     if (q.writes === undefined && (anywhere || self.owner === null))
         for (const a of mix.announced)
             if (a.score === score &&
                 (score !== undefined || a.slot === mix.slot) &&
                 (q.name === undefined || a.name === q.name) &&
                 (q.tag === undefined || a.tags.includes(q.tag)))
-                found.push({ order: a.order, t: Number.isNaN(a.at) ? undefined : mixAt(mix, a.at) });
-    if (found.length === 0)
-        return undefined;
-    found.sort((x, y) => x.order - y.order);
-    const resolver = q.resolver ?? 'last';
-    if (resolver === 'first')
-        return found[0]?.t;
-    if (resolver === 'last')
-        return found[found.length - 1]?.t;
-    const times = found.flatMap((e) => (e.t === undefined ? [] : [e.t])).sort((x, y) => x - y);
-    if (resolver === 'next') {
-        const now = Number.isNaN(mix.now) ? Number.NEGATIVE_INFINITY : mix.now;
-        return times.find((t) => t >= now);
-    }
-    return resolver === 'earliest' ? times[0] : times[times.length - 1];
+                picked.take(a.order, Number.isNaN(a.at) ? undefined : mixAt(mix, a.at));
+    return (picked.any ? picked : forgotten).answer();
+}
+/** `self`'s read of `m`'s gone voices for one query, started over where the list has changed under it. */
+function foldOf(m, list, key, mark, self, resolver) {
+    self.folds ??= new Map();
+    let byMix = self.folds.get(key);
+    if (byMix === undefined) {
+        byMix = new Map();
+        self.folds.set(key, byMix);
+    }
+    let fold = byMix.get(m);
+    if (fold === undefined || fold.list !== list || fold.mark !== mark) {
+        fold = {
+            list,
+            mark,
+            seen: 0,
+            pick: new Pick(resolver, Number.NEGATIVE_INFINITY),
+            owned: [],
+            live: null,
+            liveOf: null,
+            liveVersion: -1,
+            liveReduced: false,
+        };
+        byMix.set(m, fold);
+    }
+    return fold;
 }

package/dist/project.d.ts

@@ -1,7 +1,18 @@
-import { Transport } from './transport.js';
+import { Mixer } from './mixer.js';
+import { type Cut, Transport } from './transport.js';
 import type { TransportProjection } from './types.js';
+import type { Subject, Voice } from './voice.js';
 /**
  * Every mix on a transport read at mix time `t`, through copies of them on a transport of their
  * own, moved together so an anchor across mixes answers as it would live.
  */
 export declare function projectAll(transport: Transport, t: number): TransportProjection;
+/** Sets each copied voice's state to what its clock and fade make it at `t`. */
+export declare function stateAt<I, O>(c: Mixer<I, O>, t: number): void;
+/** Gives a projection's copy what it reads of the live mix as it is, before its voices are copied. */
+export declare function mirror<I, O>(mix: Mixer<I, O>, c: Mixer<I, O>): void;
+/**
+ * A projection back starts each subject from the latest copy kept at or before `t`, else from its
+ * voice's start with fresh state, which is exact for a voice stepped at a fixed interval.
+ */
+export declare function recall<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject: I, t: number, cut: Cut): Subject<unknown> | undefined;