@msb235/blits 0.6.0 → 0.7.0

package/dist/project.js

@@ -1,85 +1,60 @@
 import { ownBlends } from './blend.js';
 import { index } from './chain.js';
-import { copyHeld, last } from './history.js';
-import { readingAt } from './marks.js';
+import { copyHeld, last, leftAt } from './history.js';
+import { Mixer } from './mixer.js';
 import { move } from './move.js';
 import { heldByInput, ownerReading, relink } from './owner.js';
 import { pin } from './place.js';
 import { reading } from './reading.js';
 import { Store } from './store.js';
+import { hostAt } from './tape.js';
+import { Transport } from './transport.js';
+import { cover } from './unpage.js';
 import { unreached } from './unreached.js';
-/** A projection to `timestamp` through `c`, a mixer of its own the mix has just made. */
-export function project(mix, c, timestamp) {
-    const u = timestamp - mix.offset;
-    const pace = mix.pace;
-    const t = readingAt(mix, u);
-    c.projecting = true;
-    c.pose = mix.pose;
-    c.offset = mix.offset;
-    c.u = u;
-    c.wantsPose = mix.wantsPose;
-    c.nextId = mix.nextId;
-    c.reducedNow = mix.reducedNow;
-    if (Number.isNaN(mix.now) || t >= mix.now) {
-        c.now = mix.now;
-        c.pace = pace === null ? null : pace.until(Number.POSITIVE_INFINITY);
-        c.cued = mix.cued
-            .filter((v) => v.state !== 'done')
-            .map((v) => {
-            const copy = v.copy((subject) => carry(mix, v, subject));
-            const at = mix.pins?.get(v);
-            if (at !== undefined)
-                pin(c, copy, at);
-            return copy;
-        });
-        ownBlends(c.cued);
-        if (mix.owners !== null)
-            relink(c.cued);
-        c.announced = mix.announced.map((a) => ({ ...a }));
-        count(c);
-        move(c, t);
-    }
-    else {
-        const history = mix.opts.history;
+/**
+ * Every mix on a transport read at mix time `t`, through copies of them on a transport of their
+ * own, moved together so an anchor across mixes answers as it would live.
+ */
+export function projectAll(transport, t) {
+    const ahead = Number.isNaN(transport.now) || t >= transport.now;
+    const tape = transport.tape;
+    const next = ahead && tape !== undefined ? tape.timestampAt(tape.undoDepth()) : undefined;
+    if (next !== undefined && next <= t)
+        throw new Error(`blits: the tape holds calls at ${next} that a read ahead to ${t} cannot play; seek there to see them`);
+    if (!ahead) {
+        const history = transport.history;
         if (!history)
             throw new Error('blits: reading back needs a mix made with history');
-        if (t < mix.now - history.ms)
-            throw new Error(`blits: ${timestamp} is older than this mix's history reaches`);
-        c.now = t;
-        c.pace = pace === null ? null : pace.until(u);
-        c.backward = true;
-        const was = last(mix.hostLog, t, true);
-        const host = mix.opts.host;
-        const then = was && typeof host === 'object' && host !== null
-            ? Object.assign(Object.create(host), was.fields)
-            : undefined;
-        if (was)
-            c.hostThen = was;
-        c.announced = mix.announced.filter((a) => a.made < t).map((a) => ({ ...a }));
-        c.cued = [...mix.cued, ...mix.gone]
-            .filter((v) => v.cuedAt <= t && v.doneAt > t)
-            .sort((a, b) => a.id - b.id)
-            .map((v) => {
-            const log = v.log;
-            const copy = v.copy((subject) => recall(mix, v, subject, t), last(log, t, (e) => e.sync) ?? log[0]);
-            if (then !== undefined)
-                copy.setting.host = then;
-            return copy;
+        cover(transport, t);
+    }
+    const u = hostAt(transport, t);
+    const pace = transport.pace;
+    const c = new Transport(undefined, true);
+    c.offset = transport.offset;
+    c.u = u;
+    c.nextId = transport.nextId;
+    c.now = ahead ? transport.now : t;
+    c.pace = pace === null ? null : pace.until(ahead ? Number.POSITIVE_INFINITY : u);
+    c.announced = (ahead ? transport.announced : transport.announced.filter((a) => a.made < t)).map((a) => ({ ...a }));
+    const copies = new Map();
+    for (const mix of transport.members) {
+        const copy = new Mixer(mix.kit, {
+            ...mix.opts,
+            history: undefined,
+            lanes: false,
+            transport: c,
         });
-        ownBlends(c.cued);
-        if (mix.owners !== null)
-            relink(c.cued);
-        for (const copy of c.cued)
-            copy.state =
-                (copy.owner === null ? t : ownerReading(copy.owner, t)) < copy.start
-                    ? 'pending'
-                    : copy.out && copy.out.at <= t
-                        ? 'fading'
-                        : copy.freezesAfter && copy.elapsedAt(t) >= copy.span + copy.latest
-                            ? 'frozen'
-                            : 'live';
-        count(c);
+        copy.slot = mix.slot;
+        copy.projecting = true;
+        copies.set(mix, copy);
+        if (ahead)
+            copyAhead(mix, copy);
+        else
+            copyBack(mix, copy, t);
     }
+    if (ahead)
+        for (const copy of copies.values())
+            move(copy, t);
     const read = (f) => {
         reading.live = false;
         try {
@@ -90,14 +65,78 @@ export function project(mix, c, timestamp) {
         }
     };
     return {
-        timestamp,
-        probe: (subject, out) => read(() => c.fold(subject, out)),
-        assess: (subject) => read(() => {
-            c.fold(subject);
-            return doubts(c, subject);
-        }),
+        timestamp: t,
+        of(mix) {
+            const copy = copies.get(mix);
+            if (copy === undefined)
+                throw new Error('blits: that mix is not on this transport');
+            return {
+                timestamp: t,
+                probe: (subject, out) => read(() => copy.fold(subject, out)),
+                assess: (subject) => read(() => {
+                    copy.fold(subject);
+                    return doubts(copy, subject);
+                }),
+            };
+        },
     };
 }
+/** A mix's copy for a read ahead: its voices as they stand, each subject carried from the live one. */
+function copyAhead(mix, c) {
+    c.pose = mix.pose;
+    c.wantsPose = mix.wantsPose;
+    c.reducedNow = mix.reducedNow;
+    c.cued = mix.cued
+        .filter((v) => v.state !== 'done')
+        .map((v) => {
+        const copy = v.copy((subject) => carry(mix, v, subject));
+        const at = mix.pins?.get(v);
+        if (at !== undefined)
+            pin(c, copy, at);
+        return copy;
+    });
+    ownBlends(c.cued);
+    if (mix.owners !== null)
+        relink(c.cued);
+    count(c);
+}
+/** A mix's copy for a read back to `t`: its voices then, from the controls and copies kept. */
+function copyBack(mix, c, t) {
+    c.pose = mix.pose;
+    c.wantsPose = mix.wantsPose;
+    c.reducedNow = mix.reducedNow;
+    c.backward = true;
+    const was = last(mix.hostLog, t, true);
+    const host = mix.opts.host;
+    const then = was && typeof host === 'object' && host !== null
+        ? Object.assign(Object.create(host), was.fields)
+        : undefined;
+    if (was)
+        c.hostThen = was;
+    c.cued = [...mix.cued, ...mix.gone]
+        .filter((v) => v.cuedAt <= t && v.doneAt > t)
+        .sort((a, b) => a.id - b.id)
+        .map((v) => {
+        const log = v.log;
+        const copy = v.copy((subject) => recall(mix, v, subject, t), last(log, t, (e) => e.sync) ?? log[0]);
+        if (then !== undefined)
+            copy.setting.host = then;
+        return copy;
+    });
+    ownBlends(c.cued);
+    if (mix.owners !== null)
+        relink(c.cued);
+    for (const copy of c.cued)
+        copy.state =
+            (copy.owner === null ? t : ownerReading(copy.owner, t)) < copy.start
+                ? 'pending'
+                : copy.out && copy.out.at <= t
+                    ? 'fading'
+                    : copy.freezesAfter && copy.elapsedAt(t) >= copy.span + copy.latest
+                        ? 'frozen'
+                        : 'live';
+    count(c);
+}
 /** Recounts what the fold's shortcuts depend on, for a projection's freshly copied voices. */
 function count(mix) {
     mix.named = new Store();
@@ -132,7 +171,7 @@ function carry(mix, voice, subject) {
  * voice's start with fresh state, which is exact for a voice stepped at a fixed interval.
  */
 function recall(mix, voice, subject, t) {
-    const live = recordOf(mix, voice, subject);
+    const live = leftAt(voice.left, subject, t) ?? recordOf(mix, voice, subject);
     if (live === undefined)
         return undefined;
     const snap = live.snaps && last(live.snaps, t, true);
@@ -192,7 +231,7 @@ function doubts(mix, subject) {
         for (const slot of voice.slots)
             out[mix.names[slot]] = 'held';
     }
-    for (let held = mix.chain(subject, mix.now); held !== null; held = held.next) {
+    for (let held = mix.chain(subject); held !== null; held = held.next) {
         const voice = held.voice;
         if (voice === null || voice.state === 'done')
             continue;

package/dist/pull.js

@@ -1,3 +1,4 @@
+import { axesOf } from './channels.js';
 import { copy } from './clone.js';
 import { clampRun, flush, pullRun, writeLater } from './columns.js';
 /** Writes a folded pose's value into subject `n`'s places in a column. */
@@ -128,14 +129,14 @@ function readAll(mix, list, columns, live, current, whole) {
                 const kept = heads[n];
                 const head = was[n] === subject && kept !== undefined && kept.version === version
                     ? kept
-                    : mix.chain(subject, now);
+                    : mix.chain(subject);
                 was[n] = subject;
                 heads[n] = head;
                 slot = head.slot;
                 slots[n] = slot;
             }
         }
-        const laned = live && lanes?.prepare(slot, subject, now, mix.version, heads[n] ?? null) === true;
+        const laned = live && lanes?.prepare(slot, subject, mix.version, heads[n] ?? null) === true;
         if (laned && whole && lanes.whole && !lanes.owes(slot)) {
             writeLater(lanes, slot, columns, n);
             continue;
@@ -160,7 +161,7 @@ function columnsOf(mix, into) {
             throw new Error(`blits: pull was handed ${key}, which the kit lacks`);
         const channel = mix.channels[slot];
         const rest = channel.rest;
-        const axes = Array.isArray(rest) ? rest.length : 1;
+        const axes = axesOf(channel);
         const bounds = channel.bounds;
         const at = new Float64Array(axes).fill(Number.NaN);
         if (typeof rest === 'number')

package/dist/qualify.js

@@ -163,11 +163,13 @@ export function requalify(lanes, version) {
             return;
         const channel = host.channels[slot];
         const n = numericOf(channel);
-        const rest = channel.rest;
+        // A rest-less channel's values are NaN until some voice passes the band: absent from the pose.
+        const rest = (channel.rest ?? Number.NaN);
+        const scalar = typeof rest === 'number' && n.axes === 1;
         const ch = {
             name: host.names[slot],
             op: n.op,
-            scalar: typeof rest === 'number',
+            scalar,
             rest: typeof rest === 'number' ? rest : rest[0],
             axes: n.axes,
             values: new Float64Array(lanes.cap * n.axes),

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/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;