@msb235/blits 0.7.1 → 0.8.1

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, first } 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 ? first(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;

package/dist/standing.js

@@ -0,0 +1,79 @@
+import { ownBlends } from './blend.js';
+import { relink } from './owner.js';
+import { pin } from './place.js';
+import { mirror, recall, stateAt } from './project.js';
+import { recount } from './roster.js';
+/**
+ * Why a voice cannot be read at an earlier time from how it stands now, or undefined where it can:
+ * what it shows depends on more than its clock as cued, so the frames it has played decided it.
+ */
+function unfit(mix, voice) {
+    const patch = voice.patch;
+    const spec = voice.spec;
+    if (patch.state !== undefined || patch.step !== undefined)
+        return 'its patch keeps state';
+    if (voice.motion !== undefined)
+        return 'it plays a motion';
+    if (voice.keeping)
+        return 'its patch or its weight keeps state';
+    if (spec.from === 'current')
+        return 'it starts from the pose its subjects had';
+    if (voice.written)
+        return 'its handle has been written to';
+    if (spec.anchor !== undefined)
+        return 'an anchor places it';
+    if (voice.holding !== null)
+        return 'it is an owner';
+    if (voice.owner !== null)
+        return 'it plays under an owner';
+    // A rest-less channel switches on across a band, by the weights its voice has passed through.
+    const steady = typeof spec.weight !== 'function' &&
+        spec.locus === undefined &&
+        !((voice.fade.in ?? 0) > 0) &&
+        !((voice.fade.out ?? 0) > 0);
+    if (!steady && voice.slots.some((s) => mix.channels[s]?.rest === undefined))
+        return 'it writes a channel with no rest at a weight that moves';
+    return undefined;
+}
+/**
+ * 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 function stands(transport, t) {
+    const need = `blits: reading back to ${t} needs a mix made with history`;
+    if (transport.pace !== null)
+        throw new Error(`${need}: the mix's rate has been set`);
+    if (t < transport.settled)
+        throw new Error(`${need}: a mix changed or a voice left at ${transport.settled}, and without history a mix keeps only how it stands now`);
+    for (const mix of transport.members)
+        for (const voice of mix.cued) {
+            if (voice.state === 'done')
+                continue;
+            const why = unfit(mix, voice);
+            if (why !== undefined)
+                throw new Error(`${need}: voice ${voice.id} is cued, and ${why}`);
+        }
+}
+/** A mix's copy for a read back to `t` with no history: its voices as they stand, each at `t`. */
+export function copyStanding(mix, c, t, cut) {
+    mirror(mix, c);
+    c.backward = true;
+    c.cued = mix.cued
+        .filter((v) => v.state !== 'done')
+        .map((v) => {
+        const copy = v.copy((subject) => recall(mix, v, subject, t, cut));
+        // A fade its own end began after `t` had not begun then.
+        if (copy.out !== null && copy.out.at > t)
+            copy.out = null;
+        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);
+    stateAt(c, t);
+    recount(c);
+}

package/dist/store.d.ts

@@ -1,9 +1,9 @@
 /**
  * Per-subject storage keyed by identity. Objects go in a WeakMap and are forgotten when the host
  * drops them; anything else — a string id, the unit subject of a mix with no subject dimension —
- * goes in a Map that only `drop` and `clear` empty, which is why a host keying by value should
- * call `drop`. Each map is made when first written, since a mix holds a store per voice and patch;
- * until then it is a shared empty one, so the field always holds a map.
+ * goes in a Map that only `delete` and `clear` empty, which is why a host keying by value should
+ * call `Mix.drop`. Each map is made when first written, since a mix holds a store per voice and
+ * patch; until then it is a shared empty one, so the field always holds a map.
  */
 export declare class Store<K, V> {
     private weak;

package/dist/store.js

@@ -4,9 +4,9 @@ const noStrong = new Map();
 /**
  * Per-subject storage keyed by identity. Objects go in a WeakMap and are forgotten when the host
  * drops them; anything else — a string id, the unit subject of a mix with no subject dimension —
- * goes in a Map that only `drop` and `clear` empty, which is why a host keying by value should
- * call `drop`. Each map is made when first written, since a mix holds a store per voice and patch;
- * until then it is a shared empty one, so the field always holds a map.
+ * goes in a Map that only `delete` and `clear` empty, which is why a host keying by value should
+ * call `Mix.drop`. Each map is made when first written, since a mix holds a store per voice and
+ * patch; until then it is a shared empty one, so the field always holds a map.
  */
 export class Store {
     weak = noWeak;

package/dist/strays.js

@@ -42,6 +42,9 @@ export function motionOwner(mix) {
         now() {
             return mix.deref()?.now ?? Number.NaN;
         },
+        seq() {
+            return mix.deref()?.transport.seq ?? Number.NaN;
+        },
         changed(id, motion, subject, change) {
             const m = mix.deref();
             if (m === undefined)

package/dist/tape.d.ts

@@ -1,7 +1,10 @@
 import type { Pace } from './pace.js';
 import type { Transport } from './transport.js';
 import type { Tape } from './types.js';
-/** The tape `history.tape` makes for a transport, stamping each call with the mix time it was made at. */
+/**
+ * The tape `history.tape` makes for a transport, stamping each call with the host time it was made
+ * at: rate 0 holds mix time still across frames, and host time tells them apart.
+ */
 export declare function tapeOf(transport: Transport): Tape | undefined;
 /** Records a host call, which `again` makes once more when the mix plays past it after a seek. */
 export declare function record(on: {
@@ -14,8 +17,8 @@ export declare function hostAt(clock: {
     readonly pace: Pace | null;
 }, t: number): number;
 /**
- * Makes the recorded calls due by mix time `to()` again, each with every mix on the transport
- * moved to the time it was made at, as the host made it then. `to` is asked again after every
- * call, since a call may change the rate and so where a host time lands.
+ * Makes the recorded calls `due` by the host time each was made at again, each host time's in a
+ * frame of its own with every mix on the transport moved to where it stood then, as the host made
+ * them. Answers the host time of the last frame it played, NaN for none.
  */
-export declare function replay(transport: Transport, to: () => number): void;
+export declare function replay(transport: Transport, due: (u: number) => boolean): number;

package/dist/tape.js

@@ -1,13 +1,16 @@
 import { move } from './move.js';
 /** What a recorded call's `invert` gives: a mix goes back by restoring, never by undoing a call. */
 const undone = { apply() { }, invert: () => undone };
-/** The tape `history.tape` makes for a transport, stamping each call with the mix time it was made at. */
+/**
+ * The tape `history.tape` makes for a transport, stamping each call with the host time it was made
+ * at: rate 0 holds mix time still across frames, and host time tells them apart.
+ */
 export function tapeOf(transport) {
     const make = transport.history?.tape;
     if (make === undefined)
         return undefined;
     return make(transport, {
-        now: () => (Number.isNaN(transport.now) ? Number.NEGATIVE_INFINITY : transport.now),
+        now: () => (Number.isNaN(transport.u) ? Number.NEGATIVE_INFINITY : transport.u),
         branching: true,
         coalesceWindowMs: 0,
     });
@@ -31,24 +34,29 @@ export function hostAt(clock, t) {
     return clock.pace === null ? t : clock.pace.timeOf(t);
 }
 /**
- * Makes the recorded calls due by mix time `to()` again, each with every mix on the transport
- * moved to the time it was made at, as the host made it then. `to` is asked again after every
- * call, since a call may change the rate and so where a host time lands.
+ * Makes the recorded calls `due` by the host time each was made at again, each host time's in a
+ * frame of its own with every mix on the transport moved to where it stood then, as the host made
+ * them. Answers the host time of the last frame it played, NaN for none.
  */
-export function replay(transport, to) {
+export function replay(transport, due) {
     const tape = transport.tape;
     if (tape === undefined)
-        return;
+        return Number.NaN;
     const u = transport.u;
+    let last = Number.NaN;
     try {
         for (;;) {
             const at = tape.timestampAt(tape.undoDepth());
-            if (at === undefined || !(at <= to()))
-                return;
-            if (at > transport.now) {
-                transport.u = hostAt(transport, at);
-                for (const m of transport.members)
-                    move(m, at);
+            if (at === undefined || !due(at))
+                return last;
+            if (at !== last) {
+                last = at;
+                transport.u = at;
+                const now = transport.pace === null ? at : transport.pace.reading(at);
+                if (now > transport.now)
+                    for (const m of transport.members)
+                        move(m, now);
+                transport.tick(transport.now);
             }
             transport.replaying = true;
             try {

package/dist/testing.d.ts

@@ -0,0 +1,35 @@
+import type { Kit, Patch, Setting } from './types.js';
+/**
+ * A `Setting` for calling a patch's `at` or `step` outside a mix: `keep` holds per owner as a mix's
+ * does, and `send` keeps what is sent in `sent`. Any field may be given; the rest read a voice at
+ * full weight at the start of its first pass, 1/60 s after the last frame.
+ *
+ * @category patch
+ */
+export declare function setting<S = void, H = unknown>(fields?: Partial<Omit<Setting<S, H>, 'keep' | 'send'>>): Setting<S, H> & {
+    sent: unknown[];
+};
+/** @category patch */
+export interface CheckOptions<I, O, H = unknown> {
+    /** The subject to read the patch for. */
+    subject: I;
+    /** A kit the patch should play in: each channel it writes, of the kind it was written for. */
+    kit?: Kit<O>;
+    /** What the patch's `reads` find on `setting.host`. */
+    host?: H;
+    /** The interval `step` is given, as under `stepMs`. Default 1000 / 60. */
+    stepMs?: number;
+    /** How many steps to run before reading state. Default 30. */
+    steps?: number;
+}
+/**
+ * What a patch does that a mix cannot rely on, one sentence per problem; empty when none. It reads
+ * `at` across its phase, twice from fresh state, and checks that it writes only its `writes`, gives
+ * the same delta each time, and leaves the subject alone; that `state` makes a new value per call,
+ * that `step` lands the same from the same start, and that `clone` and `pack`/`unpack` give back an
+ * equal state; that every field it `reads` is on `host`; and, given a kit, that `cue` would
+ * take it. Meant for a library's own tests: `expect(checkPatch(glow, { subject })).toEqual([])`.
+ *
+ * @category patch
+ */
+export declare function checkPatch<I, O, S = void, H = unknown>(patch: Patch<I, O, S, H>, opts: CheckOptions<I, O, H>): string[];

package/dist/testing.js

@@ -0,0 +1,116 @@
+import { clone } from './clone.js';
+import { fitsKit } from './cue.js';
+import { same } from './history.js';
+/**
+ * A `Setting` for calling a patch's `at` or `step` outside a mix: `keep` holds per owner as a mix's
+ * does, and `send` keeps what is sent in `sent`. Any field may be given; the rest read a voice at
+ * full weight at the start of its first pass, 1/60 s after the last frame.
+ *
+ * @category patch
+ */
+export function setting(fields = {}) {
+    const kept = new Map();
+    const sent = [];
+    return {
+        timestamp: 0,
+        dt: 1000 / 60,
+        elapsed: 0,
+        pass: 0,
+        weight: 1,
+        state: undefined,
+        host: undefined,
+        ...fields,
+        keep(owner, init) {
+            if (!kept.has(owner))
+                kept.set(owner, init());
+            return kept.get(owner);
+        },
+        send(event) {
+            sent.push(event);
+        },
+        sent,
+    };
+}
+/**
+ * What a patch does that a mix cannot rely on, one sentence per problem; empty when none. It reads
+ * `at` across its phase, twice from fresh state, and checks that it writes only its `writes`, gives
+ * the same delta each time, and leaves the subject alone; that `state` makes a new value per call,
+ * that `step` lands the same from the same start, and that `clone` and `pack`/`unpack` give back an
+ * equal state; that every field it `reads` is on `host`; and, given a kit, that `cue` would
+ * take it. Meant for a library's own tests: `expect(checkPatch(glow, { subject })).toEqual([])`.
+ *
+ * @category patch
+ */
+export function checkPatch(patch, opts) {
+    const problems = [];
+    const { subject, host } = opts;
+    const tick = opts.stepMs ?? 1000 / 60;
+    const steps = opts.steps ?? 30;
+    const writes = new Set(patch.writes);
+    if (opts.kit !== undefined)
+        try {
+            fitsKit(patch, opts.kit);
+        }
+        catch (e) {
+            problems.push(e.message);
+        }
+    for (const field of patch.reads ?? [])
+        if (typeof host !== 'object' || host === null || !(field in host))
+            problems.push(`reads host.${field}, which the host given lacks`);
+    const fresh = () => (patch.state ? patch.state(subject) : undefined);
+    if (patch.state) {
+        const a = fresh();
+        if (typeof a === 'object' && a !== null && a === fresh())
+            problems.push('state() hands every subject the same object, so they share state');
+    }
+    /** The state after `steps` steps from fresh. */
+    const stepped = () => {
+        const state = fresh();
+        if (patch.step)
+            for (let n = 1; n <= steps; n++)
+                patch.step(state, tick, subject, setting({ state, host, dt: tick, timestamp: n * tick }));
+        return state;
+    };
+    const before = clone(subject);
+    const phases = [0, 0.25, 0.5, 0.75, 1];
+    const read = (state) => phases.map((phase) => clone(patch.at(phase, subject, setting({ state, host, elapsed: phase * patch.duration }))));
+    let first = [];
+    try {
+        first = read(stepped());
+        const second = read(stepped());
+        const stray = new Set();
+        for (const delta of first)
+            for (const key of Object.keys(delta))
+                if (!writes.has(key))
+                    stray.add(key);
+        for (const key of stray)
+            problems.push(`at() writes ${key}, which is not in writes`);
+        if (!same(first, second))
+            problems.push('at() gives a different delta for the same phase, subject and state');
+    }
+    catch (e) {
+        problems.push(`at() or step() threw: ${e.message}`);
+    }
+    if (!same(subject, before))
+        problems.push('at() or step() changed the subject');
+    if (patch.step || patch.state) {
+        const state = stepped();
+        if (!same(state, stepped()))
+            problems.push('step() lands somewhere else from the same start and steps');
+        if (patch.clone) {
+            const c = patch.clone(state);
+            if (!same(c, state))
+                problems.push('clone() gives a state unequal to the one it was given');
+            else if (typeof state === 'object' && state !== null && c === state)
+                problems.push('clone() hands back the state itself, not a copy');
+        }
+        if ((patch.pack === undefined) !== (patch.unpack === undefined))
+            problems.push('pack and unpack come as a pair');
+        else if (patch.pack && patch.unpack) {
+            const back = patch.unpack(JSON.parse(JSON.stringify(patch.pack(state))));
+            if (!same(back, state))
+                problems.push('unpack(pack(state)) through JSON gives another state');
+        }
+    }
+    return problems;
+}

package/dist/touch.d.ts

@@ -0,0 +1,6 @@
+import type { Mixer } from './mixer.js';
+/**
+ * What `Mix.touch` does: makes stale every delta read this frame, for one subject or for all, so
+ * the next probe calls each patch again, on either path.
+ */
+export declare function touch<I, O>(mix: Mixer<I, O>, subject?: I): void;

package/dist/touch.js

@@ -0,0 +1,28 @@
+import { restamp } from './everyone.js';
+import { nextFrame } from './move.js';
+/**
+ * What `Mix.touch` does: makes stale every delta read this frame, for one subject or for all, so
+ * the next probe calls each patch again, on either path.
+ */
+export function touch(mix, subject) {
+    mix.frame = nextFrame();
+    if (subject === undefined) {
+        // A motion patch reads nothing from outside the mix, and an owner has no delta.
+        for (const voice of mix.cued)
+            if (voice.motion === undefined && voice.holding === null) {
+                voice.seeks++;
+                voice.touches++;
+            }
+    }
+    else {
+        // No voice's `seeks` is below 0, so no record stamped with it reads as current.
+        let held = mix.chains.get(subject) ?? null;
+        for (; held !== null; held = held.next)
+            held.seeks = -1;
+        const slot = mix.chains.get(subject)?.slot ?? -1;
+        for (const voice of mix.sharers)
+            restamp(voice, slot);
+    }
+    mix.lanes?.refill();
+    mix.stir();
+}

package/dist/transport.d.ts

@@ -1,3 +1,4 @@
+import { Frames } from './frames.js';
 import type { Mixer } from './mixer.js';
 import { Pace } from './pace.js';
 import { Pager } from './paging.js';
@@ -5,22 +6,39 @@ import { type ScoreHolders } from './scored.js';
 import type { Marked, Mix, MixOptions, Tape, Transport as TransportApi, TransportOptions, TransportProjection } from './types.js';
 /**
  * A mark the host announced on a score: `at` in host time, so the rate never moves one, and NaN
- * until the next sync for one announced as now before any sync; `made` is the mix time it was
- * announced, for a read back to know what was known.
+ * until the next sync for one announced as now before any sync.
  */
 export interface Announced {
     name: string;
     score: string | undefined;
     tags: readonly string[];
     at: number;
-    made: number;
     order: number;
+    /** The frame it was announced in, for a read back to know what was known. */
+    seq: number;
     /** The slot of the mix that announced it, -1 for the transport; only it sees an unnamed score. */
     slot: number;
     /** That mix's name, for `Marked.mix`. */
     mix: string | undefined;
 }
 type Member = Mixer<unknown, unknown>;
+/**
+ * One frame on the transport: its number, the mix time it stood at and the host time it was made
+ * at. Rate 0 holds mix time still across frames, so only the number tells two of them apart.
+ */
+export interface Frame {
+    seq: number;
+    at: number;
+    u: number;
+}
+/** Where history is cut for a seek or read: what frame `seq` made, and before it, is kept. */
+export interface Cut {
+    seq: number;
+    /** For a read of what a frame showed: of that frame's own changes, only those made before it was read. */
+    strict: boolean;
+}
+/** Whether a change made in frame `seq` falls inside `cut`; `early` for one made before the frame was read. */
+export declare function within(cut: Cut, seq: number, early?: boolean): boolean;
 /**
  * The clock its mixes play on: host time less what `rebase` took out, at the rate its `pace`
  * sets, moved by `sync` and `seek`, and the tape of calls a seek plays again. A mix made alone
@@ -35,6 +53,7 @@ export declare class Transport implements TransportApi {
     dropped: {
         mix: Member;
         at: number;
+        seq: number;
     }[];
     /** Numbers the mixes as they join, for their order and for whose unnamed score a mark is on. */
     slots: number;
@@ -44,6 +63,13 @@ export declare class Transport implements TransportApi {
     private woken;
     /** The mix clock at the last sync or seek. */
     now: number;
+    /**
+     * The number of the frame being played: each sync and seek begins one, and so does each host
+     * time the tape plays calls again at.
+     */
+    seq: number;
+    /** Under history, the frames a seek or read back may reach, oldest first. */
+    frames: Frames;
     /** Host time at the last sync: the host's timestamp less every gap `rebase` took out. */
     u: number;
     offset: number;
@@ -57,6 +83,17 @@ export declare class Transport implements TransportApi {
     taped: number;
     /** The rate; null while it has never been set, when mix time is host time. */
     pace: Pace | null;
+    /** The latest mix time a voice any mix on it let go of from `gone` had left at. */
+    forgotTo: number;
+    /**
+     * The latest mix time a host changed a mix on it, or a voice or a subject left one: without
+     * history, the earliest time a read back still finds the mixes as they stand now.
+     */
+    settled: number;
+    /** Records a change or a leaving at the mix time now; before the first sync, nothing. */
+    settle(): void;
+    /** The frame the rate was first set in, which a seek or read back to before it finds unset. */
+    pacedSeq: number;
     /** True while the tape makes a recorded call again, so it is not recorded twice. */
     replaying: boolean;
     announced: Announced[];
@@ -72,11 +109,11 @@ export declare class Transport implements TransportApi {
     constructor(history: MixOptions['history'], shared: boolean);
     /** Whether this is a projection's own transport, which records and seeks nothing. */
     get projecting(): boolean;
-    /** Takes a mix on, after every mix that joined before it; `slot` keeps a copy's in place. */
+    /** Takes a mix on, after every mix that joined before it; `slot` keeps one a seek puts back in place. */
     join(mix: Member, slot?: number): void;
     drop<I, O, H>(mix: Mix<I, O, H>): void;
-    /** A seek back to `t`: every mix dropped after it is back on, as it stood then. */
-    undrop(t: number): void;
+    /** A seek back to frame `seq`: every mix dropped after it is back on, as it stood then. */
+    undrop(seq: number): void;
     seek(time: number): void;
     prepare(time: number): Promise<void>;
     announce(name: string, opts: {
@@ -93,6 +130,8 @@ export declare class Transport implements TransportApi {
     woke(): void;
     sync(timestamp: number): void;
     private syncAt;
+    /** Begins a frame at mix time `at` and the host time the transport stands at. */
+    tick(at: number): void;
     rebase(): void;
     /**
      * Moves `floor` past what the mix clock standing at `now` has let go of. With a store nothing is