@msb235/blits 0.9.0 → 0.11.0

package/dist/marks.js

@@ -1,5 +1,20 @@
+import { inPass } from './book.js';
 import { startOf } from './place.js';
 import { none } from './voice.js';
+/** A voice's marks, in the order `marks` lists those at one time. */
+export const voiceMarks = ['start', 'in', 'coast', 'out', 'end'];
+/** Refuses marks placed inside a voice under one of its own five names, or that it could never reach. */
+export function checkMarks(marks, duration) {
+    for (const name of Object.keys(marks)) {
+        if (voiceMarks.includes(name))
+            throw new Error(`blits: ${name} is one of a voice's own marks; a mark placed inside it needs another name`);
+        const at = marks[name];
+        if (!inPass(at, duration))
+            throw new RangeError(duration > 0
+                ? `blits: mark ${name} is voice ms into a pass, 0 up to ${duration}, not ${at}`
+                : `blits: mark ${name} is voice ms, 0 or more, not ${at}`);
+    }
+}
 /** The host timestamp the mix clock reads mix time `t` at; Infinity where it never will. */
 export function hostOf(mix, t) {
     return (mix.pace === null ? t : mix.pace.timeOf(t)) + mix.offset;
@@ -10,7 +25,7 @@ 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 out = voiceMarks(mix, from, to);
+    const out = marksOf(mix, from, to);
     for (const a of announcedMarks(mix.transport, from, to))
         if (a.score !== undefined || a.slot === mix.slot)
             out.push(a.listed);
@@ -20,7 +35,7 @@ export function listed(mix, from, to) {
 export function listedAll(transport, from, to) {
     const out = [];
     for (const m of transport.members)
-        out.push(...voiceMarks(m, from, to));
+        out.push(...marksOf(m, from, to));
     for (const a of announcedMarks(transport, from, to))
         out.push(a.listed);
     return sorted(out);
@@ -50,30 +65,36 @@ function announcedMarks(transport, from, to) {
             });
     return out;
 }
-function voiceMarks(mix, from, to) {
+function marksOf(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', '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)
-                continue;
-            out.push({
-                timestamp: t + mix.offset,
-                mark,
-                voice: voice.id,
-                score: voice.spec.score,
-                name: voice.spec.name,
-                tags: voice.spec.tags ?? none,
-                mix: mix.name,
-                order: voice.id,
-            });
-        }
+        for (const mark of voiceMarks)
+            listOne(mix, voice, mark, lo, hi, out);
+        const inner = voice.spec.marks;
+        if (inner !== undefined)
+            for (const mark of Object.keys(inner))
+                listOne(mix, voice, mark, lo, hi, out);
     }
     return out;
 }
