@msb235/blits 0.7.1 → 0.8.1

package/dist/patch.js

@@ -1,5 +1,5 @@
-import { lerpInto } from './channels.js';
-import { curve } from './easing.js';
+import { lerpInto, lerpNumber } from './channels.js';
+import { curve, startSlope } from './easing.js';
 /**
  * The procedural form. Flicker, roving, a hash walk, a starter strike.
  *
@@ -12,7 +12,6 @@ export function patch(duration, at, opts) {
     return {
         form: 'fn',
         duration,
-        period: duration,
         writes,
         kit: opts.kit,
         reads: opts.reads,
@@ -23,11 +22,6 @@ export function patch(duration, at, opts) {
         unpack: opts.unpack,
     };
 }
-const options = new WeakMap();
-/** The options a `keys` patch was built with, for an engine reading its stops rather than calling it. */
-export function keysOptionsOf(p) {
-    return options.get(p);
-}
 const linear = (a, b, u) => a + (b - a) * u;
 function interpolate(a, b, u) {
     if (typeof a === 'number' && typeof b === 'number')
@@ -64,6 +58,10 @@ function build(stops, writes, duration, opts) {
         }
         all.sort((x, y) => x.at - y.at);
         const tail = all.filter((pt) => pt.at !== 0);
+        const lerp = opts.lerpBy?.(channel) ?? opts.kit?.[channel]?.lerp;
+        const plain = all.length > 0 &&
+            (lerp === undefined || lerp === lerpNumber) &&
+            all.every((pt) => typeof pt.value === 'number');
         tracks.push({
             channel: channel,
             all,
@@ -71,7 +69,14 @@ function build(stops, writes, duration, opts) {
             ats: all.map((pt) => pt.at),
             tailAts: null,
             delay: opts.delayBy?.(channel) ?? 0,
-            lerp: opts.lerpBy?.(channel) ?? opts.kit?.[channel]?.lerp,
+            lerp,
+            numbers: plain
+                ? {
+                    ats: Float64Array.from(all, (pt) => pt.at),
+                    values: Float64Array.from(all, (pt) => pt.value),
+                    eases: all.map((pt) => pt.ease),
+                }
+                : null,
         });
     }
     return { tracks, duration };
@@ -100,12 +105,17 @@ export function shifted(track, phase, duration) {
 }
 /** A phase once a channel's delay of `delay` ms in a duration of `duration` applies. */
 export function shift(delay, phase, duration) {
-    return delay === 0 || duration === 0 ? phase : Math.max(0, (phase * duration - delay) / duration);
+    if (delay === 0 || duration === 0)
+        return phase;
+    // The channel travels in what is left after its wait, so it lands with the rest at phase 1.
+    if (delay >= duration)
+        return phase >= 1 ? 1 : 0;
+    return Math.max(0, (phase * duration - delay) / (duration - delay));
 }
 /**
  * Where `phase` falls among `n` stop phases `ats[off + k * stride]`, in order: -2 for no stops, -1
  * at or before the first, `n` at or past the last, and otherwise the first stop past it, where the
- * segment from the one before ends. With `segment`'s, the one copy of the search.
+ * segment from the one before ends. `segment` and `readNumber` make the same search.
  */
 export function locate(ats, off, stride, n, phase) {
     if (n === 0)
@@ -132,8 +142,8 @@ export function fraction(phase, a, b) {
     return (phase - a) / (b - a);
 }
 /**
- * Finds where one track is at a phase, into `seg`: the one copy of the search, which `read` and a
- * lane folding stops straight into a subject's values both make. `base` stands in for the value at
+ * Finds where one track is at a phase, into `seg`: the search `read` and a lane folding stops
+ * straight into a subject's values both make. `base` stands in for the value at
  * phase 0, which is how `from: 'current'` starts a voice wherever the subject already is.
  */
 export function segment(track, phase, base) {
@@ -179,10 +189,44 @@ export function segment(track, phase, base) {
     seg.ease = b.ease;
     return BETWEEN;
 }
+/**
+ * A plain-number track at a phase, in exactly `segment`'s and `read`'s arithmetic: the stop at or
+ * past the phase by binary search, the fraction before easing, then a straight lerp.
+ */
+function readNumber(t, phase) {
+    const ats = t.ats;
+    const values = t.values;
+    const n = ats.length;
+    if (phase <= ats[0])
+        return values[0];
+    if (phase >= ats[n - 1])
+        return values[n - 1];
+    let lo = 1;
+    let hi = n - 1;
+    while (lo < hi) {
+        const mid = (lo + hi) >> 1;
+        if (ats[mid] >= phase)
+            hi = mid;
+        else
+            lo = mid + 1;
+    }
+    const a = ats[lo - 1];
+    const u = (phase - a) / (ats[lo] - a);
+    const ease = t.eases[lo];
+    const eased = ease ? ease(u) : u;
+    const from = values[lo - 1];
+    return from + (values[lo] - from) * eased;
+}
 /** Reads one track at a phase; `base` as `segment` takes it. */
 function read(track, phase, base, lerp, 
 /** Units per ms, for a retarget's first segment. */
 slope, duration, into, reuse) {
+    const numbers = track.numbers;
+    if (numbers !== null &&
+        base === undefined &&
+        slope === undefined &&
+        (lerp === undefined || lerp === lerpNumber || track.lerp !== undefined))
+        return readNumber(numbers, phase);
     const found = segment(track, phase, base);
     if (found === NOTHING)
         return undefined;
@@ -208,7 +252,9 @@ slope, duration, into, reuse) {
     // add c·u(1−u)², which is 0 at both ends, flat at the end, and fixes the slope at the start.
     if (slope === undefined || !first)
         return value;
-    const e0 = ease ? ease(1e-6) / 1e-6 : 1;
+    const e0 = ease ? startSlope(ease) : 1;
+    if (e0 === Number.POSITIVE_INFINITY)
+        return value;
     const bend = (s, a, z) => (s * duration * len - (z - a) * e0) * u * (1 - u) * (1 - u);
     if (typeof value === 'number' && typeof slope === 'number')
         return value + bend(slope, aValue, bValue);
@@ -262,14 +308,15 @@ slopes, intos, scratch) {
     }
     return out;
 }
-/** A patch's `duration`, or the deprecated `period` where only that is set. */
-export const durationOf = (p) => p.duration ?? p.period ?? 0;
 const cache = new WeakMap();
-/** The built form of a patch's stops, made on first ask for a patch `keys()` did not build. */
+/**
+ * The built form of a patch's stops, made on first ask for a patch `keys()` did not build: a copy
+ * of one, or one another copy of blits made, each read by the fields it carries.
+ */
 export function builtOf(p) {
     let held = cache.get(p);
     if (held === undefined) {
-        held = build(p.keys, p.writes, durationOf(p), keysOptionsOf(p) ?? {});
+        held = build(p.keys, p.writes, p.duration, p);
         cache.set(p, held);
     }
     return held;
@@ -289,13 +336,28 @@ export function keys(duration, stops, opts = {}) {
     const p = {
         form: 'keys',
         duration,
-        period: duration,
         writes,
         kit: opts.kit,
         keys: stops,
-        at: (phase) => readKeys(made, phase, {}),
+        ...given(opts),
+        // A copy of the patch carries this `at` with fields of its own, which it is read by.
+        at(phase) {
+            return readKeys(this === p ? made : builtOf(this), phase, {});
+        },
     };
-    options.set(p, opts);
     cache.set(p, made);
     return p;
 }
+/** The `keys` options a patch carries as fields, those given only: an absent one adds no key. */
+function given(opts) {
+    const out = {};
+    if (opts.ease !== undefined)
+        out.ease = opts.ease;
+    if (opts.easeBy !== undefined)
+        out.easeBy = opts.easeBy;
+    if (opts.delayBy !== undefined)
+        out.delayBy = opts.delayBy;
+    if (opts.lerpBy !== undefined)
+        out.lerpBy = opts.lerpBy;
+    return out;
+}

package/dist/place.js

@@ -1,3 +1,5 @@
+import { departedMatches } from './departed.js';
+import { reorigin } from './held.js';
 import { noted } from './history.js';
 import { markOf } from './marks.js';
 import { mixTime, ownerReading } from './owner.js';
@@ -37,6 +39,10 @@ function startAt(mix, voice, start) {
     voice.start = start;
     voice.anchorNow = start;
     voice.anchorElapsed = 0;
+    voice.clocks = null;
+    // A clock moved outright, as a seek moves it: what a record computed at this mix time is stale.
+    voice.seeks++;
+    reorigin(mix, voice, mix.now);
     noted(mix, voice);
     return true;
 }
@@ -266,7 +272,7 @@ class Pick {
 /**
  * The mix time a query answers: `mark` of the voice it picks, among those cued and those that have
  * left, never the asker; or a mark the host announced on the score, which is the same time for
- * any of the four. Undefined while what it picks has no such time. A query naming no score looks
+ * any mark. Undefined while what it picks has no such time. A query naming no score looks
  * among the asker's siblings, the voices its owner holds.
  */
 function timeOf(mix, key, mark, self) {
@@ -290,8 +296,17 @@ function timeOf(mix, key, mark, self) {
         : listed
             ? holders(mix, score)
             : mix.transport.members;
+    // Voices forgotten on leaving answer only where no voice the mix still knows does.
+    const owner = self.owner?.id ?? -1;
+    const forgotten = new Pick(resolver, now);
     for (let i = 0; i < mixes.length; i++) {
         const m = mixes[i];
+        let departed = false;
+        for (const d of m.departed.all)
+            if (departedMatches(d, q, score, anywhere, owner)) {
+                forgotten.take(d.id, d.marks[mark]);
+                departed = true;
+            }
         if (score === undefined || m.projecting || mix.projecting) {
             for (const v of [...m.gone, ...m.cued])
                 if (matches(v))
@@ -300,7 +315,7 @@ function timeOf(mix, key, mark, self) {
         }
         const cued = scored(m, score);
         const list = scoredGone(m, score);
-        if (cued.size === 0 && list.length === 0) {
+        if (cued.size === 0 && list.length === 0 && !departed) {
             if (listed) {
                 unhold(m, score);
                 i--;
@@ -359,7 +374,7 @@ function timeOf(mix, key, mark, self) {
                 (q.name === undefined || a.name === q.name) &&
                 (q.tag === undefined || a.tags.includes(q.tag)))
                 picked.take(a.order, Number.isNaN(a.at) ? undefined : mixAt(mix, a.at));
-    return picked.answer();
+    return (picked.any ? picked : forgotten).answer();
 }
 /** `self`'s read of `m`'s gone voices for one query, started over where the list has changed under it. */
 function foldOf(m, list, key, mark, self, resolver) {

package/dist/project.d.ts

@@ -1,7 +1,18 @@
-import { Transport } from './transport.js';
+import { Mixer } from './mixer.js';
+import { type Cut, Transport } from './transport.js';
 import type { TransportProjection } from './types.js';
+import type { Subject, Voice } from './voice.js';
 /**
  * Every mix on a transport read at mix time `t`, through copies of them on a transport of their
  * own, moved together so an anchor across mixes answers as it would live.
  */
 export declare function projectAll(transport: Transport, t: number): TransportProjection;
+/** Sets each copied voice's state to what its clock and fade make it at `t`. */
+export declare function stateAt<I, O>(c: Mixer<I, O>, t: number): 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 projection back starts each subject from the latest copy kept at or before `t`, else from its
+ * voice's start with fresh state, which is exact for a voice stepped at a fixed interval.
+ */
+export declare function recall<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject: I, t: number, cut: Cut): Subject<unknown> | undefined;

package/dist/project.js

@@ -1,14 +1,16 @@
 import { ownBlends } from './blend.js';
-import { index } from './chain.js';
-import { copyHeld, last, leftAt } from './history.js';
+import { open, sighted, weightAt } from './everyone.js';
+import { copyHeld, last, lastWithin } from './history.js';
 import { Mixer } from './mixer.js';
 import { move } from './move.js';
 import { heldByInput, ownerReading, relink } from './owner.js';
 import { pin } from './place.js';
 import { reading } from './reading.js';
-import { Store } from './store.js';
+import { record } from './record.js';
+import { recount } from './roster.js';
+import { copyStanding, stands } from './standing.js';
 import { hostAt } from './tape.js';
-import { Transport } from './transport.js';
+import { Transport, within } from './transport.js';
 import { cover } from './unpage.js';
 import { unreached } from './unreached.js';
 /**
@@ -18,24 +20,36 @@ import { unreached } from './unreached.js';
 export function projectAll(transport, t) {
     const ahead = Number.isNaN(transport.now) || t >= transport.now;
     const tape = transport.tape;
-    const next = ahead && tape !== undefined ? tape.timestampAt(tape.undoDepth()) : undefined;
+    const stamp = ahead && tape !== undefined ? tape.timestampAt(tape.undoDepth()) : undefined;
+    const pace = transport.pace;
+    const next = stamp === undefined || pace === null ? stamp : pace.reading(stamp);
     if (next !== undefined && next <= t)
         throw new Error(`blits: the tape holds calls at ${next} that a read ahead to ${t} cannot play; seek there to see them`);
-    if (!ahead) {
-        const history = transport.history;
-        if (!history)
-            throw new Error('blits: reading back needs a mix made with history');
+    // Behind, the last frame at or before `t`, read as it showed when `t` is that frame's own time.
+    let cut = { seq: transport.seq, strict: false };
+    let u = hostAt(transport, t);
+    const kept = transport.history !== undefined;
+    if (!ahead && kept) {
         cover(transport, t);
+        const frame = transport.frames.at(t);
+        if (frame !== undefined) {
+            cut = { seq: frame.seq, strict: frame.at === t };
+            if (frame.at === t)
+                u = frame.u;
+        }
     }
-    const u = hostAt(transport, t);
-    const pace = transport.pace;
+    else if (!ahead)
+        stands(transport, t);
     const c = new Transport(undefined, true);
     c.offset = transport.offset;
     c.u = u;
     c.nextId = transport.nextId;
     c.now = ahead ? transport.now : t;
-    c.pace = pace === null ? null : pace.until(ahead ? Number.POSITIVE_INFINITY : u);
-    c.announced = (ahead ? transport.announced : transport.announced.filter((a) => a.made < t)).map((a) => ({ ...a }));
+    c.pace =
+        pace === null || !within(cut, transport.pacedSeq)
+            ? null
+            : pace.until(ahead ? Number.POSITIVE_INFINITY : u);
+    c.announced = (ahead ? transport.announced : transport.announced.filter((a) => within(cut, a.seq))).map((a) => ({ ...a }));
     const copies = new Map();
     for (const mix of transport.members) {
         const copy = new Mixer(mix.kit, {
@@ -49,8 +63,10 @@ export function projectAll(transport, t) {
         copies.set(mix, copy);
         if (ahead)
             copyAhead(mix, copy);
+        else if (kept)
+            copyBack(mix, copy, t, cut);
         else
-            copyBack(mix, copy, t);
+            copyStanding(mix, copy, t, cut);
     }
     if (ahead)
         for (const copy of copies.values())
@@ -83,13 +99,11 @@ export function projectAll(transport, t) {
 }
 /** A mix's copy for a read ahead: its voices as they stand, each subject carried from the live one. */
 function copyAhead(mix, c) {
-    c.pose = mix.pose;
-    c.wantsPose = mix.wantsPose;
-    c.reducedNow = mix.reducedNow;
+    mirror(mix, c);
     c.cued = mix.cued
         .filter((v) => v.state !== 'done')
         .map((v) => {
-        const copy = v.copy((subject) => carry(mix, v, subject));
+        const copy = v.copy((subject) => carry(mix, v, subject, c, copy), undefined, true);
         const at = mix.pins?.get(v);
         if (at !== undefined)
             pin(c, copy, at);
@@ -98,15 +112,14 @@ function copyAhead(mix, c) {
     ownBlends(c.cued);
     if (mix.owners !== null)
         relink(c.cued);
-    count(c);
+    recount(c);
 }
-/** A mix's copy for a read back to `t`: its voices then, from the controls and copies kept. */
-function copyBack(mix, c, t) {
-    c.pose = mix.pose;
-    c.wantsPose = mix.wantsPose;
-    c.reducedNow = mix.reducedNow;
+/** A mix's copy for a read back to `t`, cut at `cut`: its voices then, from the controls and copies kept. */
+function copyBack(mix, c, t, cut) {
+    mirror(mix, c);
     c.backward = true;
-    const was = last(mix.hostLog, t, true);
+    // Copied as the frame's first probe began, so its own frame shows it.
+    const was = lastWithin(mix.hostLog, { seq: cut.seq, strict: false });
     const host = mix.opts.host;
     const then = was && typeof host === 'object' && host !== null
         ? Object.assign(Object.create(host), was.fields)
@@ -114,11 +127,11 @@ function copyBack(mix, c, t) {
     if (was)
         c.hostThen = was;
     c.cued = [...mix.cued, ...mix.gone]
-        .filter((v) => v.cuedAt <= t && v.doneAt > t)
+        .filter((v) => v.cuedSeq <= cut.seq && !within(cut, v.doneSeq, true))
         .sort((a, b) => a.id - b.id)
         .map((v) => {
         const log = v.log;
-        const copy = v.copy((subject) => recall(mix, v, subject, t), last(log, t, (e) => e.sync) ?? log[0]);
+        const copy = v.copy((subject) => recall(mix, v, subject, t, cut), lastWithin(log, cut) ?? log[0]);
         if (then !== undefined)
             copy.setting.host = then;
         return copy;
@@ -126,30 +139,39 @@ function copyBack(mix, c, t) {
     ownBlends(c.cued);
     if (mix.owners !== null)
         relink(c.cued);
+    stateAt(c, t);
+    recount(c);
+}
+/** Sets each copied voice's state to what its clock and fade make it at `t`. */
+export function stateAt(c, t) {
     for (const copy of c.cued)
-        copy.state =
-            (copy.owner === null ? t : ownerReading(copy.owner, t)) < copy.start
+        copy.state = copy.out
+            ? 'fading'
+            : (copy.owner === null ? t : ownerReading(copy.owner, t)) < copy.start
                 ? 'pending'
-                : copy.out && copy.out.at <= t
-                    ? 'fading'
-                    : copy.freezesAfter && copy.elapsedAt(t) >= copy.span + copy.latest
-                        ? 'frozen'
-                        : 'live';
-    count(c);
+                : copy.freezesAfter && copy.elapsedAt(t) >= copy.span + copy.latest
+                    ? 'frozen'
+                    : 'live';
 }
-/** Recounts what the fold's shortcuts depend on, for a projection's freshly copied voices. */
-function count(mix) {
-    mix.named = new Store();
-    mix.naming = 0;
-    mix.general = [];
-    for (const voice of mix.cued)
-        index(mix, voice);
-    mix.loci = mix.cued.filter((v) => v.spec.locus !== undefined).length;
-    mix.anchored = mix.cued.filter((v) => v.spec.anchor !== undefined).length;
-    mix.steps.push(null, ++mix.version);
+/** 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.pose = mix.pose;
+    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. */
 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 = mix.chains.get(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;
@@ -157,12 +179,19 @@ function recordOf(mix, voice, subject) {
         ? voice.unreached
         : undefined;
 }
-/** A projection ahead starts each subject from where the live mix holds it. */
-function carry(mix, voice, subject) {
+/**
+ * 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(mix, voice, subject, c, copy) {
     const live = recordOf(mix, voice, subject);
     if (live === undefined)
         return undefined;
     const h = 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;
     return h;
 }
@@ -170,8 +199,8 @@ function carry(mix, voice, subject) {
  * A projection back starts each subject from the latest copy kept at or before `t`, else from its
  * voice's start with fresh state, which is exact for a voice stepped at a fixed interval.
  */
-function recall(mix, voice, subject, t) {
-    const live = leftAt(voice.left, subject, t) ?? recordOf(mix, voice, subject);
+export function recall(mix, voice, subject, t, cut) {
+    const live = voice.left?.at(subject, cut) ?? recordOf(mix, voice, subject);
     if (live === undefined)
         return undefined;
     const snap = live.snaps && last(live.snaps, t, true);
@@ -182,33 +211,18 @@ function recall(mix, voice, subject, t) {
         return h;
     }
     const stepped = live.since < t ? live.since : t;
-    return {
-        reaches: live.reaches,
-        delay: live.delay,
-        since: live.since,
-        shown: live.shown,
-        weight: 0,
-        rested: false,
-        bands: null,
-        state: live.reaches && voice.patch.state
-            ? voice.patch.state(subject)
-            : undefined,
-        stepped,
-        ticks: 0,
-        probed: Number.NaN,
-        delta: null,
-        phase: 0,
-        seeks: 0,
-        kept: null,
-        voice,
-        next: null,
-        version: Number.NaN,
-        loci: null,
-        slot: -1,
-        from: stepped,
-        unknown: voice.spec.from === 'current',
-        replay: live.inputs,
-    };
+    const h = record(voice, live.reaches, live.reaches && voice.patch.state
+        ? voice.patch.state(subject)
+        : undefined);
+    h.delay = live.delay;
+    h.since = live.since;
+    h.shown = live.shown;
+    h.stepped = stepped;
+    h.rebuilt = voice.rebuilds;
+    h.from = stepped;
+    h.unknown = voice.spec.from === 'current';
+    h.replay = live.inputs;
+    return h;
 }
 /** Per channel, the least sure voice that fed it this frame. */
 function doubts(mix, subject) {
@@ -231,19 +245,23 @@ function doubts(mix, subject) {
         for (const slot of voice.slots)
             out[mix.names[slot]] = 'held';
     }
-    for (let held = mix.chain(subject); held !== null; held = held.next) {
-        const voice = held.voice;
-        if (voice === null || voice.state === 'done')
-            continue;
-        if (held.weight <= 0)
-            continue;
+    const feed = (voice, held) => {
+        if (voice.state === 'done' || held.weight <= 0)
+            return;
         const d = doubtOf(mix, voice, held);
         for (const slot of voice.slots) {
             const name = mix.names[slot];
             if (rank[d] > rank[out[name]])
                 out[name] = d;
         }
-    }
+    };
+    for (let held = mix.chain(subject); held !== null; held = held.next)
+        if (held.voice !== null)
+            feed(held.voice, held);
+    // A voice sharing one record is in no chain; its record holds the weight the fold just gave.
+    for (const voice of mix.sharers)
+        if (voice.everyone !== null && voice.state !== 'pending')
+            feed(voice, voice.everyone);
     return out;
 }
 function doubtOf(mix, voice, held) {

package/dist/pull.d.ts

@@ -3,3 +3,5 @@ import type { Columns } from './types.js';
 /** After a probe, keeps the pose a retarget from `'current'` reads as the subject's last. */
 export declare function keep<I, O>(this: Mixer<I, O>, subject: I, pose: O, out: O | undefined): void;
 export declare function pull<I, O>(mix: Mixer<I, O>, subjects: Iterable<I>, into: Columns<O>): void;
+/** Forgets the array `pull` last read, whose heads a seek has made stale. */
+export declare function unpull<I, O>(mix: Mixer<I, O>): void;

package/dist/pull.js

@@ -174,3 +174,11 @@ function columnsOf(mix, into) {
     }
     return columns;
 }
+/** Forgets the array `pull` last read, whose heads a seek has made stale. */
+export function unpull(mix) {
+    mix.pulled = [];
+    mix.pulledHeads = [];
+    mix.pulledSlots = new Int32Array(0);
+    mix.pulledVersion = Number.NaN;
+    mix.pulledRelinks = -1;
+}

package/dist/qualify.js

@@ -1,6 +1,7 @@
 import { numericOf } from './channels.js';
 import { flush } from './columns.js';
 import { crowdable } from './crowd.js';
+import { weighAt } from './everyone.js';
 import { wake } from './fill.js';
 import { Lane } from './lane.js';
 import { bury, compactSparse, join, regroup, retouchRow, sameCrowds } from './rows.js';
@@ -169,6 +170,9 @@ export function requalify(lanes, version) {
         const ch = {
             name: host.names[slot],
             op: n.op,
+            plain: n.op !== 'last' && n.op !== 'own' && n.turn === undefined,
+            turn: n.turn ?? 0,
+            channel,
             scalar,
             rest: typeof rest === 'number' ? rest : rest[0],
             axes: n.axes,
@@ -332,8 +336,12 @@ function leave(lanes, lane) {
             const rec = lane.records[p];
             const slot = lane.list[p];
             const w = done ? undefined : lanes.reported(lane, slot);
-            if (rec !== undefined && w !== undefined)
-                rec.weight = w;
+            if (rec !== undefined && w !== undefined) {
+                if (lane.voice.sharing)
+                    weighAt(lane.voice, slot, w, lanes.cap);
+                else
+                    rec.weight = w;
+            }
             if (rec !== undefined && lane.motion !== undefined)
                 settle(lanes, lane, p, slot, rec);
         }

package/dist/reading.d.ts

@@ -20,4 +20,9 @@ export declare const reading: {
      * One count for every mix: a change to a spring in one mix refills the lanes of all of them.
      */
     moved: number;
+    /**
+     * How many changes an `input` signal has reported, in any mix, so a fill can tell an input moved
+     * since it read it. One count for every mix, as `moved` is.
+     */
+    inputs: number;
 };

package/dist/reading.js

@@ -20,4 +20,9 @@ export const reading = {
      * One count for every mix: a change to a spring in one mix refills the lanes of all of them.
      */
     moved: 0,
+    /**
+     * How many changes an `input` signal has reported, in any mix, so a fill can tell an input moved
+     * since it read it. One count for every mix, as `moved` is.
+     */
+    inputs: 0,
 };

package/dist/record.d.ts

@@ -0,0 +1,9 @@
+import type { Subject } from './voice.js';
+/**
+ * A subject's record for `voice` holding every field one can come to hold, in one order, so every
+ * record in a mix shares one hidden class: a record built elsewhere, or given `base`, `snaps` or
+ * `from` later, took a class of its own, and a fold walking a chain of several kinds reads each
+ * field the slow way. The caller sets what it knows; nothing here takes a number, which a call V8
+ * does not inline would box.
+ */
+export declare function record(voice: object | null, reaches: boolean, state: unknown): Subject<unknown>;