@msb235/blits 0.6.0 → 0.7.1

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';
 /**

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 { frozenAt, SPARSE } from './lane.js';
-import { closed } from './motion.js';
 import { move } from './sample.js';
 /**
  * Whether a laned voice belongs in a crowd: one naming a single subject, which shares nothing
@@ -209,6 +209,8 @@ 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];
@@ -307,6 +309,7 @@ function copyVoice(c, p) {
         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;

package/dist/cue.js

@@ -1,15 +1,59 @@
 import { checkHits } from './book.js';
 import { changed, index } from './chain.js';
 import { schedule } from './due.js';
+import { VoiceHandle } from './handle.js';
 import { started } from './held.js';
 import { handle } from './hosts.js';
 import { motionOf } from './motion.js';
-import { adopt, ownerReading } from './owner.js';
+import { adopt, ownerPatch, ownerReading } from './owner.js';
 import { durationOf } from './patch.js';
 import { checkPlacement, localNow, mixAt, pin, place } from './place.js';
+import { scoredAdd } from './scored.js';
+import { checkChild, refit } from './spans.js';
 import { motionOwner } from './strays.js';
+import { record } from './tape.js';
 import { Voice } from './voice.js';
 export function cue(mix, spec) {
+    const patch = spec.patch;
+    playable(mix, spec);
+    if (spec.from === 'current' && patch.form !== 'keys')
+        throw new Error("blits: from: 'current' needs a keys patch");
+    if (spec.subjects !== undefined && spec.target !== undefined)
+        throw new Error('blits: a voice takes target or subjects, not both');
+    const anchor = spec.anchor;
+    const owner = spec.owner === undefined ? null : ownerOf(mix, spec.owner);
+    if (anchor)
+        checkPlacement(mix, spec, anchor, owner);
+    if (spec.hits !== undefined)
+        checkHits(spec.hits, durationOf(patch));
+    const anchored = anchor !== undefined && (anchor.start !== undefined || anchor.in !== undefined);
+    // A voice an owner holds is placed on the owner's clock: ms from when it starts.
+    const local = owner === null ? mix.now : ownerReading(owner, mix.now);
+    const start = anchored || owner?.fitting
+        ? Number.POSITIVE_INFINITY
+        : owner !== null
+            ? (spec.start ?? (local > 0 ? local : 0))
+            : spec.start !== undefined
+                ? mixAt(mix, spec.start - mix.offset)
+                : Number.isNaN(mix.now)
+                    ? 0
+                    : mix.now;
+    const voice = new Voice(mix.nextId++, spec, patch, spec.fade ?? {}, local, start, mix.slotOf, mix.channels, mix.opts.host, mix.send, owner);
+    if (patch === ownerPatch && mix.fitting !== null)
+        voice.fitting = mix.fitting;
+    if (owner?.fitting)
+        checkChild(spec, voice);
+    if (mix.pace !== null && owner === null && spec.start !== undefined && voice.state === 'pending')
+        voice.pinned = spec.start - mix.offset;
+    enter(mix, voice);
+    const h = handle(mix, voice);
+    voice.handle = h;
+    // By its handle, so a voice a history store paged out and a seek revived is the one cued again.
+    record(mix, 'cue', () => recue(mix, VoiceHandle.voiceOf(h) ?? lost(h)));
+    return h;
+}
+/** Refuses a spec whose patch the mix cannot play, or whose state its history cannot keep. */
+export function playable(mix, spec) {
     const patch = spec.patch;
     for (const channel of patch.writes) {
         if (!(channel in mix.kit))
@@ -34,29 +78,30 @@ export function cue(mix, spec) {
             if (typeof host !== 'object' || host === null || !(field in host))
                 throw new Error(`blits: the patch reads host.${field}, which this mix's host lacks`);
     }
-    if (spec.from === 'current' && patch.form !== 'keys')
-        throw new Error("blits: from: 'current' needs a keys patch");
-    if (spec.subjects !== undefined && spec.target !== undefined)
-        throw new Error('blits: a voice takes target or subjects, not both');
+    if (mix.transport.pager !== null &&
+        (patch.state !== undefined || patch.step !== undefined) &&
+        (patch.pack === undefined || patch.unpack === undefined))
+        throw new Error("blits: this mix's history has a store, which keeps a stateful patch's state as data; give the patch pack and unpack");
+    if (spec.as !== undefined && mix.transport.pager !== null && !mix.opts.history?.revive)
+        throw new Error('blits: a voice cued with as needs history.revive to rebuild it from');
+}
+/** A voice parked by a seek, cued again as the mix plays past its cue, on the handle it had. */
+function recue(mix, voice) {
+    const owner = voice.owner;
+    if ((owner === null ? mix.now : ownerReading(owner, mix.now)) >= voice.start)
+        voice.state = 'live';
+    enter(mix, voice);
+}
+function lost(h) {
+    throw new Error(`blits: voice ${h.id} is paged out, and the seek that plays its cue again did not load it`);
+}
+/** Puts a voice just made, or parked by a seek, into the mix. */
+function enter(mix, voice) {
+    const spec = voice.spec;
+    const owner = voice.owner;
     const anchor = spec.anchor;
-    const owner = spec.owner === undefined ? null : ownerOf(mix, spec.owner);
-    if (anchor)
-        checkPlacement(mix, spec, anchor, owner);
-    if (spec.hits !== undefined)
-        checkHits(spec.hits, durationOf(patch));
     const anchored = anchor !== undefined && (anchor.start !== undefined || anchor.in !== undefined);
-    // A voice an owner holds is placed on the owner's clock: ms from when it starts.
-    const local = owner === null ? mix.now : ownerReading(owner, mix.now);
-    const start = anchored
-        ? Number.POSITIVE_INFINITY
-        : owner !== null
-            ? (spec.start ?? (local > 0 ? local : 0))
-            : spec.start !== undefined
-                ? mixAt(mix, spec.start - mix.offset)
-                : Number.isNaN(mix.now)
-                    ? 0
-                    : mix.now;
-    const voice = new Voice(mix.nextId++, spec, patch, spec.fade ?? {}, local, start, mix.slotOf, mix.channels, mix.opts.host, mix.send, owner);
+    const motion = voice.motion;
     if (owner !== null)
         adopt(owner, voice);
     if (voice.holding !== null) {
@@ -68,15 +113,22 @@ export function cue(mix, spec) {
         voice.opened = mix.now;
     }
     voice.placing = anchored;
-    if (mix.pace !== null && owner === null && spec.start !== undefined && voice.state === 'pending')
-        pin(mix, voice, spec.start - mix.offset);
+    // A start the host gave by its own clock, where the mix's rate puts it.
+    if (!Number.isNaN(voice.pinned) && voice.state === 'pending')
+        pin(mix, voice, voice.pinned);
     if (motion !== undefined) {
         mix.playing.set(motion, (mix.playing.get(motion) ?? 0) + 1);
         mix.owner ??= motionOwner(new WeakRef(mix));
         motion.owner = mix.owner;
         motion.ownerId = voice.id;
     }
-    mix.cued.push(voice);
+    // In id order, which a voice cued again after later ones keeps by going in at its place.
+    const cued = mix.cued;
+    let i = cued.length;
+    while (i > 0 && cued[i - 1].id > voice.id)
+        i--;
+    cued.splice(i, 0, voice);
+    scoredAdd(mix, voice);
     index(mix, voice);
     changed(mix, voice);
     mix.stir();
@@ -95,14 +147,15 @@ export function cue(mix, spec) {
             changed(mix, voice);
         }
     }
+    if (owner?.fitting)
+        refit(mix, owner);
     // After placing, so the controls it starts with are where its anchors put it at the cue.
     if (mix.opts.history) {
         voice.log = [];
         voice.note(Number.NEGATIVE_INFINITY);
+        voice.first ??= voice.log[0];
     }
     schedule(mix, voice);
-    voice.handle = handle(mix, voice);
-    return voice.handle;
 }
 /** The owner a handle names, refused where it is not one of this mix's or has left. */
 function ownerOf(mix, handle) {

package/dist/due.js

@@ -15,6 +15,9 @@ function dueOf(mix, voice) {
     if (voice.parts !== null)
         for (const r of voice.parts.values())
             due = Math.min(due, r.at + r.over);
+    const back = voice.back;
+    if (back !== null)
+        due = Math.min(due, back.at + (1 - back.from) * back.over);
     if (voice.state === 'pending')
         return Math.min(due, Number.isNaN(voice.start) ? due : voice.start);
     if (voice.state === 'fading') {