@msb235/blits 0.14.0 → 0.15.0

package/dist/fold.js

@@ -1,15 +1,6 @@
 import { foldNumber } from './channels.js';
-import { passAt, phaseAt, phaseBefore, silent, stepOf } from './clock.js';
 import { copy as copyValue, first } from './clone.js';
 import { open as openRecord, shut as shutRecord, weighAt } from './everyone.js';
-import { waits } from './held.js';
-import { apart, copyState, recordHost, remember } from './history.js';
-import { stateful } from './hosts.js';
-import { locusScratch } from './locus.js';
-import { moved } from './moved.js';
-import { readKeys } from './patch.js';
-import { reading } from './reading.js';
-import { checkWrites } from './voice.js';
 // V8 reads a local const as a constant, where it reads an import from its module on every call.
 const copy = copyValue;
 const open = openRecord;
@@ -42,330 +33,6 @@ export function merged(channel, acc, b) {
         acc[i] = r[i];
     return acc;
 }
-/**
- * A record after a seek that rebuilds: fresh state, stepped again from where the voice's clock now
- * puts this subject's start, which under `stepMs` lands where a voice cued fresh would.
- */
-function rebuild(mix, voice, subject, now, held) {
-    held.rebuilt = voice.rebuilds;
-    const patch = voice.patch;
-    if (patch.state === undefined && patch.step === undefined && held.kept === null)
-        return;
-    held.state = patch.state ? patch.state(subject) : undefined;
-    held.kept = null;
-    held.unkept = undefined;
-    held.since = mix.sinceOf(voice, held.delay);
-    held.shown = mix.shownOf(voice, held.since);
-    held.ticks = 0;
-    held.stepped = held.since < now ? held.since : now;
-    held.probed = Number.NaN;
-}
-/** Whether a seek since its last read moved a stateful record's origin, as one back before it does. */
-function sentBack(mix, voice, held) {
-    const p = voice.patch;
-    if (p.state === undefined && p.step === undefined && !voice.keeping)
-        return false;
-    return mix.sinceOf(voice, held.delay) !== held.since;
-}
-/**
- * One live voice's delta for one subject this frame, through its record for the subject, or null
- * when it does not reach. Its weight is left in `w`.
- */
-export function contribution(voice, subject, now, held) {
-    held.weight = 0;
-    if (!held.reaches)
-        return null;
-    if (voice.out?.rest && held.rested)
-        return null;
-    if (held.rebuilt !== voice.rebuilds)
-        rebuild(this, voice, subject, now, held);
-    else if (held.seeks !== voice.seeks && sentBack(this, voice, held)) {
-        // A seek sent it back before its start, so it starts afresh there, whatever state it kept.
-        rebuild(this, voice, subject, now, held);
-        waits(voice, held, now);
-    }
-    const raw = voice.rawAt(now, held.delay);
-    const early = voice.before(raw, now);
-    if (early && !voice.holdsFirst)
-        return null;
-    const elapsed = voice.shownAt(raw);
-    if (Number.isNaN(elapsed))
-        return null;
-    // A frozen subject's clock stands still at the edge it freezes at: -1 before, 1 after, 0 playing.
-    const still = early ? -1 : voice.freezesAfter && raw > voice.span ? 1 : 0;
-    const duration = voice.duration;
-    const phase = elapsed < 0 ? phaseBefore(elapsed, duration) : phaseAt(elapsed, duration, voice.passes);
-    const pass = passAt(elapsed, duration, voice.passes);
-    const primed = this.primed;
-    primed[0 /* Primed.NOW */] = now;
-    primed[1 /* Primed.ELAPSED */] = elapsed;
-    primed[2 /* Primed.PASS */] = pass;
-    this.prime(voice, held);
-    const setting = voice.setting;
-    // A signal that keeps state makes its voice stateful, as a patch that does: a lane would call
-    // it for subjects no probe asked about.
-    const keptAtWeigh = reading.kept;
-    const weight = this.weigh(voice, subject, now, held);
-    if (reading.kept !== keptAtWeigh && !voice.keeping)
-        stateful(this, voice);
-    setting.weight = weight;
-    held.weight = weight;
-    if (held.probed === now && held.delta && held.seeks === voice.seeks) {
-        if (voice.holder !== held && voice.scratch.length > 0)
-            this.keyed(voice, subject, held);
-        this.w = weight;
-        return held.delta;
-    }
-    const keptBefore = reading.kept;
-    const history = this.opts.history;
-    if (history?.inputs && voice.patch.reads !== undefined && !this.projecting)
-        recordHost(this, now);
-    // Only a motion reads it.
-    if (voice.motion !== undefined)
-        reading.horizon = this.horizonFor(voice, held.delay, now);
-    if (voice.patch.step && held.probed !== now) {
-        // Frozen after, it steps once more to where its last pass ended, and no further; run back
-        // past its start, to where it reached it. Before a start it has yet to reach, it does not step.
-        const to = still === 0
-            ? now
-            : still === 1
-                ? voice.timeAt(held.delay + voice.span)
-                : voice.ranBackTo(held.delay, now);
-        // Never probed, it may be a record a seek put back, sharing its copy's state until it steps.
-        const snaps = held.snaps;
-        const sought = Number.isNaN(held.probed) && snaps !== undefined;
-        if (!Number.isNaN(to)) {
-            if (held.stepped < held.since) {
-                held.stepped = held.since;
-                setting.dt = this.capped(now - held.since);
-            }
-            const tick = stepOf(this, voice);
-            if (tick !== undefined && sought)
-                ahead(this, voice, subject, held, snaps, tick, to);
-            if (sought)
-                own(voice, held);
-            if (tick !== undefined)
-                this.tick(voice, subject, held, tick, to);
-            else if (still === 0 ? now !== held.stepped : to > held.stepped) {
-                if (still !== 0)
-                    setting.dt = this.capped(to - held.stepped);
-                voice.patch.step(held.state, setting.dt, subject, setting);
-                held.stepped = to;
-            }
-        }
-        else if (sought)
-            own(voice, held);
-    }
-    let delta = null;
-    // A keys voice in a locus reads at weight 0 too: having a delta makes it a member, and the
-    // locus folds at its first member's place.
-    if (silent(voice, weight) && (voice.built === null || voice.spec.locus === undefined)) {
-        // A `from: 'current'` voice takes its base on its first read, silent or not.
-        if (voice.built && voice.spec.from === 'current' && held.base === undefined) {
-            held.base = this.baseFor(voice, subject);
-            held.slope = this.slopeFor(voice, subject);
-        }
-    }
-    else if (voice.built) {
-        held.phase = phase;
-        delta = this.keyed(voice, subject, held);
-    }
-    else if (voice.motion !== undefined) {
-        delta = moved(voice.motion, voice.patch.writes[0], subject, setting, held);
-    }
-    else {
-        delta = voice.patch.at(phase, subject, setting);
-        if (voice.unchecked)
-            checkWrites(voice, delta);
-    }
-    held.delta = delta;
-    held.probed = now;
-    held.seeks = voice.seeks;
-    if (history !== undefined)
-        remember(this, voice, subject, held);
-    if (reading.kept !== keptBefore && !voice.keeping)
-        stateful(this, voice);
-    if (delta === null)
-        return null;
-    if (voice.out?.rest && this.isRest(delta)) {
-        held.weight = 0;
-        held.rested = true;
-        held.restedAt = now;
-        voice.restedCount++;
-        return null;
-    }
-    this.w = weight;
-    return delta;
-}
-/** Reads a keys voice's stops at `held.phase` into the subject's delta, through the voice's scratch. */
-export function keyed(voice, subject, held) {
-    let base;
-    if (voice.spec.from === 'current') {
-        if (held.base === undefined) {
-            held.base = this.baseFor(voice, subject);
-            held.slope = this.slopeFor(voice, subject);
-        }
-        base = held.base;
-    }
-    const delta = readKeys(voice.built, held.phase, held.delta ?? {}, base, voice.lerps, held.slope, voice.intos, voice.scratch);
-    held.delta = delta;
-    if (voice.scratch.length > 0)
-        voice.holder = held;
-    return delta;
-}
-/** How many whole intervals of `tick` a subject's step grid holds by mix time `to`. */
-function dueBy(held, tick, to) {
-    // The epsilon keeps an interval like 1000 / 120 from landing a hair short of a whole count.
-    return Math.floor((to - held.since) / tick + 1e-9);
-}
-/**
- * The first step of a record a seek put back from a copy: takes up the furthest state stepped on
- * from that copy that the steps due now run past, the one the record the seek replaced reached or
- * the one the copy was last stepped ahead to, and otherwise keeps the copy's stepped ahead to the
- * moment sought, so a mix sought back time after time does not step from the copy each time, nor a
- * mix sought back and returned step again to where it was. Only where the same steps give the same
- * state: a fixed interval, no `maxDt`, no host field read.
- */
-function ahead(mix, voice, subject, held, snaps, tick, to) {
-    const from = snaps[snaps.length - 1];
-    const got = from?.ahead;
-    if (from === undefined || got === undefined || got.put !== held)
-        return;
-    got.put = null;
-    const reads = voice.patch.reads;
-    if (mix.opts.maxDt !== undefined || (reads !== undefined && reads.length > 0))
-        return;
-    // Stepped, rebuilt or placed anew since it was put back, its steps are no longer the copy's.
-    const was = from.held;
-    if (held.ticks !== was.ticks || held.since !== got.since || held.rebuilt !== was.rebuilt)
-        return;
-    const at = got.sought;
-    const due = dueBy(held, tick, to);
-    const usable = got.state !== undefined && got.ticks <= due;
-    if (got.left !== undefined && got.leftTicks <= due && !(usable && got.ticks > got.leftTicks)) {
-        // Taken, not copied: the next seek back keeps the state this record steps on to in its place.
-        held.state = got.left;
-        got.left = undefined;
-        voice.setting.state = held.state;
-        held.ticks = got.leftTicks;
-        return;
-    }
-    if (usable) {
-        held.state = copyState(voice, got.state);
-        voice.setting.state = held.state;
-        held.ticks = got.ticks;
-    }
-    const last = usable ? got.at : from.at;
-    if (!(at < to) || at - last < apart(mix.opts.history))
-        return;
-    own(voice, held);
-    mix.tick(voice, subject, held, tick, at);
-    got.state = copyState(voice, held.state);
-    got.ticks = held.ticks;
-    got.at = at;
-}
-/**
- * A record a seek put back shares the state of the copy it was made from, which no read changes,
- * until its first probe: before it steps, it takes a copy of its own.
- */
-function own(voice, held) {
-    const snaps = held.snaps;
-    const from = snaps[snaps.length - 1];
-    if (from !== undefined && held.state !== undefined && held.state === from.held.state) {
-        held.state = copyState(voice, held.state);
-        voice.setting.state = held.state;
-    }
-}
-/**
- * Runs `step` once per whole interval between where this subject last stopped and now, on a grid
- * counted from when its delay ran out, and leaves the remainder for the next sample. Counting
- * rather than adding keeps the grid where it is however many samples it is reached through.
- */
-export function tick(voice, subject, held, tick, to) {
-    const now = this.now;
-    const setting = voice.setting;
-    const frameDt = setting.dt;
-    let n = held.ticks;
-    const due = dueBy(held, tick, to);
-    const cap = this.opts.maxDt;
-    if (cap !== undefined) {
-        const most = Math.floor(cap / tick);
-        if (due - n > most)
-            n = due - most;
-    }
-    const step = voice.patch.step;
-    setting.dt = tick;
-    for (n++; n <= due; n++) {
-        setting.timestamp = held.since + n * tick;
-        step(held.state, tick, subject, setting);
-    }
-    held.ticks = due > held.ticks ? due : held.ticks;
-    held.stepped = held.since + held.ticks * tick;
-    setting.timestamp = now;
-    setting.dt = frameDt;
-}
-/**
- * Stop 0 for a retargeting voice: the subject's pose in the frame before this voice contributes.
- * With no such frame on record — a voice cued before the subject was ever probed, or a host that
- * samples into its own object — it is this frame's pose with every other voice folded in.
- */
-export function baseFor(voice, subject) {
-    let prior = this.pose.get(subject)?.pose;
-    if (prior === undefined && !this.folding.has(voice.id)) {
-        this.folding.add(voice.id);
-        try {
-            prior = this.fold(subject, undefined, false, voice.id);
-        }
-        finally {
-            this.folding.delete(voice.id);
-        }
-    }
-    const base = {};
-    for (const key of voice.patch.writes) {
-        const channel = this.kit[key];
-        const value = prior?.[key];
-        const fallback = channel.rest;
-        if (value !== undefined)
-            base[key] = copy(value);
-        else if (fallback !== undefined)
-            base[key] = copy(fallback);
-    }
-    return base;
-}
-/**
- * How fast each numeric channel this voice writes was moving, from the subject's last two probed
- * poses, in units per ms. Undefined with fewer than two on record, which starts the voice at rest.
- */
-export function slopeFor(voice, subject) {
-    const rec = this.pose.get(subject);
-    if (rec?.prev === undefined || !(rec.at > rec.prevAt))
-        return undefined;
-    const dt = rec.at - rec.prevAt;
-    const now = rec.pose;
-    const before = rec.prev;
-    const slope = {};
-    for (const key of voice.patch.writes) {
-        const a = before[key];
-        const b = now[key];
-        if (typeof a === 'number' && typeof b === 'number')
-            slope[key] = (b - a) / dt;
-        else if (Array.isArray(a) && Array.isArray(b) && a.length === b.length)
-            slope[key] = b.map((v, i) => (v - a[i]) / dt);
-    }
-    return slope;
-}
-export function isRest(delta) {
-    for (const key of Object.keys(delta)) {
-        if (delta[key] === undefined)
-            continue;
-        const channel = this.kit[key];
-        if (channel.rest === undefined)
-            return false;
-        if (!near(delta[key], channel.rest))
-            return false;
-    }
-    return true;
-}
 /**
  * A record's band state once its voice is skipped at weight 0: off, as `passes` would have said, so
  * a weight that comes back inside the band does not find it still on.
@@ -430,18 +97,6 @@ export function bound(channel, v) {
         }
     return v;
 }
-/**
- * Whether a fold's next voice is its chain's next record, `held`, and not the next voice sharing
- * one record, `sharers[q]`: the two lists are each in voice order, and a fold takes them as one.
- */
-export function chainFirst(held, sharers, q) {
-    if (held === null)
-        return false;
-    if (q >= sharers.length || held.voice === null)
-        return true;
-    const next = sharers[q];
-    return next.id > held.voice.id;
-}
 /**
  * After a fold read a sharing voice for the subject numbered `slot`: keeps the weight it gave and
  * what the read left on its record, and gives the fold's place in `sharers`, which moves back where
@@ -469,7 +124,7 @@ export function fold(subject, out, dry = false, except) {
 }
 export function folded(subject, out, dry = false, except) {
     const head = this.linked(subject);
-    return this.foldWith(subject, out ?? {}, head, this.linkedLaned, dry, except);
+    return this.foldWith(subject, out ?? this.pose(), head, this.linkedLaned, dry, except);
 }
 /**
  * A subject's chain, linked for this frame, and in `linkedLaned` whether its lanes answer for the
@@ -555,15 +210,15 @@ export function foldWith(subject, out, head, laned, dry, except) {
     return this.foldDetour(subject, pose, head, laned, dry, except, owed);
 }
 /**
- * `foldWith`'s voices in a mix with a locus or a voice sharing one record in it. The chain is taken
+ * `foldWith`'s voices in a mix with a role or a voice sharing one record in it. The chain is taken
  * again where a voice stopped sharing since it was linked, as a patch call in this probe's fill can
- * make one do. With no locus, the chain's records fold in voice order, and each voice sharing one
+ * make one do. With no role, the chain's records fold in voice order, and each voice sharing one
  * record, which is in no chain, before the first chain record that comes after it.
  */
 export function foldDetour(subject, pose, linkedHead, laned, dry, except, owed) {
     const head = linkedHead.version === this.version ? linkedHead : this.chain(subject);
-    if (this.loci !== 0)
-        return this.foldLoci(subject, pose, head, laned, dry, except, owed);
+    if (this.roleVoices !== 0)
+        return this.foldRoles(subject, pose, head, laned, dry, except, owed);
     const now = this.now;
     const lanes = this.lanes;
     const sharers = this.sharers;
@@ -625,166 +280,3 @@ export function foldSharers(pose, subject, head, q, before, laned, dry, except,
 export function owedBy(owed, voice) {
     return owed >= 0 && this.lanes.owesVoice(owed, voice.id);
 }
-/** `foldWith`'s voices with a locus in play: each locus folds at its first member's place. */
-export function foldLoci(subject, pose, head, laned, dry, except, owed) {
-    const now = this.now;
-    // A patch reading the pose can fold again from inside this one, so each depth has its own.
-    let k = this.locusScratch[this.locusDepth];
-    if (k === undefined) {
-        k = locusScratch(this.channels.length);
-        this.locusScratch[this.locusDepth] = k;
-    }
-    this.locusDepth++;
-    try {
-        k.n = 0;
-        k.m = 0;
-        k.names.length = 0;
-        const sharers = this.sharers;
-        let q = 0;
-        let at = head;
-        while (at !== null || q < sharers.length) {
-            const mine = chainFirst(at, sharers, q);
-            let voice;
-            let rec;
-            if (mine) {
-                rec = at;
-                voice = rec.voice;
-                at = rec.next;
-            }
-            else {
-                voice = sharers[q++];
-                rec = voice.state === 'pending' ? null : voice.everyone;
-            }
-            if (voice === null || rec === null)
-                continue;
-            if (laned && voice.laned && !this.owedBy(owed, voice))
-                continue;
-            if (voice.id === except || voice.state === 'done')
-                continue;
-            const held = rec;
-            if (!mine)
-                open(voice, held, head.slot);
-            const delta = this.read(voice, subject, now, dry, held);
-            if (owed >= 0 && voice.laned)
-                this.lanes.paid(voice.id, owed, held.weight);
-            if (!mine)
-                q = this.shared(voice, head.slot, held, q);
-            if (delta === null)
-                continue;
-            const locus = voice.spec.locus;
-            let group = -1;
-            if (locus !== undefined) {
-                group = k.names.indexOf(locus);
-                const m = k.m++;
-                k.mVoices[m] = voice;
-                k.mDeltas[m] = delta;
-                k.mWeights[m] = this.w;
-                if (group >= 0) {
-                    k.mGroups[m] = group;
-                    continue;
-                }
-                group = k.names.length;
-                k.names.push(locus);
-                k.mGroups[m] = group;
-            }
-            const n = k.n++;
-            k.voices[n] = voice;
-            k.helds[n] = held;
-            k.deltas[n] = delta;
-            k.weights[n] = locus === undefined ? this.w : 0;
-            k.groups[n] = group;
-        }
-        let bands = head.loci;
-        if (bands === null) {
-            bands = new Map();
-            head.loci = bands;
-        }
-        for (let n = 0; n < k.n; n++) {
-            const group = k.groups[n];
-            if (group < 0) {
-                const weight = k.weights[n];
-                if (weight > 0)
-                    this.apply(pose, k.voices[n], k.helds[n], k.deltas[n], weight);
-                else
-                    unband(k.helds[n]);
-                continue;
-            }
-            const weight = this.foldLocus(k, group);
-            const name = k.names[group];
-            if (!(weight > 0)) {
-                bands.get(name)?.fill(2);
-                continue;
-            }
-            let on = bands.get(name);
-            if (on === undefined) {
-                on = new Uint8Array(this.channels.length);
-                bands.set(name, on);
-            }
-            for (let t = 0; t < k.touched.length; t++) {
-                const slot = k.touched[t];
-                const value = k.values[slot];
-                k.values[slot] = undefined;
-                const key = this.names[slot];
-                const channel = this.channels[slot];
-                // A channel folds at the weight of the members that wrote it, not the whole locus.
-                const taken = k.taken[slot];
-                const w = taken > 1 ? 1 : taken;
-                if (channel.rest !== undefined && channel.scale) {
-                    // pose[key] is the copy of rest this fold made, so it is ours to write into.
-                    pose[key] = channel.fold
-                        ? channel.fold(pose[key], value, w)
-                        : merged(channel, pose[key], channel.scale(value, w));
-                    continue;
-                }
-                const band = on[slot];
-                const passes = this.passes(band === 0 ? undefined : band === 1, w);
-                on[slot] = passes ? 1 : 2;
-                if (passes)
-                    pose[key] = pose[key] === undefined ? first(value) : merged(channel, pose[key], value);
-            }
-        }
-        return pose;
-    }
-    finally {
-        for (let n = 0; n < k.n; n++) {
-            k.voices[n] = null;
-            k.helds[n] = null;
-            k.deltas[n] = null;
-        }
-        for (let m = 0; m < k.m; m++) {
-            k.mVoices[m] = null;
-            k.mDeltas[m] = null;
-        }
-        // Left set only where a channel's lerp threw partway, which the next fold must not inherit.
-        for (let t = 0; t < k.touched.length; t++) {
-            const slot = k.touched[t];
-            k.met[slot] = 0;
-            k.values[slot] = undefined;
-        }
-        k.touched.length = 0;
-        this.locusDepth--;
-    }
-}
-/** `contribution`, or for a dry fold a subject already probed this frame, without advancing it. */
-export function read(voice, subject, now, dry, held) {
-    if (dry) {
-        if (held.reaches && held.probed === now && held.delta && held.seeks === voice.seeks) {
-            const setting = voice.setting;
-            // The setting the probe that read the delta had, but for `dt`: a dry read advances nothing.
-            const elapsed = voice.shownAt(voice.rawAt(now, held.delay));
-            setting.timestamp = now;
-            setting.dt = 0;
-            setting.elapsed = elapsed;
-            setting.pass = passAt(elapsed, voice.duration, voice.passes);
-            setting.weight = 0;
-            setting.state = held.state;
-            voice.keepOn = held;
-            this.w = this.weigh(voice, subject, now, held);
-            held.weight = this.w;
-            if (voice.holder !== held && voice.scratch.length > 0)
-                this.keyed(voice, subject, held);
-            return held.delta;
-        }
-    }
-    return this.contribution(voice, subject, now, held);
-}

package/dist/gather.d.ts

@@ -1,14 +1,19 @@
-import { type Lane, type Laned, type Locus } from './lane.js';
+import { type Lane, type Laned, type Role } from './lane.js';
 import type { Lanes } from './lanes.js';
 /**
- * Every member of a locus, in voice order, gathered rather than folded: a member's delta for a
+ * Every member of a role, in voice order, gathered rather than folded: a member's delta for a
  * subject is lerped into what the members before it left there by its share of the weight
- * taken, as the general path's `foldLocus` does, so each subject's locus can fold in at its
+ * taken, as the general path's `foldRole` does, so each subject's role can fold in at its
  * first member's place in the order.
  */
-export declare function gatherLocus<I, O>(lanes: Lanes<I, O>, g: Locus<I, O>): void;
-/** A locus member's turn in the order: each subject it was the first member of takes the locus. */
-export declare function foldLocus<I, O>(lanes: Lanes<I, O>, lane: Lane<I, O>, g: Locus<I, O>): void;
+export declare function gatherRole<I, O>(lanes: Lanes<I, O>, g: Role<I, O>): void;
+/** A role member's turn in the order: each subject it was the first member of takes the role. */
+export declare function foldRole<I, O>(lanes: Lanes<I, O>, lane: Lane<I, O>, g: Role<I, O>): void;
+/**
+ * An inlined role at its first member's turn: each subject's members gathered in voice order, as
+ * `gatherRole` gathers them, then folded at once, with no pass of its own and no array of sums.
+ */
+export declare function runRole<I, O>(lanes: Lanes<I, O>, g: Role<I, O>): void;
 /** For a keys voice: the delta's value for each channel it writes, read once per phase. */
 export declare function gather<I, O>(this: Lanes<I, O>, lane: Lane<I, O>, delta: Record<string, unknown>): void;
 /** Folds what `gather` read into a subject's laned values, at `Arg.WEIGHT`. */
@@ -21,7 +26,7 @@ export declare function fold<I, O>(this: Lanes<I, O>, lane: Lane<I, O>, slot: nu
 export declare function foldDelta<I, O>(this: Lanes<I, O>, chans: readonly Laned[], slot: number, delta: Record<string, unknown>): void;
 /** Folds a motion sample's axes, kept apart from `foldInto` so neither reads two array kinds. */
 export declare function foldRun<I, O>(this: Lanes<I, O>, ch: Laned, slot: number, xs: Float64Array): void;
-/** Folds one channel's value into a subject's laned values, or its locus, at `Arg.WEIGHT`. */
+/** Folds one channel's value into a subject's laned values, or its role, at `Arg.WEIGHT`. */
 export declare function foldInto<I, O>(this: Lanes<I, O>, ch: Laned, slot: number, value: unknown): void;
 /**
  * Whether a rest-less channel's contribution passes the band, for the record `one` is folding: the