@msb235/blits 0.14.0 → 0.15.0

package/dist/cut.d.ts

@@ -0,0 +1,8 @@
+/** Where history is cut for a seek or read: what frame `seq` made, and before it, is kept. */
+export interface Cut {
+    seq: number;
+    /** For a read of what a frame showed: of that frame's own changes, only those made before it was read. */
+    strict: boolean;
+}
+/** Whether a change made in frame `seq` falls inside `cut`; `early` for one made before the frame was read. */
+export declare function within(cut: Cut, seq: number, early?: boolean): boolean;

package/dist/cut.js

@@ -0,0 +1,4 @@
+/** Whether a change made in frame `seq` falls inside `cut`; `early` for one made before the frame was read. */
+export function within(cut, seq, early = false) {
+    return seq < cut.seq || (seq === cut.seq && (!cut.strict || early));
+}

package/dist/drop.d.ts

@@ -0,0 +1,9 @@
+import { releasing } from './history.js';
+import type { Mixer } from './mixer.js';
+import type { Motions } from './motions.js';
+import type { Voice } from './voice.js';
+export declare function drop<I, O>(this: Mixer<I, O>, subject: I): void;
+/** Lets `voice` go of a dropped subject. Methods rather than closures, so a drop makes neither. */
+export declare function forgetIn<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, kept: ReturnType<typeof releasing>): void;
+export declare function releaseIn<I, O>(this: Mixer<I, O>, motion: Motions<I>, subject: I, kept: ReturnType<typeof releasing>): void;
+export declare function recordDrop<I, O>(this: Mixer<I, O>, subject: I): void;

package/dist/drop.js

@@ -0,0 +1,84 @@
+import { headOf, unlink } from './chain.js';
+import { leaveVoice } from './fade.js';
+import { goneIndex } from './gone.js';
+import { releasing } from './history.js';
+import { nextFrame } from './move.js';
+import { Masked } from './store.js';
+import { record, taping, unplayable } from './tape.js';
+export function drop(subject) {
+    this.frame = nextFrame();
+    const head = headOf(this, subject);
+    // Nothing that kept this head, such as `pull`'s remembered list, may take it as current again.
+    if (head !== undefined)
+        unlink(this, head);
+    // A number a seek carried over is released even where its chain is not linked since.
+    const slot = this.chains.get(subject)?.slot ?? -1;
+    if (slot >= 0 && this.lanes !== null)
+        this.lanes.release(slot);
+    // A read ahead's copy reads the live mix's poses, and so hides one where the mix deletes it.
+    if (this.projecting && !(this.lastPoses instanceof Masked))
+        this.lastPoses = new Masked(this.lastPoses);
+    if (!this.projecting)
+        this.places?.drop(subject);
+    this.lastPoses.delete(subject);
+    this.restStamps?.delete(subject);
+    this.chains.delete(subject);
+    this.stir();
+    // A record of it is only in a voice over every subject, one naming it, or one gone; a ramp out
+    // of a voice that does not name it is in `parters`, and a patch's own state in `motions`.
+    const kept = releasing(this);
+    for (const voice of this.general)
+        this.forgetIn(voice, subject, kept);
+    const named = this.named.get(subject);
+    if (named !== undefined)
+        for (const voice of [...named])
+            this.forgetIn(voice, subject, kept);
+    const gone = goneIndex(this);
+    for (const voice of gone.general)
+        this.forgetIn(voice, subject, kept);
+    const goneNaming = gone.named.get(subject);
+    if (goneNaming !== undefined)
+        for (const voice of goneNaming)
+            this.forgetIn(voice, subject, kept);
+    if (this.owners !== null)
+        for (const voice of this.owners)
+            this.forgetIn(voice, subject, kept);
+    for (const voice of this.parters) {
+        this.forgetIn(voice, subject, kept);
+        if (voice.parts?.size === 0)
+            voice.parts = null;
+        if (voice.parted?.size === 0)
+            voice.parted = null;
+        if (voice.parts === null && voice.parted === null)
+            this.parters.delete(voice);
+    }
+    const strays = this.strays.get(subject);
+    if (strays !== undefined)
+        for (const motion of strays)
+            this.releaseIn(motion, subject, kept);
+    this.strays.delete(subject);
+    for (const motion of this.strayAll)
+        this.releaseIn(motion, subject, kept);
+    if (taping(this))
+        this.recordDrop(subject);
+}
+/** Lets `voice` go of a dropped subject. Methods rather than closures, so a drop makes neither. */
+export function forgetIn(voice, subject, kept) {
+    leaveVoice(this, voice, subject);
+    voice.subjects.delete(subject);
+    if (voice.motion !== undefined)
+        this.releaseIn(voice.motion, subject, kept);
+    voice.parts?.delete(subject);
+    voice.parted?.delete(subject);
+    voice.blend?.of.reads.delete(subject);
+}
+// A motion patch's state is the live mix's alone: a read ahead cannot start a subject afresh in it.
+export function releaseIn(motion, subject, kept) {
+    if (!this.projecting)
+        motion.release(subject, kept[0], kept[1], kept[2], kept[3]);
+    else if (motion.holds(subject))
+        unplayable('a drop of a subject a motion patch holds');
+}
+export function recordDrop(subject) {
+    record(this, 'drop', (stage) => stage.mix(this)?.drop(subject));
+}

