@msb235/blits 0.4.0 → 0.5.0

package/dist/qualify.js

@@ -0,0 +1,345 @@
+import { numericOf } from './channels.js';
+import { flush } from './columns.js';
+import { crowdable } from './crowd.js';
+import { wake } from './fill.js';
+import { Lane } from './lane.js';
+import { bury, compactSparse, join, regroup, retouchRow, sameCrowds } from './rows.js';
+import { settle } from './sample.js';
+/**
+ * Which channels run as lanes and which voices run on them: the fixed point where every voice
+ * writing a laned channel fits and writes only laned channels. Only channels some laned voice
+ * writes are laned.
+ */
+export function qualify(numeric, voices) {
+    const open = numeric.slice();
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const v of voices) {
+            if (v.fits && v.slots.every((s) => open[s]))
+                continue;
+            for (const s of v.slots)
+                if (open[s]) {
+                    open[s] = false;
+                    changed = true;
+                }
+        }
+    }
+    const laned = new Set();
+    const channels = numeric.map(() => false);
+    for (const v of voices) {
+        if (!v.fits || !v.slots.every((s) => open[s]))
+            continue;
+        laned.add(v.id);
+        for (const s of v.slots)
+            channels[s] = true;
+    }
+    return { channels, voices: laned };
+}
+export function requalify(lanes, version) {
+    flush(lanes);
+    const host = lanes.host;
+    lanes.qualifiedVersion = version;
+    lanes.filledVersion = Number.NaN;
+    const touched = lanes.touched.slice();
+    lanes.touched.length = 0;
+    // An owner writes nothing and no fold meets it, so it neither takes a lane nor keeps one whole.
+    const present = host.voices.filter((v) => v.state !== 'done' && v.holding === null);
+    for (const v of present)
+        if (v.id > lanes.known)
+            lanes.known = v.id;
+    const numeric = host.channels.map((c) => numericOf(c) !== undefined);
+    // A voice writing nothing has no lane to fill, so it stays where its calls are made.
+    const fits = present.map((v) => v.slots.length > 0 && host.fits(v));
+    const candidates = () => present.map((v, i) => ({ id: v.id, fits: fits[i], slots: v.slots }));
+    let { channels, voices } = qualify(numeric, candidates());
+    // A locus folds its members together, so they run on lanes all together or not at all.
+    for (let split = true; split;) {
+        split = false;
+        const loci = new Map();
+        present.forEach((v, i) => {
+            const name = v.spec.locus;
+            if (name === undefined)
+                return;
+            const at = loci.get(name);
+            if (at === undefined)
+                loci.set(name, [i]);
+            else
+                at.push(i);
+        });
+        for (const at of loci.values()) {
+            const on = at.filter((i) => voices.has(present[i].id)).length;
+            if (on === 0 || on === at.length)
+                continue;
+            for (const i of at)
+                fits[i] = false;
+            split = true;
+        }
+        if (split)
+            ({ channels, voices } = qualify(numeric, candidates()));
+    }
+    for (const lane of lanes.lanes)
+        if (!voices.has(lane.voice.id))
+            leave(lanes, lane);
+    const kept = [];
+    let crowded = 0;
+    for (const v of present) {
+        if (!voices.has(v.id))
+            continue;
+        if (crowdable(v)) {
+            crowded++;
+            continue;
+        }
+        const lane = lanes.byId.get(v.id) ?? new Lane(v);
+        v.laned = true;
+        if (lane.epoch === 0 && v.state !== 'pending')
+            lane.epoch = open(lanes, v);
+        kept.push(lane);
+    }
+    lanes.lanes = kept;
+    lanes.loci = [];
+    const loci = new Map();
+    for (const lane of kept) {
+        lane.group = null;
+        const name = lane.voice.spec.locus;
+        if (name === undefined)
+            continue;
+        let g = loci.get(name);
+        if (g === undefined) {
+            g = {
+                members: [],
+                met: new Float64Array(lanes.cap),
+                first: new Float64Array(lanes.cap),
+                sum: new Float64Array(lanes.cap),
+                values: [],
+                taken: [],
+            };
+            loci.set(name, g);
+            lanes.loci.push(g);
+        }
+        g.members.push(lane);
+        lane.group = g;
+    }
+    lanes.dense = kept
+        .filter((l) => l.voice.named === null && l.epoch > 0)
+        .sort((a, b) => a.epoch - b.epoch);
+    lanes.whole = kept.length + crowded === present.length;
+    lanes.byId.clear();
+    for (const lane of kept)
+        lanes.byId.set(lane.voice.id, lane);
+    // With no lane left no fill comes to let go of the subjects the last probes held.
+    if (kept.length === 0 && crowded === 0)
+        lanes.subjects = [];
+    const members = present.filter((v) => voices.has(v.id) && crowdable(v));
+    // The same channels laned and the same voices crowded, as when a voice over every subject comes
+    // or goes among a crowd of thousands: what a rebuild would make is what is there.
+    if (sameChannels(lanes, channels) && sameCrowds(lanes, members)) {
+        for (const lane of kept) {
+            lane.chans = lane.voice.slots.map((s) => lanes.bySlot[s]);
+            lane.values = lane.chans.map(() => undefined);
+        }
+        for (const c of lanes.crowds)
+            for (let p = 0; p < c.size; p++) {
+                const v = c.voices[p];
+                if (c.rowOf.get(v.id) === p && v.state === 'done')
+                    bury(lanes, c, p);
+            }
+        // A crowd voice that started or began fading takes it up on its row, as `retouch` does.
+        for (const v of touched) {
+            if (v.state === 'done')
+                continue;
+            const c = lanes.crowdOf.get(v.id);
+            const p = c?.rowOf.get(v.id);
+            if (c !== undefined && p !== undefined)
+                retouchRow(lanes, c, p, v);
+        }
+        compactSparse(lanes);
+        return;
+    }
+    lanes.laned = [];
+    lanes.bySlot = host.channels.map(() => undefined);
+    channels.forEach((on, slot) => {
+        if (!on)
+            return;
+        const channel = host.channels[slot];
+        const n = numericOf(channel);
+        const rest = channel.rest;
+        const ch = {
+            name: host.names[slot],
+            op: n.op,
+            scalar: typeof rest === 'number',
+            rest: typeof rest === 'number' ? rest : rest[0],
+            axes: n.axes,
+            values: new Float64Array(lanes.cap * n.axes),
+            start: typeof rest === 'number' ? [] : rest,
+            index: lanes.laned.length,
+        };
+        lanes.laned.push(ch);
+        lanes.bySlot[slot] = ch;
+    });
+    lanes.copies.length = 0;
+    for (const ch of lanes.bySlot)
+        lanes.copies.push(ch !== undefined);
+    for (const lane of kept) {
+        lane.chans = lane.voice.slots.map((s) => lanes.bySlot[s]);
+        lane.values = lane.chans.map(() => undefined);
+    }
+    regroup(lanes, members);
+}
+/** Whether qualifying laned exactly the channels laned now. */
+function sameChannels(lanes, channels) {
+    const by = lanes.bySlot;
+    if (by.length !== channels.length)
+        return false;
+    for (let i = 0; i < by.length; i++)
+        if ((by[i] !== undefined) !== channels[i])
+            return false;
+    return true;
+}
+/**
+ * A voice starts playing on a lane or crowd: its epoch. Every subject meets a voice over all of
+ * them on its next probe; a voice naming its subjects marks only those.
+ */
+export function open(lanes, v) {
+    const epoch = ++lanes.epochs;
+    if (v.named === null) {
+        lanes.wide = epoch;
+        return epoch;
+    }
+    for (const subject of v.named) {
+        const slot = lanes.host.slotOf(subject);
+        if (slot < 0 || slot >= lanes.cap)
+            continue;
+        const i = slot * 6 /* Per.SLOT */ + 1 /* Per.SEEN */;
+        const seen = lanes.per[i];
+        const from = seen < 0 ? -1 - seen : seen;
+        lanes.per[i] = -1 - Math.min(from, epoch - 1);
+    }
+    return epoch;
+}
+/**
+ * Takes the voices `touch` named on or off their crowds, each as it now stands; false at the
+ * first that cannot be, which needs a qualify: one that leaves a lane or the general path, which
+ * may open a channel, or one that joins anything but a crowd on a laned channel. Neither a voice
+ * that fits joining laned channels nor a laned one leaving moves the fixed point `qualify` finds.
+ * A crowd a quarter empty rows is compacted.
+ */
+export function retouch(lanes) {
+    const touched = [...new Set(lanes.touched)].sort((a, b) => a.id - b.id);
+    lanes.touched.length = 0;
+    // The qualify a false answer calls takes up every touched voice, crowd rows starting included.
+    const qualify = () => {
+        lanes.touched = touched;
+        return false;
+    };
+    for (const v of touched) {
+        const known = v.id <= lanes.known;
+        if (v.id > lanes.known)
+            lanes.known = v.id;
+        const c = lanes.crowdOf.get(v.id);
+        const p = c?.rowOf.get(v.id);
+        if (c !== undefined && p !== undefined) {
+            if (v.state === 'done') {
+                bury(lanes, c, p);
+                continue;
+            }
+            retouchRow(lanes, c, p, v);
+            continue;
+        }
+        if (v.state === 'done' && !known)
+            continue;
+        const lane = lanes.byId.get(v.id);
+        if (lane !== undefined) {
+            if (!relane(lanes, lane))
+                return qualify();
+            continue;
+        }
+        if (v.state === 'done')
+            return qualify();
+        // A locus's members are on lanes together or not at all, so one joining may move the others.
+        if (v.spec.locus !== undefined)
+            return qualify();
+        const laned = v.slots.some((slot) => lanes.bySlot[slot] !== undefined);
+        const fits = v.slots.length > 0 && lanes.host.fits(v);
+        if (!laned && !fits) {
+            lanes.whole = false;
+            continue;
+        }
+        if (known || !fits || !laned || v.slots.some((slot) => lanes.bySlot[slot] === undefined))
+            return qualify();
+        if (crowdable(v))
+            join(lanes, v, undefined, undefined, lanes.crowds);
+        else
+            enlane(lanes, v);
+    }
+    compactSparse(lanes);
+    // As a qualify leaving nothing on lanes: no fill comes to let go of what the last probes held.
+    if (lanes.lanes.length === 0 && lanes.crowds.every((c) => c.dead === c.size))
+        lanes.subjects = [];
+    return true;
+}
+/**
+ * A new voice that fits and writes only laned channels, and that no crowd takes, gets a lane at
+ * the end of the order, its id being past every other: what a qualify would give it, since such a
+ * voice joining cannot unlane a channel.
+ */
+function enlane(lanes, v) {
+    const lane = new Lane(v);
+    v.laned = true;
+    if (v.state !== 'pending')
+        lane.epoch = open(lanes, v);
+    lane.chans = v.slots.map((s) => lanes.bySlot[s]);
+    lane.values = lane.chans.map(() => undefined);
+    lanes.lanes.push(lane);
+    lanes.byId.set(v.id, lane);
+    if (v.named === null && lane.epoch > 0)
+        lanes.dense.push(lane);
+}
+/**
+ * A laned voice that started playing or finished, as a qualify would take it: a lane leaving
+ * cannot lane or unlane another channel. False for a locus member, which a qualify must take.
+ */
+function relane(lanes, lane) {
+    const v = lane.voice;
+    if (v.state !== 'done') {
+        if (lane.epoch === 0 && v.state !== 'pending') {
+            lane.epoch = open(lanes, v);
+            if (v.named === null)
+                lanes.dense.push(lane);
+        }
+        return true;
+    }
+    if (lane.group !== null)
+        return false;
+    leave(lanes, lane);
+    lanes.lanes.splice(lanes.lanes.indexOf(lane), 1);
+    const d = lanes.dense.indexOf(lane);
+    if (d >= 0)
+        lanes.dense.splice(d, 1);
+    lanes.byId.delete(v.id);
+    return true;
+}
+/** Hands a voice back to the general path, with the weights `weightOf` reports kept on its records. */
+function leave(lanes, lane) {
+    if (lane.idle)
+        wake(lanes, lane);
+    // A retired voice reports no weight, so only a motion's samples are left to settle.
+    const done = lane.voice.state === 'done';
+    if (!done || lane.motion !== undefined)
+        for (let p = 0; p < lane.list.length; p++) {
+            const rec = lane.records[p];
+            const slot = lane.list[p];
+            const w = done ? undefined : lanes.reported(lane, slot);
+            if (rec !== undefined && w !== undefined)
+                rec.weight = w;
+            if (rec !== undefined && lane.motion !== undefined)
+                settle(lanes, lane, p, slot, rec);
+        }
+    const run = lane.motion;
+    if (run !== undefined && run.watcher === lanes && run.watchId === lane.voice.id) {
+        for (let p = 0; p < lane.list.length; p++)
+            lane.fix(p);
+        run.watcher = null;
+    }
+    lane.voice.laned = false;
+}

