@msb235/blits 0.13.0 → 0.15.0

package/CHANGELOG.md

@@ -4,6 +4,189 @@ 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.15.0
+
+### Breaking
+
+- `Setting`'s fields are `readonly`, so a patch or signal that assigns to
+  `setting.weight`, `dt` or any other field no longer type-checks. The mix reuses one setting per
+  voice across subjects, so such a write already reached whatever it called next. A patch's
+  `state` is still its own to change in place.
+
+### Changed
+
+- A locus is now a **role**, `VoiceSpec.role`: voices in one role are alternatives, so whichever
+  plays it, the subject shows one performance, not two stacked. `locus` is still taken as `role`
+  for one release, deprecated, and the mix warns once outside production; a voice given both with
+  different values is refused. The mix option for tags that act as roles is `roles`, and `loci` is
+  taken the same way. Errors and warnings say role.
+
+### Added
+
+- `within` on a cue: a circle `{ x, y, r }` (the type `Circle`) the host moves, outside which the
+  voice's weight signal is 0, so the mix gives those subjects nothing without calling the signal for
+  them. The host gives the subjects' positions with `mix.plot(subjects, xy)`, two numbers a subject
+  read in place, and calls `mix.moved()` after writing new ones. Positions hold an object subject
+  weakly, and `drop` takes a subject's away. Outside production the mix warns once if the signal is
+  above 0 just outside the circle, which would cut it off there. A voice naming its `subjects` and
+  a role member, an owner's child, a motion, a patch keeping state and a `from: 'current'` voice
+  take it; a patch that steps still steps outside the circle, and a `from: 'current'` voice still
+  takes its base there, as each does at weight 0. Under history a bound reads as its signal does:
+  live on a read back, or with `inputs`, as the signal's recorded reads, a 0 recorded for each
+  subject read outside.
+- `within` also takes a finder of the host's own, `{ find(out) }` (the type `Finder`), over any axes
+  or none: once a frame `find` writes into `out`, an `Int32Array` the mix lends it, the indices of
+  the subjects the signal can be above 0 for, and returns how many. A circle and a finder share one
+  path through the mix.
+- `mix.place(subject)` gives a subject its index, which a finder names it by: the one it has, or a
+  new one. It keeps it until `drop`, or for an object until it is collected, and the index then goes
+  to the next subject placed. `plot` hands out indices too, in its list's order. With no `plot`,
+  `put` writes into positions the mix keeps itself, and a placed subject has none until then.
+- `mix.around(circle, { ease })`, a weight signal over the plotted positions: 1 at the circle's
+  center, falling to 0 at `r` along an easing, linear by default. A voice it weighs is bounded to
+  the circle as if cued `within` it, with no check for a clipped signal, from the first `plot` if it
+  was cued before one.
+- `mix.put(subject, x, y)` moves one subject, for a host where few move at once. It writes into the
+  array `plot` was given, so it mixes freely with writing that array and calling `moved`, or with no
+  `plot`, into the mix's own, and keeps the grid as built until a sixteenth of the subjects have left
+  their cells. It throws for a subject with no index, or one past the array `plot` was given.
+- A watched mix's `voice(handle)` gives `within`, the circle a voice is bounded to by `within` or
+  an `around` weight, or its finder, the host's own object, or undefined for none. blits-panel draws
+  circles only.
+- `color({ lerp: 'oklch' })` and `color(last(), { lerp: 'oklch' })` run on lanes, where they took
+  the general path. The pose is the same to the bit.
+- `mix.pose()` makes a new empty pose for `probe`'s `out`, holding each channel with a rest in kit
+  order. Made once and probed into every frame, its numbers are written without allocating, where
+  an `out` made as `{}` can box each one: about 310 kB a frame less on a 10,000-subject scene.
+- Named, exported types for option bags and return values that were written inline, so each can
+  be read on its own: `LastOptions`, `NumberTuple`, `Layout`, `OverrunOptions`, `MotionOptions`,
+  `SpringOptions`, `GlideOptions`, `TweenOptions`, `Spring`, `Glide`, `Tween`, `SpringSpec`,
+  `GlideSpec`, `TweenSpec`, `Input`, `Level`, `SlewOptions`, `LagOptions`, `Band`,
+  `AnnounceOptions`, `TapeOptions`, `Taken`, `VoiceFade`, `SubjectFade`, `RegistryChange`,
+  `WatchedHistory`, `WatchedVoice`, `Probed`, and `Pulled`. `Moving` and `Signal` are interfaces now,
+  of the same shape.
+
+### Fixed
+
+- A host writing into a pose `probe` handed back without `out` no longer changes where a later
+  `from: 'current'` voice starts, or the speed it starts at: the mix keeps a copy of that pose, not
+  the object itself.
+- Probes of subjects on lanes cost 4 to 10% less a frame: the copy of laned values into the pose
+  stores each channel under its own name, written out once per set of laned channels, where one
+  store by a varying name went through V8's generic path. A voice over 10,000 subjects replaced
+  every frame (`swap`) takes 1.632 ms a frame against 1.739, its keys form 1.165 against 1.259, and
+  a probe then `atRest` of each subject (`probed`) 1.333 against 1.487 (teitou, medians of nine
+  runs, each in its own process). A pose the mix makes itself, for a probe without `out`, `atRest`
+  or `pull`, is now a plain object of the mix's own shape holding each channel with a rest in kit
+  order, so its numbers are stored unboxed. Under a content security policy that refuses
+  `Function`, the copy is the loop it was, and the mix asks only once, so a page sees one
+  violation at most: each refused `Function` fires one, caught or not.
+- A weight signal on lanes is handed, after a stretch of frames at weight 0, the `dt` since its
+  last read, as it is off lanes. It was handed the gap since the subject last had a delta.
+- Tweens read by `pull` cost about a twentieth less a frame: a probe holds its subject for the
+  next fill only while fills look subjects up, which bare tweens never do, and a motion voice's
+  fill reads each subject's flags once and weighs a shared fade once. 10,000 one-subject tween
+  voices (`tweens^`) take 0.285 ms a frame against 0.300, and one tween voice over 10,000 subjects
+  (`weasel^`) 0.369 against 0.391 (keiei, medians of seven runs of 5,000 frames, each in its own
+  process); other rows are unchanged.
+- 10,000 one-subject tween voices read by `pull` (`tweens^`) cost about 7% less a frame, 0.163 ms
+  against 0.175: a crowd row's fill checks once, not every frame, that its stretch is numbered and
+  its subject met (teitou, medians of nine runs of 5,000 frames, each in its own process).
+- Starting voices allocates about 400 B less each: a voice's `subjects`, given as an array of
+  distinct subjects, is copied without being iterated, and voices of a patch writing one channel
+  share their channel slots. 10,000 one-subject voices' first frame takes 20.7 ms against 23.5 for
+  tweens and 8.9 against 10.8 for fns (teitou, medians of nine rounds; `bench/start.mjs`).
+- A mix with no tape no longer makes the closures that record the host's calls only to drop them:
+  a cue, a `drop`, a motion change and every handle write each made one. A voice cued and replaced
+  leaves 11.7 KB of garbage against 12.4 (keiei, medians of three alternated passes of
+  `bench/churnwho.mjs 5000`); frame cost is level.
+- A stateless fn voice over every subject cued between frames costs about a quarter less on the
+  frame its subjects first meet it: their probe makes its first call on its lane and folds it into
+  the lanes' values, where it was folded on the general path. A voice over 10,000 subjects
+  replaced every frame among a tween voice per subject (`swap`) takes 2.67 ms a frame against
+  3.67, and allocates 2.0 MB a frame against 2.8 (msb-uai, medians of seven runs of 3,000 frames,
+  each in its own process).
+- That frame costs about a sixth less again where every subject was probed the frame before: the
+  voice's lane takes every subject when it opens, and the fill makes each one's first call, where
+  each probe met the lane and made it. `swap` takes 2.19 ms a frame against 2.64 (msb-uai, medians
+  of seven runs of 3,000 frames, each in its own process); other rows are unchanged.
+- A `keys` voice over every subject cued between frames gets both: a probe meeting its lane reads
+  it there, and where every subject was probed the frame before, its lane takes them all when it
+  opens. A keys voice over 10,000 subjects replaced every frame among a tween voice per subject
+  (`swapkeys`) takes 1.21 ms a frame against 2.26 (teitou, medians of seven runs of 3,000 frames,
+  each in its own process); other rows are unchanged.
+- A `keys` voice per subject read by `pull` costs about a sixth less a frame: rows whose stops
+  share their phases and easings, at the same phase, find their segment and ease it once rather
+  than once a row. 10,000 of them (`keyses^`) take 0.270 ms a frame against 0.327, and allocate
+  half as much (teitou, medians of nine runs of 5,000 frames, each in its own process). A lane fill
+  also reads a subject's last-read stamp only where the weight it keeps for `weightOf` could
+  change, which takes `weasel^` from 0.204 to 0.198 ms; other rows are unchanged.
+- A voice weighted by a signal costs a little less a frame on lanes: its setting's `timestamp`,
+  `elapsed` and `pass` are filled once for the subjects that share them, not once a subject. A
+  pointer glow over 10,000 subjects read by `pull` (`glow^`) takes 1.657 ms a frame against 1.708,
+  and three signal-weighted voices over 10,000 (`signal`) 4.511 against 4.641 (keiei, medians of
+  seven runs of 5,000 frames, each in its own process); other rows are within their spread.
+- A role, and so a `mix.blend`, costs a further tenth less a frame on lanes where no other voice
+  falls between its members in voice order: each subject's members are gathered and folded
+  together, at the first member's turn, rather than gathered for every subject and folded in a
+  second pass. Three voices in a role over 10,000 subjects (`role`) take 2.555 ms a frame against
+  2.839, and a blend of three (`blend`) 2.841 against 3.055 (teitou, medians of nine runs of 5,000
+  frames, each in its own process); three plain voices (`fn`) and three signal-weighted ones
+  (`signal`) are unchanged.
+- A role, and so a `mix.blend`, costs about a tenth less a frame on lanes, and allocates no more
+  than its members would apart: a member's numbers reach the role without being boxed, 16 bytes
+  each a channel a subject. Three voices in a role over 10,000 subjects (`role`) take 4.349 ms a
+  frame against 4.810 and allocate 2.4 MB against 4.0, and a blend of three (`blend`) 4.633 against
+  5.128 (keiei, medians of seven runs of 5,000 frames, each in its own process).
+- `project` back under `history` reads a motion voice's subject as it showed. A subject retargeted
+  and then faded out of the voice or dropped read back to before it left as though met afresh from
+  `from`, and a retarget, push or `set` given a time earlier than the frame it was made in read back
+  as in force before that frame. A seek already read both right. A read back no longer numbers a
+  subject in the live patch either.
+- A read ahead across many known events of a stateful mix costs a quarter to a third less a frame
+  and allocates half as much: each stop hands a subject's record on to the next instead of copying
+  it, and a voice starting many stops on asks only the copies that may hold a record for it.
+  Reading 5 s ahead past the starts, fade-ins and ends of seven voices over 1,000 subjects (`far`)
+  takes 15.1 ms a frame against 20.5 and allocates 25 MB against 53, and over 10,000 subjects 201
+  ms against 305; seeking back over the calls that cued them and reading ahead to where the mix
+  was (`redo`), 15.5 ms against 21.0 (teitou, medians of five alternated runs of 100 frames against
+  `be0aaa4`). With 31 voices starting 150 ms apart, the record handed on reads 154 ms against 182,
+  and looking past the copies 109 against 151 (against `03af146`).
+- A voice stopped before its end is let go of when it stops. The mix's schedule kept an entry for
+  the time each voice would next change, and one stopped early stayed in it, holding the voice,
+  until that time came: 20,000 `patch` voices of 10⁹ ms replaced over 1,000 subjects held 47 MB of
+  heap, and now 2.4 (keiei, one run each, `bench/leak.mjs`). A motion patch was never held, as it
+  schedules no end.
+
+## 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
@@ -134,7 +151,7 @@ do yet.
 
 ## Status
 
