@msb235/blits 0.5.0 → 0.7.0

package/dist/clock.d.ts

@@ -9,17 +9,24 @@ export declare function passesOf(loop: boolean | number | undefined): number;
 export declare function phaseAt(elapsed: number, duration: number, passes: number): number;
 /** The pass `elapsed` voice ms falls in, held at the last once they are done. */
 export declare function passAt(elapsed: number, duration: number, passes: number): number;
-/** A voice's own fade this frame, 0..1: in from `since` over `fadeIn`, and out along its ramp. */
+/**
+ * A voice's own fade this frame, 0..1: in from `since` over `fadeIn`, out along its ramp, and back
+ * up the same curve where a fade out was turned around.
+ */
 export declare function envelope(fadeIn: number, out: {
     at: number;
     over: number;
     rest: boolean;
-} | null, ease: Curve | undefined, reduced: boolean, now: number, since: number): number;
+} | null, ease: Curve | undefined, reduced: boolean, now: number, since: number, back?: {
+    from: number;
+    at: number;
+    over: number;
+} | null): number;
 /**
- * A subject's voice time `raw` once the voice's holds apply: 0 before it starts if it holds before,
- * else NaN, where it shows nothing; `span` once its passes end if it holds after.
+ * A subject's voice time `raw` once the voice's freezes apply: 0 before it starts if it freezes
+ * before, else NaN, where it shows nothing; `span` once its passes end if it freezes after.
  */
