@msb235/blits 0.3.0 → 0.5.0

package/CHANGELOG.md

@@ -4,6 +4,320 @@ 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.5.0
+
+### Breaking
+
+- A patch is not asked for a subject its voice gives no weight: `at` is skipped at weight 0, unless
+  the voice is fading to rest, while `step` still runs. A blend over 8 stops now runs the 2 around
+  its signal per subject rather than all 8. A patch that counted its calls or sent events from `at`
+  at weight 0 no longer sees those frames.
+- A patch's length is `duration`, not `period`: a pass is one run through a patch whether or not
+  it loops, and only a looping voice has a period. `period` is still set on every patch `patch`,
+  `keys`, `spring`, `glide` and `tween` build, and a patch that sets only `period` still plays,
+  but it is deprecated and a later release removes it.
+
+- A spring, glide or tween's `to`, `push`, `read` and `at` are methods of its class, so call them on
+  the patch, as `glide.to(id, 1)`: one taken off it, as `const { to } = glide`, has no patch to act
+  on. Its `motion` is a getter on the class rather than its own property.
+- `mix.blend` reads its signal once per subject per frame, with the first member's setting, and
+  every member takes its share of that one reading; it read it once per member. A host counting
+  calls sees a third as many from a three-member blend, and a signal reading `setting.elapsed` or
+  `setting.pass` sees the first member's even where a member was sought or retimed on its own. A
+  signal keeping state, as `slew`, `lag` and `gate` do, keeps one state per subject for the whole
+  blend, which carries on when the member that made it leaves; each member kept its own, and those
+  could part ways where members left the lanes in different frames.
+- `keys` copies each stop's array when it is made, so editing an array after passing it to `keys`
+  changes nothing; it showed on the general path and on a lane, and a crowd row now keeps its own
+  copy of the numbers. Make a new patch to change its stops.
+
+- A spring, glide or tween refuses a value of the wrong kind for its channel: an array on a channel
+  holding a number, or a number on one holding an array. A value every subject shares is refused at
+  `cue`, and one given per subject on that subject's first sample. A one-element array on a number
+  channel used to play as its number, through a fold about 5× slower (1.2 ms a frame at 10k subjects
+  against 0.24, on teitou); a number on an array channel played as the channel's rest.
+
+- `atRest` after a probe of the subject in the same frame answers for the pose that probe gave,
+  rather than folding the subject again: a weight reading host input that moved between the two no
+  longer changes the answer. With lanes off, a probe then `atRest` of 10k subjects under two voices
+  (`probed-`) takes 2.64–2.71 ms a frame against 3.80–3.87 (teitou, three alternated runs); a mix
+  that never asks `atRest` reads as before.
+
+### Added
+
+- A mix's host has a type: `mix<I, O, H>` types its `host` option, and every patch, signal and
+  setting it plays reads `setting.host` as `H`, without a cast. `Setting`, `Patch`, `PatchOptions`,
+  `Signal`, `VoiceSpec`, `MixOptions` and `Mix` take `H` as their last type parameter, `unknown` by
+  default, and the stock signals carry it through.
+- `slew` and `lag` take `from`: where a subject starts the first time they see it, in place of on
+  their input, so a follower can climb from rest.
+- `mix.voices(tag?)`: a handle on every voice still in the mix, pending, live, held or fading, in
+  cue order, or only those whose `tags` carry `tag`. A host no longer has to keep every handle `cue`
+  returned to know what is playing. Each handle listed is the one `cue` returned for that voice, so
+  it compares `===` with it.
+- A rate for the whole mix, `mix.rate` and `mix.ramp(rate, over)`, shaped like a handle's and
+  multiplied into every voice's; 0 pauses the mix. It runs mix time, so everything a voice owns
+  slows with it: its clock, its fades, `stagger`, an anchor's `by`, `stepMs` and every `dt`. A
+  timestamp the host gives or reads stays on the host's clock: a `start`, an anchor given as a
+  number, an announced mark, `marks` and `project`. A paused mix with nothing left to land is
+  `inert`, and `history` keeps every rate change, so `project` reads back through them as it does
+  through a handle's. A mix whose rate is never set reads the same bits as before, at the same
+  cost: every row timed (`fn`, `keys`, `named`, `spring`, `tweens^`, `churn^`, `ahead`, `back`)
+  overlaps `9015b0b`'s range over three to five alternated runs on studio.
+- Booking ahead against an outside clock, for a host that schedules on one: sound on an
+  `AudioContext`, MIDI sent with a timestamp, a video loaded before the voice that shows it.
+  `mix.book({ clock, ahead, late, take, tag?, score? })` hands `take` every mark `marks` lists and
+  every hit, `ahead` ms before it comes, with its time on that clock. A hit is a new `VoiceSpec`
+  field, `hits: [{ at, event }]`: events at times on the voice's clock, once per pass, for the
+  voice rather than per subject. A booking whose time moves by more than 1 ms or that goes away (a
+  seek, a rate on the voice or the mix, a fade, a `rebase`, an anchor's target moving, the voice
+  leaving) has the `stop` that `take` returned called and is booked again; an item first seen past
+  is taken at once with `lateBy`, up to `late`. `book` returns a `stop()`. `project` books nothing.
+  A mix with no booker costs what it did: every row timed (`fn`, `keys`, `signal`, `blend`,
+  `named`, `spring`, `tweens`, `churn`, `weasel`, `sparse`) overlaps `c6de97e`'s range over three
+  alternated runs on msb-uai, each row in a process of its own.
+- Owners, for placing, timing and fading voices as one: `mix.owns(spec)` cues a voice with no
+  patch, and a voice cued with `owner: handle` plays under it. A child's `start` and anchors count
+  on the owner's clock, in ms from its start, and a bare name in its anchors means a sibling. The
+  owner's `rate`, `ramp` and `seek` move every child's clock with its own, leaving their state where
+  it is; its `weight`, a number or a signal, and its `fade` multiply into each child's weight per
+  subject; a child with no `hold` takes the owner's. The owner is `played` once every child has
+  finished its passes and leaves with its last child, and its fade ending takes them all. Owners
+  nest, `handle.owner` names a child's owner, and `marks`, hits, `history` and `project` all read
+  through the chain of owner clocks. An owner refuses `loop`. A mix with no owner costs what it
+  did: every row timed (`fn`, `keys`, `signal`, `blend`, `named`, `spring`, `tweens^`, `churn^`,
+  `weasel^`, `swap`, `sparse`) overlaps `995cd97`'s range over four alternated runs on teitou, each
+  row in a process of its own.
+
+### Fixed
+
+- `pull` queues the subjects it reads from the lanes as runs, a first subject and a count, rather
+  than one by one, and writes each run into its arrays as a block. Its loop over the subjects no
+  longer shares a function with its tail: compiled while the first long list was read, `pull`
+  deoptimized at its tail on every frame a voice came or went. At 10k subjects, a frame takes
+  0.167–0.180 ms against 0.228–0.235 with a tween voice per subject (`tweens^`), 0.218–0.227
+  against 0.269–0.278 over one voice (`weasel^`), 0.218–0.234 against 0.291–0.307 with one voice
+  replaced each frame (`churn^`), and 0.308–0.314 against 0.330–0.344 with one subject replaced
+  each frame (`turnover^`) (teitou, eight alternated runs).
+
+- A fill samples a tween on a lane or in a crowd and folds it in one loop, calling its closed form
+  and the channel's fold directly, and keeps no copy of the sample: one is worked out again from
+  the tween's stretch when a probe later in the frame needs it. The steady frame no longer
+  allocates 16 B a subject (8 B over one voice). At 10k subjects read by `pull`, a frame takes
+  0.225–0.234 ms against 0.321–0.327 with a tween voice per subject (`tweens^`), 0.269–0.280
+  against 0.350–0.357 with one voice over all of them (`weasel^`), 0.295–0.308 against
+  0.373–0.404 with one voice replaced each frame (`churn^`), and 0.324–0.337 against 0.397–0.468
+  with one subject replaced each frame (`turnover^`) (teitou, eight alternated runs).
+
+- A voice retiring no longer has the mix read every voice it holds to take it out of the list: up
+  to 8 a frame are found by their id. At 10k voices with one leaving each frame (`turnover^`), a
+  frame takes 0.407–0.416 ms against 0.427–0.436 (teitou, three alternated runs).
+
+- A subject meeting a voice over every subject on a lane does less to meet it. A lane finds a
+  subject's place by its number in an array rather than a Map, the voice's record comes from the
+  chain the probe just linked rather than a second lookup, the voices naming the subject are looked
+  up only when one has started on it since, and the subjects that fold the voice on the general path
+  this frame share one list of it rather than a copy each in a Map. With 10k tween voices of one
+  subject each and a voice over all of them replaced every frame (`swap`), a frame takes
+  4.66–5.13 ms on teitou, from 6.22–6.43.
+- A voice over every subject coming, starting or going relinks each subject's chain by that voice
+  alone, taking it off or putting it on at its place in voice order, where every chain was linked
+  afresh through every voice reaching the subject. The same `swap` frame takes 4.24–4.47 ms on
+  teitou, from 4.81–4.93; a voice per subject (`named`) is unchanged.
+- A subject owing the same voices as the one before it in a frame takes that answer rather than
+  working out again whether it may fold them after the lanes, and a retired voice leaving its lane
+  writes no weights back to its records, which nothing reads once it is done. The same `swap`
+  frame takes 3.55–3.70 ms on teitou, from 3.77–4.09.
+- A projection that retires a copy of a motion voice leaves the live patch asking the live voice
+  for its time. The copy carried the voice's hooks, and retiring it cut the patch off from the
+  mix: an untimed `to` or `push` after such a projection took its time from the subject's next read
+  rather than the latest frame. A motion patch now asks its mix by voice id, where each voice made
+  a weak reference and two closures of its own: a one-subject tween voice holds about 250 B less
+  (`bench/heapwho.mjs 5000 tweens` 3747 B from 4004, `weasel` 3448 from 3704).
+- A spring, glide or tween playing one object subject finds its number for it through the weak
+  reference it numbered it by, rather than a WeakMap of its own: a one-subject tween voice over an
+  object holds 3610 B, from 3747 (`bench/heapwho.mjs 5000 tweens`). Starting them takes no less
+  time.
+- A spring, glide or tween makes its buffer when it numbers its first subject, rather than one for
+  its law when it is made and another then, and works out a still start without asking `to` again:
+  making and cueing 10k one-subject tween voices takes 2.5–2.8 ms on teitou, from 5.1–6.8, and
+  their first frame 15.7–16.9 ms, from 19.0–21.1 (`bench/start.mjs`).
+- A voice over every subject keeps the subjects its `target` turned away as a bit by the number
+  lanes give each, where it kept a map entry for each: memory no longer grows with voices times
+  subjects. 1000 voices each picking one of 1000 subjects by `target` hold 4.6 KB a voice after
+  their first frame, from 37.1, and over 3000 subjects 4.2 KB, from 135; that first frame takes
+  35–38 ms on teitou, from 72–79, and later frames are unchanged (`bench/memory.mjs`, row `own`).
+  With `lanes: false` the answers are kept in a map as before.
+- A crowd's `keys` rows read their stops from one array the crowd keeps, copied as each row
+  joins, rather than through each row's voice, tracks and stop arrays: 10k `keys` voices of one
+  subject each read by `pull` take 0.34–0.36 ms a frame on teitou, from 0.66–1.02, and by probe
+  0.81–0.83, from 1.00–1.37. A row whose stops are not plain numbers on its channel's axes reads
+  them as before.
+- A `keys` patch keeps its stops' phases in a plain array made with it, and those of the stops after
+  phase 0 only once a `from: 'current'` voice first reads them, where it made a typed array of
+  each as it was built: making and cueing 10k one-subject `keys` voices takes 10.9–11.9 ms on
+  teitou, from 13.9–14.8, with their first frame and later frames unchanged.
+- A projection copies each voice into an object V8 keeps in fast mode, where the copy was a
+  dictionary that every read of it looked up by name: a projection made and probed every frame
+  takes 0.57–0.58 ms ahead and 0.74–0.87 back on teitou, from 0.81–0.84 and 0.95–1.09 (`ahead` and
+  `back`, 1000 subjects under three voices, four alternated runs).
+- A pose never holds a patch's own array. Where a channel's `merge` returned its second argument,
+  as `last()` does, the mix put that array into the pose as it was: with two voices on a keyed
+  array channel, a host editing its pose edited the stop, and every later frame read the edit. The
+  mix now copies such a value, into the array the pose already holds where one fits.
+- A voice holds less while it plays. A store keeps its first id inline rather than in a Map, a
+  voice's small arrays are sized to what they hold, `setting.keep` is made the first time a patch
+  reads it, and a spring, glide or tween keeps its methods on its class rather than in closures of
+  its own: a one-subject tween voice keyed by a number, cued and retargeted as weasel's animator
+  does, holds 3.7 KB, from 5.3
+  (`bench/heapwho.mjs 5000 weasel`, which breaks a voice's bytes down by the field that holds them).
+- A crowd voice that starts or begins fading in the frame the lanes are qualified again plays on
+  them. A qualify that kept the crowds as they stood, as when a voice over every subject leaves,
+  dropped the news, and the row stayed silent: a voice starting at 50 ms on one subject read nothing
+  on the lanes while one over every subject faded out then.
+- A crowd voice that starts or begins fading in the same frame as a voice whose change needs the
+  lanes qualified again plays on them. Taking the frame's changes one at a time stopped at the
+  first that needs a qualify, such as a locus member off the lanes starting, and the qualify that
+  followed never heard of the rest: a voice on one subject starting at 50 ms beside a glide in a
+  locus starting then read nothing on the lanes for good.
+- A paused mix asks a weight signal again at each sync, on lanes and for a blend, as the general
+  path already asked a plain voice's. A sync that moved host time while the mix clock stood still
+  was not a new frame: a laned voice kept the weight its lanes were last filled with, and a blend
+  the reading it took before, so a signal the host set while paused, such as a `level`, changed
+  nothing until the mix ran again. A paused mix on lanes now fills them each frame, as a running
+  one does.
+- A subject numbered by a mix, or by a motion patch, is let go once collected even when it was the
+  first object numbered and was collected before a second came. Its number, its lane positions and
+  its motion state were held for good.
+- A crowd copies its rows' motion stretches as a fill begins, rather than in the loop that reads
+  every row. Once voices had faded, V8 spent that loop's inlining on the copy and stopped inlining
+  each row's ease, and every mix in the process stayed slower afterwards. With 10k tween voices of
+  one subject each read by `pull`, a frame takes 0.24 ms on teitou after every voice has been
+  replaced once, from 0.31, and 0.40 ms with one replaced each frame (`churn^`), from 0.44.
+- A crowd compacts its rows once a quarter of them are empty, rather than half: one replacing a
+  voice a frame carried as many empty rows as live ones, all walked every fill. The same 10k voices
+  replaced once each take 0.31 ms a frame on teitou, from 0.33 (`bench/scatter.mjs replaced`).
+- A voice weighted by a signal on a lane is weighed under the fade its lane already worked out,
+  where the general path's weighing worked the fade out again for every subject; a laned `fn` call
+  in a mix keeping no history no longer asks the mix for its horizon. On teitou three signal voices
+  over 10k subjects take about 0.91 of the time they did, three plain `fn` voices 0.91 and a blend
+  of three 0.95.
+- A voice's handle is one object of a class, where each `cue` made a dozen closures: cueing 10k
+  tween voices of one subject each takes 7.7–9.7 ms on teitou, from 13.5–15.3, and 10k `fn` voices
+  2.8–3.1 ms, from 4.8–7.1.
+- A voice naming its subjects keeps them in a list, with a set only past eight, and a motion patch
+  numbering one subject makes no `FinalizationRegistry` until it numbers a second: a tween voice of
+  one subject holds about 5.3 KB, from 5.6 (`bench/heapby.mjs`).
+- A voice over every subject coming, starting or going among a crowd no longer qualifies every
+  voice again, and a probe meeting it folds it onto the lanes' values where it comes after every
+  other laned voice, rather than reading the general path for the frame: with 10k tween voices of
+  one subject each and a voice over all of them replaced every frame (`swap`), a frame takes
+  6.0–6.1 ms on teitou, from 12.2–12.5. A qualify that would rebuild the crowds and laned channels
+  unchanged keeps them as they stand.
+- `atRest` answers from the lanes' values for a subject every voice of which is laned, rather than
+  folding a pose to compare: asked of 10k subjects under two voices, a frame takes 0.94–1.07 ms on
+  teitou, from 1.41–1.43 (`rest`).
+- A subject fading out of a voice with `handle.fade({ subject })` gets the same weight on a lane
+  as on the general path. A lane held the voice's weight to 1 before multiplying in the subject's
+  ramp, where the general path holds the product: a voice at weight 1.6 halfway out of a subject
+  read 0.5 of its delta on a lane and 0.8 elsewhere. Below weight 1 the two differed only in the
+  last bit.
+- A voice weighted by a signal runs on lanes, weighed by the general path's own arithmetic, where
+  it always took the general path; a signal that keeps state through `setting.keep` takes its voice
+  off lanes from the first call, as a patch that keeps state does. Three such voices over 10k
+  subjects take 0.79 of the time they did on teitou. A signal holding state of its own outside
+  `setting.keep` is now called for every subject the mix has met, probed or not, as a stateless
+  patch on a lane already is.
+- `atRest` reads a voice's weight as the probe it repeats did, holds and stagger delay included.
+  It handed a weight signal the voice's time before its holds and the subject's delay, so
+  `weightOf` changed after it, and a channel with no rest could switch on or off and stay so.
+- A locus whose members are all `keys` or stateless `fn` voices runs on lanes, so `mix.blend` over
+  such patches does: each subject's members are gathered as the general path's locus fold gathers
+  them and folded in at its first member's place. A motion member keeps the whole locus on the
+  general path. On teitou three voices in a locus over 10k subjects take 0.72 of the time they
+  did, and a blend of three weighted by a signal 0.84.
+- A voice in a locus folds only the channels its patch writes, as a voice outside one does; a
+  delta's other keys were folded too.
+- A `keys` or stateless `fn` voice naming one subject and writing several channels joins a crowd,
+  as one writing a single channel does, where it took the general path. On teitou 10k such voices
+  read by probe take 0.79 of the time they did and 1k take 0.65; 100 take about 1.1.
+- A crowd's `keys` rows fold their stops straight into the lanes, through the same segment search
+  `readKeys` makes, rather than through a delta per row: 10k `keys` voices of one subject each
+  take 0.74 of the time they did read by `pull` and 0.85 by probe on teitou.
+- A crowd more than half empty rows slides its rows down in place, where the mix qualified every
+  voice again: with one of 10k tween voices replaced each frame, the worst of 12,000 frames fell
+  from about 9 ms to 3 on teitou.
+- A fold with a locus in play allocates nothing per subject: 10k subjects under three voices in a
+  locus take 0.83 of the time they did on teitou, with a third of the collections.
+- A read back copies records holding plain data directly, not through `structuredClone`: a
+  projection made and probed every frame over 1k subjects and three voices takes 0.61 of the time
+  ahead and 0.81 back.
+- A spring works out its time terms once for the subjects released together: one spring voice over
+  10k subjects read by `pull` takes about 0.89 of the time, and a spring voice per subject 0.86.
+- A voice shares one record among the subjects it does not reach, where it kept a full one for
+  each subject it was asked about. 1000 voices each picking one subject by `target` held 269 MB
+  after their first frame and now 37 MB; that first frame takes 77 ms on teitou, from 123, and
+  each later frame 0.86 of the time.
+- A voice and its records make their maps, arrays and promises on first use, and a subject's
+  number needs no token object. A voice of one subject holds 2.5 KB after its first frame as a
+  `fn` (3.4 KB before) and 5.2 KB as a tween (7.3 KB). On teitou cueing 10k tween voices of one
+  subject each takes about 18 ms, from 26, and reading their first frame about 31, from 39.
+  `setting.keep` is now one function per voice that writes to the record being called for, so one
+  kept and called after its call, which `Setting` never allowed, no longer reaches the record it
+  came with.
+
+## 0.4.0
+
+### Breaking
+
+- A tween's `MotionSpec` reads `ms: undefined` where its `ms` is a function of the subject.
+- `Handle.state` can read `'held'`. Only a voice cued with `hold` reaches it, so nothing changes at
+  run time for one cued without, but a `switch` over every state no longer covers them all.
+
+### Added
+
+- `mix.inert` is true when another frame would change no pose, so a host's loop may sleep while
+  `live` is still true: every voice is done, held after its passes at a plain weight, or a motion
+  whose every subject has landed on its target. A retarget, a fade or a cue makes it false again.
+- `handle.fade({ subject, over })` fades one subject out of a voice, which plays on for the rest.
+  Once the ramp ends the voice forgets the subject (its record, its lane position and a motion
+  patch's state for it) and no longer reaches it; a motion patch's `to` brings it back, met afresh.
+  `mix.drop(subject)` clears it too. It keeps the voice on its lane.
+- `tween`'s `ms` may be a function of the subject, asked each time one of its stretches starts.
+- `hold: 'before' | 'after' | 'both'` on a voice. Before, a subject shows the voice's first frame
+  while the voice is pending and while the subject waits out its `stagger`; after, a finite loop
+  shows its last frame once its passes are done and stays, `held`, until faded. `fade.in` counts
+  from the first frame shown. What WAAPI calls `fill`.
+- `handle.played` resolves true when a finite loop's last pass ends, false if the voice leaves
+  first. It never rejects.
+
+### Fixed
+
+- A `keys` or stateless `fn` voice naming one subject and writing one channel fills from its
+  channel's crowd, as a motion voice does, where it took the general path. On teitou 10k `fn`
+  voices of one subject each read by `pull` take 0.7 of the time they did.
+- A voice naming its subjects that is cued, starts or retires relinks only those subjects, and
+  joins or leaves its crowd in place, where it made every subject relink and the lanes qualify
+  every voice again: a frame stopping one of 10k such voices and cueing another fell from about
+  9 ms to 0.6 by `pull` on teitou. `mix.drop` looks only at the voices over every subject and
+  those naming the one dropped, where it walked every voice.
+- `mix.drop` frees a subject from a voice faded off it with `handle.fade({ subject })`, and a mix
+  whose last ramp of that kind is dropped can read `inert` again; it also frees the subject from a
+  motion patch that another voice plays on after the voice naming the subject left.
+- `pull` reads a list it read before in the same order from the lanes in one run, checking the
+  frame once rather than per subject: a tween voice over 10k subjects read by `pull` takes about
+  0.83 of the time it did on teitou.
+- A lane gives a `vec(1)` channel an array of one, as the general path does, where it gave a
+  bare number; and a motion voice on one folds without making an array per subject per frame.
+- A `tween` divides elapsed by its length in milliseconds, so a point a whole fraction of the way
+  in lands exactly: 150 ms into a 200 ms linear tween from 0 to 100 reads 75, not 74.99999999999999.
+- `pull` over a list read again in the same order skips looking each subject up, and copies lane
+  values a column at a time; a motion voice's lane fills in one loop. One tween voice over 10k
+  subjects read by `pull` takes 0.59–0.66 of the time it did on teitou; a spring 0.68–0.74.
+- Motion voices of one subject each fill from one crowd of flat rows per channel, and `sync` visits
+  only voices with something due: 10k tween voices of one subject each take 0.54–0.59 of the time
+  they did on teitou, 100k take 0.31–0.33.
+
 ## 0.3.0
 
 ### Breaking

package/README.md

@@ -76,9 +76,10 @@ so the engine keeps no dependencies; its README says how it works.
 
 ## Status
 
-v0.3.0, with two consumers. magicsmoke runs every fault on it, and
+v0.5.0, with four consumers. magicsmoke runs every fault on it, wod its wheel, tricks and
+transitions, weasel its animator's tweens, 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, on a branch not yet merged.
+part effects, and the environment a sign is lit by — on a mix each.
 That port was an extraction rather than a rewrite, so it is also the evidence that the arithmetic
 here is the arithmetic a working renderer already had: klieg's suite of 1974 cases and its
 screenshot baselines came through it unchanged.

package/dist/bare.d.ts

@@ -0,0 +1,29 @@
+import { type Crowd } from './crowd.js';
+import { type Lane } from './lane.js';
+import type { Lanes } from './lanes.js';
+/**
+ * `Row.SAMPLED` of a crowd row sampled bare in every fill that ran its crowd since it was set, so
+ * its sample is the one `unbare` works out from `hot` at `Crowd.bareNow` rather than a copy.
+ */
+export declare const enum Sampled {
+    BARE = -2
+}
+/** A `Flag.FAST` row's voice time at `now`, before its delay. */
+export declare function clock(hot: Float64Array, h: number, now: number): number;
+/**
+ * A crowd's rows from `p` on that are tweens with nothing on the voice or the stretch for
+ * `runCrowd` to look at, sampled from `hot` and folded straight in, up to voice `id`; returns the
+ * first row it leaves to `runCrowd`. A row's sample is not kept: `unbare` works it out again when
+ * something asks for it.
+ */
+export declare function bareRows<I, O>(lanes: Lanes<I, O>, c: Crowd<I, O>, p: number, id: number): number;
+/**
+ * Keeps the sample a `Sampled.BARE` row was last given, worked out from `hot` as `bareRows` did,
+ * before `hot` changes or something reads it; nothing for any other row.
+ */
+export declare function unbare<I, O>(c: Crowd<I, O>, p: number): void;
+/**
+ * `unbare` for a lane position: its sample worked out again from its patch's stretch, which tells
+ * the lane through `stretchChanged` before it changes.
+ */
+export declare function unbareLane<I, O>(lane: Lane<I, O>, p: number): void;

package/dist/bare.js

@@ -0,0 +1,105 @@
+import { foldNumber } from './channels.js';
+import { bare } from './crowd.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) {
+    return (hot[h + 2 /* Hot.ELAPSED */] +
+        (now - hot[h + 1 /* Hot.NOW */]) * hot[h + 3 /* Hot.RATE */]);
+}
+/**
+ * A crowd's rows from `p` on that are tweens with nothing on the voice or the stretch for
+ * `runCrowd` to look at, sampled from `hot` and folded straight in, up to voice `id`; returns the
+ * first row it leaves to `runCrowd`. A row's sample is not kept: `unbare` works it out again when
+ * something asks for it.
+ */
+export function bareRows(lanes, c, p, id) {
+    const data = c.data;
+    const hot = c.hot;
+    const H = c.stride;
+    const per = lanes.per;
+    const list = c.list;
+    const ch = c.chans[0];
+    const n = c.axes;
+    const fills = lanes.fills;
+    const from = lanes.frameProbes;
+    const probed = lanes.probes !== from;
+    const now = lanes.now;
+    const op = ch.op;
+    for (; p < list.length; p++) {
+        const h = p * H;
+        if (hot[h + 7 /* Hot.ID */] >= id || !bare(hot[h + 0 /* Hot.FLAGS */]))
+            break;
+        const o = p * 8 /* Row.STRIDE */;
+        if (data[o + 4 /* Row.MSLOT */] < 0 || data[o + 7 /* Row.MET */] === 0)
+            break;
+        const slot = list[p];
+        const q = slot * 6 /* Per.SLOT */;
+        if (probed &&
+            (per[q + 3 /* Per.LANE_PROBE */] > from || per[q + 4 /* Per.GENERAL_PROBE */] > from))
+            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 */];
+        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;
+        }
+        const share = left(c.eases[p], progress(elapsed, hot[h + 8 /* Hot.AT */], hot[h + 9 /* Hot.MS */]));
+        if (w <= 0)
+            continue;
+        const values = ch.values;
+        const base = slot * n;
+        const x = h + 10 /* Hot.X0 */;
+        const g = x + 2 * n;
+        for (let a = 0; a < n; a++)
+            values[base + a] = foldNumber(op, values[base + a], between(hot[x + a], hot[g + a], share), w);
+    }
+    return p;
+}
+/**
+ * Keeps the sample a `Sampled.BARE` row was last given, worked out from `hot` as `bareRows` did,
+ * before `hot` changes or something reads it; nothing for any other row.
+ */
+export function unbare(c, p) {
+    const o = p * 8 /* Row.STRIDE */;
+    const data = c.data;
+    if (data[o + 5 /* Row.SAMPLED */] !== -2 /* Sampled.BARE */)
+        return;
+    const hot = c.hot;
+    const h = p * c.stride;
+    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 g = x + 2 * n;
+    for (let a = 0; a < n; a++)
+        c.samples[p * n + a] = between(hot[x + a], hot[g + a], share);
+    data[o + 5 /* Row.SAMPLED */] = c.bareFill;
+    data[o + 6 /* Row.SEEKS */] = hot[h + 5 /* Hot.SEEKS */];
+}
+/**
+ * `unbare` for a lane position: its sample worked out again from its patch's stretch, which tells
+ * the lane through `stretchChanged` before it changes.
+ */
+export function unbareLane(lane, p) {
+    const o = p * 8 /* Row.STRIDE */;
+    const data = lane.data;
+    if (data[o + 5 /* Row.SAMPLED */] !== -2 /* Sampled.BARE */)
+        return;
+    const run = lane.motion;
+    const runs = run.runs;
+    const n = run.n;
+    const b = run.base(data[o + 4 /* Row.MSLOT */]);
+    const elapsed = lane.bareElapsed - data[o + 0 /* Row.DELAY */];
+    const share = left(run.ease, progress(elapsed, runs[b], runs[b + 2]));
+    const x = b + 3;
+    const g = x + 2 * n;
+    for (let a = 0; a < n; a++)
+        lane.samples[p * n + a] = between(runs[x + a], runs[g + a], share);
+    data[o + 5 /* Row.SAMPLED */] = lane.bareFill;
+    data[o + 6 /* Row.SEEKS */] = lane.bareSeeks;
+}

