@msb235/blits 0.7.1 → 0.8.0

package/dist/meet.js

@@ -8,21 +8,27 @@ export function owable(lanes, slot) {
     if (lanes.metCrowd || lanes.owes(slot))
         return false;
     // Subjects meeting the same lanes in one fill get the same answer, and a list is kept only once true.
-    if (lanes.owed.last(lanes.met))
-        return true;
     const met = lanes.met;
+    const n = lanes.metN;
+    if (lanes.owed.last(met, n))
+        return true;
     let other = Number.NEGATIVE_INFINITY;
     for (const lane of lanes.lanes) {
         const id = lane.voice.id;
-        if (id > other && !met.includes(id))
+        if (id <= other)
+            continue;
+        const at = met.indexOf(id);
+        if (at < 0 || at >= n)
             other = id;
     }
     for (const c of lanes.crowds)
         if (c.size > 0)
             other = Math.max(other, c.hot[(c.size - 1) * c.stride + 7 /* Hot.ID */]);
-    for (const id of met)
+    for (let i = 0; i < n; i++) {
+        const id = met[i];
         if (id <= other || lanes.byId.get(id).group !== null)
             return false;
+    }
     return true;
 }
 /**
@@ -35,7 +41,7 @@ export function meet(lanes, slot, subject, head, lane) {
     const from = seen < 0 ? -1 - seen : seen;
     lanes.per[slot * 6 /* Per.SLOT */ + 1 /* Per.SEEN */] = lanes.epochs;
     let met = false;
