@msb235/blits 0.6.0 → 0.7.1

package/dist/place.js

@@ -1,6 +1,7 @@
 import { noted } from './history.js';
 import { markOf } from './marks.js';
 import { mixTime, ownerReading } from './owner.js';
+import { holders, scored, scoredGone, scoreVersion, unhold } from './scored.js';
 import { none } from './voice.js';
 /** What a voice's own owner's clock reads now: the mix clock for a voice no owner holds. */
 export function localNow(mix, voice) {
@@ -17,6 +18,7 @@ export function mixAt(mix, u) {
 export function pin(mix, voice, u) {
     mix.pins ??= new Map();
     mix.pins.set(voice, u);
+    voice.pinned = u;
 }
 /** Puts each pending voice's start, given in host time, where the mix's rate now puts it. */
 export function repin(mix) {
@@ -49,20 +51,23 @@ export function checkPlacement(mix, spec, anchor, owner) {
     const name = spec.name;
     if (name === undefined)
         return;
-    // A voice is known by its owner, its score and its name; a bare name in an anchor is in the
-    // asker's score under the asker's owner.
-    const key = (o, score, n) => `${o?.id ?? 0}\u0000${score ?? ''}\u0000${n}`;
-    const names = (p, score, o) => [p.start, p.in, p.out, p.end].flatMap((a) => {
-        if (a === undefined || typeof a === 'number')
-            return [];
+    // A voice is known by its owner, its score and its name, and by its mix where it names no score;
+    // a bare name in an anchor is in the asker's score under the asker's owner.
+    const key = (o, score, n, slot) => `${score === undefined ? slot : ''}\u0000${o?.id ?? 0}\u0000${score ?? ''}\u0000${n}`;
+    const named = (a, score, o, slot) => {
+        if ('all' in a)
+            return a.all.flatMap((m) => named(m, score, o, slot));
+        if ('any' in a)
+            return a.any.flatMap((m) => named(m, score, o, slot));
         const q = 'of' in a ? a.of : 'after' in a ? a.after : 'with' in a ? a.with : a.before;
         if (typeof q === 'string')
-            return [key(o, score, q)];
-        return q.name === undefined ? [] : [key(o, q.score ?? score, q.name)];
-    });
-    const self = key(owner, spec.score, name);
+            return [key(o, score, q, slot)];
+        return q.name === undefined ? [] : [key(o, q.score ?? score, q.name, slot)];
+    };
+    const names = (p, score, o, slot) => [p.start, p.in, p.out, p.end].flatMap((a) => a === undefined || typeof a === 'number' ? [] : named(a, score, o, slot));
+    const self = key(owner, spec.score, name, mix.slot);
     const seen = new Set();
-    const waits = names(anchor, spec.score, owner);
+    const waits = names(anchor, spec.score, owner, mix.slot);
     while (waits.length > 0) {
         const n = waits.pop();
         if (n === self)
@@ -70,11 +75,12 @@ export function checkPlacement(mix, spec, anchor, owner) {
         if (seen.has(n))
             continue;
         seen.add(n);
-        for (const v of mix.cued)
-            if (v.spec.name !== undefined &&
-                key(v.owner, v.spec.score, v.spec.name) === n &&
-                v.spec.anchor)
-                waits.push(...names(v.spec.anchor, v.spec.score, v.owner));
+        for (const m of mix.transport.members)
+            for (const v of m.cued)
+                if (v.spec.name !== undefined &&
+                    key(v.owner, v.spec.score, v.spec.name, m.slot) === n &&
+                    v.spec.anchor)
+                    waits.push(...names(v.spec.anchor, v.spec.score, v.owner, m.slot));
     }
 }
 /**
@@ -104,7 +110,7 @@ export function place(mix) {
                         moved = true;
                 }
             }
-            if (voice.state !== 'fading') {
+            if (voice.state !== 'fading' && !voice.outSet) {
                 const by = anchor.out ?? anchor.end;
                 const t = by === undefined ? undefined : resolve(mix, by, voice);
                 if (t !== undefined) {
@@ -127,6 +133,32 @@ function resolve(mix, a, self) {
     const o = self.owner;
     if (typeof a === 'number')
         return o === null ? mixAt(mix, a - mix.offset) : a;
+    if ('all' in a) {
+        let latest = Number.NEGATIVE_INFINITY;
+        for (const m of a.all) {
+            const t = member(mix, m, self);
+            if (t === undefined)
+                return undefined;
+            latest = Math.max(latest, t);
+        }
+        return a.all.length === 0 ? undefined : latest;
+    }
+    if ('any' in a) {
+        // A member still unknown may yet answer earlier than every known one, until one has passed.
+        const now = Number.isNaN(mix.now) ? Number.NEGATIVE_INFINITY : localNow(mix, self);
+        let earliest = Number.POSITIVE_INFINITY;
+        let unknown = false;
+        for (const m of a.any) {
+            const t = member(mix, m, self);
+            if (t === undefined)
+                unknown = true;
+            else
+                earliest = Math.min(earliest, t);
+        }
+        if (earliest === Number.POSITIVE_INFINITY)
+            return undefined;
+        return unknown && earliest > now ? undefined : earliest;
+    }
     let query;
     let mark;
     let by = a.by ?? 0;
@@ -147,7 +179,7 @@ function resolve(mix, a, self) {
         mark = 'start';
         by = -by;
     }
-    const t = timeOf(mix, typeof query === 'string' ? { name: query } : query, mark, self);
+    const t = timeOf(mix, query, mark, self);
     if (t === undefined)
         return undefined;
     if (o === null)
@@ -155,42 +187,202 @@ function resolve(mix, a, self) {
     const local = ownerReading(o, t);
     return Number.isFinite(local) ? local + by : undefined;
 }
+/**
+ * What one member of a join answers, or the time it last gave once its target has left, as a lone
+ * anchor keeps its voice where its target last put it.
+ */
+function member(mix, a, self) {
+    const t = resolve(mix, a, self);
+    if (t === undefined)
+        return self.answers?.get(a);
+    if (!mix.projecting) {
+        self.answers ??= new Map();
+        self.answers.set(a, t);
+    }
+    return t;
+}
+/** Picks among the times a query meets, as its resolver says, in the order they are met. */
+class Pick {
+    resolver;
+    now;
+    any = false;
+    firstOrder = Number.POSITIVE_INFINITY;
+    lastOrder = Number.NEGATIVE_INFINITY;
+    first;
+    last;
+    pick;
+    constructor(resolver, now) {
+        this.resolver = resolver;
+        this.now = now;
+    }
+    take(order, t) {
+        this.any = true;
+        if (order < this.firstOrder) {
+            this.firstOrder = order;
+            this.first = t;
+        }
+        if (order > this.lastOrder) {
+            this.lastOrder = order;
+            this.last = t;
+        }
+        if (t !== undefined)
+            this.consider(t);
+    }
+    /** Takes what `o` picked as though its times had been met here. */
+    merge(o) {
+        if (!o.any)
+            return;
+        this.any = true;
+        if (o.firstOrder < this.firstOrder) {
+            this.firstOrder = o.firstOrder;
+            this.first = o.first;
+        }
+        if (o.lastOrder > this.lastOrder) {
+            this.lastOrder = o.lastOrder;
+            this.last = o.last;
+        }
+        if (o.pick !== undefined)
+            this.consider(o.pick);
+    }
+    consider(t) {
+        const p = this.pick;
+        if (this.resolver === 'earliest'
+            ? p === undefined || t < p
+            : this.resolver === 'latest'
+                ? p === undefined || t > p
+                : this.resolver === 'next' && t >= this.now && (p === undefined || t < p))
+            this.pick = t;
+    }
+    answer() {
+        if (!this.any)
+            return undefined;
+        if (this.resolver === 'first')
+            return this.first;
+        if (this.resolver === 'last')
+            return this.last;
+        return this.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
  * among the asker's siblings, the voices its owner holds.
  */
-function timeOf(mix, q, mark, self) {
+function timeOf(mix, key, mark, self) {
+    const q = typeof key === 'string' ? { name: key } : key;
     const score = q.score ?? self.spec.score;
     const anywhere = q.score !== undefined;
-    const found = [];
-    for (const v of [...mix.gone, ...mix.cued])
-        if (v !== self &&
-            v.spec.score === score &&
-            (anywhere || v.owner === self.owner) &&
-            (q.name === undefined || v.spec.name === q.name) &&
-            (q.tag === undefined || (v.spec.tags ?? none).includes(q.tag)) &&
-            (q.writes === undefined || v.patch.writes.includes(q.writes)))
-            found.push({ order: v.id, t: markOf(mix, v, mark) });
+    const resolver = q.resolver ?? 'last';
+    const now = Number.isNaN(mix.now) ? Number.NEGATIVE_INFINITY : mix.now;
+    const picked = new Pick(resolver, now);
+    const matches = (v) => v !== self &&
+        v.spec.score === score &&
+        (anywhere || v.owner === self.owner) &&
+        (q.name === undefined || v.spec.name === q.name) &&
+        (q.tag === undefined || (v.spec.tags ?? none).includes(q.tag)) &&
+        (q.writes === undefined || v.patch.writes.includes(q.writes));
+    // A query naming a score looks in every mix on the transport that holds a voice on it; one
+    // naming none, in its own.
+    const listed = anywhere && score !== undefined && !mix.projecting;
+    const mixes = !anywhere
+        ? [mix]
+        : listed
+            ? holders(mix, score)
+            : mix.transport.members;
+    for (let i = 0; i < mixes.length; i++) {
+        const m = mixes[i];
+        if (score === undefined || m.projecting || mix.projecting) {
+            for (const v of [...m.gone, ...m.cued])
+                if (matches(v))
+                    picked.take(v.id, markOf(m, v, mark));
+            continue;
+        }
+        const cued = scored(m, score);
+        const list = scoredGone(m, score);
+        if (cued.size === 0 && list.length === 0) {
+            if (listed) {
+                unhold(m, score);
+                i--;
+            }
+            continue;
+        }
+        // `next` asks what is still ahead of now, which a running pick cannot keep.
+        if (resolver === 'next') {
+            for (const v of cued)
+                if (matches(v))
+                    picked.take(v.id, markOf(m, v, mark));
+            for (const v of list)
+                if (matches(v))
+                    picked.take(v.id, markOf(m, v, mark));
+            continue;
+        }
+        const fold = foldOf(m, list, key, mark, self, resolver);
+        const version = scoreVersion(m, score);
+        const reduced = m.reduced;
+        if (fold.live === null ||
+            fold.liveOf !== m.cued ||
+            fold.liveVersion !== version ||
+            fold.liveReduced !== reduced) {
+            const live = new Pick(resolver, Number.NEGATIVE_INFINITY);
+            let keeps = true;
+            for (const v of cued) {
+                if (!matches(v))
+                    continue;
+                if (v.owner !== null || v.holding !== null || v.fitting !== null)
+                    keeps = false;
+                live.take(v.id, markOf(m, v, mark));
+            }
+            fold.live = live;
+            fold.liveOf = keeps ? m.cued : null;
+            fold.liveVersion = version;
+            fold.liveReduced = reduced;
+        }
+        picked.merge(fold.live);
+        for (; fold.seen < list.length; fold.seen++) {
+            const v = list[fold.seen];
+            if (!matches(v))
+                continue;
+            if (v.owner === null)
+                fold.pick.take(v.id, markOf(m, v, mark));
+            else
+                fold.owned.push(v);
+        }
+        picked.merge(fold.pick);
+        for (const v of fold.owned)
+            picked.take(v.id, markOf(m, v, mark));
+    }
     if (q.writes === undefined && (anywhere || self.owner === null))
         for (const a of mix.announced)
             if (a.score === score &&
+                (score !== undefined || a.slot === mix.slot) &&
                 (q.name === undefined || a.name === q.name) &&
                 (q.tag === undefined || a.tags.includes(q.tag)))
-                found.push({ order: a.order, t: Number.isNaN(a.at) ? undefined : mixAt(mix, a.at) });
-    if (found.length === 0)
-        return undefined;
-    found.sort((x, y) => x.order - y.order);
-    const resolver = q.resolver ?? 'last';
-    if (resolver === 'first')
-        return found[0]?.t;
-    if (resolver === 'last')
-        return found[found.length - 1]?.t;
-    const times = found.flatMap((e) => (e.t === undefined ? [] : [e.t])).sort((x, y) => x - y);
-    if (resolver === 'next') {
-        const now = Number.isNaN(mix.now) ? Number.NEGATIVE_INFINITY : mix.now;
-        return times.find((t) => t >= now);
-    }
-    return resolver === 'earliest' ? times[0] : times[times.length - 1];
+                picked.take(a.order, Number.isNaN(a.at) ? undefined : mixAt(mix, a.at));
+    return picked.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) {
+    self.folds ??= new Map();
+    let byMix = self.folds.get(key);
+    if (byMix === undefined) {
+        byMix = new Map();
+        self.folds.set(key, byMix);
+    }
+    let fold = byMix.get(m);
+    if (fold === undefined || fold.list !== list || fold.mark !== mark) {
+        fold = {
+            list,
+            mark,
+            seen: 0,
+            pick: new Pick(resolver, Number.NEGATIVE_INFINITY),
+            owned: [],
+            live: null,
+            liveOf: null,
+            liveVersion: -1,
+            liveReduced: false,
+        };
+        byMix.set(m, fold);
+    }
+    return fold;
 }

package/dist/project.d.ts

@@ -1,4 +1,7 @@
-import type { Mixer } from './mixer.js';
-import type { Projection } from './types.js';
-/** A projection to `timestamp` through `c`, a mixer of its own the mix has just made. */
-export declare function project<I, O>(mix: Mixer<I, O>, c: Mixer<I, O>, timestamp: number): Projection<I, O>;
+import { Transport } from './transport.js';
+import type { TransportProjection } from './types.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;

package/dist/project.js

@@ -1,85 +1,60 @@
 import { ownBlends } from './blend.js';
 import { index } from './chain.js';
-import { copyHeld, last } from './history.js';
-import { readingAt } from './marks.js';
+import { copyHeld, last, leftAt } 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 { hostAt } from './tape.js';
+import { Transport } from './transport.js';
+import { cover } from './unpage.js';
 import { unreached } from './unreached.js';
-/** A projection to `timestamp` through `c`, a mixer of its own the mix has just made. */
-export function project(mix, c, timestamp) {
-    const u = timestamp - mix.offset;
-    const pace = mix.pace;
-    const t = readingAt(mix, u);
-    c.projecting = true;
-    c.pose = mix.pose;
-    c.offset = mix.offset;
-    c.u = u;
-    c.wantsPose = mix.wantsPose;
-    c.nextId = mix.nextId;
-    c.reducedNow = mix.reducedNow;
-    if (Number.isNaN(mix.now) || t >= mix.now) {
-        c.now = mix.now;
-        c.pace = pace === null ? null : pace.until(Number.POSITIVE_INFINITY);
-        c.cued = mix.cued
-            .filter((v) => v.state !== 'done')
-            .map((v) => {
-            const copy = v.copy((subject) => carry(mix, v, subject));
-            const at = mix.pins?.get(v);
-            if (at !== undefined)
-                pin(c, copy, at);
-            return copy;
-        });
-        ownBlends(c.cued);
-        if (mix.owners !== null)
-            relink(c.cued);
-        c.announced = mix.announced.map((a) => ({ ...a }));
-        count(c);
-        move(c, t);
-    }
-    else {
-        const history = mix.opts.history;
+/**
+ * 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 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;
+    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');
-        if (t < mix.now - history.ms)
-            throw new Error(`blits: ${timestamp} is older than this mix's history reaches`);
-        c.now = t;
-        c.pace = pace === null ? null : pace.until(u);
-        c.backward = true;
-        const was = last(mix.hostLog, t, true);
-        const host = mix.opts.host;
-        const then = was && typeof host === 'object' && host !== null
-            ? Object.assign(Object.create(host), was.fields)
-            : undefined;
-        if (was)
-            c.hostThen = was;
-        c.announced = mix.announced.filter((a) => a.made < t).map((a) => ({ ...a }));
-        c.cued = [...mix.cued, ...mix.gone]
-            .filter((v) => v.cuedAt <= t && v.doneAt > t)
-            .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]);
-            if (then !== undefined)
-                copy.setting.host = then;
-            return copy;
+        cover(transport, t);
+    }
+    const u = hostAt(transport, t);
+    const pace = transport.pace;
+    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 }));
+    const copies = new Map();
+    for (const mix of transport.members) {
+        const copy = new Mixer(mix.kit, {
+            ...mix.opts,
+            history: undefined,
+            lanes: false,
+            transport: c,
         });
-        ownBlends(c.cued);
-        if (mix.owners !== null)
-            relink(c.cued);
-        for (const copy of c.cued)
-            copy.state =
-                (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.slot = mix.slot;
+        copy.projecting = true;
+        copies.set(mix, copy);
+        if (ahead)
+            copyAhead(mix, copy);
+        else
+            copyBack(mix, copy, t);
     }
+    if (ahead)
+        for (const copy of copies.values())
+            move(copy, t);
     const read = (f) => {
         reading.live = false;
         try {
@@ -90,14 +65,78 @@ export function project(mix, c, timestamp) {
         }
     };
     return {
-        timestamp,
-        probe: (subject, out) => read(() => c.fold(subject, out)),
-        assess: (subject) => read(() => {
-            c.fold(subject);
-            return doubts(c, subject);
-        }),
+        timestamp: t,
+        of(mix) {
+            const copy = copies.get(mix);
+            if (copy === undefined)
+                throw new Error('blits: that mix is not on this transport');
+            return {
+                timestamp: t,
+                probe: (subject, out) => read(() => copy.fold(subject, out)),
+                assess: (subject) => read(() => {
+                    copy.fold(subject);
+                    return doubts(copy, subject);
+                }),
+            };
+        },
     };
 }
+/** 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;
+    c.cued = mix.cued
+        .filter((v) => v.state !== 'done')
+        .map((v) => {
+        const copy = v.copy((subject) => carry(mix, v, subject));
+        const at = mix.pins?.get(v);
+        if (at !== undefined)
+            pin(c, copy, at);
+        return copy;
+    });
+    ownBlends(c.cued);
+    if (mix.owners !== null)
+        relink(c.cued);
+    count(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;
+    c.backward = true;
+    const was = last(mix.hostLog, t, true);
+    const host = mix.opts.host;
+    const then = was && typeof host === 'object' && host !== null
+        ? Object.assign(Object.create(host), was.fields)
+        : undefined;
+    if (was)
+        c.hostThen = was;
+    c.cued = [...mix.cued, ...mix.gone]
+        .filter((v) => v.cuedAt <= t && v.doneAt > t)
+        .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]);
+        if (then !== undefined)
+            copy.setting.host = then;
+        return copy;
+    });
+    ownBlends(c.cued);
+    if (mix.owners !== null)
+        relink(c.cued);
+    for (const copy of c.cued)
+        copy.state =
+            (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);
+}
 /** Recounts what the fold's shortcuts depend on, for a projection's freshly copied voices. */
 function count(mix) {
     mix.named = new Store();
@@ -132,7 +171,7 @@ function carry(mix, voice, subject) {
  * 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 = recordOf(mix, voice, subject);
+    const live = leftAt(voice.left, subject, t) ?? recordOf(mix, voice, subject);
     if (live === undefined)
         return undefined;
     const snap = live.snaps && last(live.snaps, t, true);
@@ -192,7 +231,7 @@ function doubts(mix, subject) {
         for (const slot of voice.slots)
             out[mix.names[slot]] = 'held';
     }
-    for (let held = mix.chain(subject, mix.now); held !== null; held = held.next) {
+    for (let held = mix.chain(subject); held !== null; held = held.next) {
         const voice = held.voice;
         if (voice === null || voice.state === 'done')
             continue;

package/dist/pull.js

@@ -1,3 +1,4 @@
+import { axesOf } from './channels.js';
 import { copy } from './clone.js';
 import { clampRun, flush, pullRun, writeLater } from './columns.js';
 /** Writes a folded pose's value into subject `n`'s places in a column. */
@@ -128,14 +129,14 @@ function readAll(mix, list, columns, live, current, whole) {
                 const kept = heads[n];
                 const head = was[n] === subject && kept !== undefined && kept.version === version
                     ? kept
-                    : mix.chain(subject, now);
+                    : mix.chain(subject);
                 was[n] = subject;
                 heads[n] = head;
                 slot = head.slot;
                 slots[n] = slot;
             }
         }
-        const laned = live && lanes?.prepare(slot, subject, now, mix.version, heads[n] ?? null) === true;
+        const laned = live && lanes?.prepare(slot, subject, mix.version, heads[n] ?? null) === true;
         if (laned && whole && lanes.whole && !lanes.owes(slot)) {
             writeLater(lanes, slot, columns, n);
             continue;
@@ -160,7 +161,7 @@ function columnsOf(mix, into) {
             throw new Error(`blits: pull was handed ${key}, which the kit lacks`);
         const channel = mix.channels[slot];
         const rest = channel.rest;
-        const axes = Array.isArray(rest) ? rest.length : 1;
+        const axes = axesOf(channel);
         const bounds = channel.bounds;
         const at = new Float64Array(axes).fill(Number.NaN);
         if (typeof rest === 'number')

package/dist/qualify.js

@@ -163,11 +163,13 @@ export function requalify(lanes, version) {
             return;
         const channel = host.channels[slot];
         const n = numericOf(channel);
-        const rest = channel.rest;
+        // A rest-less channel's values are NaN until some voice passes the band: absent from the pose.
+        const rest = (channel.rest ?? Number.NaN);
+        const scalar = typeof rest === 'number' && n.axes === 1;
         const ch = {
             name: host.names[slot],
             op: n.op,
-            scalar: typeof rest === 'number',
+            scalar,
             rest: typeof rest === 'number' ? rest : rest[0],
             axes: n.axes,
             values: new Float64Array(lanes.cap * n.axes),