@msb235/blits 0.14.0 → 0.15.1

package/CHANGELOG.md

@@ -4,6 +4,204 @@ 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.1
+
+### Added
+
+- `mix.trace(from, to, { grid })` reads the mix over a window of mix time without moving it, and
+  `trace.of(subject, channel)` gives a channel of one number as a `Run`: points joined by straight
+  lines, two points at one time for a jump, and `exact` where the lines are the mix's own values
+  throughout. Where every voice feeding the channel is a `keys` voice of known shape (plain number
+  stops eased `linear`, a number weight, a steady rate, no fade under way), the points are its own
+  breakpoints; elsewhere the run is read every `grid` ms, default 5. One trace shares its reads
+  across subjects. `Run`, `Trace`, `TraceOptions` and `NumberChannel` are exported.
+
+### Changed
+
+- A voice cued with `subjects` asks `stagger` for each of them at `cue`, not on first sight, and a
+  finite loop ends once its latest-staggered subject is done whether or not the host has read that
+  subject yet. A read ahead now sees the same end as the live mix. A voice reaching its subjects by
+  `target` still ends by the subjects it has met.
+
+### Fixed
+
+- One-subject tween voices cost about a fifth less a frame once they have landed: a fill folds a
+  landed tween's end as it stands, without reading its clock or easing it, until its voice, its
+  stretch or its subject's delay changes or the clock reads earlier than when it landed. 10,000 of
+  them read by `pull` (`tweens^`) take 0.235 ms a frame against 0.296, `churn^` 0.301 against
+  0.356 and `turnover^` 0.419 against 0.458 (studio, medians of seven runs of 5,000 frames, each in
+  its own process); one tween voice over 10,000 subjects (`weasel^`) is unchanged.
+- A crowd of one-subject `keys` or `fn` voices applies its voices' freezes in the fill's own loop
+  rather than through a call a row. 10,000 `keys` voices read by `pull` (`keyses^`) take 0.449 ms
+  a frame against 0.479, and allocate 6 kB a frame against 162 (studio, medians of seven runs of
+  1,500 frames, each in its own process); the same voices freezing at both ends (`frozen`,
+  `frozen^`) are unchanged.
+- `pull` over a list whose order has drifted from the order the mix first saw it in, as a list
+  kept dense by swap-remove does, writes rests in a few runs, not one per short stretch of
+  subjects. With one subject leaving and one arriving every frame (`turnover^`), a frame takes
+  0.253 ms against 0.262. Teitou, medians of seven runs of 5,000 frames, each in its own process.
+  Other rows are unchanged.
+- A list kept dense by swap-remove stays in the mix's own order for `pull`: a subject moved into
+  the place a dropped one left takes the number the drop freed, so `pull` reads the list in long
+  runs. `turnover^` takes 0.223 ms a frame against 0.263, close to the 0.210 of `churn^`, which
+  replaces voices without reordering anything (teitou with the node to itself, medians of seven
+  runs). The other rows are unchanged. A mix that keeps history, or has roles or a bound on its
+  lanes, keeps the old order.
+
+## 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

package/README.md

@@ -151,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.1, 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.
@@ -160,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 */;
@@ -43,24 +48,41 @@ export function bareRows(lanes, c, p, id) {
             !(per[q + 3 /* Per.LANE_PROBE */] > lately ||
                 per[q + 4 /* Per.GENERAL_PROBE */] > lately))
             break;
-        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 */];
+        // Every step from `now` to a sample's progress rounds monotonically, so a row seen landed at a
+        // positive rate is landed at any later `now` while it stays ready, and folds its `to` as it is.
+        const landed = ready && now >= hot[h + 8 /* Hot.LANDED */];
+        let elapsed = 0;
+        if (!landed) {
+            elapsed = clock(hot, h, now) - data[o + 0 /* Row.DELAY */];
+            if (!(elapsed >= 0))
+                break;
+        }
+        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 */;
+            hot[h + 8 /* Hot.LANDED */] = Number.POSITIVE_INFINITY;
         }
         if (w <= 0)
             continue;
-        const share = left(c.eases[p], progress(elapsed, hot[h + 8 /* Hot.AT */], hot[h + 9 /* Hot.MS */]));
         const values = ch.values;
         const base = slot * n;
-        const x = h + 10 /* Hot.X0 */;
+        const x = h + 11 /* Hot.X0 */;
         const g = x + 2 * n;
+        if (landed) {
+            for (let a = 0; a < n; a++)
+                values[base + a] = foldNumber(op, values[base + a], hot[g + a], w);
+            continue;
+        }
+        const u = progress(elapsed, hot[h + 9 /* Hot.AT */], hot[h + 10 /* Hot.MS */]);
+        const share = left(c.eases[p], u);
+        if (u >= 1 && hot[h + 3 /* Hot.RATE */] > 0)
+            hot[h + 8 /* Hot.LANDED */] = now;
         for (let a = 0; a < n; a++)
             values[base + a] = foldNumber(op, values[base + a], between(hot[x + a], hot[g + a], share), w);
     }
@@ -77,10 +99,11 @@ 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 */]));
-    const x = h + 10 /* Hot.X0 */;
+    const share = left(c.eases[p], progress(elapsed, hot[h + 9 /* Hot.AT */], hot[h + 10 /* Hot.MS */]));
+    const x = h + 11 /* Hot.X0 */;
     const g = x + 2 * n;
     for (let a = 0; a < n; a++)
         c.samples[p * n + a] = between(hot[x + a], hot[g + a], share);