-v0.10.0, with five consumers. magicsmoke runs every fault on it, wod its wheel, tricks and
+v0.15.0, with five consumers. magicsmoke runs every fault on it, wod its wheel, tricks and
 transitions, weasel its animator's tweens, sherpa its seams, and
 [klieg](https://github.com/orochi235/klieg) composes all three of its systems — letter motion,
 part effects, and the environment a sign is lit by — on a mix each.
@@ -143,8 +160,8 @@ here is the arithmetic a working renderer already had: klieg's suite of 1974 cas
 screenshot baselines came through it unchanged.
 
 One thing the port sent back. klieg's three motion phases layer, so they cue as separate voices; a
-`locus` folds its members through each channel's `lerp` instead, which is what a crossfade between
-alternatives wants and is not the same number on a multiplicative channel. Reach for a locus when
+`role` folds its members through each channel's `lerp` instead, which is what a crossfade between
+alternatives wants and is not the same number on a multiplicative channel. Reach for a role when
 one voice should replace another, not when both should be heard.
 
 Zero runtime dependencies, ESM only, types included.

package/dist/ahead.d.ts

@@ -0,0 +1,26 @@
+import { Mixer } from './mixer.js';
+import type { Subject } from './subject.js';
+import { Transport } from './transport.js';
+import type { Voice } from './voice.js';
+/** A live mix's copies at each known event a read ahead stopped at, and the subjects read there. */
+export interface Stages {
+    at: Mixer<unknown, unknown>[];
+    met: Set<unknown>;
+}
+/**
+ * Moves a read ahead's copies to mix time `t`, making the calls the tape holds on the way as a seek
+ * there makes them on the mixes. While a voice could carry state across it, it stops at each known
+ * event: a call, and every mark of a voice or announced. At each stop the copies are kept for
+ * subjects to be read there and copied on, so `copies` ends holding those at `t`. Answers the
+ * transport they stand on, and puts the tape back where it stood.
+ */
+export declare function playAhead(transport: Transport, c: Transport, copies: Map<Mixer<unknown, unknown>, Mixer<unknown, unknown>>, t: number, earlier: Map<Mixer<unknown, unknown>, Stages>): Transport;
+/**
+ * A mix's copy for a read ahead: its voices as they stand, each subject carried from the live one,
+ * or from the copy at the known event before.
+ */
+export declare function copyAhead<I, O>(mix: Mixer<I, O>, c: Mixer<I, O>): void;
+/** Gives a projection's copy what it reads of the live mix as it is, before its voices are copied. */
+export declare function mirror<I, O>(mix: Mixer<I, O>, c: Mixer<I, O>): void;
+/** A voice's record of a subject, the one it shares among those it does not reach included. */
+export declare function recordOf<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject: I): Subject<unknown> | undefined;

