@msb235/blits 0.15.0 → 0.16.0

package/CHANGELOG.md

@@ -4,6 +4,85 @@ This package follows [semver](https://semver.org). Below 1.0.0, a breaking chang
 version and everything else the patch. Each release lists its changes as **Breaking**, **Added** and
 **Fixed**, and the release workflow refuses a tag with no section here.
 
+## 0.16.0
+
+### Added
+
+- `ink()`, a color channel for colors that stand for a meaning (a status, a level, a team), beside
+  `color()` for colors as the real world shows them. It takes the same `oklab()` values. It travels
+  round the hue the short way, and overlapping voices blend round the hue too: the pose holds
+  `[Σw·L, Σw·a, Σw·b, Σw·C, Σw]` and shows the hue of `Σw·(a, b)` at the average chroma, so red and
+  blue at equal weight show a vivid purple rather than the grayed one `color()` shows. Near-opposite
+  hues swing round the wheel as their weights cross. `ink(last())` replaces, traveling round the
+  hue, and holds four numbers. `toHex` and `css` read a pose of either length. Both run on lanes.
+
+### Changed
+
+- A `tween`, `spring` or `glide` on an `ink`, or on the deprecated `color({ lerp: 'oklch' })`,
+  goes round the hue rather than straight across each OKLab axis through gray. A tween reads as the
+  channel's lerp along its easing; a spring and a glide are solved in lightness, chroma and hue
+  with coverage alongside, so velocity carries through a retarget and the path bends rather than
+  starting over. What the patch takes and reports stays premultiplied OKLab, four numbers. A glide
+  with `bounds` on such a channel is refused at `cue`. Lanes read it as the general path does, to
+  the bit; such a voice on one subject no longer joins a crowd. `color()` is unchanged.
+
+- Under `history`, turning an owner back (a rate below 0) brings back the children that already
+  left, so playback reverses completely. A child an owner holds no longer leaves when its passes
+  run out: it fades as before, then stays with its owner, `live` and showing nothing, until the
+  owner leaves, and comes back, climbing over its `fade.out`, once its clock is back in its
+  passes. Its `done` now resolves when its owner leaves rather than at its own end. The owner
+  leaves when it did before, and without `history` nothing changes.
+
+### Deprecated
+
+- `color({ lerp })`: `lerp: 'oklch'` is `ink()`, which also blends overlapping voices round the
+  hue, and `lerp: 'oklab'` is `color()`. It keeps its old behavior for this release and warns once.
+  The playground loads compositions saved with it.
+
+## 0.15.1
+
+### Added
+
+- `mix.trace(from, to, { grid })` reads the mix over a window of mix time without moving it, and
+  `trace.of(subject, channel)` gives a channel of one number as a `Run`: points joined by straight
+  lines, two points at one time for a jump, and `exact` where the lines are the mix's own values
+  throughout. Where every voice feeding the channel is a `keys` voice of known shape (plain number
+  stops eased `linear`, a number weight, a steady rate, no fade under way), the points are its own
+  breakpoints; elsewhere the run is read every `grid` ms, default 5. One trace shares its reads
+  across subjects. `Run`, `Trace`, `TraceOptions` and `NumberChannel` are exported.
+
+### Changed
+
+- A voice cued with `subjects` asks `stagger` for each of them at `cue`, not on first sight, and a
+  finite loop ends once its latest-staggered subject is done whether or not the host has read that
+  subject yet. A read ahead now sees the same end as the live mix. A voice reaching its subjects by
+  `target` still ends by the subjects it has met.
+
+### Fixed
+
+- One-subject tween voices cost about a fifth less a frame once they have landed: a fill folds a
+  landed tween's end as it stands, without reading its clock or easing it, until its voice, its
+  stretch or its subject's delay changes or the clock reads earlier than when it landed. 10,000 of
+  them read by `pull` (`tweens^`) take 0.235 ms a frame against 0.296, `churn^` 0.301 against
+  0.356 and `turnover^` 0.419 against 0.458 (studio, medians of seven runs of 5,000 frames, each in
+  its own process); one tween voice over 10,000 subjects (`weasel^`) is unchanged.
+- A crowd of one-subject `keys` or `fn` voices applies its voices' freezes in the fill's own loop
+  rather than through a call a row. 10,000 `keys` voices read by `pull` (`keyses^`) take 0.449 ms
+  a frame against 0.479, and allocate 6 kB a frame against 162 (studio, medians of seven runs of
+  1,500 frames, each in its own process); the same voices freezing at both ends (`frozen`,
+  `frozen^`) are unchanged.
+- `pull` over a list whose order has drifted from the order the mix first saw it in, as a list
+  kept dense by swap-remove does, writes rests in a few runs, not one per short stretch of
+  subjects. With one subject leaving and one arriving every frame (`turnover^`), a frame takes
+  0.253 ms against 0.262. Teitou, medians of seven runs of 5,000 frames, each in its own process.
+  Other rows are unchanged.
+- A list kept dense by swap-remove stays in the mix's own order for `pull`: a subject moved into
+  the place a dropped one left takes the number the drop freed, so `pull` reads the list in long
+  runs. `turnover^` takes 0.223 ms a frame against 0.263, close to the 0.210 of `churn^`, which
+  replaces voices without reordering anything (teitou with the node to itself, medians of seven
+  runs). The other rows are unchanged. A mix that keeps history, or has roles or a bound on its
+  lanes, keeps the old order.
+
 ## 0.15.0
 
 ### Breaking

package/README.md

@@ -151,7 +151,7 @@ do yet.
 
 ## Status
 
-v0.15.0, with five consumers. magicsmoke runs every fault on it, wod its wheel, tricks and
+v0.16.0, with five consumers. magicsmoke runs every fault on it, wod its wheel, tricks and
 transitions, weasel its animator's tweens, sherpa its seams, and
 [klieg](https://github.com/orochi235/klieg) composes all three of its systems — letter motion,
 part effects, and the environment a sign is lit by — on a mix each.

package/dist/ahead.js

@@ -1,6 +1,5 @@
 import { ownBlends } from './blend.js';
 import { headOf } from './chain.js';
-import { open, sighted, weightAt } from './everyone.js';
 import { copyHeld, unread } from './history.js';
 import { markOf, voiceMarks } from './marks.js';
 import { Mixer } from './mixer.js';
@@ -39,6 +38,7 @@ export function playAhead(transport, c, copies, t, earlier) {
                 const on = new Mixer(copy.kit, { ...copy.opts, transport: next }, null);
                 on.slot = copy.slot;
                 on.projecting = true;
+                on.share = copy.share;
                 copyAhead(copy, on);
                 const stages = earlier.get(mix);
                 if (stages === undefined)
@@ -196,11 +196,12 @@ export function recordOf(mix, voice, subject) {
     // the subject for the caller to copy from.
     if (voice.sharing) {
         const slot = headOf(mix, subject)?.slot ?? -1;
-        if (!sighted(voice, slot))
+        const share = mix.share;
+        if (!share.sighted(voice, slot))
             return undefined;
         const all = voice.everyone;
-        open(voice, all, slot);
-        all.weight = weightAt(voice, slot);
+        share.open(voice, all, slot);
+        all.weight = share.weightAt(voice, slot);
         return all;
     }
     const held = voice.subjects.get(subject);

package/dist/bare.js

@@ -48,9 +48,15 @@ export function bareRows(lanes, c, p, id) {
             !(per[q + 3 /* Per.LANE_PROBE */] > lately ||
                 per[q + 4 /* Per.GENERAL_PROBE */] > lately))
             break;
-        const elapsed = clock(hot, h, now) - data[o + 0 /* Row.DELAY */];
-        if (!(elapsed >= 0))
-            break;
+        // Every step from `now` to a sample's progress rounds monotonically, so a row seen landed at a
+        // positive rate is landed at any later `now` while it stays ready, and folds its `to` as it is.
+        const landed = ready && now >= hot[h + 8 /* Hot.LANDED */];
+        let elapsed = 0;
+        if (!landed) {
+            elapsed = clock(hot, h, now) - data[o + 0 /* Row.DELAY */];
+            if (!(elapsed >= 0))
+                break;
+        }
         keepProbed(data, o, per, q, fills);
         const w = hot[h + 4 /* Hot.WEIGHT */];
         data[o + 2 /* Row.WEIGHT */] = w;
@@ -60,14 +66,23 @@ export function bareRows(lanes, c, p, id) {
                 c.deltas[p] = null;
             }
             hot[h + 0 /* Hot.FLAGS */] = f | 2048 /* Flag.READY */;
+            hot[h + 8 /* Hot.LANDED */] = Number.POSITIVE_INFINITY;
         }
         if (w <= 0)
             continue;
-        const share = left(c.eases[p], progress(elapsed, hot[h + 8 /* Hot.AT */], hot[h + 9 /* Hot.MS */]));
         const values = ch.values;
         const base = slot * n;
-        const x = h + 10 /* Hot.X0 */;
+        const x = h + 11 /* Hot.X0 */;
         const g = x + 2 * n;
+        if (landed) {
+            for (let a = 0; a < n; a++)
+                values[base + a] = foldNumber(op, values[base + a], hot[g + a], w);
+            continue;
+        }
+        const u = progress(elapsed, hot[h + 9 /* Hot.AT */], hot[h + 10 /* Hot.MS */]);
+        const share = left(c.eases[p], u);
+        if (u >= 1 && hot[h + 3 /* Hot.RATE */] > 0)
+            hot[h + 8 /* Hot.LANDED */] = now;
         for (let a = 0; a < n; a++)
             values[base + a] = foldNumber(op, values[base + a], between(hot[x + a], hot[g + a], share), w);
     }
@@ -87,8 +102,8 @@ export function unbare(c, p) {
     hot[h + 0 /* Hot.FLAGS */] = hot[h + 0 /* Hot.FLAGS */] & ~2048 /* Flag.READY */;
     const n = c.axes;
     const elapsed = clock(hot, h, c.bareNow) - data[o + 0 /* Row.DELAY */];
-    const share = left(c.eases[p], progress(elapsed, hot[h + 8 /* Hot.AT */], hot[h + 9 /* Hot.MS */]));
-    const x = h + 10 /* Hot.X0 */;
+    const share = left(c.eases[p], progress(elapsed, hot[h + 9 /* Hot.AT */], hot[h + 10 /* Hot.MS */]));
+    const x = h + 11 /* Hot.X0 */;
     const g = x + 2 * n;
     for (let a = 0; a < n; a++)
         c.samples[p * n + a] = between(hot[x + a], hot[g + a], share);

package/dist/chain.js

@@ -1,4 +1,3 @@
-import { everyoneOf, sight } from './everyone.js';
 import { record } from './record.js';
 /** The first record of a subject no live voice reaches, so a probe of it still makes one lookup. */
 function stub() {
@@ -98,10 +97,10 @@ export function linkable(voice, subject, slot, guess = null) {
     if (state === 'done' || (state === 'pending' && !voice.freezesBefore))
         return null;
     // A voice sharing one record is in no chain: a fold takes it from `sharers` at its place.
-    if (voice.sharing && everyoneOf(this, voice) !== null) {
+    if (voice.sharing && this.share.everyoneOf(this, voice) !== null) {
         // A projection numbers no subject, and keeps nothing by subject.
         if (slot >= 0)
-            sight(voice, slot, this.lanes.cap);
+            this.share.sight(voice, slot, this.lanes.cap);
         return null;
     }
     const held = this.held(voice, subject, slot, guess);

package/dist/color.d.ts

@@ -8,44 +8,66 @@ import type { Channel } from './types.js';
  */
 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
- * short way round, as `mixHex` does.
+ * What `color` took before `ink` existed: `lerp: 'oklch'` overlaps straight across OKLab and
+ * travels round the hue.
  *
  * @category channel
  */
 export interface ColorOptions {
+    /** @deprecated `'oklch'` is `ink()`, which also blends overlapping voices round the hue; `'oklab'` is `color()`. */
     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.
+ * Whether `channel` travels round the hue, as `ink` does, so a motion patch cued on it moves round
+ * the hue too.
+ */
+export declare function roundsHue(channel: Channel<unknown>): boolean;
+/**
+ * Color as the real world shows it, light, sky, smoke or paint: 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. It travels between two colors, in a motion or a role's handoff, straight across
+ * OKLab, so opposite hues cross through gray. For colors that stand for a meaning, use `ink`.
  *
  * @category channel
  */
 export declare function color(opts?: ColorOptions): Channel<number[]>;
 export declare function color(of: Channel<number> | Channel<unknown>, opts?: ColorOptions): Channel<number[]>;
 /**
- * Converts 0xrrggbb to a `color` value. The value is OKLab `[L, a, b]` at full coverage. Convert
+ * Color standing for a meaning, a status, a level or a team, rather than for a physical
+ * phenomenon: choose it over `color` when the colors are symbols. People picture the midpoint
+ * between red and blue as purple, reached by turning the hue, not as the grayed mix light makes,
+ * and `ink` gives them that. It travels round the hue the short way, in a motion, between keys
+ * and in a role's handoff, and `ink()` blends overlapping voices round the hue too: each voice
+ * sums as `[w·L, w·a, w·b, w·C, w]`, C its chroma, so a pose shows lightness `ΣwL/Σw`, the hue of
+ * `Σw·(a, b)`, which a gray voice pulls on not at all, and chroma `ΣwC/Σw`, so two vivid colors
+ * stay vivid. Near-opposite hues overlapping swing round the wheel as their weights cross, with
+ * no tiebreak, and exactly opposite ones cancel to gray. A patch writes it the `oklab()` values a
+ * `color` takes, and `toHex` and `css` read either. `ink(last())` replaces, traveling round the
+ * hue, and holds the four numbers it was written, since it never sums.
+ *
+ * @category channel
+ */
+export declare function ink(of?: Channel<number> | Channel<unknown>): Channel<number[]>;
+/**
+ * Converts 0xrrggbb to a `color` or `ink` 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, 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`.
+ * A `color` or `ink` 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, 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.
+ * A `color` or `ink` 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

@@ -1,4 +1,6 @@
-import { lerpNumber, numericOf, sum, vec, vouch, widen } from './channels.js';
+import { doubles, lerpNumber, numericOf, sum, vec, vouch, widen } from './channels.js';
+import { HUES, lchPair, shortWay } from './lch.js';
+import { warnOnce } from './warn.js';
 const mix = lerpNumber;
 const LINEAR = Array.from({ length: 256 }, (_, c) => {
     const v = c / 255;
@@ -25,8 +27,6 @@ const toByte = (v) => {
     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.
@@ -104,46 +104,107 @@ export function mixHex(a, b, u) {
 }
 /** 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 from + turn * u;
+    shortWay(ah, ac, bh, bc);
+    return HUES[0] + HUES[1] * u;
 }
+const LERP = {};
+const PAIR = new Float64Array(8);
 /** 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 C = mix(xc, yc, 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];
+    const p = PAIR;
+    lchPair(x, 0, y, 0, p);
+    const w = mix(p[3], p[7], u);
+    const C = mix(p[1], p[5], u);
+    const h = p[2] + HUES[1] * u;
+    return [mix(p[0], p[4], u) * w, C * Math.cos(h) * w, C * Math.sin(h) * w, w];
+}
+/** Below this, an ink pose's summed `(a, b)` has canceled out and shows no hue. */
+const CANCEL = 1e-9;
+/**
+ * A color value, `oklab()`'s four numbers or ink's five, into `out` at `o` as `[L, C, h, w]`, its
+ * coverage divided out. Five numbers show their own chroma, the fourth, at the hue of their `(a, b)`.
+ */
+function lchOf(v, out, o) {
+    const five = v.length > 4;
+    const w = (five ? v[4] : v[3]) ?? 0;
+    const s = w > 0 ? 1 / w : 0;
+    const a = (v[1] ?? 0) * s;
+    const b = (v[2] ?? 0) * s;
+    const r = Math.sqrt(a * a + b * b);
+    out[o] = (v[0] ?? 0) * s;
+    out[o + 1] = !five ? r : r < CANCEL ? 0 : (v[3] ?? 0) * s;
+    out[o + 2] = Math.atan2(b, a);
+    out[o + 3] = w;
+}
+/** A color value as ink's five numbers, `[w·L, w·a, w·b, w·C, w]` times `k`, into `out`. */
+function inked(v, k, out) {
+    const a = v[1] ?? 0;
+    const b = v[2] ?? 0;
+    const five = v.length > 4;
+    out[0] = (v[0] ?? 0) * k;
+    out[1] = a * k;
+    out[2] = b * k;
+    out[3] = (five ? (v[3] ?? 0) : Math.sqrt(a * a + b * b)) * k;
+    out[4] = ((five ? v[4] : v[3]) ?? 0) * k;
+    return out;
+}
+/** Two colors, four numbers or five, interpolated round the hue into ink's five. */
+function lerpInk(x, y, u) {
+    if (u === 0)
+        return inked(x, 1, doubles(5, 0));
+    if (u === 1)
+        return inked(y, 1, doubles(5, 0));
+    const p = PAIR;
+    lchOf(x, p, 0);
+    lchOf(y, p, 4);
+    // A color with no coverage has none of its own to keep, so it takes the other end's.
+    const from = p[3] > 0 ? 0 : 4;
+    const to = p[7] > 0 ? 4 : 0;
+    const xc = p[from + 1];
+    const yc = p[to + 1];
+    shortWay(p[from + 2], xc, p[to + 2], yc);
+    const w = mix(p[3], p[7], u);
+    const Cw = mix(xc, yc, u) * w;
+    const h = HUES[0] + HUES[1] * u;
+    return [
+        mix(p[from], p[to], u) * w,
+        Math.cos(h) * Cw,
+        Math.sin(h) * Cw,
+        Cw,
+        w,
+    ];
+}
+/**
+ * Whether `channel` travels round the hue, as `ink` does, so a motion patch cued on it moves round
+ * the hue too.
+ */
+export function roundsHue(channel) {
+    const lerp = channel.lerp;
+    return lerp === lerpLch || lerp === lerpInk;
+}
+/** Whether `of` asks a color channel to average: absent, or a stock `sum` with no turn or bounds. */
+function averages(of) {
+    if (of === undefined)
+        return true;
+    const stock = numericOf(of);
+    return stock?.op === 'sum' && stock.turn === undefined && of.bounds === undefined;
+}
+const refuse = (name, of) => new Error(`${name} takes sum() to average or last() to replace, not ${of.kind ?? 'a channel of its own'}`);
+/** A `last` color channel, which replaces and travels by `lerp`. */
+function replacing(kind, lerp) {
+    const channel = { kind, merge: (_a, b) => b, lerp };
+    widen(channel, 4);
+    vouch(channel, { op: 'last', axes: 4 });
+    return channel;
 }
 export function color(ofOrOpts, maybe) {
     const of = ofOrOpts !== undefined && 'merge' in ofOrOpts ? ofOrOpts : undefined;
     const opts = of === undefined ? ofOrOpts : maybe;
+    if (opts?.lerp !== undefined)
+        warnOnce(LERP, "color({ lerp }) is deprecated: 'oklch' is ink(), which also blends overlapping voices round the hue, and 'oklab' is color()");
     const round = opts?.lerp === 'oklch';
     const space = round ? ', oklch' : '';
-    const stock = of === undefined ? undefined : numericOf(of);
-    if (of === undefined ||
-        (stock?.op === 'sum' && stock.turn === undefined && of.bounds === undefined)) {
+    if (averages(of)) {
         const channel = vec(4, sum());
         channel.kind = `color(sum${space})`;
         if (!round)
@@ -152,20 +213,59 @@ export function color(ofOrOpts, maybe) {
         vouch(turning, { op: 'own', axes: 4, folds: 'sum' });
         return turning;
     }
-    if (of.kind === 'last') {
-        const channel = {
-            kind: `color(last${space})`,
-            merge: (_a, b) => b,
-            lerp: round ? lerpLch : vec(4, sum()).lerp,
-        };
-        widen(channel, 4);
-        vouch(channel, { op: 'last', axes: 4 });
-        return channel;
+    const own = of;
+    if (own.kind === 'last')
+        return replacing(`color(last${space})`, round ? lerpLch : vec(4, sum()).lerp);
+    throw refuse('color', own);
+}
+/** Where `ink`'s merge and fold widen a contribution, which neither keeps. */
+const WIDE = doubles(5, 0);
+/**
+ * Color standing for a meaning, a status, a level or a team, rather than for a physical
+ * phenomenon: choose it over `color` when the colors are symbols. People picture the midpoint
+ * between red and blue as purple, reached by turning the hue, not as the grayed mix light makes,
+ * and `ink` gives them that. It travels round the hue the short way, in a motion, between keys
+ * and in a role's handoff, and `ink()` blends overlapping voices round the hue too: each voice
+ * sums as `[w·L, w·a, w·b, w·C, w]`, C its chroma, so a pose shows lightness `ΣwL/Σw`, the hue of
+ * `Σw·(a, b)`, which a gray voice pulls on not at all, and chroma `ΣwC/Σw`, so two vivid colors
+ * stay vivid. Near-opposite hues overlapping swing round the wheel as their weights cross, with
+ * no tiebreak, and exactly opposite ones cancel to gray. A patch writes it the `oklab()` values a
+ * `color` takes, and `toHex` and `css` read either. `ink(last())` replaces, traveling round the
+ * hue, and holds the four numbers it was written, since it never sums.
+ *
+ * @category channel
+ */
+export function ink(of) {
+    if (!averages(of)) {
+        const own = of;
+        if (own.kind === 'last')
+            return replacing('ink(last)', lerpLch);
+        throw refuse('ink', own);
     }
-    throw new Error(`color takes sum() to average or last() to replace, not ${of.kind ?? 'a channel of its own'}`);
+    const channel = {
+        kind: 'ink(sum)',
+        rest: doubles(5, 0),
+        merge: (x, y) => {
+            const out = inked(x, 1, doubles(5, 0));
+            const add = inked(y, 1, WIDE);
+            for (let i = 0; i < 5; i++)
+                out[i] = out[i] + add[i];
+            return out;
+        },
+        scale: (v, w) => inked(v, w, doubles(5, 0)),
+        fold: (into, v, w) => {
+            const add = inked(v, w, WIDE);
+            for (let i = 0; i < 5; i++)
+                into[i] = (into[i] ?? 0) + add[i];
+            return into;
+        },
+        lerp: lerpInk,
+    };
+    vouch(channel, { op: 'own', axes: 5 });
+    return channel;
 }
 /**
- * Converts 0xrrggbb to a `color` value. The value is OKLab `[L, a, b]` at full coverage. Convert
+ * Converts 0xrrggbb to a `color` or `ink` 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
@@ -174,36 +274,64 @@ export function oklab(rgb) {
     lab(rgb);
     return [LAB[0], LAB[1], LAB[2], 1];
 }
+/** The color the last `shows` call read, `[L, a, b]` with its coverage divided out. */
+const SHOWN = [0, 0, 0];
+/**
+ * A `color` pose's or an `ink` pose's color into `SHOWN`, returning its coverage. Ink's shows the
+ * hue of its `(a, b)` at the chroma its fourth number holds, and gray where `(a, b)` cancels.
+ */
+function shows(pose) {
+    if (pose.length <= 4) {
+        const w = pose[3] ?? 0;
+        if (!(w > 0))
+            return w;
+        const s = 1 / w;
+        SHOWN[0] = (pose[0] ?? 0) * s;
+        SHOWN[1] = (pose[1] ?? 0) * s;
+        SHOWN[2] = (pose[2] ?? 0) * s;
+        return w;
+    }
+    const w = pose[4] ?? 0;
+    if (!(w > 0))
+        return w;
+    const s = 1 / w;
+    const a = (pose[1] ?? 0) * s;
+    const b = (pose[2] ?? 0) * s;
+    const r = Math.sqrt(a * a + b * b);
+    const k = r < CANCEL ? 0 : ((pose[3] ?? 0) * s) / r;
+    SHOWN[0] = (pose[0] ?? 0) * s;
+    SHOWN[1] = a * k;
+    SHOWN[2] = b * k;
+    return w;
+}
 /**
- * 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`.
+ * A `color` or `ink` 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 function toHex(pose, under = 0x000000) {
-    const w = pose[3] ?? 0;
+    const w = shows(pose);
     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;
+    const L = SHOWN[0];
+    const A = SHOWN[1];
+    const B = SHOWN[2];
     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, 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.
+ * A `color` or `ink` 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
  */
 export function css(pose) {
-    const w = pose[3] ?? 0;
+    const w = shows(pose);
     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})`;
+    return `oklab(${SHOWN[0]} ${SHOWN[1]} ${SHOWN[2]} / ${w < 1 ? w : 1})`;
 }

package/dist/columns.d.ts

@@ -1,15 +1,5 @@
 import type { Lanes } from './lanes.js';
-/** One channel `pull` writes: where in the kit, how many numbers a subject, and its rest. */
-export interface Column {
-    key: string;
-    slot: number;
-    axes: number;
-    out: Float64Array;
-    /** The rest, clamped, or NaN for a channel with none. */
-    rest: Float64Array;
-    bounds: readonly [number, number] | undefined;
-}
-export declare function clampRun(out: Float64Array, at: number, n: number, [lo, hi]: readonly [number, number]): void;
+import { type Column } from './pull.js';
 /**
  * For a `pull` of a list it read last time in the same order, with every voice on a lane, where
  * each position's remembered chain head was current when the mix's `relinks` read `since`: what
@@ -22,7 +12,8 @@ export declare function pullRun<I, O>(lanes: Lanes<I, O>, slots: Int32Array, lis
  * Queues a subject's values for each column at subject `n`'s places, for a `pull` that reads
  * from the lanes while every voice is on one; `flush` writes what is queued, column by column. A
  * channel no lane holds is at rest. Anything queued is written before the lanes fill again.
+ * `slots` holds each row's lane slot, `slot` among them.
  */
-export declare function writeLater<I, O>(lanes: Lanes<I, O>, slot: number, columns: readonly Column[], n: number): void;
+export declare function writeLater<I, O>(lanes: Lanes<I, O>, slot: number, columns: readonly Column[], n: number, slots: Int32Array): void;
 /** Writes every queued run into its columns: a channel's values as a block, a rest as a fill. */
 export declare function flush<I, O>(lanes: Lanes<I, O>): void;