@msb235/blits 0.15.0 → 0.16.0

package/dist/held.js

@@ -1,7 +1,7 @@
 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';
@@ -23,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;
     }
@@ -50,7 +50,7 @@ export function held(voice, subject, slot, guess = null) {
         voice.keyed ??= new Set();
         voice.keyed.add(this.keys.key(subject));
     }
-    const delay = voice.spec.stagger ? voice.spec.stagger(subject) : 0;
+    const delay = delayOf(voice, subject);
     const since = this.sinceOf(voice, delay);
     const shown = this.shownOf(voice, since);
     held = record(voice, true, voice.patch.state ? voice.patch.state(subject) : undefined);
@@ -66,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';
@@ -20,7 +20,7 @@ export { fold } from './stack.js';
 export type { Ticked, Ticker, TickerOptions } from './ticker.js';
 export { ticker } from './ticker.js';
 export { transport } from './transport.js';
-export type { Anchor, AnnounceOptions, ArcHandle, ArcPart, ArcSpec, ArcVoice, Band, BlendMember, BookedHit, Booker, BookOptions, Channel, Circle, Columns, Described, Doubt, Easing, Engine, FadeOptions, FadeSpec, Finder, FitResult, GlideSpec, Handle, HistoryOptions, HistoryStore, Hit, Hold, Keyframe, Kit, Mark, Marked, MarkName, Mix, MixOptions, MotionSpec, OwnerSpec, Paged, PagedStream, Patch, Placement, Probed, Projection, Pulled, Query, Registry, RegistryChange, SeekOptions, Sent, Setting, Signal, SpanHandle, SpanHints, SpanSpec, SpringSpec, SubjectFade, Taken, Tape, TapeBranch, TapeMaker, TapeOp, TapeOptions, Transport, TransportOptions, TransportProjection, TweenSpec, VoiceFade, VoiceSpec, Watched, WatchedFrame, WatchedHistory, WatchedVoice, } from './types.js';
+export type { Anchor, AnnounceOptions, ArcHandle, ArcPart, ArcSpec, ArcVoice, Band, BlendMember, BookedHit, Booker, BookOptions, Channel, Circle, Columns, Described, Doubt, Easing, Engine, FadeOptions, FadeSpec, Finder, FitResult, GlideSpec, Handle, HistoryOptions, HistoryStore, Hit, Hold, Keyframe, Kit, Mark, Marked, MarkName, Mix, MixOptions, MotionSpec, NumberChannel, OwnerSpec, Paged, PagedStream, Patch, Placement, Probed, Projection, Pulled, Query, Registry, RegistryChange, Run, SeekOptions, Sent, Setting, Signal, SpanHandle, SpanHints, SpanSpec, SpringSpec, SubjectFade, Taken, Tape, TapeBranch, TapeMaker, TapeOp, TapeOptions, Trace, TraceOptions, Transport, TransportOptions, TransportProjection, TweenSpec, VoiceFade, VoiceSpec, Watched, WatchedFrame, WatchedHistory, WatchedVoice, } from './types.js';
 export { watched } from './watch.js';
 export type { WaveOptions, WaveShape } from './wave.js';
 export { wave, waveAt } from './wave.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/lane.d.ts

@@ -260,11 +260,8 @@ export declare class Lane<I, O> implements Positions<I, O> {
     reserve(n: number, cap: number): void;
     /** Gives a subject the voice reaches a position, from what its record fixed on first sight. */
     add(slot: number, held: Subject<unknown>): void;
+    /** The subject numbered `from` is numbered `to` now, a number no position holds: same position. */
+    renumber(from: number, to: number): void;
     /** A subject lost its number: the last position moves into its place. */
     remove(slot: number): void;
 }
-/**
- * A subject's voice time once its voice's freezes apply: frozen at 0 before it starts and at the end
- * of its passes after, and NaN where it shows nothing, as past its end running back.
- */
-export declare function frozenAt<I, O>(voice: Voice<I, O>, elapsed: number): number;

package/dist/lane.js

@@ -1,5 +1,4 @@
 import { unbareLane } from './bare.js';
-import { frozenTime } from './clock.js';
 import { motionOf } from './motion.js';
 /**
  * Keeps the weight a probe read from the last fill as `Row.PROBED`, for `weightOf`, before a fill
@@ -185,6 +184,20 @@ export class Lane {
         this.records[p] = held;
         this.deltas[p] = null;
     }
+    /** The subject numbered `from` is numbered `to` now, a number no position holds: same position. */
+    renumber(from, to) {
+        const p = this.positionOf(from);
+        if (p < 0)
+            return;
+        if (to >= this.at.length) {
+            const at = new Int32Array(Math.max(to + 1, this.at.length * 2, 64));
+            at.set(this.at);
+            this.at = at;
+        }
+        this.list[p] = to;
+        this.at[to] = p + 1;
+        this.at[from] = 0;
+    }
     /** A subject lost its number: the last position moves into its place. */
     remove(slot) {
         const p = this.positionOf(slot);
@@ -214,12 +227,3 @@ export class Lane {
         this.deltas[last] = null;
     }
 }
