@msb235/blits 0.15.1 → 0.16.1

package/CHANGELOG.md

@@ -4,6 +4,190 @@ 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.1
+
+### Fixed
+
+- A child anchored to a sibling under an owner at rate 0 plays where its anchor puts it when the
+  owner is sought forward past both. Its anchor's time went through mix time on a clock standing
+  still, which maps every time it has passed to the seek's moment, so the child was placed at the
+  time sought plus its offset and never played.
+- `inert` reads false while a motion voice has a subject it met inside its `stagger` and has not
+  read since, which moves once it is probed. It read true, so a host that stops on `inert` stopped
+  a subject that had yet to start.
+- A span's child whose cue a seek back plays again waits for the span's fit, as it did when first
+  cued, so the span lays it out as before. It started at once wherever its span's clock had passed
+  the start the fit first gave it: the fit then took it for ended, so it skipped nothing else, or,
+  in a span running back, the child ran back to its start and left.
+- A child its owner's seek put back before its start stays where it was through a mix sought back to
+  after that seek: a later fit keeps it in its place, and an anchor does not place it again. The
+  seek took it for one still to start, so a span laid it out afresh, and a child anchored to a
+  sibling's end was placed again from that end, and played on as if its owner had not been sought.
+- A voice cued while the mix is paused, its `start` a host time still ahead, waits for that time
+  again when a seek back plays its cue again. It started at once, at the paused mix time, since
+  the voice was taken for one cued while the mix slept and its start was moved to the next sync.
+- A span whose budget runs out between two frames fits again from that moment, in turn with its
+  siblings' starts and ends: a child it places at a start already passed starts in that frame, and
+  one queued after it starts where it lapsed at any frame rate. The span lapsed only after the
+  frame had started its siblings, so a sibling whose old start the frame passed kept it, and one
+  placed in the past waited a frame to start.
+- An owner running back holds a child placed where its clock stands unplayed, whether or not a
+  frame lands there. An owner cued backward with a child at 0 started that child, ended it, and
+  left with it only when a frame fell exactly on the owner's start; otherwise both waited for good.
+- A read ahead that throws partway, on a call the tape holds that it cannot play, puts the tape
+  back. It left the live tape moved past the call, so a later seek restored the wrong state.
+- Under `history`, a voice faded out of one subject is let go when history lets it go. The mix
+  held every such voice for good, and each `drop` walked them all.
+- What `prepare` loads is let go once `history.ms` of mix time passes without a seek or read
+  taking it. Until one did, the mix kept every record paged since, for good.
+- `trace` of a voice sought past its end, with a `fade.out`, follows the fade from the voice's
+  start, where the mix runs it. It called the run exact and read 0 throughout.
+- `weightOf` with lanes on reports the weight a subject was given when its voice moved onto a lane
+  after the subject's probe that frame. It reported 0.
+- A `pull` right after two or more cues folds the new voices in voice order, as a probe does. It
+  folded them newest first, which on a `mul` or `sum` channel could differ in the last bit.
+- An owner's fade in counts from when the owner started, under an owner turned back or slowed.
+  It was worked out again each frame from where the outer owner's clock would next reach the
+  inner owner's start, so a clip under an inner owner with a fade in vanished when the outer
+  owner turned back, and slowing the outer owner jumped the fade to its end.
+- A fade set for now or earlier, on a voice whose owner runs back, begins then. It was put off to
+  when the owner's clock would come back to the voice's start, playing at full weight until then.
+- A fade in stands still while a fade out runs, and climbs on from there after `rise`, rather than
+  jumping to where its clock had reached. A subject's own fade out stops its fade in climbing too,
+  as the voice's does; before, the two multiplied into a rise.
+- A span child with `faster` or `slower` at `Infinity` is retimed to fill its span. It got a rate
+  of Infinity, jumping to its end, or 0, and was skipped as never fitting.
+- A `from: 'current'` voice whose stop lists fewer axes than its `vec` channel reads the missing
+  axes as the lerp does. They read NaN.
+- `spring` and `glide` throw for an infinite parameter. A glide with an infinite `ms` or
+  `stiffness` read NaN, and a spring with infinite `damping` or `mass` jumped to its target.
+- A role member at weight 0 holds its role's place whatever its patch's form, and a band switched
+  off by a frame at weight 0 stays off when the weight comes back between `off` and `on`. A `keys`
+  member at weight 0 was read and so held the role's place; any other was not, so its role folded
+  at the next member's place, which on a `last` channel changed which value won, and the role's
+  band, along with every band in a mix with a role in it, survived the frame at 0.
+- A frame with span children in it costs less than before this release's span-order fixes, which
+  had made it about 5% dearer: a child's visit reads its owners' clocks once, and the voices
+  visited every frame, which include every voice an owner holds, are kept in a list of their own
+  rather than sifted through the due queue's heap and sorted each frame. The new `spans` bench row,
+  ten staggered clips cued under one owner every four frames, reads 5.0% faster than with the
+  fixes (0.141 to 0.134 ms a frame) and 3.4% faster than before them (0.179 to 0.173 on another
+  node), 7 rounds each, U 7.
+- A voice an owner holds, first read while the owner runs back, shows at once instead of waiting
+  on its fade in. The fade in counted from where the owner's clock, running back, would next reach
+  the voice's start, a time still to come, so the voice read nothing until then.
+- An owner sought forward passes the span children it crosses as played straight through,
+  whatever its rate: they start and end in order, and their span fits from each end. Sought ahead
+  while turned back, it started them in the order its clock running back put their starts, last
+  first, and ended none; turning forward later ended them all at once, out of order, and a span
+  holding spans left in a later frame at a time still to come, so a mix sought back left it
+  fading and its clips silent. A timeline's reel jumped ahead in reverse played its scenes slowed
+  and overlapping.
+- A span child kept quiet at its start, its owner having run back to it, comes back and ends in
+  turn when a seek of the owner takes it past its end, and its span fits from that end. It stayed
+  quiet, so the children playing past it kept the rate they had before its end.
+- Under `history`, an owner another owner holds no longer leaves once none of its children plays:
+  it stays with its own owner, quiet, so turning the outer owner back brings back a clip under an
+  owner inside it, as it does a direct child.
+- A span an owner ran back over keeps the layout it made going forward. Before, each child it ran
+  back to the start of fitted the span again from there, and so did a seek back into it, counting
+  the children waiting for the clock to come back as playing: the ones still to start moved
+  earlier, and the playing ones changed speed.
+- A span lays out its children the same at any frame rate. When a child ended between two frames,
+  its span fitted again from that moment, and a sibling whose start had passed by then, but which
+  no frame had started yet, was placed again from there at a new start and rate: two children of a
+  `stagger` span read 420 stepped every 10 ms and 389.47 every 25 ms.
+- A voice under an owner whose rate ramps through 0 (from forward to back) ends where its passes
+  run out while the owner still runs forward. The time was taken as never, so it ended at the
+  frame that noticed, and a span holding it fitted again from there, its layout following the
+  frame rate.
+- A placement whose names make a loop is taken where no mark in it waits on itself: a cue whose
+  `out` is its follow's `start`, the follow starting off the cue's `coast`, was refused as waiting
+  on itself, since the check followed every name whatever mark it asked for. A voice's `start`,
+  `in`, `coast` and the marks placed inside it wait only on what places its start; its `out` and
+  `end` on that and what places its out.
+- A placement that waits on itself through a query by tag or by channel is refused at `cue`, as
+  one through names is: a voice starting after the one tagged `b`, cued beside one tagged `b`
+  starting after the one tagged `a`, was taken. A query is followed to the voices it can pick at
+  the cue, the voice being cued among them.
+- A voice no owner holds, placed by a timestamp in its anchor, stays where it was placed through a
+  seek back. Each placing read the timestamp against the mix's offset at that moment, which a seek
+  moves, so after `seek(1000)` from 2100 an owner anchored to start at 2000 had started at 900, and
+  one anchored to end at 4000 left at 0. The timestamp is now read against the offset in force when
+  the voice was cued, as a plain `start` is.
+- Under `history`, a span an owner holds no longer leaves once its budget is out and none of its
+  children plays: it stays with its owner, quiet, so turning the owner back brings back a clip
+  under a span, or under a span in a span, as it does one under an owner.
+- A child cued into a span an owner ran back over queues after the children it holds. The span
+  was fitted again at the cue, counting the children waiting for the clock to come back as
+  playing, so the new one started beside them. No fit, from a cue, an arc, a sibling leaving or a
+  seek, moves a span run back over until the clock passes it again.
+- A child whose rate a fit changed reads, run back over by an owner, what it read going forward. Its
+  clock read the new rate all the way back past where the fit changed it; it now runs back on the
+  clock it had before, and forward again the fit changes it at the same place.
+- An owner sought past a span's child fits the rest of the span from where that child ended. The
+  owner's clock now put the end before the mix began, where a span read its own clock as 0, so the
+  children still to come were laid out from the span's start: a timeline's reel jumped into its
+  fifth sequence started the third scene beside the second.
+- A span whose children end in one frame fits from each end in the order they came. They were
+  taken in cue order, so an end the frame noticed first could be one that a fit from an earlier
+  end would have moved, and two children of a `stagger` span read 509.5 stepped every 50 ms where
+  1 ms steps read 525.3.
+- A child a fit skipped reads, once its owner is sought or run back before the skip, what it read
+  going forward. One skipped while playing kept its jump to its end and read on from there, and
+  one skipped before it started, placed at its end at its start, played its passes backward from
+  its start.
+- A span child its owner ran or was sought back over takes the change a fit made to it again as
+  the owner's clock comes forward to it, as the layout made going forward stands. The span was
+  fitted again there instead, with the children it had skipped counted as still playing or left
+  out, so the ones it had skipped together with them played on, slowed, beside them.
+- An owner sought past a span lays the span out in that frame as played straight through. Its
+  children that started and ended in the frame were taken in cue order once their span had started,
+  each started and ended in one step, so a fit from one end missed the children it should have
+  moved.
+- A span its owner was sought back before keeps the layout it made going forward, as one run
+  back over does. A child's end there fitted it again with the children ahead, left quiet by the
+  seek, counted as gone, so the playing ones slowed to fill the span.
+- A mix sought back into a span plays on as it stood at that moment. A seek fitted every span
+  again from the moment sought, which a span played straight through is not, so its children's
+  rates followed where the seek landed. A span's end and `result` are now kept with its history and
+  put back by the seek.
+
+## 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