package/dist/ahead.js

@@ -0,0 +1,264 @@
+import { ownBlends } from './blend.js';
+import { headOf } from './chain.js';
+import { open, sighted, weightAt } from './everyone.js';
+import { copyHeld, unread } from './history.js';
+import { markOf, voiceMarks } from './marks.js';
+import { Mixer } from './mixer.js';
+import { move } from './move.js';
+import { relink } from './owner.js';
+import { pin, place } from './place.js';
+import { recount } from './roster.js';
+import { hostAhead, replay } from './tape.js';
+import { Transport } from './transport.js';
+import { unreached } from './unreached.js';
+/**
+ * Moves a read ahead's copies to mix time `t`, making the calls the tape holds on the way as a seek
+ * there makes them on the mixes. While a voice could carry state across it, it stops at each known
+ * event: a call, and every mark of a voice or announced. At each stop the copies are kept for
+ * subjects to be read there and copied on, so `copies` ends holding those at `t`. Answers the
+ * transport they stand on, and puts the tape back where it stood.
+ */
+export function playAhead(transport, c, copies, t, earlier) {
+    const tape = transport.tape;
+    const depth = tape?.undoDepth() ?? 0;
+    let played = false;
+    try {
+        for (;;) {
+            const e = nextEvent(tape, c, t);
+            if (!(e < t))
+                break;
+            played = playTo(transport, c, copies, e) || played;
+            if (!carries(c))
+                continue;
+            // Placed now, as the next move would place them, while a target that has just left is here.
+            for (const m of c.members)
+                if (m.anchored > 0)
+                    place(m);
+            const next = restage(c);
+            for (const [mix, copy] of copies) {
+                const on = new Mixer(copy.kit, { ...copy.opts, transport: next }, null);
+                on.slot = copy.slot;
+                on.projecting = true;
+                copyAhead(copy, on);
+                const stages = earlier.get(mix);
+                if (stages === undefined)
+                    earlier.set(mix, { at: [copy], met: new Set() });
+                else
+                    stages.at.push(copy);
+                copies.set(mix, on);
+            }
+            c = next;
+        }
+        played = playTo(transport, c, copies, t) || played;
+    }
+    finally {
+        if (played)
+            tape?.goto(depth);
+    }
+    return c;
+}
+/**
+ * Whether a voice on a read ahead's copies could carry state from one known event to the next: a
+ * patch that steps, or a weight given by a signal, which may keep state. Where none could, a read
+ * crosses the events in one go, as fast as one with none.
+ */
+function carries(c) {
+    for (const m of c.members)
+        for (const v of m.cued)
+            if (v.state !== 'done' && (v.patch.step !== undefined || typeof v.spec.weight === 'function'))
+                return true;
+    return false;
+}
+/**
+ * The earliest known event a read ahead's copies have yet to reach before `t`, mix time: the next
+ * call the tape holds, and while a voice could carry state across one, a mark of a voice or one
+ * announced. Infinity where there is none.
+ */
+function nextEvent(tape, c, t) {
+    const now = c.now;
+    let e = Number.POSITIVE_INFINITY;
+    const call = tape?.timestampAt(tape.undoDepth());
+    if (call !== undefined)
+        e = c.pace === null ? call : c.pace.reading(call);
+    if (!carries(c))
+        return e < t ? e : Number.POSITIVE_INFINITY;
+    for (const m of c.members)
+        for (const v of m.cued) {
+            if (v.state === 'done')
+                continue;
+            for (const mark of voiceMarks) {
+                const at = markOf(m, v, mark);
+                if (at !== undefined && at > now && at < e)
+                    e = at;
+            }
+            const inner = v.spec.marks;
+            if (inner !== undefined)
+                for (const mark of Object.keys(inner)) {
+                    const at = markOf(m, v, mark);
+                    if (at !== undefined && at > now && at < e)
+                        e = at;
+                }
+        }
+    for (const a of c.announced) {
+        const at = c.pace === null ? a.at : c.pace.at(a.at, c.u);
+        if (at > now && at < e)
+            e = at;
+    }
+    return e < t ? e : Number.POSITIVE_INFINITY;
+}
+/**
+ * Makes the calls the tape holds up to mix time `to` on a read ahead's copies and moves them
+ * there. Answers whether it moved the tape.
+ */
+function playTo(transport, c, copies, to) {
+    const tape = transport.tape;
+    const due = (at) => (c.pace === null ? at : c.pace.reading(at)) <= to;
+    const next = tape?.timestampAt(tape.undoDepth());
+    c.u = hostAhead(c, to);
+    let played = false;
+    if (next !== undefined && due(next)) {
+        // A call may write what a copy shares with the voice it was copied from.
+        for (const copy of c.members)
+            for (const v of copy.cued) {
+                if (v.parts !== null)
+                    v.parts = new Map(v.parts);
+                if (v.parted !== null)
+                    v.parted = new Map(v.parted);
+            }
+        played = true;
+        const last = replay(transport, due, c, {
+            transport: () => c,
+            mix: (of) => copies.get(of),
+        });
+        c.u = Math.max(last, hostAhead(c, to));
+    }
+    // A call played at `to` itself moved the copies there before it, as a sync does.
+    if (!(c.now >= to))
+        for (const copy of c.members)
+            move(copy, to);
+    return played;
+}
+/** A transport for a read ahead's copies to go on from where those on `c` stand. */
+function restage(c) {
+    const next = new Transport(undefined, true);
+    next.offset = c.offset;
+    next.u = c.u;
+    next.nextId = c.nextId;
+    next.now = c.now;
+    next.pace = c.pace === null ? null : c.pace.until(Number.POSITIVE_INFINITY);
+    next.announced = c.announced.map((a) => ({ ...a }));
+    // The retargets and pushes the tape made carry their times, so every stop shares one list.
+    next.ahead = c.ahead;
+    return next;
+}
+/**
+ * A mix's copy for a read ahead: its voices as they stand, each subject carried from the live one,
+ * or from the copy at the known event before.
+ */
+export function copyAhead(mix, c) {
+    mirror(mix, c);
+    c.cued = mix.cued
+        .filter((v) => v.state !== 'done')
+        .map((v) => {
+        const link = {
+            mix,
+            voice: v,
+            up: links.get(v),
+            seen: 0,
+            shared: false,
+            filled: false,
+        };
+        const copy = v.copy((subject) => carry(link, subject, c, copy), undefined, true);
+        link.seen = copy.seen;
+        link.shared = copy.sharing;
+        links.set(copy, link);
+        const at = mix.pins?.get(v);
+        if (at !== undefined)
+            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)))
+        relink(c.cued);
+    recount(c);
+}
+/** Gives a projection's copy what it reads of the live mix as it is, before its voices are copied. */
+export function mirror(mix, c) {
+    c.lastPoses = mix.lastPoses;
+    c.wantsPose = mix.wantsPose;
+    c.reducedNow = mix.reducedNow;
+}
+/** A voice's record of a subject, the one it shares among those it does not reach included. */
+export function recordOf(mix, voice, subject) {
+    // A voice sharing one record has that for every subject a chain has asked it about, pointed at
+    // the subject for the caller to copy from.
+    if (voice.sharing) {
+        const slot = headOf(mix, subject)?.slot ?? -1;
+        if (!sighted(voice, slot))
+            return undefined;
+        const all = voice.everyone;
+        open(voice, all, slot);
+        all.weight = weightAt(voice, slot);
+        return all;
+    }
+    const held = voice.subjects.get(subject);
+    if (held !== undefined || voice.unreachedBits === null)
+        return held;
+    return unreached(voice, headOf(mix, subject)?.slot ?? -1)
+        ? voice.unreached
+        : undefined;
+}
+/** Each read ahead copy's link, by the copy. */
+const links = new WeakMap();
+/**
+ * Whether a read ahead's copy of a voice holds a record only where the copy it was made from does:
+ * it has met no subject, taken no record, shares none, and reaches none it was asked about.
+ */
+function empty(voice, link) {
+    return (voice.seen === link.seen &&
+        !link.filled &&
+        !link.shared &&
+        voice.unreached === null &&
+        voice.unreachedBits === null);
+}
+/**
+ * Whether a subject's record on a read ahead's copy at a stop can go on to the copy at the next
+ * stop as it is: each stop reads a subject once, before the next carries it on, and nothing reads
+ * the record there again. Not one a voice shares among subjects, or one the live mix holds.
+ */
+function handable(mix, voice, h) {
+    return mix.projecting && h.reaches && !voice.sharing && h !== voice.unreached;
+}
+/** A record handed on as `copyHeld` would copy it, its place in the stop's chain let go. */
+function handOn(h) {
+    h.restored = null;
+    return unread(h);
+}
+/**
+ * A projection ahead starts each subject from where the live mix holds it, its `since` worked out
+ * again where it was still ahead, since the copy's clock may have moved it.
+ */
+function carry(link, subject, c, copy) {
+    const mix = link.mix;
+    const voice = link.voice;
+    // A voice starting many stops on would otherwise ask every copy before it, one by one. Where
+    // the first copy that may hold one has none, each copy after it has none, dropped or not.
+    let from = link;
+    while (from.up !== undefined && empty(from.voice, from.up))
+        from = from.up;
+    if (from !== link && recordOf(from.mix, from.voice, subject) === undefined)
+        return undefined;
+    const live = recordOf(mix, voice, subject);
+    if (live === undefined)
+        return undefined;
+    const h = handable(mix, voice, live) ? handOn(live) : copyHeld(voice, live);
+    if (h.reaches && !(h.since <= mix.now)) {
+        h.since = c.sinceOf(copy, h.delay);
+        h.shown = c.shownOf(copy, h.since);
+    }
+    h.from = h.stepped;
+    link.filled = true;
+    return h;
+}