package/dist/due.d.ts

@@ -1,10 +1,29 @@
 import type { Mixer } from './mixer.js';
 import type { Voice } from './voice.js';
-/** One entry in a mix's due queue; stale once its voice has been scheduled again. */
-export interface Due<I, O> {
-    at: number;
-    voice: Voice<I, O>;
-    token: number;
+/**
+ * Live voices by the earliest mix time `moveTo` would change each, a binary heap. The times sit in
+ * one flat array, so a sift reads no voice: at 40,000 voices a stop's sift to the top missed the
+ * cache at each of its levels. An entry is stale once its voice has been scheduled again.
+ */
+export declare class DueQueue<I, O> {
+    size: number;
+    private at;
+    private tokens;
+    private voices;
+    /** The size past which stale entries are pruned, so a voice rescheduled often cannot grow it. */
+    private limit;
+    push(at: number, voice: Voice<I, O>, token: number): void;
+    /** The earliest entry's time, Infinity while empty. */
+    first(): number;
+    /** Takes off the earliest entry, giving its voice where it is current and undefined where stale. */
+    pop(): Voice<I, O> | undefined;
+    clear(): void;
+    private move;
+    /** Puts an entry in the hole at `i` and sifts it down to where it belongs. */
+    private sink;
+    private grow;
+    /** Drops the entries made stale by a later one and heapifies what is left. */
+    private prune;
 }
 /** Files a voice in the due queue at its current due, replacing any entry it had. */
 export declare function schedule<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): void;

package/dist/due.js