package/README.md

@@ -151,7 +151,7 @@ do yet.
 
 ## Status
 
-v0.15.1, with five consumers. magicsmoke runs every fault on it, wod its wheel, tricks and
+v0.16.1, 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';
@@ -21,13 +20,12 @@ import { unreached } from './unreached.js';
 export function playAhead(transport, c, copies, t, earlier) {
     const tape = transport.tape;
     const depth = tape?.undoDepth() ?? 0;
-    let played = false;
     try {
         for (;;) {
             const e = nextEvent(tape, c, t);
             if (!(e < t))
                 break;
-            played = playTo(transport, c, copies, e) || played;
+            playTo(transport, c, copies, e);
             if (!carries(c))
                 continue;
             // Placed now, as the next move would place them, while a target that has just left is here.
@@ -39,6 +37,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)
@@ -49,11 +48,12 @@ export function playAhead(transport, c, copies, t, earlier) {
             }
             c = next;
         }
-        played = playTo(transport, c, copies, t) || played;
+        playTo(transport, c, copies, t);
     }
     finally {
-        if (played)
-            tape?.goto(depth);
+        // A call that throws partway has moved the tape already, so this asks the tape, not `playTo`.
+        if (tape !== undefined && tape.undoDepth() !== depth)
+            tape.goto(depth);
     }
     return c;
 }
