@msb235/blits 0.9.0 → 0.11.0

package/dist/motions.js

@@ -28,6 +28,17 @@ function ahead(segs, list) {
 let shared = { xs: new Float64Array(4), vs: new Float64Array(4) };
 /** What a patch's `xs` and `vs` are before its first subject sets its axes. */
 const unsized = new Float64Array(0);
+/** Where `applied` reads a stretch at the time a change lands; copied out before it returns. */
+let landing = { x: new Float64Array(4), v: new Float64Array(4) };
+/** Where `numbers` gathers what it copies, kept an array of doubles so every copy is one too. */
+const gathered = [0.5];
+/** `n` numbers of `from` from `at`, as an array of their own. */
+function numbers(from, at, n) {
+    // `Array.from` walks a typed array by its iterator: about 500 B a call for three axes.
+    for (let i = 0; i < n; i++)
+        gathered[i] = from[at + i];
+    return gathered.slice(0, n);
+}
 /**
  * A subject's flags: its value is a number; it has changes pending; it has older stretches; the
  * stretch it is playing was found landed, which holds until another replaces it.
@@ -211,6 +222,10 @@ export class Motions {
             pending: pending === undefined ? undefined : [...pending],
         };
     }
+    /** Whether the patch holds a run for `subject`. */
+    holds(subject) {
+        return this.known(subject) !== undefined;
+    }
     /** A subject's run as plain data, for a voice leaving memory; undefined where it has none. */
     pack(subject) {
         const s = this.known(subject);
@@ -496,7 +511,7 @@ export class Motions {
     /** Every change due by `t` applied to a copy of the stretch playing then, committing nothing. */
     peek(s, t, xo, vo) {
         let seg = this.playing(s, t);
-        const list = this.pending?.[s];
+        const list = this.dueTo(s);
         if (list !== undefined)
             for (const change of list) {
                 const a = change.at;
@@ -507,6 +522,21 @@ export class Motions {
             }
         this.evaluateSegment(seg, t, xo, vo);
     }
+    /** Subject `s`'s changes waiting, with those a read ahead's tape made filed among them by time. */
+    dueTo(s) {
+        const own = this.pending?.[s];
+        const ahead = reading.ahead?.get(this);
+        if (ahead === undefined)
+            return own;
+        const subject = this.numbers.subject(s);
+        const made = subject === absent ? undefined : ahead.get(subject);
+        if (made === undefined)
+            return own;
+        if (own === undefined)
+            return made;
+        // The patch's own were made first, and a stable sort keeps them first at one time.
+        return [...own.filter((c) => c.at !== undefined), ...made].sort((a, b) => a.at - b.at);
+    }
     check(a, n) {
         if (a !== undefined && a.length !== n)
             throw new Error('blits: a motion patch moves every subject on the same number of axes');
@@ -611,9 +641,9 @@ export class Motions {
         return {
             at: this.runs[this.base(s)],
             ms: this.runs[this.base(s) + 2],
-            x0: Array.from(this.runs.subarray(x, x + n)),
-            v0: Array.from(this.runs.subarray(x + n, x + 2 * n)),
-            to: Array.from(this.runs.subarray(x + 2 * n, x + 3 * n)),
+            x0: numbers(this.runs, x, n),
+            v0: numbers(this.runs, x + n, n),
+            to: numbers(this.runs, x + 2 * n, n),
             change: this.causes?.[s],
         };
     }
@@ -636,11 +666,13 @@ export class Motions {
         return list[lo];
     }
     applied(s, seg, change, at) {
-        const x = new Float64Array(this.n);
-        const v = new Float64Array(this.n);
+        const n = this.n;
+        if (landing.x.length < n)
+            landing = { x: new Float64Array(n), v: new Float64Array(n) };
+        const { x, v } = landing;
         this.evaluateSegment(seg, at, x, v);
-        const xs = Array.from(x);
-        const vs = change.v ?? Array.from(v);
+        const xs = numbers(x, 0, n);
+        const vs = change.v ?? numbers(v, 0, n);
         const subject = this.numbers.subject(s);
         const known = subject === absent ? undefined : subject;
         const to = this.shape.aim(xs, vs, change.to ?? seg.to, known);
@@ -695,8 +727,7 @@ export class Motions {
      * The mix time and frame a stretch was in force by, which a store keys it under: when the change
      * that ended it was made, which falls in the same life of the subject.
      */
-    made(next) {
-        const c = next.change;
+    made(c) {
         const made = c?.made;
         if (made === undefined || Number.isNaN(made))
             return { at: this.owner?.now() ?? Number.NaN, seq: this.owner?.seq() ?? Number.NaN };
@@ -717,7 +748,10 @@ export class Motions {
         const out = list.splice(0, n);
         const subject = this.numbers.subject(s);
         if (this.owner !== null && subject !== absent)
-            this.owner.page(this.ownerId, 'stretch', subject, out.map((seg, i) => ({ ...this.made(out[i + 1] ?? list[0] ?? this.latest(s)), data: seg })));
+            this.owner.page(this.ownerId, 'stretch', subject, out.map((seg, i) => {
+                const next = out[i + 1] ?? list[0];
+                return { ...this.made(next === undefined ? this.causes?.[s] : next.change), data: seg };
+            }));
         if (list.length === 0) {
             this.older[s] = undefined;
             this.flag(s, OLDER, false);

package/dist/move.js

@@ -1,6 +1,6 @@
 import { changed } from './chain.js';
 import { elapsedWith } from './clock.js';
-import { popDue, schedule } from './due.js';
+import { byId, popDue, schedule } from './due.js';
 import { detour } from './everyone.js';
 import { beginFade, part, retire } from './fade.js';
 import { expireGone, keepGone } from './gone.js';
@@ -66,7 +66,13 @@ function moveTo(mix, now) {
             (voice.owner === null ? now : ownerReading(voice.owner, now)) >= voice.start)
             begin(mix, voice, now);
         // After it starts, so a fade due by now on a voice that started since the last frame begins.
-        if ((voice.state === 'live' || voice.state === 'frozen') && voice.outAt <= now)
+        // Not one set for after its passes run out, where a move across both would begin it first.
+        if ((voice.state === 'live' || voice.state === 'frozen') &&
+            voice.outAt <= now &&
+            !(voice.state === 'live' &&
+                !voice.freezesAfter &&
+                !voice.freezesBefore &&
+                voice.endsAt() < voice.outAt))
             beginFade(mix, voice, { over: Number.isNaN(voice.outOver) ? undefined : voice.outOver }, Math.max(startOf(voice), voice.outAt));
         if (voice.state !== 'pending') {
             if (voice.turns)
@@ -155,11 +161,16 @@ function turn(mix, voice, now) {
     voice.anchorNow = at;
     noted(mix, voice);
 }
-/** Past this many voices retiring in one frame, one pass over the list beats a search for each. */
+/**
+ * Past this many voices retiring in one frame, and more than one in `SPARSE` of the list, one pass
+ * over the list beats a search for each.
+ */
 const SEARCHED = 8;
+const SPARSE = 32;
 /**
- * Takes the voices retired since the last prune out of the list, in list order. A few are found by
- * their id, which the list is in order of, so the voices still in it are not read.
+ * Takes the voices retired since the last prune out of the list, in list order. A few, or a small
+ * share of a long list, are found by their id, which the list is in order of, so the voices still
+ * in it are not read.
  */
 function prune(mix) {
     const retired = mix.retired;
@@ -167,9 +178,8 @@ function prune(mix) {
     const voices = mix.cued;
     let at = null;
     // A projection's list holds copies of voices gone before it, which only a pass takes out.
-    if (retired.length <= SEARCHED && !mix.projecting) {
-        if (retired.length > 1)
-            retired.sort((a, b) => a.id - b.id);
+    if ((retired.length <= SEARCHED || retired.length * SPARSE <= voices.length) && !mix.projecting) {
+        byId(retired);
         at = [];
         for (let k = 0; k < retired.length; k++) {
             const voice = retired[k];
@@ -185,8 +195,16 @@ function prune(mix) {
     if (at !== null) {
         for (const voice of retired)
             pruned = leave(mix, voice) || pruned;
-        for (let k = at.length - 1; k >= 0; k--)
-            voices.splice(at[k], 1);
+        // Closed up in one pass from the first to go: a splice for each moves the tail once a voice.
+        let kept = at[0];
+        let k = 0;
+        for (let i = kept; i < voices.length; i++) {
+            if (at[k] === i)
+                k++;
+            else
+                voices[kept++] = voices[i];
+        }
+        voices.length = kept;
     }
     else {
         let kept = 0;

package/dist/owner.d.ts

@@ -9,6 +9,19 @@ export declare class Holding<V> {
     /** How many it has held, and how many of those finished their passes. */
     kids: number;
     played: number;
+    /**
+     * When the children that left coast, as pairs of the frame one left in and the latest coast so
+     * far, mix time: a pair only where the latest grew, so a seek back cuts it to a prefix.
+     */
+    coasts: number[];
+    /** The frame the first child to leave before its passes ended left in; Infinity for none. */
+    cutSeq: number;
+    /** The latest coast of a child that left; -Infinity for none. */
+    get coast(): number;
+    /** A child left in frame `seq`, coasting at `coast`, or before its passes ended for undefined. */
+    left(coast: number | undefined, seq: number): void;
+    /** Forgets the children that left after frame `seq`, for a seek or read back to it. */
+    back(seq: number): void;
 }
 /**
  * What an owner's clock reads at mix time `now`, through every owner above it: -Infinity before it
@@ -41,5 +54,8 @@ export declare function heldByInput<I, O>(voice: Voice<I, O>): boolean;
 export declare function ownWeight<I, O>(owner: Voice<I, O>, now: number, reduced: boolean, base: (owner: Voice<I, O>) => number): number;
 /** What every owner above a voice multiplies into its weight. */
 export declare function ownersWeight<I, O>(voice: Voice<I, O>, now: number, reduced: boolean, base: (owner: Voice<I, O>) => number): number;
-/** Points a projection's copies at each other's owners, each owner holding only copies. */
-export declare function relink<I, O>(copies: readonly Voice<I, O>[]): void;
+/**
+ * Points a projection's copies at each other's owners, each owner holding only copies; for a read
+ * back to frame `seq`, as its children that had left by then left it.
+ */
+export declare function relink<I, O>(copies: readonly Voice<I, O>[], seq?: number): void;

package/dist/owner.js

@@ -13,6 +13,35 @@ export class Holding {
     /** How many it has held, and how many of those finished their passes. */
     kids = 0;
     played = 0;
+    /**
+     * When the children that left coast, as pairs of the frame one left in and the latest coast so
+     * far, mix time: a pair only where the latest grew, so a seek back cuts it to a prefix.
+     */
+    coasts = [];
+    /** The frame the first child to leave before its passes ended left in; Infinity for none. */
+    cutSeq = Number.POSITIVE_INFINITY;
+    /** The latest coast of a child that left; -Infinity for none. */
+    get coast() {
+        const n = this.coasts.length;
+        return n === 0 ? Number.NEGATIVE_INFINITY : this.coasts[n - 1];
+    }
+    /** A child left in frame `seq`, coasting at `coast`, or before its passes ended for undefined. */
+    left(coast, seq) {
+        if (coast === undefined) {
+            if (seq < this.cutSeq)
+                this.cutSeq = seq;
+        }
+        else if (coast > this.coast)
+            this.coasts.push(seq, coast);
+    }
+    /** Forgets the children that left after frame `seq`, for a seek or read back to it. */
+    back(seq) {
+        const c = this.coasts;
+        while (c.length > 0 && c[c.length - 2] > seq)
+            c.length -= 2;
+        if (this.cutSeq > seq)
+            this.cutSeq = Number.POSITIVE_INFINITY;
+    }
 }
 /**
  * What an owner's clock reads at mix time `now`, through every owner above it: -Infinity before it
@@ -103,8 +132,11 @@ export function ownersWeight(voice, now, reduced, base) {
         w *= ownWeight(o, now, reduced, base);
     return w;
 }
-/** Points a projection's copies at each other's owners, each owner holding only copies. */
-export function relink(copies) {
+/**
+ * Points a projection's copies at each other's owners, each owner holding only copies; for a read
+ * back to frame `seq`, as its children that had left by then left it.
+ */
+export function relink(copies, seq) {
     const byId = new Map();
     for (const v of copies) {
         byId.set(v.id, v);
@@ -112,6 +144,10 @@ export function relink(copies) {
             const h = new Holding();
             h.kids = v.holding.kids;
             h.played = v.holding.played;
+            h.coasts = v.holding.coasts.slice();
+            h.cutSeq = v.holding.cutSeq;
+            if (seq !== undefined)
+                h.back(seq);
             v.holding = h;
         }
     }

package/dist/pack.d.ts

@@ -12,6 +12,7 @@ export interface PackedRecord {
     stepped: number;
     ticks: number;
     rebuilt: number;
+    copied?: true;
     /**
      * What `setting.keep` held, in the order its owners first kept it. An owner is code, which no
      * store keeps, and a voice revived from a descriptor has new ones; the same code keeps in the same

package/dist/pack.js

@@ -18,6 +18,8 @@ export function packHeld(voice, h) {
         rebuilt: h.rebuilt,
         kept: kept.length === 0 ? null : kept.map(clone),
     };
+    if (h.copied)
+        p.copied = true;
     if (h.base !== undefined)
         p.base = clone(h.base);
     if (h.slope !== undefined)
@@ -42,6 +44,7 @@ export function unpackHeld(voice, p) {
     h.stepped = p.stepped;
     h.ticks = p.ticks;
     h.rebuilt = p.rebuilt;
+    h.copied = p.copied === true;
     if (p.kept !== null)
         h.unkept = p.kept;
     if (p.base !== undefined)

package/dist/placed.d.ts

@@ -0,0 +1,19 @@
+/**
+ * By subject number, the crowd voices whose rows are placed on it, so letting a number go reaches
+ * its rows without walking every crowd's. Kept by voice id, which a row keeps as a crowd closes up
+ * or is rebuilt around it.
+ */
+export declare class Placed {
+    /** By subject number, one voice placed on it; 0, which is no voice's id, for none. */
+    private one;
+    /** The others, for a subject with several; null until some subject has two. */
+    private rest;
+    /** Makes room for subject numbers below `cap`. */
+    grow(cap: number): void;
+    /** Some voice placed on the subject at `slot`, 0 for none. */
+    any(slot: number): number;
+    /** Every voice placed on the subject at `slot`, in no order: for a test to read. */
+    all(slot: number): number[];
+    add(slot: number, id: number): void;
+    remove(slot: number, id: number): void;
+}

package/dist/placed.js

@@ -0,0 +1,54 @@
+/**
+ * By subject number, the crowd voices whose rows are placed on it, so letting a number go reaches
+ * its rows without walking every crowd's. Kept by voice id, which a row keeps as a crowd closes up
+ * or is rebuilt around it.
+ */
+export class Placed {
+    /** By subject number, one voice placed on it; 0, which is no voice's id, for none. */
+    one = new Int32Array(0);
+    /** The others, for a subject with several; null until some subject has two. */
+    rest = null;
+    /** Makes room for subject numbers below `cap`. */
+    grow(cap) {
+        const one = new Int32Array(cap);
+        one.set(this.one);
+        this.one = one;
+    }
+    /** Some voice placed on the subject at `slot`, 0 for none. */
+    any(slot) {
+        return this.one[slot] | 0;
+    }
+    /** Every voice placed on the subject at `slot`, in no order: for a test to read. */
+    all(slot) {
+        const one = this.any(slot);
+        return one === 0 ? [] : [one, ...(this.rest?.get(slot) ?? [])];
+    }
+    add(slot, id) {
+        if (this.one[slot] === 0) {
+            this.one[slot] = id;
+            return;
+        }
+        this.rest ??= new Map();
+        const more = this.rest.get(slot);
+        if (more === undefined)
+            this.rest.set(slot, [id]);
+        else
+            more.push(id);
+    }
+    remove(slot, id) {
+        const more = this.rest?.get(slot);
+        if (this.one[slot] === id)
+            this.one[slot] = more === undefined ? 0 : more.pop();
+        else if (more !== undefined) {
+            const i = more.indexOf(id);
+            if (i < 0)
+                return;
+            more[i] = more[more.length - 1];
+            more.pop();
+        }
+        else
+            return;
+        if (more !== undefined && more.length === 0)
+            this.rest.delete(slot);
+    }
+}

package/dist/project.d.ts

@@ -4,9 +4,12 @@ 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.
+ * own, moved together so an anchor across mixes answers as it would live. Ahead, they stop at each
+ * known event on the way, and a subject asked about is read at each before `t`.
  */
-export declare function projectAll(transport: Transport, t: number): TransportProjection;
+export declare function projectAll(transport: Transport, at: number | {
+    readonly frame: 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. */