@msb235/blits 0.6.0 → 0.7.0

package/dist/lanes.js

@@ -1,7 +1,7 @@
 import { row } from './crowd.js';
 import { call, fillAll, foldKeys, one, parting, readKeyed, reset, run, signalled, subjectAt, } from './fill.js';
-import { fold, foldDelta, foldInto, foldRun, gather } from './gather.js';
-import { meet, owable, reach } from './meet.js';
+import { fold, foldDelta, foldInto, foldRun, gate, gather } from './gather.js';
+import { meet, reach } from './meet.js';
 import { Numbers } from './numbers.js';
 import { Owed } from './owed.js';
 import { requalify, retouch } from './qualify.js';
@@ -26,6 +26,9 @@ export class Lanes {
     overlap = false;
     /** The loci whose voices are on lanes, every member of each on one. */
     loci = [];
+    /** The lane and record `one` is folding, whose band state a rest-less channel reads. */
+    folding = null;
+    rec = null;
     /** While a fill gathers a locus: that locus and the member gathering, where folds go instead. */
     into = null;
     intoId = 0;
@@ -52,14 +55,17 @@ export class Lanes {
     /** The highest voice id the last qualify or settling of `touched` considered. */
     known = 0;
     /**
-     * Per subject number, `SLOT` numbers side by side, so a probe reads one place in memory: which
-     * fill last wrote it (0 for none); the latest lane epoch a probe of it has checked it against;
-     * how many idle lanes reach it, since a probe reads lanes only where none do; and the probe count
-     * at its last probe read from the lanes and at its last probe folded by the general path, with
-     * the fill the former read, which say whether a lane or a record holds what `weightOf` reports.
+     * Per subject number, `SLOT` numbers side by side, so a probe reads one place in memory: the
+     * fill that last left it to the general path, being late, owing, newly numbered or forgotten;
+     * the latest lane epoch a probe of it has checked it against; how many idle lanes reach it,
+     * since a probe reads lanes only where none do; and the probe count at its last probe read from
+     * the lanes and at its last probe folded by the general path, with the fill the former read,
+     * which say whether a lane or a record holds what `weightOf` reports.
      */
     per = new Float64Array(0);
     fills = 0;
+    /** The latest fill if it ran a lane, else 0: a subject whose `FILLED` is below it reads it. */
+    busyFill = 0;
     probes = 0;
     /**
      * Each subject by number as last probed, held from that probe until the next fill uses it, so a
@@ -104,6 +110,11 @@ export class Lanes {
     lastDistinct = 0;
     /** Numbered subjects alive. */
     live = 0;
+    /**
+     * The probe count a subject's last probe must pass for this fill to fill it: the start of the
+     * last frame with a probe, or -1 while every subject alive was probed then, when it fills all.
+     */
+    lately = -1;
     filledVersion = Number.NaN;
     qualifiedVersion = Number.NaN;
     constructor(host) {
@@ -132,7 +143,7 @@ export class Lanes {
         const slot = this.numbers.take(subject);
         this.live++;
         this.grow(slot + 1);
-        this.per[slot * 6 /* Per.SLOT */ + 0 /* Per.FILLED */] = 0;
+        this.per[slot * 6 /* Per.SLOT */ + 0 /* Per.FILLED */] = this.fills;
         this.per[slot * 6 /* Per.SLOT */ + 1 /* Per.SEEN */] = -1;
         this.per[slot * 6 /* Per.SLOT */ + 2 /* Per.IDLE */] = 0;
         this.per[slot * 6 /* Per.SLOT */ + 3 /* Per.LANE_PROBE */] = 0;
@@ -195,9 +206,10 @@ export class Lanes {
      * them. One that a lane has not met yet, newly numbered or newly reached, takes the general path
      * this frame, which is where it is first seen; so does one probed from inside a fill.
      */
-    prepare(slot, subject, now, version, head) {
-        const ready = this.filled(now, version) ? 1 /* Begin.READY */ : this.begin(now, version);
-        if (ready === 0 /* Begin.GENERAL */)
+    prepare(slot, subject, version, head) {
+        // Read, not passed: a double passed to a call V8 does not inline is boxed, once a probe.
+        const now = this.host.clock.now;
+        if (!this.filled(now, version) && this.begin(now, version) === 0 /* Begin.GENERAL */)
             return this.general(slot);
         if (slot < 0)
             return false;
@@ -206,18 +218,9 @@ export class Lanes {
         const probe = ++this.probes;
         const per = this.per;
         const o = slot * 6 /* Per.SLOT */;
-        let lane = per[o + 0 /* Per.FILLED */] === this.fills && per[o + 2 /* Per.IDLE */] === 0;
-        if (per[o + 1 /* Per.SEEN */] < this.wide && meet(this, slot, subject, head)) {
-            // The fill ran before the subject had these positions. Where every voice it just met folds
-            // after every other laned voice, the general path folds just those onto the lanes' values;
-            // otherwise it reads the general path all frame.
-            if (lane && per[o + 2 /* Per.IDLE */] === 0 && owable(this, slot))
-                this.owed.owe(slot, this.met);
-            else {
-                per[o + 0 /* Per.FILLED */] = 0;
-                lane = false;
-            }
-        }
+        let lane = per[o + 0 /* Per.FILLED */] < this.busyFill && per[o + 2 /* Per.IDLE */] === 0;
+        if (per[o + 1 /* Per.SEEN */] < this.wide)
+            lane = meet(this, slot, subject, head, lane);
         if (lane) {
             per[o + 3 /* Per.LANE_PROBE */] = probe;
             per[o + 5 /* Per.LANE_FILL */] = this.fills;
@@ -283,6 +286,20 @@ export class Lanes {
             this.per[slot * 6 /* Per.SLOT */ + 4 /* Per.GENERAL_PROBE */] = ++this.probes;
         return false;
     }
+    /**
+     * Whether this fill leaves the subject at `slot` to the general path, for not having been probed
+     * this frame or the last: a probe of it before the next fill then takes the general path.
+     */
+    unread(slot) {
+        const per = this.per;
+        const o = slot * 6 /* Per.SLOT */;
+        const lately = this.lately;
+        if (per[o + 3 /* Per.LANE_PROBE */] > lately ||
+            per[o + 4 /* Per.GENERAL_PROBE */] > lately)
+            return false;
+        per[o + 0 /* Per.FILLED */] = this.fills;
+        return true;
+    }
     /** Whether a probe has read the subject since the frame began, on either path. */
     probedThisFrame(slot) {
         const from = this.frameProbes;
@@ -312,6 +329,11 @@ export class Lanes {
     rests(slot) {
         for (const ch of this.laned) {
             const values = ch.values;
+            if (ch.op === 'last') {
+                if (!Number.isNaN(values[slot * ch.axes]))
+                    return false;
+                continue;
+            }
             if (ch.scalar) {
                 if (!(Math.abs(values[slot] - ch.rest) < 1e-9))
                     return false;
@@ -333,6 +355,12 @@ export class Lanes {
         for (let c = 0; c < laned.length; c++) {
             const ch = laned[c];
             const axes = ch.axes;
+            // Never `delete`: it drops a reused out object into dictionary mode for good.
+            if (ch.op === 'last' && Number.isNaN(ch.values[slot * axes])) {
+                if (pose[ch.name] !== undefined)
+                    pose[ch.name] = undefined;
+                continue;
+            }
             if (ch.scalar) {
                 pose[ch.name] = ch.values[slot];
                 continue;
@@ -355,7 +383,7 @@ export class Lanes {
                 if (c.list[p] === slot)
                     unplace(this, c, p);
         if (slot < this.cap)
-            this.per[slot * 6 /* Per.SLOT */ + 0 /* Per.FILLED */] = 0;
+            this.per[slot * 6 /* Per.SLOT */ + 0 /* Per.FILLED */] = this.fills;
         this.subjects[slot] = undefined;
     }
     grow(size) {
@@ -417,6 +445,7 @@ const methods = {
     foldDelta,
     foldRun,
     foldInto,
+    gate,
 };
 for (const [name, value] of Object.entries(methods))
     Object.defineProperty(Lanes.prototype, name, { value, writable: true, configurable: true });

package/dist/locus.d.ts

@@ -1,7 +1,7 @@
 import type { Mixer } from './mixer.js';
 import type { Subject, Voice } from './voice.js';
 /**
- * What a fold with a locus in play gathers, kept from one fold to the next: the influences in
+ * What a fold with a locus in play gathers, kept from one fold to the next: the contributions in
  * voice order, each a voice's own or a locus's first member; every locus member; and per channel
  * slot, a locus's folding value, the weight taken into it and the array it owns.
  */
@@ -11,7 +11,7 @@ export interface LocusScratch<I, O> {
     helds: (Subject<unknown> | null)[];
     deltas: (Record<string, unknown> | null)[];
     weights: number[];
-    /** Per influence, -1 for a voice's own, or which of `names` it is. */
+    /** Per contribution, -1 for a voice's own, or which of `names` it is. */
     groups: number[];
     names: string[];
     m: number;
@@ -32,7 +32,7 @@ export declare function locusScratch<I, O>(channels: number): LocusScratch<I, O>
  */
 export declare function own<I, O>(k: LocusScratch<I, O>, slot: number, value: number[], rest: number[]): number[];
 /**
- * Folds one locus's members into one influence through each channel's own `lerp`: its value per
+ * Folds one locus's members into one contribution through each channel's own `lerp`: its value per
  * channel goes in `k.values`, the channels in `k.touched` in the order first met, and its weight
  * is returned. A channel folding by scale takes its value in an array of `k`'s own, lerped in
  * place, since the fold only reads it.

package/dist/locus.js

@@ -35,7 +35,7 @@ export function own(k, slot, value, rest) {
     return out;
 }
 /**
- * Folds one locus's members into one influence through each channel's own `lerp`: its value per
+ * Folds one locus's members into one contribution through each channel's own `lerp`: its value per
  * channel goes in `k.values`, the channels in `k.touched` in the order first met, and its weight
  * is returned. A channel folding by scale takes its value in an array of `k`'s own, lerped in
  * place, since the fold only reads it.

package/dist/marks.d.ts

@@ -1,5 +1,6 @@
 import type { Listed } from './book.js';
 import type { Mixer } from './mixer.js';
+import type { Transport } from './transport.js';
 import type { Mark } from './types.js';
 import { type Voice } from './voice.js';
 /** The host timestamp the mix clock reads mix time `t` at; Infinity where it never will. */
@@ -8,5 +9,7 @@ export declare function hostOf<I, O>(mix: Mixer<I, O>, t: number): number;
 export declare function readingAt<I, O>(mix: Mixer<I, O>, u: number): number;
 /** Every mark between two host timestamps, earliest first, with the order that tells each apart. */
 export declare function listed<I, O>(mix: Mixer<I, O>, from: number, to: number): Listed[];
+/** Every mark of every mix on a transport and every one announced on it, earliest first. */
+export declare function listedAll(transport: Transport, from: number, to: number): Listed[];
 /** When a voice reaches a mark, mix time, or undefined while nothing has fixed it. */
 export declare function markOf<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, mark: Mark): number | undefined;

package/dist/marks.js

@@ -10,22 +10,52 @@ export function readingAt(mix, u) {
 }
 /** Every mark between two host timestamps, earliest first, with the order that tells each apart. */
 export function listed(mix, from, to) {
-    const lo = from - mix.offset;
-    const hi = to - mix.offset;
+    const out = voiceMarks(mix, from, to);
+    for (const a of announcedMarks(mix.transport, from, to))
+        if (a.score !== undefined || a.slot === mix.slot)
+            out.push(a.listed);
+    return sorted(out);
+}
+/** Every mark of every mix on a transport and every one announced on it, earliest first. */
+export function listedAll(transport, from, to) {
+    const out = [];
+    for (const m of transport.members)
+        out.push(...voiceMarks(m, from, to));
+    for (const a of announcedMarks(transport, from, to))
+        out.push(a.listed);
+    return sorted(out);
+}
+function sorted(out) {
+    return out.sort((a, b) => a.timestamp - b.timestamp || a.order - b.order);
+}
+function announcedMarks(transport, from, to) {
+    const lo = from - transport.offset;
+    const hi = to - transport.offset;
     const out = [];
-    for (const a of mix.announced)
+    for (const a of transport.announced)
         if (a.at >= lo && a.at <= hi)
             out.push({
-                timestamp: a.at + mix.offset,
-                mark: undefined,
-                voice: undefined,
                 score: a.score,
-                name: a.name,
-                tags: a.tags,
-                order: a.order,
+                slot: a.slot,
+                listed: {
+                    timestamp: a.at + transport.offset,
+                    mark: undefined,
+                    voice: undefined,
+                    score: a.score,
+                    name: a.name,
+                    tags: a.tags,
+                    mix: a.mix,
+                    order: a.order,
+                },
             });
+    return out;
+}
+function voiceMarks(mix, from, to) {
+    const lo = from - mix.offset;
+    const hi = to - mix.offset;
+    const out = [];
     for (const voice of [...mix.cued, ...mix.gone]) {
-        for (const mark of ['start', 'in', 'out', 'end']) {
+        for (const mark of ['start', 'in', 'coast', 'out', 'end']) {
             const m = markOf(mix, voice, mark);
             const t = m === undefined ? m : hostOf(mix, m) - mix.offset;
             if (t === undefined || t < lo || t > hi)
@@ -37,11 +67,11 @@ export function listed(mix, from, to) {
                 score: voice.spec.score,
                 name: voice.spec.name,
                 tags: voice.spec.tags ?? none,
+                mix: mix.name,
                 order: voice.id,
             });
         }
     }
-    out.sort((a, b) => a.timestamp - b.timestamp || a.order - b.order);
     return out;
 }
 /** When a voice reaches a mark, mix time, or undefined while nothing has fixed it. */
@@ -56,12 +86,19 @@ export function markOf(mix, voice, mark) {
         return start;
     if (mark === 'in')
         return start + (voice.fade.in ?? 0);
+    if (mark === 'coast')
+        return coastOf(mix, voice, start);
     const out = voice.out;
     let outAt;
     if (out !== null)
         outAt = out.at;
     else if (Number.isFinite(voice.outAt))
         outAt = voice.outAt;
+    else if (voice.fitting !== null) {
+        const t = voice.timeAt(voice.fitting.end);
+        if (Number.isFinite(t))
+            outAt = Math.max(start, t);
+    }
     else if (!voice.freezesAfter && Number.isFinite(voice.span)) {
         const t = voice.timeAt(voice.span + voice.latest);
         if (Number.isFinite(t))
@@ -76,5 +113,36 @@ export function markOf(mix, voice, mark) {
             return out.deadline === undefined ? undefined : out.at + out.deadline;
         return out.at + out.over;
     }
-    return outAt === undefined ? undefined : outAt + (mix.reduced ? 0 : (voice.fade.out ?? 0));
+    const over = Number.isNaN(voice.outOver) ? (voice.fade.out ?? 0) : voice.outOver;
+    return outAt === undefined ? undefined : outAt + (mix.reduced ? 0 : over);
+}
+/**
+ * When a voice's last pass ends, mix time: an owner's when its fit ends, or its last child's. None
+ * for a voice that never ends its passes, or that leaves or begins to fade before they end.
+ */
+function coastOf(mix, voice, start) {
+    if (voice.unplayed)
+        return undefined;
+    let t;
+    if (voice.fitting !== null)
+        t = voice.timeAt(voice.fitting.end);
+    else if (voice.holding !== null) {
+        const children = voice.holding.children;
+        if (children.length === 0)
+            return undefined;
+        t = Number.NEGATIVE_INFINITY;
+        for (const child of children) {
+            const c = markOf(mix, child, 'coast');
+            if (c === undefined)
+                return undefined;
+            t = Math.max(t, c);
+        }
+    }
+    else if (Number.isFinite(voice.span))
+        t = voice.timeAt(voice.span + voice.latest);
+    if (t === undefined || !Number.isFinite(t))
+        return undefined;
+    t = Math.max(start, t);
+    const cut = voice.out !== null ? voice.out.at : voice.state === 'done' ? voice.doneAt : voice.outAt;
+    return cut < t ? undefined : t;
 }

package/dist/meet.d.ts

@@ -9,8 +9,9 @@ import type { Subject } from './voice.js';
 export declare function owable<I, O>(lanes: Lanes<I, O>, slot: number): boolean;
 /**
  * Gives a probed subject a position on every lane that started playing since the subject was last
- * checked and that reaches it. True when any did, so the probe takes the general path.
+ * checked and that reaches it, and says whether the probe still reads the lanes, given `lane`,
+ * whether it would have. Kept out of `prepare`, which V8 then inlines into its callers.
  */
-export declare function meet<I, O>(lanes: Lanes<I, O>, slot: number, subject: I, head: Subject<unknown> | null): boolean;
+export declare function meet<I, O>(lanes: Lanes<I, O>, slot: number, subject: I, head: Subject<unknown> | null, lane: boolean): boolean;
 /** Counts an idle lane more or fewer reaching a subject. */
 export declare function reach<I, O>(lanes: Lanes<I, O>, slot: number, by: number): void;

package/dist/meet.js

@@ -27,9 +27,10 @@ export function owable(lanes, slot) {
 }
 /**
  * Gives a probed subject a position on every lane that started playing since the subject was last
- * checked and that reaches it. True when any did, so the probe takes the general path.
+ * checked and that reaches it, and says whether the probe still reads the lanes, given `lane`,
+ * whether it would have. Kept out of `prepare`, which V8 then inlines into its callers.
  */
-export function meet(lanes, slot, subject, head) {
+export function meet(lanes, slot, subject, head, lane) {
     const seen = lanes.per[slot * 6 /* Per.SLOT */ + 1 /* Per.SEEN */];
     const from = seen < 0 ? -1 - seen : seen;
     lanes.per[slot * 6 /* Per.SLOT */ + 1 /* Per.SEEN */] = lanes.epochs;
@@ -75,7 +76,18 @@ export function meet(lanes, slot, subject, head) {
             lanes.met.push(voice.id);
             met = true;
         }
-    return met;
+    if (!met)
+        return lane;
+    // The fill ran before the subject had these positions. Where every voice it just met folds
+    // after every other laned voice, the general path folds just those onto the lanes' values;
+    // otherwise it reads the general path all frame.
+    const o = slot * 6 /* Per.SLOT */;
+    if (lane && lanes.per[o + 2 /* Per.IDLE */] === 0 && owable(lanes, slot)) {
+        lanes.owed.owe(slot, lanes.met);
+        return true;
+    }
+    lanes.per[o + 0 /* Per.FILLED */] = lanes.fills;
+    return false;
 }
 /** Places a crowd voice's row on the subject a probe met, as `Lane.add` adds a position. */
 function place(lanes, voice, slot, subject, from, head) {

package/dist/mixer.d.ts

@@ -1,20 +1,24 @@
 import { blended, laneRead, shareKept } from './blend.js';
 import type { Book } from './book.js';
-import { aims, chain, linkable } from './chain.js';
+import { aims, chain, linkable, relink } from './chain.js';
 import { type LerpInto } from './channels.js';
 import type { Due } from './due.js';
 import { parting } from './fade.js';
-import { apply, baseFor, clamp, fold, folded, foldLoci, foldWith, influence, isRest, type Key, keyed, linked, owedBy, passes, read, slopeFor, tick } from './fold.js';
+import { apply, baseFor, clamp, contribution, fold, folded, foldLoci, foldWith, isRest, type Key, keyed, linked, owedBy, passes, read, slopeFor, tick } from './fold.js';
 import type { HandleHost } from './handle.js';
 import { held, shownOf, sinceOf, unreachedOf } from './held.js';
 import { Lanes } from './lanes.js';
 import { foldLocus, type LocusScratch } from './locus.js';
-import type { MotionOwner, Motions } from './motion.js';
-import { Pace } from './pace.js';
+import type { MotionOwner, Motions } from './motions.js';
+import type { Pace } from './pace.js';
+import { Keys } from './paging.js';
 import { keep } from './pull.js';
 import { Steps } from './relink.js';
+import { Outs } from './revive.js';
+import { Fitting } from './spans.js';
 import { Store } from './store.js';
-import type { Booker, BookOptions, Channel, Columns, Engine, Handle, Kit, Marked, Mix, MixOptions, OwnerSpec, Patch, Projection, Sent, Signal, VoiceSpec } from './types.js';
+import { type Announced, Transport } from './transport.js';
+import type { Booker, BookOptions, Channel, Columns, Engine, Handle, Kit, Marked, Mix, MixOptions, OwnerSpec, Patch, Projection, Sent, Signal, SpanHandle, SpanSpec, Tape, VoiceSpec } from './types.js';
 import { type Subject, type Voice } from './voice.js';
 import { base, capped, fadeOf, horizonFor, ownedBy, ownerBase, prime, weigh, weighOwned } from './weigh.js';
 export declare class Mixer<I, O> implements Mix<I, O> {
@@ -37,19 +41,6 @@ export declare class Mixer<I, O> implements Mix<I, O> {
         at: number;
         fields: Record<string, unknown>;
     }[];
-    /**
-     * Marks the host announced on a score: `at` in host time, so the mix's 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.
-     */
-    announced: {
-        name: string;
-        score: string | undefined;
-        tags: readonly string[];
-        at: number;
-        made: number;
-        order: number;
-    }[];
     hostThen: {
         fields: Record<string, unknown>;
     } | undefined;
@@ -60,22 +51,17 @@ export declare class Mixer<I, O> implements Mix<I, O> {
         prev: O | undefined;
         prevAt: number;
     }>;
-    nextId: number;
-    /**
-     * The mix clock: host time at the mix's rate. Host time is the host's timestamp less every gap
-     * `rebase` has taken out, `u` at the last sync.
-     */
-    now: number;
-    u: number;
+    /** The clock this mix plays on, which also holds its tape and the marks announced on it. */
+    readonly transport: Transport;
+    /** Its place among the mixes on its transport, in the order they joined. */
+    slot: number;
+    /** Taken off its transport, so it takes no more calls until a seek puts it back. */
+    dropped: boolean;
+    readonly name: string | undefined;
     /** This mix's frame among every mix's: moved by a sync, and by a control change or drop within one. */
     frame: number;
-    offset: number;
-    /** The mix's own rate; null while it has never been set, when mix time is host time. */
-    pace: Pace | null;
     /** Pending voices whose start the host gave, by its host time, kept where the rate puts it. */
     pins: Map<Voice<I, O>, number> | null;
-    last: number;
-    rebasing: boolean;
     wantsPose: boolean;
     /** The pose `pull` folds a subject into where it cannot read straight from the lanes. */
     scratch: O | undefined;
@@ -110,7 +96,7 @@ export declare class Mixer<I, O> implements Mix<I, O> {
      * where none does. Relinked when `version` moves, which is whenever the list or a voice's pending
      * state changes.
      */
-    readonly chains: Store<I, Subject<unknown>>;
+    chains: Store<I, Subject<unknown>>;
     version: number;
     readonly steps: Steps<Voice<I, O>>;
     /** Per subject, the voices whose `subjects` name it, in voice order. */
@@ -143,7 +129,9 @@ export declare class Mixer<I, O> implements Mix<I, O> {
         subject: I;
     };
     readonly send: (event: unknown) => void;
-    /** The weight `influence` found besides the delta, read by the caller at once. */
+    /** The moment a seek went back to: what is stepped again up to it was sent the first time. */
+    sentTo: number;
+    /** The weight `contribution` found besides the delta, read by the caller at once. */
     w: number;
     readonly names: Key<O>[];
     readonly channels: Channel<unknown>[];
@@ -155,13 +143,36 @@ export declare class Mixer<I, O> implements Mix<I, O> {
     readonly locusScratch: LocusScratch<I, O>[];
     locusDepth: number;
     readonly slotOf: Map<string, number>;
-    readonly lanes: Lanes<I, O> | null;
+    lanes: Lanes<I, O> | null;
     handles: HandleHost<I, O> | null;
     /** What `book` made, still booking; null while there is none. */
     bookers: Book<I, O>[] | null;
+    /** The fit a span being cued takes, which `cue` hands its voice. */
+    fitting: Fitting | null;
     /** Every owner still in the mix, null until one is cued. */
     owners: Voice<I, O>[] | null;
+    /** With a history store, the key each subject is paged under; null without one. */
+    keys: Keys | null;
+    /** With a history store, the voices it paged out whose handles are still held; null without one. */
+    outs: Outs | null;
     constructor(kit: Kit<O>, opts: MixOptions);
+    /** Throws where the clock is a shared transport's, which only the transport moves. */
+    private own;
+    get now(): number;
+    set now(v: number);
+    get u(): number;
+    set u(v: number);
+    get offset(): number;
+    set offset(v: number);
+    get pace(): Pace | null;
+    set pace(v: Pace | null);
+    get announced(): Announced[];
+    set announced(v: Announced[]);
+    get nextId(): number;
+    set nextId(v: number);
+    get last(): number;
+    get tape(): Tape | undefined;
+    get replaying(): boolean;
     get reduced(): boolean;
     get band(): {
         on: number;
@@ -170,17 +181,21 @@ export declare class Mixer<I, O> implements Mix<I, O> {
     cue(spec: VoiceSpec<I, O>): Handle<I>;
     blend(patches: readonly Patch<I, O, unknown>[], by: Signal<I>, spec?: Omit<VoiceSpec<I, O>, 'patch' | 'weight' | 'locus'>): Handle<I>[];
     owns(spec: OwnerSpec<I>): Handle<I>;
+    span(spec: SpanSpec<I>): SpanHandle<I>;
     sync(timestamp: number): void;
-    private syncAt;
     book(opts: BookOptions): Booker;
     probe(subject: I, out?: O): O;
     pull(subjects: Iterable<I>, into: Columns<O>): void;
-    project(timestamp: number): Projection<I, O>;
+    seek(time: number): void;
+    prepare(time: number): Promise<void>;
+    project(time: number): Projection<I, O>;
     announce(name: string, opts?: {
         at?: number;
         score?: string;
         tags?: readonly string[];
     }): void;
+    /** Throws for a mix taken off its transport. */
+    attached(): void;
     marks(from: number, to: number): Marked[];
     atRest(subject: I): boolean;
     rests(pose: O): boolean;
@@ -225,7 +240,7 @@ declare const methods: {
     owedBy: typeof owedBy;
     foldLoci: typeof foldLoci;
     read: typeof read;
-    influence: typeof influence;
+    contribution: typeof contribution;
     keyed: typeof keyed;
     tick: typeof tick;
     apply: typeof apply;
@@ -248,6 +263,7 @@ declare const methods: {
     shareKept: typeof shareKept;
     parting: typeof parting;
     chain: typeof chain;
+    relink: typeof relink;
     linkable: typeof linkable;
     aims: typeof aims;
     held: typeof held;