@msb235/blits 0.13.0 → 0.15.0

package/dist/changes.js

@@ -0,0 +1,189 @@
+import { absent } from './numbers.js';
+import { reading } from './reading.js';
+import { numbers } from './stretch.js';
+const PENDING = 2 /* RunFlag.PENDING */;
+const OLDER = 4 /* RunFlag.OLDER */;
+/** 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) };
+/**
+ * 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.
+ */
+export function 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();
+    c.early = this.owner?.early() === true;
+    if (c.at === undefined) {
+        const at = this.frame(subject);
+        if (!Number.isNaN(at))
+            c.at = at;
+        else if (!Number.isNaN(back))
+            c.at = back;
+    }
+    const list = this.pending?.[s];
+    if (list === undefined) {
+        if (this.pending === null)
+            this.pending = [undefined];
+        this.pending[s] = [c];
+        this.flag(s, PENDING, true);
+    }
+    else if (c.at === undefined)
+        list.push(c);
+    else
+        this.queue(list, c, c.at);
+    reading.moved++;
+    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. */
+export function queue(list, c, at) {
+    let i = list.length;
+    while (i > 0) {
+        const before = list[i - 1].at;
+        if (before !== undefined && before <= at)
+            break;
+        i--;
+    }
+    list.splice(i, 0, c);
+}
+/** Every change due by `t` applied to a copy of the stretch playing then, committing nothing. */
+export function peek(s, t, xo, vo) {
+    let seg = this.playing(s, t);
+    const list = this.dueTo(s);
+    if (list !== undefined)
+        for (const change of list) {
+            const a = change.at;
+            if (a === undefined || !(a <= t))
+                break;
+            if (a >= seg.at)
+                seg = this.applied(this.numbers.subject(s), seg, change, a);
+        }
+    this.evaluateSegment(seg, t, xo, vo);
+}
+/** Subject `s`'s changes waiting, with those a read ahead's tape made filed among them by time. */
+export function 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);
+}
+/**
+ * Takes back every change made after frame `seq`: each subject plays from its earliest stretch
+ * kept, with the changes made by then queued to be applied again.
+ */
+export function rewind(seq) {
+    this.unrelease(seq);
+    for (let s = 0; s < this.numbers.size; s++)
+        if (this.numbers.subject(s) !== absent)
+            this.cut(s, seq);
+}
+export function cut(s, seq) {
+    const older = this.older?.[s];
+    const pending = this.pending?.[s];
+    const current = this.latest(s);
+    const stretches = older === undefined ? [current] : [...older, current];
+    const kept = [];
+    let cut = false;
+    for (const c of [...stretches.slice(1).map((seg) => seg.change), ...(pending ?? [])])
+        if (c === undefined || c.seq === undefined || !(c.seq > seq)) {
+            if (c !== undefined)
+                kept.push(c);
+        }
+        else
+            cut = true;
+    if (!cut)
+        return;
+    if (older !== undefined) {
+        this.older[s] = undefined;
+        this.flag(s, OLDER, false);
+    }
+    this.write(s, stretches[0]);
+    // Applied again in the order they take effect; one never stamped waits for the next read.
+    const timed = kept
+        .filter((c) => c.at !== undefined)
+        .sort((a, b) => a.at - b.at);
+    const list = [...timed, ...kept.filter((c) => c.at === undefined)];
+    if (list.length === 0) {
+        if (pending !== undefined) {
+            this.pending[s] = undefined;
+            this.flag(s, PENDING, false);
+        }
+        return;
+    }
+    if (this.pending === null)
+        this.pending = [undefined];
+    this.pending[s] = list;
+    this.flag(s, PENDING, true);
+}
+/** The stretch `change` releases from `seg` at `at`, for `subject` or one no longer numbered. */
+export function applied(subject, seg, change, at) {
+    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 = change.x ?? numbers(x, 0, n);
+    const vs = change.v ?? numbers(v, 0, n);
+    const known = subject === absent ? undefined : subject;
+    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 };
+}
+export function commit(s, t) {
+    const list = this.pending[s];
+    // The first read of a subject no frame had met: those waiting for a time take this one.
+    if (list[list.length - 1].at === undefined) {
+        let i = list.length;
+        while (i > 0 && list[i - 1].at === undefined)
+            i--;
+        for (const c of list.splice(i)) {
+            c.at = t;
+            this.queue(list, c, t);
+        }
+    }
+    while (list.length > 0) {
+        const change = list[0];
+        const a = change.at;
+        if (a > t)
+            break;
+        list.shift();
+        this.insert(s, this.applied(this.numbers.subject(s), this.playing(s, a), change, a));
+    }
+    if (list.length === 0) {
+        this.pending[s] = undefined;
+        this.flag(s, PENDING, false);
+    }
+}
+export function insert(s, seg) {
+    let list = this.older?.[s];
+    if (list === undefined) {
+        list = [];
+        if (this.older === null)
+            this.older = [undefined];
+        this.older[s] = list;
+        this.flag(s, OLDER, true);
+    }
+    if (seg.at >= this.runs[this.base(s)]) {
+        list.push(this.latest(s));
+        this.write(s, seg);
+        return;
+    }
+    let i = list.length;
+    while (i > 0 && list[i - 1].at > seg.at)
+        i--;
+    list.splice(i, 0, seg);
+}

