@msb235/blits 0.15.1 → 0.16.1

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. */
@@ -261,7 +268,8 @@ export class Lanes {
     }
     reported(lane, slot) {
         const o = slot * 6 /* Per.SLOT */;
-        if (!(this.per[o + 3 /* Per.LANE_PROBE */] > this.per[o + 4 /* Per.GENERAL_PROBE */]))
+        const probe = this.per[o + 3 /* Per.LANE_PROBE */];
+        if (!(probe > this.per[o + 4 /* Per.GENERAL_PROBE */]) || !(probe > lane.made))
             return undefined;
         const p = lane.positionOf(slot);
         if (p < 0)

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

@@ -86,6 +86,15 @@ export function meet(lanes, slot, subject, head, lane) {
         }
     if (!met)
         return lane;
+    // Met newest first; folded, as the general path folds them, in voice order.
+    const ids = lanes.met;
+    for (let i = 1; i < lanes.metN; i++) {
+        const id = ids[i];
+        let j = i - 1;
+        for (; j >= 0 && ids[j] > id; j--)
+            ids[j + 1] = ids[j];
+        ids[j + 1] = id;
+    }
     // The fill ran before the subject had these positions. Where every voice it just met folds
     // after every other laned voice, the general path folds just those onto the lanes' values;
     // otherwise it reads the general path all frame.

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';
@@ -105,6 +106,8 @@ export declare class Mixer<I, O> implements Mix<I, O> {
     retired: Voice<I, O>[];
     /** Visit every voice each sync, as before the due queue; for tests that compare the two. */
     walkAll: boolean;
+    /** Owners sought forward since the last frame, which passes what each seek went past in order. */
+    leapt: Set<Voice<I, O>> | null;
     /** The last array `pull` read, by position, with each subject's chain head, to skip the lookup. */
     pulled: I[];
     pulledHeads: (Subject<unknown> | undefined)[];
@@ -209,6 +212,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

@@ -95,6 +95,8 @@ export class Mixer {
     retired = [];
     /** Visit every voice each sync, as before the due queue; for tests that compare the two. */
     walkAll = false;
+    /** Owners sought forward since the last frame, which passes what each seek went past in order. */
+    leapt = null;
     /** The last array `pull` read, by position, with each subject's chain head, to skip the lookup. */
     pulled = [];
     pulledHeads = [];
@@ -235,6 +237,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 +270,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/motion.js

@@ -241,8 +241,8 @@ export function spring(writes, opts) {
     const k = opts.stiffness ?? 170;
     const c = opts.damping ?? 26;
     const m = opts.mass ?? 1;
-    if (!(k > 0) || !(m > 0) || !(c >= 0))
-        throw new RangeError('blits: a spring takes a positive stiffness and mass, and damping of 0 or more');
+    if (!(k > 0 && k < Infinity) || !(m > 0 && m < Infinity) || !(c >= 0 && c < Infinity))
+        throw new RangeError('blits: a spring takes a finite positive stiffness and mass, and finite damping of 0 or more');
     const settle = opts.settle ?? 1e-4;
     const w0 = Math.sqrt(k / m);
     const zeta = c / (2 * Math.sqrt(k * m));
@@ -273,11 +273,11 @@ export function spring(writes, opts) {
  */
 export function glide(writes, opts) {
     const ms = opts.ms ?? 325;
-    if (!(ms > 0))
-        throw new RangeError('blits: a glide takes a positive ms');
+    if (!(ms > 0 && ms < Infinity))
+        throw new RangeError('blits: a glide takes a finite positive ms');
     const k = opts.stiffness ?? 170;
-    if (!(k > 0))
-        throw new RangeError('blits: a glide takes a positive stiffness');
+    if (!(k > 0 && k < Infinity))
+        throw new RangeError('blits: a glide takes a finite positive stiffness');
     const tau = ms / 1000;
     const settle = opts.settle ?? 1e-4;
     const bounded = opts.bounds !== undefined;

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

package/dist/motions.js

@@ -1,5 +1,6 @@
 import { applied, change, commit, cut, dueTo, insert, peek, queue, rewind } from './changes.js';
-import { closed } from './closed.js';
+import { BOUND, closed } from './closed.js';
+import { closedLch } from './lch.js';
 import { made, pack, prune, reclaim, release, restretch, runAt, runThen, unpack, unrelease, } from './lives.js';
 import { absent, Numbers } from './numbers.js';
 import { reading } from './reading.js';
@@ -16,6 +17,7 @@ const PENDING = 2 /* RunFlag.PENDING */;
 const OLDER = 4 /* RunFlag.OLDER */;
 const LANDED = 8 /* RunFlag.LANDED */;
 const wrongKind = (channel, holdsNumber) => new Error(`blits: channel ${channel} holds ${holdsNumber ? 'a number' : 'an array'}, and this motion patch gives a subject ${holdsNumber ? 'an array' : 'a number'}`);
+const notOklab = (channel) => new Error(`blits: channel ${channel} goes round the hue, and a motion on it moves oklab() values, four numbers each`);
 /**
  * A motion patch's subjects: the stretch each is playing, in one flat array by a number the patch
  * gives it, with earlier stretches a read back may reach and changes not yet applied beside them.
@@ -68,11 +70,18 @@ export class Motions {
     /** Whether the channel it was cued on holds a number; undefined until it is cued. */
     holdsNumber = undefined;
     channel = '';
+    /** Whether the channel it was cued on travels round the hue, as `ink` does, and its stretches too. */
+    round = false;
     /**
      * 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, holdsNumber) {
+    cuedOn(channel, holdsNumber, round = false) {
+        if (round && this.shape.law[0] === BOUND)
+            throw new Error(`blits: channel ${channel} goes round the hue, and a glide's bounds are a box on its OKLab axes; glide it without bounds`);
+        if (round && this.n >= 0 && this.n !== 4)
+            throw notOklab(channel);
         const every = this.shape.scalarEvery();
         if (every !== undefined && every !== holdsNumber)
             throw wrongKind(channel, holdsNumber);
@@ -82,6 +91,7 @@ export class Motions {
                 throw wrongKind(channel, holdsNumber);
         this.holdsNumber = holdsNumber;
         this.channel = channel;
+        this.round = round;
     }
     frame(subject) {
         return this.owner === null ? Number.NaN : this.owner.frame(this.ownerId, subject);
@@ -127,6 +137,8 @@ export class Motions {
     }
     /** Sets the axes every subject moves on, at the first. */
     size(n) {
+        if (this.round && n !== 4)
+            throw notOklab(this.channel);
         this.n = n;
         this.stride = 3 + 3 * n;
         if (shared.xs.length < n)
@@ -426,6 +438,8 @@ export class Motions {
         this.evaluate(seg.at, seg.ms, seg.x0, 0, seg.v0, 0, seg.to, 0, t, xo, vo);
     }
     evaluate(at, ms, x0, x, v0, v, to, g, t, xo, vo) {
+        if (this.round)
+            return closedLch(this.runs, this.shape.ease, at, ms, x0, x, v0, v, to, g, t, xo, vo);
         return closed(this.runs, this.shape.ease, this.n, at, ms, x0, x, v0, v, to, g, t, xo, vo);
     }
 }