@msb235/blits 0.3.0 → 0.5.0

package/dist/clone.js

@@ -0,0 +1,57 @@
+const slow = Symbol('slow');
+/**
+ * `structuredClone(v)`, made directly for what records mostly hold — numbers, strings, and plain
+ * objects and arrays of them two deep — with what `structuredClone` would give; anything else, or
+ * anything it would refuse, goes to it. A read back copies a record per voice and subject.
+ */
+export function clone(v) {
+    const quick = copied(v, 2);
+    met.length = 0;
+    return quick === slow ? structuredClone(v) : quick;
+}
+/** The objects one `clone` has met: one met twice is shared, which `structuredClone` keeps. */
+const met = [];
+function copied(v, depth) {
+    if (typeof v === 'symbol' || typeof v === 'function')
+        return slow;
+    if (typeof v !== 'object' || v === null)
+        return v;
+    if (depth === 0 || met.includes(v))
+        return slow;
+    met.push(v);
+    if (Array.isArray(v)) {
+        if (Object.getPrototypeOf(v) !== Array.prototype)
+            return slow;
+        const out = [];
+        for (let i = 0; i < v.length; i++) {
+            if (!(i in v))
+                return slow;
+            const x = copied(v[i], depth - 1);
+            if (x === slow)
+                return slow;
+            out.push(x);
+        }
+        // A property besides the elements, which `structuredClone` keeps.
+        let keys = 0;
+        for (const _ in v)
+            if (++keys > v.length)
+                return slow;
+        return out;
+    }
+    const proto = Object.getPrototypeOf(v);
+    if (proto !== Object.prototype && proto !== null)
+        return slow;
+    const out = {};
+    for (const k in v) {
+        if (k === '__proto__')
+            return slow;
+        const x = copied(v[k], depth - 1);
+        if (x === slow)
+            return slow;
+        out[k] = x;
+    }
+    return out;
+}
+export function copy(v) {
+    return Array.isArray(v) ? [...v] : v;
+}

package/dist/columns.d.ts

@@ -0,0 +1,29 @@
+import type { Lanes } from './lanes.js';
+/** One channel `pull` writes: where in the kit, how many numbers a subject, and its rest. */
+export interface Column {
+    key: string;
+    slot: number;
+    axes: number;
+    out: Float64Array;
+    /** The rest, clamped, or NaN for a channel with none. */
+    rest: Float64Array;
+    bounds: readonly [number, number] | undefined;
+}
+export declare function clampRun(out: Float64Array, at: number, n: number, [lo, hi]: readonly [number, number]): void;
+/**
+ * For a `pull` of a list it read last time in the same order, with every voice on a lane, where
+ * `heads` holds each position's remembered chain head unless all are known current: what
+ * `prepare` and `writeLater` do for each subject from position `from`, while the subject reads
+ * from the lanes; returns the first position that does not, or the list's length.
+ */
+export declare function pullRun<I, O>(lanes: Lanes<I, O>, slots: Int32Array, list: readonly I[], was: readonly I[], heads: readonly ({
+    version: number;
+} | undefined)[] | null, from: number, columns: readonly Column[], now: number, version: number): number;
+/**
+ * Queues a subject's values for each column at subject `n`'s places, for a `pull` that reads
+ * from the lanes while every voice is on one; `flush` writes what is queued, column by column. A
+ * channel no lane holds is at rest. Anything queued is written before the lanes fill again.
+ */
+export declare function writeLater<I, O>(lanes: Lanes<I, O>, slot: number, columns: readonly Column[], n: number): void;
+/** Writes every queued run into its columns: a channel's values as a block, a rest as a fill. */
+export declare function flush<I, O>(lanes: Lanes<I, O>): void;

package/dist/columns.js

