@msb235/blits 0.6.0 → 0.7.1

package/dist/revive.d.ts

@@ -0,0 +1,58 @@
+import type { Mixer } from './mixer.js';
+import type { Run } from './motions.js';
+import { type PackedRecord } from './pack.js';
+import { type Key } from './paging.js';
+import type { Described } from './types.js';
+import { type Controls, type Ramp, type Rise, Voice } from './voice.js';
+/** A voice that has left, as plain data: the descriptor it was cued with, its controls and its records. */
+interface PackedVoice {
+    as: Described;
+    start: number;
+    anchorNow: number;
+    anchorElapsed: number;
+    rate: number;
+    ramp: {
+        from: number;
+        to: number;
+        over: number;
+    } | null;
+    weight: number;
+    out: Ramp | null;
+    back: Rise | null;
+    outAt: number;
+    outOver: number;
+    outSet: boolean;
+    cuedAt: number;
+    doneAt: number;
+    opened: number;
+    pinned: number;
+    latest: number;
+    keeping: boolean;
+    first: Controls | null;
+    log: Controls[] | null;
+    played: boolean | undefined;
+    playedAt: number;
+    records: [Key, PackedRecord][];
+    runs: [Key, Run][];
+    left: [Key, number, PackedRecord][];
+    parts: [Key, number, number][];
+    parted: [Key, number][];
+}
+/**
+ * Voices a history store holds whose handles something still holds, by id: a seek that revives
+ * one puts it behind its handle, and needs it back if it left after the moment sought.
+ */
+export declare class Outs {
+    private readonly out;
+    private readonly gone;
+    add(id: number, doneAt: number, h: object): void;
+    /** Takes a revived voice's handle back, undefined where none is held. */
+    take(id: number): object | undefined;
+    /** The id of a voice that left after `t` and that `has` lacks; undefined for none. */
+    missing(t: number, has: (id: number) => boolean): number | undefined;
+}
+/** Pages out a voice that left before `reach`; false for one that has to stay in memory. */
+export declare function pageVoice<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, reach: number): boolean;
+/** A voice a history store paged out, rebuilt from its descriptor and put back as it left. */
+export declare function reviveVoice<I, O>(mix: Mixer<I, O>, id: number, d: PackedVoice): Voice<I, O>;
+export type { PackedVoice };

package/dist/revive.js

