@msb235/blits 0.14.0 → 0.15.1

package/dist/mixer.js

@@ -1,35 +1,43 @@
 import { cueArc } from './arcs.js';
+import { around } from './around.js';
+import { blanks } from './blank.js';
 import { blended, blendOf, laneRead, shareKept } from './blend.js';
-import { aims, chain, headOf, linkable, relink, unlink } from './chain.js';
+import { aims, chain, linkable, relink } from './chain.js';
 import { lerpInto, STOCK_BAND, scalarOp } from './channels.js';
-import { cue } from './cue.js';
+import { baseFor, contribution, isRest, keyed, read, slopeFor, tick } from './contribution.js';
+import { cue, roleTags } from './cue.js';
 import { DepartedIndex } from './departed.js';
-import { beginFade, leaveVoice, parting } from './fade.js';
-import { apply, baseFor, clamp, contribution, fold, foldDetour, folded, foldLoci, foldSharers, foldWith, isRest, keyed, linked, near, owedBy, passes, read, shared, slopeFor, tick, } from './fold.js';
-import { GoneIndex, goneIndex } from './gone.js';
+import { drop, forgetIn, recordDrop, releaseIn } from './drop.js';
+import { DueQueue } from './due.js';
+import { beginFade, parting } from './fade.js';
+import { apply, clamp, fold, foldDetour, folded, foldSharers, foldWith, linked, owedBy, passes, shared, } from './fold.js';
+import { GoneIndex } from './gone.js';
 import { held, shownOf, sinceOf, unreachedOf } from './held.js';
-import { releasing } from './history.js';
 import { book, laneHost } from './hosts.js';
 import { Lanes } from './lanes.js';
-import { foldLocus } from './locus.js';
 import { listed } from './marks.js';
 import { nextFrame } from './move.js';
 import { ownerPatch } from './owner.js';
 import { Keys } from './paging.js';
+import { moved, place, plot, put } from './plot.js';
 import { projectAll } from './project.js';
 import { keep, pull } from './pull.js';
 import { Steps } from './relink.js';
+import { atRest, restful, rests, restsKey, restsLaned, still } from './rests.js';
 import { Outs } from './revive.js';
+import { foldRole } from './role.js';
+import { foldRoles } from './roles.js';
 import { ScoreIndex } from './scored.js';
 import { seek } from './seek.js';
 import { Fitting, refit } from './spans.js';
-import { Masked, Store } from './store.js';
-import { record, unplayable } from './tape.js';
+import { Store } from './store.js';
+import { record } from './tape.js';
 import { touch } from './touch.js';
+import { traceMix } from './trace.js';
 import { announce, Transport } from './transport.js';
 import { none } from './voice.js';
 import { gave, historyFor, register, unregister } from './watch.js';
-import { base, capped, fadeOf, horizonFor, ownedBy, ownerBase, prime, weigh, weighOwned, } from './weigh.js';
+import { base, capped, fadeOf, horizonFor, ownedBy, ownerBase, prime, primeLaned, weigh, weighOwned, } from './weigh.js';
 /**
  * What a mix takes where its options say nothing. Not exported from the package: the suite turns
  * `lanes` off to run every test on the general path, which is what makes each one an equivalence check.
@@ -63,7 +71,7 @@ export class Mixer {
     hostLog = [];
     hostThen;
     /** Each subject's last two poses and when they were probed, for `from: 'current'`. */
-    pose = new Store();
+    lastPoses = new Store();
     /** The clock this mix plays on, which also holds its tape and the marks announced on it. */
     transport;
     /** Its place among the mixes on its transport, in the order they joined. */