package/dist/blend.d.ts

@@ -0,0 +1,34 @@
+import type { Mixer } from './mixer.js';
+import { Store } from './store.js';
+import type { Signal } from './types.js';
+import type { Subject, Voice } from './voice.js';
+/** A `mix.blend`'s one signal, read once for all its members. */
+export interface Blend<I, O> {
+    by: Signal<I>;
+    stops: number;
+    members: Voice<I, O>[];
+    /** The general path's last read: its frame, its subject, and the value. */
+    frame: number;
+    subject: I | undefined;
+    value: number;
+    /** The general path's read of each subject, for one probed again after another in its frame. */
+    reads: Store<I, {
+        frame: number;
+        value: number;
+    }>;
+    /** Lanes' reads by subject number: the frame each is from, and the value. */
+    frames: Float64Array;
+    values: Float64Array;
+}
+export declare function blendOf<I, O>(by: Signal<I>, stops: number): Blend<I, O>;
+/** Gives a projection's copies blends of their own, so its reads never overwrite the mix's. */
+export declare function ownBlends<I, O>(voices: Voice<I, O>[]): void;
+/** A blend member's share of its signal's read for this subject this frame, made by the first to ask. */
+export declare function blended<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, held: Subject<unknown>, slot: number): number;
+/** A blend member's share of the read lanes made of its signal for subject `slot` this frame; NaN for none. */
+export declare function laneRead<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, slot: number): number;
+/**
+ * A blend's signal kept state on one member's record: the others' records for the subject hold
+ * the same, so whichever member reads next steps it, and every member leaves its lane.
+ */
+export declare function shareKept<I, O>(this: Mixer<I, O>, of: Blend<I, O>, voice: Voice<I, O>, subject: I, held: Subject<unknown>): void;

