@msb235/blits 0.3.0 → 0.5.0

package/dist/locus.d.ts

@@ -0,0 +1,40 @@
+import type { Mixer } from './mixer.js';
+import type { Subject, Voice } from './voice.js';
+/**
+ * What a fold with a locus in play gathers, kept from one fold to the next: the influences in
+ * voice order, each a voice's own or a locus's first member; every locus member; and per channel
+ * slot, a locus's folding value, the weight taken into it and the array it owns.
+ */
+export interface LocusScratch<I, O> {
+    n: number;
+    voices: (Voice<I, O> | null)[];
+    helds: (Subject<unknown> | null)[];
+    deltas: (Record<string, unknown> | null)[];
+    weights: number[];
+    /** Per influence, -1 for a voice's own, or which of `names` it is. */
+    groups: number[];
+    names: string[];
+    m: number;
+    mVoices: (Voice<I, O> | null)[];
+    mDeltas: (Record<string, unknown> | null)[];
+    mWeights: number[];
+    mGroups: number[];
+    values: unknown[];
+    taken: Float64Array;
+    met: Uint8Array;
+    touched: number[];
+    owned: (number[] | undefined)[];
+}
+export declare function locusScratch<I, O>(channels: number): LocusScratch<I, O>;
+/**
+ * `value` copied into the array `k` owns for the slot, as long as the channel's rest, where a
+ * shorter value leaves the rest's own fill: what the channel's fold and lerp read past its end.
+ */
+export declare function own<I, O>(k: LocusScratch<I, O>, slot: number, value: number[], rest: number[]): number[];
+/**
+ * Folds one locus's members into one influence through each channel's own `lerp`: its value per
+ * channel goes in `k.values`, the channels in `k.touched` in the order first met, and its weight
+ * is returned. A channel folding by scale takes its value in an array of `k`'s own, lerped in
+ * place, since the fold only reads it.
+ */
+export declare function foldLocus<I, O>(this: Mixer<I, O>, k: LocusScratch<I, O>, group: number): number;

package/dist/locus.js

@@ -0,0 +1,89 @@
+import { copy } from './clone.js';
+export function locusScratch(channels) {
+    return {
+        n: 0,
+        voices: [],
+        helds: [],
+        deltas: [],
+        weights: [],
+        groups: [],
+        names: [],
+        m: 0,
+        mVoices: [],
+        mDeltas: [],
+        mWeights: [],
+        mGroups: [],
+        values: new Array(channels).fill(undefined),
+        taken: new Float64Array(channels),
+        met: new Uint8Array(channels),
+        touched: [],
+        owned: new Array(channels).fill(undefined),
+    };
+}
+/**
+ * `value` copied into the array `k` owns for the slot, as long as the channel's rest, where a
+ * shorter value leaves the rest's own fill: what the channel's fold and lerp read past its end.
+ */
+export function own(k, slot, value, rest) {
+    let out = k.owned[slot];
+    if (out === undefined) {
+        out = rest.slice();
+        k.owned[slot] = out;
+    }
+    for (let i = 0; i < out.length; i++)
+        out[i] = i < value.length ? value[i] : rest[i];
+    return out;
+}
+/**
+ * Folds one locus's members into one influence through each channel's own `lerp`: its value per
+ * channel goes in `k.values`, the channels in `k.touched` in the order first met, and its weight
+ * is returned. A channel folding by scale takes its value in an array of `k`'s own, lerped in
+ * place, since the fold only reads it.
+ */
+export function foldLocus(k, group) {
+    k.touched.length = 0;
+    let sum = 0;
+    for (let m = 0; m < k.m; m++)
+        if (k.mGroups[m] === group)
+            sum += k.mWeights[m];
+    if (sum <= 0)
+        return 0;
+    const taken = k.taken;
+    for (let m = 0; m < k.m; m++) {
+        if (k.mGroups[m] !== group)
+            continue;
+        const weight = k.mWeights[m];
+        if (weight <= 0)
+            continue;
+        const delta = k.mDeltas[m];
+        const slots = k.mVoices[m].slots;
+        for (let i = 0; i < slots.length; i++) {
+            const slot = slots[i];
+            const value = delta[this.names[slot]];
+            if (value === undefined)
+                continue;
+            const channel = this.channels[slot];
+            if (k.met[slot] === 0) {
+                k.met[slot] = 1;
+                k.touched.push(slot);
+                taken[slot] = weight;
+                k.values[slot] =
+                    this.lerpsInto[slot] !== undefined && channel.scale && Array.isArray(value)
+                        ? own(k, slot, value, channel.rest)
+                        : copy(value);
+                continue;
+            }
+            const total = taken[slot] + weight;
+            const was = k.values[slot];
+            const lerp = this.lerpsInto[slot];
+            k.values[slot] =
+                lerp !== undefined && was === k.owned[slot]
+                    ? lerp(was, was, value, weight / total)
+                    : channel.lerp(was, value, weight / total);
+            taken[slot] = total;
+        }
+    }
+    for (let t = 0; t < k.touched.length; t++)
+        k.met[k.touched[t]] = 0;
+    return sum > 1 ? 1 : sum;
+}