package/dist/around.d.ts

@@ -0,0 +1,11 @@
+import type { Mixer } from './mixer.js';
+import type { Circle, Easing, Signal } from './types.js';
+/** The circle a weight carries: an `around` signal's own, or none. */
+export declare const carried: (weight: unknown) => Circle | undefined;
+/**
+ * `Mix.around`: 1 at the circle's center, falling with distance over the positions `plot` gave to 0
+ * at `r` and beyond, along `ease` read from the edge (0) to the center (1).
+ */
+export declare function around<I, O>(this: Mixer<I, O>, circle: Circle, opts?: {
+    ease?: Easing;
+}): Signal<I>;

package/dist/around.js

@@ -0,0 +1,32 @@
+import { curve } from './easing.js';
+/** Each `around` signal's circle, which a voice it weighs is bounded to as if cued `within` it. */
+const circles = new WeakMap();
+/** The circle a weight carries: an `around` signal's own, or none. */
+export const carried = (weight) => typeof weight === 'function' ? circles.get(weight) : undefined;
+/**
+ * `Mix.around`: 1 at the circle's center, falling with distance over the positions `plot` gave to 0
+ * at `r` and beyond, along `ease` read from the edge (0) to the center (1).
+ */
+export function around(circle, opts = {}) {
+    if (typeof circle !== 'object' || circle === null)
+        throw new TypeError('blits: around takes a circle, { x, y, r }');
+    const shape = curve(opts.ease ?? 'linear');
+    const read = (subject) => {
+        const places = this.places;
+        if (places === null)
+            return 0;
+        const i = places.cur >= 0 ? places.cur : (places.at.get(subject) ?? -1);
+        const xy = places.xy;
+        if (i < 0 || 2 * i + 1 >= xy.length)
+            return 0;
+        const r = circle.r;
+        const dx = xy[2 * i] - circle.x;
+        const dy = xy[2 * i + 1] - circle.y;
+        const d2 = dx * dx + dy * dy;
+        if (!(r > 0) || !(d2 <= r * r))
+            return 0;
+        return shape(1 - Math.sqrt(d2) / r);
+    };
+    circles.set(read, circle);
+    return read;
+}

