@msb235/blits 0.10.0 → 0.12.0

package/dist/departed.js

@@ -1,20 +1,34 @@
-import { markOf } from './marks.js';
+import { markOf, voiceMarks } from './marks.js';
 import { none } from './voice.js';
-const MARKS = ['start', 'in', 'coast', 'out', 'end'];
+/** A departed voice's marks: its five as fields, so it stays in fast mode, on no prototype. */
+class Marks {
+    start = undefined;
+    in = undefined;
+    coast = undefined;
+    out = undefined;
+    end = undefined;
+}
+Object.setPrototypeOf(Marks.prototype, null);
 /**
  * The departed voices a query could still pick: for each name, tag and channel within a score and
  * owner, the first and the last to leave. It grows with those, never with how many voices left.
  */
 export class DepartedIndex {
-    ends = new Map();
+    scopes = new Map();
     all = new Set();
     add(mix, voice) {
         // Nothing can be cued beside a voice whose owner has gone, so nothing will ask for it.
         if (voice.owner?.state === 'done')
             return;
-        const marks = {};
-        for (const mark of MARKS)
+        const marks = new Marks();
+        for (let i = 0; i < voiceMarks.length; i++) {
+            const mark = voiceMarks[i];
             marks[mark] = markOf(mix, voice, mark);
+        }
+        const inner = voice.spec.marks;
+        if (inner !== undefined)
+            for (const mark of Object.keys(inner))
+                marks[mark] = markOf(mix, voice, mark);
         const d = {
             id: voice.id,
             score: voice.spec.score,
@@ -25,25 +39,19 @@ export class DepartedIndex {
             marks,
             held: 0,
         };
-        const base = `${d.score ?? ''}\u0000${d.owner}\u0000`;
-        const keys = [`${base}w`];
-        if (d.name !== undefined)
-            keys.push(`${base}n\u0000${d.name}`);
-        for (const tag of d.tags)
-            keys.push(`${base}t\u0000${tag}`);
-        for (const ch of d.writes)
-            keys.push(`${base}c\u0000${String(ch)}`);
-        for (const key of keys) {
-            const end = this.ends.get(key);
-            if (end === undefined) {
-                this.ends.set(key, { first: d, last: d });
-                d.held += 2;
-                continue;
-            }
-            this.release(end.last);
-            end.last = d;
-            d.held++;
+        const scope = this.scopeOf(d.score, d.owner);
+        if (scope.whole === undefined) {
+            scope.whole = { first: d, last: d };
+            d.held += 2;
         }
+        else
+            this.hold(scope.whole, d);
+        if (d.name !== undefined)
+            this.keep(scope.names, d.name, d);
+        for (let i = 0; i < d.tags.length; i++)
+            this.keep(scope.tags, d.tags[i], d);
+        for (let i = 0; i < d.writes.length; i++)
+            this.keep(scope.writes, d.writes[i], d);
         if (d.held > 0)
             this.all.add(d);
         if (voice.holding !== null)
@@ -51,12 +59,51 @@ export class DepartedIndex {
     }
     /** Lets go of the voices an owner that has left held: nothing can be cued beside them again. */
     dropOwner(owner) {
-        for (const [key, end] of this.ends)
-            if (end.first.owner === owner) {
-                this.ends.delete(key);
-                this.all.delete(end.first);
-                this.all.delete(end.last);
-            }
+        for (const owners of this.scopes.values()) {
+            const scope = owners.get(owner);
+            if (scope === undefined)
+                continue;
+            owners.delete(owner);
+            if (scope.whole !== undefined)
+                this.forget(scope.whole);
+            for (const end of scope.names.values())
+                this.forget(end);
+            for (const end of scope.tags.values())
+                this.forget(end);
+            for (const end of scope.writes.values())
+                this.forget(end);
+        }
+    }
+    scopeOf(score, owner) {
+        let owners = this.scopes.get(score);
+        if (owners === undefined) {
+            owners = new Map();
+            this.scopes.set(score, owners);
+        }
+        let scope = owners.get(owner);
+        if (scope === undefined) {
+            scope = { whole: undefined, names: new Map(), tags: new Map(), writes: new Map() };
+            owners.set(owner, scope);
+        }
+        return scope;
+    }
+    keep(ends, key, d) {
+        const end = ends.get(key);
+        if (end === undefined) {
+            ends.set(key, { first: d, last: d });
+            d.held += 2;
+        }
+        else
+            this.hold(end, d);
+    }
+    hold(end, d) {
+        this.release(end.last);
+        end.last = d;
+        d.held++;
+    }
+    forget(end) {
+        this.all.delete(end.first);
+        this.all.delete(end.last);
     }
     release(d) {
         if (--d.held === 0)

package/dist/due.d.ts

@@ -10,3 +10,7 @@ export interface Due<I, O> {
 export declare function schedule<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): void;
 /** Takes every current entry due by `now` off the queue, in cue order. */
 export declare function popDue<I, O>(mix: Mixer<I, O>, now: number): Voice<I, O>[];
+/** Puts voices in id order in place, those of one id left in the order they had; returns `list`. */
+export declare function byId<V extends {
+    readonly id: number;
+}>(list: V[]): V[];

package/dist/due.js

@@ -97,7 +97,20 @@ export function popDue(mix, now) {
             out.push(top.voice);
         }
     }
-    if (out.length > 1)
-        out.sort((a, b) => a.id - b.id);
-    return out;
+    return byId(out);
+}
+/** Past this many voices the built-in sort, which makes working arrays however few it is given. */
+const SHORT = 8;
+/** Puts voices in id order in place, those of one id left in the order they had; returns `list`. */
+export function byId(list) {
+    if (list.length > SHORT)
+        return list.sort((a, b) => a.id - b.id);
+    for (let i = 1; i < list.length; i++) {
+        const v = list[i];
+        let k = i;
+        for (; k > 0 && list[k - 1].id > v.id; k--)
+            list[k] = list[k - 1];
+        list[k] = v;
+    }
+    return list;
 }

package/dist/easing.d.ts

@@ -1,9 +1,20 @@
 import type { Easing } from './types.js';
+/**
+ * A curve on 0..1: the function an easing stands for.
+ *
+ * @category patch
+ */
 export type Curve = (u: number) => number;
 /**
  * How fast a curve leaves 0, for bending a retarget to the speed the subject had: Infinity where
  * the curve jumps or leaves vertically, so no finite bend can match it.
  */
 export declare function startSlope(c: Curve): number;
-/** The function an easing names. Resolved once where a patch or voice is built, not per frame. */
+/**
+ * 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.
+ *
+ * @category patch
+ */
 export declare function curve(easing: Easing): Curve;

package/dist/easing.js

@@ -71,7 +71,13 @@ export function startSlope(c) {
     // Past a thousandth of the way within a millionth of the time: a jump, not a slope.
     return v > 1e-3 ? Number.POSITIVE_INFINITY : v / h;
 }
-/** The function an easing names. Resolved once where a patch or voice is built, not per frame. */
+/**
+ * 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.
+ *
+ * @category patch
+ */
 export function curve(easing) {
     if (typeof easing === 'function')
         return easing;

package/dist/everyone.d.ts

@@ -10,9 +10,22 @@ import type { Subject, Voice } from './voice.js';
  * and `shut` takes back after. About 32 B a subject where a record and its place in the voice's
  * store took about 370 (bench/allocs.mjs on the `swap` row, 2026-10-09). It needs lanes for the
  * numbers. What only shows later (a subject faded out of it alone, a fade at rest, state kept
- * through `setting.keep`) turns it back with `unshare`.
+ * through `setting.keep`) turns it back with `unshare`, and so does playing `shareFrames` frames.
  */
 export declare function shares<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): boolean;
+/**
+ * How many frames a voice plays sharing one record before it takes one a subject. Sharing saves a
+ * voice cued and gone within a few frames a record per subject, but costs a read more than a record
+ * of the subject's own: 0.13 ms a frame for one voice over 10,000 subjects (`glowbase`, teitou,
+ * 2026-10-21), against about 2 MB allocated once to stop. Settable for bench/same.mjs.
+ */
+export declare let shareFrames: number;
+export declare function setShareFrames(n: number): void;
+/**
+ * Turns back each voice that has played `shareFrames` frames sharing one record. Not a keys voice,
+ * whose record `open` never points at a subject, so it costs no read more.
+ */
+export declare function outgrow<I, O>(mix: Mixer<I, O>): void;
 /**
  * A sharing voice's one record, made when a chain first asks; null where its origin is still
  * ahead, which a record of its own per subject follows as the clock moves, so it shares no more.

package/dist/everyone.js

@@ -1,3 +1,4 @@
+import { headOf } from './chain.js';
 import { numericOf } from './channels.js';
 import { record } from './record.js';
 /**
@@ -10,7 +11,7 @@ import { record } from './record.js';
  * and `shut` takes back after. About 32 B a subject where a record and its place in the voice's
  * store took about 370 (bench/allocs.mjs on the `swap` row, 2026-10-09). It needs lanes for the
  * numbers. What only shows later (a subject faded out of it alone, a fade at rest, state kept
- * through `setting.keep`) turns it back with `unshare`.
+ * through `setting.keep`) turns it back with `unshare`, and so does playing `shareFrames` frames.
  */
 export function shares(mix, voice) {
     const spec = voice.spec;
@@ -38,6 +39,30 @@ export function shares(mix, voice) {
             return channel.rest !== undefined && numericOf(channel)?.op !== 'last';
         }));
 }
