@msb235/blits 0.15.1 → 0.16.1

package/dist/move.js

@@ -2,18 +2,17 @@ import { settleArcs } from './arcs.js';
 import { changed } from './chain.js';
 import { elapsedWith } from './clock.js';
 import { byId, popDue, schedule } from './due.js';
-import { detour, outgrow } from './everyone.js';
-import { beginFade, part, retire } from './fade.js';
+import { beginFade, part, release, retire, rouse, stay } from './fade.js';
 import { expireGone, keepGone } from './gone.js';
-import { begin } from './held.js';
+import { begin, reorigin } from './held.js';
 import { noted } from './history.js';
-import { leave as leaveClock } from './origin.js';
-import { ownerReading } from './owner.js';
+import { leave as leaveClock, startedAt } from './origin.js';
+import { descendants, ownerReading, plays } from './owner.js';
 import { mixAt, place, repin, startAt, startOf } from './place.js';
 import { pageVoice } from './revive.js';
-import { delist } from './roster.js';
+import { delist, detour } from './roster.js';
 import { scoredLeft, scoredRemove } from './scored.js';
-import { lapse } from './spans.js';
+import { lapse, lapses, unfit } from './spans.js';
 import { unplay } from './strays.js';
 /** Numbers every mix's frames apart, so a blend's read is never taken for another mix's or frame's. */
 let frames = 0;
@@ -60,90 +59,323 @@ function moveTo(mix, now) {
     }
     // A live mix visits only the voices due by now; a projection, which copies few, visits all.
     const visit = mix.projecting || mix.walkAll ? mix.cued : popDue(mix, now);
+    let held = null;
     for (const voice of visit) {
         if (voice.state === 'done')
             continue;
-        if (Number.isNaN(voice.opened))
-            voice.opened = now;
-        if (voice.state === 'pending' &&
-            (voice.owner === null ? now : ownerReading(voice.owner, now)) >= voice.start)
-            begin(mix, voice, now);
-        // After it starts, so a fade due by now on a voice that started since the last frame begins.
-        // Not one set for after its passes run out, where a move across both would begin it first.
-        if ((voice.state === 'live' || voice.state === 'frozen') &&
-            voice.outAt <= now &&
-            !(voice.state === 'live' &&
-                !voice.freezesAfter &&
-                !voice.freezesBefore &&
-                voice.endsAt() < voice.outAt))
-            beginFade(mix, voice, { over: Number.isNaN(voice.outOver) ? undefined : voice.outOver }, Math.max(startOf(voice), voice.outAt));
-        if (voice.state !== 'pending') {
-            if (voice.turns)
-                turn(mix, voice, now);
-            // Its passes run out at its end running forward, and at its start running back. A clock
-            // standing still at or before its start is where it was: waiting, or frozen there.
-            const way = heading(voice, now);
-            const at = voice.elapsedAt(now);
-            const back = way < 0;
-            const atStart = !voice.beginless && at <= voice.soonest;
-            // An owner run back to its start stays for what it holds, and leaves with its last child.
-            const holds = voice.holding !== null && voice.holding.children.length > 0;
-            const over = back
-                ? atStart && !holds
-                : Number.isFinite(voice.span) && at >= voice.span + voice.latest;
-            if (over) {
-                voice.play(true, now, mix.transport.seq);
-                // The fade starts when its passes ran out, not at the frame that noticed, so it plays
-                // the same at any frame rate and a read at another time can find it.
-                if (voice.state === 'live') {
-                    if (back ? voice.freezesBefore : voice.freezesAfter)
-                        voice.state = 'frozen';
-                    else
-                        beginFade(mix, voice, { back }, Math.max(startOf(voice), Math.min(now, voice.endsAt())));
-                }
-            }
-            else if (voice.state === 'frozen' && !(atStart && way === 0))
-                voice.state = 'live';
-        }
-        // A projection reads a finished ramp as weight 0, and leaves the live voice's subjects be.
-        if (voice.parts !== null && !mix.projecting)
-            for (const [subject, r] of voice.parts)
-                if (now - r.at >= r.over)
-                    part(mix, voice, subject, r.at + r.over);
-        const back = voice.back;
-        if (back !== null && now >= back.at + (1 - back.from) * back.over && !mix.projecting) {
-            voice.back = null;
-            mix.lanes?.refill();
-        }
-        if (voice.state === 'fading' && voice.out) {
-            const { at, over, rest, deadline } = voice.out;
-            const spent = now - at;
-            if (rest) {
-                const out = deadline !== undefined && spent >= deadline;
-                const settled = voice.seen > 0 && voice.restedCount >= voice.seen;
-                if (out)
-                    retire(mix, voice, at + deadline);
-                else if (settled)
-                    retire(mix, voice);
-            }
-            else if (spent >= over)
-                retire(mix, voice, at + over);
+        if (visitOne(mix, voice, now, voice.owner !== null && voice.owner.fitting !== null)) {
+            held ??= [];
+            held.push(voice);
         }
-        if (!mix.projecting)
-            schedule(mix, voice);
-    }
-    if (mix.owners !== null) {
-        lapse(mix, now);
-        settleArcs(mix, now);
     }
+    const back = mix.leapt === null && held === null ? null : turnedBack(mix, held, now);
+    mix.leapt = null;
+    if (back === null)
+        settle(mix, held, now);
+    else
+        ahead(mix, back, held, now);
     if (mix.sharers.length > 0 && !mix.projecting)
-        outgrow(mix);
+        mix.share?.outgrow(mix);
     mix.stirred = false;
     mix.asleep = false;
     if (mix.retired.length > 0)
         prune(mix);
     forget(mix);
 }
