@msb235/blits 0.15.1 → 0.16.0

package/dist/everyone.js

@@ -1,6 +1,7 @@
 import { headOf } from './chain.js';
 import { numericOf } from './channels.js';
 import { record } from './record.js';
+import { detour } from './roster.js';
 /**
  * Whether a voice can keep one record for every subject, decided when it is cued. A record holds
  * what a voice knows of one subject; where the voice is over every subject with no stagger, keeps
@@ -263,17 +264,25 @@ export function unshare(mix, voice, kept = false, keeper) {
     detour(mix);
     mix.lanes?.refill();
 }
-/**
- * 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 function detour(mix) {
-    mix.detours = mix.roleVoices + mix.sharers.length + (mix.unshared ? 1 : 0);
-}
 /** Gives a record just made for a subject a sharing voice had seen what the voice kept for it. */
 export function inherit(voice, held, slot) {
     held.weight = weightAt(voice, slot);
     open(voice, held, slot);
     unsight(voice, slot);
 }
+/** What the general path calls on a sharing voice, reached through `Lanes`, so a lean bundle leaves it out. */
+export const share = {
+    shares,
+    outgrow,
+    everyoneOf,
+    sighted,
+    sight,
+    weightAt,
+    weighAt,
+    open,
+    shut,
+    restamp,
+    unsight,
+    unshare,
+    inherit,
+};

package/dist/fade.d.ts

@@ -30,7 +30,13 @@ export declare function beginFade<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, op
     at?: 'rest';
     deadline?: number;
     back?: boolean;
+    stays?: boolean;
 }, at?: number): void;
+/**
+ * Keeps a voice faded at the end of its passes with its owner, live and quiet, rather than letting
+ * it leave; the owner leaves at `at` if it holds no child still playing.
+ */
+export declare function stay<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, at: number): void;
 /**
  * Turns a fading voice around: it climbs back from where its fade out had got to, up the same
  * curve, at the whole curve per `over` ms. A fade waiting for rest is taken back at once. A voice
@@ -44,5 +50,10 @@ export declare function beginRise<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, op
  * exactly there; at or behind now, the fade began then and is partway.
  */
 export declare function fadeAt<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, at: number, over: number | undefined): void;
+/**
+ * Brings back a voice kept quiet past its passes, its clock back in them by mix time `now`: it
+ * climbs from nothing over the fade it left over, from when its clock reached them.
+ */
+export declare function rouse<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, now: number): void;
 /** Removes a voice, recording that it left at `at`, default now. */
 export declare function retire<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, at?: number): void;

package/dist/fade.js

@@ -1,10 +1,9 @@
 import { changed, headOf, unlink } from './chain.js';
 import { envelope } from './clock.js';
 import { schedule } from './due.js';
-import { unshare, unsight } from './everyone.js';
 import { leave, noted, releasing } from './history.js';
 import { markOf } from './marks.js';
-import { orphan, ownerReading } from './owner.js';
+import { orphan, ownerReading, plays } from './owner.js';
 import { startOf } from './place.js';
 import { isRested } from './record.js';
 import { scoreTouched } from './scored.js';