package/dist/marks.d.ts

@@ -0,0 +1,12 @@
+import type { Listed } from './book.js';
+import type { Mixer } from './mixer.js';
+import type { Mark } from './types.js';
+import { type Voice } from './voice.js';
+/** The host timestamp the mix clock reads mix time `t` at; Infinity where it never will. */
+export declare function hostOf<I, O>(mix: Mixer<I, O>, t: number): number;
+/** What the mix clock reads at host time `u`, by the clock in force then. */
+export declare function readingAt<I, O>(mix: Mixer<I, O>, u: number): number;
+/** Every mark between two host timestamps, earliest first, with the order that tells each apart. */
+export declare function listed<I, O>(mix: Mixer<I, O>, from: number, to: number): Listed[];
+/** When a voice reaches a mark, mix time, or undefined while nothing has fixed it. */
+export declare function markOf<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, mark: Mark): number | undefined;

package/dist/marks.js

@@ -0,0 +1,80 @@
+import { startOf } from './place.js';
+import { none } from './voice.js';
+/** The host timestamp the mix clock reads mix time `t` at; Infinity where it never will. */
+export function hostOf(mix, t) {
+    return (mix.pace === null ? t : mix.pace.timeOf(t)) + mix.offset;
+}
+/** What the mix clock reads at host time `u`, by the clock in force then. */
+export function readingAt(mix, u) {
+    return mix.pace === null ? u : mix.pace.reading(u);
+}
+/** Every mark between two host timestamps, earliest first, with the order that tells each apart. */
+export function listed(mix, from, to) {
+    const lo = from - mix.offset;
+    const hi = to - mix.offset;
+    const out = [];
+    for (const a of mix.announced)
+        if (a.at >= lo && a.at <= hi)
+            out.push({
+                timestamp: a.at + mix.offset,
+                mark: undefined,
+                voice: undefined,
+                score: a.score,
+                name: a.name,
+                tags: a.tags,
+                order: a.order,
+            });
+    for (const voice of [...mix.cued, ...mix.gone]) {
+        for (const mark of ['start', 'in', 'out', 'end']) {
+            const m = markOf(mix, voice, mark);
+            const t = m === undefined ? m : hostOf(mix, m) - mix.offset;
+            if (t === undefined || t < lo || t > hi)
+                continue;
+            out.push({
+                timestamp: t + mix.offset,
+                mark,
+                voice: voice.id,
+                score: voice.spec.score,
+                name: voice.spec.name,
+                tags: voice.spec.tags ?? none,
+                order: voice.id,
+            });
+        }
+    }
+    out.sort((a, b) => a.timestamp - b.timestamp || a.order - b.order);
+    return out;
+}
+/** When a voice reaches a mark, mix time, or undefined while nothing has fixed it. */
+export function markOf(mix, voice, mark) {
+    if (!Number.isFinite(voice.start))
+        return undefined;
+    // A mark is known only while every clock above it is fixed.
+    const start = startOf(voice);
+    if (!Number.isFinite(start))
+        return undefined;
+    if (mark === 'start')
+        return start;
+    if (mark === 'in')
+        return start + (voice.fade.in ?? 0);
+    const out = voice.out;
+    let outAt;
+    if (out !== null)
+        outAt = out.at;
+    else if (Number.isFinite(voice.outAt))
+        outAt = voice.outAt;
+    else if (!voice.holdsAfter && Number.isFinite(voice.span)) {
+        const t = voice.timeAt(voice.span + voice.latest);
+        if (Number.isFinite(t))
+            outAt = Math.max(start, t);
+    }
+    if (mark === 'out')
+        return voice.state === 'done' && outAt === undefined ? voice.doneAt : outAt;
+    if (voice.state === 'done')
+        return voice.doneAt;
+    if (out !== null) {
+        if (out.rest)
+            return out.deadline === undefined ? undefined : out.at + out.deadline;
+        return out.at + out.over;
+    }
+    return outAt === undefined ? undefined : outAt + (mix.reduced ? 0 : (voice.fade.out ?? 0));
+}

package/dist/meet.d.ts

@@ -0,0 +1,16 @@
+import type { Lanes } from './lanes.js';
+import type { Subject } from './voice.js';
+/**
+ * Whether the lanes a probe of the subject at `slot` just met (`met`) can be folded on the general
+ * path after the lanes' values: none is in a locus or a crowd, the subject owes none already this
+ * fill, and each comes after every other laned voice in voice order, so folding it last folds in
+ * the general path's order.
+ */
+export declare function owable<I, O>(lanes: Lanes<I, O>, slot: number): boolean;
+/**
+ * Gives a probed subject a position on every lane that started playing since the subject was last
+ * checked and that reaches it. True when any did, so the probe takes the general path.
+ */
+export declare function meet<I, O>(lanes: Lanes<I, O>, slot: number, subject: I, head: Subject<unknown> | null): boolean;
+/** Counts an idle lane more or fewer reaching a subject. */
+export declare function reach<I, O>(lanes: Lanes<I, O>, slot: number, by: number): void;