+/** Takes the span children waiting their turn, then lets go of spans and arcs that are over. */
+function settle(mix, held, now) {
+    if (held !== null)
+        inTurn(mix, held, now);
+    if (mix.owners !== null) {
+        lapse(mix, now);
+        settleArcs(mix, now);
+    }
+}
+/**
+ * The owners sought forward since the last frame, or above the span children waiting their turn,
+ * whose clocks do not run forward at `now`, with those above them that do not either; null where
+ * there are none. An owner a span holds is left out, since its span's fits change its clock.
+ */
+function turnedBack(mix, held, now) {
+    let back = null;
+    if (mix.leapt !== null)
+        for (const o of mix.leapt)
+            back = up(o, now, back);
+    if (held !== null)
+        for (const v of held)
+            back = up(v.owner, now, back);
+    return back;
+}
+/** Adds to `back` the owners from `from` up that `turnedBack` takes. */
+function up(from, now, back) {
+    for (let o = from; o !== null; o = o.owner) {
+        if (o.state === 'done' || o.owner?.fitting || back?.includes(o))
+            continue;
+        if (o.rateAt(o.owner === null ? now : ownerReading(o.owner, now)) > 0)
+            continue;
+        back ??= [];
+        back.push(o);
+    }
+    return back;
+}
+/**
+ * Settles a frame in which a seek took owners whose clocks do not run forward ahead: the span
+ * children and spans it passed start and end in order, as played straight through, with those
+ * clocks run forward to where they read now, then back on their own.
+ */
+function ahead(mix, back, held, now) {
+    const kept = back.map((o) => {
+        const { anchorNow, anchorElapsed, rate, ramp, start } = o;
+        const at = o.owner === null ? now : ownerReading(o.owner, now);
+        o.anchorElapsed = elapsedWith(o, at);
+        o.anchorNow = at;
+        o.rate = 1;
+        o.ramp = null;
+        // Started where the clock run forward reads 0, so a time on it before now maps back to it.
+        o.start = at - o.anchorElapsed;
+        return { anchorNow, anchorElapsed, rate, ramp, start, logged: o.log?.length ?? 0 };
+    });
+    try {
+        // Anchors are placed on those clocks too, and a plain child placed behind them starts there:
+        // on a clock standing still, an owner's time maps to the seek's moment and back to where it
+        // was sought, so a later frame would place it again past it.
+        if (mix.anchored > 0) {
+            place(mix);
+            for (const o of back)
+                descendants(o, (v) => {
+                    if (v.state === 'pending' && v.spec.anchor !== undefined && v.owner?.fitting === null)
+                        visitOne(mix, v, now);
+                });
+        }
+        settle(mix, held, now);
+    }
+    finally {
+        back.forEach((o, i) => {
+            const { logged, ...clock } = kept[i];
+            Object.assign(o, clock);
+            const log = o.log;
+            if (log !== null)
+                for (let k = logged; k < log.length; k++)
+                    Object.assign(log[k], clock);
+        });
+    }
+    // What was worked out in mix time from the clocks run forward is worked out again on their own.
+    mix.frame = nextFrame();
+    for (const o of back) {
+        if (o.state !== 'done')
+            schedule(mix, o);
+        descendants(o, (v) => {
+            if (v.state === 'done')
+                return;
+            reorigin(mix, v, now);
+            schedule(mix, v);
+        });
+    }
+    mix.lanes?.refill();
+}
+/**
+ * Starts, ends and fades one voice as of `now`; with `wait`, a span's child, it does none of that
+ * and answers true where the child `meets` now, to wait its turn.
+ */
+function visitOne(mix, voice, now, wait = false) {
+    if (Number.isNaN(voice.opened))
+        voice.opened = now;
+    if (voice.earlier !== null || voice.later !== null)
+        unfit(mix, voice, now);
+    const t = voice.owner === null ? now : ownerReading(voice.owner, now);
+    if (wait && meetsAt(voice, t, now))
+        return true;
+    if (voice.state === 'pending' && starts(voice, t, now))
+        begin(mix, voice, now);
+    // After it starts, so a fade due by now on a voice that started since the last frame begins.
+    // Not one set for after its passes run out, where a move across both would begin it first.
+    if ((voice.state === 'live' || voice.state === 'frozen') &&
+        voice.outAt <= now &&
+        !(voice.state === 'live' &&
+            !voice.freezesAfter &&
+            !voice.freezesBefore &&
+            voice.endsAt() < voice.outAt))
+        beginFade(mix, voice, { over: Number.isNaN(voice.outOver) ? undefined : voice.outOver }, Math.max(startedAt(voice), voice.outAt));
+    if (voice.state !== 'pending') {
+        if (voice.turns)
+            turn(mix, voice, now);
+        if (voice.state === 'live' && voice.out !== null && !voice.quietAt(now))
+            rouse(mix, voice, now);
+        // Its passes run out at its end running forward, and at its start running back. A clock
+        // standing still at or before its start is where it was: waiting, or frozen there.
+        const heads = Math.sign(voice.rateAt(t)) * (voice.owner === null ? 1 : heading(voice.owner, now));
+        const at = t === Number.NEGATIVE_INFINITY ? t : elapsedWith(voice, t);
+        const back = heads < 0;
+        const atStart = !voice.beginless && at <= voice.soonest;
+        // An owner run back to its start stays for what it holds, and leaves with its last child.
+        const holds = voice.holding !== null && plays(voice, now);
+        const over = back
+            ? atStart && !holds
+            : Number.isFinite(voice.span) && at >= voice.span + voice.latest;
+        if (over) {
+            voice.play(true, now, mix.transport.seq);
+            // The fade starts when its passes ran out, not at the frame that noticed, so it plays
+            // the same at any frame rate and a read at another time can find it.
+            if (voice.state === 'live' && voice.out === null) {
+                if (back ? voice.freezesBefore : voice.freezesAfter)
+                    voice.state = 'frozen';
+                else
+                    beginFade(mix, voice, { back, stays: voice.owner !== null && mix.opts.history !== undefined }, Math.max(startOf(voice), Math.min(now, voice.endsAt())));
+            }
+        }
+        else if (voice.state === 'frozen' && !(atStart && heads === 0))
+            voice.state = 'live';
+    }
+    // A projection reads a finished ramp as weight 0, and leaves the live voice's subjects be.
+    if (voice.parts !== null && !mix.projecting)
+        for (const [subject, r] of voice.parts)
+            if (now - r.at >= r.over)
+                part(mix, voice, subject, r.at + r.over);
+    const back = voice.back;
+    if (back !== null && now >= back.at + (1 - back.from) * back.over && !mix.projecting) {
+        voice.back = null;
+        mix.lanes?.refill();
+    }
+    if (voice.state === 'fading' && voice.out) {
+        const { at, over, rest, deadline } = voice.out;
+        const spent = now - at;
+        if (rest) {
+            const out = deadline !== undefined && spent >= deadline;
+            const settled = voice.seen > 0 && voice.restedCount >= voice.seen;
+            if (out)
+                retire(mix, voice, at + deadline);
+            else if (settled)
+                retire(mix, voice);
+        }
+        else if (spent >= over) {
+            if (voice.out.stays)
+                stay(mix, voice, at + over);
+            else
+                retire(mix, voice, at + over);
+        }
+    }
+    if (!mix.projecting)
+        schedule(mix, voice);
+    return false;
+}
+/**
+ * Whether a pending voice starts with its owner's clock at `t`: at its very start only on a clock
+ * not running back, where it would leave as it starts, as one passed between frames never starts.
+ */
+function starts(voice, t, now) {
+    return (t > voice.start ||
+        (t === voice.start && (voice.owner === null || heading(voice.owner, now) >= 0)));
+}
+/**
+ * Whether a span's child starts, comes back, or reaches the end of its passes by `now`: a fit from
+ * an end earlier in the frame can move any of these, so they wait for the ends before them. One
+ * kept quiet at its start comes back as its clock passes it. Past its end, or its start, on a clock
+ * not running forward, a seek of an owner took it there going forward. Takes first the changes a
+ * fit made to it that its owner's clock has come back to, as `visitOne` would.
+ */
+function meets(mix, voice, now) {
+    if (voice.earlier !== null || voice.later !== null)
+        unfit(mix, voice, now);
+    return meetsAt(voice, ownerReading(voice.owner, now), now);
+}
+/** `meets`, given what its owner's clock reads at `now`, `t`. */
+function meetsAt(voice, t, now) {
+    if (voice.state === 'pending')
+        return starts(voice, t, now);
+    if (voice.state !== 'live')
+        return false;
+    const out = voice.out;
+    if (voice.fitting !== null)
+        return out === null && lapses(voice, now);
+    if (!Number.isFinite(voice.span))
+        return false;
+    if (out !== null && !(out.stays === true && out.back === true))
+        return false;
+    const at = t === Number.NEGATIVE_INFINITY ? t : elapsedWith(voice, t);
+    const edge = out === null ? voice.span + voice.latest : voice.soonest;
+    return at > edge || (at === edge && heading(voice, now) > 0);
+}
+/**
+ * Visits span children that start, come back or end within the frame in the order those happen,
+ * one at a time, since a fit from each end can move the starts and ends after it. A start or a
+ * return only does that here; a child a fit moves to meet `now`, or whose span starts, joins them.
+ */
+function inTurn(mix, held, now) {
+    // A lone start of a child holding nothing moves nothing else: it starts and is visited.
+    const lone = held.length === 1 ? held[0] : null;
+    if (lone !== null && lone.state === 'pending' && lone.holding === null) {
+        begin(mix, lone, now);
+        if (!meets(mix, lone, now)) {
+            visitOne(mix, lone, now);
+            return;
+        }
+    }
+    // `held` is this frame's own list, so it is the one the children waiting their turn join.
+    const waiting = held;
+    const ended = [];
+    for (;;) {
+        let next;
+        let when = Number.POSITIVE_INFINITY;
+        for (let i = 0; i < waiting.length; i++) {
+            const v = waiting[i];
+            if (v.state === 'done' || ended.includes(v) || !meets(mix, v, now))
+                continue;
+            const t = v.state === 'pending'
+                ? startOf(v)
+                : v.fitting !== null
+                    ? lapseOf(v)
+                    : v.out !== null
+                        ? v.reaches(v.soonest)
+                        : v.endsAt();
+            // At one time an end comes first, as a fit from it counts a start there as still to come.
+            if (next === undefined || t < when || (t === when && rank(v) < rank(next))) {
+                next = v;
+                when = t;
+            }
+        }
+        if (next === undefined)
+            break;
+        if (next.state === 'pending') {
+            begin(mix, next, now);
+            if (next.holding !== null)
+                join(mix, next, now, waiting, ended);
+        }
+        else if (next.out !== null)
+            rouse(mix, next, now);
+        else {
+            ended.push(next);
+            if (next.fitting !== null)
+                release(mix, next, when);
+            else
+                visitOne(mix, next, now);
+            for (let o = next.owner; o?.fitting; o = o.owner)
+                join(mix, o, now, waiting, ended);
+        }
+    }
+    byId(waiting);
+    for (let i = 0; i < waiting.length; i++) {
+        const v = waiting[i];
+        if (!ended.includes(v) && v.state !== 'done')
+            visitOne(mix, v, now);
+    }
+}
+/** When a span's budget ran out, mix time. */
+function lapseOf(span) {
+    return span.timeAt(span.fitting.budget);
+}
+/** Adds to `waiting` the children of `o` that meet `now` and have not yet ended this frame. */
+function join(mix, o, now, waiting, ended) {
+    const children = o.holding.children;
+    for (let i = 0; i < children.length; i++) {
+        const c = children[i];
+        if (c.state !== 'done' && !ended.includes(c) && !waiting.includes(c) && meets(mix, c, now))
+            waiting.push(c);
+    }
+}
+/** Which of two events at one time comes first: an end before a start or return, then cue order. */
+function rank(v) {
+    return (v.state === 'pending' || v.out !== null ? 2 ** 40 : 0) + v.id;
+}
 /** Starts each voice cued while the mix slept at `now`, the first sync after its cue. */
 function wake(mix, now) {
     mix.waking = false;

package/dist/origin.d.ts

@@ -19,3 +19,5 @@ export declare function leave<I, O>(voice: Voice<I, O>, u: number, sought?: bool
  * `rebuilt` starts from the last seek that rebuilt state, as a stateful record does.
  */
 export declare function originOf<I, O>(voice: Voice<I, O>, elapsed: number, rebuilt: boolean): number;
+/** The mix time a voice started, or will by its owners' controls now: where its clock read 0. */
+export declare function startedAt<I, O>(voice: Voice<I, O>): number;

package/dist/origin.js

@@ -80,3 +80,7 @@ export function originOf(voice, elapsed, rebuilt) {
     }
     return voice.owner === null ? t : originOf(voice.owner, t, rebuilt);
 }
+/** The mix time a voice started, or will by its owners' controls now: where its clock read 0. */
+export function startedAt(voice) {
+    return voice.owner === null ? voice.start : originOf(voice.owner, voice.start, false);
+}

package/dist/owner.d.ts

@@ -36,8 +36,13 @@ export declare function mixTime<I, O>(owner: Voice<I, O>, t: number): number;
 export declare function turnedBack<I, O>(voice: Voice<I, O>): boolean;
 /** Takes a child into its owner. */
 export declare function adopt<I, O>(owner: Voice<I, O>, child: Voice<I, O>): void;
-/** A child left: its owner, where that was its last child and it should leave too. */
-export declare function orphan<I, O>(child: Voice<I, O>): Voice<I, O> | null;
+/**
+ * A child left at mix time `now`: its owner, where that was its last child still playing and it
+ * should leave too.
+ */
+export declare function orphan<I, O>(child: Voice<I, O>, now: number): Voice<I, O> | null;
+/** Whether an owner holds a child at mix time `now` that is not kept quiet past its passes. */
+export declare function plays<I, O>(owner: Voice<I, O>, now: number): boolean;
 /** A child finished its passes: its owner has played once every child it held has. */
 export declare function childPlayed<I, O>(owner: Voice<I, O>, at: number, seq: number): void;
 /** Every voice an owner holds, its children's children included. */

package/dist/owner.js

@@ -1,5 +1,6 @@
 import { arcShare } from './arcs.js';
 import { backWith, clampWeight, elapsedWith, envelope, timeWith } from './clock.js';
+import { startedAt } from './origin.js';
 /** What an owner is cued with in place of a patch: it writes nothing, so no fold ever meets it. */
 export const ownerPatch = Object.freeze({
     form: 'fn',
@@ -76,14 +77,24 @@ export function adopt(owner, child) {
     h.children.push(child);
     h.kids++;
 }
-/** A child left: its owner, where that was its last child and it should leave too. */
-export function orphan(child) {
+/**
+ * A child left at mix time `now`: its owner, where that was its last child still playing and it
+ * should leave too.
+ */
+export function orphan(child, now) {
     const owner = child.owner;
     const h = owner.holding;
     const i = h.children.indexOf(child);
     if (i >= 0)
         h.children.splice(i, 1);
-    return h.children.length === 0 && owner.state !== 'done' ? owner : null;
+    return !plays(owner, now) && owner.state !== 'done' ? owner : null;
+}
+/** Whether an owner holds a child at mix time `now` that is not kept quiet past its passes. */
+export function plays(owner, now) {
+    for (const child of owner.holding.children)
+        if (!child.quietAt(now))
+            return true;
+    return false;
 }
 /** A child finished its passes: its owner has played once every child it held has. */
 export function childPlayed(owner, at, seq) {
@@ -122,9 +133,10 @@ export function heldByInput(voice) {
  */
 export function ownWeight(owner, now, reduced, base) {
     const b = typeof owner.spec.weight === 'function' ? base(owner) : owner.weight;
-    const start = owner.owner === null ? owner.start : mixTime(owner.owner, owner.start);
+    const start = startedAt(owner);
     const since = owner.freezesBefore && owner.opened < start ? owner.opened : start;
-    return clampWeight(b * envelope(owner.fade.in ?? 0, owner.out, owner.ease, reduced, now, since, owner.back));
+    return clampWeight(b *
+        envelope(owner.fade.in ?? 0, owner.out, owner.ease, reduced, now, since, owner.back, owner.stalls));
 }
 /** What every owner above a voice multiplies into its weight. */
 export function ownersWeight(voice, now, reduced, base) {

package/dist/paging.d.ts

@@ -22,9 +22,13 @@ export declare class HistoryMiss extends Error {
 /** A transport's history store: what left memory, and what `prepare` loaded back. */
 export declare class Pager {
     readonly store: HistoryStore;
-    /** What the last `prepare` loaded, and every record paged since, until a seek or read takes it. */
+    /**
+     * What the last `prepare` loaded at mix time `now`, and every record paged since, until a seek or
+     * read takes it, or memory's length of mix time passes.
+     */
     loaded: {
         t: number;
+        now: number;
         records: Paged[];
     } | null;
     /** The latest record paged, which a miss names. */

package/dist/paging.js

@@ -23,7 +23,10 @@ export class HistoryMiss extends Error {
 /** A transport's history store: what left memory, and what `prepare` loaded back. */
 export class Pager {
     store;
-    /** What the last `prepare` loaded, and every record paged since, until a seek or read takes it. */
+    /**
+     * What the last `prepare` loaded at mix time `now`, and every record paged since, until a seek or
+     * read takes it, or memory's length of mix time passes.
+     */
     loaded = null;
     /** The latest record paged, which a miss names. */
     last = null;
@@ -94,7 +97,14 @@ export function pageOut(mix, stream, voice, subject, out, data, reach) {
 export function page(transport, records, reach) {
     const pager = transport.pager;
     pager.store.page(records);
-    pager.loaded?.records.push(...records);
+    const loaded = pager.loaded;
+    if (loaded !== null) {
+        // Left unread for longer than memory reaches, it is let go: the store still has it all.
+        if (transport.now - loaded.now > (transport.history?.ms ?? 0))
+            pager.loaded = null;
+        else
+            loaded.records.push(...records);
+    }
     const last = records[records.length - 1];
     pager.last = { mix: last.mix, stream: last.stream };
     if (reach > transport.floor)
@@ -141,5 +151,5 @@ export async function prepare(transport, t) {
     if (pager === null || transport.reaches(t))
         return;
     const records = await pager.store.load(t);
-    pager.loaded = { t, records: [...records] };
+    pager.loaded = { t, now: transport.now, records: [...records] };
 }

package/dist/patch.js

@@ -262,13 +262,33 @@ slope, duration, into, reuse) {
         return value + bend(slope, aValue, bValue);
     if (Array.isArray(value) && Array.isArray(slope)) {
         const out = value === lastRead.wrote ? value : new Array(value.length);
+        // A stop shorter than the channel reads its missing axes as the lerp does, at each end.
+        let ends;
+        const endsOf = () => {
+            const by = track.lerp ?? lerp;
+            const at = (t) => into !== undefined
+                ? into(undefined, aValue, bValue, t)
+                : by
+                    ? by(aValue, bValue, t)
+                    : interpolate(aValue, bValue, t);
+            ends = [at(0), at(1)];
+            return ends;
+        };
         for (let i = 0; i < value.length; i++) {
             const v = value[i];
             const s = slope[i];
-            out[i] =
-                typeof v === 'number' && typeof s === 'number'
-                    ? v + bend(s, aValue[i], bValue[i])
-                    : v;
+            if (typeof v !== 'number' || typeof s !== 'number') {
+                out[i] = v;
+                continue;
+            }
+            let a = aValue[i];
+            let z = bValue[i];
+            if (typeof a !== 'number' || typeof z !== 'number') {
+                const [a0, z1] = ends ?? endsOf();
+                a = a0?.[i];
+                z = z1?.[i];
+            }
+            out[i] = typeof a === 'number' && typeof z === 'number' ? v + bend(s, a, z) : v;
         }
         return out;
     }