@@ -14,7 +13,7 @@ import { unreach } from './unreached.js';
 export function fadeSubject(mix, voice, subject, over) {
     if (voice.state === 'done' || voice.parted?.has(subject) || voice.parts?.has(subject))
         return;
-    unshare(mix, voice);
+    mix.share?.unshare(mix, voice);
     mix.stir();
     const ms = mix.reduced ? 0 : (over ?? voice.fade.out ?? 0);
     const at = Number.isNaN(mix.now) ? startOf(voice) : mix.now;
@@ -104,7 +103,7 @@ function forgetIn(mix, voice, subject) {
     if (head !== undefined && head.slot >= 0) {
         unreach(voice, head.slot, false);
         // What the voice kept for the subject while it shared one record, which `weightOf` reads.
-        unsight(voice, head.slot);
+        mix.share?.unsight(voice, head.slot);
     }
     const held = voice.subjects.get(subject);
     if (held !== undefined) {
@@ -135,7 +134,7 @@ export function beginFade(mix, voice, opts, at) {
     // A fade at rest marks each subject's record as it comes to rest, at its next read: one already
     // read this frame is read again, as after `touch`.
     if (opts.at === 'rest') {
-        unshare(mix, voice);
+        mix.share?.unshare(mix, voice);
         voice.seeks++;
     }
     voice.state = 'fading';
@@ -148,14 +147,36 @@ export function beginFade(mix, voice, opts, at) {
     };
     if (opts.back)
         voice.out.back = true;
+    if (opts.stays)
+        voice.out.stays = true;
     noted(mix, voice);
     // A fade at rest, from a voice's start, or of a voice yet to start takes it off its lane.
     if (opts.at === 'rest' || opts.back || waiting)
         mix.lanes?.invalidate();
     else
         mix.lanes?.refill();
-    if (over === 0 && opts.at !== 'rest')
-        retire(mix, voice, voice.out.at);
+    if (over === 0 && opts.at !== 'rest') {
+        if (opts.stays)
+            stay(mix, voice, voice.out.at);
+        else
+            retire(mix, voice, voice.out.at);
+    }
+}
+/**
+ * Keeps a voice faded at the end of its passes with its owner, live and quiet, rather than letting
+ * it leave; the owner leaves at `at` if it holds no child still playing.
+ */
+export function stay(mix, voice, at) {
+    voice.state = 'live';
+    mix.lanes?.refill();
+    const owner = voice.owner;
+    if (owner.state === 'done')
+        return;
+    const now = Number.isNaN(mix.now) ? Number.NEGATIVE_INFINITY : mix.now;
+    if (!plays(owner, now) && !lingers(owner, at))
+        retire(mix, owner, at);
+    else if (owner.fitting !== null && !voice.skipped)
+        refit(mix, owner, at);
 }
 /**
  * Turns a fading voice around: it climbs back from where its fade out had got to, up the same
@@ -211,6 +232,21 @@ export function fadeAt(mix, voice, at, over) {
     voice.outSet = true;
     noted(mix, voice);
 }
+/**
+ * Brings back a voice kept quiet past its passes, its clock back in them by mix time `now`: it
+ * climbs from nothing over the fade it left over, from when its clock reached them.
+ */
+export function rouse(mix, voice, now) {
+    const out = voice.out;
+    const edge = out.back === true ? voice.soonest : voice.span + voice.latest;
+    const reached = voice.reaches(edge);
+    const at = Math.max(out.at + out.over, reached <= now ? reached : now);
+    const over = mix.reduced ? 0 : out.over;
+    voice.out = null;
+    voice.back = over > 0 ? { from: 0, at, over } : null;
+    noted(mix, voice);
+    mix.lanes?.refill();
+}
 /** Whether a motion patch still asks this voice of this mix for its time. */
 function asks(mix, motion, voice) {
     return motion.owner === mix.owner && motion.ownerId === voice.id;
@@ -248,7 +284,7 @@ export function retire(mix, voice, at) {
     if (voice.owner !== null) {
         const span = voice.owner;
         leaving(mix, voice);
-        const owner = orphan(voice);
+        const owner = orphan(voice, now);
         if (owner !== null && !lingers(owner, voice.doneAt))
             retire(mix, owner, voice.doneAt);
         // A child the fit skipped had no time in it, so the rest of the fit stands: fitting again

package/dist/fold.js

@@ -1,10 +1,7 @@
 import { foldNumber } from './channels.js';
 import { copy as copyValue, first } from './clone.js';
-import { open as openRecord, shut as shutRecord, weighAt } from './everyone.js';
 // V8 reads a local const as a constant, where it reads an import from its module on every call.
 const copy = copyValue;
-const open = openRecord;
-const shut = shutRecord;
 /** A record's band state, made when a rest-less channel first asks. */
 function bandsFor(held, n) {
     const bands = new Uint8Array(n);
@@ -107,9 +104,9 @@ export function shared(voice, slot, rec, q) {
         // A projection numbers no subject, and keeps nothing by subject.
         if (slot < 0)
             return q;
-        const cap = this.lanes.cap;
-        weighAt(voice, slot, rec.weight, cap);
-        shut(voice, rec, slot, cap);
+        const lanes = this.lanes;
+        this.share.weighAt(voice, slot, rec.weight, lanes.cap);
+        this.share.shut(voice, rec, slot, lanes.cap);
         return q;
     }
     const sharers = this.sharers;
@@ -265,7 +262,7 @@ export function foldSharers(pose, subject, head, q, before, laned, dry, except,
             continue;
         if (voice.id === except || voice.state === 'done')
             continue;
-        open(voice, rec, head.slot);
+        this.share.open(voice, rec, head.slot);
         const delta = this.read(voice, subject, now, dry, rec);
         if (owed >= 0 && voice.laned)
             this.lanes.paid(voice.id, owed, rec.weight);

package/dist/held.js

@@ -2,7 +2,6 @@ import { changed } from './chain.js';
 import { stepOf } from './clock.js';
 import { delayOf } from './delay.js';
 import { schedule } from './due.js';
-import { everyoneOf, inherit, sighted } from './everyone.js';
 import { originOf } from './origin.js';
 import { startOf } from './place.js';
 import { record } from './record.js';
@@ -24,7 +23,7 @@ export function unreachedOf(voice, now) {
  */
 export function held(voice, subject, slot, guess = null) {
     if (voice.sharing) {
-        const all = everyoneOf(this, voice);
+        const all = this.share.everyoneOf(this, voice);
         if (all !== null)
             return all;
     }
@@ -67,8 +66,8 @@ export function held(voice, subject, slot, guess = null) {
     voice.subjects.set(subject, held);
     waits(voice, held, now);
     // A subject a voice saw while it shared one record was counted then.
-    if (sighted(voice, slot))
-        inherit(voice, held, slot);
+    if (voice.sighted !== null && this.share?.sighted(voice, slot))
+        this.share.inherit(voice, held, slot);
     else
         voice.seen++;
     if (delay > voice.latest) {

package/dist/hosts.d.ts

@@ -4,6 +4,13 @@ import type { Booker, BookOptions, Handle } from './types.js';
 import type { Voice } from './voice.js';
 export declare function book<I, O>(mix: Mixer<I, O>, opts: BookOptions<unknown, I>): Booker;
 export declare function laneHost<I, O>(mix: Mixer<I, O>): LaneHost<I, O>;
+/**
+ * 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. A motion going round
+ * an `ink` color's hue stays out, since a crowd solves its stretches straight across each axis.
+ */
+export declare function crowdable<I, O>(v: Voice<I, O>): boolean;
 /**
  * Whether a voice's patch and spec can run on a lane, its channels aside. A voice whose patch has
  * kept state on a record through `setting.keep` is stateful from then on, and leaves its lane;

package/dist/hosts.js

@@ -3,9 +3,7 @@ import { Book } from './book.js';
 import { headOf } from './chain.js';
 import { numericOf } from './channels.js';
 import { stepOf } from './clock.js';
-import { crowdable } from './crowd.js';
 import { schedule } from './due.js';
-import { unshare, unsight, weightAt } from './everyone.js';
 import { beginFade, beginRise, fadeAt, fadeSubject } from './fade.js';
 import { goneIndex } from './gone.js';
 import { VoiceHandle } from './handle.js';
@@ -67,7 +65,7 @@ export function laneHost(mix) {
             for (const voice of mix.general) {
                 unreach(voice, slot, false);
                 if (voice.sighted !== null)
-                    unsight(voice, slot);
+                    mix.share?.unsight(voice, slot);
             }
             for (const voice of goneIndex(mix).general)
                 unreach(voice, slot, false);
@@ -110,6 +108,19 @@ export function laneHost(mix) {
         kept: (voice) => stateful(mix, voice),
     };
 }
+/**
+ * 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. A motion going round
+ * an `ink` color's hue stays out, since a crowd solves its stretches straight across each axis.
+ */
+export function crowdable(v) {
+    return (v.named !== null &&
+        v.named.size === 1 &&
+        v.spec.role === undefined &&
+        (v.slots.length === 1 || v.motion === undefined) &&
+        v.motion?.round !== true);
+}
 /**
  * Whether a voice's patch and spec can run on a lane, its channels aside. A voice whose patch has
  * kept state on a record through `setting.keep` is stateful from then on, and leaves its lane;
@@ -181,7 +192,7 @@ export function stateful(mix, voice) {
     voice.keeping = true;
     // The call that kept state was for the subject last sent to, whose record the state is on.
     if (voice.sharing)
-        unshare(mix, voice, true, mix.sending.subject);
+        mix.share?.unshare(mix, voice, true, mix.sending.subject);
     mix.lanes?.invalidate();
 }
 export function handle(mix, voice) {
@@ -248,7 +259,9 @@ function handleHost(mix) {
                 ? undefined
                 : voice.subjects.get(subject);
             // A voice that stopped sharing makes a subject's record at its next read, from what it kept.
-            return held !== undefined ? held.weight : weightAt(voice, slot);
+            if (held !== undefined)
+                return held.weight;
+            return mix.share === null ? 0 : mix.share.weightAt(voice, slot);
         },
         taping: () => taping(mix),
         record: (h, label, again) => record(mix, label, (stage) => {

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export type { LastOptions, NumberOptions, NumberTuple, Vec } from './channels.js';
 export { kit, last, max, mul, sum, vec } from './channels.js';
 export type { ColorOptions } from './color.js';
-export { color, css, mixHex, oklab, toHex } from './color.js';
+export { color, css, ink, mixHex, oklab, toHex } from './color.js';
 export type { Curve } from './easing.js';
 export { curve } from './easing.js';
 export type { Claim, Fit, FitPlan, Layout, Order, OverrunOptions, SpanClaim, Strength, } from './fit.js';

package/dist/index.js

@@ -1,5 +1,5 @@
 export { kit, last, max, mul, sum, vec } from './channels.js';
-export { color, css, mixHex, oklab, toHex } from './color.js';
+export { color, css, ink, mixHex, oklab, toHex } from './color.js';
 export { curve } from './easing.js';
 export { conclude, condense, lax, layout, overrun, pipe, plain, shed, } from './fit.js';
 export { mix, mixer } from './mixer.js';

package/dist/lanes.d.ts

@@ -1,4 +1,4 @@
-import type { Column } from './columns.js';
+import { flush, pullRun, writeLater } from './columns.js';
 import { type Copier, copy } from './copyout.js';
 import { type Crowd, row } from './crowd.js';
 import { call, foldKeys, one, parting, readKeyed, reset, run, runEveryone, signalled, subjectAt } from './fill.js';
@@ -7,6 +7,8 @@ import { type Lane, type Laned, type Role } from './lane.js';
 import { absent, Numbers } from './numbers.js';
 import { Owed } from './owed.js';
 import { Placed } from './placed.js';
+import type { Column } from './pull.js';
+import { renumber } from './renumber.js';
 import { type Seat } from './seat.js';
 import type { Watcher } from './stretch.js';
 import type { Subject } from './subject.js';
@@ -64,6 +66,29 @@ export interface LaneHost<I, O> {
  */
 export declare class Lanes<I, O> implements Watcher {
     readonly host: LaneHost<I, O>;
+    /** What the general path calls on a sharing voice, given to a mix by its engine so a lean bundle leaves it out. */
+    static readonly share: {
+        shares: typeof import("./everyone.js").shares;
+        outgrow: typeof import("./everyone.js").outgrow;
+        everyoneOf: typeof import("./everyone.js").everyoneOf;
+        sighted: typeof import("./everyone.js").sighted;
+        sight: typeof import("./everyone.js").sight;
+        weightAt: typeof import("./everyone.js").weightAt;
+        weighAt: typeof import("./everyone.js").weighAt;
+        open: typeof import("./everyone.js").open;
+        shut: typeof import("./everyone.js").shut;
+        restamp: typeof import("./everyone.js").restamp;
+        unsight: typeof import("./everyone.js").unsight;
+        unshare: typeof import("./everyone.js").unshare;
+        inherit: typeof import("./everyone.js").inherit;
+    };
+    /** What `pull` calls on lanes alone. */
+    readonly pulls: {
+        pullRun: typeof pullRun;
+        writeLater: typeof writeLater;
+        flush: typeof flush;
+        renumber: typeof renumber;
+    };
     readonly numbers: Numbers<I>;
     lanes: Lane<I, O>[];
     /** The lanes over every subject that have started playing, by epoch. */

package/dist/lanes.js

@@ -1,6 +1,8 @@
 import { lit } from './bound.js';
+import { flush, pullRun, writeLater } from './columns.js';
 import { copy } from './copyout.js';
 import { row } from './crowd.js';
+import { share } from './everyone.js';
 import { call, fillAll, foldKeys, one, parting, readKeyed, reset, run, runEveryone, signalled, subjectAt, } from './fill.js';
 import { fold, foldDelta, foldInto, foldRun, gate, gather, unplain } from './gather.js';
 import { meet, reach } from './meet.js';
@@ -9,6 +11,7 @@ import { Owed } from './owed.js';
 import { Placed } from './placed.js';
 import { requalify, retouch } from './qualify.js';
 import { reading } from './reading.js';
+import { renumber } from './renumber.js';
 import { reportedRow, unplace } from './rows.js';
 import { seatOf } from './seat.js';
 /**
@@ -18,6 +21,10 @@ import { seatOf } from './seat.js';
 // biome-ignore lint/suspicious/noUnsafeDeclarationMerging: every member of `Methods` is installed below
 export class Lanes {
     host;
+    /** What the general path calls on a sharing voice, given to a mix by its engine so a lean bundle leaves it out. */
+    static share = share;
+    /** What `pull` calls on lanes alone. */
+    pulls = { pullRun, writeLater, flush, renumber };
     numbers;
     lanes = [];
     /** The lanes over every subject that have started playing, by epoch. */

package/dist/lch.d.ts

@@ -0,0 +1,23 @@
+import type { Curve } from './easing.js';
+/** Below this chroma a color is gray and its hue is noise, so it takes the other end's. */
+export declare const GRAY = 0.0001;
+/** Where `shortWay` leaves the hue a way starts from and how far it turns. */
+export declare const HUES: number[];
+/** The way from hue `ah` to `bh` the short way round into `HUES`, a gray end taking the other's. */
+export declare function shortWay(ah: number, ac: number, bh: number, bc: number): void;
+/**
+ * Two premultiplied OKLab colors, `[w·L, w·a, w·b, w]` read from `x` at `i` and `y` at `j`, into
+ * `out` as `[L, C, h, w]` each, `y`'s hue the short way round from `x`'s. A color with no coverage
+ * has none of its own to keep, so it takes the other end's.
+ */
+export declare function lchPair(x: ArrayLike<number>, i: number, y: ArrayLike<number>, j: number, out: Float64Array): void;
+/**
+ * `closed` for a stretch of a color traveling round the hue, as `ink` does: its ends and velocity,
+ * premultiplied OKLab as the patch keeps them, moved into `[L, C, h, w]`, solved there axis by
+ * axis, and the position and
+ * velocity moved back into `xo` and `vo`. A spring heads round the hue the short way from where
+ * the stretch starts, so a retarget bends the path rather than restarting it, and one that
+ * overshoots its target overshoots in hue too. A glide comes to rest `v·τ` along each of the four,
+ * so it coasts round the hue rather than off along a tangent.
+ */
+export declare function closedLch(law: Float64Array, ease: Curve | undefined, 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/lch.js

@@ -0,0 +1,126 @@
+import { COAST, closed } from './closed.js';
+/** Below this chroma a color is gray and its hue is noise, so it takes the other end's. */
+export const GRAY = 1e-4;
+/** Where `shortWay` leaves the hue a way starts from and how far it turns. */
+export const HUES = [0, 0];
+/** The way from hue `ah` to `bh` the short way round into `HUES`, a gray end taking the other's. */
+export function shortWay(ah, ac, bh, bc) {
+    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;
+    HUES[0] = from;
+    HUES[1] = turn;
+}
+/**
+ * Two premultiplied OKLab colors, `[w·L, w·a, w·b, w]` read from `x` at `i` and `y` at `j`, into
+ * `out` as `[L, C, h, w]` each, `y`'s hue the short way round from `x`'s. A color with no coverage
+ * has none of its own to keep, so it takes the other end's.
+ */
+export function lchPair(x, i, y, j, out) {
+    const xw = x[i + 3] ?? 0;
+    const yw = y[j + 3] ?? 0;
+    const ys = yw > 0 ? 1 / yw : 0;
+    const yL = (y[j] ?? 0) * ys;
+    const yA = (y[j + 1] ?? 0) * ys;
+    const yB = (y[j + 2] ?? 0) * ys;
+    const xs = xw > 0 ? 1 / xw : 0;
+    const xL = xw > 0 ? (x[i] ?? 0) * xs : yL;
+    const xA = xw > 0 ? (x[i + 1] ?? 0) * xs : yA;
+    const xB = xw > 0 ? (x[i + 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);
+    shortWay(Math.atan2(xB, xA), xc, Math.atan2(toB, toA), yc);
+    out[0] = xL;
+    out[1] = xc;
+    out[2] = HUES[0];
+    out[3] = xw;
+    out[4] = toL;
+    out[5] = yc;
+    out[6] = HUES[0] + HUES[1];
+    out[7] = yw;
+}
+const PAIR = new Float64Array(8);
+const RATES = new Float64Array(4);
+const REST = new Float64Array(4);
+const XS = new Float64Array(4);
+const VS = new Float64Array(4);
+/**
+ * `closed` for a stretch of a color traveling round the hue, as `ink` does: its ends and velocity,
+ * premultiplied OKLab as the patch keeps them, moved into `[L, C, h, w]`, solved there axis by
+ * axis, and the position and
+ * velocity moved back into `xo` and `vo`. A spring heads round the hue the short way from where
+ * the stretch starts, so a retarget bends the path rather than restarting it, and one that
+ * overshoots its target overshoots in hue too. A glide comes to rest `v·τ` along each of the four,
+ * so it coasts round the hue rather than off along a tangent.
+ */
+export function closedLch(law, ease, at, ms, x0, x, v0, v, to, g, t, xo, vo) {
+    const p = PAIR;
+    lchPair(x0, x, to, g, p);
+    const L = p[0];
+    const C = p[1];
+    const h = p[2];
+    const w = p[3];
+    // OKLab's rates of change at the start, its coverage's share divided out, turned onto L, C and h.
+    const dw = v0[v + 3];
+    let dL = 0;
+    let dC = 0;
+    let dh = 0;
+    if (w > 0) {
+        const cos = Math.cos(h);
+        const sin = Math.sin(h);
+        dL = (v0[v] - dw * L) / w;
+        const da = (v0[v + 1] - dw * C * cos) / w;
+        const db = (v0[v + 2] - dw * C * sin) / w;
+        dC = da * cos + db * sin;
+        dh = C < GRAY ? 0 : (db * cos - da * sin) / C;
+    }
+    RATES[0] = dL;
+    RATES[1] = dC;
+    RATES[2] = dh;
+    RATES[3] = dw;
+    let goal = p;
+    let o = 4;
+    if (law[0] === COAST) {
+        const tau = law[2];
+        for (let i = 0; i < 4; i++)
+            REST[i] = p[i] + RATES[i] * tau;
+        goal = REST;
+        o = 0;
+    }
+    const still = closed(law, ease, 4, at, ms, p, 0, RATES, 0, goal, o, t, XS, VS);
+    if (still && o === 4) {
+        for (let i = 0; i < 4; i++) {
+            xo[i] = to[g + i];
+            vo[i] = 0;
+        }
+        return true;
+    }
+    const nL = XS[0];
+    const nC = XS[1];
+    const nh = XS[2];
+    const nw = XS[3];
+    const cos = Math.cos(nh);
+    const sin = Math.sin(nh);
+    const a = nC * cos;
+    const b = nC * sin;
+    const rL = VS[0];
+    const rC = VS[1];
+    const rh = VS[2];
+    const rw = VS[3];
+    xo[0] = nL * nw;
+    xo[1] = a * nw;
+    xo[2] = b * nw;
+    xo[3] = nw;
+    vo[0] = rL * nw + nL * rw;
+    vo[1] = (rC * cos - nC * rh * sin) * nw + a * rw;
+    vo[2] = (rC * sin + nC * rh * cos) * nw + b * rw;
+    vo[3] = rw;
+    return still;
+}

package/dist/mixer.d.ts

@@ -4,11 +4,11 @@ import { blended, laneRead, shareKept } from './blend.js';
 import type { Book } from './book.js';
 import { aims, chain, linkable, relink } from './chain.js';
 import { type LerpInto } from './channels.js';
-import type { Column } from './columns.js';
 import { baseFor, contribution, isRest, keyed, read, slopeFor, tick } from './contribution.js';
 import { DepartedIndex } from './departed.js';
 import { drop, forgetIn, recordDrop, releaseIn } from './drop.js';
 import { DueQueue } from './due.js';
+import type { Share } from './everyone.js';
 import { parting } from './fade.js';
 import { apply, clamp, fold, foldDetour, folded, foldSharers, foldWith, type Key, linked, owedBy, passes, shared } from './fold.js';
 import { GoneIndex } from './gone.js';
@@ -20,6 +20,7 @@ import type { Pace } from './pace.js';
 import { Keys } from './paging.js';
 import type { Places } from './places.js';
 import { moved, place, plot, put } from './plot.js';
+import type { Column } from './pull.js';
 import { keep } from './pull.js';
 import { Steps } from './relink.js';
 import { atRest, restful, rests, restsKey, restsLaned, still } from './rests.js';
@@ -209,6 +210,8 @@ export declare class Mixer<I, O> implements Mix<I, O> {
     roleDepth: number;
     readonly slotOf: Map<string, number>;
     lanes: Lanes<I, O> | null;
+    /** The sharing hooks of the lanes this entry was built with, which a projection's copy keeps. */
+    share: Share | null;
     handles: HandleHost<I, O> | null;
     /** What `book` made, still booking; null while there is none. */
     bookers: Book<I, O>[] | null;

package/dist/mixer.js

@@ -235,6 +235,8 @@ export class Mixer {
     roleDepth = 0;
     slotOf = new Map();
     lanes;
+    /** The sharing hooks of the lanes this entry was built with, which a projection's copy keeps. */
+    share;
     handles = null;
     /** What `book` made, still booking; null while there is none. */
     bookers = null;
@@ -266,6 +268,7 @@ export class Mixer {
         });
         if (lanesOf === null && opts.lanes === true)
             throw new Error("blits: '@msb235/blits/lean' has no lanes; take mix from '@msb235/blits'");
+        this.share = lanesOf?.share ?? null;
         this.lanes =
             lanesOf !== null && (opts.lanes ?? defaults.lanes) ? new lanesOf(laneHost(this)) : null;
         this.name = opts.name;

package/dist/motions.d.ts

@@ -64,11 +64,14 @@ export declare class Motions<I> {
     /** Whether the channel it was cued on holds a number; undefined until it is cued. */
     private holdsNumber;
     private channel;
+    /** Whether the channel it was cued on travels round the hue, as `ink` does, and its stretches too. */
+    round: boolean;
     /**
      * Records what the channel the patch is cued on holds, refusing a value of the other kind: at once
      * where every subject's value is one kind, else on the first sample of a subject whose value is not.
+     * `round` for a channel that travels round the hue, as `ink` does.
      */
-    cuedOn(channel: string, holdsNumber: boolean): void;
+    cuedOn(channel: string, holdsNumber: boolean, round?: boolean): void;
     frame(subject: I): number;
     constructor(shape: Shape<I>);
     /** The patch's number for `subject`, made with its first stretch on first ask. */