package/dist/meet.js

@@ -0,0 +1,113 @@
+/**
+ * Whether the lanes a probe of the subject at `slot` just met (`met`) can be folded on the general
+ * path after the lanes' values: none is in a locus or a crowd, the subject owes none already this
+ * fill, and each comes after every other laned voice in voice order, so folding it last folds in
+ * the general path's order.
+ */
+export function owable(lanes, slot) {
+    if (lanes.metCrowd || lanes.owes(slot))
+        return false;
+    // Subjects meeting the same lanes in one fill get the same answer, and a list is kept only once true.
+    if (lanes.owed.last(lanes.met))
+        return true;
+    const met = lanes.met;
+    let other = Number.NEGATIVE_INFINITY;
+    for (const lane of lanes.lanes) {
+        const id = lane.voice.id;
+        if (id > other && !met.includes(id))
+            other = id;
+    }
+    for (const c of lanes.crowds)
+        if (c.size > 0)
+            other = Math.max(other, c.hot[(c.size - 1) * c.stride + 7 /* Hot.ID */]);
+    for (const id of met)
+        if (id <= other || lanes.byId.get(id).group !== null)
+            return false;
+    return true;
+}
+/**
+ * Gives a probed subject a position on every lane that started playing since the subject was last
+ * checked and that reaches it. True when any did, so the probe takes the general path.
+ */
+export function meet(lanes, slot, subject, head) {
+    const seen = lanes.per[slot * 6 /* Per.SLOT */ + 1 /* Per.SEEN */];
+    const from = seen < 0 ? -1 - seen : seen;
+    lanes.per[slot * 6 /* Per.SLOT */ + 1 /* Per.SEEN */] = lanes.epochs;
+    let met = false;
+    lanes.met.length = 0;
+    lanes.metCrowd = false;
+    const dense = lanes.dense;
+    for (let i = dense.length - 1; i >= 0; i--) {
+        const lane = dense[i];
+        if (lane.epoch <= from)
+            break;
+        if (lane.positionOf(slot) >= 0)
+            continue;
+        const held = lanes.host.meet(lane.voice, subject, head, slot);
+        if (!held.reaches)
+            continue;
+        lane.add(slot, held);
+        if (lane.idle)
+            reach(lanes, slot, 1);
+        lanes.met.push(lane.voice.id);
+        met = true;
+    }
+    // `open` marks every subject a voice naming it starts on, so an unmarked one has none to meet.
+    const naming = seen < 0 ? lanes.host.naming(subject) : undefined;
+    if (naming !== undefined)
+        for (const voice of naming) {
+            const lane = lanes.byId.get(voice.id);
+            if (lane === undefined) {
+                if (place(lanes, voice, slot, subject, from, head)) {
+                    met = true;
+                    lanes.metCrowd = true;
+                }
+                continue;
+            }
+            if (lane.epoch <= from || lane.positionOf(slot) >= 0)
+                continue;
+            const held = lanes.host.meet(voice, subject, head, slot);
+            if (!held.reaches)
+                continue;
+            lane.add(slot, held);
+            if (lane.idle)
+                reach(lanes, slot, 1);
+            lanes.met.push(voice.id);
+            met = true;
+        }
+    return met;
+}
+/** Places a crowd voice's row on the subject a probe met, as `Lane.add` adds a position. */
+function place(lanes, voice, slot, subject, from, head) {
+    const c = lanes.crowdOf.get(voice.id);
+    const p = c?.rowOf.get(voice.id);
+    if (c === undefined || p === undefined)
+        return false;
+    const h = p * c.stride;
+    const flags = c.hot[h + 0 /* Hot.FLAGS */];
+    if (c.hot[h + 6 /* Hot.EPOCH */] <= from || (flags & 16 /* Flag.PLACED */) !== 0)
+        return false;
+    const held = lanes.host.meet(voice, subject, head, slot);
+    if (!held.reaches)
+        return false;
+    const o = p * 8 /* Row.STRIDE */;
+    c.list[p] = slot;
+    c.data[o + 0 /* Row.DELAY */] = held.delay;
+    c.data[o + 1 /* Row.SINCE */] = held.shown;
+    c.data[o + 2 /* Row.WEIGHT */] = 0;
+    c.data[o + 3 /* Row.PROBED */] = 0;
+    c.data[o + 4 /* Row.MSLOT */] = -1;
+    c.data[o + 5 /* Row.SAMPLED */] = -1;
+    c.data[o + 7 /* Row.MET */] = 0;
+    c.records[p] = held;
+    c.deltas[p] = null;
+    c.restale(p, flags | 16 /* Flag.PLACED */);
+    if (c.idle)
+        reach(lanes, slot, 1);
+    return true;
+}
+/** Counts an idle lane more or fewer reaching a subject. */
+export function reach(lanes, slot, by) {
+    const i = slot * 6 /* Per.SLOT */ + 2 /* Per.IDLE */;
+    lanes.per[i] = lanes.per[i] + by;
+}