@@ -82,7 +90,7 @@ export class Mixer {
     /** The pose `pull` folds a subject into where it cannot read straight from the lanes. */
     scratch;
     /** Live voices by the earliest mix time `moveTo` would change each, a binary heap. */
-    due = [];
+    due = new DueQueue();
     /** Voices retired since `moveTo` last pruned them, in the order they retired. */
     retired = [];
     /** Visit every voice each sync, as before the due queue; for tests that compare the two. */
@@ -151,6 +159,8 @@ export class Mixer {
      */
     chains = new Store();
     version = 0;
+    /** The positions `plot` gave, which a voice's `within` reads: see `bound.ts`. */
+    places = null;
     /** What `prime` reads its clock, voice time and pass from: see `Primed`. */
     primed = new Float64Array(3 /* Primed.SIZE */);
     steps = new Steps();
@@ -182,8 +192,10 @@ export class Mixer {
     unshared = false;
     /** 0 where a fold is a walk of the chain: see `detour` in `everyone.ts`. */
     detours = 0;
-    /** How many voices in the list carry a locus; with none, a fold allocates nothing. */
-    loci = 0;
+    /** How many voices in the list carry a role; with none, a fold allocates nothing. */
+    roleVoices = 0;
+    /** The tags the mix's options declare roles. */
+    roleTags;
     /** What every motion patch it plays asks for its voice's time, holding this mix weakly. */
     owner = null;
     /** How many voices in the list are anchored, so a sync with none skips placing them. */
@@ -218,9 +230,9 @@ export class Mixer {
     lerpsInto;
     /** By slot, a stock scalar channel's arithmetic, which a fold applies without calling the channel. */
     scalars;
-    /** What a fold with a locus in play gathers into, one per depth of folds under way. */
-    locusScratch = [];
-    locusDepth = 0;
+    /** What a fold with a role in play gathers into, one per depth of folds under way. */
+    roleScratch = [];
+    roleDepth = 0;
     slotOf = new Map();
     lanes;
     handles = null;
@@ -236,6 +248,7 @@ export class Mixer {
     keys = null;
     /** With a history store, the voices it paged out whose handles are still held; null without one. */
     outs = null;
+    pose;
     constructor(kit, opts, 
     /** The lanes an entry was built with; null in one that leaves them out. */
     lanesOf) {
@@ -246,6 +259,7 @@ export class Mixer {
         this.channels = this.names.map((k) => kit[k]);
         this.bounded = this.channels.flatMap((c, i) => (c.bounds ? [i] : []));
         this.lerpsInto = this.channels.map((c) => lerpInto(c));
+        this.pose = blanks(this.names, this.channels);
         this.scalars = this.channels.map((c) => scalarOp(c));
         this.names.forEach((k, i) => {
             this.slotOf.set(k, i);
@@ -255,6 +269,7 @@ export class Mixer {
         this.lanes =
             lanesOf !== null && (opts.lanes ?? defaults.lanes) ? new lanesOf(laneHost(this)) : null;
         this.name = opts.name;
+        this.roleTags = roleTags(opts);
         const shared = opts.transport;
         if (shared !== undefined) {
             if (opts.history !== undefined)
@@ -345,14 +360,14 @@ export class Mixer {
         return cue(this, spec);
     }
     blend(members, by, spec = {}) {
-        const locus = `blend:${this.nextId}`;
+        const role = `blend:${this.nextId}`;
         const of = blendOf(by, members.length - 1);
         return members.map((member, i) => {
             const own = {
                 ...spec,
                 patch: member,
                 weight: by,
-                locus,
+                role,
             };
             if ('patch' in member) {
                 own.patch = member.patch;
@@ -421,6 +436,9 @@ export class Mixer {
     project(at) {
         return projectAll(this.transport, at).of(this);
     }
+    trace(from, to, opts) {
+        return traceMix(this, from, to, opts);
+    }
     announce(name, opts = {}) {
         this.attached();
         announce(this.transport, name, opts, this.slot, this.name);
@@ -433,38 +451,6 @@ export class Mixer {
     marks(from, to) {
         return listed(this, from, to).map(({ order: _, ...m }) => m);
     }
-    atRest(subject) {
-        this.restStamps ??= new Store();
-        const head = this.linked(subject);
-        const laned = this.linkedLaned;
-        const lanes = this.lanes;
-        // Every voice on lanes and nothing to clamp: the pose a fold would make is the lanes' values.
-        if (laned && this.restsLaned()) {
-            const slot = head.slot;
-            if (!lanes.owes(slot))
-                return lanes.rests(slot);
-        }
-        // A probe this frame answers for the pose it gave the host.
-        const since = (this.restStamps.get(subject) ?? Number.NaN) - 2 * this.restsKey();
-        if (since >= 0)
-            return since === 1;
-        this.restScratch ??= {};
-        const pose = this.foldWith(subject, this.restScratch, head, laned, true);
-        return this.rests((this.bounded.length === 0 ? pose : this.clamp(pose)));
-    }
-    rests(pose) {
-        for (let i = 0; i < this.names.length; i++) {
-            const channel = this.channels[i];
-            const value = pose[this.names[i]];
-            if (channel.rest === undefined) {
-                if (value !== undefined)
-                    return false;
-            }
-            else if (!near(value, channel.rest))
-                return false;
-        }
-        return true;
-    }
     rebase() {
         this.own('rebase').rebase();
     }
@@ -486,16 +472,6 @@ export class Mixer {
             this.asleep = true;
         return inert;
     }
-    restful() {
-        // Standing still, a voice changes no pose but by its weight signal, or by an anchor or start
-        // that host time may yet reach.
-        if (this.pace?.stopped(this.u))
-            return this.cued.every((v) => v.state === 'done' ||
-                (v.state !== 'pending' &&
-                    typeof v.spec.weight !== 'function' &&
-                    v.spec.anchor === undefined));
-        return this.cued.every((v) => this.still(v, this.now));
-    }
     get rate() {
         return this.transport.rate;
     }
@@ -505,22 +481,6 @@ export class Mixer {
     ramp(rate, over) {
         this.own('ramp').ramp(rate, over);
     }
-    /** Whether a voice will change no pose from `now` on, short of a change made to it. */
-    still(voice, now) {
-        if (voice.state === 'done')
-            return true;
-        if (voice.state !== 'frozen' && voice.state !== 'live')
-            return false;
-        if (typeof voice.spec.weight === 'function' || voice.parts !== null)
-            return false;
-        const fadeIn = this.reducedNow ? 0 : (voice.fade.in ?? 0);
-        if (fadeIn > 0 && now - this.sinceOf(voice, voice.latest) < fadeIn)
-            return false;
-        if (voice.state === 'frozen' || voice.holding !== null)
-            return true;
-        const motion = voice.motion;
-        return motion !== undefined && voice.elapsedAt(now) >= voice.latest && motion.landed();
-    }
     close() {
         unregister(this);
     }
@@ -531,80 +491,6 @@ export class Mixer {
         }
         record(this, 'mute', (stage) => stage.mix(this)?.mute(opts));
     }
-    drop(subject) {
-        this.frame = nextFrame();
-        const head = headOf(this, subject);
-        // Nothing that kept this head, such as `pull`'s remembered list, may take it as current again.
-        if (head !== undefined)
-            unlink(this, head);
-        // A number a seek carried over is released even where its chain is not linked since.
-        const slot = this.chains.get(subject)?.slot ?? -1;
-        if (slot >= 0 && this.lanes !== null)
-            this.lanes.release(slot);
-        // A read ahead's copy reads the live mix's poses, and so hides one where the mix deletes it.
-        if (this.projecting && !(this.pose instanceof Masked))
-            this.pose = new Masked(this.pose);
-        this.pose.delete(subject);
-        this.restStamps?.delete(subject);
-        this.chains.delete(subject);
-        this.stir();
-        // A record of it is only in a voice over every subject, one naming it, or one gone; a ramp out
-        // of a voice that does not name it is in `parters`, and a patch's own state in `motions`.
-        const kept = releasing(this);
-        for (const voice of this.general)
-            this.forgetIn(voice, subject, kept);
-        const named = this.named.get(subject);
-        if (named !== undefined)
-            for (const voice of [...named])
-                this.forgetIn(voice, subject, kept);
-        const gone = goneIndex(this);
-        for (const voice of gone.general)
-            this.forgetIn(voice, subject, kept);
-        const goneNaming = gone.named.get(subject);
-        if (goneNaming !== undefined)
-            for (const voice of goneNaming)
-                this.forgetIn(voice, subject, kept);
-        if (this.owners !== null)
-            for (const voice of this.owners)
-                this.forgetIn(voice, subject, kept);
-        for (const voice of this.parters) {
-            this.forgetIn(voice, subject, kept);
-            if (voice.parts?.size === 0)
-                voice.parts = null;
-            if (voice.parted?.size === 0)
-                voice.parted = null;
-            if (voice.parts === null && voice.parted === null)
-                this.parters.delete(voice);
-        }
-        const strays = this.strays.get(subject);
-        if (strays !== undefined)
-            for (const motion of strays)
-                this.releaseIn(motion, subject, kept);
-        this.strays.delete(subject);
-        for (const motion of this.strayAll)
-            this.releaseIn(motion, subject, kept);
-        this.recordDrop(subject);
-    }
-    /** Lets `voice` go of a dropped subject. Methods rather than closures, so a drop makes neither. */
-    forgetIn(voice, subject, kept) {
-        leaveVoice(this, voice, subject);
-        voice.subjects.delete(subject);
-        if (voice.motion !== undefined)
-            this.releaseIn(voice.motion, subject, kept);
-        voice.parts?.delete(subject);
-        voice.parted?.delete(subject);
-        voice.blend?.of.reads.delete(subject);
-    }
-    // A motion patch's state is the live mix's alone: a read ahead cannot start a subject afresh in it.
-    releaseIn(motion, subject, kept) {
-        if (!this.projecting)
-            motion.release(subject, kept[0], kept[1], kept[2]);
-        else if (motion.holds(subject))
-            unplayable('a drop of a subject a motion patch holds');
-    }
-    recordDrop(subject) {
-        record(this, 'drop', (stage) => stage.mix(this)?.drop(subject));
-    }
     touch(subject) {
         this.attached();
         touch(this, subject);
@@ -641,22 +527,6 @@ export class Mixer {
     restsStirs = -1;
     /** The pose `atRest` folds into where no probe this frame answers. */
     restScratch;
-    restsLaned() {
-        return this.lanes.whole && this.bounded.length === 0;
-    }
-    restsKey() {
-        if (this.frame !== this.restsFrame ||
-            this.version !== this.restsVersion ||
-            this.relinks !== this.restsRelinks ||
-            this.stirs !== this.restsStirs) {
-            this.restsEpoch++;
-            this.restsFrame = this.frame;
-            this.restsVersion = this.version;
-            this.restsRelinks = this.relinks;
-            this.restsStirs = this.stirs;
-        }
-        return this.restsEpoch;
-    }
 }
 // The probe's hot path is methods, installed here from the modules that own them: as functions
 // called directly they made probes and fills up to 9% slower (bench/ab.sh on teitou, 2026-10-05).
@@ -666,7 +536,7 @@ const methods = {
     linked,
     foldWith,
     owedBy,
-    foldLoci,
+    foldRoles,
     foldDetour,
     foldSharers,
     shared,
@@ -681,6 +551,7 @@ const methods = {
     baseFor,
     slopeFor,
     prime,
+    primeLaned,
     capped,
     horizonFor,
     weigh,
@@ -702,7 +573,22 @@ const methods = {
     sinceOf,
     shownOf,
     keep,
-    foldLocus,
+    foldRole,
+    atRest,
+    rests,
+    restful,
+    still,
+    restsLaned,
+    restsKey,
+    plot,
+    place,
+    moved,
+    put,
+    around,
+    drop,
+    forgetIn,
+    releaseIn,
+    recordDrop,
 };
 for (const [name, value] of Object.entries(methods))
     Object.defineProperty(Mixer.prototype, name, { value, writable: true, configurable: true });
@@ -724,7 +610,7 @@ export function made(kit, opts, lanes) {
     return m;
 }
 /**
- * The one that ships: every form on the CPU, probed per subject on demand.
+ * The engine that ships, running every form on the CPU. It probes per subject on demand.
  *
  * @category engine
  */
@@ -736,7 +622,7 @@ export const mixer = {
     },
 };
 /**
- * Makes a mix over a kit, on the engine the options name or the stock one.
+ * Makes a mix over a kit. It runs on the engine the options name, or the stock one.
  *
  * @category mix
  */

package/dist/motion.d.ts

@@ -1,69 +1,11 @@
 import { Motions } from './motions.js';
-import type { Easing, Patch } from './types.js';
-/**
- * A number, or one number per axis.
- *
- * @category patch
- */
-export type Value = number | readonly number[];
-/**
- * One value for every subject, or one per subject.
- *
- * @category patch
- */
-export type PerSubject<I, V> = V | ((subject: I) => V);
-/**
- * Where a subject is and how fast it is moving, at one moment of voice time.
- *
- * @category patch
- */
-export interface Motion<V extends Value = number> {
-    value: V;
-    /** Units per second. */
-    velocity: V;
-}
-/**
- * A patch whose motion is a closed form per subject, so it lands in the same place at any frame
- * rate, and whose changes mid-flight start from where the subject is and how fast it moves.
- *
- * @category patch
- */
-export type Moving<I, O, V extends Value> = Patch<I, O, void> & {
-    /**
-     * Where `subject` is and how fast it moves at voice time `at`, default the mix's latest frame,
-     * counting every change due by then. With no time given, undefined until a frame of its voice
-     * has met the subject, while the subject is still inside its stagger, and once that voice is gone.
-     * At any time, undefined for a subject the patch has never met or changed, or that the mix
-     * dropped.
-     */
-    read(subject: I, at?: number): Motion<V> | undefined;
-    /**
-     * Sets `subject` moving at `velocity`, units per second, from voice time `at`, default the mix's
-     * latest frame; for a subject no frame of its voice has met yet, or still inside its stagger, its
-     * first read, after any change with a time due by then. A subject faded out of the voice comes
-     * back at the latest frame too, however long it is before it is next read.
-     */
-    push(subject: I, velocity: V, at?: number): void;
-    /**
-     * Puts `subject` at `value` from voice time `at`, keeping its velocity, with `at` defaulting as
-     * `push`'s does: a spring or tween heads for its target from there, a glide coasts on from there.
-     */
-    set(subject: I, value: V, at?: number): void;
-};
+import type { Glide, GlideOptions, Spring, SpringOptions, Tween, TweenOptions, Value } from './types/motion.js';
+export type { Glide, GlideOptions, Motion, MotionOptions, Moving, PerSubject, Spring, SpringOptions, Tween, TweenOptions, Value, } from './types/motion.js';
 /**
  * The state behind a `'motion'` patch, for an engine that reads it directly; a patch another copy
  * of the same release made counts.
  */
 export declare function motionOf<I>(p: object): Motions<I> | undefined;
-interface Common<I, V extends Value> {
-    /** Units per second each subject starts moving at. Default 0. */
-    velocity?: PerSubject<I, V>;
-    /**
-     * Within this distance of where it heads, and this slow, a subject lands there exactly, so a mix
-     * can see it at rest. Default 1e-4; 0 keeps the curve exact.
-     */
-    settle?: number;
-}
 /**
  * A damped spring toward a target, solved in closed form. `to(subject, target)` retargets one
  * subject mid-flight, and the new stretch starts from where it is and how fast it moves, so there is
@@ -72,28 +14,12 @@ interface Common<I, V extends Value> {
  *
  * @category patch
  */
-export declare function spring<I, O, V extends Value = number>(writes: keyof O, opts: Common<I, V> & {
-    to: PerSubject<I, V>;
-    /** Where each subject starts. Default: `to`, at rest. */
-    from?: PerSubject<I, V>;
-    /** Per second squared. Default 170. */
-    stiffness?: number;
-    /** Per second. Default 26, just short of critical at the default stiffness. */
-    damping?: number;
-    mass?: number;
-}): Moving<I, O, V> & {
-    /**
-     * Heads `subject` for `target` from voice time `at`, keeping its velocity: by default the mix's
-     * latest frame, or for a subject no frame of its voice has met yet, or still inside its stagger,
-     * its first read, after any change with a time due by then. A subject faded out of the voice
-     * comes back at the latest frame too, however long it is before it is next read.
-     */
-    to(subject: I, target: V, at?: number): void;
-};
+export declare function spring<I, O, V extends Value = number>(writes: keyof O, opts: SpringOptions<I, V>): Spring<I, O, V>;
 /**
- * Coasting under friction, a fling: a subject keeps its velocity, which falls by a factor of e every
- * `ms`, and comes to rest `velocity · ms / 1000` past where it was released. `push` sets it moving
- * again from wherever it is. Closed form, so frame rate does not change where it stops.
+ * A patch that coasts each subject to a stop under friction, as after a fling. A subject keeps its
+ * velocity, which falls by a factor of e every `ms`, and comes to rest `velocity · ms / 1000` past
+ * where it was released. `push` sets it moving again from wherever it is. Closed form, so frame
+ * rate does not change where it stops.
  *
  * With `bounds`, a coast that would stop past an edge springs back to it from where it crosses, at
  * the speed it crosses at, on a critically damped spring of `stiffness`; one let go past an edge
@@ -102,44 +28,14 @@ export declare function spring<I, O, V extends Value = number>(writes: keyof O,
  *
  * @category patch
  */
-export declare function glide<I, O, V extends Value = number>(writes: keyof O, opts: Common<I, V> & {
-    /** Where each subject starts. */
-    from: PerSubject<I, V>;
-    /** The friction's time constant, ms. Default 325, a touch scroll's. */
-    ms?: number;
-    /** The least and greatest value a coast comes to rest at, per axis. Default none. */
-    bounds?: PerSubject<I, readonly [min: V, max: V]>;
-    /** The spring back's, per second squared, with `bounds`. Default 170, as a spring's. */
-    stiffness?: number;
-}): Moving<I, O, V> & {
-    /** `subject`'s bounds, undefined for a glide without them. */
-    bounds(subject: I): readonly [min: V, max: V] | undefined;
-};
+export declare function glide<I, O, V extends Value = number>(writes: keyof O, opts: GlideOptions<I, V>): Glide<I, O, V>;
 /**
- * From one value to another over `ms` along an easing, solved in closed form, so frame rate does not
- * change where a subject is. `to(subject, target)` retargets one subject mid-flight: the new stretch
- * starts from where it is and takes the full `ms` again, so its velocity jumps where a spring's
- * would not. Time is the voice's, so `rate` and `seek` apply, and a voice's `loop` does not repeat
- * it. Cue each tween on one voice. Every subject moves on the same number of axes.
+ * From one value to another over `ms` along an easing. Solved in closed form, so frame rate does
+ * not change where a subject is. `to(subject, target)` retargets one subject mid-flight: the new
+ * stretch starts from where it is and takes the full `ms` again, so its velocity jumps where a
+ * spring's would not. Time is the voice's, so `rate` and `seek` apply, and a voice's `loop` does
+ * not repeat it. Cue each tween on one voice. Every subject moves on the same number of axes.
  *
  * @category patch
  */
-export declare function tween<I, O, V extends Value = number>(writes: keyof O, opts: {
-    /** Where each subject starts. */
-    from: PerSubject<I, V>;
-    /** Where each subject ends. */
-    to: PerSubject<I, V>;
-    /** How long a stretch takes, ms: asked per subject each time one of its stretches starts. */
-    ms: PerSubject<I, number>;
-    /** The curve from `from` to `to`. Default `'ease'`, as CSS's. */
-    ease?: Easing;
-}): Omit<Moving<I, O, V>, 'push'> & {
-    /**
-     * Heads `subject` for `target` from voice time `at`, over a full `ms` from where it is: by default
-     * the mix's latest frame, or for a subject no frame of its voice has met yet, or still inside its
-     * stagger, its first read, after any change with a time due by then. A subject faded out of the
-     * voice comes back at the latest frame too, however long it is before it is next read.
-     */
-    to(subject: I, target: V, at?: number): void;
-};
-export {};
+export declare function tween<I, O, V extends Value = number>(writes: keyof O, opts: TweenOptions<I, V>): Tween<I, O, V>;

package/dist/motion.js

@@ -1,7 +1,9 @@
 import { BOUND, COAST, CRITICAL, EASED, OVER, UNDER } from './closed.js';
 import { curve } from './easing.js';
 import { Motions } from './motions.js';
+import { reading } from './reading.js';
 import { release } from './shared.js';
+import { sampleThen } from './then.js';
 const axes = (v) => (typeof v === 'number' ? [v] : [...v]);
 /** Zero on every axis `x` has: a motion's velocity where its options give none. */
 const still = (x) => new Array(x.length).fill(0);
@@ -40,6 +42,11 @@ class MotionPatch {
     }
     at(_phase, subject, setting) {
         const state = this.motions;
+        const back = reading.back;
+        if (back !== null) {
+            const flags = sampleThen(state, subject, setting.elapsed, back);
+            return { [this.writes[0]]: state.valueOf(flags, state.xs) };
+        }
         const s = state.slot(subject);
         state.sample(s, setting.elapsed, state.xs, state.vs);
         return { [this.writes[0]]: state.value(s, state.xs) };
@@ -252,9 +259,10 @@ export function spring(writes, opts) {
     return new SpringPatch(writes, new Motions(new SpringShape(law, motion, opts)));
 }
 /**
- * Coasting under friction, a fling: a subject keeps its velocity, which falls by a factor of e every
- * `ms`, and comes to rest `velocity · ms / 1000` past where it was released. `push` sets it moving
- * again from wherever it is. Closed form, so frame rate does not change where it stops.
+ * A patch that coasts each subject to a stop under friction, as after a fling. A subject keeps its
+ * velocity, which falls by a factor of e every `ms`, and comes to rest `velocity · ms / 1000` past
+ * where it was released. `push` sets it moving again from wherever it is. Closed form, so frame
+ * rate does not change where it stops.
  *
  * With `bounds`, a coast that would stop past an edge springs back to it from where it crosses, at
  * the speed it crosses at, on a critically damped spring of `stiffness`; one let go past an edge
@@ -277,11 +285,11 @@ export function glide(writes, opts) {
     return new GlidePatch(writes, new Motions(shape), opts.bounds);
 }
 /**
- * From one value to another over `ms` along an easing, solved in closed form, so frame rate does not
- * change where a subject is. `to(subject, target)` retargets one subject mid-flight: the new stretch
- * starts from where it is and takes the full `ms` again, so its velocity jumps where a spring's
- * would not. Time is the voice's, so `rate` and `seek` apply, and a voice's `loop` does not repeat
- * it. Cue each tween on one voice. Every subject moves on the same number of axes.
+ * From one value to another over `ms` along an easing. Solved in closed form, so frame rate does
+ * not change where a subject is. `to(subject, target)` retargets one subject mid-flight: the new
+ * stretch starts from where it is and takes the full `ms` again, so its velocity jumps where a
+ * spring's would not. Time is the voice's, so `rate` and `seek` apply, and a voice's `loop` does
+ * not repeat it. Cue each tween on one voice. Every subject moves on the same number of axes.
  *
  * @category patch
  */