@@ -0,0 +1,158 @@
+import { playable } from './cue.js';
+import { VoiceHandle } from './handle.js';
+import { handle } from './hosts.js';
+import { packHeld, unpackHeld } from './pack.js';
+import { pageOut } from './paging.js';
+import { Voice } from './voice.js';
+/**
+ * Voices a history store holds whose handles something still holds, by id: a seek that revives
+ * one puts it behind its handle, and needs it back if it left after the moment sought.
+ */
+export class Outs {
+    out = new Map();
+    gone = new FinalizationRegistry((id) => {
+        if (this.out.get(id)?.handle.deref() === undefined)
+            this.out.delete(id);
+    });
+    add(id, doneAt, h) {
+        this.out.set(id, { doneAt, handle: new WeakRef(h) });
+        this.gone.register(h, id);
+    }
+    /** Takes a revived voice's handle back, undefined where none is held. */
+    take(id) {
+        const e = this.out.get(id);
+        this.out.delete(id);
+        return e?.handle.deref();
+    }
+    /** The id of a voice that left after `t` and that `has` lacks; undefined for none. */
+    missing(t, has) {
+        for (const [id, e] of this.out)
+            if (e.doneAt > t && !has(id))
+                return id;
+        return undefined;
+    }
+}
+/** Whether a voice can leave memory: it was cued with `as`, and nothing else in the mix holds it. */
+function pageable(voice) {
+    return (voice.spec.as !== undefined &&
+        voice.owner === null &&
+        voice.holding === null &&
+        voice.blend === null &&
+        voice.answers === null &&
+        voice.fitting === null);
+}
+/** Pages out a voice that left before `reach`; false for one that has to stay in memory. */
+export function pageVoice(mix, voice, reach) {
+    if (!pageable(voice))
+        return false;
+    const keys = mix.keys;
+    const data = packVoice(voice, keys);
+    pageOut(mix, 'voice', voice.id, undefined, [{ at: voice.doneAt }], () => data, reach);
+    const h = voice.handle;
+    VoiceHandle.page(h, { weight: voice.weight, played: voice.settled.played === true });
+    mix.outs.add(voice.id, voice.doneAt, h);
+    mix.parters.delete(voice);
+    return true;
+}
+function packVoice(voice, keys) {
+    const subjectOf = (key) => keys.subject(key);
+    const records = [];
+    const runs = [];
+    for (const key of voice.keyed ?? []) {
+        const subject = subjectOf(key);
+        const held = voice.subjects.get(subject);
+        if (held?.reaches)
+            records.push([key, packHeld(voice, held)]);
+        const run = voice.motion?.pack(subject);
+        if (run !== undefined)
+            runs.push([key, run]);
+    }
+    const settled = voice.settled;
+    return {
+        as: voice.spec.as,
+        start: voice.start,
+        anchorNow: voice.anchorNow,
+        anchorElapsed: voice.anchorElapsed,
+        rate: voice.rate,
+        ramp: voice.ramp,
+        weight: voice.weight,
+        out: voice.out,
+        back: voice.back,
+        outAt: voice.outAt,
+        outOver: voice.outOver,
+        outSet: voice.outSet,
+        cuedAt: voice.cuedAt,
+        doneAt: voice.doneAt,
+        opened: voice.opened,
+        pinned: voice.pinned,
+        latest: voice.latest,
+        keeping: voice.keeping,
+        first: voice.first,
+        log: voice.log,
+        played: settled.played,
+        playedAt: settled.at,
+        records,
+        runs,
+        left: (voice.left ?? []).map((e) => [keys.key(e.subject), e.at, packHeld(voice, e.held)]),
+        parts: [...(voice.parts ?? [])].map(([s, r]) => [keys.key(s), r.at, r.over]),
+        parted: [...(voice.parted ?? [])].map(([s, at]) => [keys.key(s), at]),
+    };
+}
+/** A voice a history store paged out, rebuilt from its descriptor and put back as it left. */
+export function reviveVoice(mix, id, d) {
+    const revive = mix.opts.history?.revive;
+    if (revive === undefined)
+        throw new Error('blits: a paged voice needs history.revive');
+    const spec = { ...revive(d.as), as: d.as };
+    playable(mix, spec);
+    const voice = new Voice(id, spec, spec.patch, spec.fade ?? {}, Number.NEGATIVE_INFINITY, d.start, mix.slotOf, mix.channels, mix.opts.host, mix.send, null);
+    voice.anchorNow = d.anchorNow;
+    voice.anchorElapsed = d.anchorElapsed;
+    voice.rate = d.rate;
+    voice.ramp = d.ramp;
+    voice.weight = d.weight;
+    voice.out = d.out;
+    voice.back = d.back;
+    voice.outAt = d.outAt;
+    voice.outOver = d.outOver;
+    voice.outSet = d.outSet;
+    voice.cuedAt = d.cuedAt;
+    voice.doneAt = d.doneAt;
+    voice.opened = d.opened;
+    voice.pinned = d.pinned;
+    voice.latest = d.latest;
+    voice.keeping = d.keeping;
+    voice.first = d.first;
+    voice.log = d.log;
+    voice.state = 'done';
+    if (d.played !== undefined)
+        voice.play(d.played, d.playedAt);
+    voice.resolve();
+    const keys = mix.keys;
+    const subjectOf = (key) => keys.subject(key);
+    voice.keyed = new Set();
+    for (const [key, p] of d.records) {
+        voice.subjects.set(subjectOf(key), unpackHeld(voice, p));
+        voice.keyed.add(key);
+    }
+    for (const [key, run] of d.runs)
+        voice.motion?.unpack(subjectOf(key), run);
+    if (d.left.length > 0)
+        voice.left = d.left.map(([key, at, p]) => ({
+            subject: subjectOf(key),
+            at,
+            held: unpackHeld(voice, p),
+        }));
+    if (d.parts.length > 0)
+        voice.parts = new Map(d.parts.map(([key, at, over]) => [subjectOf(key), { at, over }]));
+    if (d.parted.length > 0)
+        voice.parted = new Map(d.parted.map(([key, at]) => [subjectOf(key), at]));
+    const h = mix.outs?.take(id);
+    if (h === undefined)
+        voice.handle = handle(mix, voice);
+    else {
+        VoiceHandle.rehome(h, voice);
+        voice.handle = h;
+    }
+    return voice;
+}

