@msb235/blits 0.7.1 → 0.8.1

package/dist/fill.js

@@ -1,14 +1,20 @@
 import { foldNumber, lerpNumber } from './channels.js';
-import { passAt, phaseAt, silent, weighed } from './clock.js';
+import { passAt, phaseAt, same, silent, weighed } from './clock.js';
 import { flush } from './columns.js';
 import { crowdsUpTo, freshen } from './crowd.js';
+import { open as openRecord, shut as shutRecord } from './everyone.js';
 import { foldLocus, gatherLocus } from './gather.js';
+import { runKeys } from './keyfill.js';
 import { frozenAt } from './lane.js';
 import { reach } from './meet.js';
 import { absent } from './numbers.js';
 import { AT, NOTHING, readKeys, seg, segment, shifted } from './patch.js';
 import { reading } from './reading.js';
 import { move, runMotion } from './sample.js';
+import { rested } from './turns.js';
+// V8 reads a local const as a constant, where it reads an import from its module on every call.
+const open = openRecord;
+const shut = shutRecord;
 /** The least prime at least `n`, and 1 below 2. */
 function primeFrom(n) {
     if (n < 2)
@@ -47,7 +53,7 @@ export function fillAll(lanes, now, version) {
         for (const lane of lanes.lanes) {
             if (decide) {
                 // A lane with few subjects, such as one naming its own, goes by the share of all probed;
-                // one with a single subject shares nothing a fill could save, as a solo lane does not.
+                // one with a single subject shares nothing a fill could save.
                 const line = lane.line;
                 const n = lane.list.length;
                 if (n >= 64)
@@ -77,7 +83,7 @@ export function fillAll(lanes, now, version) {
         }
         if (busy) {
             for (const ch of lanes.laned)
-                ch.values.fill(ch.rest, 0, size * ch.axes);
+                rested(ch, size);
             for (const g of lanes.loci)
                 gatherLocus(lanes, g);
             for (const lane of lanes.lanes) {
@@ -104,6 +110,7 @@ export function fillAll(lanes, now, version) {
             lanes.holding = false;
         }
         lanes.moved = reading.moved;
+        lanes.inputs = reading.inputs;
     }
     finally {
         lanes.filling = false;
@@ -168,21 +175,29 @@ export function wake(lanes, lane) {
             reach(lanes, slot, -1);
 }
 /**
- * A voice with a signal weight: its weight for the subject at `slot` under the voice's fade `fade`,
- * through the general path's own arithmetic; NaN where that path has not made the voice's first
- * call for the subject, which it then makes this frame, so a signal that keeps state is first
- * called where the general path would call it.
+ * A voice with a signal weight: its weight for the subject at `slot`, left in `Arg.WEIGHT`, at the
+ * voice time, pass and fade in `Arg.ELAPSED`, `Arg.PASS` and `Arg.FADE`, through the general path's
+ * own arithmetic. False where that path has not made the voice's first call for the subject, which
+ * it then makes this frame, so a signal that keeps state is first called where the general path
+ * would call it.
  */
-export function signalled(voice, slot, rec, elapsed, pass, fade) {
+export function signalled(voice, slot, rec) {
+    const arg = this.arg;
+    const elapsed = arg[1 /* Arg.ELAPSED */];
+    const pass = arg[3 /* Arg.PASS */];
+    const fade = arg[5 /* Arg.FADE */];
     if (Number.isNaN(rec.probed)) {
         this.late.push(slot);
-        return Number.NaN;
+        return false;
     }
     const subject = this.subjectAt(slot);
-    if (subject === absent)
-        return 0;
+    if (subject === absent) {
+        arg[0 /* Arg.WEIGHT */] = 0;
+        return true;
+    }
     const base = this.host.signal(voice, subject, rec, elapsed, pass, slot);
-    return weighed(base, fade, voice.parts === null ? 1 : this.host.parting(voice, subject));
+    arg[0 /* Arg.WEIGHT */] = weighed(base, fade, voice.parts === null ? 1 : this.host.parting(voice, subject));
+    return true;
 }
 /** What a subject's own ramp out of a voice leaves of its weight: 1 with none. */
 export function parting(voice, slot) {
@@ -228,25 +243,53 @@ export function run(lane) {
         runMotion(this, lane, lane.motion);
         return;
     }
-    const elapsed = voice.elapsedAt(this.now);
-    const duration = voice.duration;
-    const passes = voice.passes;
+    if (voice.built !== null && typeof voice.spec.weight !== 'function') {
+        runKeys(this, lane);
+        return;
+    }
+    lane.elapsedNow = voice.elapsedAt(this.now);
     const list = lane.list;
+    if (voice.sharing) {
+        this.runEveryone(lane);
+        return;
+    }
     for (let p = 0; p < list.length; p++) {
-        this.one(lane, p, list[p], elapsed, duration, passes);
+        this.one(lane, p, list[p]);
         // Its patch just made kept state: no further call this fill, the general path makes them.
         if (voice.keeping)
             return;
     }
 }
+/**
+ * `run`'s loop for a voice keeping one record for every subject: the record is pointed at each
+ * subject before its call and taken back after, so `one` and `call` read it as a record of the
+ * subject's own. A loop of its own, which leaves theirs as they were for every other voice.
+ */
+export function runEveryone(lane) {
+    const voice = lane.voice;
+    const rec = voice.everyone;
+    const list = lane.list;
+    const cap = this.cap;
+    for (let p = 0; p < list.length; p++) {
+        const slot = list[p];
+        open(voice, rec, slot);
+        this.one(lane, p, slot);
+        // Its patch just made kept state, and the record is now that subject's own.
+        if (voice.keeping)
+            return;
+        shut(voice, rec, slot, cap);
+    }
+}
 /**
  * One subject's contribution from a lane's voice. True where the voice gave the subject a delta,
  * as the general path's `contribution` does where it returns one, which is what makes a voice in a
  * locus one of its members for the subject.
  */
-export function one(lane, p, slot, elapsedNow, duration, passes) {
+export function one(lane, p, slot) {
     const host = this.host;
     const voice = lane.voice;
+    const elapsedNow = lane.elapsedNow;
+    const arg = this.arg;
     const data = lane.data;
     const o = p * 8 /* Row.STRIDE */;
     // A probe read this subject from the last fill: keep the weight it read for `weightOf`.
@@ -260,25 +303,28 @@ export function one(lane, p, slot, elapsedNow, duration, passes) {
         data[o + 2 /* Row.WEIGHT */] = 0;
         return false;
     }
-    if (!lane.placed || !Object.is(elapsed, lane.placedAt)) {
+    if (!lane.placed || !same(elapsed, lane.placedAt)) {
         lane.placed = true;
         lane.placedAt = elapsed;
-        lane.phase = phaseAt(elapsed, duration, passes);
-        lane.pass = passAt(elapsed, duration, passes);
+        lane.phase = phaseAt(elapsed, voice.duration, voice.passes);
+        lane.pass = passAt(elapsed, voice.duration, voice.passes);
     }
     const since = data[o + 1 /* Row.SINCE */];
-    if (!lane.flat && (!lane.weighed || !Object.is(since, lane.weighedSince))) {
+    if (!lane.flat && (!lane.weighed || !same(since, lane.weighedSince))) {
         lane.fade = host.envelope(voice, since);
         lane.weighed = true;
         lane.weighedSince = since;
     }
     let w;
     if (typeof voice.spec.weight === 'function') {
-        w = this.signalled(voice, slot, lane.records[p], elapsed, lane.pass, lane.fade);
-        if (Number.isNaN(w)) {
+        arg[1 /* Arg.ELAPSED */] = elapsed;
+        arg[3 /* Arg.PASS */] = lane.pass;
+        arg[5 /* Arg.FADE */] = lane.fade;
+        if (!this.signalled(voice, slot, lane.records[p])) {
             data[o + 2 /* Row.WEIGHT */] = 0;
             return false;
         }
+        w = arg[0 /* Arg.WEIGHT */];
     }
     else
         w = weighed(voice.weight, lane.fade, this.parting(voice, slot));
@@ -286,14 +332,16 @@ export function one(lane, p, slot, elapsedNow, duration, passes) {
     this.folding = lane;
     this.rec = lane.records[p] ?? null;
     if (voice.built !== null) {
-        if (!lane.read || !Object.is(elapsed, lane.readAt)) {
+        if (!lane.read || !same(elapsed, lane.readAt)) {
             this.readKeyed(voice, lane.phase, lane.delta, lane.scratch);
             lane.read = true;
             lane.readAt = elapsed;
             this.gather(lane, lane.delta);
         }
-        if (w > 0)
-            this.fold(lane, slot, w);
+        if (w > 0) {
+            arg[0 /* Arg.WEIGHT */] = w;
+            this.fold(lane, slot);
+        }
         return true;
     }
     const rec = lane.records[p];
@@ -303,18 +351,25 @@ export function one(lane, p, slot, elapsedNow, duration, passes) {
         return false;
     }
     // A motion patch needs the subject only to number it, so the lookup waits until then.
+    arg[1 /* Arg.ELAPSED */] = elapsed;
+    arg[4 /* Arg.DELAY */] = delay;
+    arg[0 /* Arg.WEIGHT */] = w;
     if (lane.motion !== undefined) {
-        move(this, lane, lane.motion, p, slot, rec, elapsed, delay, w);
+        move(this, lane, lane.motion, p, slot, rec);
         return true;
     }
-    return this.call(voice, lane.chans, rec, slot, elapsed, lane.phase, lane.pass, delay, w);
+    arg[2 /* Arg.PHASE */] = lane.phase;
+    arg[3 /* Arg.PASS */] = lane.pass;
+    return this.call(voice, lane.chans, rec, slot);
 }
 /**
- * A keys voice's stops at `phase` folded straight into a subject's values, without a delta: what
- * `readKeyed` then `foldDelta` give, through the same segment search and the stock channels' own
- * lerp, which is all a laned keys voice can use.
+ * A keys voice's stops at `Arg.PHASE` folded straight into a subject's values at `Arg.WEIGHT`,
+ * without a delta: what `readKeyed` then `foldDelta` give, through the same segment search and the
+ * stock channels' own lerp, which is all a laned keys voice can use.
  */
-export function foldKeys(voice, chans, phase, slot, w) {
+export function foldKeys(voice, chans, slot) {
+    const phase = this.arg[2 /* Arg.PHASE */];
+    const w = this.arg[0 /* Arg.WEIGHT */];
     const built = voice.built;
     const tracks = built.tracks;
     for (let i = 0; i < tracks.length; i++) {
@@ -324,14 +379,14 @@ export function foldKeys(voice, chans, phase, slot, w) {
         if (found === NOTHING)
             continue;
         if (found === AT) {
-            this.foldInto(ch, slot, seg.a, w);
+            this.foldInto(ch, slot, seg.a);
             continue;
         }
         const a = seg.a;
         const b = seg.b;
         const u = seg.eased;
-        if (ch.scalar) {
-            this.foldInto(ch, slot, voice.lerps[i](a, b, u), w);
+        if (ch.scalar || !ch.plain) {
+            this.foldInto(ch, slot, voice.lerps[i](a, b, u));
             continue;
         }
         // `vec`'s lerp, reading each end past its length as the rest, then its fold.
@@ -351,10 +406,18 @@ export function readKeyed(voice, phase, delta, scratch) {
     readKeys(voice.built, phase, delta, undefined, voice.lerps, undefined, voice.intos, scratch);
 }
 /**
- * Calls a stateless fn voice's patch for a subject its general path has met, and folds the delta;
- * false for a subject the host has let go of.
+ * Calls a stateless fn voice's patch for a subject its general path has met, and folds the delta,
+ * at the voice time, phase, pass, delay and weight in `Arg`; false where it gave no delta, for a
+ * subject the host has let go of or a weight the voice is silent at. As arguments those cost nothing where V8 inlines the call and 31 bytes a call where it
+ * does not, which differs by V8 version: Node 26.1 does not (2026-10-09).
  */
-export function call(voice, chans, rec, slot, elapsed, phase, pass, delay, w) {
+export function call(voice, chans, rec, slot) {
+    const arg = this.arg;
+    const elapsed = arg[1 /* Arg.ELAPSED */];
+    const phase = arg[2 /* Arg.PHASE */];
+    const pass = arg[3 /* Arg.PASS */];
+    const delay = arg[4 /* Arg.DELAY */];
+    const w = arg[0 /* Arg.WEIGHT */];
     const host = this.host;
     const subject = this.subjectAt(slot);
     if (subject === absent)
@@ -362,11 +425,11 @@ export function call(voice, chans, rec, slot, elapsed, phase, pass, delay, w) {
     // Called already this frame, by the general path or a fill before a refill: reuse, as a probe does.
     if (rec.probed === this.now && rec.delta !== null && rec.seeks === voice.seeks) {
         if (w > 0)
-            this.foldDelta(chans, slot, rec.delta, w);
+            this.foldDelta(chans, slot, rec.delta);
         return true;
     }
     if (silent(voice, w))
-        return true;
+        return false;
     const kept = reading.kept;
     host.ready(voice, subject, rec, elapsed, pass, w);
     if (this.keeps)
@@ -383,6 +446,6 @@ export function call(voice, chans, rec, slot, elapsed, phase, pass, delay, w) {
     if (reading.kept !== kept && !voice.keeping)
         host.kept(voice);
     if (w > 0)
-        this.foldDelta(chans, slot, delta, w);
+        this.foldDelta(chans, slot, delta);
     return true;
 }

package/dist/fit.js

@@ -93,7 +93,8 @@ export function condense() {
         if (fits(span, kids, plan) || !kids.some((k) => k.overlap))
             return plan;
         const at = (s) => ({ ...plan, share: s });
-        // `least` finds the smallest x that fits; the share wanted is the largest, so search 1 - share.
+        // `least` finds the smallest x that fits; the share wanted is the largest, so search how far
+        // under the plan's it is.
         const x = least(0, plan.share, (d) => fits(span, kids, at(plan.share - d)));
         return at(plan.share - x);
     };

package/dist/fold.d.ts

@@ -1,7 +1,14 @@
 import type { Mixer } from './mixer.js';
+import type { Channel } from './types.js';
 import type { Subject, Voice } from './voice.js';
 export type Key<O> = keyof O & string;
 export declare function near(a: unknown, b: unknown): boolean;
+/**
+ * `merge(acc, b)`, where a result that is `b` itself, as `last()` gives, is copied into `acc` or a
+ * 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.
+ */
+export declare function merged(channel: Channel<unknown>, acc: unknown, b: unknown): unknown;
 export type Values = Record<string, unknown>;
 /**
  * One live voice's delta for one subject this frame, through its record for the subject, or null
@@ -28,12 +35,30 @@ export declare function baseFor<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, sub
  */
 export declare function slopeFor<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I): Record<string, unknown> | undefined;
 export declare function isRest<I, O>(this: Mixer<I, O>, delta: Record<string, unknown>): boolean;
+/**
+ * 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 declare function unband(held: Subject<unknown> | null | undefined): void;
 /** Whether a rest-less channel's contribution is switched on, across a band rather than an edge. */
 export declare function passes<I, O>(this: Mixer<I, O>, was: boolean | undefined, w: number): boolean;
 /** Folds one voice's delta into the pose, its band state kept on the subject's record. */
 export declare function apply<I, O>(this: Mixer<I, O>, pose: Record<string, unknown>, voice: Voice<I, O>, held: Subject<unknown>, delta: Record<string, unknown>, weight: number): void;
 /** Clamps every bounded channel of a folded pose into its range, in place. */
 export declare function clamp<I, O>(this: Mixer<I, O>, pose: Record<string, unknown>): Record<string, unknown>;
+/** A folded value held to its channel's bounds: a number clamped, an array clamped in place. */
+export declare function bound(channel: Channel<unknown>, v: unknown): unknown;
+/**
+ * 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 declare function chainFirst<I, O>(held: Subject<unknown> | null, sharers: readonly Voice<I, O>[], q: number): boolean;
+/**
+ * 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 declare function shared<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, slot: number, rec: Subject<unknown>, q: number): number;
 export declare function fold<I, O>(this: Mixer<I, O>, subject: I, out?: O, dry?: boolean, except?: number): O;
 export declare function folded<I, O>(this: Mixer<I, O>, subject: I, out?: O, dry?: boolean, except?: number): O;
 /**
@@ -43,6 +68,18 @@ export declare function folded<I, O>(this: Mixer<I, O>, subject: I, out?: O, dry
 export declare function linked<I, O>(this: Mixer<I, O>, subject: I): Subject<unknown> | null;
 /** The fold after a subject's chain is linked and its lanes asked whether it reads from them. */
 export declare function foldWith<I, O>(this: Mixer<I, O>, subject: I, out: O, head: Subject<unknown> | null, laned: boolean, dry: boolean, except?: number): O;
+/**
+ * `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 declare function foldDetour<I, O>(this: Mixer<I, O>, subject: I, pose: Record<string, unknown>, linkedHead: Subject<unknown>, laned: boolean, dry: boolean, except: number | undefined, owed: number): O;
+/**
+ * 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 declare function foldSharers<I, O>(this: Mixer<I, O>, pose: Record<string, unknown>, subject: I, head: Subject<unknown>, q: number, before: number, laned: boolean, dry: boolean, except: number | undefined, owed: number): number;
 /** Whether the subject numbered `owed` reads laned `voice` from the general path this fill. */
 export declare function owedBy<I, O>(this: Mixer<I, O>, owed: number, voice: Voice<I, O>): boolean;
 /** `foldWith`'s voices with a locus in play: each locus folds at its first member's place. */