@msb235/blits 0.8.0 → 0.8.1

package/CHANGELOG.md

@@ -4,6 +4,19 @@ This package follows [semver](https://semver.org). Below 1.0.0, a breaking chang
 version and everything else the patch. Each release lists its changes as **Breaking**, **Added** and
 **Fixed**, and the release workflow refuses a tag with no section here.
 
+## 0.8.1
+
+### Fixed
+
+- A frame under `history` costs what it did in 0.7.1 again. 0.8.0 added two costs to every frame:
+  a sync shifted the whole list of frames history can reach to let go of the oldest, 7,200 of
+  them at 60 fps under the default 120 s; and an object a voice gave a channel with no `rest` to
+  fold into, such as `last<Row>()`, was copied for every subject on every frame. The frames now
+  leave from the front without a shift, and such a channel's pose holds the patch's own object, as
+  in 0.7.1; an array is still copied. astv's motion bench on one machine, mean µs a frame over
+  two runs, 0.7.1, 0.8.0, then this: one window landing 6 text changes of 5 rows, 19.6, 28.8,
+  19.5; its busy stage, 354.6, 402.2, 340.7; 10 flights a second, 6.4, 8.0, 6.6.
+
 ## 0.8.0
 
 ### Breaking

package/README.md

@@ -118,7 +118,7 @@ so the engine keeps no dependencies; its README says how it works.
 
 ## Status
 
-v0.8.0, with five consumers. magicsmoke runs every fault on it, wod its wheel, tricks and
+v0.8.1, with five consumers. magicsmoke runs every fault on it, wod its wheel, tricks and
 transitions, weasel its animator's tweens, sherpa its seams, and
 [klieg](https://github.com/orochi235/klieg) composes all three of its systems — letter motion,
 part effects, and the environment a sign is lit by — on a mix each.

package/dist/clone.d.ts

@@ -6,5 +6,10 @@
 export declare function clone<T>(v: T): T;
 /** A copy a fold may write into: arrays, typed arrays and plain objects copied, the rest as is. */
 export declare function copy(v: unknown): unknown;
+/**
+ * A value that starts a channel no fold writes into: only `merged` touches it after, and that
+ * writes into arrays alone, so an object is the patch's own, not a copy made each frame.
+ */
+export declare function first(v: unknown): unknown;
 /** Whether `copy` can copy `v` faithfully, when it is an object. */
 export declare function copyable(v: object): boolean;

package/dist/clone.js

@@ -62,6 +62,13 @@ export function copy(v) {
         return v.slice();
     return plainObject(v) ? clone(v) : v;
 }
+/**
+ * A value that starts a channel no fold writes into: only `merged` touches it after, and that
+ * writes into arrays alone, so an object is the patch's own, not a copy made each frame.
+ */
+export function first(v) {
+    return Array.isArray(v) ? [...v] : v;
+}
 /** Whether `copy` can copy `v` faithfully, when it is an object. */
 export function copyable(v) {
     return Array.isArray(v) || ArrayBuffer.isView(v) || plainObject(v);

package/dist/fold.js

@@ -1,5 +1,5 @@
 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';
@@ -298,7 +298,7 @@ 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. */
@@ -617,7 +617,7 @@ export function foldLoci(subject, pose, head, laned, dry, except, owed) {
                 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/locus.js

@@ -1,4 +1,4 @@
-import { copy } from './clone.js';
+import { first } from './clone.js';
 export function locusScratch(channels) {
     return {
         n: 0,
@@ -70,7 +70,7 @@ export function foldLocus(k, group) {
                 k.values[slot] =
                     this.lerpsInto[slot] !== undefined && channel.scale && Array.isArray(value)
                         ? own(k, slot, value, channel.rest)
-                        : copy(value);
+                        : first(value);
                 continue;
             }
             const total = taken[slot] + weight;

package/dist/paging.js

@@ -110,12 +110,7 @@ export function pageTransport(transport) {
         return;
     const reach = transport.now - history.ms;
     const records = [];
-    const frames = transport.frames;
-    let n = 0;
-    while (n + 1 < frames.length && frames[n + 1].at <= reach)
-        n++;
-    for (const f of frames.splice(0, n))
-        records.push({ mix: '', stream: 'frame', at: f.at, seq: f.seq, data: f.u });
+    transport.frames.shed(reach, (f) => records.push({ mix: '', stream: 'frame', at: f.at, seq: f.seq, data: f.u }));
     const pace = transport.pace;
     const timeOf = (u) => (pace === null ? u : pace.reading(u));
     if (transport.announced.some((a) => timeOf(a.at) < reach)) {

package/dist/project.js

@@ -31,7 +31,7 @@ export function projectAll(transport, t) {
     const kept = transport.history !== undefined;
     if (!ahead && kept) {
         cover(transport, t);
-        const frame = transport.frameAt(t);
+        const frame = transport.frames.at(t);
         if (frame !== undefined) {
             cut = { seq: frame.seq, strict: frame.at === t };
             if (frame.at === t)

package/dist/seek.js

@@ -155,7 +155,7 @@ export function seek(transport, t) {
             move(m, t);
     }
     else {
-        const frame = transport.frameAt(t);
+        const frame = transport.frames.at(t);
         if (frame === undefined)
             throw new Error(`blits: ${t} is older than this mix's history reaches`);
         // On the frame itself, its own host time: rate 0 may have held the clock there for several.
@@ -165,7 +165,7 @@ export function seek(transport, t) {
         transport.undrop(seq);
         // What history kept after the frame is let go; the tape holds the calls that made it.
         transport.announced = transport.announced.filter((a) => a.seq <= seq);
-        transport.frames = transport.frames.filter((f) => f.seq <= seq);
+        transport.frames.set(transport.frames.all().filter((f) => f.seq <= seq));
         if (transport.pacedSeq > seq) {
             transport.pace = null;
             transport.pacedSeq = Number.POSITIVE_INFINITY;

package/dist/stack.js

@@ -1,4 +1,4 @@
-import { copy } from './clone.js';
+import { copy, first } from './clone.js';
 import { bound, merged } from './fold.js';
 /** The weight a mix's default band first switches a rest-less channel on at. */
 const ON = 0.6;
@@ -35,7 +35,7 @@ export function fold(kit, deltas, weights) {
                     ? channel.fold(pose[key], value, w)
                     : merged(channel, pose[key], channel.scale(value, w));
             else if (w >= 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);
         }
     }
     for (const key of names) {

package/dist/transport.d.ts

@@ -1,3 +1,4 @@
+import { Frames } from './frames.js';
 import type { Mixer } from './mixer.js';
 import { Pace } from './pace.js';
 import { Pager } from './paging.js';
@@ -68,7 +69,7 @@ export declare class Transport implements TransportApi {
      */
     seq: number;
     /** Under history, the frames a seek or read back may reach, oldest first. */
-    frames: Frame[];
+    frames: Frames;
     /** Host time at the last sync: the host's timestamp less every gap `rebase` took out. */
     u: number;
     offset: number;
@@ -131,11 +132,6 @@ export declare class Transport implements TransportApi {
     private syncAt;
     /** Begins a frame at mix time `at` and the host time the transport stands at. */
     tick(at: number): 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.
-     */
-    frameAt(t: number): Frame | undefined;
     rebase(): void;
     /**
      * Moves `floor` past what the mix clock standing at `now` has let go of. With a store nothing is

package/dist/transport.js

@@ -1,3 +1,4 @@
+import { Frames } from './frames.js';
 import { listedAll } from './marks.js';
 import { move, nextFrame, waits } from './move.js';
 import { Pace } from './pace.js';
@@ -39,7 +40,7 @@ export class Transport {
      */
     seq = 0;
     /** Under history, the frames a seek or read back may reach, oldest first. */
-    frames = [];
+    frames = new Frames();
     /** Host time at the last sync: the host's timestamp less every gap `rebase` took out. */
     u = Number.NaN;
     offset = 0;
@@ -220,12 +221,7 @@ export class Transport {
         }
         if (history !== undefined && this.dropped.length > 0)
             this.dropped = this.dropped.filter((d) => d.at >= reach);
-        const frames = this.frames;
-        let n = 0;
-        while (n + 1 < frames.length && frames[n + 1].at <= reach)
-            n++;
-        if (n > 0)
-            frames.splice(0, n);
+        this.frames.shed(reach);
         pageTransport(this);
         this.woken = false;
         // It is a frame too, which asks every weight signal again, so one reading input follows it.
@@ -249,27 +245,6 @@ export class Transport {
         for (const m of this.members)
             m.looked = false;
     }
-    /**
-     * 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.
-     */
-    frameAt(t) {
-        const frames = this.frames;
-        let lo = 0;
-        let hi = frames.length - 1;
-        let found;
-        while (lo <= hi) {
-            const mid = (lo + hi) >> 1;
-            const f = frames[mid];
-            if (f.at <= t) {
-                found = f;
-                lo = mid + 1;
-            }
-            else
-                hi = mid - 1;
-        }
-        return found;
-    }
     rebase() {
         this.rebasing = true;
         this.settle();

package/dist/unpage.js

@@ -69,7 +69,7 @@ function unpageTransport(transport, records) {
     const frames = own
         .filter((r) => r.stream === 'frame')
         .map((r) => ({ seq: r.seq, at: r.at, u: r.data }));
-    transport.frames = before(frames, transport.frames);
+    transport.frames.set(before(frames, transport.frames.all()));
     const held = new Set(transport.announced.map((a) => a.order));
     const marks = own
         .filter((r) => r.stream === 'mark' && !held.has(r.data.order))

package/docs/schema.html

@@ -161,7 +161,7 @@
   <h1>An effects schema, and the API around it</h1>
   <p class="lede">A small runtime package for concurrent effects. Each effect runs on its own clock with its own state and weight, and a mix folds them into one value per subject per frame by rules that belong to the channel, not the effect.</p>
   <p class="meta"><b>For:</b> whoever builds <code>blits</code>, and whoever ports klieg, wod, sherpa or magicsmoke onto it. <b>Answers:</b> what the vocabulary is, what an author writes, what a host calls, and where a second engine would plug in. The package implements this page; where the two differ, the code in <code>src/</code> is the one that runs.</p>
-  <span class="status">Built · v0.8.0 · design 2026-09-15, package 2026-09-28</span>
+  <span class="status">Built · v0.8.1 · design 2026-09-15, package 2026-09-28</span>
 </header>
 
 <h2 id="picture">In one picture</h2>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@msb235/blits",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "Concurrent effects: each on its own clock with its own state and weight, folded into one value per subject per frame",
   "keywords": [
     "animation",