+function listOne(mix, voice, mark, lo, hi, out) {
+    const m = markOf(mix, voice, mark);
+    const t = m === undefined ? m : hostOf(mix, m) - mix.offset;
+    if (t === undefined || t < lo || t > hi)
+        return;
+    out.push({
+        timestamp: t + mix.offset,
+        mark,
+        voice: voice.id,
+        score: voice.spec.score,
+        name: voice.spec.name,
+        tags: voice.spec.tags ?? none,
+        mix: mix.name,
+        order: voice.id,
+    });
+}
 /** When a voice reaches a mark, mix time, or undefined while nothing has fixed it. */
 export function markOf(mix, voice, mark) {
     if (!Number.isFinite(voice.start))
@@ -88,8 +109,12 @@ export function markOf(mix, voice, mark) {
         return start + (voice.fade.in ?? 0);
     if (mark === 'coast')
         return coastOf(mix, voice, start);
+    if (mark !== 'out' && mark !== 'end')
+        return insideOf(mix, voice, start, mark);
     const out = voice.out;
     let outAt;
+    // An owner leaves with its last child, over no fade of its own.
+    let leaves = false;
     if (out !== null)
         outAt = out.at;
     else if (Number.isFinite(voice.outAt))
@@ -99,6 +124,13 @@ export function markOf(mix, voice, mark) {
         if (Number.isFinite(t))
             outAt = Math.max(start, t);
     }
+    else if (voice.holding !== null) {
+        const t = lastChild(mix, voice.holding.children, 'end');
+        if (t !== undefined) {
+            outAt = Math.max(start, t);
+            leaves = true;
+        }
+    }
     else if (!(voice.backs ? voice.freezesBefore : voice.freezesAfter)) {
         const t = voice.endsAt();
         if (Number.isFinite(t))
@@ -113,9 +145,38 @@ export function markOf(mix, voice, mark) {
             return out.deadline === undefined ? undefined : out.at + out.deadline;
         return out.at + out.over;
     }
+    if (leaves)
+        return outAt;
     const over = Number.isNaN(voice.outOver) ? (voice.fade.out ?? 0) : voice.outOver;
     return outAt === undefined ? undefined : outAt + (mix.reduced ? 0 : over);
 }
+/** Voice ms within which a mark placed inside a voice counts as reached where the voice starts. */
+const REACHED = 1e-9;
+/**
+ * When a voice reaches a mark it placed inside itself, mix time: `at` into the first pass that
+ * reaches it from where the voice starts, while its clock runs forward and before it ends. None for
+ * a mark it does not place.
+ */
+function insideOf(mix, voice, start, name) {
+    const marks = voice.spec.marks;
+    if (marks === undefined || !Object.hasOwn(marks, name) || voice.backs)
+        return undefined;
+    const at = marks[name];
+    const from = voice.elapsedAt(start);
+    const d = voice.duration;
+    let pass = 0;
+    if (d > 0)
+        pass = Math.max(0, Math.ceil((from - at) / d - REACHED));
+    else if (at < from - REACHED)
+        return undefined;
+    if (pass >= voice.passes)
+        return undefined;
+    const t = voice.timeAt(pass * d + at);
+    if (!Number.isFinite(t))
+        return undefined;
+    const end = markOf(mix, voice, 'end');
+    return end !== undefined && t >= end ? undefined : Math.max(start, t);
+}
 /**
  * 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.
@@ -127,15 +188,15 @@ function coastOf(mix, voice, start) {
     if (voice.fitting !== null)
         t = voice.timeAt(voice.fitting.end);
     else if (voice.holding !== null) {
-        const children = voice.holding.children;
-        if (children.length === 0)
+        const h = voice.holding;
+        if (h.cutSeq !== Number.POSITIVE_INFINITY)
             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);
+        if (h.children.length === 0)
+            t = voice.state === 'done' ? h.coast : undefined;
+        else {
+            t = lastChild(mix, h.children, 'coast');
+            if (t !== undefined)
+                t = Math.max(t, h.coast);
         }
     }
     else
@@ -146,3 +207,17 @@ function coastOf(mix, voice, start) {
     const cut = voice.out !== null ? voice.out.at : voice.state === 'done' ? voice.doneAt : voice.outAt;
     return cut < t ? undefined : t;
 }
+/** The latest of the children's `mark`; undefined for none, or while one has not fixed it. */
+function lastChild(mix, children, mark) {
+    if (children.length === 0)
+        return undefined;
+    let t = Number.NEGATIVE_INFINITY;
+    for (const child of children) {
+        const c = markOf(mix, child, mark);
+        if (c === undefined)
+            return undefined;
+        if (c > t)
+            t = c;
+    }
+    return t;
+}

package/dist/meet.js

@@ -110,6 +110,7 @@ function place(lanes, voice, slot, subject, from, head) {
         return false;
     const o = p * 8 /* Row.STRIDE */;
     c.list[p] = slot;
+    lanes.placed.add(slot, voice.id);
     c.data[o + 0 /* Row.DELAY */] = held.delay;
     c.data[o + 1 /* Row.SINCE */] = held.shown;
     c.data[o + 2 /* Row.WEIGHT */] = 0;

package/dist/mixer.d.ts

@@ -2,6 +2,7 @@ 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 type { Column } from './columns.js';
 import { DepartedIndex } from './departed.js';
 import type { Due } from './due.js';
 import { parting } from './fade.js';
@@ -21,7 +22,7 @@ import { ScoreIndex } from './scored.js';
 import { Fitting } from './spans.js';
 import { Store } from './store.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 { BlendMember, 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';
 /**
@@ -34,6 +35,8 @@ export declare const defaults: {
 export declare class Mixer<I, O> implements Mix<I, O> {
     readonly kit: Kit<O>;
     readonly opts: MixOptions;
+    /** The lanes an entry was built with; null in one that leaves them out. */
+    readonly lanesOf: typeof Lanes | null;
     cued: Voice<I, O>[];
     /** Under `history`, voices that have left but that a read back may still reach. */
     gone: Voice<I, O>[];
@@ -95,10 +98,15 @@ export declare class Mixer<I, O> implements Mix<I, O> {
     /** 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. */
+    /**
+     * Each remembered head's lane slot, -1 at a position with none, and the `version` and `relinks`
+     * they were all current at.
+     */
     pulledSlots: Int32Array<ArrayBuffer>;
     pulledVersion: number;
     pulledRelinks: number;
+    /** What `pull` knows of each channel it has written, by name; none until the first pull. */
+    pullColumns: Map<string, Column> | null;
     /** Counts chains made stale one subject at a time, which `version` does not. */
     relinks: number;
     /** Read once a sync, so a `reduce` function is not called per voice per subject. */
@@ -187,7 +195,9 @@ export declare class Mixer<I, O> implements Mix<I, O> {
     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);
+    constructor(kit: Kit<O>, opts: MixOptions, 
+    /** The lanes an entry was built with; null in one that leaves them out. */
+    lanesOf: typeof Lanes | null);
     /** Throws where the clock is a shared transport's, which only the transport moves. */
     private own;
     get now(): number;
@@ -202,6 +212,8 @@ export declare class Mixer<I, O> implements Mix<I, O> {
     set announced(v: Announced[]);
     get nextId(): number;
     set nextId(v: number);
+    get timestamp(): number;
+    get seq(): number;
     get last(): number;
     get tape(): Tape | undefined;
     get replaying(): boolean;
@@ -211,16 +223,20 @@ export declare class Mixer<I, O> implements Mix<I, O> {
         off: number;
     };
     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>[];
+    blend(members: readonly (Patch<I, O, unknown> | BlendMember<I, O>)[], 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;
-    book(opts: BookOptions): Booker;
+    book<E = unknown>(opts: BookOptions<E, I>): Booker;
     probe(subject: I, out?: O): O;
     pull(subjects: Iterable<I>, into: Columns<O>): void;
-    seek(time: number): void;
+    seek(to: number | {
+        readonly frame: number;
+    }): void;
     prepare(time: number): Promise<void>;
-    project(time: number): Projection<I, O>;
+    project(at: number | {
+        readonly frame: number;
+    }): Projection<I, O>;
     announce(name: string, opts?: {
         at?: number;
         score?: string;

package/dist/mixer.js

@@ -1,13 +1,13 @@
 import { blended, blendOf, laneRead, shareKept } from './blend.js';
-import { aims, chain, linkable, relink } from './chain.js';
+import { aims, chain, linkable, relink, unlink } from './chain.js';
 import { lerpInto } from './channels.js';
 import { cue } from './cue.js';
 import { DepartedIndex } from './departed.js';
-import { beginFade, leftWith, parting } from './fade.js';
+import { beginFade, leaveVoice, 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';
+import { releasing } from './history.js';
 import { book, laneHost } from './hosts.js';
 import { Lanes } from './lanes.js';
 import { foldLocus } from './locus.js';
@@ -22,8 +22,8 @@ import { Outs } from './revive.js';
 import { ScoreIndex } from './scored.js';
 import { seek } from './seek.js';
 import { Fitting, refit } from './spans.js';
-import { Store } from './store.js';
-import { record } from './tape.js';
+import { Masked, Store } from './store.js';
+import { record, unplayable } from './tape.js';
 import { touch } from './touch.js';
 import { announce, Transport } from './transport.js';
 import { none } from './voice.js';
@@ -37,6 +37,7 @@ export const defaults = { lanes: true };
 export class Mixer {
     kit;
     opts;
+    lanesOf;
     cued = [];
     /** Under `history`, voices that have left but that a read back may still reach. */
     gone = [];
@@ -87,10 +88,15 @@ export class Mixer {
     /** 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. */
+    /**
+     * Each remembered head's lane slot, -1 at a position with none, and the `version` and `relinks`
+     * they were all current at.
+     */
     pulledSlots = new Int32Array(0);
     pulledVersion = Number.NaN;
     pulledRelinks = -1;
+    /** What `pull` knows of each channel it has written, by name; none until the first pull. */
+    pullColumns = null;
     /** Counts chains made stale one subject at a time, which `version` does not. */
     relinks = 0;
     /** Read once a sync, so a `reduce` function is not called per voice per subject. */
@@ -215,9 +221,12 @@ export class Mixer {
     keys = null;
     /** With a history store, the voices it paged out whose handles are still held; null without one. */
     outs = null;
-    constructor(kit, opts) {
+    constructor(kit, opts, 
+    /** The lanes an entry was built with; null in one that leaves them out. */
+    lanesOf) {
         this.kit = kit;
         this.opts = opts;
+        this.lanesOf = lanesOf;
         this.names = Object.keys(kit);
         this.channels = this.names.map((k) => kit[k]);
         this.bounded = this.channels.flatMap((c, i) => (c.bounds ? [i] : []));
@@ -225,7 +234,10 @@ export class Mixer {
         this.names.forEach((k, i) => {
             this.slotOf.set(k, i);
         });
-        this.lanes = (opts.lanes ?? defaults.lanes) ? new Lanes(laneHost(this)) : null;
+        if (lanesOf === null && opts.lanes === true)
+            throw new Error("blits: '@msb235/blits/lean' has no lanes; take mix from '@msb235/blits'");
+        this.lanes =
+            lanesOf !== null && (opts.lanes ?? defaults.lanes) ? new lanesOf(laneHost(this)) : null;
         this.name = opts.name;
         const shared = opts.transport;
         if (shared !== undefined) {
@@ -287,6 +299,12 @@ export class Mixer {
     set nextId(v) {
         this.transport.nextId = v;
     }
+    get timestamp() {
+        return this.transport.last;
+    }
+    get seq() {
+        return this.transport.seq;
+    }
     get last() {
         return this.transport.last;
     }
@@ -305,16 +323,31 @@ export class Mixer {
     }
     cue(spec) {
         this.attached();
-        const engine = this.opts.engine ?? mixer;
-        if (!engine.runs.has(spec.patch.form))
+        const engine = this.opts.engine;
+        if (engine !== undefined && !engine.runs.has(spec.patch.form))
             throw new Error(`blits: engine ${engine.name} does not run ${spec.patch.form} patches`);
         return cue(this, spec);
     }
-    blend(patches, by, spec = {}) {
+    blend(members, by, spec = {}) {
         const locus = `blend:${this.nextId}`;
-        const of = blendOf(by, patches.length - 1);
-        return patches.map((patch, i) => {
-            const handle = this.cue({ ...spec, patch, weight: by, locus });
+        const of = blendOf(by, members.length - 1);
+        return members.map((member, i) => {
+            const own = {
+                ...spec,
+                patch: member,
+                weight: by,
+                locus,
+            };
+            if ('patch' in member) {
+                own.patch = member.patch;
+                if (member.name !== undefined)
+                    own.name = member.name;
+                if (member.tags !== undefined)
+                    own.tags = member.tags;
+                if (member.hits !== undefined)
+                    own.hits = member.hits;
+            }
+            const handle = this.cue(own);
             const voice = this.cued[this.cued.length - 1];
             voice.blend = { of, i };
             of.members.push(voice);
@@ -327,6 +360,8 @@ export class Mixer {
         return this.cue({ ...spec, patch: ownerPatch });
     }
     span(spec) {
+        if ((spec.rate ?? 1) < 0)
+            throw new Error('blits: a span lays out its children forward from its start, so it is not cued backward');
         this.fitting = new Fitting(spec);
         try {
             const handle = this.owns(spec);
@@ -356,16 +391,16 @@ export class Mixer {
         this.looked = true;
         pull(this, subjects, into);
     }
-    seek(time) {
+    seek(to) {
         if (this.projecting)
             throw new Error('blits: a projection does not seek');
-        seek(this.own('seek'), time);
+        seek(this.own('seek'), to);
     }
     prepare(time) {
         return this.own('prepare').prepare(time);
     }
-    project(time) {
-        return projectAll(this.transport, time).of(this);
+    project(at) {
+        return projectAll(this.transport, at).of(this);
     }
     announce(name, opts = {}) {
         this.attached();
@@ -466,18 +501,19 @@ export class Mixer {
             voice.written = true;
             beginFade(this, voice, { over: opts?.over });
         }
-        record(this, 'mute', () => this.mute(opts));
+        record(this, 'mute', (stage) => stage.mix(this)?.mute(opts));
     }
     drop(subject) {
         this.frame = nextFrame();
         const head = this.chains.get(subject);
         // Nothing that kept this head, such as `pull`'s remembered list, may take it as current again.
-        if (head !== undefined) {
-            head.version = Number.NaN;
-            this.relinks++;
-        }
+        if (head !== undefined)
+            unlink(this, head);
         if (head !== undefined && head.slot >= 0 && this.lanes !== null)
             this.lanes.release(head.slot);
+        // A read ahead's copy reads the live mix's poses, and so hides one where the mix deletes it.
+        if (this.projecting && !(this.pose instanceof Masked))
+            this.pose = new Masked(this.pose);
         this.pose.delete(subject);
         this.restStamps?.delete(subject);
         this.chains.delete(subject);
@@ -485,10 +521,18 @@ export class Mixer {
         // A record of it is only in a voice over every subject, one naming it, or one gone; a ramp out
         // of a voice that does not name it is in `parters`, and a patch's own state in `motions`.
         const kept = releasing(this);
+        // A motion patch's state is the live mix's alone: a read ahead cannot start a subject afresh in it.
+        const release = (motion) => {
+            if (!this.projecting)
+                motion.release(subject, ...kept);
+            else if (motion.holds(subject))
+                unplayable('a drop of a subject a motion patch holds');
+        };
         const forget = (voice) => {
-            leave(this, voice, subject, leftWith(this, voice, subject));
+            leaveVoice(this, voice, subject);
             voice.subjects.delete(subject);
-            voice.motion?.release(subject, ...kept);
+            if (voice.motion !== undefined)
+                release(voice.motion);
             voice.parts?.delete(subject);
             voice.parted?.delete(subject);
             voice.blend?.of.reads.delete(subject);
@@ -521,11 +565,11 @@ export class Mixer {
         const strays = this.strays.get(subject);
         if (strays !== undefined)
             for (const motion of strays)
-                motion.release(subject, ...kept);
+                release(motion);
         this.strays.delete(subject);
         for (const motion of this.strayAll)
-            motion.release(subject, ...kept);
-        record(this, 'drop', () => this.drop(subject));
+            release(motion);
+        record(this, 'drop', (stage) => stage.mix(this)?.drop(subject));
     }
     touch(subject) {
         this.attached();
@@ -645,7 +689,7 @@ export const mixer = {
     name: 'mixer',
     runs: new Set(['fn', 'keys', 'motion']),
     create(kit, opts) {
-        return new Mixer(kit, opts);
+        return new Mixer(kit, opts, Lanes);
     },
 };
 /**

package/dist/motion.d.ts

@@ -45,7 +45,10 @@ export type Moving<I, O, V extends Value> = Patch<I, O, void> & {
      */
     push(subject: I, velocity: V, at?: number): void;
 };
-/** The state behind a `'motion'` patch, for an engine that reads it directly. */
+/**
+ * The state behind a `'motion'` patch, for an engine that reads it directly; a patch another copy
+ * of the same release made counts.
+ */
 export declare function motionOf<I>(p: object): Motions<I> | undefined;
 interface Common<I, V extends Value> {
     /** Units per second each subject starts moving at. Default 0. */

package/dist/motion.js

@@ -1,11 +1,17 @@
 import { COAST, CRITICAL, EASED, OVER, UNDER } from './closed.js';
 import { curve } from './easing.js';
 import { Motions } from './motions.js';
+import { release } from './shared.js';
 const axes = (v) => (typeof v === 'number' ? [v] : [...v]);
 /** Zero on every axis `x` has: a motion's velocity where its options give none. */
 const still = (x) => new Array(x.length).fill(0);
 const per = (p, subject) => typeof p === 'function' ? p(subject) : p;
 const scalarOf = (p) => typeof p === 'function' ? undefined : typeof p === 'number';
+/**
+ * What marks a motion patch to every copy of blits of this release loaded in one realm, so a
+ * spring another copy made runs on this copy's lanes; it gives the patch's state.
+ */
+const MOTIONS = Symbol.for(`@msb235/blits/motions@${release}`);
 /** One `writes` array per channel, shared by every motion patch that writes it. */
 const writesOf = new Map();
 /**
@@ -29,6 +35,9 @@ class MotionPatch {
     get motion() {
         return this.motions.spec();
     }
+    get [MOTIONS]() {
+        return this.motions;
+    }
     at(_phase, subject, setting) {
         const state = this.motions;
         const s = state.slot(subject);
@@ -58,9 +67,14 @@ class GlidePatch extends MotionPatch {
         this.motions.change(subject, { at, v: axes(velocity) });
     }
 }
-/** The state behind a `'motion'` patch, for an engine that reads it directly. */
+/**
+ * The state behind a `'motion'` patch, for an engine that reads it directly; a patch another copy
+ * of the same release made counts.
+ */
 export function motionOf(p) {
-    return p instanceof MotionPatch ? p.motions : undefined;
+    return p instanceof MotionPatch
+        ? p.motions
+        : p[MOTIONS];
 }
 /**
  * The shapes of the stock motions, each one object over the options it reads, copied out of them so

package/dist/motions.d.ts

@@ -167,6 +167,8 @@ export declare class Motions<I> {
     private unrelease;
     /** Subject `s`'s run as it stands. */
     private runAt;
+    /** Whether the patch holds a run for `subject`. */
+    holds(subject: I): boolean;
     /** A subject's run as plain data, for a voice leaving memory; undefined where it has none. */
     pack(subject: I): Run | undefined;
     /** Puts a subject's run back as `pack` or a release left it, replacing any it has now. */
@@ -244,6 +246,8 @@ export declare class Motions<I> {
     private queue;
     /** Every change due by `t` applied to a copy of the stretch playing then, committing nothing. */
     private peek;
+    /** Subject `s`'s changes waiting, with those a read ahead's tape made filed among them by time. */
+    private dueTo;
     private check;
     private flag;
     forget(s: number): void;