@msb235/blits 0.16.0 → 0.16.1

package/dist/fade.js

@@ -1,8 +1,9 @@
 import { changed, headOf, unlink } from './chain.js';
-import { envelope } from './clock.js';
+import { envelope, fadeInAt } from './clock.js';
 import { schedule } from './due.js';
 import { leave, noted, releasing } from './history.js';
 import { markOf } from './marks.js';
+import { startedAt } from './origin.js';
 import { orphan, ownerReading, plays } from './owner.js';
 import { startOf } from './place.js';
 import { isRested } from './record.js';
@@ -27,12 +28,26 @@ export function fadeSubject(mix, voice, subject, over) {
     schedule(mix, voice);
     mix.lanes?.refill();
 }
-/** What a subject's own ramp out of a voice leaves of its weight this frame, 0..1. */
+/**
+ * What a subject's own ramp out of a voice leaves of its weight this frame. It also holds the
+ * voice's fade in where the ramp began, as a fade out of the whole voice does, so it is a ratio to
+ * the fade in the voice's envelope gives.
+ */
 export function parting(voice, subject, now) {
     const r = voice.parts?.get(subject);
     if (r === undefined)
         return 1;
-    return envelope(0, { at: r.at, over: r.over, rest: false }, voice.ease, this.reducedNow, now, 0);
+    const reduced = this.reducedNow;
+    const w = envelope(0, { at: r.at, over: r.over, rest: false }, voice.ease, reduced, now, 0);
+    const fadeIn = voice.fade.in ?? 0;
+    const since = voice.subjects.get(subject)?.shown;
+    if (!(fadeIn > 0) || reduced || since === undefined || !(r.at < now))
+        return w;
+    const out = voice.out;
+    const climbing = fadeInAt(fadeIn, out, voice.ease, now, since, voice.stalls);
+    if (!(climbing > 0))
+        return w;
+    return w * (fadeInAt(fadeIn, out, voice.ease, now, since, voice.stalls, r.at) / climbing);
 }
 /**
  * Takes a subject out of one voice for good, as of mix time `at`: the voice forgets its record,
@@ -164,7 +179,8 @@ export function beginFade(mix, voice, opts, at) {
 }
 /**
  * Keeps a voice faded at the end of its passes with its owner, live and quiet, rather than letting
- * it leave; the owner leaves at `at` if it holds no child still playing.
+ * it leave; the owner, where it holds no child still playing, leaves at `at`, or stays quiet in
+ * turn where an owner holds it.
  */
 export function stay(mix, voice, at) {
     voice.state = 'live';
@@ -173,10 +189,22 @@ export function stay(mix, voice, at) {
     if (owner.state === 'done')
         return;
     const now = Number.isNaN(mix.now) ? Number.NEGATIVE_INFINITY : mix.now;
-    if (!plays(owner, now) && !lingers(owner, at))
+    if (plays(owner, now) || lingers(owner, at)) {
+        if (owner.fitting !== null && !voice.skipped)
+            refit(mix, owner, at);
+    }
+    else
+        release(mix, owner, at);
+}
+/**
+ * Lets an owner holding no child still playing leave at `at`; under history one an owner holds
+ * stays with it instead, quiet while its children are.
+ */
+export function release(mix, owner, at) {
+    if (owner.owner !== null && owner.state === 'live' && mix.opts.history !== undefined)
+        beginFade(mix, owner, { over: 0, stays: true }, at);
+    else
         retire(mix, owner, at);
-    else if (owner.fitting !== null && !voice.skipped)
-        refit(mix, owner, at);
 }
 /**
  * Turns a fading voice around: it climbs back from where its fade out had got to, up the same
@@ -205,7 +233,12 @@ export function beginRise(mix, voice, opts) {
     voice.out = null;
     voice.outAt = Number.POSITIVE_INFINITY;
     voice.state = waiting ? 'pending' : 'live';
+    if (waiting)
+        voice.begunSeq = Number.POSITIVE_INFINITY;
     voice.back = over > 0 && from < 1 ? { from, at, over } : null;
+    // Its fade in stood still from where the fade out began, and climbs on from where it stood.
+    if (!out.rest && out.at < at)
+        voice.stalls = [...(voice.stalls ?? []), out.at, at];
     if (waiting)
         changed(mix, voice);
     noted(mix, voice);
@@ -223,7 +256,7 @@ export function fadeAt(mix, voice, at, over) {
         return;
     const now = Number.isNaN(mix.now) ? startOf(voice) : mix.now;
     if (at <= now) {
-        beginFade(mix, voice, { over }, Math.max(startOf(voice), at));
+        beginFade(mix, voice, { over }, Math.max(startedAt(voice), at));
         mix.stir();
         return;
     }

package/dist/fill.js

@@ -472,7 +472,8 @@ export function call(voice, chans, rec, slot) {
         rec.delta = null;
         rec.probed = this.now;
         rec.seeks = voice.seeks;
-        return false;
+        // A role member is one at weight 0 too, unasked, and holds its role's place as on the general path.
+        return voice.spec.role !== undefined;
     }
     const kept = reading.kept;
     host.ready(voice, subject, rec);

package/dist/fit.js

@@ -50,6 +50,14 @@ function least(lo, hi, ok) {
         return lo;
     if (!ok(hi))
         return hi;
+    // An unbounded `hi`, as an `Infinity` hint gives, is brought to a finite one before halving.
+    if (hi === Number.POSITIVE_INFINITY) {
+        hi = Math.max(lo, 1) * 2;
+        while (!ok(hi)) {
+            lo = hi;
+            hi *= 2;
+        }
+    }
     for (let i = 0; i < 60; i++) {
         const mid = (lo + hi) / 2;
         if (ok(mid))

package/dist/gone.js

@@ -77,6 +77,7 @@ export function goneIndex(mix) {
 /** Hands voices let go of from `gone` to the departed index, noting the latest that left. */
 function forgot(mix, out) {
     for (const v of out) {
+        mix.parters.delete(v);
         mix.departed.add(mix, v);
         if (v.doneAt > mix.transport.forgotTo)
             mix.transport.forgotTo = v.doneAt;

package/dist/handle.d.ts

@@ -11,7 +11,7 @@ export interface HandleHost<I, O> {
      * The voice's clock jumped: for an owner, so did every clock it holds. With `rebuild`, their
      * state is made again for where they now are. How sure that leaves it.
      */
-    sought(voice: Voice<I, O>, rebuild: boolean): Doubt;
+    sought(voice: Voice<I, O>, rebuild: boolean, ahead: boolean): Doubt;
     fade(voice: Voice<I, O>, opts: FadeOptions<I> | undefined): void;
     rise(voice: Voice<I, O>, opts: {
         over?: number;

package/dist/handle.js

@@ -115,14 +115,16 @@ export class VoiceHandle {
             return 'exact';
         voice.written = true;
         // A pending voice's clock is anchored at its start, so it starts there on time.
+        let ahead = false;
         if (voice.state !== 'pending') {
             const u = this.#host.nowFor(voice);
             leave(voice, u, true);
             voice.rebase(u);
+            ahead = elapsed > voice.anchorElapsed;
         }
         voice.anchorElapsed = elapsed;
         voice.seeks++;
-        const doubt = this.#host.sought(voice, opts?.state !== 'keep');
+        const doubt = this.#host.sought(voice, opts?.state !== 'keep', ahead);
         this.#host.changed(voice);
         if (this.#host.taping())
             this.#host.record(this, 'seek', (h) => h.seek(elapsed, opts));

package/dist/held.d.ts

@@ -22,7 +22,8 @@ export declare function sinceOf<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, del
 /**
  * The mix time a subject's fade in counts from: `since`, but no earlier than its voice starts,
  * where a voice sought ahead of its start has a subject's delay run out before it; and from when
- * the voice first showed, for one freezing before.
+ * the voice first showed, for one freezing before. Its start is where its owners' clocks first
+ * read it, as `since` is, not where they would by their controls now.
  */
 export declare function shownOf<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, since: number): number;
 /** Lists a record whose origin is still ahead of `now`, for a later change to the clock to move. */

package/dist/held.js

@@ -2,8 +2,7 @@ import { changed } from './chain.js';
 import { stepOf } from './clock.js';
 import { delayOf } from './delay.js';
 import { schedule } from './due.js';
-import { originOf } from './origin.js';
-import { startOf } from './place.js';
+import { originOf, startedAt } from './origin.js';
 import { record } from './record.js';
 import { unreach, unreached } from './unreached.js';
 /** The record a voice gives every subject it does not reach. */
@@ -118,13 +117,21 @@ export function sinceOf(voice, delay) {
 /**
  * The mix time a subject's fade in counts from: `since`, but no earlier than its voice starts,
  * where a voice sought ahead of its start has a subject's delay run out before it; and from when
- * the voice first showed, for one freezing before.
+ * the voice first showed, for one freezing before. Its start is where its owners' clocks first
+ * read it, as `since` is, not where they would by their controls now.
  */
 export function shownOf(voice, since) {
-    const start = startOf(voice);
+    const start = startedAt(voice);
     const from = since < start ? start : since;
     return voice.freezesBefore && voice.opened < from ? voice.opened : from;
 }
+/**
+ * Whether a listed record stays listed at `now`: its origin is ahead, or it is a motion voice's,
+ * unread since its origin, which `still` asks after since the motion has no run for it yet.
+ */
+function stillEarly(voice, held, now) {
+    return !(held.since <= now) || (voice.motion !== undefined && !(held.probed >= held.since));
+}
 /** Lists a record whose origin is still ahead of `now`, for a later change to the clock to move. */
 export function waits(voice, held, now) {
     if (held.since <= now)
@@ -135,7 +142,7 @@ export function waits(voice, held, now) {
     if (early.length >= 64 && (early.length & (early.length - 1)) === 0) {
         let kept = 0;
         for (const h of early)
-            if (!(h.since <= now))
+            if (stillEarly(voice, h, now))
                 early[kept++] = h;
         early.length = kept;
     }
@@ -147,6 +154,7 @@ export function waits(voice, held, now) {
  */
 export function begin(mix, voice, now) {
     voice.state = 'live';
+    voice.begunSeq = mix.transport.seq;
     if (voice.anchorElapsed !== 0) {
         voice.seeks++;
         voice.rebuilds++;
@@ -178,7 +186,7 @@ export function reorigin(mix, voice, now) {
     let kept = 0;
     for (const held of early) {
         origin(mix, voice, held);
-        if (!(held.since <= now))
+        if (stillEarly(voice, held, now))
             early[kept++] = held;
     }
     early.length = kept;

package/dist/hosts.js

@@ -216,7 +216,11 @@ function handleHost(mix) {
             mix.lanes?.refill();
         },
         // A delta read before an owner's seek, or a hit booked, is not taken as standing after it.
-        sought: (voice, rebuild) => {
+        sought: (voice, rebuild, ahead) => {
+            if (ahead && voice.holding !== null && !mix.projecting) {
+                mix.leapt ??= new Set();
+                mix.leapt.add(voice);
+            }
             if (rebuild)
                 voice.rebuilds++;
             let doubt = seekDoubt(mix, voice, rebuild);

package/dist/lane.d.ts

@@ -185,6 +185,8 @@ export declare class Lane<I, O> implements Positions<I, O> {
      * checked against every lane up to some epoch has met this one if this one's is no later.
      */
     epoch: number;
+    /** The lanes' probe count when it was made: a probe no later read its subject elsewhere. */
+    made: number;
     /**
      * Per position, `STRIDE` numbers side by side, so one subject's are one read from memory: its
      * delay, its `since`, its weight at the last fill, its weight at the last fill a probe read, a

package/dist/lane.js

@@ -37,6 +37,8 @@ export class Lane {
      * checked against every lane up to some epoch has met this one if this one's is no later.
      */
     epoch = 0;
+    /** The lanes' probe count when it was made: a probe no later read its subject elsewhere. */
+    made = 0;
     /**
      * Per position, `STRIDE` numbers side by side, so one subject's are one read from memory: its
      * delay, its `since`, its weight at the last fill, its weight at the last fill a probe read, a

package/dist/lanes.js

@@ -268,7 +268,8 @@ export class Lanes {
     }
     reported(lane, slot) {
         const o = slot * 6 /* Per.SLOT */;
-        if (!(this.per[o + 3 /* Per.LANE_PROBE */] > this.per[o + 4 /* Per.GENERAL_PROBE */]))
+        const probe = this.per[o + 3 /* Per.LANE_PROBE */];
+        if (!(probe > this.per[o + 4 /* Per.GENERAL_PROBE */]) || !(probe > lane.made))
             return undefined;
         const p = lane.positionOf(slot);
         if (p < 0)

package/dist/meet.js

@@ -86,6 +86,15 @@ export function meet(lanes, slot, subject, head, lane) {
         }
     if (!met)
         return lane;
+    // Met newest first; folded, as the general path folds them, in voice order.
+    const ids = lanes.met;
+    for (let i = 1; i < lanes.metN; i++) {
+        const id = ids[i];
+        let j = i - 1;
+        for (; j >= 0 && ids[j] > id; j--)
+            ids[j + 1] = ids[j];
+        ids[j + 1] = id;
+    }
     // The fill ran before the subject had these positions. Where every voice it just met folds
     // after every other laned voice, the general path folds just those onto the lanes' values;
     // otherwise it reads the general path all frame.

package/dist/mixer.d.ts

@@ -106,6 +106,8 @@ export declare class Mixer<I, O> implements Mix<I, O> {
     retired: Voice<I, O>[];
     /** Visit every voice each sync, as before the due queue; for tests that compare the two. */
     walkAll: boolean;
+    /** Owners sought forward since the last frame, which passes what each seek went past in order. */
+    leapt: Set<Voice<I, O>> | null;
     /** The last array `pull` read, by position, with each subject's chain head, to skip the lookup. */
     pulled: I[];
     pulledHeads: (Subject<unknown> | undefined)[];

package/dist/mixer.js

@@ -95,6 +95,8 @@ export class Mixer {
     retired = [];
     /** Visit every voice each sync, as before the due queue; for tests that compare the two. */
     walkAll = false;
+    /** Owners sought forward since the last frame, which passes what each seek went past in order. */
+    leapt = null;
     /** The last array `pull` read, by position, with each subject's chain head, to skip the lookup. */
     pulled = [];
     pulledHeads = [];

package/dist/motion.js

@@ -241,8 +241,8 @@ export function spring(writes, opts) {
     const k = opts.stiffness ?? 170;
     const c = opts.damping ?? 26;
     const m = opts.mass ?? 1;
-    if (!(k > 0) || !(m > 0) || !(c >= 0))
-        throw new RangeError('blits: a spring takes a positive stiffness and mass, and damping of 0 or more');
+    if (!(k > 0 && k < Infinity) || !(m > 0 && m < Infinity) || !(c >= 0 && c < Infinity))
+        throw new RangeError('blits: a spring takes a finite positive stiffness and mass, and finite damping of 0 or more');
     const settle = opts.settle ?? 1e-4;
     const w0 = Math.sqrt(k / m);
     const zeta = c / (2 * Math.sqrt(k * m));
@@ -273,11 +273,11 @@ export function spring(writes, opts) {
  */
 export function glide(writes, opts) {
     const ms = opts.ms ?? 325;
-    if (!(ms > 0))
-        throw new RangeError('blits: a glide takes a positive ms');
+    if (!(ms > 0 && ms < Infinity))
+        throw new RangeError('blits: a glide takes a finite positive ms');
     const k = opts.stiffness ?? 170;
-    if (!(k > 0))
-        throw new RangeError('blits: a glide takes a positive stiffness');
+    if (!(k > 0 && k < Infinity))
+        throw new RangeError('blits: a glide takes a finite positive stiffness');
     const tau = ms / 1000;
     const settle = opts.settle ?? 1e-4;
     const bounded = opts.bounds !== undefined;