-export declare function heldTime(raw: number, before: boolean, after: boolean, span: number): number;
+export declare function frozenTime(raw: number, before: boolean, after: boolean, span: number): number;
 /** A weight held to 0..1. */
 export declare function clampWeight(raw: number): number;
 /**

package/dist/clock.js

@@ -21,14 +21,22 @@ export function passAt(elapsed, duration, passes) {
         return 0;
     return over(elapsed, duration, passes) ? passes - 1 : Math.floor(elapsed / duration);
 }
-/** A voice's own fade this frame, 0..1: in from `since` over `fadeIn`, and out along its ramp. */
-export function envelope(fadeIn, out, ease, reduced, now, since) {
+/**
+ * A voice's own fade this frame, 0..1: in from `since` over `fadeIn`, out along its ramp, and back
+ * up the same curve where a fade out was turned around.
+ */
+export function envelope(fadeIn, out, ease, reduced, now, since, back = null) {
     let w = 1;
     if (fadeIn > 0 && !reduced) {
         const u = (now - since) / fadeIn;
         if (u < 1)
             w *= ease ? ease(Math.max(0, u)) : Math.max(0, u);
     }
+    if (back && !reduced) {
+        const u = back.from + (now - back.at) / back.over;
+        if (u < 1)
+            w *= ease ? ease(Math.max(0, u)) : Math.max(0, u);
+    }
     if (out && !out.rest) {
         if (reduced || out.over === 0)
             return 0;
@@ -39,10 +47,10 @@ export function envelope(fadeIn, out, ease, reduced, now, since) {
     return w;
 }
 /**
- * A subject's voice time `raw` once the voice's holds apply: 0 before it starts if it holds before,
- * else NaN, where it shows nothing; `span` once its passes end if it holds after.
+ * A subject's voice time `raw` once the voice's freezes apply: 0 before it starts if it freezes
+ * before, else NaN, where it shows nothing; `span` once its passes end if it freezes after.
  */
-export function heldTime(raw, before, after, span) {
+export function frozenTime(raw, before, after, span) {
     if (raw < 0)
         return before ? 0 : Number.NaN;
     return after && raw > span ? span : raw;

package/dist/closed.d.ts

@@ -0,0 +1,15 @@
+import type { Curve } from './easing.js';
+/** The closed forms a motion patch's law picks between, by its first number. */
+export declare const UNDER = 0;
+export declare const CRITICAL = 1;
+export declare const OVER = 2;
+export declare const COAST = 3;
+export declare const EASED = 4;
+/**
+ * A stretch `t` voice ms into it, 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
+ * `[form, settle, k1, k2, k3]`, the head of a patch's buffer or a copy of it) picks between. A tween reads `ease` and
+ * `ms`, the stretch's length, dividing in milliseconds so a boundary lands exactly; every other
+ * form ignores them.
+ */
+export declare function closed(law: Float64Array, ease: Curve | undefined, n: number, at: number, ms: number, x0: ArrayLike<number>, x: number, v0: ArrayLike<number>, v: number, to: ArrayLike<number>, g: number, t: number, xo: Float64Array, vo: Float64Array): boolean;

package/dist/closed.js

@@ -0,0 +1,144 @@
+import { eased, progress } from './tweened.js';
+/** The closed forms a motion patch's law picks between, by its first number. */
+export const UNDER = 0;
+export const CRITICAL = 1;
+export const OVER = 2;
+export const COAST = 3;
+export const EASED = 4;
+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
+ * a sample works them out once rather than once per axis.
+ */
+const timed = { e: 0, e2: 0, cos: 0, sin: 0 };
+/** The law and time `timed` was last worked out for: subjects released together share them. */
+const prepared = {
+    form: Number.NaN,
+    k1: Number.NaN,
+    k2: Number.NaN,
+    k3: Number.NaN,
+    t: Number.NaN,
+};
+/** `t` seconds after release, the terms every axis shares, into `timed`. */
+function prepare(law, t) {
+    const form = law[0];
+    const k1 = law[2];
+    const k2 = law[3];
+    const k3 = law[4];
+    const p = prepared;
+    if (Object.is(t, p.t) && form === p.form && k1 === p.k1 && k2 === p.k2 && k3 === p.k3)
+        return;
+    p.form = form;
+    p.k1 = k1;
+    p.k2 = k2;
+    p.k3 = k3;
+    p.t = t;
+    switch (form) {
+        case UNDER: {
+            const zeta = law[2];
+            const w0 = law[3];
+            const wd = law[4];
+            timed.e = Math.exp(-zeta * w0 * t);
+            timed.cos = Math.cos(wd * t);
+            timed.sin = Math.sin(wd * t);
+            return;
+        }
+        case CRITICAL: {
+            const w0 = law[3];
+            timed.e = Math.exp(-w0 * t);
+            return;
+        }
+        case OVER: {
+            timed.e = Math.exp(law[2] * t);
+            timed.e2 = Math.exp(law[3] * t);
+            return;
+        }
+        default:
+            timed.e = Math.exp(-t / law[2]);
+    }
+}
+/**
+ * One axis, `t` seconds after release, `y0` from where it heads and moving at `v0`, into `solved`,
+ * with `timed` prepared for `t`. Each form is a function of its own, small enough for V8 to inline
+ * wherever `closed` is: as one switch over all four it was not, and spring fills ran at two speeds.
+ */
+function solve(law, y0, v0, t) {
+    const form = law[0];
+    if (form === UNDER)
+        solveUnder(law, y0, v0);
+    else if (form === CRITICAL)
+        solveCritical(law, y0, v0, t);
+    else if (form === OVER)
+        solveOver(law, y0, v0);
+    else
+        solveGlide(law, y0);
+}
+function solveUnder(law, y0, v0) {
+    const zeta = law[2];
+    const w0 = law[3];
+    const wd = law[4];
+    const e = timed.e;
+    const b = (v0 + zeta * w0 * y0) / wd;
+    const cos = timed.cos;
+    const sin = timed.sin;
+    const y = e * (y0 * cos + b * sin);
+    solved.y = y;
+    solved.dy = -zeta * w0 * y + e * wd * (b * cos - y0 * sin);
+}
+function solveCritical(law, y0, v0, t) {
+    const w0 = law[3];
+    const e = timed.e;
+    const b = v0 + w0 * y0;
+    const y = e * (y0 + b * t);
+    solved.y = y;
+    solved.dy = e * b - w0 * y;
+}
+function solveOver(law, y0, v0) {
+    const r1 = law[2];
+    const r2 = law[3];
+    const a = (v0 - r2 * y0) / (r1 - r2);
+    const b = y0 - a;
+    const e1 = timed.e;
+    const e2 = timed.e2;
+    solved.y = a * e1 + b * e2;
+    solved.dy = a * r1 * e1 + b * r2 * e2;
+}
+/**
+ * Released at x moving at v, a glide comes to rest at x + v·τ; y is the distance still to go,
+ * which friction closes as e^(−t/τ), and its derivative at release is v again.
+ */
+function solveGlide(law, y0) {
+    const tau = law[2];
+    const e = timed.e;
+    solved.y = y0 * e;
+    solved.dy = (-y0 / tau) * e;
+}
+/**
+ * A stretch `t` voice ms into it, 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
+ * `[form, settle, k1, k2, k3]`, the head of a patch's buffer or a copy of it) picks between. A tween reads `ease` and
+ * `ms`, the stretch's length, dividing in milliseconds so a boundary lands exactly; every other
+ * form ignores them.
+ */
+export function closed(law, ease, n, at, ms, x0, x, v0, v, to, g, t, xo, vo) {
+    if (law[0] === EASED)
+        return eased(ease, n, progress(t, at, ms), ms, x0, x, to, g, xo, vo);
+    const dt = Math.max(0, t - at) / 1000;
+    const settle = law[1];
+    let still = settle > 0;
+    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);
+        xo[i] = goal + solved.y;
+        vo[i] = solved.dy;
+        if (Math.abs(solved.y) > settle || Math.abs(solved.dy) > settle)
+            still = false;
+    }
+    if (still)
+        for (let i = 0; i < n; i++) {
+            xo[i] = to[g + i];
+            vo[i] = 0;
+        }
+    return still;
+}

package/dist/color.d.ts

@@ -0,0 +1,61 @@
+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.
+ *
+ * @category channel
+ */
+export declare function mixHex(a: number, b: number, u: number): number;
+/**
+ * Color, as 0xrrggbb, blended in OKLCH as `mixHex` does, or with `space: 'srgb'` channel by
+ * channel in sRGB, which keeps a port's arithmetic identical to a host that blended that way.
+ *
+ * @deprecated Use `color(last(), { lerp: 'oklch' })`, which replaces as this does, and `toHex` at
+ * write. A packed color has no arithmetic to stack with; `color()` averages instead.
+ * @category channel
+ */
+export declare function hex(opts?: {
+    space?: 'oklch' | 'srgb';
+}): Channel<number>;
+/**
+ * How a `color` channel interpolates two colors: straight across OKLab, or in OKLCH with hue the
+ * short way round, as `mixHex` does.
+ *
+ * @category channel
+ */
+export interface ColorOptions {
+    lerp?: 'oklab' | 'oklch';
+}
+/**
+ * Color as OKLab `[L, a, b, coverage]`, its merge rule given as `of`. `color()` averages: voices
+ * stack as a premultiplied sum, so a pose holds `[Σw·L, Σw·a, Σw·b, Σw]` and runs on lanes;
+ * `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.
+ *
+ * @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.
+ *
+ * @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`.
+ *
+ * @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.
+ *
+ * @category channel
+ */
+export declare function css(pose: ArrayLike<number>): string;

package/dist/color.js

@@ -0,0 +1,229 @@
+import { last, lerpNumber, numericOf, sum, vec, vouch, widen } from './channels.js';
+const mix = lerpNumber;
+const LINEAR = Array.from({ length: 256 }, (_, c) => {
+    const v = c / 255;
+    return v <= 0.04045 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4;
+});
+/** The linear value halfway between byte c - 1 and c: at or above it, a value rounds to c. */
+const ROUNDS_UP = LINEAR.map((_, c) => {
+    const v = (c - 0.5) / 255;
+    return v <= 0.04045 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4;
+});
+/** The byte each 1/4096 of linear light starts at; a bin holds at most one rounding point. */
+const BINS = 4096;
+const FIRST = Array.from({ length: BINS + 1 }, (_, i) => {
+    let c = 0;
+    while (c < 255 && i / BINS >= ROUNDS_UP[c + 1])
+        c++;
+    return c;
+});
+const toByte = (v) => {
+    if (v <= 0)
+        return 0;
+    if (v >= 1)
+        return 255;
+    const c = FIRST[(v * BINS) | 0];
+    return c < 255 && v >= ROUNDS_UP[c + 1] ? c + 1 : c;
+};
+/** Below this chroma a color is gray and its hue is noise, so the lerp takes the other end's. */
+const GRAY = 1e-4;
+/**
+ * Colors already turned into OKLCH, direct-mapped on a byte of their hash: a mix reads the same
+ * few keyframe colors every frame, and the table stays 256 colors however many it meets.
+ */
+const SLOTS = 256;
+const slotColor = new Int32Array(SLOTS).fill(-1);
+const slotL = new Float64Array(SLOTS);
+const slotC = new Float64Array(SLOTS);
+const slotH = new Float64Array(SLOTS);
+/** The last `lab` conversion's result, so the hot path allocates nothing. */
+const LAB = [0, 0, 0];
+/** 0xrrggbb to OKLab `[L, a, b]` in `LAB`; Björn Ottosson's OKLab matrices. */
+function lab(rgb) {
+    const r = LINEAR[(rgb >> 16) & 0xff];
+    const g = LINEAR[(rgb >> 8) & 0xff];
+    const b = LINEAR[rgb & 0xff];
+    const l = Math.cbrt(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b);
+    const m = Math.cbrt(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b);
+    const s = Math.cbrt(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b);
+    LAB[0] = 0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s;
+    LAB[1] = 1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s;
+    LAB[2] = 0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s;
+}
+/** OKLab to 0xrrggbb, clipping each channel to sRGB's gamut. */
+function fromLab(L, A, B) {
+    const l_ = L + 0.3963377774 * A + 0.2158037573 * B;
+    const m_ = L - 0.1055613458 * A - 0.0638541728 * B;
+    const s_ = L - 0.0894841775 * A - 1.291485548 * B;
+    const l = l_ * l_ * l_;
+    const m = m_ * m_ * m_;
+    const s = s_ * s_ * s_;
+    const r = 4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s;
+    const g = -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s;
+    const b = -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s;
+    return (toByte(r) << 16) | (toByte(g) << 8) | toByte(b);
+}
+/** 0xrrggbb to its slot, filled with [L, C, h], h in radians. */
+function oklch(rgb) {
+    const slot = Math.imul(rgb, 0x9e3779b1) >>> 24;
+    if (slotColor[slot] === rgb)
+        return slot;
+    lab(rgb);
+    const A = LAB[1];
+    const B = LAB[2];
+    slotColor[slot] = rgb;
+    slotL[slot] = LAB[0];
+    slotC[slot] = Math.sqrt(A * A + B * B);
+    slotH[slot] = Math.atan2(B, A);
+    return slot;
+}
+/** [L, C, h] to 0xrrggbb, clipping each channel to sRGB's gamut. */
+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.
+ *
+ * @category channel
+ */
+export function mixHex(a, b, u) {
+    if (u === 0 || a === b)
+        return a;
+    if (u === 1)
+        return b;
+    const sa = oklch(a);
+    const al = slotL[sa];
+    const ac = slotC[sa];
+    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];
+    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);
+}
+const clamp255 = (v) => (v < 0 ? 0 : v > 255 ? 255 : Math.round(v));
+/** Each of red, green and blue on its own, as klieg's light channel blends. */
+function mixSrgb(a, b, u) {
+    const ar = (a >> 16) & 0xff;
+    const ag = (a >> 8) & 0xff;
+    const ab = a & 0xff;
+    const br = (b >> 16) & 0xff;
+    const bg = (b >> 8) & 0xff;
+    const bb = b & 0xff;
+    return ((clamp255(mix(ar, br, u)) << 16) | (clamp255(mix(ag, bg, u)) << 8) | clamp255(mix(ab, bb, u)));
+}
+/**
+ * Color, as 0xrrggbb, blended in OKLCH as `mixHex` does, or with `space: 'srgb'` channel by
+ * channel in sRGB, which keeps a port's arithmetic identical to a host that blended that way.
+ *
+ * @deprecated Use `color(last(), { lerp: 'oklch' })`, which replaces as this does, and `toHex` at
+ * write. A packed color has no arithmetic to stack with; `color()` averages instead.
+ * @category channel
+ */
+export function hex(opts) {
+    return { ...last({ lerp: opts?.space === 'srgb' ? mixSrgb : mixHex }), kind: 'hex' };
+}
+/** Two OKLab colors with coverage, interpolated in OKLCH: color by `u`, coverage by `u` alongside. */
+function lerpLch(x, y, u) {
+    const xw = x[3] ?? 0;
+    const yw = y[3] ?? 0;
+    const w = mix(xw, yw, u);
+    // A color with no coverage has none of its own to keep, so the lerp takes the other end's.
+    const ys = yw > 0 ? 1 / yw : 0;
+    const yL = (y[0] ?? 0) * ys;
+    const yA = (y[1] ?? 0) * ys;
+    const yB = (y[2] ?? 0) * ys;
+    const xs = xw > 0 ? 1 / xw : 0;
+    const xL = xw > 0 ? (x[0] ?? 0) * xs : yL;
+    const xA = xw > 0 ? (x[1] ?? 0) * xs : yA;
+    const xB = xw > 0 ? (x[2] ?? 0) * xs : yB;
+    const toL = yw > 0 ? yL : xL;
+    const toA = yw > 0 ? yA : xA;
+    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;
+    return [mix(xL, toL, u) * w, C * Math.cos(h) * w, C * Math.sin(h) * w, w];
+}
+export function color(ofOrOpts, maybe) {
+    const of = ofOrOpts !== undefined && 'merge' in ofOrOpts ? ofOrOpts : undefined;
+    const opts = of === undefined ? ofOrOpts : maybe;
+    const round = opts?.lerp === 'oklch';
+    const space = round ? ', oklch' : '';
+    if (of === undefined || (numericOf(of)?.op === 'sum' && 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 (of.kind === 'last') {
+        const channel = {
+            kind: `color(last${space})`,
+            merge: (_a, b) => b,
+            lerp: round ? lerpLch : vec(4, sum()).lerp,
+        };
+        widen(channel, 4);
+        if (!round)
+            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.
+ *
+ * @category channel
+ */
+export function oklab(rgb) {
+    lab(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`.
+ *
+ * @category channel
+ */
+export function toHex(pose, under = 0x000000) {
+    const w = pose[3] ?? 0;
+    if (!(w > 0))
+        return under;
+    const s = 1 / w;
+    const L = (pose[0] ?? 0) * s;
+    const A = (pose[1] ?? 0) * s;
+    const B = (pose[2] ?? 0) * s;
+    if (w >= 1)
+        return fromLab(L, A, B);
+    lab(under);
+    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.
+ *
+ * @category channel
+ */
+export function css(pose) {
+    const w = pose[3] ?? 0;
+    if (!(w > 0))
+        return 'oklab(0 0 0 / 0)';
+    const s = 1 / w;
+    return `oklab(${(pose[0] ?? 0) * s} ${(pose[1] ?? 0) * s} ${(pose[2] ?? 0) * s} / ${w < 1 ? w : 1})`;
+}

package/dist/columns.js

@@ -16,6 +16,7 @@ export function pullRun(lanes, slots, list, was, heads, from, columns, now, vers
         return from;
     const per = lanes.per;
     const fills = lanes.fills;
+    const busy = lanes.busyFill;
     const wide = lanes.wide;
     const frame = lanes.frameProbes;
     const subjects = lanes.subjects;
@@ -39,7 +40,7 @@ export function pullRun(lanes, slots, list, was, heads, from, columns, now, vers
         const slot = slots[n];
         const o = slot * 6 /* Per.SLOT */;
         if (slot < 0 ||
-            per[o + 0 /* Per.FILLED */] !== fills ||
+            per[o + 0 /* Per.FILLED */] >= busy ||
             per[o + 2 /* Per.IDLE */] !== 0 ||
             per[o + 1 /* Per.SEEN */] < wide ||
             lanes.owes(slot))

package/dist/crowd.d.ts

@@ -2,7 +2,7 @@ import type { Curve } from './easing.js';
 import { KeyRows } from './keyrows.js';
 import { type Laned, type Positions } from './lane.js';
 import type { Lanes } from './lanes.js';
-import { type Motions } from './motion.js';
+import type { Motions } from './motions.js';
 import type { Scratch } from './patch.js';
 import type { Subject, Voice } from './voice.js';
 /**
@@ -31,7 +31,7 @@ export declare const enum Hot {
 }
 /** A crowd row's flags, at `Hot.FLAGS`. */
 export declare const enum Flag {
-    /** The voice is playing: live, held or fading. */
+    /** The voice is playing: live, frozen or fading. */
     PLAYING = 1,
     /** Its weight and clock are `hot`'s: no fade in or out, rate ramp, subject ramp or kept state. */
     FAST = 2,
@@ -47,8 +47,8 @@ export declare const enum Flag {
     VOICE = 64,
     /** The row's voice is a motion voice; otherwise its patch is keys or a stateless fn. */
     MOTION = 128,
-    /** The voice holds before or after, so its clock is read from the voice. */
-    HOLDS = 256,
+    /** The voice freezes before or after, so its clock is read from the voice. */
+    FREEZES = 256,
     /** A keys row whose stops `keys` holds, at `Hot.AT`, with its duration at `Hot.X0` and passes at `Hot.MS`. */
     FLAT = 512,
     /** The row's patch is a tween. */

package/dist/crowd.js

@@ -1,8 +1,8 @@
 import { bareRows, clock, unbare } from './bare.js';
 import { clampWeight, passAt, phaseAt, weighed } from './clock.js';
+import { closed } from './closed.js';
 import { KeyRows } from './keyrows.js';
-import { held, SPARSE } from './lane.js';
-import { closed } from './motion.js';
+import { frozenAt, SPARSE } from './lane.js';
 import { move } from './sample.js';
 /**
  * Whether a laned voice belongs in a crowd: one naming a single subject, which shares nothing
@@ -209,13 +209,15 @@ function rows(lanes, c, first, id) {
         const q = slot * 6 /* Per.SLOT */;
         if (per[q + 5 /* Per.LANE_FILL */] === fills - 1)
             data[o + 3 /* Row.PROBED */] = data[o + 2 /* Row.WEIGHT */];
+        if (lanes.lately >= 0 && lanes.unread(slot))
+            continue;
         const delay = data[o + 0 /* Row.DELAY */];
         const fast = (f & 2 /* Flag.FAST */) !== 0;
         const voice = c.voices[p];
         const elapsedNow = fast ? clock(hot, h, now) : voice.elapsedAt(now);
         let elapsed = elapsedNow - delay;
-        if ((f & 256 /* Flag.HOLDS */) !== 0)
-            elapsed = held(voice, elapsed);
+        if ((f & 256 /* Flag.FREEZES */) !== 0)
+            elapsed = frozenAt(voice, elapsed);
         if (!(elapsed >= 0)) {
             data[o + 2 /* Row.WEIGHT */] = 0;
             continue;
@@ -298,15 +300,16 @@ export function row(c, p, voice, slot, elapsed, delay, w) {
 function copyVoice(c, p) {
     const v = c.voices[p];
     const h = p * c.stride;
-    let f = c.hot[h + 0 /* Hot.FLAGS */] & ~(64 /* Flag.VOICE */ | 1 /* Flag.PLAYING */ | 2 /* Flag.FAST */ | 256 /* Flag.HOLDS */);
-    if (v.state === 'live' || v.state === 'held' || v.state === 'fading')
+    let f = c.hot[h + 0 /* Hot.FLAGS */] & ~(64 /* Flag.VOICE */ | 1 /* Flag.PLAYING */ | 2 /* Flag.FAST */ | 256 /* Flag.FREEZES */);
+    if (v.state === 'live' || v.state === 'frozen' || v.state === 'fading')
         f |= 1 /* Flag.PLAYING */;
-    if (v.holdsBefore || v.holdsAfter)
-        f |= 256 /* Flag.HOLDS */;
+    if (v.freezesBefore || v.freezesAfter)
+        f |= 256 /* Flag.FREEZES */;
     if (v.ramp === null &&
         v.owner === null &&
         !((v.fade.in ?? 0) > 0) &&
         v.out === null &&
+        v.back === null &&
         v.parts === null &&
         !v.keeping &&
         typeof v.spec.weight !== 'function')

package/dist/cue.d.ts

@@ -1,3 +1,5 @@
 import type { Mixer } from './mixer.js';
 import type { Handle, VoiceSpec } from './types.js';
 export declare function cue<I, O>(mix: Mixer<I, O>, spec: VoiceSpec<I, O>): Handle<I>;
+/** Refuses a spec whose patch the mix cannot play, or whose state its history cannot keep. */
+export declare function playable<I, O>(mix: Mixer<I, O>, spec: VoiceSpec<I, O>): void;