-    lanes.met.length = 0;
+    lanes.metN = 0;
     lanes.metCrowd = false;
     const dense = lanes.dense;
     for (let i = dense.length - 1; i >= 0; i--) {
@@ -50,7 +56,7 @@ export function meet(lanes, slot, subject, head, lane) {
         lane.add(slot, held);
         if (lane.idle)
             reach(lanes, slot, 1);
-        lanes.met.push(lane.voice.id);
+        lanes.met[lanes.metN++] = lane.voice.id;
         met = true;
     }
     // `open` marks every subject a voice naming it starts on, so an unmarked one has none to meet.
@@ -73,7 +79,7 @@ export function meet(lanes, slot, subject, head, lane) {
             lane.add(slot, held);
             if (lane.idle)
                 reach(lanes, slot, 1);
-            lanes.met.push(voice.id);
+            lanes.met[lanes.metN++] = voice.id;
             met = true;
         }
     if (!met)
@@ -83,7 +89,7 @@ export function meet(lanes, slot, subject, head, lane) {
     // 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);
+        lanes.owed.owe(slot, lanes.met, lanes.metN);
         return true;
     }
     lanes.per[o + 0 /* Per.FILLED */] = lanes.fills;

package/dist/mixer.d.ts

@@ -2,9 +2,10 @@ import { blended, laneRead, shareKept } from './blend.js';
 import type { Book } from './book.js';
 import { aims, chain, linkable, relink } from './chain.js';
 import { type LerpInto } from './channels.js';
+import { DepartedIndex } from './departed.js';
 import type { Due } from './due.js';
 import { parting } from './fade.js';
-import { apply, baseFor, clamp, contribution, fold, folded, foldLoci, foldWith, isRest, type Key, keyed, linked, owedBy, passes, read, slopeFor, tick } from './fold.js';
+import { apply, baseFor, clamp, contribution, fold, foldDetour, folded, foldLoci, foldSharers, foldWith, isRest, type Key, keyed, linked, owedBy, passes, read, shared, slopeFor, tick } from './fold.js';
 import { GoneIndex } from './gone.js';
 import type { HandleHost } from './handle.js';
 import { held, shownOf, sinceOf, unreachedOf } from './held.js';
@@ -23,6 +24,13 @@ 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';
+/**
+ * What a mix takes where its options say nothing. Not exported from the package: the suite turns
+ * `lanes` off to run every test on the general path, which is what makes each one an equivalence check.
+ */
+export declare const defaults: {
+    lanes: boolean;
+};
 export declare class Mixer<I, O> implements Mix<I, O> {
     readonly kit: Kit<O>;
     readonly opts: MixOptions;
@@ -37,12 +45,18 @@ export declare class Mixer<I, O> implements Mix<I, O> {
     backward: boolean;
     /** True during a sync, so a control change it makes is recorded as showing in that frame. */
     moving: boolean;
+    /**
+     * Whether a probe or pull has read the mix since its clock last moved. A control change made
+     * before that shows in this frame live, so it is recorded as showing in it.
+     */
+    looked: boolean;
     /**
      * Under `history` with `inputs`, the host fields patches read, copied each frame they changed. In
      * a projection reading back, the copy in force then.
      */
     hostLog: {
         at: number;
+        seq: number;
         fields: Record<string, unknown>;
     }[];
     hostThen: {
@@ -62,20 +76,23 @@ export declare class Mixer<I, O> implements Mix<I, O> {
     /** 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. */
+    /**
+     * This mix's frame among every mix's: moved by a sync or seek, and by a control change, drop,
+     * or touch within one.
+     */
     frame: number;
     /** Pending voices whose start the host gave, by its host time, kept where the rate puts it. */
     pins: Map<Voice<I, O>, number> | null;
     wantsPose: boolean;
     /** The pose `pull` folds a subject into where it cannot read straight from the lanes. */
     scratch: O | undefined;
-    /** The last array `pull` read, by position, with each subject's chain head, to skip the lookup. */
     /** Live voices by the earliest mix time `moveTo` would change each, a binary heap. */
     due: Due<I, O>[];
     /** Voices retired since `moveTo` last pruned them, in the order they retired. */
     retired: Voice<I, O>[];
     /** Visit every voice each sync, as before the due queue; for tests that compare the two. */
     walkAll: boolean;
+    /** The last array `pull` read, by position, with each subject's chain head, to skip the lookup. */
     pulled: I[];
     pulledHeads: (Subject<unknown> | undefined)[];
     /** Each remembered head's lane slot, and the `version` and `relinks` they were all current at. */
@@ -97,16 +114,18 @@ export declare class Mixer<I, O> implements Mix<I, O> {
     onWake(fn: () => void): () => void;
     /**
      * Per subject, the first record of the chain through every live voice that reaches it, or a stub
-     * where none does. Relinked when `version` moves, which is whenever the list or a voice's pending
-     * state changes.
+     * where none does. Relinked when `version` moves, or when a voice naming the subject marks its
+     * head stale: see `changed` in `chain.ts`.
      */
     chains: Store<I, Subject<unknown>>;
     version: number;
-    readonly steps: Steps<Voice<I, O>>;
+    readonly steps: Steps<Voice<I, O>, I>;
     /** Per subject, the voices whose `subjects` name it, in voice order. */
     named: Store<I, Voice<I, O>[]>;
     /** Voices a subject has been faded out of, which `drop` looks in besides those that reach it. */
     readonly parters: Set<Voice<I, O>>;
+    /** What an anchor can still find of voices that left without history, or past its reach. */
+    readonly departed: DepartedIndex;
     /**
      * Motion patches that may hold state for a subject no voice still reaching it plays, which `drop`
      * frees besides those voices' own: per subject, a patch a voice naming it left while another
@@ -120,6 +139,15 @@ export declare class Mixer<I, O> implements Mix<I, O> {
     naming: number;
     /** The voices in the list that name no subjects, in voice order. */
     general: Voice<I, O>[];
+    /** Those of `general` that keep one record for every subject, in voice order: see `everyone.ts`. */
+    sharers: Voice<I, O>[];
+    /**
+     * Whether a voice stopped sharing this frame: a probe or pull under way then holds chains linked
+     * before it joined them, and takes each again.
+     */
+    unshared: boolean;
+    /** 0 where a fold is a walk of the chain: see `detour` in `everyone.ts`. */
+    detours: number;
     /** How many voices in the list carry a locus; with none, a fold allocates nothing. */
     loci: number;
     /** What every motion patch it plays asks for its voice's time, holding this mix weakly. */
@@ -216,6 +244,7 @@ export declare class Mixer<I, O> implements Mix<I, O> {
         over?: number;
     }): void;
     drop(subject: I): void;
+    touch(subject?: I): void;
     drain<E = unknown>(tag?: string): Sent<I, E>[];
     /** Voices whose stop 0 is mid-computation, so a fold for one cannot re-enter itself. */
     readonly folding: Set<number>;
@@ -225,7 +254,7 @@ export declare class Mixer<I, O> implements Mix<I, O> {
      * is first asked, when probes start writing it.
      */
     restStamps: Store<I, number> | null;
-    /** What a probe's record of rest is good for: moved by a new frame, version or relink. */
+    /** What a probe's record of rest is good for: moved by a new frame, version, relink, or stir. */
     private restsEpoch;
     private restsFrame;
     private restsVersion;
@@ -243,6 +272,9 @@ declare const methods: {
     foldWith: typeof foldWith;
     owedBy: typeof owedBy;
     foldLoci: typeof foldLoci;
+    foldDetour: typeof foldDetour;
+    foldSharers: typeof foldSharers;
+    shared: typeof shared;
     read: typeof read;
     contribution: typeof contribution;
     keyed: typeof keyed;

package/dist/mixer.js

@@ -2,8 +2,9 @@ import { blended, blendOf, laneRead, shareKept } from './blend.js';
 import { aims, chain, linkable, relink } from './chain.js';
 import { lerpInto } from './channels.js';
 import { cue } from './cue.js';
-import { beginFade, parting } from './fade.js';
-import { apply, baseFor, clamp, contribution, fold, folded, foldLoci, foldWith, isRest, keyed, linked, near, owedBy, passes, read, slopeFor, tick, } from './fold.js';
+import { DepartedIndex } from './departed.js';
+import { beginFade, leftWith, parting } from './fade.js';
+import { apply, baseFor, clamp, contribution, fold, foldDetour, folded, foldLoci, foldSharers, foldWith, isRest, keyed, linked, near, owedBy, passes, read, shared, slopeFor, tick, } from './fold.js';
 import { GoneIndex, goneIndex } from './gone.js';
 import { held, shownOf, sinceOf, unreachedOf } from './held.js';
 import { leave, releasing } from './history.js';
@@ -23,9 +24,15 @@ import { seek } from './seek.js';
 import { Fitting, refit } from './spans.js';
 import { Store } from './store.js';
 import { record } from './tape.js';
+import { touch } from './touch.js';
 import { announce, Transport } from './transport.js';
 import { none } from './voice.js';
 import { base, capped, fadeOf, horizonFor, ownedBy, ownerBase, prime, weigh, weighOwned, } from './weigh.js';
+/**
+ * What a mix takes where its options say nothing. Not exported from the package: the suite turns
+ * `lanes` off to run every test on the general path, which is what makes each one an equivalence check.
+ */
+export const defaults = { lanes: true };
 // biome-ignore lint/suspicious/noUnsafeDeclarationMerging: every member of `Methods` is installed below
 export class Mixer {
     kit;
@@ -41,6 +48,11 @@ export class Mixer {
     backward = false;
     /** True during a sync, so a control change it makes is recorded as showing in that frame. */
     moving = false;
+    /**
+     * Whether a probe or pull has read the mix since its clock last moved. A control change made
+     * before that shows in this frame live, so it is recorded as showing in it.
+     */
+    looked = false;
     /**
      * Under `history` with `inputs`, the host fields patches read, copied each frame they changed. In
      * a projection reading back, the copy in force then.
@@ -56,20 +68,23 @@ export class Mixer {
     /** Taken off its transport, so it takes no more calls until a seek puts it back. */
     dropped = false;
     name;
-    /** This mix's frame among every mix's: moved by a sync, and by a control change or drop within one. */
+    /**
+     * This mix's frame among every mix's: moved by a sync or seek, and by a control change, drop,
+     * or touch within one.
+     */
     frame = nextFrame();
     /** Pending voices whose start the host gave, by its host time, kept where the rate puts it. */
     pins = null;
     wantsPose = false;
     /** The pose `pull` folds a subject into where it cannot read straight from the lanes. */
     scratch;
-    /** The last array `pull` read, by position, with each subject's chain head, to skip the lookup. */
     /** Live voices by the earliest mix time `moveTo` would change each, a binary heap. */
     due = [];
     /** Voices retired since `moveTo` last pruned them, in the order they retired. */
     retired = [];
     /** Visit every voice each sync, as before the due queue; for tests that compare the two. */
     walkAll = false;
+    /** The last array `pull` read, by position, with each subject's chain head, to skip the lookup. */
     pulled = [];
     pulledHeads = [];
     /** Each remembered head's lane slot, and the `version` and `relinks` they were all current at. */
@@ -89,6 +104,9 @@ export class Mixer {
     /** Records a change to the mix's voices or controls. */
     stir() {
         this.stirs++;
+        // A change a sync makes follows from the clock; one a host makes does not.
+        if (!this.moving)
+            this.transport.settle();
         if (this.stirred)
             return;
         this.stirred = true;
@@ -113,8 +131,8 @@ export class Mixer {
     }
     /**
      * Per subject, the first record of the chain through every live voice that reaches it, or a stub
-     * where none does. Relinked when `version` moves, which is whenever the list or a voice's pending
-     * state changes.
+     * where none does. Relinked when `version` moves, or when a voice naming the subject marks its
+     * head stale: see `changed` in `chain.ts`.
      */
     chains = new Store();
     version = 0;
@@ -123,6 +141,8 @@ export class Mixer {
     named = new Store();
     /** Voices a subject has been faded out of, which `drop` looks in besides those that reach it. */
     parters = new Set();
+    /** What an anchor can still find of voices that left without history, or past its reach. */
+    departed = new DepartedIndex();
     /**
      * Motion patches that may hold state for a subject no voice still reaching it plays, which `drop`
      * frees besides those voices' own: per subject, a patch a voice naming it left while another
@@ -136,6 +156,15 @@ export class Mixer {
     naming = 0;
     /** The voices in the list that name no subjects, in voice order. */
     general = [];
+    /** Those of `general` that keep one record for every subject, in voice order: see `everyone.ts`. */
+    sharers = [];
+    /**
+     * Whether a voice stopped sharing this frame: a probe or pull under way then holds chains linked
+     * before it joined them, and takes each again.
+     */
+    unshared = false;
+    /** 0 where a fold is a walk of the chain: see `detour` in `everyone.ts`. */
+    detours = 0;
     /** How many voices in the list carry a locus; with none, a fold allocates nothing. */
     loci = 0;
     /** What every motion patch it plays asks for its voice's time, holding this mix weakly. */
@@ -196,7 +225,7 @@ export class Mixer {
         this.names.forEach((k, i) => {
             this.slotOf.set(k, i);
         });
-        this.lanes = opts.lanes === false ? null : new Lanes(laneHost(this));
+        this.lanes = (opts.lanes ?? defaults.lanes) ? new Lanes(laneHost(this)) : null;
         this.name = opts.name;
         const shared = opts.transport;
         if (shared !== undefined) {
@@ -315,6 +344,7 @@ export class Mixer {
         return book(this, opts);
     }
     probe(subject, out) {
+        this.looked = true;
         const pose = this.fold(subject, out);
         this.keep(subject, pose, out);
         // Where the lanes answer `atRest` from their own values, there is nothing to keep.
@@ -323,6 +353,7 @@ export class Mixer {
         return pose;
     }
     pull(subjects, into) {
+        this.looked = true;
         pull(this, subjects, into);
     }
     seek(time) {
@@ -431,8 +462,10 @@ export class Mixer {
         return motion !== undefined && voice.elapsedAt(now) >= voice.latest && motion.landed();
     }
     mute(opts) {
-        for (const voice of this.cued)
+        for (const voice of this.cued) {
+            voice.written = true;
             beginFade(this, voice, { over: opts?.over });
+        }
         record(this, 'mute', () => this.mute(opts));
     }
     drop(subject) {
@@ -453,7 +486,7 @@ export class Mixer {
         // of a voice that does not name it is in `parters`, and a patch's own state in `motions`.
         const kept = releasing(this);
         const forget = (voice) => {
-            leave(this, voice, subject, voice.subjects.get(subject));
+            leave(this, voice, subject, leftWith(this, voice, subject));
             voice.subjects.delete(subject);
             voice.motion?.release(subject, ...kept);
             voice.parts?.delete(subject);
@@ -494,6 +527,10 @@ export class Mixer {
             motion.release(subject, ...kept);
         record(this, 'drop', () => this.drop(subject));
     }
+    touch(subject) {
+        this.attached();
+        touch(this, subject);
+    }
     drain(tag) {
         const all = this.sent;
         if (all.length === 0)
@@ -518,7 +555,7 @@ export class Mixer {
      * is first asked, when probes start writing it.
      */
     restStamps = null;
-    /** What a probe's record of rest is good for: moved by a new frame, version or relink. */
+    /** What a probe's record of rest is good for: moved by a new frame, version, relink, or stir. */
     restsEpoch = 0;
     restsFrame = Number.NaN;
     restsVersion = Number.NaN;
@@ -552,6 +589,9 @@ const methods = {
     foldWith,
     owedBy,
     foldLoci,
+    foldDetour,
+    foldSharers,
+    shared,
     read,
     contribution,
     keyed,

package/dist/motion.d.ts

@@ -33,6 +33,8 @@ export type Moving<I, O, V extends Value> = Patch<I, O, void> & {
      * Where `subject` is and how fast it moves at voice time `at`, default the mix's latest frame,
      * counting every change due by then. With no time given, undefined until a frame of its voice
      * has met the subject, while the subject is still inside its stagger, and once that voice is gone.
+     * At any time, undefined for a subject the patch has never met or changed, or that the mix
+     * dropped.
      */
     read(subject: I, at?: number): Motion<V> | undefined;
     /**

package/dist/motion.js

@@ -26,7 +26,6 @@ class MotionPatch {
     }
     form = 'motion';
     duration = 0;
-    period = 0;
     get motion() {
         return this.motions.spec();
     }
@@ -191,6 +190,8 @@ export function spring(writes, opts) {
     const k = opts.stiffness ?? 170;
     const c = opts.damping ?? 26;
     const m = opts.mass ?? 1;
+    if (!(k > 0) || !(m > 0) || !(c >= 0))
+        throw new RangeError('blits: a spring takes a positive stiffness and mass, and damping of 0 or more');
     const settle = opts.settle ?? 1e-4;
     const w0 = Math.sqrt(k / m);
     const zeta = c / (2 * Math.sqrt(k * m));
@@ -215,6 +216,8 @@ export function spring(writes, opts) {
  */
 export function glide(writes, opts) {
     const ms = opts.ms ?? 325;
+    if (!(ms > 0))
+        throw new RangeError('blits: a glide takes a positive ms');
     const tau = ms / 1000;
     const settle = opts.settle ?? 1e-4;
     const shape = new GlideShape([COAST, settle, tau, 0, 0], { kind: 'glide', ms, settle }, opts, tau);

package/dist/motions.d.ts

@@ -23,6 +23,8 @@ export interface Change {
     v?: number[];
     /** The mix clock when it was made, NaN where no mix was playing the patch. */
     made?: number;
+    /** The frame it was made in, which a rewind partitions by; NaN where no mix was playing the patch. */
+    seq?: number;
 }
 /**
  * The mix playing a patch, asked with its voice's id: an owner and an id, where a pair of closures
@@ -35,6 +37,8 @@ export interface MotionOwner {
     revive(id: number, subject: unknown): void;
     /** The mix clock at its latest frame; NaN before the first. */
     now(): number;
+    /** The number of the frame the mix is playing. */
+    seq(): number;
     /**
      * The host made a change, already given its time, which a seek makes again on the patch its
      * voice plays then: a voice a history store paged out comes back with a patch of its own.
@@ -43,9 +47,10 @@ export interface MotionOwner {
     /** History leaving memory for a subject, which a mix with a history store pages out. */
     page(id: number, stream: 'released' | 'stretch', subject: unknown, out: Paging[]): void;
 }
-/** A record of a motion patch's history leaving memory, at a mix time. */
+/** A record of a motion patch's history leaving memory, at a mix time and frame. */
 export interface Paging {
     at: number;
+    seq: number;
     data: unknown;
 }
 /** A subject's run as plain data: its flags, its stretches oldest first, and changes still to apply. */
@@ -75,7 +80,7 @@ export interface Shape<I> {
     scalarEvery(): boolean | undefined;
     /** A tween's easing, which its law cannot hold; undefined, but present, on every other shape. */
     ease: Curve | undefined;
-    /** A tween's seconds for a stretch the subject starts now; undefined, but present, on the rest. */
+    /** A tween's ms for a stretch the subject starts now; undefined, but present, on the rest. */
     ms: ((subject: I) => number) | undefined;
     /** The patch's kind and constants, as `Patch.motion` reports them. */
     spec(): MotionSpec;
@@ -86,7 +91,7 @@ export interface Shape<I> {
  * The one copy, read by `at` and by a mix's lane alike.
  *
  * After the law, each subject's run of `stride` numbers is its release time, its flags, a tween's
- * seconds for the stretch, then `x0`, `v0` and `to` per axis. A live sample reads this one buffer and nothing else the patch owns: at
+ * ms for the stretch, then `x0`, `v0` and `to` per axis. A live sample reads this one buffer and nothing else the patch owns: at
  * 10k springs of one subject each, a buffer per field, a map lookup per sample and the law in an
  * object of its own took a call from 130 ns to 490.
  */
@@ -95,6 +100,8 @@ export declare class Motions<I> {
     private readonly numbers;
     /** Numbers by subject once a second is numbered: till then the one subject is found by `numbers`. */
     private readonly slots;
+    /** How many numbers have been given up, so a number kept elsewhere can tell it is stale. */
+    freed: number;
     /** Axes per subject; -1 until the first subject sets it. */
     n: number;
     private cap;
@@ -149,11 +156,11 @@ export declare class Motions<I> {
      */
     private released;
     /**
-     * Forgets a subject, so a later ask starts it afresh from `from`. Given the mix time `at`, under
-     * history, its run is kept for a rewind before then, until `reach` passes it.
+     * Forgets a subject, so a later ask starts it afresh from `from`. Given the mix time `at` and frame
+     * `seq`, under history, its run is kept for a rewind before then, until `reach` passes it.
      */
-    release(subject: I, at?: number, reach?: number): void;
-    /** Puts back each subject released after mix time `t`, as it stood when released. */
+    release(subject: I, at?: number, reach?: number, seq?: number): void;
+    /** Puts back each subject released after frame `seq`, as it stood when released. */
     private unrelease;
     /** Subject `s`'s run as it stands. */
     private runAt;
@@ -162,9 +169,9 @@ export declare class Motions<I> {
     /** Puts a subject's run back as `pack` or a release left it, replacing any it has now. */
     unpack(subject: I, run: Run): void;
     /** A released run a history store gave back, for a rewind to before its release. */
-    reclaim(subject: I, at: number, run: Run): void;
+    reclaim(subject: I, at: number, seq: number, run: Run): void;
     /**
-     * Stretches a history store gave back, each by the mix time it was in force by: each life of the
+     * Stretches a history store gave back, each by the frame it was in force by: each life of the
      * subject, ended by a release, takes those from its own, ahead of the earliest it still keeps.
      */
     restretch(subject: I, back: readonly Paging[]): void;
@@ -184,7 +191,7 @@ export declare class Motions<I> {
     /** Whether `law` holds this patch's law, number for number, as `Object.is` compares them. */
     hasLaw(law: Float64Array): boolean;
     /**
-     * Copies subject `s`'s current stretch into `out` from `o` as its release time, its seconds, then
+     * Copies subject `s`'s current stretch into `out` from `o` as its release time, its ms, then
      * `x0`, `v0` and `to` per axis; false, copying nothing, while it has a change pending or an
      * earlier stretch kept, which only `sample` handles.
      */
@@ -200,7 +207,7 @@ export declare class Motions<I> {
      */
     sample(s: number, t: number, xo: Float64Array, vo: Float64Array): void;
     /**
-     * Where subject `s`'s run starts in `runs` (its release time, then flags, seconds, `x0`, `v0`
+     * Where subject `s`'s run starts in `runs` (its release time, then flags, ms, `x0`, `v0`
      * and `to`) while it has nothing pending and no earlier stretch kept; -1 for any other.
      */
     bareAt(s: number): number;
@@ -238,10 +245,10 @@ export declare class Motions<I> {
     private flag;
     forget(s: number): void;
     /**
-     * Takes back every change made after mix time `t`: each subject plays from its earliest stretch
+     * Takes back every change made after frame `seq`: each subject plays from its earliest stretch
      * kept, with the changes made by then queued to be applied again.
      */
-    rewind(t: number): void;
+    rewind(seq: number): void;
     private cut;
     /** Where subject `s`'s run starts in `runs`. */
     base(s: number): number;
@@ -255,8 +262,8 @@ export declare class Motions<I> {
     private commit;
     private insert;
     /**
-     * The mix time a stretch was in force by, which a store keys it under: when the change that
-     * ended it was made, which falls in the same life of the subject.
+     * The mix time and frame a stretch was in force by, which a store keys it under: when the change
+     * that ended it was made, which falls in the same life of the subject.
      */
     private made;
     /** Lets go of stretches older than the one in force at `reading.horizon`. */