@msb235/blits 0.12.1 → 0.14.0

package/dist/mixer.d.ts

@@ -114,6 +114,13 @@ export declare class Mixer<I, O> implements Mix<I, O> {
     reducedNow: boolean;
     /** Something was changed since the last sync, so the next frame may differ from this one. */
     stirred: boolean;
+    /**
+     * The host read `inert` as true since the last sync, so its frame loop may be asleep until a
+     * change wakes it; a host that never asks keeps no loop asleep on it.
+     */
+    asleep: boolean;
+    /** Some voice cued while the mix slept waits for the next sync to set its start. */
+    waking: boolean;
     /** Counts the changes `stir` records, which a frame's record of a probe is current only before. */
     stirs: number;
     syncing: boolean;
@@ -259,6 +266,7 @@ export declare class Mixer<I, O> implements Mix<I, O> {
     voices(tag?: string): Handle<I>[];
     get live(): boolean;
     get inert(): boolean;
+    private restful;
     get rate(): number;
     set rate(r: number);
     ramp(rate: number, over: number): void;

package/dist/mixer.js

@@ -1,7 +1,7 @@
 import { cueArc } from './arcs.js';
 import { blended, blendOf, laneRead, shareKept } from './blend.js';
 import { aims, chain, headOf, linkable, relink, unlink } from './chain.js';
-import { lerpInto, scalarOp } from './channels.js';
+import { lerpInto, STOCK_BAND, scalarOp } from './channels.js';
 import { cue } from './cue.js';
 import { DepartedIndex } from './departed.js';
 import { beginFade, leaveVoice, parting } from './fade.js';
@@ -105,6 +105,13 @@ export class Mixer {
     reducedNow = false;
     /** Something was changed since the last sync, so the next frame may differ from this one. */
     stirred = false;
+    /**
+     * The host read `inert` as true since the last sync, so its frame loop may be asleep until a
+     * change wakes it; a host that never asks keeps no loop asleep on it.
+     */
+    asleep = false;
+    /** Some voice cued while the mix slept waits for the next sync to set its start. */
+    waking = false;
     /** Counts the changes `stir` records, which a frame's record of a probe is current only before. */
     stirs = 0;
     syncing = false;
@@ -328,7 +335,7 @@ export class Mixer {
         return typeof r === 'function' ? r() : r === true;
     }
     get band() {
-        return this.opts.band ?? { on: 0.6, off: 0.4 };
+        return this.opts.band ?? STOCK_BAND;
     }
     cue(spec) {
         this.attached();
@@ -474,6 +481,12 @@ export class Mixer {
     get inert() {
         if (this.stirred)
             return false;
+        const inert = this.restful();
+        if (inert && !Number.isNaN(this.now))
+            this.asleep = true;
+        return inert;
+    }
+    restful() {
         // Standing still, a voice changes no pose but by its weight signal, or by an anchor or start
         // that host time may yet reach.
         if (this.pace?.stopped(this.u))

package/dist/motion.d.ts

@@ -44,6 +44,11 @@ export type Moving<I, O, V extends Value> = Patch<I, O, void> & {
      * back at the latest frame too, however long it is before it is next read.
      */
     push(subject: I, velocity: V, at?: number): void;
+    /**
+     * Puts `subject` at `value` from voice time `at`, keeping its velocity, with `at` defaulting as
+     * `push`'s does: a spring or tween heads for its target from there, a glide coasts on from there.
+     */
+    set(subject: I, value: V, at?: number): void;
 };
 /**
  * The state behind a `'motion'` patch, for an engine that reads it directly; a patch another copy
@@ -90,6 +95,11 @@ export declare function spring<I, O, V extends Value = number>(writes: keyof O,
  * `ms`, and comes to rest `velocity · ms / 1000` past where it was released. `push` sets it moving
  * again from wherever it is. Closed form, so frame rate does not change where it stops.
  *
+ * With `bounds`, a coast that would stop past an edge springs back to it from where it crosses, at
+ * the speed it crosses at, on a critically damped spring of `stiffness`; one let go past an edge
+ * springs back from there, unless it coasts back inside. A `set` past an edge leaves the subject
+ * there, coasting on, until the next `push`, so a drag can hold it out.
+ *
  * @category patch
  */
 export declare function glide<I, O, V extends Value = number>(writes: keyof O, opts: Common<I, V> & {
@@ -97,7 +107,14 @@ export declare function glide<I, O, V extends Value = number>(writes: keyof O, o
     from: PerSubject<I, V>;
     /** The friction's time constant, ms. Default 325, a touch scroll's. */
     ms?: number;
-}): Moving<I, O, V>;
+    /** The least and greatest value a coast comes to rest at, per axis. Default none. */
+    bounds?: PerSubject<I, readonly [min: V, max: V]>;
+    /** The spring back's, per second squared, with `bounds`. Default 170, as a spring's. */
+    stiffness?: number;
+}): Moving<I, O, V> & {
+    /** `subject`'s bounds, undefined for a glide without them. */
+    bounds(subject: I): readonly [min: V, max: V] | undefined;
+};
 /**
  * From one value to another over `ms` along an easing, solved in closed form, so frame rate does not
  * change where a subject is. `to(subject, target)` retargets one subject mid-flight: the new stretch

package/dist/motion.js

@@ -1,4 +1,4 @@
-import { COAST, CRITICAL, EASED, OVER, UNDER } from './closed.js';
+import { BOUND, COAST, CRITICAL, EASED, OVER, UNDER } from './closed.js';
 import { curve } from './easing.js';
 import { Motions } from './motions.js';
 import { release } from './shared.js';
@@ -44,6 +44,9 @@ class MotionPatch {
         state.sample(s, setting.elapsed, state.xs, state.vs);
         return { [this.writes[0]]: state.value(s, state.xs) };
     }
+    set(subject, value, at) {
+        this.motions.change(subject, { at, x: axes(value) });
+    }
     read(subject, at) {
         const state = this.motions;
         const r = state.read(subject, at);
@@ -63,9 +66,18 @@ class SpringPatch extends TweenPatch {
     }
 }
 class GlidePatch extends MotionPatch {
+    edges;
+    constructor(writes, motions, edges) {
+        super(writes, motions);
+        this.edges = edges;
+    }
     push(subject, velocity, at) {
         this.motions.change(subject, { at, v: axes(velocity) });
     }
+    bounds(subject) {
+        const b = this.edges;
+        return b === undefined ? undefined : per(b, subject);
+    }
 }
 /**
  * The state behind a `'motion'` patch, for an engine that reads it directly; a patch another copy
@@ -124,12 +136,14 @@ class GlideShape {
     ms = undefined;
     start;
     speed;
+    edges;
     constructor(law, motion, opts, tau) {
         this.law = law;
         this.motion = motion;
         this.tau = tau;
         this.start = opts.from;
         this.speed = opts.velocity;
+        this.edges = opts.bounds;
     }
     spec() {
         return this.motion;
@@ -141,8 +155,24 @@ class GlideShape {
         const v = this.speed;
         return v === undefined ? still(x) : axes(per(v, s));
     }
-    aim(x, v) {
-        return x.map((xi, i) => xi + v[i] * this.tau);
+    aim(x, v, _was, s, put) {
+        const rest = x.map((xi, i) => xi + v[i] * this.tau);
+        if (this.edges === undefined)
+            return rest;
+        const [lo, hi] = per(this.edges, s);
+        const min = axes(lo);
+        const max = axes(hi);
+        if (min.length !== rest.length || max.length !== rest.length)
+            throw new Error('blits: bounds on a glide have as many axes as its subjects');
+        return rest.map((r, i) => {
+            const a = min[i];
+            const b = max[i];
+            const xi = x[i];
+            // A set past an edge stays there: a drag holds it out, and only a push lets it spring back.
+            if (put && (xi < a || xi > b))
+                return r;
+            return r < a ? a : r > b ? b : r;
+        });
     }
     scalar(s) {
         return typeof per(this.start, s) === 'number';
@@ -226,16 +256,25 @@ export function spring(writes, opts) {
  * `ms`, and comes to rest `velocity · ms / 1000` past where it was released. `push` sets it moving
  * again from wherever it is. Closed form, so frame rate does not change where it stops.
  *
+ * With `bounds`, a coast that would stop past an edge springs back to it from where it crosses, at
+ * the speed it crosses at, on a critically damped spring of `stiffness`; one let go past an edge
+ * springs back from there, unless it coasts back inside. A `set` past an edge leaves the subject
+ * there, coasting on, until the next `push`, so a drag can hold it out.
+ *
  * @category patch
  */
 export function glide(writes, opts) {
     const ms = opts.ms ?? 325;
     if (!(ms > 0))
         throw new RangeError('blits: a glide takes a positive ms');
+    const k = opts.stiffness ?? 170;
+    if (!(k > 0))
+        throw new RangeError('blits: a glide takes a positive stiffness');
     const tau = ms / 1000;
     const settle = opts.settle ?? 1e-4;
-    const shape = new GlideShape([COAST, settle, tau, 0, 0], { kind: 'glide', ms, settle }, opts, tau);
-    return new GlidePatch(writes, new Motions(shape));
+    const bounded = opts.bounds !== undefined;
+    const shape = new GlideShape(bounded ? [BOUND, settle, tau, Math.sqrt(k), 0] : [COAST, settle, tau, 0, 0], bounded ? { kind: 'glide', ms, settle, stiffness: k } : { kind: 'glide', ms, settle }, opts, tau);
+    return new GlidePatch(writes, new Motions(shape), opts.bounds);
 }
 /**
  * From one value to another over `ms` along an easing, solved in closed form, so frame rate does not

package/dist/motions.d.ts

@@ -20,6 +20,8 @@ export interface Change {
      */
     at?: number;
     to?: number[];
+    /** Where it moves from, in place of where its stretch has it then. */
+    x?: number[];
     v?: number[];
     /** The mix clock when it was made, NaN where no mix was playing the patch. */
     made?: number;
@@ -73,8 +75,11 @@ export interface Shape<I> {
     from: (subject: I) => number[];
     /** How fast each axis starts moving, given where it starts: still unless the options say. */
     velocity: (subject: I, x: number[]) => number[];
-    /** Where it heads when released from `x` at `v`, given where it was heading. */
-    aim: (x: number[], v: number[], was: number[] | null, subject: I) => number[];
+    /**
+     * Where it heads when released from `x` at `v`, given where it was heading; `put` for a stretch a
+     * `set` released.
+     */
+    aim: (x: number[], v: number[], was: number[] | null, subject: I, put: boolean) => number[];
     /** `[form, settle, k1, k2, k3]`. */
     law: readonly number[];
     /** Whether a subject's value is a number rather than an array. */
@@ -238,7 +243,7 @@ export declare class Motions<I> {
         s: number;
     } | undefined;
     /**
-     * Queues a retarget or push, untimed at the latest frame, for `subject`'s next read past its time.
+     * Queues a retarget, set or push, untimed at the latest frame, for `subject`'s next read past its time.
      * The queue keeps the changes with a time in time order, ahead of any still waiting for one.
      */
     change(subject: I, c: Change): void;

package/dist/motions.js

@@ -126,7 +126,7 @@ export class Motions {
             return known;
         const x = this.shape.from(subject);
         const v = this.shape.velocity(subject, x);
-        const to = this.shape.aim(x, v, null, subject);
+        const to = this.shape.aim(x, v, null, subject, false);
         const n = this.n < 0 ? x.length : this.n;
         this.check(x, n);
         this.check(v, n);
@@ -465,13 +465,14 @@ export class Motions {
         return { x, v, s };
     }
     /**
-     * Queues a retarget or push, untimed at the latest frame, for `subject`'s next read past its time.
+     * Queues a retarget, set or push, untimed at the latest frame, for `subject`'s next read past its time.
      * The queue keeps the changes with a time in time order, ahead of any still waiting for one.
      */
     change(subject, c) {
         const back = this.owner === null ? Number.NaN : this.owner.revive(this.ownerId, subject);
         const s = this.slot(subject);
         this.check(c.to, this.n);
+        this.check(c.x, this.n);
         this.check(c.v, this.n);
         c.made = this.owner === null ? Number.NaN : this.owner.now();
         c.seq = this.owner === null ? Number.NaN : this.owner.seq();
@@ -494,7 +495,7 @@ export class Motions {
         else
             this.queue(list, c, c.at);
         reading.moved++;
-        const made = { at: c.at, to: c.to, v: c.v };
+        const made = { at: c.at, to: c.to, x: c.x, v: c.v };
         this.owner?.changed(this.ownerId, this, subject, made);
     }
     /** Files a change with a time after every one due by then, ahead of those still waiting for one. */
@@ -671,11 +672,12 @@ export class Motions {
             landing = { x: new Float64Array(n), v: new Float64Array(n) };
         const { x, v } = landing;
         this.evaluateSegment(seg, at, x, v);
-        const xs = numbers(x, 0, n);
+        const xs = change.x ?? 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);
+        const put = change.x !== undefined && change.v === undefined;
+        const to = this.shape.aim(xs, vs, change.to ?? seg.to, known, put);
         const ms = subject === absent ? seg.ms : (this.shape.ms?.(known) ?? 0);
         return { at, ms, x0: xs, v0: vs, to, change };
     }

package/dist/move.js

@@ -9,7 +9,7 @@ import { begin } from './held.js';
 import { noted } from './history.js';
 import { leave as leaveClock } from './origin.js';
 import { ownerReading } from './owner.js';
-import { mixAt, place, repin, startOf } from './place.js';
+import { mixAt, place, repin, startAt, startOf } from './place.js';
 import { pageVoice } from './revive.js';
 import { delist } from './roster.js';
 import { scoredLeft, scoredRemove } from './scored.js';
@@ -47,6 +47,8 @@ function moveTo(mix, now) {
     for (const a of mix.announced)
         if (Number.isNaN(a.at))
             a.at = mix.u;
+    if (mix.waking)
+        wake(mix, now);
     if (mix.pins !== null && mix.pins.size > 0)
         repin(mix);
     if (mix.anchored > 0)
@@ -137,10 +139,31 @@ function moveTo(mix, now) {
     if (mix.sharers.length > 0 && !mix.projecting)
         outgrow(mix);
     mix.stirred = false;
+    mix.asleep = false;
     if (mix.retired.length > 0)
         prune(mix);
     forget(mix);
 }
+/** Starts each voice cued while the mix slept at `now`, the first sync after its cue. */
+function wake(mix, now) {
+    mix.waking = false;
+    for (const voice of mix.cued) {
+        if (!voice.waking)
+            continue;
+        voice.waking = false;
+        if (voice.state !== 'pending')
+            continue;
+        startAt(mix, voice, now);
+        // Where a seek back before the cue puts it, so the tape's cue again starts it here.
+        const first = voice.first;
+        if (first !== null) {
+            first.start = now;
+            first.anchorNow = now;
+        }
+        if (!mix.projecting)
+            schedule(mix, voice);
+    }
+}
 /**
  * Which way a voice's clock is running at mix time `now`, through every owner above it: above 0
  * forward, below 0 back, 0 standing still.
@@ -172,6 +195,8 @@ function turn(mix, voice, now) {
  */
 const SEARCHED = 8;
 const SPARSE = 32;
+/** The most retired voices `prune` splices out one at a time, rather than closing up in one pass. */
+const SPLICED = 4;
 /**
  * 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
@@ -200,16 +225,21 @@ function prune(mix) {
     if (at !== null) {
         for (const voice of retired)
             pruned = leave(mix, voice) || pruned;
-        // 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];
+        // A splice moves the tail natively, several times faster than a loop, but once a voice.
+        if (at.length <= SPLICED)
+            for (let k = at.length - 1; k >= 0; k--)
+                voices.splice(at[k], 1);
+        else {
+            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;
         }
-        voices.length = kept;
     }
     else {
         let kept = 0;

package/dist/origin.d.ts

@@ -5,12 +5,14 @@ export interface Past extends Clock {
     until: number;
     /** The voice's `rebuilds` while it ran on this clock. */
     rebuilds: number;
+    /** Whether the voice left it by a seek. */
+    sought: boolean;
 }
 /**
  * Keeps the clock a voice is leaving at its local time `u`, ahead of a rate change, ramp or seek,
  * where a subject's origin could still be found on it.
  */
-export declare function leave<I, O>(voice: Voice<I, O>, u: number): void;
+export declare function leave<I, O>(voice: Voice<I, O>, u: number, sought?: boolean): void;
 /**
  * The mix time a voice's clock first read `elapsed`, or will by its controls now, through its owners'
  * clocks. A clock entered already past it, by a seek, answers where that clock would have read it.

package/dist/origin.js

@@ -5,7 +5,7 @@ const MOST = 256;
  * Keeps the clock a voice is leaving at its local time `u`, ahead of a rate change, ramp or seek,
  * where a subject's origin could still be found on it.
  */
-export function leave(voice, u) {
+export function leave(voice, u, sought = false) {
     const past = voice.clocks;
     if (past !== null && past.length >= MOST)
         return;
@@ -14,7 +14,7 @@ export function leave(voice, u) {
     if (past !== null && reached(past, 0) >= reach && reached(past, fresh(voice)) >= reach)
         return;
     const { anchorNow, anchorElapsed, rate, ramp, rebuilds } = voice;
-    const left = { anchorNow, anchorElapsed, rate, ramp, until: u, rebuilds };
+    const left = { anchorNow, anchorElapsed, rate, ramp, until: u, rebuilds, sought };
     if (past === null)
         voice.clocks = [left];
     else
@@ -41,6 +41,18 @@ function fresh(voice) {
         i++;
     return i;
 }
+/**
+ * Where a walk for a stateful record at `elapsed` starts after a seek back before it: the clock that
+ * seek entered, since a subject sent back before its start starts afresh.
+ */
+function backFrom(voice, past, elapsed) {
+    for (let i = past.length - 1; i >= 0; i--) {
+        const p = past[i];
+        if (p.sought && (past[i + 1]?.anchorElapsed ?? voice.anchorElapsed) < elapsed)
+            return i + 1;
+    }
+    return 0;
+}
 /**
  * The mix time a voice's clock first read `elapsed`, or will by its controls now, through its owners'
  * clocks. A clock entered already past it, by a seek, answers where that clock would have read it.
@@ -51,7 +63,8 @@ export function originOf(voice, elapsed, rebuilt) {
     // A voice with no first pass shows every subject from its start, whatever its stagger.
     let t = voice.beginless ? voice.start : Number.NaN;
     if (past !== null && Number.isNaN(t)) {
-        for (let i = rebuilt ? fresh(voice) : 0; i < past.length; i++) {
+        const from = rebuilt ? Math.max(fresh(voice), backFrom(voice, past, elapsed)) : 0;
+        for (let i = from; i < past.length; i++) {
             const p = past[i];
             const at = timeWith(p, elapsed);
             if (at <= p.until) {

package/dist/pack.d.ts

@@ -7,6 +7,7 @@ export interface PackedRecord {
     shown: number;
     weight: number;
     rested: boolean;
+    restedAt: number;
     bands: number[] | null;
     state: unknown;
     stepped: number;

package/dist/pack.js

@@ -11,6 +11,7 @@ export function packHeld(voice, h) {
         shown: h.shown,
         weight: h.weight,
         rested: h.rested,
+        restedAt: h.restedAt,
         bands: h.bands === null ? null : Array.from(h.bands),
         state: h.state === undefined ? undefined : patch.pack ? patch.pack(h.state) : clone(h.state),
         stepped: h.stepped,
@@ -40,6 +41,7 @@ export function unpackHeld(voice, p) {
     h.shown = p.shown;
     h.weight = p.weight;
     h.rested = p.rested;
+    h.restedAt = p.restedAt;
     h.bands = bands;
     h.stepped = p.stepped;
     h.ticks = p.ticks;

package/dist/project.js

@@ -291,6 +291,7 @@ function copyAhead(mix, c) {
             pin(c, copy, at);
         return copy;
     });
+    c.waking = mix.waking;
     ownBlends(c.cued);
     // A copy keeps no list of owners, so the one before says only by its voices.
     if (mix.owners !== null || (mix.projecting && c.cued.some((v) => v.holding !== null)))

package/dist/record.js

@@ -13,6 +13,7 @@ export function record(voice, reaches, state) {
         shown: 0,
         weight: 0,
         rested: false,
+        restedAt: Number.NaN,
         bands: null,
         state,
         // -0, not 0: a field first given a small integer is boxed on every later write of a double.

package/dist/rows.js

@@ -181,8 +181,10 @@ function copyRow(from, p, to, q, keys = from.keys) {
     carry(from.data, p * 8 /* Row.STRIDE */, to.data, q * 8 /* Row.STRIDE */, 8 /* Row.STRIDE */);
     carry(from.hot, p * from.stride, to.hot, q * to.stride, from.stride);
     copyKeys(keys, to, q);
-    if ((from.hot[p * from.stride + 0 /* Hot.FLAGS */] & 4 /* Flag.STALE */) !== 0)
+    if ((from.hot[p * from.stride + 0 /* Hot.FLAGS */] & 4 /* Flag.STALE */) !== 0) {
         to.stale = true;
+        to.staleRows.push(q);
+    }
     carry(from.samples, p * from.axes, to.samples, q * to.axes, from.axes);
     to.deltas[q] = from.deltas[p] ?? null;
     to.records[q] = from.records[p];

package/dist/seek.js

@@ -33,8 +33,7 @@ function restore(mix, voice, live, at, every, mine) {
         const h = mine && live.reaches ? unread(live) : copyHeld(voice, live);
         if (h.stepped > t)
             h.stepped = t;
-        // Whether it had rested by `t` is not kept; the next probe finds it again.
-        h.rested = false;
+        restedBy(h, live, t);
         h.weight = 0;
         h.inputs = inputs;
         if (!(h.since <= t))
@@ -63,6 +62,7 @@ function restore(mix, voice, live, at, every, mine) {
     else
         h = copyHeld(voice, snap.held, true);
     h.weight = 0;
+    restedBy(h, live, t);
     if (snap.at < t)
         h.copied = true;
     const kept = i + 1;
@@ -108,6 +108,14 @@ function restore(mix, voice, live, at, every, mine) {
     }
     return h;
 }
+/**
+ * Whether a record put back for mix time `t` had rested by then, from when the live one did: a
+ * subject may have rested and moved on since, so a probe at `t` would not find it at rest again.
+ */
+function restedBy(h, live, t) {
+    h.rested = live.restedAt <= t;
+    h.restedAt = h.rested ? live.restedAt : Number.NaN;
+}
 /** Cuts a record's list of copies to its first `kept`, keeping those no other list holds as spares. */
 function trim(voice, snaps, kept) {
     while (snaps.length > kept) {
@@ -252,7 +260,14 @@ export function seek(transport, to) {
     if (frame === undefined) {
         // Ahead, under the rate the recorded calls up to `t` set, past any frames rate 0 held at `t`.
         const last = replay(transport, (at) => (transport.pace === null ? at : transport.pace.reading(at)) <= t);
-        const at = hostAhead(transport, t);
+        const left = transport.left;
+        // Inverting the rate can land an ulp from where the host stood, which every later sync would carry.
+        const at = left !== null &&
+            left.t === t &&
+            left.u >= transport.u &&
+            (transport.pace === null ? left.u : transport.pace.reading(left.u)) === t
+            ? left.u
+            : hostAhead(transport, t);
         const u = Number.isNaN(last) ? at : Math.max(last, at);
         if (!Number.isFinite(u))
             throw new RangeError(`blits: the mix's rate never reaches ${t}`);
@@ -266,6 +281,7 @@ export function seek(transport, to) {
         // On the frame itself, its own host time: rate 0 may have held the clock there for several.
         const u = frame.at === t ? frame.u : hostAt(transport, t);
         const seq = frame.seq;
+        transport.left = { t: transport.now, u: transport.u };
         tape.goto(tape.depthAt(u));
         transport.undrop(seq);
         // What history kept after the frame is let go; the tape holds the calls that made it.

package/dist/shared.d.ts

@@ -2,7 +2,7 @@
  * The package version, for a fact whose shape follows the code too closely to version by hand:
  * copies of different releases keep apart. `test/copies.test.ts` holds it to `package.json`.
  */
-export declare const release = "0.12.1";
+export declare const release = "0.14.0";
 /**
  * A WeakMap every copy of blits loaded in one realm shares, so a fact one copy records about a
  * patch or channel it made is read by another copy's mix. The name carries a version, bumped when

package/dist/shared.js

@@ -2,7 +2,7 @@
  * The package version, for a fact whose shape follows the code too closely to version by hand:
  * copies of different releases keep apart. `test/copies.test.ts` holds it to `package.json`.
  */
-export const release = '0.12.1';
+export const release = '0.14.0';
 /**
  * A WeakMap every copy of blits loaded in one realm shares, so a fact one copy records about a
  * patch or channel it made is read by another copy's mix. The name carries a version, bumped when

package/dist/stack.d.ts

@@ -3,8 +3,8 @@ import type { Kit } from './types.js';
  * Folds deltas into one pose by a kit's arithmetic, in order, with no mix and no clock: what a mix
  * gives for voices contributing these deltas at these weights. Each channel starts at its rest, a
  * weight (default 1, held to 0..1) fades a delta toward rest, and the pose is clamped to each
- * channel's bounds. A channel with no rest takes the last delta whose weight is 0.6 or more, where
- * a mix's default band first switches one on, and stays undefined where none is.
+ * channel's bounds. A channel with no rest takes the last delta a mix's default band switches on, any
+ * weight above 0, and stays undefined where none is.
  *
  * @category channel
  */

package/dist/stack.js

@@ -1,13 +1,12 @@
+import { STOCK_BAND } from './channels.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;
 /**
  * Folds deltas into one pose by a kit's arithmetic, in order, with no mix and no clock: what a mix
  * gives for voices contributing these deltas at these weights. Each channel starts at its rest, a
  * weight (default 1, held to 0..1) fades a delta toward rest, and the pose is clamped to each
- * channel's bounds. A channel with no rest takes the last delta whose weight is 0.6 or more, where
- * a mix's default band first switches one on, and stays undefined where none is.
+ * channel's bounds. A channel with no rest takes the last delta a mix's default band switches on, any
+ * weight above 0, and stays undefined where none is.
  *
  * @category channel
  */
@@ -34,7 +33,7 @@ export function fold(kit, deltas, weights) {
                 pose[key] = channel.fold
                     ? channel.fold(pose[key], value, w)
                     : merged(channel, pose[key], channel.scale(value, w));
-            else if (w >= ON)
+            else if (w >= STOCK_BAND.on)
                 pose[key] = pose[key] === undefined ? first(value) : merged(channel, pose[key], value);
         }
     }

package/dist/strays.js

@@ -117,7 +117,7 @@ function changeAhead(to, id, motion, given, change) {
         made.set(motion, bySubject);
     }
     const list = bySubject.get(subject);
-    const c = { at, to: change.to, v: change.v };
+    const c = { at, to: change.to, x: change.x, v: change.v };
     if (list === undefined)
         bySubject.set(subject, [c]);
     else {

package/dist/transport.d.ts

@@ -73,6 +73,11 @@ export declare class Transport implements TransportApi {
     /** Host time at the last sync: the host's timestamp less every gap `rebase` took out. */
     u: number;
     offset: number;
+    /** Where the last seek back left from, so a seek ahead to the same mix time lands on the same host time. */
+    left: {
+        t: number;
+        u: number;
+    } | null;
     /** The mix time of the first sync. */
     born: number;
     /** The earliest mix time what history keeps in memory restores exactly. */

package/dist/transport.js

@@ -45,6 +45,8 @@ export class Transport {
     /** Host time at the last sync: the host's timestamp less every gap `rebase` took out. */
     u = Number.NaN;
     offset = 0;
+    /** Where the last seek back left from, so a seek ahead to the same mix time lands on the same host time. */
+    left = null;
     /** The mix time of the first sync. */
     born = Number.NaN;
     /** The earliest mix time what history keeps in memory restores exactly. */