package/dist/relink.d.ts

@@ -0,0 +1,25 @@
+import type { Subject } from './voice.js';
+/** What `patch` needs of a voice: its place in voice order. */
+interface Ordered {
+    readonly id: number;
+}
+/**
+ * The voices over every subject behind each step of a mix's `version`, so a chain linked a few
+ * steps back can be brought up to date by those voices alone; null for a step that changed
+ * anything else, after which every chain links afresh.
+ */
+export declare class Steps<V extends Ordered> {
+    private list;
+    /** The version before `list[0]`. */
+    private from;
+    /** Records the step to `version`, made by `voice`. */
+    push(voice: V | null, version: number): void;
+    /**
+     * A chain linked at `version`, its first record `head` (null where it holds none), with each voice
+     * stepped since taken off it or put on at its place in voice order by `reach`, which gives the
+     * voice's record where a full relink would link it and null where it would not. undefined where
+     * the steps since do not say, so the chain must link afresh.
+     */
+    patch(head: Subject<unknown> | null, version: number, reach: (voice: V) => Subject<unknown> | null): Subject<unknown> | null | undefined;
+}
+export {};

package/dist/relink.js

@@ -0,0 +1,59 @@
+/**
+ * The voices over every subject behind each step of a mix's `version`, so a chain linked a few
+ * steps back can be brought up to date by those voices alone; null for a step that changed
+ * anything else, after which every chain links afresh.
+ */
+export class Steps {
+    list = [];
+    /** The version before `list[0]`. */
+    from = 0;
+    /** Records the step to `version`, made by `voice`. */
+    push(voice, version) {
+        if (this.list.length >= 64) {
+            this.list = this.list.slice(32);
+            this.from += 32;
+        }
+        if (this.from + this.list.length !== version - 1) {
+            this.list = [];
+            this.from = version - 1;
+        }
+        this.list.push(voice);
+    }
+    /**
+     * A chain linked at `version`, its first record `head` (null where it holds none), with each voice
+     * stepped since taken off it or put on at its place in voice order by `reach`, which gives the
+     * voice's record where a full relink would link it and null where it would not. undefined where
+     * the steps since do not say, so the chain must link afresh.
+     */
+    patch(head, version, reach) {
+        if (!(version >= this.from))
+            return undefined;
+        const list = this.list;
+        for (let k = version - this.from; k < list.length; k++) {
+            const voice = list[k];
+            if (voice === null || voice === undefined)
+                return undefined;
+            let prev = null;
+            let at = head;
+            while (at !== null && at.voice.id < voice.id) {
+                prev = at;
+                at = at.next;
+            }
+            const here = at !== null && at.voice === voice ? at : null;
+            const want = reach(voice);
+            if (want === here)
+                continue;
+            const after = here === null ? at : here.next;
+            if (want !== null) {
+                want.voice = voice;
+                want.next = after;
+            }
+            const link = want ?? after;
+            if (prev === null)
+                head = link;
+            else
+                prev.next = link;
+        }
+        return head;
+    }
+}