package/dist/channels.d.ts

@@ -26,6 +26,11 @@ export interface Numeric {
     axes: number;
     /** An angle's full turn: each value is taken the short way round before it folds. */
     turn?: number;
+    /**
+     * An `'own'` channel whose fold is this plain arithmetic, its lerp alone its own: a lane folds
+     * it as the op and lerps it through the channel. A copy that predates it folds it as `'own'`.
+     */
+    folds?: 'sum';
 }
 /**
  * The stock arithmetic of a channel `sum`, `mul`, `max` or `vec` made, or `vouch` was given, keyed
@@ -55,49 +60,71 @@ export interface NumberOptions {
     bounds?: readonly [min: number, max: number];
 }
 /**
- * Position axes, rotation, crawl, yaw, pitch, offset.
+ * A number whose contributions add, resting at 0.
+ *
+ * A weight scales a contribution toward 0, so two voices each moving `x` by 10 at half weight move it
+ * 10 in all. For position axes, rotation, crawl, yaw, pitch, offset.
  *
  * @category channel
  */
 export declare function sum(opts?: NumberOptions): Channel<number>;
 /**
- * Gain, scale, opacity, hold.
+ * A number whose contributions multiply, resting at 1.
+ *
+ * A weight fades a contribution toward 1 rather than 0, so 0.5 at half weight multiplies by 0.75, and
+ * at weight 0 it leaves the value alone. For gain, scale, opacity, hold.
  *
  * @category channel
  */
 export declare function mul(opts?: NumberOptions): Channel<number>;
 /**
- * Dark, aperture.
+ * A number where the largest contribution wins, resting at 0.
+ *
+ * A weight scales a contribution toward 0 before the comparison, so a fading voice gives way once
+ * another's value passes its scaled one. For dark, aperture.
  *
  * @category channel
  */
 export declare function max(opts?: NumberOptions): Channel<number>;
 /**
- * A channel with no rest: the last contribution to pass wins, and a weight can only gate it. The
+ * What `last` takes.
+ *
+ * @category channel
+ */
+export interface LastOptions<V> {
+    /** How to interpolate between two values. Default: step at the midpoint. */
+    lerp?: (a: V, b: V, u: number) => V;
+}
+/**
+ * A channel with no rest, where the last contribution to pass wins. A weight can only gate it. The
  * default `lerp` steps at the midpoint, which is all a value with no arithmetic can promise; a
  * consumer with a real interpolation passes its own, as `hex` does.
  *
  * @category channel
  */