@@ -1,3 +1,108 @@
+/**
+ * Live voices by the earliest mix time `moveTo` would change each, a binary heap. The times sit in
+ * one flat array, so a sift reads no voice: at 40,000 voices a stop's sift to the top missed the
+ * cache at each of its levels. An entry is stale once its voice has been scheduled again.
+ */
+export class DueQueue {
+    size = 0;
+    at = new Float64Array(64);
+    tokens = new Float64Array(64);
+    voices = [];
+    /** The size past which stale entries are pruned, so a voice rescheduled often cannot grow it. */
+    limit = 64;
+    push(at, voice, token) {
+        if (this.size >= this.limit)
+            this.prune();
+        if (this.size === this.at.length)
+            this.grow();
+        const ats = this.at;
+        let i = this.size++;
+        while (i > 0) {
+            const up = (i - 1) >> 1;
+            if (ats[up] <= at)
+                break;
+            this.move(up, i);
+            i = up;
+        }
+        ats[i] = at;
+        this.tokens[i] = token;
+        this.voices[i] = voice;
+    }
+    /** The earliest entry's time, Infinity while empty. */
+    first() {
+        return this.size > 0 ? this.at[0] : Number.POSITIVE_INFINITY;
+    }
+    /** Takes off the earliest entry, giving its voice where it is current and undefined where stale. */
+    pop() {
+        const voice = this.voices[0];
+        const token = this.tokens[0];
+        const last = --this.size;
+        if (last > 0)
+            this.sink(0, this.at[last], this.tokens[last], this.voices[last]);
+        this.voices[last] = undefined;
+        return token === voice.dueToken && voice.state !== 'done' ? voice : undefined;
+    }
+    clear() {
+        this.size = 0;
+        this.voices = [];
+        this.limit = 64;
+    }
+    move(from, to) {
+        this.at[to] = this.at[from];
+        this.tokens[to] = this.tokens[from];
+        this.voices[to] = this.voices[from];
+    }
+    /** Puts an entry in the hole at `i` and sifts it down to where it belongs. */
+    sink(i, at, token, voice) {
+        const ats = this.at;
+        const n = this.size;
+        for (;;) {
+            const l = 2 * i + 1;
+            const r = l + 1;
+            let m = i;
+            let least = at;
+            if (l < n && ats[l] < least) {
+                m = l;
+                least = ats[l];
+            }
+            if (r < n && ats[r] < least)
+                m = r;
+            if (m === i)
+                break;
+            this.move(m, i);
+            i = m;
+        }
+        ats[i] = at;
+        this.tokens[i] = token;
+        this.voices[i] = voice;
+    }
+    grow() {
+        const at = new Float64Array(this.at.length * 2);
+        at.set(this.at);
+        this.at = at;
+        const tokens = new Float64Array(this.tokens.length * 2);
+        tokens.set(this.tokens);
+        this.tokens = tokens;
+    }
+    /** Drops the entries made stale by a later one and heapifies what is left. */
+    prune() {
+        let n = 0;
+        for (let k = 0; k < this.size; k++) {
+            const voice = this.voices[k];
+            if (this.tokens[k] !== voice.dueToken)
+                continue;
+            if (n !== k)
+                this.move(k, n);
+            n++;
+        }
+        for (let k = n; k < this.size; k++)
+            this.voices[k] = undefined;
+        this.size = n;
+        for (let k = (n >> 1) - 1; k >= 0; k--)
+            this.sink(k, this.at[k], this.tokens[k], this.voices[k]);
+        this.limit = Math.max(64, 2 * n);
+    }
+}
 /**
  * The earliest mix time `moveTo` would change a voice: its start, its anchored out, the end of
  * its last pass, the end of its fade or of a subject's ramp out; -Infinity where it must be
@@ -59,43 +164,18 @@ export function schedule(mix, voice) {
     const due = dueOf(mix, voice);
     if (due === Number.POSITIVE_INFINITY)
         return;
-    const heap = mix.due;
-    heap.push({ at: Number.isNaN(due) ? Number.NEGATIVE_INFINITY : due, voice, token });
-    let i = heap.length - 1;
-    while (i > 0) {
-        const up = (i - 1) >> 1;
-        if (heap[up].at <= heap[i].at)
-            break;
-        [heap[up], heap[i]] = [heap[i], heap[up]];
-        i = up;
-    }
+    mix.due.push(Number.isNaN(due) ? Number.NEGATIVE_INFINITY : due, voice, token);
 }
 /** Takes every current entry due by `now` off the queue, in cue order. */
 export function popDue(mix, now) {
-    const heap = mix.due;
-    const at = (k) => k < heap.length ? heap[k].at : Number.POSITIVE_INFINITY;
+    const queue = mix.due;
     const out = [];
-    while (heap.length > 0 && heap[0].at <= now) {
-        const top = heap[0];
-        const last = heap.pop();
-        if (heap.length > 0) {
-            heap[0] = last;
-            let i = 0;
-            for (;;) {
-                const l = 2 * i + 1;
-                const r = l + 1;
-                const m0 = at(l) < at(i) ? l : i;
-                const m = at(r) < at(m0) ? r : m0;
-                if (m === i)
-                    break;
-                [heap[m], heap[i]] = [heap[i], heap[m]];
-                i = m;
-            }
-        }
-        if (top.token === top.voice.dueToken && top.voice.state !== 'done') {
-            top.voice.dueToken++;
-            out.push(top.voice);
-        }
+    while (queue.first() <= now) {
+        const voice = queue.pop();
+        if (voice === undefined)
+            continue;
+        voice.dueToken++;
+        out.push(voice);
     }
     return byId(out);
 }

package/dist/easing.d.ts

@@ -1,6 +1,6 @@
 import type { Easing } from './types.js';
 /**
- * A curve on 0..1: the function an easing stands for.
+ * The function an easing stands for, a curve on 0..1.
  *
  * @category patch
  */
@@ -11,9 +11,9 @@ export type Curve = (u: number) => number;
  */
 export declare function startSlope(c: Curve): number;
 /**
- * The function an easing names: a CSS name, a `bezier` or `steps`, or a function, which comes back
- * as it is. Call it once where a curve is built, not per frame; the same name or easing object
- * gives the same function each time.
+ * The function an easing names. The easing is a CSS name, a `bezier` or `steps`, or a function,
+ * which comes back as it is. Call it once where a curve is built, not per frame; the same name or
+ * easing object gives the same function each time.
  *
  * @category patch
  */

package/dist/easing.js

@@ -72,9 +72,9 @@ export function startSlope(c) {
     return v > 1e-3 ? Number.POSITIVE_INFINITY : v / h;
 }
 /**
- * The function an easing names: a CSS name, a `bezier` or `steps`, or a function, which comes back
- * as it is. Call it once where a curve is built, not per frame; the same name or easing object
- * gives the same function each time.
+ * The function an easing names. The easing is a CSS name, a `bezier` or `steps`, or a function,
+ * which comes back as it is. Call it once where a curve is built, not per frame; the same name or
+ * easing object gives the same function each time.
  *
  * @category patch
  */

package/dist/everyone.d.ts

@@ -1,5 +1,6 @@
 import type { Mixer } from './mixer.js';
-import type { Subject, Voice } from './voice.js';
+import type { Subject } from './subject.js';
+import type { Voice } from './voice.js';
 /**
  * Whether a voice can keep one record for every subject, decided when it is cued. A record holds
  * what a voice knows of one subject; where the voice is over every subject with no stagger, keeps
@@ -60,7 +61,7 @@ export declare function unsight<I, O>(voice: Voice<I, O>, slot: number): void;
  */
 export declare function unshare<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, kept?: boolean, keeper?: I): void;
 /**
- * Counts what makes a mix's fold more than a walk of each chain: a locus, a voice sharing one
+ * Counts what makes a mix's fold more than a walk of each chain: a role, a voice sharing one
  * record, a voice that stopped sharing this frame. Called wherever one of the three changes, so
  * `foldWith` asks one number.
  */