package/dist/sample.d.ts

@@ -1,6 +1,6 @@
 import { type Lane, type Positions } from './lane.js';
 import type { Lanes } from './lanes.js';
-import type { Motions } from './motion.js';
+import type { Motions } from './motions.js';
 import type { Subject } from './voice.js';
 /**
  * A motion voice's fill: what `one` and `move` do for each subject, in one loop for the common

package/dist/sample.js

@@ -17,6 +17,7 @@ export function runMotion(lanes, lane, run) {
     const ch = lane.chans[0];
     const fills = lanes.fills;
     const from = lanes.frameProbes;
+    const lately = lanes.lately;
     const seeks = voice.seeks;
     const elapsedNow = voice.elapsedAt(lanes.now);
     const flat = lane.flat;
@@ -57,6 +58,10 @@ export function runMotion(lanes, lane, run) {
         const q = slot * 6 /* Per.SLOT */;
         if (per[q + 5 /* Per.LANE_FILL */] === fills - 1)
             data[o + 3 /* Row.PROBED */] = data[o + 2 /* Row.WEIGHT */];
+        if (lately >= 0 && lanes.unread(slot)) {
+            unbareLane(lane, p);
+            continue;
+        }
         const delay = data[o + 0 /* Row.DELAY */];
         const elapsed = elapsedNow - delay;
         if (elapsed < 0) {
@@ -106,9 +111,9 @@ export function runMotion(lanes, lane, run) {
                 data[o + 5 /* Row.SAMPLED */] = -2 /* Sampled.BARE */;
                 lane.deltas[p] = null;
             }
-            const share = left(ease, progress(elapsed, runs[b], runs[b + 2]));
             if (w <= 0)
                 continue;
+            const share = left(ease, progress(elapsed, runs[b], runs[b + 2]));
             const values = ch.values;
             const base = slot * n;
             const x = b + 3;

package/dist/scored.d.ts

@@ -0,0 +1,57 @@
+import type { Mixer } from './mixer.js';
+import type { Voice } from './voice.js';
+/**
+ * A mix's voices by the score they were cued on, for an anchor that asks for a score's marks: the
+ * cued ones as a set, the gone ones in the order they left, which an anchor reads once each. Built
+ * over the lists it saw: a seek or a copy that replaces either rebuilds that half on the next read.
+ * A score whose gone voices history lets go of gets a fresh list, so a read of the old one starts
+ * over.
+ */
+export declare class ScoreIndex<I, O> {
+    cued: readonly Voice<I, O>[] | null;
+    by: Map<string, Set<Voice<I, O>>>;
+    gone: readonly Voice<I, O>[] | null;
+    goneBy: Map<string, Voice<I, O>[]>;
+    /** Bumped for a score each time a voice on it is cued, retimed, retired or leaves. */
+    versions: Map<string, number>;
+    /** The scores whose list on the transport names this mix. */
+    held: Set<string>;
+}
+type Member = Mixer<unknown, unknown>;
+/**
+ * Per score, the mixes on a transport that may hold a voice on it, cued or gone, in the
+ * transport's order. Never short of one that does; one found holding none is let go on that read.
+ */
+export type ScoreHolders = Map<string, Member[]>;
+/** The mixes on `mix`'s transport that may hold a voice on `score`; the list is the transport's own. */
+export declare function holders<I, O>(mix: Mixer<I, O>, score: string): readonly Mixer<I, O>[];
+/** Takes `mix` off `score`'s list, having found it holds nothing there. */
+export declare function unhold<I, O>(mix: Mixer<I, O>, score: string): void;
+/** A mix joining its transport, with whatever voices it already has. */
+export declare function scoredJoin<I, O>(mix: Mixer<I, O>): void;
+/** A mix leaving its transport. */
+export declare function scoredDrop<I, O>(mix: Mixer<I, O>): void;
+/**
+ * A voice on its score was cued, retimed, retired or left: what was read of the score is stale. A
+ * host can still retime a gone voice through a handle it kept, so `retimed` on a done voice
+ * replaces its score's gone list too, which starts every read of it over.
+ */
+export declare function scoreTouched<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, retimed?: boolean): void;
+/** How many times `score` has been touched in `mix`. */
+export declare function scoreVersion<I, O>(mix: Mixer<I, O>, score: string): number;
+/** The voices of `mix` cued on `score` and not yet gone, in no order. */
+export declare function scored<I, O>(mix: Mixer<I, O>, score: string): ReadonlySet<Voice<I, O>>;
+/** The voices of `mix` cued on `score` that have gone, in the order they left. */
+export declare function scoredGone<I, O>(mix: Mixer<I, O>, score: string): readonly Voice<I, O>[];
+/** A voice just pushed onto `gone`. */
+export declare function scoredLeft<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): void;
+/**
+ * Gone voices history let go of, out of `was`; `mix.gone` is already what is left, whether that
+ * is `was` cut in place or a new list.
+ */
+export declare function scoredCut<I, O>(mix: Mixer<I, O>, was: readonly Voice<I, O>[], out: readonly Voice<I, O>[]): void;
+/** A voice just cued. */
+export declare function scoredAdd<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): void;
+/** Voices no longer cued. */
+export declare function scoredRemove<I, O>(mix: Mixer<I, O>, voices: Iterable<Voice<I, O>>): void;
+export {};

