@msb235/blits 0.7.1 → 0.8.0

package/dist/seek.js

@@ -1,10 +1,14 @@
-import { index } from './chain.js';
 import { schedule } from './due.js';
-import { copyHeld, last, leftAt } from './history.js';
+import { copyHeld, last, lastWithin } from './history.js';
 import { laneHost } from './hosts.js';
 import { Lanes } from './lanes.js';
-import { move } from './move.js';
+import { Leavings } from './leavings.js';
+import { move, nextFrame } from './move.js';
 import { ownerReading } from './owner.js';
+import { place } from './place.js';
+import { unpull } from './pull.js';
+import { Restored } from './restored.js';
+import { recount } from './roster.js';
 import { refitAll } from './spans.js';
 import { Store } from './store.js';
 import { hostAt, replay } from './tape.js';
@@ -35,44 +39,6 @@ function restore(voice, live, t) {
     h.inputs = inputs;
     return h;
 }
-/**
- * A voice's records after a seek back: each subject's is put back from the records it had, the first
- * time it is asked for, since the subjects a store holds cannot be listed.
- */
-class Restored extends Store {
-    was;
-    make;
-    left;
-    constructor(was, make, left) {
-        super();
-        this.was = was;
-        this.make = make;
-        this.left = left;
-    }
-    /** Subjects whose record has been put back or deleted, which `left` no longer answers for. */
-    settled = new Store();
-    get(key) {
-        const v = super.get(key);
-        if (v !== undefined)
-            return v;
-        // A subject that left after the moment sought had the record it left with, whatever it has now.
-        const kept = this.settled.get(key) === undefined ? this.left(key) : undefined;
-        this.settled.set(key, true);
-        const live = kept ?? this.was.get(key);
-        if (live === undefined)
-            return undefined;
-        this.was.delete(key);
-        const made = this.make(live);
-        if (made !== undefined)
-            super.set(key, made);
-        return made;
-    }
-    delete(key) {
-        super.delete(key);
-        this.was.delete(key);
-        this.settled.set(key, true);
-    }
-}
 /** Takes a voice cued after the moment sought out of the mix, until the tape cues it again. */
 function park(mix, voice) {
     const owner = voice.owner;
@@ -86,34 +52,27 @@ function park(mix, voice) {
         motion.owner = null;
     voice.park();
 }
-/** Puts a voice's controls and records back as they stood at mix time `t`. */
-function restoreVoice(voice, t) {
+/** Puts a voice's controls and records back as they stood at mix time `t`, the end of frame `seq`. */
+function restoreVoice(mix, voice, t, seq) {
+    const cut = { seq, strict: false };
     const log = voice.log;
-    const c = last(log, t, true) ?? log[0];
+    const c = lastWithin(log, cut) ?? log[0];
     log.length = log.indexOf(c) + 1;
-    voice.anchorNow = c.anchorNow;
-    voice.anchorElapsed = c.anchorElapsed;
-    voice.rate = c.rate;
-    voice.ramp = c.ramp;
-    voice.weight = c.weight;
-    voice.out = c.out;
-    voice.start = c.start;
-    voice.outAt = c.outAt;
-    voice.outOver = c.outOver;
-    voice.outSet = c.outSet;
-    if (voice.reopen(t) && voice.owner?.holding)
+    voice.take(c);
+    if (voice.reopen(seq) && voice.owner?.holding)
         voice.owner.holding.played--;
     voice.doneAt = Number.POSITIVE_INFINITY;
+    voice.doneSeq = Number.POSITIVE_INFINITY;
     if (voice.parts !== null) {
         for (const [subject, r] of voice.parts)
-            if (r.at > t)
+            if (r.seq > seq)
                 voice.parts.delete(subject);
         if (voice.parts.size === 0)
             voice.parts = null;
     }
     if (voice.parted !== null) {
-        for (const [subject, at] of voice.parted)
-            if (at > t)
+        for (const [subject, p] of voice.parted)
+            if (p.seq > seq)
                 voice.parted.delete(subject);
         if (voice.parted.size === 0)
             voice.parted = null;
@@ -127,30 +86,43 @@ function restoreVoice(voice, t) {
     voice.unreached = null;
     voice.unreachedBits = null;
     voice.seeks++;
-    const left = voice.left;
-    voice.left = left === null ? null : left.filter((e) => e.at <= t);
-    const future = left === null ? [] : left.filter((e) => e.at > t);
-    voice.subjects = new Restored(voice.subjects, (live) => {
-        const h = restore(voice, live, t);
-        if (h === undefined)
+    const left = voice.left?.all() ?? [];
+    voice.left = Leavings.from(left.filter((e) => e.seq <= seq));
+    const future = Leavings.from(left.filter((e) => e.seq > seq));
+    let records = voice.subjects;
+    if (!(records instanceof Restored)) {
+        records = new Restored(records, (live, least, top) => {
+            const h = restore(voice, live, least);
+            if (h === undefined)
+                return h;
+            if (h.reaches)
+                voice.seen++;
+            if (h.rested)
+                voice.restedCount++;
+            if (!(h.since <= least)) {
+                // Kept while its origin was still ahead: where the controls put back place it now.
+                h.since = mix.sinceOf(voice, h.delay);
+                h.shown = mix.shownOf(voice, h.since);
+                if (h.ticks === 0 && h.stepped > h.since)
+                    h.stepped = h.since;
+            }
+            if (!(h.since <= top)) {
+                voice.early ??= [];
+                voice.early.push(h);
+            }
             return h;
-        if (h.reaches)
-            voice.seen++;
-        if (h.rested)
-            voice.restedCount++;
-        if (voice.state === 'pending') {
-            voice.early ??= [];
-            voice.early.push(h);
-        }
-        return h;
-    }, (key) => leftAt(future, key, t));
+        });
+        voice.subjects = records;
+    }
+    records.back(t, cut, future);
 }
 /** Each voice's state at mix time `t`, once every clock above it is back where it was. */
 function stateAt(voice, t) {
+    // A fade begins at once, even one whose ramp starts later, at the voice's start.
+    if (voice.out !== null)
+        return 'fading';
     if ((voice.owner === null ? t : ownerReading(voice.owner, t)) < voice.start)
         return 'pending';
-    if (voice.out !== null && voice.out.at <= t)
-        return 'fading';
     if (voice.freezesAfter && voice.elapsedAt(t) >= voice.span + voice.latest)
         return 'frozen';
     return 'live';
@@ -172,34 +144,43 @@ export function seek(transport, t) {
     if (!(t >= transport.born))
         throw new Error(`blits: ${t} is older than this mix's history reaches`);
     const unpaged = cover(transport, t);
-    if (t >= transport.now)
-        replay(transport, () => t);
-    // Under the rate the recorded calls up to `t` set, ahead; behind, under the rate it had then.
-    const u = hostAt(transport, t);
-    if (!Number.isFinite(u))
-        throw new RangeError(`blits: the mix's rate never reaches ${t}`);
     if (t >= transport.now) {
+        // Ahead, under the rate the recorded calls up to `t` set, past any frames rate 0 held at `t`.
+        const last = replay(transport, (at) => (transport.pace === null ? at : transport.pace.reading(at)) <= t);
+        const u = Number.isNaN(last) ? hostAt(transport, t) : Math.max(last, hostAt(transport, t));
+        if (!Number.isFinite(u))
+            throw new RangeError(`blits: the mix's rate never reaches ${t}`);
         transport.u = u;
         for (const m of transport.members)
             move(m, t);
     }
     else {
-        const n = tape.depthAt(t);
-        if (n < tape.undoDepth())
-            tape.goto(n);
-        transport.undrop(t);
-        // What history kept after `t` is let go; the tape holds the calls that made it.
-        transport.announced = transport.announced.filter((a) => a.made <= t);
-        transport.pace?.cut(u);
+        const frame = transport.frameAt(t);
+        if (frame === undefined)
+            throw new Error(`blits: ${t} is older than this mix's history reaches`);
+        // On the frame itself, its own host time: rate 0 may have held the clock there for several.
+        const u = frame.at === t ? frame.u : hostAt(transport, t);
+        const seq = frame.seq;
+        tape.goto(tape.depthAt(u));
+        transport.undrop(seq);
+        // What history kept after the frame is let go; the tape holds the calls that made it.
+        transport.announced = transport.announced.filter((a) => a.seq <= seq);
+        transport.frames = transport.frames.filter((f) => f.seq <= seq);
+        if (transport.pacedSeq > seq) {
+            transport.pace = null;
+            transport.pacedSeq = Number.POSITIVE_INFINITY;
+        }
+        else
+            transport.pace?.cut(u);
         transport.u = u;
         transport.now = t;
         for (const m of transport.members)
-            back(m, t);
-        cut(transport, t, unpaged);
+            back(m, t, seq, frame.at < t);
+        cut(transport, seq, unpaged);
     }
+    transport.tick(t);
     // The host's clock reads on from here: its next sync reads `t` plus its time since its last.
-    transport.offset = transport.last - u;
-    transport.u = u;
+    transport.offset = transport.last - transport.u;
     transport.kept();
     for (const m of transport.members) {
         m.stir();
@@ -209,8 +190,11 @@ export function seek(transport, t) {
                 b.sought();
     }
 }
-/** Puts one mix back as it stood at the end of frame `t`, its transport already there. */
-function back(mix, t) {
+/**
+ * Puts one mix back as it stood at mix time `t`, the end of frame `seq`, its transport already
+ * there; `on` past that frame's own time, where it moves on to `t`.
+ */
+function back(mix, t, seq, on) {
     const all = [...mix.cued, ...mix.gone].sort((a, b) => a.id - b.id);
     const kept = [];
     const gone = [];
@@ -220,14 +204,14 @@ function back(mix, t) {
         if (voice.motion !== undefined)
             motions.add(voice.motion);
     for (const voice of all)
-        if (voice.cuedAt > t)
+        if (voice.cuedSeq > seq)
             park(mix, voice);
-        else if (voice.doneAt <= t)
+        else if (voice.doneSeq <= seq)
             gone.push(voice);
         else
             kept.push(voice);
     for (const voice of kept)
-        restoreVoice(voice, t);
+        restoreVoice(mix, voice, t, seq);
     for (const voice of kept)
         voice.state = stateAt(voice, t);
     mix.cued = kept;
@@ -242,28 +226,17 @@ function back(mix, t) {
     if (oldLanes !== null)
         mix.lanes = new Lanes(laneHost(mix));
     mix.chains = new Store();
-    mix.named = new Store();
-    mix.naming = 0;
-    mix.general = [];
-    for (const voice of kept)
-        index(mix, voice);
     mix.owners = kept.some((v) => v.holding !== null) ? kept.filter((v) => v.holding !== null) : null;
-    mix.loci = kept.filter((v) => v.spec.locus !== undefined).length;
-    mix.anchored = kept.filter((v) => v.spec.anchor !== undefined).length;
+    recount(mix);
     mix.parters.clear();
     for (const voice of [...kept, ...gone])
         if (voice.parts !== null || voice.parted !== null)
             mix.parters.add(voice);
-    mix.steps.push(null, ++mix.version);
     mix.relinks++;
     mix.pose = new Store();
     if (mix.restStamps !== null)
         mix.restStamps = new Store();
-    mix.pulled = [];
-    mix.pulledHeads = [];
-    mix.pulledSlots = new Int32Array(0);
-    mix.pulledVersion = Number.NaN;
-    mix.pulledRelinks = -1;
+    unpull(mix);
     for (const voice of [...kept, ...gone]) {
         voice.unreached = null;
         voice.unreachedBits = null;
@@ -290,10 +263,10 @@ function back(mix, t) {
     for (const motion of motions) {
         if (oldLanes !== null && motion.watcher === oldLanes)
             motion.watcher = null;
-        motion.rewind(t);
+        motion.rewind(seq);
     }
     // What history kept after `t` is let go; the tape holds the calls that made it.
-    mix.hostLog = mix.hostLog.filter((e) => e.at <= t);
+    mix.hostLog = mix.hostLog.filter((e) => e.seq <= seq);
     mix.sent = mix.sent.filter((e) => e.timestamp <= t);
     mix.sentTo = t;
     mix.pins = null;
@@ -307,5 +280,15 @@ function back(mix, t) {
     for (const voice of kept)
         schedule(mix, voice);
     mix.stir();
-    move(mix, t);
+    // On the frame's own time its move is behind it: a second would land what the next frame does.
+    if (on)
+        move(mix, t);
+    else {
+        mix.frame = nextFrame();
+        mix.reducedNow = mix.reduced;
+        // A voice history let go of may have placed an anchor then: placed again from what it holds.
+        const ms = mix.opts.history.ms;
+        if (mix.anchored > 0 && mix.transport.forgotTo >= t - ms)
+            place(mix);
+    }
 }

package/dist/shared.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A WeakMap every copy of blits loaded in one realm shares, so a fact one copy records about a
+ * patch or channel it made is read by another copy's mix. The name carries a version, bumped when
+ * what is stored changes shape, so copies that disagree on the shape keep apart.
+ */
+export declare function shared<K extends object, V>(name: string): WeakMap<K, V>;

package/dist/shared.js

@@ -0,0 +1,15 @@
+/**
+ * A WeakMap every copy of blits loaded in one realm shares, so a fact one copy records about a
+ * patch or channel it made is read by another copy's mix. The name carries a version, bumped when
+ * what is stored changes shape, so copies that disagree on the shape keep apart.
+ */
+export function shared(name) {
+    const key = Symbol.for(`@msb235/blits/${name}`);
+    const g = globalThis;
+    let map = g[key];
+    if (map === undefined) {
+        map = new WeakMap();
+        g[key] = map;
+    }
+    return map;
+}

package/dist/signals.d.ts

@@ -1,4 +1,6 @@
-import type { Signal } from './types.js';
+import type { Setting, Signal } from './types.js';
+/** Whether a change to an input signal reaches `reading.inputs`, so a lane fill can see it. */
+export declare const heard: (signal: object) => boolean;
 /**
  * The loudest of several signals.
  *
@@ -6,7 +8,26 @@ import type { Signal } from './types.js';
  */
 export declare function peak<I, H = unknown>(...signals: readonly Signal<I, H>[]): Signal<I, H>;
 /**
- * A signal the host writes. klieg's `level`.
+ * Marks `read` as a signal driven from outside the clock, which a host's own signal has to be for
+ * `assess` and a history's `inputs` to treat it as one. Two uses:
+ *
+ * `input(read)` is an input of the host's own: a pointer, a volume, a value in a store. The host
+ * calls `touch()` after each change to what `read` reads, and a voice weighted by the signal, or by
+ * `peak`, `slew`, `lag` or `gate` over it, keeps its lane. A change nobody reports shows once the
+ * mix's clock next moves.
+ *
+ * `input(read, of)` is a signal built on others, as a wrapper that clamps one is: `of` lists every
+ * signal `read` calls, and the result is an input where any of them is, and reports its changes
+ * where they all do.
+ *
+ * @category signal
+ */
+export declare function input<I, H = unknown>(read: (subject: I, setting: Setting<void, H>) => number, of?: readonly Signal<I, H>[]): Signal<I, H> & {
+    touch(): void;
+};
+/**
+ * A signal the host writes: `input` over one number, with `set` reporting each change. klieg's
+ * `level`.
  *
  * @category signal
  */
@@ -14,7 +35,7 @@ export declare function level<I, H = unknown>(initial?: number): Signal<I, H> &
     set(v: number): void;
 };
 /**
- * The package's one decay primitive: follows its input at a rate limit, no faster than `riseMs` per
+ * The package's linear decay primitive: follows its input at a rate limit, no faster than `riseMs` per
  * unit climbing or `fallMs` draining. The mix keeps its state per voice and subject, so two voices
  * handed the same slew each follow on their own. A subject starts on its input, or at `from`
  * unless `dt` is infinite.

package/dist/signals.js

@@ -1,5 +1,16 @@
+import { reading } from './reading.js';
+/** Input signals whose every change bumps `reading.inputs`: `input`'s, and those built only on them. */
+const told = new WeakSet();
+/** Whether a change to an input signal reaches `reading.inputs`, so a lane fill can see it. */
+export const heard = (signal) => told.has(signal);
 const inputOf = (signals) => signals.some((s) => s.input);
-const marked = (read, input) => (input ? Object.assign(read, { input: true }) : read);
+const marked = (read, of) => {
+    if (!inputOf(of))
+        return read;
+    if (of.every((s) => !s.input || told.has(s)))
+        told.add(read);
+    return Object.assign(read, { input: true });
+};
 /**
  * The loudest of several signals.
  *
@@ -14,19 +25,46 @@ export function peak(...signals) {
                 out = v;
         }
         return out;
-    }, inputOf(signals));
+    }, signals);
 }
+const touch = () => {
+    reading.inputs++;
+};
 /**
- * A signal the host writes. klieg's `level`.
+ * Marks `read` as a signal driven from outside the clock, which a host's own signal has to be for
+ * `assess` and a history's `inputs` to treat it as one. Two uses:
+ *
+ * `input(read)` is an input of the host's own: a pointer, a volume, a value in a store. The host
+ * calls `touch()` after each change to what `read` reads, and a voice weighted by the signal, or by
+ * `peak`, `slew`, `lag` or `gate` over it, keeps its lane. A change nobody reports shows once the
+ * mix's clock next moves.
+ *
+ * `input(read, of)` is a signal built on others, as a wrapper that clamps one is: `of` lists every
+ * signal `read` calls, and the result is an input where any of them is, and reports its changes
+ * where they all do.
+ *
+ * @category signal
+ */
+export function input(read, of) {
+    if (of !== undefined)
+        return Object.assign(marked(read, of), { touch });
+    told.add(read);
+    return Object.assign(read, { input: true, touch });
+}
+/**
+ * A signal the host writes: `input` over one number, with `set` reporting each change. klieg's
+ * `level`.
  *
  * @category signal
  */
 export function level(initial = 0) {
     let value = initial;
-    return Object.assign(() => value, {
-        input: true,
+    return Object.assign(input(() => value), {
         set(v) {
+            if (Object.is(v, value))
+                return;
             value = v;
+            touch();
         },
     });
 }
@@ -38,7 +76,7 @@ const firstSight = (target, from, setting) => from === undefined || !Number.isFi
     ? { value: target, seen: Number.NaN }
     : { value: from, seen: setting.timestamp };
 /**
- * The package's one decay primitive: follows its input at a rate limit, no faster than `riseMs` per
+ * The package's linear decay primitive: follows its input at a rate limit, no faster than `riseMs` per
  * unit climbing or `fallMs` draining. The mix keeps its state per voice and subject, so two voices
  * handed the same slew each follow on their own. A subject starts on its input, or at `from`
  * unless `dt` is infinite.
@@ -56,7 +94,8 @@ export function slew(of, { riseMs = 0, fallMs = 0, from }) {
             const gap = target - held.value;
             const ms = gap > 0 ? riseMs : fallMs;
             if (ms > 0) {
-                const step = (setting.timestamp - held.seen) / ms;
+                // No longer than `dt`, which `maxDt` caps, as every step is.
+                const step = Math.min(setting.timestamp - held.seen, setting.dt) / ms;
                 next = gap > 0 ? Math.min(target, held.value + step) : Math.max(target, held.value - step);
             }
         }
@@ -64,7 +103,7 @@ export function slew(of, { riseMs = 0, fallMs = 0, from }) {
         held.seen = setting.timestamp;
         return next;
     };
-    return marked(read, inputOf([of]));
+    return marked(read, [of]);
 }
 /**
  * The exponential counterpart to `slew`: closes the same fraction of the distance to its input in
@@ -86,7 +125,7 @@ export function lag(of, { riseMs = 0, fallMs = 0, floor = 1e-6, from, }) {
         if (!Number.isNaN(held.seen) && Number.isFinite(setting.dt)) {
             const ms = target > held.value ? riseMs : fallMs;
             if (ms > 0) {
-                const gap = setting.timestamp - held.seen;
+                const gap = Math.min(setting.timestamp - held.seen, setting.dt);
                 next = held.value + (target - held.value) * (1 - Math.exp(-gap / ms));
                 if (Math.abs(target - next) <= floor)
                     next = target;
@@ -96,7 +135,7 @@ export function lag(of, { riseMs = 0, fallMs = 0, floor = 1e-6, from, }) {
         held.seen = setting.timestamp;
         return next;
     };
-    return marked(read, inputOf([of]));
+    return marked(read, [of]);
 }
 /**
  * The other half of the pair: a band, not an edge. It drops at `off`, passes at `on`, and between
@@ -116,5 +155,5 @@ export function gate(of, band) {
         }
         return held.on ? 1 : 0;
     };
-    return marked(read, inputOf([of]));
+    return marked(read, [of]);
 }

package/dist/spans.js

@@ -1,8 +1,10 @@
 import { elapsedWith, retime } from './clock.js';
 import { retire } from './fade.js';
 import { defaultFit, layout, settle } from './fit.js';
+import { reorigin } from './held.js';
 import { noted } from './history.js';
 import { nextFrame } from './move.js';
+import { leave } from './origin.js';
 import { ownerReading } from './owner.js';
 /** What a span keeps beside its owner: its claim, its fit, and how the last fit came out. */
 export class Fitting {
@@ -89,6 +91,7 @@ export function refit(mix, span) {
     kids.forEach((c, i) => {
         const rate = (c.spec.rate ?? 1) * plan.rate[i];
         const skipped = plan.skip[i] && c.holding === null;
+        c.skipped = skipped;
         let moved = false;
         if (c.state === 'pending') {
             const start = local + at[i];
@@ -99,23 +102,27 @@ export function refit(mix, span) {
                 c.anchorElapsed = elapsed;
                 c.rate = rate;
                 c.ramp = null;
+                c.clocks = null;
                 moved = true;
             }
         }
         else {
             if (skipped) {
+                leave(c, local);
                 c.rebase(local);
                 c.anchorElapsed = c.span;
                 c.seeks++;
                 moved = true;
             }
             if (c.rate !== rate || c.ramp !== null) {
+                leave(c, local);
                 retime(c, local, rate, 0);
                 moved = true;
             }
         }
         if (moved) {
             mix.frame = nextFrame();
+            reorigin(mix, c, mix.now);
             noted(mix, c);
         }
     });

package/dist/stack.d.ts

@@ -0,0 +1,11 @@
+import type { Kit } from './types.js';
+/**
+ * Folds deltas into one pose by a kit's arithmetic, in order, with no mix and no clock: what a mix
+ * gives for voices contributing these deltas at these weights. Each channel starts at its rest, a
+ * weight (default 1, held to 0..1) fades a delta toward rest, and the pose is clamped to each
+ * channel's bounds. A channel with no rest takes the last delta whose weight is 0.6 or more, where
+ * a mix's default band first switches one on, and stays undefined where none is.
+ *
+ * @category channel
+ */
+export declare function fold<O>(kit: Kit<O>, deltas: readonly Partial<O>[], weights?: readonly number[]): O;

package/dist/stack.js

@@ -0,0 +1,47 @@
+import { copy } from './clone.js';
+import { bound, merged } from './fold.js';
+/** The weight a mix's default band first switches a rest-less channel on at. */
+const ON = 0.6;
+/**
+ * Folds deltas into one pose by a kit's arithmetic, in order, with no mix and no clock: what a mix
+ * gives for voices contributing these deltas at these weights. Each channel starts at its rest, a
+ * weight (default 1, held to 0..1) fades a delta toward rest, and the pose is clamped to each
+ * channel's bounds. A channel with no rest takes the last delta whose weight is 0.6 or more, where
+ * a mix's default band first switches one on, and stays undefined where none is.
+ *
+ * @category channel
+ */
+export function fold(kit, deltas, weights) {
+    const pose = {};
+    const names = Object.keys(kit);
+    for (const key of names) {
+        const channel = kit[key];
+        const rest = channel.rest;
+        pose[key] = rest === undefined ? undefined : channel.copy ? channel.copy(rest) : copy(rest);
+    }
+    for (let i = 0; i < deltas.length; i++) {
+        const given = weights?.[i] ?? 1;
+        const w = given > 1 ? 1 : given;
+        if (!(w > 0))
+            continue;
+        const delta = deltas[i];
+        for (const key of names) {
+            const value = delta[key];
+            if (value === undefined)
+                continue;
+            const channel = kit[key];
+            if (channel.rest !== undefined && channel.scale)
+                pose[key] = channel.fold
+                    ? channel.fold(pose[key], value, w)
+                    : merged(channel, pose[key], channel.scale(value, w));
+            else if (w >= ON)
+                pose[key] = pose[key] === undefined ? copy(value) : merged(channel, pose[key], value);
+        }
+    }
+    for (const key of names) {
+        const channel = kit[key];
+        if (channel.bounds)
+            pose[key] = bound(channel, pose[key]);
+    }
+    return pose;
+}

package/dist/standing.d.ts

@@ -0,0 +1,10 @@
+import type { Mixer } from './mixer.js';
+import type { Cut, Transport } from './transport.js';
+/**
+ * Throws unless a read back to mix time `t` is exact with no history: every voice plays as it was
+ * cued and reads the same whenever it is asked, and no mix on the transport has changed since `t`.
+ * A mix keeps only how it stands now, which is how it has stood since its last change.
+ */
+export declare function stands(transport: Transport, t: number): void;
+/** A mix's copy for a read back to `t` with no history: its voices as they stand, each at `t`. */
+export declare function copyStanding<I, O>(mix: Mixer<I, O>, c: Mixer<I, O>, t: number, cut: Cut): void;