package/dist/everyone.js

@@ -22,7 +22,7 @@ export function shares(mix, voice) {
         voice.named === null &&
         spec.target === undefined &&
         spec.stagger === undefined &&
-        spec.locus === undefined &&
+        spec.role === undefined &&
         spec.anchor === undefined &&
         spec.from !== 'current' &&
         typeof spec.weight !== 'function' &&
@@ -234,12 +234,12 @@ export function unshare(mix, voice, kept = false, keeper) {
     mix.lanes?.refill();
 }
 /**
- * Counts what makes a mix's fold more than a walk of each chain: a locus, a voice sharing one
+ * Counts what makes a mix's fold more than a walk of each chain: a role, a voice sharing one
  * record, a voice that stopped sharing this frame. Called wherever one of the three changes, so
  * `foldWith` asks one number.
  */
 export function detour(mix) {
-    mix.detours = mix.loci + mix.sharers.length + (mix.unshared ? 1 : 0);
+    mix.detours = mix.roleVoices + mix.sharers.length + (mix.unshared ? 1 : 0);
 }
 /** Gives a record just made for a subject a sharing voice had seen what the voice kept for it. */
 export function inherit(voice, held, slot) {

package/dist/fade.d.ts

@@ -1,5 +1,6 @@
 import type { Mixer } from './mixer.js';
-import type { Left, Parted, Parting, Voice } from './voice.js';
+import type { Left, Parted, Parting } from './subject.js';
+import type { Voice } from './voice.js';
 /** Starts one subject's ramp out of a voice, or takes it out at once for a ramp of 0. */
 export declare function fadeSubject<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject: I, over?: number): void;
 /** What a subject's own ramp out of a voice leaves of its weight this frame, 0..1. */

package/dist/fade.js

@@ -6,6 +6,7 @@ import { leave, noted, releasing } from './history.js';
 import { markOf } from './marks.js';
 import { orphan, ownerReading } from './owner.js';
 import { startOf } from './place.js';
+import { isRested } from './record.js';
 import { scoreTouched } from './scored.js';
 import { lingers, refit } from './spans.js';
 import { unreach } from './unreached.js';
@@ -111,7 +112,7 @@ function forgetIn(mix, voice, subject) {
         voice.subjects.delete(subject);
         if (held.reaches)
             voice.seen--;
-        if (held.rested)
+        if (isRested(held))
             voice.restedCount--;
         if (voice.holder === held)
             voice.holder = null;

package/dist/fill.d.ts

@@ -2,7 +2,8 @@ import { type Lane, type Laned, type Paced } from './lane.js';
 import type { Lanes } from './lanes.js';
 import { absent } from './numbers.js';
 import { type Scratch } from './patch.js';
-import type { Subject, Voice } from './voice.js';
+import type { Subject } from './subject.js';
+import type { Voice } from './voice.js';
 export declare function fillAll<I, O>(lanes: Lanes<I, O>, now: number, version: number): void;
 /** Leaves a lane's subjects to the general path until it wakes, keeping what `weightOf` reports. */
 export declare function rest<I, O>(lanes: Lanes<I, O>, lane: Paced): void;
@@ -31,7 +32,7 @@ export declare function runEveryone<I, O>(this: Lanes<I, O>, lane: Lane<I, O>):
 /**
  * One subject's contribution from a lane's voice. True where the voice gave the subject a delta,
  * as the general path's `contribution` does where it returns one, which is what makes a voice in a
- * locus one of its members for the subject.
+ * role one of its members for the subject.
  */
 export declare function one<I, O>(this: Lanes<I, O>, lane: Lane<I, O>, p: number, slot: number): boolean;
 /**

package/dist/fill.js

@@ -1,11 +1,13 @@
+import { runBounded } from './bound.js';
 import { foldNumber, lerpNumber } from './channels.js';
 import { passAt, phaseAt, same, silent, weighed } from './clock.js';
 import { flush } from './columns.js';
 import { crowdsUpTo, freshen } from './crowd.js';
 import { open as openRecord, shut as shutRecord } from './everyone.js';
 import { unband } from './fold.js';
-import { foldLocus, gatherLocus } from './gather.js';
+import { foldRole, gatherRole, runRole } from './gather.js';
 import { runKeys } from './keyfill.js';
+import { keepProbed } from './lane.js';
 import { reach } from './meet.js';
 import { absent } from './numbers.js';
 import { AT, NOTHING, readKeys, seg, segment, shifted } from './patch.js';
@@ -15,6 +17,8 @@ import { rested } from './turns.js';
 // V8 reads a local const as a constant, where it reads an import from its module on every call.
 const open = openRecord;
 const shut = shutRecord;
+/** The last `Arg.MARK` handed out, by every mix's lanes, so no two placings share one. */
+let marks = 0;
 /** The least prime at least `n`, and 1 below 2. */
 function primeFrom(n) {
     if (n < 2)
@@ -34,6 +38,7 @@ export function fillAll(lanes, now, version) {
     flush(lanes);
     const host = lanes.host;
     lanes.filling = true;
+    const lookups = lanes.lookups;
     try {
         lanes.fills++;
         lanes.owed.begin(lanes.fills);
@@ -84,17 +89,21 @@ export function fillAll(lanes, now, version) {
         if (busy) {
             for (const ch of lanes.laned)
                 rested(ch, size);
-            for (const g of lanes.loci)
-                gatherLocus(lanes, g);
+            for (const g of lanes.roles)
+                gatherRole(lanes, g);
             for (const lane of lanes.lanes) {
                 if (lane.idle)
                     continue;
-                if (lanes.crowds.length > 0)
+                if (lanes.crowds.length > 0) {
+                    lanes.arg[6 /* Arg.MARK */] = Number.NaN;
                     crowdsUpTo(lanes, lane.voice.id);
+                }
                 lanes.run(lane);
             }
-            if (lanes.crowds.length > 0)
+            if (lanes.crowds.length > 0) {
+                lanes.arg[6 /* Arg.MARK */] = Number.NaN;
                 crowdsUpTo(lanes, Number.POSITIVE_INFINITY);
+            }
             for (const c of lanes.crowds)
                 if (!c.idle) {
                     c.bareFill = lanes.fills;
@@ -111,6 +120,7 @@ export function fillAll(lanes, now, version) {
         }
         lanes.moved = reading.moved;
         lanes.inputs = reading.inputs;
+        lanes.holds = lanes.lookups !== lookups;
     }
     finally {
         lanes.filling = false;
@@ -162,10 +172,7 @@ export function rest(lanes, lane) {
             continue;
         reach(lanes, slot, 1);
         // A probe read this subject from the last fill, which this lane's weight stays from.
-        if (lanes.per[slot * 6 /* Per.SLOT */ + 5 /* Per.LANE_FILL */] === lanes.fills - 1) {
-            const o = p * 8 /* Row.STRIDE */;
-            data[o + 3 /* Row.PROBED */] = data[o + 2 /* Row.WEIGHT */];
-        }
+        keepProbed(data, p * 8 /* Row.STRIDE */, lanes.per, slot * 6 /* Per.SLOT */, lanes.fills);
     }
 }
 export function wake(lanes, lane) {
@@ -205,6 +212,7 @@ export function parting(voice, slot) {
     return subject === absent ? 1 : this.host.parting(voice, subject);
 }
 export function subjectAt(slot) {
+    this.lookups++;
     let subject = this.subjects[slot];
     if (subject === undefined) {
         subject = this.numbers.subject(slot);
@@ -217,6 +225,7 @@ export function subjectAt(slot) {
 export function reset(lane) {
     const voice = lane.voice;
     lane.placed = false;
+    this.arg[6 /* Arg.MARK */] = Number.NaN;
     lane.read = false;
     lane.weighed = false;
     // With no fade in or out the envelope is 1 for every subject, which is what it would return.
@@ -232,11 +241,16 @@ export function run(lane) {
     const voice = lane.voice;
     if (voice.state === 'pending' || voice.state === 'done')
         return;
-    if (lane.group !== null) {
-        foldLocus(this, lane, lane.group);
+    const g = lane.group;
+    if (g !== null) {
+        if (!g.inline)
+            foldRole(this, lane, g);
+        else if (lane === g.members[0])
+            runRole(this, g);
         return;
     }
     this.reset(lane);
+    lane.ran = this.fills;
     if (lane.motion !== undefined && !voice.keeping) {
         runMotion(this, lane, lane.motion);
         return;
@@ -251,6 +265,10 @@ export function run(lane) {
         this.runEveryone(lane);
         return;
     }
+    if (voice.bound !== null) {
+        runBounded(this, lane, voice.bound);
+        return;
+    }
     for (let p = 0; p < list.length; p++) {
         this.one(lane, p, list[p]);
         // Its patch just made kept state: no further call this fill, the general path makes them.
@@ -281,7 +299,7 @@ export function runEveryone(lane) {
 /**
  * One subject's contribution from a lane's voice. True where the voice gave the subject a delta,
  * as the general path's `contribution` does where it returns one, which is what makes a voice in a
- * locus one of its members for the subject.
+ * role one of its members for the subject.
  */
 export function one(lane, p, slot) {
     const host = this.host;
@@ -290,9 +308,7 @@ export function one(lane, p, slot) {
     const arg = this.arg;
     const data = lane.data;
     const o = p * 8 /* Row.STRIDE */;
-    // A probe read this subject from the last fill: keep the weight it read for `weightOf`.
-    if (this.per[slot * 6 /* Per.SLOT */ + 5 /* Per.LANE_FILL */] === this.fills - 1)
-        data[o + 3 /* Row.PROBED */] = data[o + 2 /* Row.WEIGHT */];
+    keepProbed(data, o, this.per, slot * 6 /* Per.SLOT */, this.fills);
     if (this.lately >= 0 && this.unread(slot))
         return false;
     const delay = data[o + 0 /* Row.DELAY */];
@@ -319,6 +335,8 @@ export function one(lane, p, slot) {
         lane.placedAt = elapsed;
         lane.phase = phaseAt(elapsed, voice.duration, voice.passes);
         lane.pass = passAt(elapsed, voice.duration, voice.passes);
+        arg[6 /* Arg.MARK */] = ++marks;
+        lane.mark = arg[6 /* Arg.MARK */];
     }
     const since = data[o + 1 /* Row.SINCE */];
     if (!lane.flat && (!lane.weighed || !same(since, lane.weighedSince))) {
@@ -352,6 +370,14 @@ export function one(lane, p, slot) {
             lane.readAt = elapsed;
             this.gather(lane, lane.delta);
         }
+        // A signal is handed the gap since the subject's last read, which this read is, as it is on
+        // the general path; the record's delta is not this read's, so a probe reads it again.
+        if (typeof voice.spec.weight === 'function') {
+            const rec = lane.records[p];
+            rec.probed = this.now;
+            rec.seeks = voice.seeks;
+            rec.delta = null;
+        }
         if (w > 0) {
             arg[0 /* Arg.WEIGHT */] = w;
             this.fold(lane, slot);
@@ -359,8 +385,9 @@ export function one(lane, p, slot) {
         return true;
     }
     const rec = lane.records[p];
-    // The general path makes a voice's first call for a subject, where it first sees it play.
-    if (Number.isNaN(rec.probed)) {
+    // The general path makes a voice's first call for a subject, where it first sees it play, or a
+    // probe meeting the voice makes it here, or the fill of a lane that took every subject.
+    if (Number.isNaN(rec.probed) && !this.meeting && !lane.every) {
         this.late.push(slot);
         return false;
     }
@@ -399,7 +426,7 @@ export function foldKeys(voice, chans, slot) {
         const a = seg.a;
         const b = seg.b;
         const u = seg.eased;
-        if (ch.scalar || !ch.plain) {
+        if (ch.scalar || !ch.plain || !ch.straight) {
             this.foldInto(ch, slot, voice.lerps[i](a, b, u));
             continue;
         }
@@ -440,8 +467,13 @@ export function call(voice, chans, rec, slot) {
             this.foldDelta(chans, slot, rec.delta);
         return true;
     }
-    if (silent(voice, w))
+    if (silent(voice, w)) {
+        // As `contribution` leaves a silent read, so the next one is handed the same `dt`.
+        rec.delta = null;
+        rec.probed = this.now;
+        rec.seeks = voice.seeks;
         return false;
+    }
     const kept = reading.kept;
     host.ready(voice, subject, rec);
     if (this.keeps)