+/**
+ * How many frames a voice plays sharing one record before it takes one a subject. Sharing saves a
+ * voice cued and gone within a few frames a record per subject, but costs a read more than a record
+ * of the subject's own: 0.13 ms a frame for one voice over 10,000 subjects (`glowbase`, teitou,
+ * 2026-10-21), against about 2 MB allocated once to stop. Settable for bench/same.mjs.
+ */
+export let shareFrames = 60;
+export function setShareFrames(n) {
+    shareFrames = n;
+}
+/**
+ * Turns back each voice that has played `shareFrames` frames sharing one record. Not a keys voice,
+ * whose record `open` never points at a subject, so it costs no read more.
+ */
+export function outgrow(mix) {
+    const sharers = mix.sharers;
+    for (let i = sharers.length - 1; i >= 0; i--) {
+        const voice = sharers[i];
+        if (voice.built !== null || voice.state === 'pending' || voice.state === 'done')
+            continue;
+        if (++voice.shared >= shareFrames)
+            unshare(mix, voice);
+    }
+}
 /**
  * A sharing voice's one record, made when a chain first asks; null where its origin is still
  * ahead, which a record of its own per subject follows as the clock moves, so it shares no more.
@@ -191,7 +216,7 @@ export function unshare(mix, voice, kept = false, keeper) {
     const at = mix.sharers.indexOf(voice);
     if (at >= 0)
         mix.sharers.splice(at, 1);
-    const slot = kept ? (mix.chains.get(keeper)?.slot ?? -1) : -1;
+    const slot = kept ? (headOf(mix, keeper)?.slot ?? -1) : -1;
     // A projection numbers no subject, so its copy's record is the keeper's without being asked.
     if (all !== null && kept && (mix.projecting || sighted(voice, slot))) {
         if (slot >= 0)

package/dist/fade.d.ts

@@ -1,5 +1,5 @@
 import type { Mixer } from './mixer.js';
-import type { Subject, Voice } from './voice.js';
+import type { Left, Parted, Parting, 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. */
@@ -12,11 +12,18 @@ export declare function part<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject
 /** Brings a subject faded out of a voice back, to be met afresh on its next probe. */
 export declare function unpart<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject: I): void;
 /**
- * The record a read back finds a subject left a voice with: its own, or the voice's record for
- * subjects it does not reach while faded out of it, since a probe on either path may have left a
- * record of that or none.
+ * Keeps, under history, the record a subject leaves a voice with as it is let go of: for one faded
+ * out before the voice met it, a record saying it is not reached.
  */