@@ -0,0 +1,183 @@
+export function clampRun(out, at, n, [lo, hi]) {
+    for (let i = at; i < at + n; i++) {
+        const x = out[i];
+        out[i] = x < lo ? lo : x > hi ? hi : x;
+    }
+}
+/**
+ * For a `pull` of a list it read last time in the same order, with every voice on a lane, where
+ * `heads` holds each position's remembered chain head unless all are known current: what
+ * `prepare` and `writeLater` do for each subject from position `from`, while the subject reads
+ * from the lanes; returns the first position that does not, or the list's length.
+ */
+export function pullRun(lanes, slots, list, was, heads, from, columns, now, version) {
+    const ready = lanes.filled(now, version) ? 1 /* Begin.READY */ : lanes.begin(now, version);
+    if (ready !== 1 /* Begin.READY */ || !lanes.whole)
+        return from;
+    const per = lanes.per;
+    const fills = lanes.fills;
+    const wide = lanes.wide;
+    const frame = lanes.frameProbes;
+    const subjects = lanes.subjects;
+    if (columns !== lanes.queuedFor) {
+        flush(lanes);
+        lanes.queuedFor = columns;
+    }
+    room(lanes, lanes.queued + list.length - from);
+    const qSlots = lanes.queueSlots;
+    const qRows = lanes.queueRows;
+    const qCounts = lanes.queueCounts;
+    let k = lanes.queued;
+    let n = from;
+    // The run being gathered: its first slot and row, and how far it has reached.
+    let first = -1;
+    let start = from;
+    for (; n < list.length; n++) {
+        const subject = list[n];
+        if (was[n] !== subject || (heads !== null && heads[n]?.version !== version))
+            break;
+        const slot = slots[n];
+        const o = slot * 6 /* Per.SLOT */;
+        if (slot < 0 ||
+            per[o + 0 /* Per.FILLED */] !== fills ||
+            per[o + 2 /* Per.IDLE */] !== 0 ||
+            per[o + 1 /* Per.SEEN */] < wide ||
+            lanes.owes(slot))
+            break;
+        if (!(per[o + 3 /* Per.LANE_PROBE */] > frame ||
+            per[o + 4 /* Per.GENERAL_PROBE */] > frame))
+            lanes.distinct++;
+        per[o + 3 /* Per.LANE_PROBE */] = ++lanes.probes;
+        per[o + 5 /* Per.LANE_FILL */] = fills;
+        subjects[slot] = subject;
+        if (slot !== first + (n - start)) {
+            if (first >= 0) {
+                qSlots[k] = first;
+                qRows[k] = start;
+                qCounts[k] = n - start;
+                k++;
+            }
+            first = slot;
+            start = n;
+        }
+    }
+    if (first >= 0) {
+        qSlots[k] = first;
+        qRows[k] = start;
+        qCounts[k] = n - start;
+        k++;
+    }
+    lanes.queued = k;
+    if (n > from)
+        lanes.holding = true;
+    return n;
+}
+/**
+ * Queues a subject's values for each column at subject `n`'s places, for a `pull` that reads
+ * from the lanes while every voice is on one; `flush` writes what is queued, column by column. A
+ * channel no lane holds is at rest. Anything queued is written before the lanes fill again.
+ */
+export function writeLater(lanes, slot, columns, n) {
+    queue(lanes, columns, slot, n, 1);
+}
+/** Queues `count` subjects from lane slot `slot` for rows from `row`, one apart in both. */
+function queue(lanes, columns, slot, row, count) {
+    if (columns !== lanes.queuedFor) {
+        flush(lanes);
+        lanes.queuedFor = columns;
+    }
+    const k = lanes.queued;
+    if (k > 0) {
+        const last = k - 1;
+        const had = lanes.queueCounts[last];
+        if (slot === lanes.queueSlots[last] + had &&
+            row === lanes.queueRows[last] + had) {
+            lanes.queueCounts[last] = had + count;
+            return;
+        }
+    }
+    room(lanes, k + 1);
+    lanes.queueSlots[k] = slot;
+    lanes.queueRows[k] = row;
+    lanes.queueCounts[k] = count;
+    lanes.queued = k + 1;
+}
+/** Makes room in the queue for `runs` runs. */
+function room(lanes, runs) {
+    if (runs <= lanes.queueSlots.length)
+        return;
+    const size = Math.max(64, runs, lanes.queueSlots.length * 2);
+    lanes.queueSlots = grown(lanes.queueSlots, size);
+    lanes.queueRows = grown(lanes.queueRows, size);
+    lanes.queueCounts = grown(lanes.queueCounts, size);
+}
+function grown(a, size) {
+    const b = new Int32Array(size);
+    b.set(a);
+    return b;
+}
+/** Writes every queued run into its columns: a channel's values as a block, a rest as a fill. */
+export function flush(lanes) {
+    const runs = lanes.queued;
+    const columns = lanes.queuedFor;
+    if (runs === 0 || columns === null)
+        return;
+    lanes.queued = 0;
+    for (let k = 0; k < columns.length; k++) {
+        const c = columns[k];
+        const ch = lanes.bySlot[c.slot];
+        if (ch === undefined)
+            rests(lanes, c, runs);
+        else
+            copies(lanes, c, ch.values, runs);
+        if (c.bounds !== undefined)
+            for (let r = 0; r < runs; r++)
+                clampRun(c.out, lanes.queueRows[r] * c.axes, lanes.queueCounts[r] * c.axes, c.bounds);
+    }
+}
+// A typed array's `fill` and `set` cost more to call than a short run costs to copy.
+/** Writes a column's rest into every queued run's rows. */
+function rests(lanes, c, runs) {
+    const rows = lanes.queueRows;
+    const counts = lanes.queueCounts;
+    const out = c.out;
+    const axes = c.axes;
+    if (axes === 1) {
+        const v = c.rest[0];
+        for (let r = 0; r < runs; r++) {
+            const at = rows[r];
+            const end = at + counts[r];
+            if (end - at > 64)
+                out.fill(v, at, end);
+            else
+                for (let i = at; i < end; i++)
+                    out[i] = v;
+        }
+        return;
+    }
+    for (let r = 0; r < runs; r++) {
+        const at = rows[r] * axes;
+        const end = at + counts[r] * axes;
+        for (let i = at; i < end; i += axes)
+            for (let a = 0; a < axes; a++)
+                out[i + a] = c.rest[a];
+    }
+}
+/** Copies a laned channel's values for every queued run into its rows. */
+function copies(lanes, c, values, runs) {
+    const slots = lanes.queueSlots;
+    const rows = lanes.queueRows;
+    const counts = lanes.queueCounts;
+    const out = c.out;
+    const axes = c.axes;
+    for (let r = 0; r < runs; r++) {
+        const at = rows[r] * axes;
+        const base = slots[r] * axes;
+        const span = counts[r] * axes;
+        if (span > 64)
+            out.set(values.subarray(base, base + span), at);
+        else
+            for (let i = 0; i < span; i++)
+                out[at + i] = values[base + i];
+    }
+}

