@msb235/blits 0.7.1 → 0.8.0

package/dist/paging.d.ts

@@ -51,13 +51,19 @@ export declare class Keys {
     subject(key: Key): unknown;
 }
 /**
- * Hands records leaving memory to the store, the last of any that share a time, which is the one
- * a read finds. `reach` is how far back memory still reaches.
+ * Hands records leaving memory to the store, the last of any made in one frame, which is the one a
+ * read finds. `reach` is how far back memory still reaches.
  */
 export declare function pageOut<I, O, E extends {
     at: number;
+    seq: number;
 }>(mix: Mixer<I, O>, stream: PagedStream, voice: number | undefined, subject: Key, out: readonly E[], data: (e: E) => unknown, reach: number): void;
 /** Gives records to the store; memory now reaches back no further than `reach`. */
 export declare function page(transport: Transport, records: Paged[], reach: number): void;
+/**
+ * With a store, hands it what the transport itself keeps from before memory's reach: announced
+ * marks, changes of its rate, and frames, the last at or before the reach staying.
+ */
+export declare function pageTransport(transport: Transport): void;
 /** Loads what a seek or read to `t` needs where it reaches past memory. */
 export declare function prepare(transport: Transport, t: number): Promise<void>;

package/dist/paging.js

@@ -68,8 +68,8 @@ export class Keys {
     }
 }
 /**
- * Hands records leaving memory to the store, the last of any that share a time, which is the one
- * a read finds. `reach` is how far back memory still reaches.
+ * Hands records leaving memory to the store, the last of any made in one frame, which is the one a
+ * read finds. `reach` is how far back memory still reaches.
  */
 export function pageOut(mix, stream, voice, subject, out, data, reach) {
     const pager = mix.transport.pager;
@@ -79,9 +79,9 @@ export function pageOut(mix, stream, voice, subject, out, data, reach) {
     const records = [];
     for (let i = 0; i < out.length; i++) {
         const e = out[i];
-        if (i + 1 < out.length && out[i + 1].at === e.at)
+        if (i + 1 < out.length && out[i + 1].seq === e.seq)
             continue;
-        const r = { mix: name, stream, at: e.at, data: data(e) };
+        const r = { mix: name, stream, at: e.at, seq: e.seq, data: data(e) };
         if (voice !== undefined)
             r.voice = voice;
         if (subject !== undefined)
@@ -100,6 +100,46 @@ export function page(transport, records, reach) {
     if (reach > transport.floor)
         transport.floor = reach;
 }
+/**
+ * With a store, hands it what the transport itself keeps from before memory's reach: announced
+ * marks, changes of its rate, and frames, the last at or before the reach staying.
+ */
+export function pageTransport(transport) {
+    const history = transport.history;
+    if (history === undefined || transport.pager === null)
+        return;
+    const reach = transport.now - history.ms;
+    const records = [];
+    const frames = transport.frames;
+    let n = 0;
+    while (n + 1 < frames.length && frames[n + 1].at <= reach)
+        n++;
+    for (const f of frames.splice(0, n))
+        records.push({ mix: '', stream: 'frame', at: f.at, seq: f.seq, data: f.u });
+    const pace = transport.pace;
+    const timeOf = (u) => (pace === null ? u : pace.reading(u));
+    if (transport.announced.some((a) => timeOf(a.at) < reach)) {
+        const kept = [];
+        for (const a of transport.announced)
+            if (timeOf(a.at) < reach)
+                records.push({
+                    mix: '',
+                    stream: 'mark',
+                    subject: a.order,
+                    at: timeOf(a.at),
+                    seq: a.seq,
+                    data: a,
+                });
+            else
+                kept.push(a);
+        transport.announced = kept;
+    }
+    if (pace !== null)
+        for (const c of pace.shed(reach))
+            records.push({ mix: '', stream: 'pace', at: c.anchorElapsed, seq: c.seq, data: c });
+    if (records.length > 0)
+        page(transport, records, reach);
+}
 /** Loads what a seek or read to `t` needs where it reaches past memory. */
 export async function prepare(transport, t) {
     const pager = transport.pager;

package/dist/patch.d.ts

@@ -35,7 +35,7 @@ export interface KeysOptions<O> {
     ease?: Easing;
     /** A curve for one channel, where it differs from the rest. */
     easeBy?: (channel: keyof O) => Easing | undefined;
-    /** Milliseconds one channel waits before it starts moving, within the duration. */
+    /** Milliseconds one channel waits before it starts moving; it then travels in the time left. */
     delayBy?: (channel: keyof O) => number;
     /**
      * How one channel interpolates, where it should differ from the channel's own `lerp`. A mix hands
@@ -45,8 +45,6 @@ export interface KeysOptions<O> {
     /** The channels these stops were written against, which `cue` checks a mix's kit against. */
     kit?: Partial<Kit<O>>;
 }
-/** The options a `keys` patch was built with, for an engine reading its stops rather than calling it. */
-export declare function keysOptionsOf<I, O, S>(p: Patch<I, O, S>): KeysOptions<O> | undefined;
 interface Point {
     at: number;
     value: unknown;
@@ -66,6 +64,12 @@ export interface Track {
     tailAts: number[] | null;
     delay: number;
     lerp: ((a: never, b: never, u: number) => unknown) | undefined;
+    /** Where every stop is a plain number lerped straight across: the stops flat, for `readNumber`. */
+    numbers: {
+        ats: Float64Array;
+        values: Float64Array;
+        eases: (Curve | undefined)[];
+    } | null;
 }
 export interface Built {
     tracks: Track[];
@@ -96,14 +100,14 @@ export declare function shift(delay: number, phase: number, duration: number): n
 /**
  * Where `phase` falls among `n` stop phases `ats[off + k * stride]`, in order: -2 for no stops, -1
  * at or before the first, `n` at or past the last, and otherwise the first stop past it, where the
- * segment from the one before ends. With `segment`'s, the one copy of the search.
+ * segment from the one before ends. `segment` and `readNumber` make the same search.
  */
 export declare function locate(ats: ArrayLike<number>, off: number, stride: number, n: number, phase: number): number;
 /** How far along a segment from phase `a` to `b` a phase is, before easing. */
 export declare function fraction(phase: number, a: number, b: number): number;
 /**
- * Finds where one track is at a phase, into `seg`: the one copy of the search, which `read` and a
- * lane folding stops straight into a subject's values both make. `base` stands in for the value at
+ * Finds where one track is at a phase, into `seg`: the search `read` and a lane folding stops
+ * straight into a subject's values both make. `base` stands in for the value at
  * phase 0, which is how `from: 'current'` starts a voice wherever the subject already is.
  */
 export declare function segment(track: Track, phase: number, base: unknown): number;
@@ -125,9 +129,10 @@ export declare function intosOf(built: Built, channels: readonly Channel<unknown
 export declare function readKeys(built: Built, phase: number, out: Record<string, unknown>, base?: Record<string, unknown>, lerps?: readonly (Lerp | undefined)[], 
 /** Per channel, how fast a retargeted subject was moving, units per ms. */
 slopes?: Record<string, unknown>, intos?: readonly (LerpInto | undefined)[], scratch?: Scratch): Record<string, unknown>;
-/** A patch's `duration`, or the deprecated `period` where only that is set. */
-export declare const durationOf: <I, O, S>(p: Patch<I, O, S>) => number;
-/** The built form of a patch's stops, made on first ask for a patch `keys()` did not build. */
+/**
+ * The built form of a patch's stops, made on first ask for a patch `keys()` did not build: a copy
+ * of one, or one another copy of blits made, each read by the fields it carries.
+ */
 export declare function builtOf<I, O, S>(p: Patch<I, O, S>): Built;
 /** Evaluates a stop list into a fresh delta. */
 export declare function evalKeys<O>(stops: readonly Keyframe<O>[], writes: readonly (keyof O)[], phase: number, duration: number, opts: KeysOptions<O>, base?: Partial<O>): Partial<O>;

package/dist/patch.js

@@ -1,5 +1,5 @@
-import { lerpInto } from './channels.js';
-import { curve } from './easing.js';
+import { lerpInto, lerpNumber } from './channels.js';
+import { curve, startSlope } from './easing.js';
 /**
  * The procedural form. Flicker, roving, a hash walk, a starter strike.
  *
@@ -12,7 +12,6 @@ export function patch(duration, at, opts) {
     return {
         form: 'fn',
         duration,
-        period: duration,
         writes,
         kit: opts.kit,
         reads: opts.reads,
@@ -23,11 +22,6 @@ export function patch(duration, at, opts) {
         unpack: opts.unpack,
     };
 }
-const options = new WeakMap();
-/** The options a `keys` patch was built with, for an engine reading its stops rather than calling it. */
-export function keysOptionsOf(p) {
-    return options.get(p);
-}
 const linear = (a, b, u) => a + (b - a) * u;
 function interpolate(a, b, u) {
     if (typeof a === 'number' && typeof b === 'number')
@@ -64,6 +58,10 @@ function build(stops, writes, duration, opts) {
         }
         all.sort((x, y) => x.at - y.at);
         const tail = all.filter((pt) => pt.at !== 0);
+        const lerp = opts.lerpBy?.(channel) ?? opts.kit?.[channel]?.lerp;
+        const plain = all.length > 0 &&
+            (lerp === undefined || lerp === lerpNumber) &&
+            all.every((pt) => typeof pt.value === 'number');
         tracks.push({
             channel: channel,
             all,
@@ -71,7 +69,14 @@ function build(stops, writes, duration, opts) {
             ats: all.map((pt) => pt.at),
             tailAts: null,
             delay: opts.delayBy?.(channel) ?? 0,
-            lerp: opts.lerpBy?.(channel) ?? opts.kit?.[channel]?.lerp,
+            lerp,
+            numbers: plain
+                ? {
+                    ats: Float64Array.from(all, (pt) => pt.at),
+                    values: Float64Array.from(all, (pt) => pt.value),
+                    eases: all.map((pt) => pt.ease),
+                }
+                : null,
         });
     }
     return { tracks, duration };
@@ -100,12 +105,17 @@ export function shifted(track, phase, duration) {
 }
 /** A phase once a channel's delay of `delay` ms in a duration of `duration` applies. */
 export function shift(delay, phase, duration) {
-    return delay === 0 || duration === 0 ? phase : Math.max(0, (phase * duration - delay) / duration);
+    if (delay === 0 || duration === 0)
+        return phase;
+    // The channel travels in what is left after its wait, so it lands with the rest at phase 1.
+    if (delay >= duration)
+        return phase >= 1 ? 1 : 0;
+    return Math.max(0, (phase * duration - delay) / (duration - delay));
 }
 /**
  * Where `phase` falls among `n` stop phases `ats[off + k * stride]`, in order: -2 for no stops, -1
  * at or before the first, `n` at or past the last, and otherwise the first stop past it, where the
- * segment from the one before ends. With `segment`'s, the one copy of the search.
+ * segment from the one before ends. `segment` and `readNumber` make the same search.
  */
 export function locate(ats, off, stride, n, phase) {
     if (n === 0)
@@ -132,8 +142,8 @@ export function fraction(phase, a, b) {
     return (phase - a) / (b - a);
 }
 /**
- * Finds where one track is at a phase, into `seg`: the one copy of the search, which `read` and a
- * lane folding stops straight into a subject's values both make. `base` stands in for the value at
+ * Finds where one track is at a phase, into `seg`: the search `read` and a lane folding stops
+ * straight into a subject's values both make. `base` stands in for the value at
  * phase 0, which is how `from: 'current'` starts a voice wherever the subject already is.
  */
 export function segment(track, phase, base) {
@@ -179,10 +189,44 @@ export function segment(track, phase, base) {
     seg.ease = b.ease;
     return BETWEEN;
 }
+/**
+ * A plain-number track at a phase, in exactly `segment`'s and `read`'s arithmetic: the stop at or
+ * past the phase by binary search, the fraction before easing, then a straight lerp.
+ */
+function readNumber(t, phase) {
+    const ats = t.ats;
+    const values = t.values;
+    const n = ats.length;
+    if (phase <= ats[0])
+        return values[0];
+    if (phase >= ats[n - 1])
+        return values[n - 1];
+    let lo = 1;
+    let hi = n - 1;
+    while (lo < hi) {
+        const mid = (lo + hi) >> 1;
+        if (ats[mid] >= phase)
+            hi = mid;
+        else
+            lo = mid + 1;
+    }
+    const a = ats[lo - 1];
+    const u = (phase - a) / (ats[lo] - a);
+    const ease = t.eases[lo];
+    const eased = ease ? ease(u) : u;
+    const from = values[lo - 1];
+    return from + (values[lo] - from) * eased;
+}
 /** Reads one track at a phase; `base` as `segment` takes it. */
 function read(track, phase, base, lerp, 
 /** Units per ms, for a retarget's first segment. */
 slope, duration, into, reuse) {
+    const numbers = track.numbers;
+    if (numbers !== null &&
+        base === undefined &&
+        slope === undefined &&
+        (lerp === undefined || lerp === lerpNumber || track.lerp !== undefined))
+        return readNumber(numbers, phase);
     const found = segment(track, phase, base);
     if (found === NOTHING)
         return undefined;
@@ -208,7 +252,9 @@ slope, duration, into, reuse) {
     // add c·u(1−u)², which is 0 at both ends, flat at the end, and fixes the slope at the start.
     if (slope === undefined || !first)
         return value;
-    const e0 = ease ? ease(1e-6) / 1e-6 : 1;
+    const e0 = ease ? startSlope(ease) : 1;
+    if (e0 === Number.POSITIVE_INFINITY)
+        return value;
     const bend = (s, a, z) => (s * duration * len - (z - a) * e0) * u * (1 - u) * (1 - u);
     if (typeof value === 'number' && typeof slope === 'number')
         return value + bend(slope, aValue, bValue);
@@ -262,14 +308,15 @@ slopes, intos, scratch) {
     }
     return out;
 }
-/** A patch's `duration`, or the deprecated `period` where only that is set. */
-export const durationOf = (p) => p.duration ?? p.period ?? 0;
 const cache = new WeakMap();
-/** The built form of a patch's stops, made on first ask for a patch `keys()` did not build. */
+/**
+ * The built form of a patch's stops, made on first ask for a patch `keys()` did not build: a copy
+ * of one, or one another copy of blits made, each read by the fields it carries.
+ */
 export function builtOf(p) {
     let held = cache.get(p);
     if (held === undefined) {
-        held = build(p.keys, p.writes, durationOf(p), keysOptionsOf(p) ?? {});
+        held = build(p.keys, p.writes, p.duration, p);
         cache.set(p, held);
     }
     return held;
@@ -289,13 +336,28 @@ export function keys(duration, stops, opts = {}) {
     const p = {
         form: 'keys',
         duration,
-        period: duration,
         writes,
         kit: opts.kit,
         keys: stops,
-        at: (phase) => readKeys(made, phase, {}),
+        ...given(opts),
+        // A copy of the patch carries this `at` with fields of its own, which it is read by.
+        at(phase) {
+            return readKeys(this === p ? made : builtOf(this), phase, {});
+        },
     };
-    options.set(p, opts);
     cache.set(p, made);
     return p;
 }
+/** The `keys` options a patch carries as fields, those given only: an absent one adds no key. */
+function given(opts) {
+    const out = {};
+    if (opts.ease !== undefined)
+        out.ease = opts.ease;
+    if (opts.easeBy !== undefined)
+        out.easeBy = opts.easeBy;
+    if (opts.delayBy !== undefined)
+        out.delayBy = opts.delayBy;
+    if (opts.lerpBy !== undefined)
+        out.lerpBy = opts.lerpBy;
+    return out;
+}

package/dist/place.js

@@ -1,3 +1,5 @@
+import { departedMatches } from './departed.js';
+import { reorigin } from './held.js';
 import { noted } from './history.js';
 import { markOf } from './marks.js';
 import { mixTime, ownerReading } from './owner.js';
@@ -37,6 +39,10 @@ function startAt(mix, voice, start) {
     voice.start = start;
     voice.anchorNow = start;
     voice.anchorElapsed = 0;
+    voice.clocks = null;
+    // A clock moved outright, as a seek moves it: what a record computed at this mix time is stale.
+    voice.seeks++;
+    reorigin(mix, voice, mix.now);
     noted(mix, voice);
     return true;
 }
@@ -266,7 +272,7 @@ class Pick {
 /**
  * The mix time a query answers: `mark` of the voice it picks, among those cued and those that have
  * left, never the asker; or a mark the host announced on the score, which is the same time for
- * any of the four. Undefined while what it picks has no such time. A query naming no score looks
+ * any mark. Undefined while what it picks has no such time. A query naming no score looks
  * among the asker's siblings, the voices its owner holds.
  */
 function timeOf(mix, key, mark, self) {
@@ -290,8 +296,17 @@ function timeOf(mix, key, mark, self) {
         : listed
             ? holders(mix, score)
             : mix.transport.members;
+    // Voices forgotten on leaving answer only where no voice the mix still knows does.
+    const owner = self.owner?.id ?? -1;
+    const forgotten = new Pick(resolver, now);
     for (let i = 0; i < mixes.length; i++) {
         const m = mixes[i];
+        let departed = false;
+        for (const d of m.departed.all)
+            if (departedMatches(d, q, score, anywhere, owner)) {
+                forgotten.take(d.id, d.marks[mark]);
+                departed = true;
+            }
         if (score === undefined || m.projecting || mix.projecting) {
             for (const v of [...m.gone, ...m.cued])
                 if (matches(v))
@@ -300,7 +315,7 @@ function timeOf(mix, key, mark, self) {
         }
         const cued = scored(m, score);
         const list = scoredGone(m, score);
-        if (cued.size === 0 && list.length === 0) {
+        if (cued.size === 0 && list.length === 0 && !departed) {
             if (listed) {
                 unhold(m, score);
                 i--;
@@ -359,7 +374,7 @@ function timeOf(mix, key, mark, self) {
                 (q.name === undefined || a.name === q.name) &&
                 (q.tag === undefined || a.tags.includes(q.tag)))
                 picked.take(a.order, Number.isNaN(a.at) ? undefined : mixAt(mix, a.at));
-    return picked.answer();
+    return (picked.any ? picked : forgotten).answer();
 }
 /** `self`'s read of `m`'s gone voices for one query, started over where the list has changed under it. */
 function foldOf(m, list, key, mark, self, resolver) {

package/dist/project.d.ts

@@ -1,7 +1,18 @@
-import { Transport } from './transport.js';
+import { Mixer } from './mixer.js';
+import { type Cut, Transport } from './transport.js';
 import type { TransportProjection } from './types.js';
+import type { Subject, Voice } from './voice.js';
 /**
  * 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 declare function projectAll(transport: Transport, t: number): TransportProjection;
+/** Sets each copied voice's state to what its clock and fade make it at `t`. */
+export declare function stateAt<I, O>(c: Mixer<I, O>, t: number): void;
+/** Gives a projection's copy what it reads of the live mix as it is, before its voices are copied. */
+export declare function mirror<I, O>(mix: Mixer<I, O>, c: Mixer<I, O>): void;
+/**
+ * A projection back starts each subject from the latest copy kept at or before `t`, else from its
+ * voice's start with fresh state, which is exact for a voice stepped at a fixed interval.
+ */
+export declare function recall<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject: I, t: number, cut: Cut): Subject<unknown> | undefined;