@@ -108,14 +108,13 @@ function nextEvent(tape, c, t) {
 }
 /**
  * Makes the calls the tape holds up to mix time `to` on a read ahead's copies and moves them
- * there. Answers whether it moved the tape.
+ * there.
  */
 function playTo(transport, c, copies, to) {
     const tape = transport.tape;
     const due = (at) => (c.pace === null ? at : c.pace.reading(at)) <= to;
     const next = tape?.timestampAt(tape.undoDepth());
     c.u = hostAhead(c, to);
-    let played = false;
     if (next !== undefined && due(next)) {
         // A call may write what a copy shares with the voice it was copied from.
         for (const copy of c.members)
@@ -125,7 +124,6 @@ function playTo(transport, c, copies, to) {
                 if (v.parted !== null)
                     v.parted = new Map(v.parted);
             }
-        played = true;
         const last = replay(transport, due, c, {
             transport: () => c,
             mix: (of) => copies.get(of),
@@ -136,7 +134,6 @@ function playTo(transport, c, copies, to) {
     if (!(c.now >= to))
         for (const copy of c.members)
             move(copy, to);
-    return played;
 }
 /** A transport for a read ahead's copies to go on from where those on `c` stand. */
 function restage(c) {
@@ -196,11 +193,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/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/clock.d.ts

@@ -9,6 +9,16 @@ 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 fade in from `since` over `fadeIn` at mix time `now`, 0..1. It stands still where a fade out
+ * began, or the two ramps multiply into a rise, from `stop` on, and through `stalls`, pairs of mix
+ * times.
+ */
+export declare function fadeInAt(fadeIn: number, out: {
+    at: number;
+    over: number;
+    rest: boolean;
+} | null, ease: Curve | undefined, now: number, since: number, stalls: readonly number[] | null, stop?: number): number;
 /**
  * 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.
@@ -21,7 +31,7 @@ export declare function envelope(fadeIn: number, out: {
     from: number;
     at: number;
     over: number;
-} | null): number;
+} | null, stalls?: readonly number[] | null): number;
 /**
  * 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. A `raw`

package/dist/clock.js

@@ -21,19 +21,36 @@ export function passAt(elapsed, duration, passes) {
         return 0;
     return over(elapsed, duration, passes) ? passes - 1 : Math.floor(elapsed / duration);
 }
+/**
+ * A fade in from `since` over `fadeIn` at mix time `now`, 0..1. It stands still where a fade out
+ * began, or the two ramps multiply into a rise, from `stop` on, and through `stalls`, pairs of mix
+ * times.
+ */
+export function fadeInAt(fadeIn, out, ease, now, since, stalls, stop = Number.POSITIVE_INFINITY) {
+    let end = out && !out.rest && out.at < now ? out.at : now;
+    if (stop < end)
+        end = stop;
+    let climbed = end - since;
+    if (stalls !== null)
+        for (let i = 0; i < stalls.length; i += 2) {
+            const a = Math.max(stalls[i], since);
+            const b = Math.min(stalls[i + 1], end);
+            if (b > a)
+                climbed -= b - a;
+        }
+    const u = climbed / fadeIn;
+    if (u >= 1)
+        return 1;
+    return ease ? ease(Math.max(0, u)) : Math.max(0, u);
+}
 /**
  * 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) {
+export function envelope(fadeIn, out, ease, reduced, now, since, back = null, stalls = null) {
     let w = 1;
-    if (fadeIn > 0 && !reduced) {
-        // A fade in stops climbing where a fade out begins, or the two ramps multiply into a rise.
-        const end = out && !out.rest && out.at < now ? out.at : now;
-        const u = (end - since) / fadeIn;
-        if (u < 1)
-            w *= ease ? ease(Math.max(0, u)) : Math.max(0, u);
-    }
+    if (fadeIn > 0 && !reduced)
+        w *= fadeInAt(fadeIn, out, ease, now, since, stalls);
     if (back && !reduced) {
         const u = back.from + (now - back.at) / back.over;
         if (u < 1)
@@ -114,7 +131,9 @@ export function timeWith(c, elapsed) {
         return r.from > 0 ? c.anchorNow + (elapsed - e0) / r.from : c.anchorNow;
     const a = (r.to - r.from) / (2 * r.over);
     const atEnd = e0 + r.from * r.over + a * r.over * r.over;
-    if (elapsed <= atEnd) {
+    // A ramp that turns the clock back reads furthest where its rate crosses 0, not at its end.
+    const top = r.from > 0 && r.to < 0 ? e0 - (r.from * r.from) / (4 * a) : atEnd;
+    if (elapsed <= top) {
         const k = e0 - elapsed;
         const dt = Math.abs(a) < 1e-12
             ? -k / r.from

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