package/dist/bare.js

@@ -1,5 +1,6 @@
 import { foldNumber } from './channels.js';
 import { bare } from './crowd.js';
+import { keepProbed } from './lane.js';
 import { between, left, progress } from './tweened.js';
 /** A `Flag.FAST` row's voice time at `now`, before its delay. */
 export function clock(hot, h, now) {
@@ -26,12 +27,16 @@ export function bareRows(lanes, c, p, id) {
     const lately = lanes.lately;
     const now = lanes.now;
     const op = ch.op;
+    // Ids are finite, so a fill running to the end need not read each row's.
+    const bounded = id !== Number.POSITIVE_INFINITY;
     for (; p < list.length; p++) {
         const h = p * H;
-        if (hot[h + 7 /* Hot.ID */] >= id || !bare(hot[h + 0 /* Hot.FLAGS */]))
+        const f = hot[h + 0 /* Hot.FLAGS */];
+        if ((bounded && hot[h + 7 /* Hot.ID */] >= id) || !bare(f))
             break;
         const o = p * 8 /* Row.STRIDE */;
-        if (data[o + 4 /* Row.MSLOT */] < 0 || data[o + 7 /* Row.MET */] === 0)
+        const ready = (f & 2048 /* Flag.READY */) !== 0;
+        if (!ready && (data[o + 4 /* Row.MSLOT */] < 0 || data[o + 7 /* Row.MET */] === 0))
             break;
         const slot = list[p];
         const q = slot * 6 /* Per.SLOT */;
@@ -46,13 +51,15 @@ export function bareRows(lanes, c, p, id) {
         const elapsed = clock(hot, h, now) - data[o + 0 /* Row.DELAY */];
         if (!(elapsed >= 0))
             break;
-        if (per[q + 5 /* Per.LANE_FILL */] === fills - 1)
-            data[o + 3 /* Row.PROBED */] = data[o + 2 /* Row.WEIGHT */];
+        keepProbed(data, o, per, q, fills);
         const w = hot[h + 4 /* Hot.WEIGHT */];
         data[o + 2 /* Row.WEIGHT */] = w;
-        if (data[o + 5 /* Row.SAMPLED */] !== -2 /* Sampled.BARE */) {
-            data[o + 5 /* Row.SAMPLED */] = -2 /* Sampled.BARE */;
-            c.deltas[p] = null;
+        if (!ready) {
+            if (data[o + 5 /* Row.SAMPLED */] !== -2 /* Sampled.BARE */) {
+                data[o + 5 /* Row.SAMPLED */] = -2 /* Sampled.BARE */;
+                c.deltas[p] = null;
+            }
+            hot[h + 0 /* Hot.FLAGS */] = f | 2048 /* Flag.READY */;
         }
         if (w <= 0)
             continue;
@@ -77,6 +84,7 @@ export function unbare(c, p) {
         return;
     const hot = c.hot;
     const h = p * c.stride;
+    hot[h + 0 /* Hot.FLAGS */] = hot[h + 0 /* Hot.FLAGS */] & ~2048 /* Flag.READY */;
     const n = c.axes;
     const elapsed = clock(hot, h, c.bareNow) - data[o + 0 /* Row.DELAY */];
     const share = left(c.eases[p], progress(elapsed, hot[h + 8 /* Hot.AT */], hot[h + 9 /* Hot.MS */]));

package/dist/blank.d.ts

@@ -0,0 +1,10 @@
+import type { Channel } from './types.js';
+/**
+ * A maker of empty poses for one kit: plain objects holding each channel with a rest, in kit order,
+ * a number rest at its value and any other as `undefined` until the fold writes it.
+ *
+ * `{}` shares V8's chain of shapes with every small object literal, so a host's
+ * `kit({ gain: mul() })` leaves `gain` a field that boxes each number stored in it. A constructor of
+ * the mix's own starts a chain of its own, where a number field stays a double.
+ */
+export declare function blanks<O>(names: readonly string[], channels: readonly Channel<unknown>[]): () => O;

package/dist/blank.js

@@ -0,0 +1,26 @@
+/**
+ * A maker of empty poses for one kit: plain objects holding each channel with a rest, in kit order,
+ * a number rest at its value and any other as `undefined` until the fold writes it.
+ *
+ * `{}` shares V8's chain of shapes with every small object literal, so a host's
+ * `kit({ gain: mul() })` leaves `gain` a field that boxes each number stored in it. A constructor of
+ * the mix's own starts a chain of its own, where a number field stays a double.
+ */
+export function blanks(names, channels) {
+    const keys = [];
+    const starts = [];
+    for (let i = 0; i < names.length; i++) {
+        const rest = channels[i].rest;
+        if (rest === undefined)
+            continue;
+        keys.push(names[i]);
+        starts.push(typeof rest === 'number' ? rest : undefined);
+    }
+    function Pose() {
+        for (let i = 0; i < keys.length; i++)
+            this[keys[i]] = starts[i];
+    }
+    Pose.prototype = Object.prototype;
+    const P = Pose;
+    return () => new P();
+}