package/dist/rows.d.ts

@@ -0,0 +1,33 @@
+import { Crowd } from './crowd.js';
+import type { Lanes } from './lanes.js';
+import type { Voice } from './voice.js';
+/** Takes a crowd row off its subject, to be placed again if a probe meets it again. */
+export declare function unplace<I, O>(lanes: Lanes<I, O>, c: Crowd<I, O>, p: number): void;
+/**
+ * Whether every voice qualifying for a crowd has its row, and every row's voice either qualified
+ * or is done, so the crowds stand as a rebuild would leave them, departed rows aside.
+ */
+export declare function sameCrowds<I, O>(lanes: Lanes<I, O>, members: readonly Voice<I, O>[]): boolean;
+/**
+ * Rebuilds the crowds from the voices that belong in one, in voice order: a voice already in a
+ * crowd keeps its row's numbers, a new one gets a row a probe will place, and a voice no longer in
+ * one is handed back to the general path, as a lane's voice is when it leaves.
+ */
+export declare function regroup<I, O>(lanes: Lanes<I, O>, members: Voice<I, O>[]): void;
+/**
+ * Gives a voice the next row of its channel's crowd, made if there is none: a copy of the row it
+ * had in `from` at `at`, or a new one. `old` holds the crowds being replaced, whose idle state a
+ * new crowd on the same channel keeps. Rows stay in voice order only because voices join in it.
+ */
+export declare function join<I, O>(lanes: Lanes<I, O>, v: Voice<I, O>, from: Crowd<I, O> | undefined, at: number | undefined, old: readonly Crowd<I, O>[]): void;
+/** A crowd row takes up its voice as it now stands: opened once it starts, its fields copied again. */
+export declare function retouchRow<I, O>(lanes: Lanes<I, O>, c: Crowd<I, O>, p: number, v: Voice<I, O>): void;
+/**
+ * Compacts every crowd a quarter or more empty rows: each fill walks every row, and at half a
+ * crowd replacing a voice a frame carried as many empty rows as live ones.
+ */
+export declare function compactSparse<I, O>(lanes: Lanes<I, O>): void;
+/** A crowd voice left: its row stays, empty, until the crowds are next rebuilt. */
+export declare function bury<I, O>(lanes: Lanes<I, O>, c: Crowd<I, O>, p: number): void;
+/** A crowd row's weight as `reported` reads a lane position's. */
+export declare function reportedRow<I, O>(lanes: Lanes<I, O>, c: Crowd<I, O>, p: number, slot: number): number | undefined;