-export declare function last<V>(opts?: {
-    lerp?: (a: V, b: V, u: number) => V;
-}): Channel<V>;
+export declare function last<V>(opts?: LastOptions<V>): Channel<V>;
 /**
  * `n` copies of `v` in an array the engine stores as doubles from the start, so a copy of it, and
  * every fraction written into that copy, keeps one element kind: a pose's arrays then look alike to
  * every fold, whichever path made them.
  */
 export declare function doubles(n: number, v: number): number[];
-type Tuple<N extends number, T extends number[] = []> = T['length'] extends N ? T : Tuple<N, [...T, number]>;
 /**
- * `N` numbers: a tuple where `N` is a literal, as `Vec<3>` is `[number, number, number]`, and
- * `number[]` where it is only known to be a number.
+ * A tuple of `N` numbers, as `NumberTuple<3>` is `[number, number, number]`. `T` is the tuple built
+ * so far; leave it out.
+ *
+ * @category channel
+ */
+export type NumberTuple<N extends number, T extends number[] = []> = T['length'] extends N ? T : NumberTuple<N, [...T, number]>;
+/**
+ * `N` numbers, as a tuple where `N` is a literal. `Vec<3>` is `[number, number, number]`, and a
+ * `Vec` is `number[]` where `N` is only known to be a number.
  *
  * @category channel
  */
-export type Vec<N extends number> = number extends N ? number[] : Tuple<N>;
+export type Vec<N extends number> = number extends N ? number[] : NumberTuple<N>;
 /**
- * Vec3 position, premultiplied light: one channel's arithmetic applied down an axis list.
+ * One channel's arithmetic applied down an axis list. For a Vec3 position, or premultiplied light.
  *
  * @category channel
  */
@@ -108,4 +135,3 @@ export declare function vec<N extends number>(n: N, of: Channel<number>): Channe
  * @category channel
  */
 export declare function kit<O>(channels: Kit<O>): Kit<O>;
-export {};

package/dist/channels.js

