@msb235/blits 0.10.0 → 0.12.0

package/dist/tape.js

@@ -1,4 +1,13 @@
 import { move } from './move.js';
+const live = { transport: (of) => of, mix: (of) => of };
+/** The stage the tape is playing calls on; the live one outside a read ahead's replay. */
+let stage = live;
+/** What a call threw on a read ahead's stage, for `replay` to throw once the tape has the entry back. */
+let failed;
+/** Refuses a recorded call a read ahead's copies cannot take. */
+export function unplayable(what) {
+    throw new Error(`blits: the tape holds ${what}, which a read ahead cannot play; seek there to see it`);
+}
 /** What a recorded call's `invert` gives: a mix goes back by restoring, never by undoing a call. */
 const undone = { apply() { }, invert: () => undone };
 /**
@@ -15,7 +24,10 @@ export function tapeOf(transport) {
         coalesceWindowMs: 0,
     });
 }
-/** Records a host call, which `again` makes once more when the mix plays past it after a seek. */
+/**
+ * Records a host call, which `again` makes once more when the mix plays past it after a seek, or
+ * when a read ahead does, on the stage it is given.
+ */
 export function record(on, label, again) {
     const tape = on.tape;
     if (tape === undefined || on.replaying || on.projecting)
@@ -23,7 +35,16 @@ export function record(on, label, again) {
     const op = {
         label,
         apply() {
-            again();
+            if (stage === live)
+                again(stage);
+            // Thrown inside the tape's `redo`, it would leave the tape without the entry.
+            else
+                try {
+                    again(stage);
+                }
+                catch (e) {
+                    failed ??= { error: e };
+                }
         },
         invert: () => undone,
     };
@@ -33,16 +54,26 @@ export function record(on, label, again) {
 export function hostAt(clock, t) {
     return clock.pace === null ? t : clock.pace.timeOf(t);
 }
+/**
+ * The host time a move ahead to mix time `t` lands at: never behind the clock's own, since rate 0
+ * reads `t` at every host time from the earliest `hostAt` gives, and a call stamped earlier than
+ * one already on the tape would cut it out of order.
+ */
+export function hostAhead(clock, t) {
+    const at = hostAt(clock, t);
+    return clock.u > at ? clock.u : at;
+}
 /**
  * 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.
+ * them. Answers the host time of the last frame it played, NaN for none. Given `onto` and the
+ * stage of its copies, it makes them on those, and the caller puts the tape back.
  */
-export function replay(transport, due) {
+export function replay(transport, due, onto = transport, on = live) {
     const tape = transport.tape;
     if (tape === undefined)
         return Number.NaN;
-    const u = transport.u;
+    const u = onto.u;
     let last = Number.NaN;
     try {
         for (;;) {
@@ -51,23 +82,30 @@ export function replay(transport, due) {
                 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)
+                onto.u = at;
+                const now = onto.pace === null ? at : onto.pace.reading(at);
+                if (now > onto.now)
+                    for (const m of onto.members)
                         move(m, now);
-                transport.tick(transport.now);
+                onto.tick(onto.now);
             }
             transport.replaying = true;
+            stage = on;
             try {
                 tape.redo();
             }
             finally {
                 transport.replaying = false;
+                stage = live;
+            }
+            if (failed !== undefined) {
+                const { error } = failed;
+                failed = undefined;
+                throw error;
             }
         }
     }
     finally {
-        transport.u = u;
+        onto.u = u;
     }
 }

package/dist/touch.js

@@ -1,3 +1,4 @@
+import { headOf } from './chain.js';
 import { restamp } from './everyone.js';
 import { nextFrame } from './move.js';
 /**
@@ -16,10 +17,10 @@ export function touch(mix, subject) {
     }
     else {
         // No voice's `seeks` is below 0, so no record stamped with it reads as current.
-        let held = mix.chains.get(subject) ?? null;
+        let held = headOf(mix, subject) ?? null;
         for (; held !== null; held = held.next)
             held.seeks = -1;
-        const slot = mix.chains.get(subject)?.slot ?? -1;
+        const slot = headOf(mix, subject)?.slot ?? -1;
         for (const voice of mix.sharers)
             restamp(voice, slot);
     }

package/dist/transport.d.ts

@@ -94,6 +94,11 @@ export declare class Transport implements TransportApi {
     settle(): void;
     /** The frame the rate was first set in, which a seek or read back to before it finds unset. */
     pacedSeq: number;
+    /**
+     * On a read ahead's own transport, the retargets and pushes its tape's calls made, which
+     * `reading.ahead` hands the motion patches while it reads.
+     */
+    ahead: Map<object, Map<unknown, unknown[]>>;
     /** True while the tape makes a recorded call again, so it is not recorded twice. */
     replaying: boolean;
     announced: Announced[];
@@ -114,7 +119,9 @@ export declare class Transport implements TransportApi {
     drop<I, O, H>(mix: Mix<I, O, H>): 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;
+    seek(to: number | {
+        readonly frame: number;
+    }): void;
     prepare(time: number): Promise<void>;
     announce(name: string, opts: {
         at?: number;
@@ -122,7 +129,9 @@ export declare class Transport implements TransportApi {
         tags?: readonly string[];
     }): void;
     marks(from: number, to: number): Marked[];
-    project(time: number): TransportProjection;
+    project(at: number | {
+        readonly frame: number;
+    }): TransportProjection;
     get live(): boolean;
     get inert(): boolean;
     onWake(fn: () => void): () => void;

package/dist/transport.js

@@ -8,6 +8,7 @@ import { projectAll } from './project.js';
 import { scoredDrop, scoredJoin } from './scored.js';
 import { seek } from './seek.js';
 import { hostAt, record, replay, tapeOf } from './tape.js';
+import { gave, historyFor } from './watch.js';
 /** How far the tape's reach moves before it is pruned again, ms of mix time. */
 const TAPE_STEP_MS = 1000;
 /** Whether a change made in frame `seq` falls inside `cut`; `early` for one made before the frame was read. */
@@ -68,6 +69,11 @@ export class Transport {
     }
     /** The frame the rate was first set in, which a seek or read back to before it finds unset. */
     pacedSeq = Number.POSITIVE_INFINITY;
+    /**
+     * On a read ahead's own transport, the retargets and pushes its tape's calls made, which
+     * `reading.ahead` hands the motion patches while it reads.
+     */
+    ahead = new Map();
     /** True while the tape makes a recorded call again, so it is not recorded twice. */
     replaying = false;
     announced = [];
@@ -110,7 +116,11 @@ export class Transport {
         m.dropped = true;
         if (this.history !== undefined) {
             this.dropped.push({ mix: m, at: this.now, seq: this.seq });
-            record(this, 'drop', () => this.drop(mix));
+            record(this, 'drop', (stage) => {
+                const to = stage.mix(m);
+                if (to !== undefined)
+                    stage.transport(this).drop(to);
+            });
         }
     }
     /** A seek back to frame `seq`: every mix dropped after it is back on, as it stood then. */
@@ -124,8 +134,8 @@ export class Transport {
             this.join(d.mix, d.mix.slot);
         }
     }
-    seek(time) {
-        seek(this, time);
+    seek(to) {
+        seek(this, to);
     }
     prepare(time) {
         return prepare(this, time);
@@ -138,8 +148,8 @@ export class Transport {
     marks(from, to) {
         return listedAll(this, from, to).map(({ order: _, ...m }) => m);
     }
-    project(time) {
-        return projectAll(this, time);
+    project(at) {
+        return projectAll(this, at);
     }
     get live() {
         return this.members.some((m) => m.live);
@@ -286,7 +296,8 @@ export class Transport {
         if (!(rate >= 0 && rate < Number.POSITIVE_INFINITY))
             throw new RangeError(`blits: a mix's rate is a finite number, 0 or more, not ${rate}`);
         if (this.pace === null) {
-            this.pace = new Pace(this.history !== undefined);
+            // A read ahead keeps every clock too: it moves once across calls a mix met frame by frame.
+            this.pace = new Pace(this.history !== undefined || this.projecting);
             this.pacedSeq = this.seq;
             // Until now mix time was host time, so a pending voice's start is the host time it was given.
             for (const m of this.members)
@@ -298,7 +309,7 @@ export class Transport {
         this.pace.change(this.u, rate, over, reach, this.seq);
         for (const m of this.members)
             m.stir();
-        record(this, 'rate', () => this.ramp(rate, over));
+        record(this, 'rate', (stage) => stage.transport(this).ramp(rate, over));
     }
 }
 /** Puts a mark on a score: one the transport announced, or a mix on it, `slot`. */
@@ -316,8 +327,9 @@ export function announce(transport, name, opts, slot, mix) {
     };
     transport.announced.push(mark);
     transport.settle();
-    record(transport, 'announce', () => {
-        transport.announced.push({ ...mark, seq: transport.seq });
+    record(transport, 'announce', (stage) => {
+        const to = stage.transport(transport);
+        to.announced.push({ ...mark, seq: to.seq });
     });
 }
 /**
@@ -326,5 +338,9 @@ export function announce(transport, name, opts, slot, mix) {
  * @category mix
  */
 export function transport(opts = {}) {
-    return new Transport(opts.history, true);
+    const { history, added } = historyFor(opts);
+    const t = new Transport(history, true);
+    if (added)
+        gave(t);
+    return t;
 }

package/dist/types/arc.d.ts

@@ -0,0 +1,55 @@
+import type { Handle, OwnerSpec, VoiceSpec } from './voice.js';
+/**
+ * One voice of an arc's part: a voice's spec, less what the arc sets for it. The arc places it,
+ * fades it across each boundary by `blend`, and holds its first and last frames for the blend.
+ *
+ * @category score
+ */
+export interface ArcVoice<I, O, H = unknown> extends Omit<VoiceSpec<I, O, H>, 'owner' | 'start' | 'anchor' | 'freeze' | 'fade' | 'faster' | 'slower' | 'overlap' | 'ballast' | 'priority' | 'earliest' | 'rank'> {
+    /**
+     * How long the part holds the arc, ms on the arc's clock. Default: the patch's duration times
+     * its passes, which leaves out a `stagger`, so a part whose last subject lands later says so here.
+     */
+    duration?: number;
+}
+/**
+ * One part of an arc: a voice, or several layered together that play as one and last as long as
+ * the longest.
+ *
+ * @category score
+ */
+export type ArcPart<I, O, H = unknown> = ArcVoice<I, O, H> | readonly ArcVoice<I, O, H>[];
+/**
+ * What `arc` takes: an owner over three parts that hand over in order, `enter`, `active` and
+ * `exit`, any of which may be left out.
+ *
+ * @category score
+ */
+export interface ArcSpec<I, O, H = unknown> extends Omit<OwnerSpec<I, H>, 'freeze'> {
+    /** What plays as it arrives. Its end is the arc's `in` mark. */
+    enter?: ArcPart<I, O, H>;
+    /** What plays between the two, over the hold. Its end is the arc's `coast` mark. */
+    active?: ArcPart<I, O, H>;
+    /** What plays as it leaves. Its start is the arc's `out` mark, and its end the arc's `end`. */
+    exit?: ArcPart<I, O, H>;
+    /**
+     * How long `active` plays, ms on the arc's clock, looping for it unless its `loop` says how many
+     * passes; or `'open'`, until `release`. Default: `active`'s own length, held open where it loops
+     * for good, and 0 with no `active`.
+     */
+    hold?: number | 'open';
+    /** A crossfade across each boundary, ms, half before it and half after. Default 0. */
+    blend?: number;
+}
+/**
+ * An arc's handle: an owner's, and the release of its hold. `fade` takes it out with no exit.
+ *
+ * @category score
+ */
+export interface ArcHandle<I = unknown> extends Handle<I> {
+    /**
+     * Ends the hold now and plays the exit, its blend starting here; where the enter is still
+     * playing, the exit follows it. Nothing once the exit has begun or the arc is fading.
+     */
+    release(): void;
+}

package/dist/types/arc.js

@@ -0,0 +1 @@
+export {};

package/dist/types/mix.d.ts

@@ -1,9 +1,10 @@
+import type { ArcHandle, ArcSpec } from './arc.js';
 import type { Kit } from './channel.js';
 import type { HistoryOptions, Tape } from './history.js';
 import type { Patch, Sent, Signal } from './patch.js';
 import type { Booker, BookOptions, Marked } from './place.js';
 import type { Transport } from './transport.js';
-import type { Handle, OwnerSpec, SpanHandle, SpanSpec, VoiceSpec } from './voice.js';
+import type { BlendMember, Handle, OwnerSpec, SpanHandle, SpanSpec, VoiceSpec } from './voice.js';
 /**
  * How a mix is built: its engine, reduced motion, the host, and its limits.
  *
@@ -52,6 +53,11 @@ export interface MixOptions<H = unknown> {
      * string or number subject is its own key; with a store, an object subject needs this.
      */
     keyOf?(subject: never): string | number;
+    /**
+     * What a debugger calls a subject (see `watched`); where it gives nothing, the subject's own
+     * `name` or `id`, a DOM element's tag, id and classes, or its class and a number.
+     */
+    labelOf?(subject: never): string | undefined;
     /**
      * Whether a channel may run as a lane: computed for every subject at once in flat arrays, when
      * every voice writing it can run that way. On by default; what a host reads is the same either
@@ -77,7 +83,7 @@ export interface MixOptions<H = unknown> {
 /**
  * How sure a projection is of one channel: `exact` where only the clock and known changes drove
  * it; `stepped` where state was advanced across a gap in one go, which is as good as the patch's
- * step makes it; `held` where it depends on input from outside the clock, whose value at that time
+ * step makes it, or a signal's state was read back from a copy; `held` where it depends on input from outside the clock, whose value at that time
  * is not known, so the value it had is held.
  *
  * @category mix
@@ -119,9 +125,11 @@ export interface Mix<I, O, H = unknown> {
     /**
      * N voices whose weights split one signal, cued into one locus so they fold as alternatives. The
      * signal is read once per subject per frame, with the first member's setting, and every member
-     * takes its share of that one reading; a signal keeping state keeps it once, not per member.
+     * takes its share of that one reading, which `share` reads outside the blend; a signal keeping
+     * state keeps it once, not per member. One `spec` cues them all, and a member given as a
+     * `BlendMember` carries its own `name`, `tags` and `hits` in place of the spec's.
      */
-    blend(patches: readonly Patch<I, O, unknown, H>[], by: Signal<I, H>, spec?: Omit<VoiceSpec<I, O, H>, 'patch' | 'weight' | 'locus'>): Handle<I>[];
+    blend(members: readonly (Patch<I, O, unknown, H> | BlendMember<I, O, H>)[], by: Signal<I, H>, spec?: Omit<VoiceSpec<I, O, H>, 'patch' | 'weight' | 'locus'>): Handle<I>[];
     /**
      * Cues an owner: a voice with no patch that holds the voices cued with `owner` set to its handle,
      * and plays them on its own clock, so they can be placed, timed and faded as one. Its handle acts
@@ -139,9 +147,23 @@ export interface Mix<I, O, H = unknown> {
      * span's to set, so it takes neither `start` nor an anchored start; its `SpanHints` say how it
      * may give way. A span with a budget stays until the budget has passed, though its children
      * finish sooner, so late ones can still join, and its `end` mark is where its children end or
-     * its budget does, whichever is later. A voice that loops for good cannot join one.
+     * its budget does, whichever is later. A voice that loops for good cannot join one. Throws for
+     * a `rate` below 0: a span lays its children out forward from its start, and its handle's `rate`
+     * turns it once it plays.
      */
     span(spec: SpanSpec<I, H>): SpanHandle<I>;
+    /**
+     * Cues an arc: an owner holding three parts that hand over in order on its clock, `enter`, then
+     * `active` for the `hold`, then `exit`, each a voice or several layered. Its marks are its own:
+     * `start` as the enter begins, `in` as it ends, `coast` as the hold ends and `out` as the exit
+     * begins, which are one time, and `end` as the exit ends, where it leaves and `done` resolves.
+     * While the hold is open, `coast`, `out` and `end` are unknown until `release` fixes them. Each
+     * part shows its first and last frames through the blends either side of it, and a part left
+     * out leaves its time to the one before it. Its `fade` takes it out with no exit. An arc with a
+     * finite hold may sit in a span. Throws for a `rate` below 0, a hold below 0, and an `enter` or
+     * `exit` that never ends.
+     */
+    arc(spec: ArcSpec<I, O, H>): ArcHandle<I>;
     /**
      * The host reports the clock, once a frame. Nothing advances at the call. Throws for a timestamp
      * earlier than the last sync's, short of a `rebase`: the host's clock only goes forward, and
@@ -194,8 +216,11 @@ export interface Mix<I, O, H = unknown> {
     /**
      * Reads the mix at another mix time, without moving it. At the mix's own time it reads what
      * `probe` does: what the host has done since the last sync lands at the next. Ahead of the mix
-     * it plays what is cued forward, and throws for a time past a call the tape will play again after a `seek` back, which
-     * only a seek there makes; behind it, with `history`, it reads the last frame at or before `time`
+     * it plays what is cued forward, with the calls the tape holds after a `seek` back, and while a
+     * voice could carry state (a patch that steps, a signal weight) it reads each subject asked about
+     * at every known event on the way: each call, and each mark `marks` would list. It throws
+     * for the two a copy cannot take: a `drop` of a subject a motion patch holds, and a retarget or
+     * push made before its voice met the subject. Behind it, with `history`, it reads the last frame at or before `time`
      * as that frame showed, and throws for a time older than the history reaches. On a transport it
      * reads every mix on it together, so anchors across them answer.
      *
@@ -204,8 +229,13 @@ export interface Mix<I, O, H = unknown> {
      * alone: no state, motion, `from: 'current'`, anchor or owner, no write to its handle, and no channel without a rest
      * at a weight that moves. The mix's rate has never been set. And `time` is no earlier than the
      * last cue, `drop`, `touch`, `announce` or `rebase`, or the last frame a voice left in.
+     *
+     * Given `{ frame }`, a number `seq` read, it reads that frame as it showed, as `seek` does; it
+     * needs `history`.
      */
-    project(time: number): Projection<I, O>;
+    project(at: number | {
+        readonly frame: number;
+    }): Projection<I, O>;
     /**
      * Moves the mix to mix time `time`, as it stood at the end of that frame, and plays on from
      * there; where rate 0 held the clock at `time` for several frames, the last of them. Needs
@@ -214,11 +244,12 @@ export interface Mix<I, O, H = unknown> {
      * Back, the mix restores itself: controls, records, voices and marks as they stood then. Voices
      * that left after it are back on the handles the host holds, their `done` and `played` starting
      * over where they had settled since. Voices cued after it wait as `pending` until the mix plays
-     * their cue again. Stateful voices restart from the copy `history` kept nearest before it and
-     * step once to it, exact under `stepMs`. A subject faded out of a voice or dropped after it comes
-     * back with the record it had, a motion patch's state included. Recorded input and host fields
-     * after it are let go: after a seek back, signals and host fields read live again, and `assess`
-     * reports what they fed as `held`.
+     * their cue again, and a write to the handle of one waiting changes nothing. Stateful voices
+     * restart from the copy `history` kept nearest before it and step once to it, exact under
+     * `stepMs`. A subject faded out of a voice or dropped after it comes back with the record it
+     * had, a motion patch's state included. Recorded input and host fields after it are let go:
+     * after a seek back, signals and host fields read live again, and `assess` reports what they
+     * fed as `held`.
      *
      * Forward, through a sync or a later seek, the mix plays the recorded calls again in the frames
      * they were made in: cues, handle writes, fades, retargets and pushes, its rate, marks,
@@ -230,8 +261,15 @@ export interface Mix<I, O, H = unknown> {
      * host's time since its last sync. Throws for a time older than history reaches, and before
      * the first sync. With a history `store`, a time older than memory needs `prepare` first, or
      * throws `HistoryMiss` before anything moves.
+     *
+     * Given `{ frame }`, a number `seq` read, it moves to the end of that frame instead, which is
+     * how a host reaches an earlier one of several frames rate 0 held at one mix time. The frame has
+     * to be one history still holds: not let go with age, and not after a moment an earlier seek went
+     * back to. With a store, one older than memory needs `prepare` of its mix time first.
      */
-    seek(time: number): void;
+    seek(to: number | {
+        readonly frame: number;
+    }): void;
     /** As `Transport.prepare`, for a mix made alone. */
     prepare(time: number): Promise<void>;
     /**
@@ -241,6 +279,11 @@ export interface Mix<I, O, H = unknown> {
     readonly now: number;
     /** The host's timestamp at the last sync; NaN before the first. */
     readonly timestamp: number;
+    /**
+     * The number of the frame being played, which `seek({ frame })` and `project({ frame })` take:
+     * each sync and seek begins a frame with a higher one, so two frames at one mix time differ.
+     */
+    readonly seq: number;
     /** The tape `history.tape` made, undefined without one. */
     readonly tape: Tape | undefined;
     /**

package/dist/types/patch.d.ts

@@ -129,7 +129,11 @@ export interface Patch<I, O, S = void, H = unknown> {
     readonly form: 'fn' | 'keys' | 'motion';
     /** Milliseconds one pass lasts, whether or not the voice loops. 0 has no passes: phase and pass stay 0. */
     readonly duration: number;
-    /** The channels this patch contributes to. Every key `at` sets, and no others. */
+    /**
+     * The channels this patch contributes to. Every key `at` sets, and no others: a mix drops any
+     * other key, and warns once per patch outside production when it finds one in the first delta a
+     * voice's `at` returns.
+     */
     readonly writes: readonly (keyof O)[];
     /**
      * The channels this patch was written against. `cue` refuses a mix whose channel of the same name

package/dist/types/place.d.ts

@@ -8,6 +8,12 @@
  * @category score
  */
 export type Mark = 'start' | 'in' | 'coast' | 'out' | 'end';
+/**
+ * A mark by name: one of a voice's own five, or one it places inside itself with `marks`.
+ *
+ * @category score
+ */
+export type MarkName = Mark | (string & {});
 /**
  * Selects voices by what the plan knows of them, never by a channel's value, within the asking
  * voice's own score unless it names another. Where several match,
@@ -26,7 +32,8 @@ export interface Query {
     resolver?: 'last' | 'first' | 'next' | 'earliest' | 'latest';
 }
 /**
- * A time given by another voice: `mark` of the voice `of` selects, moved by `by` ms. `after` is
+ * A time given by another voice: `mark` of the voice `of` selects, moved by `by` ms, where `mark`
+ * is one of its five or one it places inside itself with `marks`. `after` is
  * sugar for that voice's `end`, `with` for its `start`, and `before` for its start less `by`. A
  * string selects by name. `all` is the latest of its anchors, known once every one is; `any` the
  * earliest, known once one has passed or every one is known.
@@ -35,7 +42,7 @@ export interface Query {
  */
 export type Anchor = {
     of: string | Query;
-    mark: Mark;
+    mark: MarkName;
     by?: number;
 } | {
     after: string | Query;
@@ -77,8 +84,8 @@ export interface Placement {
 export interface Marked {
     /** On the host's clock. */
     timestamp: number;
-    /** Which of a voice's this is; undefined for an announced mark. */
-    mark: Mark | undefined;
+    /** Which of a voice's this is, one of its five or one it placed inside itself; undefined for an announced mark. */
+    mark: MarkName | undefined;
     /** The voice it belongs to; undefined for an announced mark. */
     voice: number | undefined;
     score: string | undefined;

package/dist/types/transport.d.ts

@@ -39,13 +39,17 @@ export interface Transport {
      * tape plays every mix's calls again in the order they were made, so an anchor across mixes
      * answers as it did. A mix dropped after the moment sought is back on the transport.
      */
-    seek(time: number): void;
+    seek(to: number | {
+        readonly frame: number;
+    }): void;
     /**
      * Loads from the history `store` what `seek(time)` and `project(time)` will need, where that
      * reaches past memory. Without a store, or within memory, it loads nothing.
      */
     prepare(time: number): Promise<void>;
     readonly now: number;
+    /** As `Mix.seq`: the number of the frame being played, the same for every mix on it. */
+    readonly seq: number;
     readonly tape: Tape | undefined;
     /** Puts a named mark on a score every mix on it sees. Throws without a `score`. */
     announce(name: string, opts: {
@@ -55,8 +59,13 @@ export interface Transport {
     }): void;
     /** Every mark of every mix on it, and every mark announced on it, earliest first. */
     marks(from: number, to: number): Marked[];
-    /** Every mix on it read at mix time `time`, together, so anchors across them answer. */
-    project(time: number): TransportProjection;
+    /**
+     * Every mix on it read at mix time `at`, or at the frame `{ frame }` names, together, so anchors
+     * across them answer.
+     */
+    project(at: number | {
+        readonly frame: number;
+    }): TransportProjection;
     /** Any mix on it live. */
     readonly live: boolean;
     /** Every mix on it inert. */