package/dist/scored.js

@@ -0,0 +1,196 @@
+/**
+ * A mix's voices by the score they were cued on, for an anchor that asks for a score's marks: the
+ * cued ones as a set, the gone ones in the order they left, which an anchor reads once each. Built
+ * over the lists it saw: a seek or a copy that replaces either rebuilds that half on the next read.
+ * A score whose gone voices history lets go of gets a fresh list, so a read of the old one starts
+ * over.
+ */
+export class ScoreIndex {
+    cued = null;
+    by = new Map();
+    gone = null;
+    goneBy = new Map();
+    /** Bumped for a score each time a voice on it is cued, retimed, retired or leaves. */
+    versions = new Map();
+    /** The scores whose list on the transport names this mix. */
+    held = new Set();
+}
+function hold(mix, score) {
+    const held = mix.scored.held;
+    // A dropped mix is off the transport's lists until a seek puts it back, and `scoredJoin` then.
+    if (held.has(score) || mix.dropped)
+        return;
+    held.add(score);
+    const by = mix.transport.holders;
+    const m = mix;
+    const list = by.get(score);
+    if (list === undefined) {
+        by.set(score, [m]);
+        return;
+    }
+    const i = list.findIndex((o) => o.slot > m.slot);
+    if (i < 0)
+        list.push(m);
+    else
+        list.splice(i, 0, m);
+}
+/** The mixes on `mix`'s transport that may hold a voice on `score`; the list is the transport's own. */
+export function holders(mix, score) {
+    return (mix.transport.holders.get(score) ?? none);
+}
+/** Takes `mix` off `score`'s list, having found it holds nothing there. */
+export function unhold(mix, score) {
+    mix.scored.held.delete(score);
+    const by = mix.transport.holders;
+    const list = by.get(score);
+    if (list === undefined)
+        return;
+    const i = list.indexOf(mix);
+    if (i >= 0)
+        list.splice(i, 1);
+    if (list.length === 0)
+        by.delete(score);
+}
+/** A mix joining its transport, with whatever voices it already has. */
+export function scoredJoin(mix) {
+    for (const v of mix.cued)
+        if (v.spec.score !== undefined)
+            hold(mix, v.spec.score);
+    for (const v of mix.gone)
+        if (v.spec.score !== undefined)
+            hold(mix, v.spec.score);
+}
+/** A mix leaving its transport. */
+export function scoredDrop(mix) {
+    for (const score of [...mix.scored.held])
+        unhold(mix, score);
+}
+/**
+ * A voice on its score was cued, retimed, retired or left: what was read of the score is stale. A
+ * host can still retime a gone voice through a handle it kept, so `retimed` on a done voice
+ * replaces its score's gone list too, which starts every read of it over.
+ */
+export function scoreTouched(mix, voice, retimed = false) {
+    const score = voice.spec.score;
+    if (score === undefined)
+        return;
+    const ix = mix.scored;
+    ix.versions.set(score, (ix.versions.get(score) ?? 0) + 1);
+    if (!retimed || voice.state !== 'done')
+        return;
+    const gone = ix.goneBy.get(score);
+    if (gone !== undefined)
+        ix.goneBy.set(score, [...gone]);
+}
+/** How many times `score` has been touched in `mix`. */
+export function scoreVersion(mix, score) {
+    return mix.scored.versions.get(score) ?? 0;
+}
+function put(by, voice) {
+    const score = voice.spec.score;
+    if (score === undefined)
+        return;
+    const set = by.get(score);
+    if (set === undefined)
+        by.set(score, new Set([voice]));
+    else
+        set.add(voice);
+}
+/** The voices of `mix` cued on `score` and not yet gone, in no order. */
+export function scored(mix, score) {
+    const ix = mix.scored;
+    if (ix.cued !== mix.cued) {
+        ix.by = new Map();
+        for (const v of mix.cued)
+            put(ix.by, v);
+        ix.cued = mix.cued;
+    }
+    return ix.by.get(score) ?? noVoices;
+}
+const noVoices = new Set();
+/** The voices of `mix` cued on `score` that have gone, in the order they left. */
+export function scoredGone(mix, score) {
+    const ix = mix.scored;
+    if (ix.gone !== mix.gone) {
+        ix.goneBy = new Map();
+        for (const v of mix.gone)
+            goneAdd(ix.goneBy, v);
+        ix.gone = mix.gone;
+    }
+    return ix.goneBy.get(score) ?? none;
+}
+const none = [];
+function goneAdd(by, voice) {
+    const score = voice.spec.score;
+    if (score === undefined)
+        return;
+    const list = by.get(score);
+    if (list === undefined)
+        by.set(score, [voice]);
+    else
+        list.push(voice);
+}
+/** A voice just pushed onto `gone`. */
+export function scoredLeft(mix, voice) {
+    if (voice.spec.score !== undefined)
+        hold(mix, voice.spec.score);
+    const ix = mix.scored;
+    if (ix.gone === mix.gone)
+        goneAdd(ix.goneBy, voice);
+}
+/**
+ * Gone voices history let go of, out of `was`; `mix.gone` is already what is left, whether that
+ * is `was` cut in place or a new list.
+ */
+export function scoredCut(mix, was, out) {
+    const ix = mix.scored;
+    if (ix.gone !== was)
+        return;
+    ix.gone = mix.gone;
+    const by = new Map();
+    for (const v of out) {
+        const score = v.spec.score;
+        if (score === undefined)
+            continue;
+        const set = by.get(score);
+        if (set === undefined)
+            by.set(score, new Set([v]));
+        else
+            set.add(v);
+    }
+    for (const [score, gone] of by) {
+        const left = (ix.goneBy.get(score) ?? []).filter((v) => !gone.has(v));
+        if (left.length === 0)
+            ix.goneBy.delete(score);
+        else
+            ix.goneBy.set(score, left);
+    }
+}
+/** A voice just cued. */
+export function scoredAdd(mix, voice) {
+    scoreTouched(mix, voice);
+    if (voice.spec.score !== undefined)
+        hold(mix, voice.spec.score);
+    const ix = mix.scored;
+    if (ix.cued === mix.cued)
+        put(ix.by, voice);
+}
+/** Voices no longer cued. */
+export function scoredRemove(mix, voices) {
+    for (const v of voices)
+        scoreTouched(mix, v);
+    const ix = mix.scored;
+    if (ix.cued !== mix.cued)
+        return;
+    for (const v of voices) {
+        const score = v.spec.score;
+        if (score === undefined)
+            continue;
+        const set = ix.by.get(score);
+        if (set === undefined)
+            continue;
+        set.delete(v);
+        if (set.size === 0)
+            ix.by.delete(score);
+    }
+}

package/dist/seek.d.ts

@@ -0,0 +1,3 @@
+import type { Transport } from './transport.js';
+/** Moves every mix on the transport to mix time `t`, as it stood at the end of that frame. */
+export declare function seek(transport: Transport, t: number): void;