@msb235/blits 0.15.1 → 0.16.0

package/CHANGELOG.md

@@ -4,6 +4,41 @@ 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

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

package/dist/columns.js

@@ -1,9 +1,4 @@
-export function clampRun(out, at, n, [lo, hi]) {
-    for (let i = at; i < at + n; i++) {
-        const x = out[i];
-        out[i] = x < lo ? lo : x > hi ? hi : x;
-    }
-}
+import { clampRun } 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

package/dist/crowd.d.ts

@@ -6,12 +6,6 @@ import type { Motions } from './motions.js';
 import type { Scratch } from './patch.js';
 import type { Subject } from './subject.js';
 import type { Voice } from './voice.js';
-/**
- * Whether a laned voice belongs in a crowd: one naming a single subject, which shares nothing
- * across subjects for a lane to save. A motion voice writes one channel; a keys or fn voice may
- * write several, and joins the crowd of voices writing those same channels.
- */
-export declare function crowdable<I, O>(v: Voice<I, O>): boolean;
 /** The law of a row that has none, a keys or fn voice's. */
 export declare const none: Float64Array<ArrayBuffer>;
 /** Per row of a crowd's `hot`: what the fill reads of the row's voice and its current stretch. */

package/dist/crowd.js

@@ -4,17 +4,6 @@ import { closed } from './closed.js';
 import { KeyRows } from './keyrows.js';
 import { keepProbed, 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
- * across subjects for a lane to save. A motion voice writes one channel; a keys or fn voice may
- * write several, and joins the crowd of voices writing those same channels.
- */
-export function crowdable(v) {
-    return (v.named !== null &&
-        v.named.size === 1 &&
-        v.spec.role === undefined &&
-        (v.slots.length === 1 || v.motion === undefined));
-}
 /** The law of a row that has none, a keys or fn voice's. */
 export const none = new Float64Array(0);
 /** Whether a row's flags let `bareRows` take it. */

package/dist/cue.js

@@ -3,8 +3,8 @@ import { checkHits } from './book.js';
 import { bind, checkWithin } from './bound.js';
 import { changed } from './chain.js';
 import { copyable } from './clone.js';
+import { roundsHue } from './color.js';
 import { schedule } from './due.js';
-import { shares } from './everyone.js';
 import { finiteRate, plainWeight, VoiceHandle } from './handle.js';
 import { begin } from './held.js';
 import { handle } from './hosts.js';
@@ -158,11 +158,14 @@ export function playable(mix, spec) {
     const motion = motionOf(patch);
     if (motion !== undefined) {
         const channel = patch.writes[0];
-        const rest = mix.kit[channel].rest;
+        const ch = mix.kit[channel];
+        const rest = ch.rest;
         if (typeof rest === 'number')
             motion.cuedOn(String(channel), true);
         else if (Array.isArray(rest) || ArrayBuffer.isView(rest))
-            motion.cuedOn(String(channel), false);
+            motion.cuedOn(String(channel), false, roundsHue(ch));
+        else if (roundsHue(ch))
+            motion.cuedOn(String(channel), false, true);
     }
     if (patch.reads) {
         const host = mix.opts.host;
@@ -250,7 +253,7 @@ function enter(mix, voice) {
         i--;
     cued.splice(i, 0, voice);
     scoredAdd(mix, voice);
-    voice.sharing = shares(mix, voice);
+    voice.sharing = mix.share?.shares(mix, voice) === true;
     enlist(mix, voice);
     changed(mix, voice);
     mix.stir();

package/dist/everyone.d.ts

@@ -65,11 +65,22 @@ export declare function unsight<I, O>(voice: Voice<I, O>, slot: number): void;
  * positions take their own records now, since each held the one.
  */
 export declare function unshare<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, kept?: boolean, keeper?: I): void;
-/**
- * Counts what makes a mix's fold more than a walk of each chain: a role, a voice sharing one
- * record, a voice that stopped sharing this frame. Called wherever one of the three changes, so
- * `foldWith` asks one number.
- */
-export declare function detour<I, O>(mix: Mixer<I, O>): void;
 /** Gives a record just made for a subject a sharing voice had seen what the voice kept for it. */
 export declare function inherit<I, O>(voice: Voice<I, O>, held: Subject<unknown>, slot: number): void;
+/** What the general path calls on a sharing voice, reached through `Lanes`, so a lean bundle leaves it out. */
+export declare const share: {
+    shares: typeof shares;
+    outgrow: typeof outgrow;
+    everyoneOf: typeof everyoneOf;
+    sighted: typeof sighted;
+    sight: typeof sight;
+    weightAt: typeof weightAt;
+    weighAt: typeof weighAt;
+    open: typeof open;
+    shut: typeof shut;
+    restamp: typeof restamp;
+    unsight: typeof unsight;
+    unshare: typeof unshare;
+    inherit: typeof inherit;
+};
+export type Share = typeof share;