@@ -67,7 +67,10 @@ export function scalarOp(channel) {
 /** Bounds change how a value folds at its edges, so they are part of the kind. */
 const kindOf = (name, bounds) => bounds === undefined ? name : `${name}[${bounds[0]}, ${bounds[1]}]`;
 /**
- * Position axes, rotation, crawl, yaw, pitch, offset.
+ * A number whose contributions add, resting at 0.
+ *
+ * A weight scales a contribution toward 0, so two voices each moving `x` by 10 at half weight move it
+ * 10 in all. For position axes, rotation, crawl, yaw, pitch, offset.
  *
  * @category channel
  */
@@ -84,7 +87,10 @@ export function sum(opts) {
     return channel;
 }
 /**
- * Gain, scale, opacity, hold.
+ * A number whose contributions multiply, resting at 1.
+ *
+ * A weight fades a contribution toward 1 rather than 0, so 0.5 at half weight multiplies by 0.75, and
+ * at weight 0 it leaves the value alone. For gain, scale, opacity, hold.
  *
  * @category channel
  */
@@ -101,7 +107,10 @@ export function mul(opts) {
     return channel;
 }
 /**
- * Dark, aperture.
+ * A number where the largest contribution wins, resting at 0.
+ *
+ * A weight scales a contribution toward 0 before the comparison, so a fading voice gives way once
+ * another's value passes its scaled one. For dark, aperture.
  *
  * @category channel
  */
@@ -118,7 +127,7 @@ export function max(opts) {
     return channel;
 }
 /**
- * A channel with no rest: the last contribution to pass wins, and a weight can only gate it. The
+ * A channel with no rest, where the last contribution to pass wins. A weight can only gate it. The
  * default `lerp` steps at the midpoint, which is all a value with no arithmetic can promise; a
  * consumer with a real interpolation passes its own, as `hex` does.
  *
@@ -148,7 +157,7 @@ export function doubles(n, v) {
     return a;
 }
 /**
- * Vec3 position, premultiplied light: one channel's arithmetic applied down an axis list.
+ * One channel's arithmetic applied down an axis list. For a Vec3 position, or premultiplied light.
  *
  * @category channel
  */

package/dist/closed.d.ts

@@ -5,6 +5,7 @@ export declare const CRITICAL = 1;
 export declare const OVER = 2;
 export declare const COAST = 3;
 export declare const EASED = 4;
+export declare const BOUND = 5;
 /**
  * A stretch at voice time `t`, released at `at` from `x0` moving at `v0` toward `to` (each read
  * from its offset), into `xo` and `vo`: the one copy of the closed forms, which `law` (a patch's

package/dist/closed.js

@@ -6,6 +6,7 @@ export const CRITICAL = 1;
 export const OVER = 2;
 export const COAST = 3;
 export const EASED = 4;
+export const BOUND = 5;
 const solved = { y: 0, dy: 0 };
 /**
  * The terms of a stretch that depend only on how long since its release, the same on every axis, so
@@ -114,6 +115,46 @@ function solveGlide(law, y0) {
     solved.y = y0 * e;
     solved.dy = (-y0 / tau) * e;
 }
+/**
+ * A glide with bounds, heading for `goal`: the rest point itself where the coast stops inside them,
+ * else the edge it springs back to. Which one is read off the stretch, so no stretch carries more
+ * than an unbounded one: the coast's own rest, worked out as the glide's `aim` does, is `goal`
+ * exactly when it stops inside; past it on the side `x0` is on too, the subject was let go past the
+ * edge and springs back at once; else it coasts until it crosses the edge and springs from there,
+ * at the speed it crossed at. The spring is critically damped, its ω₀ the law's `k2`.
+ */
+function solveBound(law, x0, goal, v0, t) {
+    const tau = law[2];
+    const y0 = x0 - goal;
+    const over = x0 + v0 * tau - goal;
+    if (over === 0) {
+        solveGlide(law, y0);
+        return;
+    }
+    const w0 = law[3];
+    if (y0 * over > 0) {
+        const e = Math.exp(-w0 * t);
+        const b = v0 + w0 * y0;
+        const y = e * (y0 + b * t);
+        solved.y = y;
+        solved.dy = e * b - w0 * y;
+        return;
+    }
+    // e^(−t/τ) where the coast meets the edge: the fraction of its speed it still has there.
+    const left = 1 + y0 / (v0 * tau);
+    const cross = left > 0 ? -tau * Math.log(left) : Number.POSITIVE_INFINITY;
+    if (t < cross) {
+        const e = timed.e;
+        solved.y = y0 + v0 * tau * (1 - e);
+        solved.dy = v0 * e;
+        return;
+    }
+    const s = t - cross;
+    const vc = v0 * left;
+    const e = Math.exp(-w0 * s);
+    solved.y = e * vc * s;
+    solved.dy = e * vc * (1 - w0 * s);
+}
 /**
  * A stretch at voice time `t`, released at `at` from `x0` moving at `v0` toward `to` (each read
  * from its offset), into `xo` and `vo`: the one copy of the closed forms, which `law` (a patch's
@@ -130,7 +171,10 @@ export function closed(law, ease, n, at, ms, x0, x, v0, v, to, g, t, xo, vo) {
     prepare(law, dt);
     for (let i = 0; i < n; i++) {
         const goal = to[g + i];
-        solve(law, x0[x + i] - goal, v0[v + i], dt);
+        if (law[0] === BOUND)
+            solveBound(law, x0[x + i], goal, v0[v + i], dt);
+        else
+            solve(law, x0[x + i] - goal, v0[v + i], dt);
         xo[i] = goal + solved.y;
         vo[i] = solved.dy;
         if (Math.abs(solved.y) > settle || Math.abs(solved.dy) > settle)

package/dist/color.d.ts

@@ -1,13 +1,14 @@
 import type { Channel } from './types.js';
 /**
- * OKLCH, hue the short way round, so a crossfade between hues keeps its lightness and saturation
- * instead of dipping through a muddy middle. A mix that leaves sRGB's gamut is clipped per channel.
+ * Crossfades two hex colors in OKLCH, hue the short way round. A crossfade between hues then keeps
+ * its lightness and saturation instead of dipping through a muddy middle. A mix that leaves sRGB's
+ * gamut is clipped per channel.
  *
  * @category channel
  */
 export declare function mixHex(a: number, b: number, u: number): number;
 /**
- * How a `color` channel interpolates two colors: straight across OKLab, or in OKLCH with hue the
+ * How a `color` channel interpolates two colors. Straight across OKLab, or in OKLCH with hue the
  * short way round, as `mixHex` does.
  *
  * @category channel
@@ -21,29 +22,30 @@ export interface ColorOptions {
  * `toHex` divides it out and lays it over what is under it. `color(last())` replaces, the last
  * voice to pass winning, at the coverage it was authored with. `lerp` picks how two colors
  * interpolate: OKLab, the default, crosses through gray between opposite hues, and `'oklch'`
- * goes round the hue instead, off lanes.
+ * goes round the hue instead.
  *
  * @category channel
  */
 export declare function color(opts?: ColorOptions): Channel<number[]>;
 export declare function color(of: Channel<number> | Channel<unknown>, opts?: ColorOptions): Channel<number[]>;
 /**
- * 0xrrggbb as a `color` value: OKLab `[L, a, b]` at full coverage. Convert keyframe stops once
- * when authoring them, and call it outside the hot path in an `fn` patch.
+ * Converts 0xrrggbb to a `color` value. The value is OKLab `[L, a, b]` at full coverage. Convert
+ * keyframe stops once when authoring them, and call it outside the hot path in an `fn` patch.
  *
  * @category channel
  */
 export declare function oklab(rgb: number): number[];
 /**
- * A `color` pose as 0xrrggbb: its color divided out of its coverage, the coverage capped at 1
- * and laid over `under` in OKLab, then clipped to sRGB per channel. No coverage gives `under`.
+ * A `color` pose as 0xrrggbb, laid over `under`. Its color is divided out of its coverage, the
+ * coverage capped at 1 and laid over `under` in OKLab, then clipped to sRGB per channel. No
+ * coverage gives `under`.
  *
  * @category channel
  */
 export declare function toHex(pose: ArrayLike<number>, under?: number): number;
 /**
- * A `color` pose as a CSS `oklab()` color with its coverage, capped at 1, as the alpha, for a
- * host that lets the browser lay it over what is under it.
+ * A `color` pose as a CSS `oklab()` color, its coverage as the alpha. The coverage is capped at 1.
+ * For a host that lets the browser lay it over what is under it.
  *
  * @category channel
  */

package/dist/color.js

@@ -82,8 +82,9 @@ function fromOklch(L, C, h) {
     return fromLab(L, C * Math.cos(h), C * Math.sin(h));
 }
 /**
- * OKLCH, hue the short way round, so a crossfade between hues keeps its lightness and saturation
- * instead of dipping through a muddy middle. A mix that leaves sRGB's gamut is clipped per channel.
+ * Crossfades two hex colors in OKLCH, hue the short way round. A crossfade between hues then keeps
+ * its lightness and saturation instead of dipping through a muddy middle. A mix that leaves sRGB's
+ * gamut is clipped per channel.
  *
  * @category channel
  */
@@ -98,14 +99,19 @@ export function mixHex(a, b, u) {
     const ah = slotH[sa];
     const sb = oklch(b);
     const bc = slotC[sb];
-    const from = ac < GRAY ? slotH[sb] : ah;
-    const to = bc < GRAY ? ah : slotH[sb];
+    const h = hueAt(ah, ac, slotH[sb], bc, u);
+    return fromOklch(mix(al, slotL[sb], u), mix(ac, bc, u), h);
+}
+/** The hue `u` of the way from `ah` to `bh` the short way round, a gray end taking the other's. */
+function hueAt(ah, ac, bh, bc, u) {
+    const from = ac < GRAY ? bh : ah;
+    const to = bc < GRAY ? ah : bh;
     let turn = to - from;
     if (turn > Math.PI)
         turn -= 2 * Math.PI;
     else if (turn < -Math.PI)
         turn += 2 * Math.PI;
-    return fromOklch(mix(al, slotL[sb], u), mix(ac, bc, u), from + turn * u);
+    return from + turn * u;
 }
 /** Two OKLab colors with coverage, interpolated in OKLCH: color by `u`, coverage by `u` alongside. */
 function lerpLch(x, y, u) {
@@ -126,17 +132,8 @@ function lerpLch(x, y, u) {
     const toB = yw > 0 ? yB : xB;
     const xc = Math.sqrt(xA * xA + xB * xB);
     const yc = Math.sqrt(toA * toA + toB * toB);
-    const xh = Math.atan2(xB, xA);
-    const yh = Math.atan2(toB, toA);
-    const from = xc < GRAY ? yh : xh;
-    const to = yc < GRAY ? xh : yh;
-    let turn = to - from;
-    if (turn > Math.PI)
-        turn -= 2 * Math.PI;
-    else if (turn < -Math.PI)
-        turn += 2 * Math.PI;
     const C = mix(xc, yc, u);
-    const h = from + turn * u;
+    const h = hueAt(Math.atan2(xB, xA), xc, Math.atan2(toB, toA), yc, u);
     return [mix(xL, toL, u) * w, C * Math.cos(h) * w, C * Math.sin(h) * w, w];
 }
 export function color(ofOrOpts, maybe) {
@@ -149,8 +146,11 @@ export function color(ofOrOpts, maybe) {
         (stock?.op === 'sum' && stock.turn === undefined && of.bounds === undefined)) {
         const channel = vec(4, sum());
         channel.kind = `color(sum${space})`;
-        // A lane interpolates a stock channel straight across, so a lerp of its own takes it off them.
-        return round ? { ...channel, lerp: lerpLch } : channel;
+        if (!round)
+            return channel;
+        const turning = { ...channel, lerp: lerpLch };
+        vouch(turning, { op: 'own', axes: 4, folds: 'sum' });
+        return turning;
     }
     if (of.kind === 'last') {
         const channel = {
@@ -159,15 +159,14 @@ export function color(ofOrOpts, maybe) {
             lerp: round ? lerpLch : vec(4, sum()).lerp,
         };
         widen(channel, 4);
-        if (!round)
-            vouch(channel, { op: 'last', axes: 4 });
+        vouch(channel, { op: 'last', axes: 4 });
         return channel;
     }
     throw new Error(`color takes sum() to average or last() to replace, not ${of.kind ?? 'a channel of its own'}`);
 }
 /**
- * 0xrrggbb as a `color` value: OKLab `[L, a, b]` at full coverage. Convert keyframe stops once
- * when authoring them, and call it outside the hot path in an `fn` patch.
+ * Converts 0xrrggbb to a `color` value. The value is OKLab `[L, a, b]` at full coverage. Convert
+ * keyframe stops once when authoring them, and call it outside the hot path in an `fn` patch.
  *
  * @category channel
  */
@@ -176,8 +175,9 @@ export function oklab(rgb) {
     return [LAB[0], LAB[1], LAB[2], 1];
 }
 /**
- * A `color` pose as 0xrrggbb: its color divided out of its coverage, the coverage capped at 1
- * and laid over `under` in OKLab, then clipped to sRGB per channel. No coverage gives `under`.
+ * A `color` pose as 0xrrggbb, laid over `under`. Its color is divided out of its coverage, the
+ * coverage capped at 1 and laid over `under` in OKLab, then clipped to sRGB per channel. No
+ * coverage gives `under`.
  *
  * @category channel
  */
@@ -195,8 +195,8 @@ export function toHex(pose, under = 0x000000) {
     return fromLab(mix(LAB[0], L, w), mix(LAB[1], A, w), mix(LAB[2], B, w));
 }
 /**
- * A `color` pose as a CSS `oklab()` color with its coverage, capped at 1, as the alpha, for a
- * host that lets the browser lay it over what is under it.
+ * A `color` pose as a CSS `oklab()` color, its coverage as the alpha. The coverage is capped at 1.
+ * For a host that lets the browser lay it over what is under it.
  *
  * @category channel
  */

package/dist/columns.js

@@ -22,6 +22,9 @@ export function pullRun(lanes, slots, list, was, since, from, columns, now, vers
     const frame = lanes.frameProbes;
     const subjects = lanes.subjects;
     const unlinked = lanes.unlinked;
+    const holds = lanes.holds;
+    // Nothing in `pullRun` makes a subject owe a voice, so one with nobody owing need not ask.
+    const owing = lanes.owed.any();
     const current = since === Number.POSITIVE_INFINITY;
     if (columns !== lanes.queuedFor) {
         flush(lanes);
@@ -47,14 +50,15 @@ export function pullRun(lanes, slots, list, was, since, from, columns, now, vers
             per[o + 0 /* Per.FILLED */] >= busy ||
             per[o + 2 /* Per.IDLE */] !== 0 ||
             per[o + 1 /* Per.SEEN */] < wide ||
-            lanes.owes(slot))
+            (owing && lanes.owes(slot)))
             break;
         if (!(per[o + 3 /* Per.LANE_PROBE */] > frame ||
             per[o + 4 /* Per.GENERAL_PROBE */] > frame))
             lanes.distinct++;
         per[o + 3 /* Per.LANE_PROBE */] = ++lanes.probes;
         per[o + 5 /* Per.LANE_FILL */] = fills;
-        subjects[slot] = subject;
+        if (holds)
+            subjects[slot] = subject;
         if (slot !== first + (n - start)) {
             if (first >= 0) {
                 qSlots[k] = first;
@@ -73,7 +77,7 @@ export function pullRun(lanes, slots, list, was, since, from, columns, now, vers
         k++;
     }
     lanes.queued = k;
-    if (n > from)
+    if (n > from && holds)
         lanes.holding = true;
     return n;
 }

package/dist/contribution.d.ts

@@ -0,0 +1,30 @@
+import type { Mixer } from './mixer.js';
+import type { Subject } from './subject.js';
+import { type Voice } from './voice.js';
+/**
+ * One live voice's delta for one subject this frame, through its record for the subject, or null
+ * when it does not reach. Its weight is left in `w`.
+ */
+export declare function contribution<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, now: number, held: Subject<unknown>): Record<string, unknown> | null;
+/** Reads a keys voice's stops at `held.phase` into the subject's delta, through the voice's scratch. */
+export declare function keyed<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, held: Subject<unknown>): Record<string, unknown>;
+/**
+ * Runs `step` once per whole interval between where this subject last stopped and now, on a grid
+ * counted from when its delay ran out, and leaves the remainder for the next sample. Counting
+ * rather than adding keeps the grid where it is however many samples it is reached through.
+ */
+export declare function tick<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, held: Subject<unknown>, tick: number, to: number): void;
+/**
+ * Stop 0 for a retargeting voice: the subject's pose in the frame before this voice contributes.
+ * With no such frame on record — a voice cued before the subject was ever probed, or a host that
+ * samples into its own object — it is this frame's pose with every other voice folded in.
+ */
+export declare function baseFor<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I): Record<string, unknown>;
+/**
+ * How fast each numeric channel this voice writes was moving, from the subject's last two probed
+ * poses, in units per ms. Undefined with fewer than two on record, which starts the voice at rest.
+ */
+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;
+/** `contribution`, or for a dry fold a subject already probed this frame, without advancing it. */
+export declare function read<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, now: number, dry: boolean, held: Subject<unknown>): Record<string, unknown> | null;