-/**
- * A subject's voice time once its voice's freezes apply: frozen at 0 before it starts and at the end
- * of its passes after, and NaN where it shows nothing, as past its end running back.
- */
-export function frozenAt(voice, elapsed) {
-    if (elapsed > voice.span && voice.hidesPast)
-        return Number.NaN;
-    return frozenTime(elapsed, voice.freezesBefore, voice.freezesAfter, voice.span);
-}

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,9 @@ 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';
 import type { Channel } from './types.js';
@@ -63,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. */
@@ -70,7 +96,7 @@ export declare class Lanes<I, O> implements Watcher {
     readonly byId: Map<number, Lane<I, O>>;
     /** The crowds of single-subject voices, one per list of channels, and which holds each voice. */
     crowds: Crowd<I, O>[];
-    readonly crowdOf: Map<number, Crowd<I, O>>;
+    readonly seats: Map<number, Seat<I, O>>;
     /** Which crowd voices' rows are placed on each subject. */
     readonly placed: Placed;
     /**
@@ -161,14 +187,16 @@ export declare class Lanes<I, O> implements Watcher {
      */
     readonly late: number[];
     /**
-     * What `writeLater` and `pullRun` have queued, for one set of columns, as runs: each run's first
-     * lane slot, the row it goes to, and how many subjects follow both one apart.
+     * What `writeLater` and `pullRun` have queued, for one set of columns, as runs of rows: each
+     * run's first row and how many follow, and its first lane slot where its slots follow one apart
+     * too, else -1, when each row's slot is read from `queueFrom` by row.
      */
     queueSlots: Int32Array<ArrayBuffer>;
     queueRows: Int32Array<ArrayBuffer>;
     queueCounts: Int32Array<ArrayBuffer>;
     queued: number;
     queuedFor: readonly Column[] | null;
+    queueFrom: Int32Array | null;
     keeps: boolean;
     now: number;
     filledAt: number;
@@ -285,7 +313,7 @@ export declare class Lanes<I, O> implements Watcher {
     /** A voice's clock moved the `shown` of records it had already placed: copies them again. */
     reshown(id: number): void;
     /** Something on a voice changed: a crowd copies it again at the next fill. */
-    voiceChanged(id: number): void;
+    voiceChanged(voice: Voice<I, O>): void;
 }
 declare const methods: {
     copy: typeof copy;

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,7 +11,9 @@ 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';
 /**
  * The lanes of one mix: subject numbers, which channels and voices run on lanes, and the values a
  * frame's fill leaves for probes to copy.
@@ -17,6 +21,10 @@ import { reportedRow, unplace } from './rows.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. */
@@ -24,7 +32,7 @@ export class Lanes {
     byId = new Map();
     /** The crowds of single-subject voices, one per list of channels, and which holds each voice. */
     crowds = [];
-    crowdOf = new Map();
+    seats = new Map();
     /** Which crowd voices' rows are placed on each subject. */
     placed = new Placed();
     /**
@@ -115,14 +123,16 @@ export class Lanes {
      */
     late = [];
     /**
-     * What `writeLater` and `pullRun` have queued, for one set of columns, as runs: each run's first
-     * lane slot, the row it goes to, and how many subjects follow both one apart.
+     * What `writeLater` and `pullRun` have queued, for one set of columns, as runs of rows: each
+     * run's first row and how many follow, and its first lane slot where its slots follow one apart
+     * too, else -1, when each row's slot is read from `queueFrom` by row.
      */
     queueSlots = new Int32Array(0);
     queueRows = new Int32Array(0);
     queueCounts = new Int32Array(0);
     queued = 0;
     queuedFor = null;
+    queueFrom = null;
     keeps = false;
     now = Number.NaN;
     filledAt = Number.NaN;
@@ -233,10 +243,9 @@ export class Lanes {
             lane.remove(slot);
             return;
         }
-        const c = this.crowdOf.get(id);
-        const p = c?.rowOf.get(id);
-        if (c !== undefined && p !== undefined && c.list[p] === slot)
-            unplace(this, c, p);
+        const s = this.seats.get(id);
+        if (s !== undefined && s.crowd.list[s.row] === slot)
+            unplace(this, s.crowd, s.row);
     }
     /** A voice brought a subject back: its next probe meets every lane again, as it met them first. */
     rejoin(slot) {
@@ -254,9 +263,8 @@ export class Lanes {
         const lane = this.byId.get(id);
         if (lane !== undefined)
             return this.reported(lane, slot);
-        const c = this.crowdOf.get(id);
-        const p = c?.rowOf.get(id);
-        return c === undefined || p === undefined ? undefined : reportedRow(this, c, p, slot);
+        const s = this.seats.get(id);
+        return s === undefined ? undefined : reportedRow(this, s.crowd, s.row, slot);
     }
     reported(lane, slot) {
         const o = slot * 6 /* Per.SLOT */;
@@ -439,10 +447,9 @@ export class Lanes {
             lane.remove(slot);
         const placed = this.placed;
         for (let id = placed.any(slot); id !== 0; id = placed.any(slot)) {
-            const c = this.crowdOf.get(id);
-            const p = c?.rowOf.get(id);
-            if (c !== undefined && p !== undefined && c.list[p] === slot)
-                unplace(this, c, p);
+            const s = this.seats.get(id);
+            if (s !== undefined && s.crowd.list[s.row] === slot)
+                unplace(this, s.crowd, s.row);
             else
                 placed.remove(slot, id);
         }
@@ -474,10 +481,10 @@ export class Lanes {
      * next fill, and a lane keeps the sample the old one gave.
      */
     stretchChanged(id, s) {
-        const c = this.crowdOf.get(id);
-        const p = c?.rowOf.get(id);
-        if (c !== undefined && p !== undefined) {
-            c.restale(p, c.hot[p * c.stride + 0 /* Hot.FLAGS */]);
+        const seat = this.seats.get(id);
+        if (seat !== undefined) {
+            const c = seat.crowd;
+            c.restale(seat.row, c.hot[seat.row * c.stride + 0 /* Hot.FLAGS */]);
             return;
         }
         const lane = this.byId.get(id);
@@ -502,12 +509,11 @@ export class Lanes {
     }
     /** A voice's clock moved the `shown` of records it had already placed: copies them again. */
     reshown(id) {
-        const c = this.crowdOf.get(id);
-        const p = c?.rowOf.get(id);
-        if (c !== undefined && p !== undefined) {
-            const held = c.records[p];
+        const s = this.seats.get(id);
+        if (s !== undefined) {
+            const held = s.crowd.records[s.row];
             if (held !== undefined)
-                c.data[p * 8 /* Row.STRIDE */ + 1 /* Row.SINCE */] = held.shown;
+                s.crowd.data[s.row * 8 /* Row.STRIDE */ + 1 /* Row.SINCE */] = held.shown;
         }
         const lane = this.byId.get(id);
         if (lane === undefined)
@@ -519,12 +525,12 @@ export class Lanes {
         }
     }
     /** Something on a voice changed: a crowd copies it again at the next fill. */
-    voiceChanged(id) {
-        const c = this.crowdOf.get(id);
-        const p = c?.rowOf.get(id);
-        if (c === undefined || p === undefined)
+    voiceChanged(voice) {
+        const s = seatOf(this, voice);
+        if (s === null)
             return;
-        const f = p * c.stride + 0 /* Hot.FLAGS */;
+        const c = s.crowd;
+        const f = s.row * c.stride + 0 /* Hot.FLAGS */;
         c.hot[f] = c.hot[f] | 64 /* Flag.VOICE */;
     }
 }

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

@@ -1,4 +1,5 @@
 import { open, shut } from './everyone.js';
+import { seatOf } from './seat.js';
 /**
  * Whether the lanes a probe of the subject at `slot` just met (`met`) can be folded on the general
  * path after the lanes' values: none is in a role or a crowd, the subject owes none already this
@@ -183,10 +184,11 @@ function foldNow(lanes, slot, subject, again) {
 }
 /** Places a crowd voice's row on the subject a probe met, as `Lane.add` adds a position. */
 function place(lanes, voice, slot, subject, from, head) {
-    const c = lanes.crowdOf.get(voice.id);
-    const p = c?.rowOf.get(voice.id);
-    if (c === undefined || p === undefined)
+    const s = seatOf(lanes, voice);
+    if (s === null)
         return false;
+    const c = s.crowd;
+    const p = s.row;
     const h = p * c.stride;
     const flags = c.hot[h + 0 /* Hot.FLAGS */];
     if (c.hot[h + 6 /* Hot.EPOCH */] <= from || (flags & 16 /* Flag.PLACED */) !== 0)

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';
@@ -32,7 +33,7 @@ import { Store } from './store.js';
 import type { MotionOwner } from './stretch.js';
 import type { Subject } from './subject.js';
 import { type Announced, Transport } from './transport.js';
-import type { ArcHandle, ArcSpec, BlendMember, Booker, BookOptions, Channel, Columns, Engine, Handle, Kit, Marked, Mix, MixOptions, OwnerSpec, Patch, Projection, Sent, Signal, SpanHandle, SpanSpec, Tape, VoiceSpec } from './types.js';
+import type { ArcHandle, ArcSpec, BlendMember, Booker, BookOptions, Channel, Columns, Engine, Handle, Kit, Marked, Mix, MixOptions, OwnerSpec, Patch, Projection, Sent, Signal, SpanHandle, SpanSpec, Tape, Trace, TraceOptions, VoiceSpec } from './types.js';
 import { type Voice } from './voice.js';
 import { base, capped, fadeOf, horizonFor, ownedBy, ownerBase, prime, primeLaned, weigh, weighOwned } from './weigh.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;
@@ -266,6 +269,7 @@ export declare class Mixer<I, O> implements Mix<I, O> {
     project(at: number | {
         readonly frame: number;
     }): Projection<I, O>;
+    trace(from: number, to: number, opts?: TraceOptions): Trace<I, O>;
     announce(name: string, opts?: {
         at?: number;
         score?: string;