package/dist/crowd.d.ts

@@ -0,0 +1,128 @@
+import type { Curve } from './easing.js';
+import { KeyRows } from './keyrows.js';
+import { type Laned, type Positions } from './lane.js';
+import type { Lanes } from './lanes.js';
+import { type Motions } from './motion.js';
+import type { Scratch } from './patch.js';
+import type { Subject, Voice } from './voice.js';
+/**
+ * Whether a laned voice belongs in a crowd: one naming a single subject, which shares nothing
+ * across subjects for a lane to save. A motion voice writes one channel; a keys or fn voice may
+ * write several, and joins the crowd of voices writing those same channels.
+ */
+export declare function crowdable<I, O>(v: Voice<I, O>): boolean;
+/** The law of a row that has none, a keys or fn voice's. */
+export declare const none: Float64Array<ArrayBuffer>;
+/** Per row of a crowd's `hot`: what the fill reads of the row's voice and its current stretch. */
+export declare const enum Hot {
+    FLAGS = 0,
+    NOW = 1,
+    ELAPSED = 2,
+    RATE = 3,
+    /** The voice's weight, held to 0..1. */
+    WEIGHT = 4,
+    SEEKS = 5,
+    EPOCH = 6,
+    ID = 7,
+    AT = 8,
+    MS = 9,
+    /** `x0`, `v0` and `to`, `axes` numbers each. */
+    X0 = 10
+}
+/** A crowd row's flags, at `Hot.FLAGS`. */
+export declare const enum Flag {
+    /** The voice is playing: live, held or fading. */
+    PLAYING = 1,
+    /** Its weight and clock are `hot`'s: no fade in or out, rate ramp, subject ramp or kept state. */
+    FAST = 2,
+    /** Its stretch changed since `hot` copied it. */
+    STALE = 4,
+    /** `hot` holds its stretch, with nothing pending and no earlier stretch kept. */
+    BARE = 8,
+    /** A probe has met its subject, so its per-subject numbers are set. */
+    PLACED = 16,
+    /** Its samples fold as the channel's axes, a number for a number and an array for an array. */
+    FOLDS = 32,
+    /** Something on the voice changed since `hot` copied it. */
+    VOICE = 64,
+    /** The row's voice is a motion voice; otherwise its patch is keys or a stateless fn. */
+    MOTION = 128,
+    /** The voice holds before or after, so its clock is read from the voice. */
+    HOLDS = 256,
+    /** A keys row whose stops `keys` holds, at `Hot.AT`, with its duration at `Hot.X0` and passes at `Hot.MS`. */
+    FLAT = 512,
+    /** The row's patch is a tween. */
+    TWEEN = 1024
+}
+/** Whether a row's flags let `bareRows` take it. */
+export declare function bare(f: number): boolean;
+/**
+ * Every laned voice on one channel that reaches a single subject, a row each, in voice order: the
+ * per-subject numbers a lane keeps, and a copy of what a fill reads of the voice and, for a motion
+ * voice, its patch, so a fill over 100k of them reads a few flat arrays instead of 100k voices,
+ * lanes and patch buffers. Each copy is written when its source changes: the voice's by
+ * `voiceChanged`, the stretch by `stretchChanged`.
+ */
+export declare class Crowd<I, O> implements Positions<I, O> {
+    readonly chans: Laned[];
+    readonly axes: number;
+    /** The subject number at each row. */
+    list: number[];
+    /** `STRIDE` numbers per row, laid out as a lane's. */
+    data: Float64Array<ArrayBuffer>;
+    hot: Float64Array<ArrayBuffer>;
+    readonly stride: number;
+    samples: Float64Array<ArrayBuffer>;
+    deltas: (Record<string, unknown> | null)[];
+    records: (Subject<unknown> | undefined)[];
+    voices: Voice<I, O>[];
+    motions: (Motions<I> | undefined)[];
+    eases: (Curve | undefined)[];
+    /** Each row's patch law, one array shared by every row whose law is the same. */
+    laws: Float64Array[];
+    readonly rowOf: Map<number, number>;
+    idle: boolean;
+    readonly line: {
+        stop: number;
+        start: number;
+    };
+    /** Where the fill now under way has reached. */
+    cursor: number;
+    /** Rows whose voices have left, kept in place until the crowds are next rebuilt. */
+    dead: number;
+    /** Whether some row is `Flag.STALE`, for `freshen` to copy before the fill's loop. */
+    stale: boolean;
+    readonly xs: Float64Array;
+    readonly vs: Float64Array;
+    /** What a keys row reads into, folded before the next row reads. */
+    readonly delta: Record<string, unknown>;
+    /** The stops of its `Flag.FLAT` keys rows. */
+    keys: KeyRows;
+    readonly scratch: Scratch;
+    /** The last fill that ran the crowd's rows, and its `now`, which a `Sampled.BARE` row was sampled at. */
+    bareFill: number;
+    bareNow: number;
+    constructor(chans: Laned[], axes: number);
+    voiceAt(p: number): Voice<I, O>;
+    fix(p: number): void;
+    numbered(): void;
+    /** Marks row `p` to copy its stretch from its patch again before the next fill reads it. */
+    restale(p: number, flags: number): void;
+    /** Samples of another width than the channel's, which `samples` cannot hold, by row. */
+    odd: Map<number, Float64Array> | null;
+    keep(p: number, xs: Float64Array, n: number): void;
+    kept(p: number, xs: Float64Array): void;
+    motionAt(p: number): Motions<I> | undefined;
+    get size(): number;
+    /** Makes room for `rows` rows. */
+    reserve(rows: number): void;
+}
+/** Runs every crowd's rows whose voices come before voice `id`, from where each crowd reached. */
+export declare function crowdsUpTo<I, O>(lanes: Lanes<I, O>, id: number): void;
+/** A keys or fn row's contribution, as `one` makes a lane position's. */
+export declare function row<I, O>(this: Lanes<I, O>, c: Crowd<I, O>, p: number, voice: Voice<I, O>, slot: number, elapsed: number, delay: number, w: number): void;
+/**
+ * Copies stale motion rows' stretches as a fill begins: inside `runCrowd`, once voices came and
+ * went, TurboFan spent its inlining on the copy and stopped inlining every row's ease.
+ */
+export declare function freshen<I, O>(c: Crowd<I, O>): void;