@msb235/blits 0.13.0 → 0.14.0

package/CHANGELOG.md

@@ -4,6 +4,35 @@ This package follows [semver](https://semver.org). Below 1.0.0, a breaking chang
 version and everything else the patch. Each release lists its changes as **Breaking**, **Added** and
 **Fixed**, and the release workflow refuses a tag with no section here.
 
+## 0.14.0
+
+### Added
+
+- `set(subject, value, at?)` on `spring`, `glide`, `tween`, and a voice's handle puts a subject at a
+  value and keeps its velocity: a spring or tween heads for its target from there, a glide coasts
+  on. A seek plays it again, as it does a push.
+- `@msb235/blits/fling`: `fling(element, motion, subject, opts)` drags a subject by pointer and
+  flings it on release, and `track` reads a pointer's velocity from its samples with no listeners
+  of its own. The package still builds without the DOM's types.
+- `glide` takes `bounds: [min, max]`, per axis and optionally per subject: a coast that would stop
+  past an edge springs back to it from where it crosses, on a critically damped spring of
+  `stiffness` (default 170). A `set` past an edge stays there until the next push. `g.bounds(subject)`
+  reads them, and `Patch.motion` reports the `stiffness` of a glide that has them.
+- `fling` resists a drag past a glide's bounds, carrying the subject at most `give` (default 120)
+  past an edge, and a press holds a subject springing back past one where it is.
+
+### Fixed
+
+- A voice cued with no `start` into a mix whose frame loop sleeps on `inert`, as `ticker` does,
+  starts at the next sync. It started at the last one, so an effect cued after a pause had already
+  played that far, and a short one was over before its first frame.
+- A patch that names no host type can be cued and blended in a mix that declares one, so a patch
+  library's patches type-check in a host-typed mix. `VoiceSpec.patch`, `BlendMember.patch`, and
+  `blend`'s members take a patch keeping any state.
+- A seek back keeps out a subject that had already left a voice at rest by then. After a fade with
+  `at: 'rest'`, a seek to a moment where that subject was moving again put it back in the voice,
+  playing.
+
 ## 0.13.0
 
 ### Breaking

package/README.md

@@ -102,6 +102,23 @@ import { kit, mix, patch, sum } from '@msb235/blits/lean';
 
 Everything else is the same and so are the poses. `lanes: true` is refused there.
 
+## Dragging and flinging
+
+`@msb235/blits/fling` drags a motion patch's subject by pointer and flings it on release:
+
+```ts
+import { fling } from '@msb235/blits/fling';
+
+const scroll = glide<Page, Pose>('y', { from: 0 });
+mix.cue({ patch: scroll });
+const off = fling(element, scroll, page, { scale: -1 }); // content moves against the drag
+```
+
+A press stops the glide where it is, each move puts it under the pointer, and letting go pushes it at
+the pointer's velocity. `track` reads that velocity from any `(t, x)` samples, with no listeners of
+its own. Anything else in the mix can read the glide's position and velocity, so parallax, a header
+that shrinks or a blur that grows with speed are voices driven by a signal over `scroll.read(page)`.
+
 ## Writing patches for blits in another library
 
 A library that ships patches exports them with the channels they write, as a `Kit` of its own

package/dist/closed.d.ts

@@ -5,6 +5,7 @@ export declare const CRITICAL = 1;
 export declare const OVER = 2;
 export declare const COAST = 3;
 export declare const EASED = 4;
+export declare const BOUND = 5;
 /**
  * A stretch at voice time `t`, released at `at` from `x0` moving at `v0` toward `to` (each read
  * from its offset), into `xo` and `vo`: the one copy of the closed forms, which `law` (a patch's

package/dist/closed.js

@@ -6,6 +6,7 @@ export const CRITICAL = 1;
 export const OVER = 2;
 export const COAST = 3;
 export const EASED = 4;
+export const BOUND = 5;
 const solved = { y: 0, dy: 0 };
 /**
  * The terms of a stretch that depend only on how long since its release, the same on every axis, so
@@ -114,6 +115,46 @@ function solveGlide(law, y0) {
     solved.y = y0 * e;
     solved.dy = (-y0 / tau) * e;
 }
+/**
+ * A glide with bounds, heading for `goal`: the rest point itself where the coast stops inside them,
+ * else the edge it springs back to. Which one is read off the stretch, so no stretch carries more
+ * than an unbounded one: the coast's own rest, worked out as the glide's `aim` does, is `goal`
+ * exactly when it stops inside; past it on the side `x0` is on too, the subject was let go past the
+ * edge and springs back at once; else it coasts until it crosses the edge and springs from there,
+ * at the speed it crossed at. The spring is critically damped, its ω₀ the law's `k2`.
+ */
+function solveBound(law, x0, goal, v0, t) {
+    const tau = law[2];
+    const y0 = x0 - goal;
+    const over = x0 + v0 * tau - goal;
+    if (over === 0) {
+        solveGlide(law, y0);
+        return;
+    }
+    const w0 = law[3];
+    if (y0 * over > 0) {
+        const e = Math.exp(-w0 * t);
+        const b = v0 + w0 * y0;
+        const y = e * (y0 + b * t);
+        solved.y = y;
+        solved.dy = e * b - w0 * y;
+        return;
+    }
+    // e^(−t/τ) where the coast meets the edge: the fraction of its speed it still has there.
+    const left = 1 + y0 / (v0 * tau);
+    const cross = left > 0 ? -tau * Math.log(left) : Number.POSITIVE_INFINITY;
+    if (t < cross) {
+        const e = timed.e;
+        solved.y = y0 + v0 * tau * (1 - e);
+        solved.dy = v0 * e;
+        return;
+    }
+    const s = t - cross;
+    const vc = v0 * left;
+    const e = Math.exp(-w0 * s);
+    solved.y = e * vc * s;
+    solved.dy = e * vc * (1 - w0 * s);
+}
 /**
  * A stretch at voice time `t`, released at `at` from `x0` moving at `v0` toward `to` (each read
  * from its offset), into `xo` and `vo`: the one copy of the closed forms, which `law` (a patch's
@@ -130,7 +171,10 @@ export function closed(law, ease, n, at, ms, x0, x, v0, v, to, g, t, xo, vo) {
     prepare(law, dt);
     for (let i = 0; i < n; i++) {
         const goal = to[g + i];
-        solve(law, x0[x + i] - goal, v0[v + i], dt);
+        if (law[0] === BOUND)
+            solveBound(law, x0[x + i], goal, v0[v + i], dt);
+        else
+            solve(law, x0[x + i] - goal, v0[v + i], dt);
         xo[i] = goal + solved.y;
         vo[i] = solved.dy;
         if (Math.abs(solved.y) > settle || Math.abs(solved.dy) > settle)

package/dist/cue.js

@@ -44,7 +44,10 @@ export function cue(mix, given) {
                 ? mixAt(mix, spec.start - mix.offset)
                 : Number.isNaN(mix.now)
                     ? 0
-                    : mix.now;
+                    : // A loop asleep on an inert mix syncs next when it wakes, which is the cue's "now".
+                        mix.asleep
+                            ? Number.POSITIVE_INFINITY
+                            : mix.now;
     const voice = new Voice(mix.nextId++, spec, patch, spec.fade ?? noFade, local, start, mix.slotOf, mix.channels, mix.opts.host, mix.send, owner);
     if (patch === ownerPatch && mix.fitting !== null)
         voice.fitting = mix.fitting;
@@ -56,6 +59,10 @@ export function cue(mix, given) {
         checkChild(spec, voice);
     if (mix.pace !== null && owner === null && spec.start !== undefined && voice.state === 'pending')
         voice.pinned = spec.start - mix.offset;
+    if (start === Number.POSITIVE_INFINITY && !anchored && !owner?.fitting) {
+        voice.waking = true;
+        mix.waking = true;
+    }
     enter(mix, voice);
     const h = handle(mix, voice);
     voice.handle = h;

package/dist/fling.d.ts

@@ -0,0 +1,66 @@
+import type { Moving, Value } from './motion.js';
+/**
+ * A pointer's recent path, for the velocity it is let go at.
+ *
+ * @category fling
+ */
+export interface Track<V extends Value = number> {
+    /** Where it was at `t`, ms; samples must come in time order. */
+    add(t: number, x: V): void;
+    /**
+     * Units per second at `at`, default the latest sample: the least-squares slope of the samples
+     * within `ms` of the latest, or zero once the latest is more than `stop` ms before `at`, or with
+     * fewer than two samples.
+     */
+    velocity(at?: number): V;
+    clear(): void;
+}
+/**
+ * Tracks a pointer's velocity from its samples, with no listeners of its own: anything that can give
+ * a time and a position can feed it.
+ *
+ * @category fling
+ */
+export declare function track<V extends Value = number>(opts?: {
+    /** How far back the slope reads, ms. Default 100. */
+    ms?: number;
+    /** How long a pointer can sit still before letting go and still fling, ms. Default 40. */
+    stop?: number;
+}): Track<V>;
+/** The part of a pointer event `fling` reads. */
+export interface PointerLike {
+    pointerId: number;
+    clientX: number;
+    clientY: number;
+    timeStamp: number;
+}
+/** Anything pointer events come from: an element, or a stand-in for one. */
+export interface PointerTarget {
+    addEventListener(type: string, fn: (e: PointerLike) => void): void;
+    removeEventListener(type: string, fn: (e: PointerLike) => void): void;
+    setPointerCapture?(pointerId: number): void;
+}
+/**
+ * Drags `subject` of a motion patch, usually a `glide`, by pointer on `target`, and flings it on
+ * release at the pointer's velocity: a press stops it where it is, each move `set`s it under the
+ * pointer, and letting go `push`es it. Past the edge of a glide's `bounds` it follows less and less
+ * of the drag, never more than `give` past. One pointer at a time; a canceled one lets go at rest.
+ * Returns the function that removes its listeners.
+ *
+ * @category fling
+ */
+export declare function fling<I, O, V extends Value = number>(target: PointerTarget, motion: Pick<Moving<I, O, V>, 'read' | 'set' | 'push'> & {
+    bounds?(subject: I): readonly [min: V, max: V] | undefined;
+}, subject: I, opts?: {
+    /** Which pointer axes it follows: `'xy'` moves a subject on two axes. Default `'y'`. */
+    axis?: 'x' | 'y' | 'xy';
+    /** Units per pixel of pointer travel; -1 scrolls content against the drag. Default 1. */
+    scale?: number;
+    /**
+     * How far past an edge of the glide's bounds a drag can carry the subject, in its units; 0
+     * holds it at the edge. Default 120.
+     */
+    give?: number;
+    ms?: number;
+    stop?: number;
+}): () => void;

package/dist/fling.js

@@ -0,0 +1,162 @@
+/**
+ * Tracks a pointer's velocity from its samples, with no listeners of its own: anything that can give
+ * a time and a position can feed it.
+ *
+ * @category fling
+ */
+export function track(opts = {}) {
+    const span = opts.ms ?? 100;
+    const stop = opts.stop ?? 40;
+    if (!(span > 0) || !(stop >= 0))
+        throw new RangeError('blits: a track takes a positive ms and a stop of 0 or more');
+    const ts = [];
+    const xs = [];
+    let scalar = true;
+    return {
+        add(t, x) {
+            scalar = typeof x === 'number';
+            ts.push(t);
+            xs.push(typeof x === 'number' ? [x] : [...x]);
+            let drop = 0;
+            while (t - ts[drop] > span)
+                drop++;
+            if (drop > 0) {
+                ts.splice(0, drop);
+                xs.splice(0, drop);
+            }
+        },
+        velocity(at) {
+            const n = ts.length;
+            const axes = n === 0 ? 1 : xs[0].length;
+            const out = new Array(axes).fill(0);
+            const last = ts[n - 1];
+            if (n >= 2 && !((at ?? last) - last > stop)) {
+                let mt = 0;
+                for (const t of ts)
+                    mt += t;
+                mt /= n;
+                let tt = 0;
+                for (const t of ts)
+                    tt += (t - mt) ** 2;
+                if (tt > 0)
+                    for (let k = 0; k < axes; k++) {
+                        let mx = 0;
+                        for (const x of xs)
+                            mx += x[k];
+                        mx /= n;
+                        let tx = 0;
+                        for (let i = 0; i < n; i++)
+                            tx += (ts[i] - mt) * (xs[i][k] - mx);
+                        out[k] = (tx / tt) * 1000;
+                    }
+            }
+            return (scalar ? out[0] : out);
+        },
+        clear() {
+            ts.length = 0;
+            xs.length = 0;
+        },
+    };
+}
+/** How much of a drag past an edge the subject follows, right at the edge. */
+const PULL = 0.55;
+/** How far a drag `d` past an edge carries the subject, never as far as `give`. */
+const resist = (d, give) => give > 0 ? give * (1 - 1 / ((PULL * d) / give + 1)) : 0;
+/** The drag past an edge that carries the subject `r` past it, as `resist` maps it. */
+const unresist = (r, give) => {
+    const held = Math.min(r, give * 0.99);
+    return give > 0 ? (give * held) / (PULL * (give - held)) : 0;
+};
+/**
+ * Drags `subject` of a motion patch, usually a `glide`, by pointer on `target`, and flings it on
+ * release at the pointer's velocity: a press stops it where it is, each move `set`s it under the
+ * pointer, and letting go `push`es it. Past the edge of a glide's `bounds` it follows less and less
+ * of the drag, never more than `give` past. One pointer at a time; a canceled one lets go at rest.
+ * Returns the function that removes its listeners.
+ *
+ * @category fling
+ */
+export function fling(target, motion, subject, opts = {}) {
+    const axis = opts.axis ?? 'y';
+    const scale = opts.scale ?? 1;
+    const give = opts.give ?? 120;
+    if (!(give >= 0))
+        throw new RangeError('blits: a fling takes a give of 0 or more');
+    let lo;
+    let hi;
+    /** Where the drag `x` puts the subject, past an edge carried by `resist`. */
+    const held = (x) => lo === undefined || hi === undefined
+        ? x
+        : x.map((xi, k) => {
+            const a = lo[k];
+            const b = hi[k];
+            return xi < a ? a - resist(a - xi, give) : xi > b ? b + resist(xi - b, give) : xi;
+        });
+    /** The drag that puts the subject at `x`, as `held` maps it. */
+    const dragged = (x) => lo === undefined || hi === undefined
+        ? x
+        : x.map((xi, k) => {
+            const a = lo[k];
+            const b = hi[k];
+            return xi < a ? a - unresist(a - xi, give) : xi > b ? b + unresist(xi - b, give) : xi;
+        });
+    const path = track(opts);
+    let id;
+    let from = [];
+    let p0 = [];
+    const at = (e) => axis === 'x' ? [e.clientX] : axis === 'y' ? [e.clientY] : [e.clientX, e.clientY];
+    const value = (x) => (axis === 'xy' ? x : x[0]);
+    const flat = (v) => (typeof v === 'number' ? [v] : [...v]);
+    const zero = () => value(from.map(() => 0));
+    const down = (e) => {
+        if (id !== undefined)
+            return;
+        const now = motion.read(subject);
+        if (now === undefined)
+            return;
+        id = e.pointerId;
+        target.setPointerCapture?.(id);
+        const edges = motion.bounds?.(subject);
+        lo = edges === undefined ? undefined : flat(edges[0]);
+        hi = edges === undefined ? undefined : flat(edges[1]);
+        const here = flat(now.value);
+        from = dragged(here);
+        p0 = at(e);
+        motion.push(subject, zero());
+        // The push alone would spring a subject caught past an edge back; a set there holds it.
+        motion.set(subject, value(here));
+        path.clear();
+        path.add(e.timeStamp, here);
+    };
+    const move = (e) => {
+        if (e.pointerId !== id)
+            return;
+        const x = held(at(e).map((p, k) => from[k] + (p - p0[k]) * scale));
+        motion.set(subject, value(x));
+        path.add(e.timeStamp, x);
+    };
+    const up = (e) => {
+        if (e.pointerId !== id)
+            return;
+        id = undefined;
+        motion.push(subject, value(path.velocity(e.timeStamp)));
+    };
+    const cancel = (e) => {
+        if (e.pointerId !== id)
+            return;
+        id = undefined;
+        motion.push(subject, zero());
+    };
+    const on = [
+        ['pointerdown', down],
+        ['pointermove', move],
+        ['pointerup', up],
+        ['pointercancel', cancel],
+    ];
+    for (const [type, fn] of on)
+        target.addEventListener(type, fn);
+    return () => {
+        for (const [type, fn] of on)
+            target.removeEventListener(type, fn);
+    };
+}

package/dist/fold.js

@@ -190,6 +190,7 @@ export function contribution(voice, subject, now, held) {
     if (voice.out?.rest && this.isRest(delta)) {
         held.weight = 0;
         held.rested = true;
+        held.restedAt = now;
         voice.restedCount++;
         return null;
     }

package/dist/handle.d.ts

@@ -68,5 +68,6 @@ export declare class VoiceHandle<I, O> implements Handle<I> {
     weightOf(subject: I): number;
     to(subject: I, target: Value, at?: number): void;
     push(subject: I, velocity: Value, at?: number): void;
+    set(subject: I, value: Value, at?: number): void;
     read(subject: I, at?: number): Motion<Value> | undefined;
 }

package/dist/handle.js

@@ -164,6 +164,11 @@ export class VoiceHandle {
         if (voice !== null)
             moves(voice.patch, 'push', 'a spring or a glide').push(subject, velocity, at);
     }
+    set(subject, value, at) {
+        const voice = this.#voice;
+        if (voice !== null)
+            moves(voice.patch, 'set', 'a motion patch').set(subject, value, at);
+    }
     read(subject, at) {
         const voice = this.#voice;
         if (voice === null || motionOf(voice.patch) === undefined)

package/dist/history.js

@@ -122,6 +122,7 @@ export function copyHeld(voice, h, shared = false) {
         shown: h.shown,
         weight: h.weight,
         rested: h.rested,
+        restedAt: h.restedAt,
         bands: h.bands === null ? null : h.bands.slice(),
         state: h.state === undefined || shared ? h.state : copyState(voice, h.state),
         stepped: h.stepped,
@@ -172,6 +173,7 @@ export function copyHeldInto(voice, h, into, shared = false) {
     into.shown = h.shown;
     into.weight = h.weight;
     into.rested = h.rested;
+    into.restedAt = h.restedAt;
     into.bands = h.bands === null ? null : h.bands.slice();
     into.state = h.state === undefined || shared ? h.state : copyState(voice, h.state);
     into.stepped = h.stepped;

package/dist/mixer.d.ts

@@ -114,6 +114,13 @@ export declare class Mixer<I, O> implements Mix<I, O> {
     reducedNow: boolean;
     /** Something was changed since the last sync, so the next frame may differ from this one. */
     stirred: boolean;
+    /**
+     * The host read `inert` as true since the last sync, so its frame loop may be asleep until a
+     * change wakes it; a host that never asks keeps no loop asleep on it.
+     */
+    asleep: boolean;
+    /** Some voice cued while the mix slept waits for the next sync to set its start. */
+    waking: boolean;
     /** Counts the changes `stir` records, which a frame's record of a probe is current only before. */
     stirs: number;
     syncing: boolean;
@@ -259,6 +266,7 @@ export declare class Mixer<I, O> implements Mix<I, O> {
     voices(tag?: string): Handle<I>[];
     get live(): boolean;
     get inert(): boolean;
+    private restful;
     get rate(): number;
     set rate(r: number);
     ramp(rate: number, over: number): void;

package/dist/mixer.js

@@ -105,6 +105,13 @@ export class Mixer {
     reducedNow = false;
     /** Something was changed since the last sync, so the next frame may differ from this one. */
     stirred = false;
+    /**
+     * The host read `inert` as true since the last sync, so its frame loop may be asleep until a
+     * change wakes it; a host that never asks keeps no loop asleep on it.
+     */
+    asleep = false;
+    /** Some voice cued while the mix slept waits for the next sync to set its start. */
+    waking = false;
     /** Counts the changes `stir` records, which a frame's record of a probe is current only before. */
     stirs = 0;
     syncing = false;
@@ -474,6 +481,12 @@ export class Mixer {
     get inert() {
         if (this.stirred)
             return false;
+        const inert = this.restful();
+        if (inert && !Number.isNaN(this.now))
+            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))

package/dist/motion.d.ts

@@ -44,6 +44,11 @@ export type Moving<I, O, V extends Value> = Patch<I, O, void> & {
      * 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;
 };
 /**
  * The state behind a `'motion'` patch, for an engine that reads it directly; a patch another copy
@@ -90,6 +95,11 @@ export declare function spring<I, O, V extends Value = number>(writes: keyof O,
  * `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
+ * springs back from there, unless it coasts back inside. A `set` past an edge leaves the subject
+ * there, coasting on, until the next `push`, so a drag can hold it out.
+ *
  * @category patch
  */
 export declare function glide<I, O, V extends Value = number>(writes: keyof O, opts: Common<I, V> & {
@@ -97,7 +107,14 @@ export declare function glide<I, O, V extends Value = number>(writes: keyof O, o
     from: PerSubject<I, V>;
     /** The friction's time constant, ms. Default 325, a touch scroll's. */
     ms?: number;
-}): Moving<I, O, V>;
+    /** 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;
+};
 /**
  * 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

package/dist/motion.js

@@ -1,4 +1,4 @@
-import { COAST, CRITICAL, EASED, OVER, UNDER } from './closed.js';
+import { BOUND, COAST, CRITICAL, EASED, OVER, UNDER } from './closed.js';
 import { curve } from './easing.js';
 import { Motions } from './motions.js';
 import { release } from './shared.js';
@@ -44,6 +44,9 @@ class MotionPatch {
         state.sample(s, setting.elapsed, state.xs, state.vs);
         return { [this.writes[0]]: state.value(s, state.xs) };
     }
+    set(subject, value, at) {
+        this.motions.change(subject, { at, x: axes(value) });
+    }
     read(subject, at) {
         const state = this.motions;
         const r = state.read(subject, at);
@@ -63,9 +66,18 @@ class SpringPatch extends TweenPatch {
     }
 }
 class GlidePatch extends MotionPatch {
+    edges;
+    constructor(writes, motions, edges) {
+        super(writes, motions);
+        this.edges = edges;
+    }
     push(subject, velocity, at) {
         this.motions.change(subject, { at, v: axes(velocity) });
     }
+    bounds(subject) {
+        const b = this.edges;
+        return b === undefined ? undefined : per(b, subject);
+    }
 }
 /**
  * The state behind a `'motion'` patch, for an engine that reads it directly; a patch another copy
@@ -124,12 +136,14 @@ class GlideShape {
     ms = undefined;
     start;
     speed;
+    edges;
     constructor(law, motion, opts, tau) {
         this.law = law;
         this.motion = motion;
         this.tau = tau;
         this.start = opts.from;
         this.speed = opts.velocity;
+        this.edges = opts.bounds;
     }
     spec() {
         return this.motion;
@@ -141,8 +155,24 @@ class GlideShape {
         const v = this.speed;
         return v === undefined ? still(x) : axes(per(v, s));
     }
-    aim(x, v) {
-        return x.map((xi, i) => xi + v[i] * this.tau);
+    aim(x, v, _was, s, put) {
+        const rest = x.map((xi, i) => xi + v[i] * this.tau);
+        if (this.edges === undefined)
+            return rest;
+        const [lo, hi] = per(this.edges, s);
+        const min = axes(lo);
+        const max = axes(hi);
+        if (min.length !== rest.length || max.length !== rest.length)
+            throw new Error('blits: bounds on a glide have as many axes as its subjects');
+        return rest.map((r, i) => {
+            const a = min[i];
+            const b = max[i];
+            const xi = x[i];
+            // A set past an edge stays there: a drag holds it out, and only a push lets it spring back.
+            if (put && (xi < a || xi > b))
+                return r;
+            return r < a ? a : r > b ? b : r;
+        });
     }
     scalar(s) {
         return typeof per(this.start, s) === 'number';
@@ -226,16 +256,25 @@ export function spring(writes, opts) {
  * `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
+ * springs back from there, unless it coasts back inside. A `set` past an edge leaves the subject
+ * there, coasting on, until the next `push`, so a drag can hold it out.
+ *
  * @category patch
  */
 export function glide(writes, opts) {
     const ms = opts.ms ?? 325;
     if (!(ms > 0))
         throw new RangeError('blits: a glide takes a positive ms');
+    const k = opts.stiffness ?? 170;
+    if (!(k > 0))
+        throw new RangeError('blits: a glide takes a positive stiffness');
     const tau = ms / 1000;
     const settle = opts.settle ?? 1e-4;
-    const shape = new GlideShape([COAST, settle, tau, 0, 0], { kind: 'glide', ms, settle }, opts, tau);
-    return new GlidePatch(writes, new Motions(shape));
+    const bounded = opts.bounds !== undefined;
+    const shape = new GlideShape(bounded ? [BOUND, settle, tau, Math.sqrt(k), 0] : [COAST, settle, tau, 0, 0], bounded ? { kind: 'glide', ms, settle, stiffness: k } : { kind: 'glide', ms, settle }, opts, tau);
+    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

package/dist/motions.d.ts

@@ -20,6 +20,8 @@ export interface Change {
      */
     at?: number;
     to?: number[];
+    /** Where it moves from, in place of where its stretch has it then. */
+    x?: number[];
     v?: number[];
     /** The mix clock when it was made, NaN where no mix was playing the patch. */
     made?: number;
@@ -73,8 +75,11 @@ export interface Shape<I> {
     from: (subject: I) => number[];
     /** How fast each axis starts moving, given where it starts: still unless the options say. */
     velocity: (subject: I, x: number[]) => number[];
-    /** Where it heads when released from `x` at `v`, given where it was heading. */
-    aim: (x: number[], v: number[], was: number[] | null, subject: I) => number[];
+    /**
+     * Where it heads when released from `x` at `v`, given where it was heading; `put` for a stretch a
+     * `set` released.
+     */
+    aim: (x: number[], v: number[], was: number[] | null, subject: I, put: boolean) => number[];
     /** `[form, settle, k1, k2, k3]`. */
     law: readonly number[];
     /** Whether a subject's value is a number rather than an array. */
@@ -238,7 +243,7 @@ export declare class Motions<I> {
         s: number;
     } | undefined;
     /**
-     * Queues a retarget or push, untimed at the latest frame, for `subject`'s next read past its time.
+     * Queues a retarget, set or push, untimed at the latest frame, for `subject`'s next read past its time.
      * The queue keeps the changes with a time in time order, ahead of any still waiting for one.
      */
     change(subject: I, c: Change): void;

package/dist/motions.js

@@ -126,7 +126,7 @@ export class Motions {
             return known;
         const x = this.shape.from(subject);
         const v = this.shape.velocity(subject, x);
-        const to = this.shape.aim(x, v, null, subject);
+        const to = this.shape.aim(x, v, null, subject, false);
         const n = this.n < 0 ? x.length : this.n;
         this.check(x, n);
         this.check(v, n);
@@ -465,13 +465,14 @@ export class Motions {
         return { x, v, s };
     }
     /**
-     * Queues a retarget or push, untimed at the latest frame, for `subject`'s next read past its time.
+     * Queues a retarget, set or push, untimed at the latest frame, for `subject`'s next read past its time.
      * The queue keeps the changes with a time in time order, ahead of any still waiting for one.
      */
     change(subject, c) {
         const back = this.owner === null ? Number.NaN : this.owner.revive(this.ownerId, subject);
         const s = this.slot(subject);
         this.check(c.to, this.n);
+        this.check(c.x, this.n);
         this.check(c.v, this.n);
         c.made = this.owner === null ? Number.NaN : this.owner.now();
         c.seq = this.owner === null ? Number.NaN : this.owner.seq();
@@ -494,7 +495,7 @@ export class Motions {
         else
             this.queue(list, c, c.at);
         reading.moved++;
-        const made = { at: c.at, to: c.to, v: c.v };
+        const made = { at: c.at, to: c.to, x: c.x, v: c.v };
         this.owner?.changed(this.ownerId, this, subject, made);
     }
     /** Files a change with a time after every one due by then, ahead of those still waiting for one. */
@@ -671,11 +672,12 @@ export class Motions {
             landing = { x: new Float64Array(n), v: new Float64Array(n) };
         const { x, v } = landing;
         this.evaluateSegment(seg, at, x, v);
-        const xs = numbers(x, 0, n);
+        const xs = change.x ?? numbers(x, 0, n);
         const vs = change.v ?? numbers(v, 0, n);
         const subject = this.numbers.subject(s);
         const known = subject === absent ? undefined : subject;
-        const to = this.shape.aim(xs, vs, change.to ?? seg.to, known);
+        const put = change.x !== undefined && change.v === undefined;
+        const to = this.shape.aim(xs, vs, change.to ?? seg.to, known, put);
         const ms = subject === absent ? seg.ms : (this.shape.ms?.(known) ?? 0);
         return { at, ms, x0: xs, v0: vs, to, change };
     }

package/dist/move.js

@@ -9,7 +9,7 @@ import { begin } from './held.js';
 import { noted } from './history.js';
 import { leave as leaveClock } from './origin.js';
 import { ownerReading } from './owner.js';
-import { mixAt, place, repin, startOf } from './place.js';
+import { mixAt, place, repin, startAt, startOf } from './place.js';
 import { pageVoice } from './revive.js';
 import { delist } from './roster.js';
 import { scoredLeft, scoredRemove } from './scored.js';
@@ -47,6 +47,8 @@ function moveTo(mix, now) {
     for (const a of mix.announced)
         if (Number.isNaN(a.at))
             a.at = mix.u;
+    if (mix.waking)
+        wake(mix, now);
     if (mix.pins !== null && mix.pins.size > 0)
         repin(mix);
     if (mix.anchored > 0)
@@ -137,10 +139,31 @@ function moveTo(mix, now) {
     if (mix.sharers.length > 0 && !mix.projecting)
         outgrow(mix);
     mix.stirred = false;
+    mix.asleep = false;
     if (mix.retired.length > 0)
         prune(mix);
     forget(mix);
 }
+/** Starts each voice cued while the mix slept at `now`, the first sync after its cue. */
+function wake(mix, now) {
+    mix.waking = false;
+    for (const voice of mix.cued) {
+        if (!voice.waking)
+            continue;
+        voice.waking = false;
+        if (voice.state !== 'pending')
+            continue;
+        startAt(mix, voice, now);
+        // Where a seek back before the cue puts it, so the tape's cue again starts it here.
+        const first = voice.first;
+        if (first !== null) {
+            first.start = now;
+            first.anchorNow = now;
+        }
+        if (!mix.projecting)
+            schedule(mix, voice);
+    }
+}
 /**
  * Which way a voice's clock is running at mix time `now`, through every owner above it: above 0
  * forward, below 0 back, 0 standing still.

package/dist/pack.d.ts

@@ -7,6 +7,7 @@ export interface PackedRecord {
     shown: number;
     weight: number;
     rested: boolean;
+    restedAt: number;
     bands: number[] | null;
     state: unknown;
     stepped: number;

package/dist/pack.js

@@ -11,6 +11,7 @@ export function packHeld(voice, h) {
         shown: h.shown,
         weight: h.weight,
         rested: h.rested,
+        restedAt: h.restedAt,
         bands: h.bands === null ? null : Array.from(h.bands),
         state: h.state === undefined ? undefined : patch.pack ? patch.pack(h.state) : clone(h.state),
         stepped: h.stepped,
@@ -40,6 +41,7 @@ export function unpackHeld(voice, p) {
     h.shown = p.shown;
     h.weight = p.weight;
     h.rested = p.rested;
+    h.restedAt = p.restedAt;
     h.bands = bands;
     h.stepped = p.stepped;
     h.ticks = p.ticks;

package/dist/project.js

@@ -291,6 +291,7 @@ function copyAhead(mix, c) {
             pin(c, copy, at);
         return copy;
     });
+    c.waking = mix.waking;
     ownBlends(c.cued);
     // A copy keeps no list of owners, so the one before says only by its voices.
     if (mix.owners !== null || (mix.projecting && c.cued.some((v) => v.holding !== null)))

package/dist/record.js

@@ -13,6 +13,7 @@ export function record(voice, reaches, state) {
         shown: 0,
         weight: 0,
         rested: false,
+        restedAt: Number.NaN,
         bands: null,
         state,
         // -0, not 0: a field first given a small integer is boxed on every later write of a double.

package/dist/seek.js

@@ -33,8 +33,7 @@ function restore(mix, voice, live, at, every, mine) {
         const h = mine && live.reaches ? unread(live) : copyHeld(voice, live);
         if (h.stepped > t)
             h.stepped = t;
-        // Whether it had rested by `t` is not kept; the next probe finds it again.
-        h.rested = false;
+        restedBy(h, live, t);
         h.weight = 0;
         h.inputs = inputs;
         if (!(h.since <= t))
@@ -63,6 +62,7 @@ function restore(mix, voice, live, at, every, mine) {
     else
         h = copyHeld(voice, snap.held, true);
     h.weight = 0;
+    restedBy(h, live, t);
     if (snap.at < t)
         h.copied = true;
     const kept = i + 1;
@@ -108,6 +108,14 @@ function restore(mix, voice, live, at, every, mine) {
     }
     return h;
 }
+/**
+ * Whether a record put back for mix time `t` had rested by then, from when the live one did: a
+ * subject may have rested and moved on since, so a probe at `t` would not find it at rest again.
+ */
+function restedBy(h, live, t) {
+    h.rested = live.restedAt <= t;
+    h.restedAt = h.rested ? live.restedAt : Number.NaN;
+}
 /** Cuts a record's list of copies to its first `kept`, keeping those no other list holds as spares. */
 function trim(voice, snaps, kept) {
     while (snaps.length > kept) {

package/dist/shared.d.ts

@@ -2,7 +2,7 @@
  * The package version, for a fact whose shape follows the code too closely to version by hand:
  * copies of different releases keep apart. `test/copies.test.ts` holds it to `package.json`.
  */
-export declare const release = "0.13.0";
+export declare const release = "0.14.0";
 /**
  * A WeakMap every copy of blits loaded in one realm shares, so a fact one copy records about a
  * patch or channel it made is read by another copy's mix. The name carries a version, bumped when

package/dist/shared.js

@@ -2,7 +2,7 @@
  * The package version, for a fact whose shape follows the code too closely to version by hand:
  * copies of different releases keep apart. `test/copies.test.ts` holds it to `package.json`.
  */
-export const release = '0.13.0';
+export const release = '0.14.0';
 /**
  * A WeakMap every copy of blits loaded in one realm shares, so a fact one copy records about a
  * patch or channel it made is read by another copy's mix. The name carries a version, bumped when

package/dist/strays.js

@@ -117,7 +117,7 @@ function changeAhead(to, id, motion, given, change) {
         made.set(motion, bySubject);
     }
     const list = bySubject.get(subject);
-    const c = { at, to: change.to, v: change.v };
+    const c = { at, to: change.to, x: change.x, v: change.v };
     if (list === undefined)
         bySubject.set(subject, [c]);
     else {

package/dist/types/mix.d.ts

@@ -134,7 +134,7 @@ export interface Mix<I, O, H = unknown> {
      * state keeps it once, not per member. One `spec` cues them all, and a member given as a
      * `BlendMember` carries its own `name`, `tags` and `hits` in place of the spec's.
      */
-    blend(members: readonly (Patch<I, O, unknown, H> | BlendMember<I, O, H>)[], by: Signal<I, H>, spec?: Omit<VoiceSpec<I, O, H>, 'patch' | 'weight' | 'locus'>): Handle<I>[];
+    blend(members: readonly (Patch<I, O, any, H> | BlendMember<I, O, H>)[], by: Signal<I, H>, spec?: Omit<VoiceSpec<I, O, H>, 'patch' | 'weight' | 'locus'>): Handle<I>[];
     /**
      * Cues an owner: a voice with no patch that holds the voices cued with `owner` set to its handle,
      * and plays them on its own clock, so they can be placed, timed and faded as one. Its handle acts
@@ -308,7 +308,9 @@ export interface Mix<I, O, H = unknown> {
      * Another frame would change no pose, so a host's frame loop may sleep: every voice is done, frozen
      * at a plain weight, or a motion whose every subject has landed on its target. At rate 0 it is
      * enough that every voice not done has started, at a plain weight, with no anchor. A change made
-     * since the last sync, a retarget or a rate included, makes it false until the next.
+     * since the last sync, a retarget or a rate included, makes it false until the next. Read as true,
+     * it tells the mix the host may sleep: a voice cued with no `start` before the next sync starts
+     * at that sync.
      */
     readonly inert: boolean;
     /**

package/dist/types/patch.d.ts

@@ -110,6 +110,8 @@ export type MotionSpec = {
     /** The friction's time constant, ms. */
     readonly ms: number;
     readonly settle: number;
+    /** The spring back's, per second squared; only on a glide with bounds. */
+    readonly stiffness?: number;
 } | {
     readonly kind: 'tween';
     /** How long a stretch takes; undefined where it varies by subject, kept on the patch then. */

package/dist/types/voice.d.ts

@@ -47,7 +47,7 @@ export interface SpanHints {
  * @category voice
  */
 export interface VoiceSpec<I, O, H = unknown> extends SpanHints {
-    patch: Patch<I, O, unknown, H>;
+    patch: Patch<I, O, any, H>;
     /**
      * What `history.revive` rebuilds this spec from, so a history `store` can page the voice out once
      * it has left. A voice cued without it stays in memory for as long as history reaches it.
@@ -72,7 +72,9 @@ export interface VoiceSpec<I, O, H = unknown> extends SpanHints {
      * When the voice starts, in ms on the host's clock, the one it passes `sync`: a rAF timestamp and
      * `performance.now()` share an origin, `Date.now()` does not. Default: the time the mix last
      * synced to, and 0 for a voice cued before the first sync, which that sync finds already as far
-     * in as its timestamp.
+     * in as its timestamp. Where the host read `inert` as true since the last sync, its frame loop
+     * may be asleep, and the default is the next sync instead, so a voice cued after a long pause
+     * starts there rather than that far in.
      */
     start?: number;
     /**
@@ -175,7 +177,7 @@ export interface VoiceSpec<I, O, H = unknown> extends SpanHints {
  * @category blending
  */
 export interface BlendMember<I, O, H = unknown> {
-    patch: Patch<I, O, unknown, H>;
+    patch: Patch<I, O, any, H>;
     /** What other voices call this member by. Default: the spec's `name`. */
     name?: string;
     /** Default: the spec's `tags`. */
@@ -384,6 +386,11 @@ export interface Handle<I = unknown> {
      * `glide`: the patch's own `push`. Throws for any other voice.
      */
     push(subject: I, velocity: Value, at?: number): void;
+    /**
+     * Puts `subject` at `value`, keeping its velocity, for a voice playing any motion patch: the
+     * patch's own `set`. Throws for any other voice.
+     */
+    set(subject: I, value: Value, at?: number): void;
     /**
      * Where `subject` is and how fast it moves, for a voice playing a motion patch: the patch's own
      * `read`. Undefined for any other voice, and wherever the patch's `read` is.

package/dist/voice.d.ts

@@ -86,6 +86,8 @@ export interface Subject<S> {
     weight: number;
     /** Left at rest during a handover, so it stops contributing. */
     rested: boolean;
+    /** The mix time it rested at, which a seek reads to know whether it had by then; NaN until it does. */
+    restedAt: number;
     /**
      * Per written channel, whether a rest-less contribution is on: 0 unknown, 1 on, 2 off; null until
      * a rest-less channel asks.
@@ -333,6 +335,8 @@ export declare class Voice<I, O> {
     outSet: boolean;
     /** The host time a pinned start was given at, NaN for none: a seek back pins it again. */
     pinned: number;
+    /** Cued with no start while its mix slept, so the next sync sets its start. */
+    waking: boolean;
     /** Whether its start is still to be fixed by an anchor, so it waits pending. */
     placing: boolean;
     /** What each member of a join last answered, kept for once its target has left. */

package/dist/voice.js

@@ -226,6 +226,8 @@ export class Voice {
     outSet = false;
     /** The host time a pinned start was given at, NaN for none: a seek back pins it again. */
     pinned = Number.NaN;
+    /** Cued with no start while its mix slept, so the next sync sets its start. */
+    waking = false;
     /** Whether its start is still to be fixed by an anchor, so it waits pending. */
     placing = false;
     /** What each member of a join last answered, kept for once its target has left. */

package/docs/schema.html

@@ -512,12 +512,13 @@ interface Handle<I = unknown> {
   <span class="cm">/** The weight this voice gave `subject` the last frame it was probed: after fades and its signal, before a
      locus folds it. 0 where it gave none. One number on a record the mix keeps anyway, so free unasked. */</span>
   weightOf(subject: I): number;
-  <span class="cm">/** A motion patch's own `to`, `push`, and `read`, reached without holding the patch; `at` is a voice time. `to`
-     throws for a voice not playing a `spring` or a `tween`, and `push` for one not playing a `spring` or a `glide`;
-     `read` gives undefined for a voice playing no motion patch. `Value` is a number or an array of them, and
+  <span class="cm">/** A motion patch's own `to`, `push`, `set`, and `read`, reached without holding the patch; `at` is a voice time. `to`
+     throws for a voice not playing a `spring` or a `tween`, `push` for one not playing a `spring` or a `glide`, and
+     `set` for one playing no motion patch; `read` gives undefined for a voice playing no motion patch. `Value` is a number or an array of them, and
      `Motion` is `{ value, velocity }`. See Springs, glides and tweens. */</span>
   to(subject: I, target: Value, at?: number): void;
   push(subject: I, velocity: Value, at?: number): void;
+  set(subject: I, value: Value, at?: number): void;
   read(subject: I, at?: number): Motion&lt;Value&gt; | undefined;
   <span class="cm">/** Resolves when the voice has been removed from the mix, however that happened. */</span>
   readonly done: Promise&lt;void&gt;;
@@ -755,9 +756,14 @@ mix.book({
 mix.cue({ patch: s });
 s.to(node, 40);              <span class="cm">// heads elsewhere from wherever it is, keeping its velocity</span>
 s.push(node, 600);           <span class="cm">// a kick: same target, new velocity</span>
+s.set(node, 20);             <span class="cm">// moved there: same target, same velocity</span>
 s.read(node);                <span class="cm">// { value, velocity }, for handing the motion to another patch</span>
 
 const g = glide&lt;Node, Pose&gt;('x', { from: 0, velocity: 1200, ms: 325 });  <span class="cm">// a fling: rests 390 past the start</span>
+g.set(node, 80);             <span class="cm">// under a dragging pointer</span>
+g.push(node, -900);          <span class="cm">// let go: coasts on from there</span>
+
+const list = glide&lt;Node, Pose&gt;('y', { from: 0, bounds: [-2400, 0] });  <span class="cm">// springs back from an edge it coasts past</span>
 
 const t = tween&lt;Node, Pose&gt;('x', { from: (n) =&gt; n.x, to: (n) =&gt; n.goal, ms: 400, ease: 'ease-out' });
 t.to(node, 40);              <span class="cm">// from wherever it is, over a full 400 ms again</span></code></pre>
@@ -765,6 +771,8 @@ t.to(node, 40);              <span class="cm">// from wherever it is, over a ful
 <ul>
   <li><b>Time is the voice's</b>, so <code>rate</code> and <code>seek</code> apply. A change takes effect at the voice time it names, or, named none, at the subject's own voice time at the mix's latest frame, whether or not the host probed it then; naming one is what makes a retarget land the same at any frame rate. A subject no frame of its voice has met yet, or still inside its stagger, takes an unnamed change at its first read, after any named change due by then. <code>read</code> with no time answers at that same latest frame, counting every change due by then, and answers nothing once the voice is gone.</li>
   <li><b>History is kept to the mix's horizon.</b> Each subject keeps every stretch a read may still reach, so a read earlier than a change finds the stretch that was playing then. A mix without <code>history</code> keeps only the stretch playing now.</li>
+  <li id="fling"><b>Dragging and flinging.</b> <code>@msb235/blits/fling</code> wires pointer events to a motion patch: <code>fling(element, glide, subject, { axis, scale })</code> stops the subject where it is on a press, <code>set</code>s it under the pointer on each move, and <code>push</code>es it on release at the pointer&rsquo;s velocity, which <code>track</code> reads as the least-squares slope of the last 100 ms of samples, or zero if the pointer sat still for 40 ms before letting go. <code>track</code> has no listeners, so anything with a time and a position can feed it. It is a subpath because it is the package&rsquo;s only code that knows a page exists, and it asks only for <code>addEventListener</code>, <code>removeEventListener</code> and <code>setPointerCapture</code>, so the package builds without the DOM&rsquo;s types. Since the coast is a voice like any other, other voices read it: a signal over <code>glide.read(subject)</code> drives parallax off its value or a blur off its velocity. Past an edge of a glide's <code>bounds</code>, a drag carries the subject less and less of the way, never more than <code>give</code> (default 120 units) past: at the edge it follows 0.55 of the drag, as iOS's scroll views do, and <code>give: 0</code> holds it at the edge. A press on a subject springing back past an edge holds it where it is. Added 2026-10-24.</li>
+  <li id="bounds"><b>Bounds.</b> <code>glide(…, { bounds: [min, max], stiffness })</code> gives each axis the least and greatest value a coast comes to rest at, the same for every subject or one pair per subject; <code>g.bounds(subject)</code> reads them back. A coast that would stop inside them is the glide without bounds, to the bit. One that would stop past an edge coasts until it crosses it, then springs back on a critically damped spring of <code>stiffness</code> (default 170, a spring&rsquo;s), starting at the speed it crossed at, so neither where it is nor how fast it moves jumps. One let go already past an edge springs back from there, unless its coast carries it back inside, when it coasts with no spring at all. A <code>set</code> past an edge leaves the subject there, coasting on, until the next <code>push</code>: that is how a drag holds it out, and why a <code>push(subject, 0)</code> lets it go. It needed no new state: a stretch still holds where it starts, how fast, and where it heads, which is now the edge when the coast stops past one, and the closed form tells the three cases apart from those numbers alone, so lanes, seeks and history carry it as they carry any glide. Added 2026-10-24.</li>
   <li><b>A spring or a glide settles.</b> Within <code>settle</code> (1e-4) of where it heads, and that slow, it lands there exactly, so <code>atRest</code> sees it. <code>settle: 0</code> keeps the curve exact. A tween needs none: it lands on its target exactly at <code>ms</code>.</li>
   <li><b>The state is the patch's own</b>, per subject, rather than the mix's, because the host retargets through the patch, or through <code>handle.to</code>, <code>push</code>, and <code>read</code>, which reach it. Cue each one on one voice. A patch moves every subject on the same number of axes, and throws on a subject, a <code>to</code> or a <code>push</code> with another, leaving the subject as it was. Its values are the kind its channel holds, a number for a number and an array for an array: one every subject shares is refused at <code>cue</code>, one given per subject on that subject's first sample.</li>
   <li><b>The constants are data.</b> <code>patch.motion</code>, a <code>MotionSpec</code>, is <code>{ kind: 'spring', stiffness, damping, mass, settle }</code> or <code>{ kind: 'glide', ms, settle }</code> or <code>{ kind: 'tween', ms, ease }</code>, with <code>ms</code> undefined where it varies by subject, so an engine can run one without calling <code>at</code>. Where each subject starts and heads stays on the patch, since either may be a function of the subject.</li>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@msb235/blits",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "Concurrent effects: each on its own clock with its own state and weight, folded into one value per subject per frame",
   "keywords": [
     "animation",
@@ -34,6 +34,10 @@
     "./lean": {
       "types": "./dist/lean.d.ts",
       "default": "./dist/lean.js"
+    },
+    "./fling": {
+      "types": "./dist/fling.d.ts",
+      "default": "./dist/fling.js"
     }
   },
   "files": [