-export declare function leftWith<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject: I): Subject<unknown> | undefined;
+export declare function leaveVoice<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject: I): void;
+/**
+ * Puts back into a voice's fades, or a copy's, those of the subjects that left it after frame `seq`
+ * as they stood then: `leave` keeps them, since a drop or a subject brought back forgets them.
+ */
+export declare function fadesAt<I>(fades: {
+    parts: Map<I, Parting> | null;
+    parted: Map<I, Parted> | null;
+}, left: readonly Left<I>[], seq: number): void;
 export declare function beginFade<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, opts: {
     over?: number;
     at?: 'rest';

package/dist/fade.js

@@ -1,9 +1,10 @@
-import { changed } from './chain.js';
+import { changed, headOf, unlink } from './chain.js';
 import { envelope } from './clock.js';
 import { schedule } from './due.js';
-import { unshare } from './everyone.js';
+import { unshare, unsight } from './everyone.js';
 import { leave, noted, releasing } from './history.js';
-import { orphan } from './owner.js';
+import { markOf } from './marks.js';
+import { orphan, ownerReading } from './owner.js';
 import { startOf } from './place.js';
 import { scoreTouched } from './scored.js';
 import { lingers, refit } from './spans.js';
@@ -38,11 +39,12 @@ export function parting(voice, subject, now) {
  * its lane position and a motion patch's state for it, and reaches it no more.
  */
 export function part(mix, voice, subject, at) {
+    const ramp = voice.parts?.get(subject);
     voice.parts?.delete(subject);
     if (voice.parts?.size === 0)
         voice.parts = null;
     voice.parted ??= new Map();
-    voice.parted.set(subject, { at, seq: mix.transport.seq });
+    voice.parted.set(subject, { at, seq: mix.transport.seq, ramp });
     mix.parters.add(voice);
     forgetIn(mix, voice, subject);
     const motion = voice.motion;
@@ -55,31 +57,54 @@ export function unpart(mix, voice, subject) {
         return;
     // `forgetIn` keeps the subject's own record for a read back; without one, keep the voice's.
     if (voice.subjects.get(subject) === undefined)
-        leave(mix, voice, subject, leftWith(mix, voice, subject));
+        leaveVoice(mix, voice, subject);
+    // Left with its parting still on, which a seek back to before this puts back.
+    forgetIn(mix, voice, subject);
     voice.parted.delete(subject);
     if (voice.parted.size === 0)
         voice.parted = null;
-    forgetIn(mix, voice, subject);
-    const slot = mix.chains.get(subject)?.slot ?? -1;
+    const slot = headOf(mix, subject)?.slot ?? -1;
     if (slot >= 0)
         mix.lanes?.rejoin(slot);
 }
 /**
- * The record a read back finds a subject left a voice with: its own, or the voice's record for
- * subjects it does not reach while faded out of it, since a probe on either path may have left a
- * record of that or none.
+ * Keeps, under history, the record a subject leaves a voice with as it is let go of: for one faded
+ * out before the voice met it, a record saying it is not reached.
  */
-export function leftWith(mix, voice, subject) {
+export function leaveVoice(mix, voice, subject) {
     const held = voice.subjects.get(subject);
     if (held !== undefined || voice.parted?.has(subject) !== true)
-        return held;
-    return voice.unreached ?? mix.unreachedOf(voice, mix.now);
+        leave(mix, voice, subject, held);
+    else
+        leave(mix, voice, subject, voice.unreached ?? mix.unreachedOf(voice, mix.now));
+}
+/**
+ * Puts back into a voice's fades, or a copy's, those of the subjects that left it after frame `seq`
+ * as they stood then: `leave` keeps them, since a drop or a subject brought back forgets them.
+ */
+export function fadesAt(fades, left, seq) {
+    for (const e of left) {
+        const parted = e.parted;
+        if (parted !== null && parted.seq <= seq) {
+            fades.parted ??= new Map();
+            fades.parted.set(e.subject, parted);
+            continue;
+        }
+        const ramp = e.ramp ?? parted?.ramp;
+        if (ramp === undefined || ramp === null || ramp.seq > seq)
+            continue;
+        fades.parts ??= new Map();
+        fades.parts.set(e.subject, ramp);
+    }
 }
 /** Drops a voice's record of a subject and relinks the subject's chain without it. */
 function forgetIn(mix, voice, subject) {
-    const head = mix.chains.get(subject);
-    if (head !== undefined && head.slot >= 0)
+    const head = headOf(mix, subject);
+    if (head !== undefined && head.slot >= 0) {
         unreach(voice, head.slot, false);
+        // What the voice kept for the subject while it shared one record, which `weightOf` reads.
+        unsight(voice, head.slot);
+    }
     const held = voice.subjects.get(subject);
     if (held !== undefined) {
         leave(mix, voice, subject, held);
@@ -93,8 +118,7 @@ function forgetIn(mix, voice, subject) {
     }
     if (head === undefined)
         return;
-    head.version = Number.NaN;
-    mix.relinks++;
+    unlink(mix, head);
     if (voice.laned && head.slot >= 0)
         mix.lanes?.part(voice.id, head.slot);
     mix.lanes?.refill();
@@ -153,12 +177,20 @@ export function beginRise(mix, voice, opts) {
     const over = mix.reduced ? 0 : (opts.over ?? voice.fade.in ?? voice.fade.out ?? 0);
     const left = out.rest || out.over === 0 ? 1 : 1 - (at - out.at) / out.over;
     const from = left < 0 ? 0 : left > 1 ? 1 : left;
+    // A voice faded before its start waits for it again, as a seek back finds it.
+    const waiting = Number.isNaN(mix.now) ||
+        (voice.owner === null ? at : ownerReading(voice.owner, at)) < voice.start;
     voice.out = null;
     voice.outAt = Number.POSITIVE_INFINITY;
-    voice.state = 'live';
+    voice.state = waiting ? 'pending' : 'live';
     voice.back = over > 0 && from < 1 ? { from, at, over } : null;
+    if (waiting)
+        changed(mix, voice);
     noted(mix, voice);
-    mix.lanes?.refill();
+    if (waiting)
+        mix.lanes?.invalidate();
+    else
+        mix.lanes?.refill();
 }
 /**
  * Fades a voice out from mix time `at`: ahead, it plays untouched until then and begins its fade
@@ -182,6 +214,11 @@ export function fadeAt(mix, voice, at, over) {
 function asks(mix, motion, voice) {
     return motion.owner === mix.owner && motion.ownerId === voice.id;
 }
+/** What a child leaving tells its owner of when the owner coasts. */
+function leaving(mix, child) {
+    const h = child.owner.holding;
+    h.left(child.passed ? markOf(mix, child, 'coast') : undefined, child.doneSeq);
+}
 /** Removes a voice, recording that it left at `at`, default now. */
 export function retire(mix, voice, at) {
     if (voice.holding === null)
@@ -209,6 +246,7 @@ export function retire(mix, voice, at) {
                 retire(mix, child, voice.doneAt);
     if (voice.owner !== null) {
         const span = voice.owner;
+        leaving(mix, voice);
         const owner = orphan(voice);
         if (owner !== null && !lingers(owner, voice.doneAt))
             retire(mix, owner, voice.doneAt);

package/dist/fill.js

@@ -6,7 +6,6 @@ import { open as openRecord, shut as shutRecord } from './everyone.js';
 import { unband } from './fold.js';
 import { foldLocus, gatherLocus } from './gather.js';
 import { runKeys } from './keyfill.js';
-import { frozenAt } from './lane.js';
 import { reach } from './meet.js';
 import { absent } from './numbers.js';
 import { AT, NOTHING, readKeys, seg, segment, shifted } from './patch.js';
@@ -184,8 +183,6 @@ export function wake(lanes, lane) {
  */
 export function signalled(voice, slot, rec) {
     const arg = this.arg;
-    const elapsed = arg[1 /* Arg.ELAPSED */];
-    const pass = arg[3 /* Arg.PASS */];
     const fade = arg[5 /* Arg.FADE */];
     if (Number.isNaN(rec.probed)) {
         this.late.push(slot);
@@ -196,8 +193,8 @@ export function signalled(voice, slot, rec) {
         arg[0 /* Arg.WEIGHT */] = 0;
         return true;
     }
-    const base = this.host.signal(voice, subject, rec, elapsed, pass, slot);
-    arg[0 /* Arg.WEIGHT */] = weighed(base, fade, voice.parts === null ? 1 : this.host.parting(voice, subject));
+    this.host.signal(voice, subject, rec, slot);
+    arg[0 /* Arg.WEIGHT */] = weighed(arg[0 /* Arg.WEIGHT */], fade, voice.parts === null ? 1 : this.host.parting(voice, subject));
     return true;
 }
 /** What a subject's own ramp out of a voice leaves of its weight: 1 with none. */
@@ -299,7 +296,19 @@ export function one(lane, p, slot) {
     if (this.lately >= 0 && this.unread(slot))
         return false;
     const delay = data[o + 0 /* Row.DELAY */];
-    const elapsed = frozenAt(voice, elapsedNow - delay);
+    const raw = elapsedNow - delay;
+    // `frozenAt` written out: V8 leaves it out of line here, a call a subject.
+    const elapsed = !(raw >= 0)
+        ? voice.freezesBefore
+            ? 0
+            : Number.NaN
+        : raw > voice.span
+            ? voice.hidesPast
+                ? Number.NaN
+                : voice.freezesAfter
+                    ? voice.span
+                    : raw
+            : raw;
     if (!(elapsed >= 0)) {
         data[o + 2 /* Row.WEIGHT */] = 0;
         unband(lane.records[p]);
@@ -418,9 +427,7 @@ export function readKeyed(voice, phase, delta, scratch) {
  */
 export function call(voice, chans, rec, slot) {
     const arg = this.arg;
-    const elapsed = arg[1 /* Arg.ELAPSED */];
     const phase = arg[2 /* Arg.PHASE */];
-    const pass = arg[3 /* Arg.PASS */];
     const delay = arg[4 /* Arg.DELAY */];
     const w = arg[0 /* Arg.WEIGHT */];
     const host = this.host;
@@ -436,7 +443,7 @@ export function call(voice, chans, rec, slot) {
     if (silent(voice, w))
         return false;
     const kept = reading.kept;
-    host.ready(voice, subject, rec, elapsed, pass, w);
+    host.ready(voice, subject, rec);
     if (this.keeps)
         host.horizon(voice, delay);
     else

package/dist/fit.d.ts

@@ -30,6 +30,11 @@ export interface Claim {
     /** Whether it may jump to its end instead of playing. */
     ballast: boolean;
     priority: Strength;
+    /**
+     * Span ms from now before which it may not start, from its `earliest`; absent for none. Below 0
+     * where it has passed, which places the child there.
+     */
+    floor?: number;
 }
 /**
  * The span as a fit sees it.
@@ -75,7 +80,9 @@ export declare function shareOf(order: Order, stagger: number): number;
 export declare function plain(span: SpanClaim, kids: readonly Claim[]): FitPlan;
 /**
  * Where a plan puts each child, span ms from now, and how long they take together. A playing child
- * is where it is, at 0; each pending one starts its share through the one before it.
+ * is where it is, at 0; each pending one starts its share through the one before it, or at its
+ * floor where that is later. A floor already past places a child before now, so it starts partway
+ * through; one without a floor starts no sooner than now.
  *
  * @category score
  */

package/dist/fit.js

@@ -17,7 +17,9 @@ export function plain(span, kids) {
 }
 /**
  * Where a plan puts each child, span ms from now, and how long they take together. A playing child
- * is where it is, at 0; each pending one starts its share through the one before it.
+ * is where it is, at 0; each pending one starts its share through the one before it, or at its
+ * floor where that is later. A floor already past places a child before now, so it starts partway
+ * through; one without a floor starts no sooner than now.
  *
  * @category score
  */
@@ -29,9 +31,11 @@ export function layout(span, kids, plan) {
     let prevLen = 0;
     kids.forEach((k, i) => {
         const len = plan.skip[i] ? 0 : k.natural / plan.rate[i];
-        const t = k.state === 'playing' || i === 0
+        const t = k.state === 'playing'
             ? 0
-            : prevAt + (k.overlap ? Math.min(plan.share, base) : base) * prevLen;
+            : Math.max(i === 0
+                ? Number.NEGATIVE_INFINITY
+                : prevAt + (k.overlap ? Math.min(plan.share, base) : base) * prevLen, k.floor ?? 0);
         at.push(t);
         length = Math.max(length, t + len);
         prevAt = t;

package/dist/fold.d.ts

@@ -1,6 +1,6 @@
 import type { Mixer } from './mixer.js';
 import type { Channel } from './types.js';
-import type { Subject, Voice } from './voice.js';
+import { type Subject, type Voice } from './voice.js';
 export type Key<O> = keyof O & string;
 export declare function near(a: unknown, b: unknown): boolean;
 /**