package/dist/blend.js

@@ -0,0 +1,102 @@
+import { stateful } from './hosts.js';
+import { reading } from './reading.js';
+import { Store } from './store.js';
+export function blendOf(by, stops) {
+    return {
+        by,
+        stops,
+        members: [],
+        frame: 0,
+        subject: undefined,
+        value: 0,
+        reads: new Store(),
+        frames: new Float64Array(0),
+        values: new Float64Array(0),
+    };
+}
+/** Gives a projection's copies blends of their own, so its reads never overwrite the mix's. */
+export function ownBlends(voices) {
+    const own = new Map();
+    for (const v of voices) {
+        if (v.blend === null)
+            continue;
+        let of = own.get(v.blend.of);
+        if (of === undefined) {
+            of = blendOf(v.blend.of.by, v.blend.of.stops);
+            own.set(v.blend.of, of);
+        }
+        v.blend = { of, i: v.blend.i };
+        of.members.push(v);
+    }
+}
+/** A blend member's weight for its signal's read `k`: the members' stops sit evenly along 0..1. */
+function shareOf(k, i, stops) {
+    const d = stops === 0 ? 0 : Math.abs(k * stops - i);
+    return d >= 1 ? 0 : 1 - d;
+}
+/** A blend member's share of its signal's read for this subject this frame, made by the first to ask. */
+export function blended(voice, subject, held, slot) {
+    const { of, i } = voice.blend;
+    const frame = this.frame;
+    let cell;
+    if (slot < 0) {
+        if (of.frame === frame && of.subject === subject)
+            return shareOf(of.value, i, of.stops);
+        cell = of.reads.get(subject);
+        if (cell?.frame === frame)
+            return shareOf(cell.value, i, of.stops);
+    }
+    else if (slot < of.frames.length) {
+        const read = this.laneRead(voice, slot);
+        if (!Number.isNaN(read))
+            return read;
+    }
+    else {
+        const size = Math.max(slot + 1, of.frames.length * 2, 64);
+        const frames = new Float64Array(size);
+        const values = new Float64Array(size);
+        frames.set(of.frames);
+        values.set(of.values);
+        of.frames = frames;
+        of.values = values;
+    }
+    const kept = reading.kept;
+    const k = of.by(subject, voice.setting);
+    if (reading.kept !== kept && !this.projecting)
+        this.shareKept(of, voice, subject, held);
+    if (slot < 0) {
+        of.frame = frame;
+        of.subject = subject;
+        of.value = k;
+        if (cell === undefined)
+            of.reads.set(subject, { frame, value: k });
+        else {
+            cell.frame = frame;
+            cell.value = k;
+        }
+    }
+    else {
+        of.frames[slot] = frame;
+        of.values[slot] = k;
+    }
+    return shareOf(k, i, of.stops);
+}
+/** A blend member's share of the read lanes made of its signal for subject `slot` this frame; NaN for none. */
+export function laneRead(voice, slot) {
+    const { of, i } = voice.blend;
+    return slot < of.frames.length && of.frames[slot] === this.frame
+        ? shareOf(of.values[slot], i, of.stops)
+        : Number.NaN;
+}
+/**
+ * A blend's signal kept state on one member's record: the others' records for the subject hold
+ * the same, so whichever member reads next steps it, and every member leaves its lane.
+ */
+export function shareKept(of, voice, subject, held) {
+    for (const m of of.members) {
+        const h = m === voice ? undefined : m.subjects.get(subject);
+        if (h?.reaches && h.kept === null)
+            h.kept = held.kept;
+        stateful(this, m);
+    }
+}