@msb235/blits 0.13.0 → 0.15.0

package/dist/mixer.d.ts

@@ -1,31 +1,40 @@
 import { type Arc } from './arcs.js';
+import { around } from './around.js';
 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 { baseFor, contribution, isRest, keyed, read, slopeFor, tick } from './contribution.js';
 import { DepartedIndex } from './departed.js';
-import type { Due } from './due.js';
+import { drop, forgetIn, recordDrop, releaseIn } from './drop.js';
+import { DueQueue } from './due.js';
 import { parting } from './fade.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 { apply, clamp, fold, foldDetour, folded, foldSharers, foldWith, type Key, linked, owedBy, passes, shared } from './fold.js';
 import { GoneIndex } from './gone.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 './motions.js';
+import type { Motions } from './motions.js';
 import type { Pace } from './pace.js';
 import { Keys } from './paging.js';
+import type { Places } from './places.js';
+import { moved, place, plot, put } from './plot.js';
 import { keep } from './pull.js';
 import { Steps } from './relink.js';
+import { atRest, restful, rests, restsKey, restsLaned, still } from './rests.js';
 import { Outs } from './revive.js';
+import { foldRole, type RoleScratch } from './role.js';
+import { foldRoles } from './roles.js';
 import { ScoreIndex } from './scored.js';
 import { Fitting } from './spans.js';
 import { Store } from './store.js';
+import type { MotionOwner } from './stretch.js';
+import type { Subject } from './subject.js';
 import { type Announced, Transport } from './transport.js';
 import type { ArcHandle, ArcSpec, 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';
+import { type Voice } from './voice.js';
+import { base, capped, fadeOf, horizonFor, ownedBy, ownerBase, prime, primeLaned, 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.
@@ -67,7 +76,7 @@ export declare class Mixer<I, O> implements Mix<I, O> {
         fields: Record<string, unknown>;
     } | undefined;
     /** Each subject's last two poses and when they were probed, for `from: 'current'`. */
-    pose: Store<I, {
+    lastPoses: Store<I, {
         pose: O;
         at: number;
         prev: O | undefined;
@@ -91,7 +100,7 @@ export declare class Mixer<I, O> implements Mix<I, O> {
     /** The pose `pull` folds a subject into where it cannot read straight from the lanes. */
     scratch: O | undefined;
     /** Live voices by the earliest mix time `moveTo` would change each, a binary heap. */
-    due: Due<I, O>[];
+    due: DueQueue<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. */
@@ -114,6 +123,13 @@ export declare class Mixer<I, O> implements Mix<I, O> {
     reducedNow: boolean;
     /** Something was changed since the last sync, so the next frame may differ from this one. */
     stirred: boolean;
+    /**
+     * The host read `inert` as true since the last sync, so its frame loop may be asleep until a
+     * change wakes it; a host that never asks keeps no loop asleep on it.
+     */
+    asleep: boolean;
+    /** Some voice cued while the mix slept waits for the next sync to set its start. */
+    waking: boolean;
     /** Counts the changes `stir` records, which a frame's record of a probe is current only before. */
     stirs: number;
     syncing: boolean;
@@ -128,6 +144,8 @@ export declare class Mixer<I, O> implements Mix<I, O> {
      */
     chains: Store<I, Subject<unknown>>;
     version: number;
+    /** The positions `plot` gave, which a voice's `within` reads: see `bound.ts`. */
+    places: Places<I> | null;
     /** What `prime` reads its clock, voice time and pass from: see `Primed`. */
     readonly primed: Float64Array<ArrayBuffer>;
     readonly steps: Steps<Voice<I, O>, I>;
@@ -159,8 +177,10 @@ export declare class Mixer<I, O> implements Mix<I, O> {
     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;
+    /** How many voices in the list carry a role; with none, a fold allocates nothing. */
+    roleVoices: number;
+    /** The tags the mix's options declare roles. */
+    readonly roleTags: readonly string[] | undefined;
     /** What every motion patch it plays asks for its voice's time, holding this mix weakly. */
     owner: MotionOwner | null;
     /** How many voices in the list are anchored, so a sync with none skips placing them. */
@@ -184,9 +204,9 @@ export declare class Mixer<I, O> implements Mix<I, O> {
     readonly lerpsInto: (LerpInto | undefined)[];
     /** By slot, a stock scalar channel's arithmetic, which a fold applies without calling the channel. */
     readonly scalars: ('sum' | 'mul' | 'max' | undefined)[];
-    /** What a fold with a locus in play gathers into, one per depth of folds under way. */
-    readonly locusScratch: LocusScratch<I, O>[];
-    locusDepth: number;
+    /** What a fold with a role in play gathers into, one per depth of folds under way. */
+    readonly roleScratch: RoleScratch<I, O>[];
+    roleDepth: number;
     readonly slotOf: Map<string, number>;
     lanes: Lanes<I, O> | null;
     handles: HandleHost<I, O> | null;
@@ -202,6 +222,7 @@ 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;
+    readonly pose: () => O;
     constructor(kit: Kit<O>, opts: MixOptions, 
     /** The lanes an entry was built with; null in one that leaves them out. */
     lanesOf: typeof Lanes | null);
@@ -230,7 +251,7 @@ export declare class Mixer<I, O> implements Mix<I, O> {
         off: number;
     };
     cue(spec: VoiceSpec<I, O>): 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>[];
+    blend(members: readonly (Patch<I, O, unknown> | BlendMember<I, O>)[], by: Signal<I>, spec?: Omit<VoiceSpec<I, O>, 'patch' | 'weight' | 'role' | 'locus' | 'within'>): Handle<I>[];
     owns(spec: OwnerSpec<I>): Handle<I>;
     span(spec: SpanSpec<I>): SpanHandle<I>;
     arc(spec: ArcSpec<I, O>): ArcHandle<I>;
@@ -253,8 +274,6 @@ export declare class Mixer<I, O> implements Mix<I, O> {
     /** Throws for a mix taken off its transport. */
     attached(): void;
     marks(from: number, to: number): Marked[];
-    atRest(subject: I): boolean;
-    rests(pose: O): boolean;
     rebase(): void;
     voices(tag?: string): Handle<I>[];
     get live(): boolean;
@@ -262,17 +281,10 @@ export declare class Mixer<I, O> implements Mix<I, O> {
     get rate(): number;
     set rate(r: number);
     ramp(rate: number, over: number): void;
-    /** Whether a voice will change no pose from `now` on, short of a change made to it. */
-    still(voice: Voice<I, O>, now: number): boolean;
     close(): void;
     mute(opts?: {
         over?: number;
     }): void;
-    drop(subject: I): void;
-    /** Lets `voice` go of a dropped subject. Methods rather than closures, so a drop makes neither. */
-    private forgetIn;
-    private releaseIn;
-    private recordDrop;
     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. */
@@ -284,15 +296,13 @@ export declare class Mixer<I, O> implements Mix<I, O> {
      */
     restStamps: Store<I, number> | null;
     /** 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;
-    private restsRelinks;
-    private restsStirs;
+    restsEpoch: number;
+    restsFrame: number;
+    restsVersion: number;
+    restsRelinks: number;
+    restsStirs: number;
     /** The pose `atRest` folds into where no probe this frame answers. */
-    private restScratch;
-    private restsLaned;
-    private restsKey;
+    restScratch: O | undefined;
 }
 declare const methods: {
     fold: typeof fold;
@@ -300,7 +310,7 @@ declare const methods: {
     linked: typeof linked;
     foldWith: typeof foldWith;
     owedBy: typeof owedBy;
-    foldLoci: typeof foldLoci;
+    foldRoles: typeof foldRoles;
     foldDetour: typeof foldDetour;
     foldSharers: typeof foldSharers;
     shared: typeof shared;
@@ -315,6 +325,7 @@ declare const methods: {
     baseFor: typeof baseFor;
     slopeFor: typeof slopeFor;
     prime: typeof prime;
+    primeLaned: typeof primeLaned;
     capped: typeof capped;
     horizonFor: typeof horizonFor;
     weigh: typeof weigh;
@@ -336,7 +347,22 @@ declare const methods: {
     sinceOf: typeof sinceOf;
     shownOf: typeof shownOf;
     keep: typeof keep;
-    foldLocus: typeof foldLocus;
+    foldRole: typeof foldRole;
+    atRest: typeof atRest;
+    rests: typeof rests;
+    restful: typeof restful;
+    still: typeof still;
+    restsLaned: typeof restsLaned;
+    restsKey: typeof restsKey;
+    plot: typeof plot;
+    place: typeof place;
+    moved: typeof moved;
+    put: typeof put;
+    around: typeof around;
+    drop: typeof drop;
+    forgetIn: typeof forgetIn;
+    releaseIn: typeof releaseIn;
+    recordDrop: typeof recordDrop;
 };
 type Methods = typeof methods;
 export interface Mixer<I, O> extends Methods {
@@ -344,13 +370,13 @@ export interface Mixer<I, O> extends Methods {
 /** Makes a mix the host asked for, with the registry's history where it names none, and lists it there. */
 export declare function made<I, O, H>(kit: Kit<O>, opts: MixOptions<H>, lanes: typeof Lanes | null): Mix<I, O, H>;
 /**
- * The one that ships: every form on the CPU, probed per subject on demand.
+ * The engine that ships, running every form on the CPU. It probes per subject on demand.
  *
  * @category engine
  */
 export declare const mixer: Engine;
 /**
- * Makes a mix over a kit, on the engine the options name or the stock one.
+ * Makes a mix over a kit. It runs on the engine the options name, or the stock one.
  *
  * @category mix
  */

package/dist/mixer.js

@@ -1,35 +1,42 @@
 import { cueArc } from './arcs.js';
+import { around } from './around.js';
+import { blanks } from './blank.js';
 import { blended, blendOf, laneRead, shareKept } from './blend.js';
-import { aims, chain, headOf, linkable, relink, unlink } from './chain.js';
+import { aims, chain, linkable, relink } from './chain.js';
 import { lerpInto, STOCK_BAND, scalarOp } from './channels.js';
-import { cue } from './cue.js';
+import { baseFor, contribution, isRest, keyed, read, slopeFor, tick } from './contribution.js';
+import { cue, roleTags } from './cue.js';
 import { DepartedIndex } from './departed.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 { drop, forgetIn, recordDrop, releaseIn } from './drop.js';
+import { DueQueue } from './due.js';
+import { beginFade, parting } from './fade.js';
+import { apply, clamp, fold, foldDetour, folded, foldSharers, foldWith, linked, owedBy, passes, shared, } from './fold.js';
+import { GoneIndex } from './gone.js';
 import { held, shownOf, sinceOf, unreachedOf } from './held.js';
-import { releasing } from './history.js';
 import { book, laneHost } from './hosts.js';
 import { Lanes } from './lanes.js';
-import { foldLocus } from './locus.js';
 import { listed } from './marks.js';
 import { nextFrame } from './move.js';
 import { ownerPatch } from './owner.js';
 import { Keys } from './paging.js';
+import { moved, place, plot, put } from './plot.js';
 import { projectAll } from './project.js';
 import { keep, pull } from './pull.js';
 import { Steps } from './relink.js';
+import { atRest, restful, rests, restsKey, restsLaned, still } from './rests.js';
 import { Outs } from './revive.js';
+import { foldRole } from './role.js';
+import { foldRoles } from './roles.js';
 import { ScoreIndex } from './scored.js';
 import { seek } from './seek.js';
 import { Fitting, refit } from './spans.js';
-import { Masked, Store } from './store.js';
-import { record, unplayable } from './tape.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 { gave, historyFor, register, unregister } from './watch.js';
-import { base, capped, fadeOf, horizonFor, ownedBy, ownerBase, prime, weigh, weighOwned, } from './weigh.js';
+import { base, capped, fadeOf, horizonFor, ownedBy, ownerBase, prime, primeLaned, 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.
@@ -63,7 +70,7 @@ export class Mixer {
     hostLog = [];
     hostThen;
     /** Each subject's last two poses and when they were probed, for `from: 'current'`. */
-    pose = new Store();
+    lastPoses = new Store();
     /** The clock this mix plays on, which also holds its tape and the marks announced on it. */
     transport;
     /** Its place among the mixes on its transport, in the order they joined. */
@@ -82,7 +89,7 @@ export class Mixer {
     /** The pose `pull` folds a subject into where it cannot read straight from the lanes. */
     scratch;
     /** Live voices by the earliest mix time `moveTo` would change each, a binary heap. */
-    due = [];
+    due = new DueQueue();
     /** 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. */
@@ -105,6 +112,13 @@ export class Mixer {
     reducedNow = false;
     /** Something was changed since the last sync, so the next frame may differ from this one. */
     stirred = false;
+    /**
+     * The host read `inert` as true since the last sync, so its frame loop may be asleep until a
+     * change wakes it; a host that never asks keeps no loop asleep on it.
+     */
+    asleep = false;
+    /** Some voice cued while the mix slept waits for the next sync to set its start. */
+    waking = false;
     /** Counts the changes `stir` records, which a frame's record of a probe is current only before. */
     stirs = 0;
     syncing = false;
@@ -144,6 +158,8 @@ export class Mixer {
      */
     chains = new Store();
     version = 0;
+    /** The positions `plot` gave, which a voice's `within` reads: see `bound.ts`. */
+    places = null;
     /** What `prime` reads its clock, voice time and pass from: see `Primed`. */
     primed = new Float64Array(3 /* Primed.SIZE */);
     steps = new Steps();
@@ -175,8 +191,10 @@ export class Mixer {
     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;
+    /** How many voices in the list carry a role; with none, a fold allocates nothing. */
+    roleVoices = 0;
+    /** The tags the mix's options declare roles. */
+    roleTags;
     /** What every motion patch it plays asks for its voice's time, holding this mix weakly. */
     owner = null;
     /** How many voices in the list are anchored, so a sync with none skips placing them. */
@@ -211,9 +229,9 @@ export class Mixer {
     lerpsInto;
     /** By slot, a stock scalar channel's arithmetic, which a fold applies without calling the channel. */
     scalars;
-    /** What a fold with a locus in play gathers into, one per depth of folds under way. */
-    locusScratch = [];
-    locusDepth = 0;
+    /** What a fold with a role in play gathers into, one per depth of folds under way. */
+    roleScratch = [];
+    roleDepth = 0;
     slotOf = new Map();
     lanes;
     handles = null;
@@ -229,6 +247,7 @@ export class Mixer {
     keys = null;
     /** With a history store, the voices it paged out whose handles are still held; null without one. */
     outs = null;
+    pose;
     constructor(kit, opts, 
     /** The lanes an entry was built with; null in one that leaves them out. */
     lanesOf) {
@@ -239,6 +258,7 @@ export class Mixer {
         this.channels = this.names.map((k) => kit[k]);
         this.bounded = this.channels.flatMap((c, i) => (c.bounds ? [i] : []));
         this.lerpsInto = this.channels.map((c) => lerpInto(c));
+        this.pose = blanks(this.names, this.channels);
         this.scalars = this.channels.map((c) => scalarOp(c));
         this.names.forEach((k, i) => {
             this.slotOf.set(k, i);
@@ -248,6 +268,7 @@ export class Mixer {
         this.lanes =
             lanesOf !== null && (opts.lanes ?? defaults.lanes) ? new lanesOf(laneHost(this)) : null;
         this.name = opts.name;
+        this.roleTags = roleTags(opts);
         const shared = opts.transport;
         if (shared !== undefined) {
             if (opts.history !== undefined)
@@ -338,14 +359,14 @@ export class Mixer {
         return cue(this, spec);
     }
     blend(members, by, spec = {}) {
-        const locus = `blend:${this.nextId}`;
+        const role = `blend:${this.nextId}`;
         const of = blendOf(by, members.length - 1);
         return members.map((member, i) => {
             const own = {
                 ...spec,
                 patch: member,
                 weight: by,
-                locus,
+                role,
             };
             if ('patch' in member) {
                 own.patch = member.patch;
@@ -426,38 +447,6 @@ export class Mixer {
     marks(from, to) {
         return listed(this, from, to).map(({ order: _, ...m }) => m);
     }
-    atRest(subject) {
-        this.restStamps ??= new Store();
-        const head = this.linked(subject);
-        const laned = this.linkedLaned;
-        const lanes = this.lanes;
-        // Every voice on lanes and nothing to clamp: the pose a fold would make is the lanes' values.
-        if (laned && this.restsLaned()) {
-            const slot = head.slot;
-            if (!lanes.owes(slot))
-                return lanes.rests(slot);
-        }
-        // A probe this frame answers for the pose it gave the host.
-        const since = (this.restStamps.get(subject) ?? Number.NaN) - 2 * this.restsKey();
-        if (since >= 0)
-            return since === 1;
-        this.restScratch ??= {};
-        const pose = this.foldWith(subject, this.restScratch, head, laned, true);
-        return this.rests((this.bounded.length === 0 ? pose : this.clamp(pose)));
-    }
-    rests(pose) {
-        for (let i = 0; i < this.names.length; i++) {
-            const channel = this.channels[i];
-            const value = pose[this.names[i]];
-            if (channel.rest === undefined) {
-                if (value !== undefined)
-                    return false;
-            }
-            else if (!near(value, channel.rest))
-                return false;
-        }
-        return true;
-    }
     rebase() {
         this.own('rebase').rebase();
     }
@@ -474,14 +463,10 @@ export class Mixer {
     get inert() {
         if (this.stirred)
             return false;
-        // Standing still, a voice changes no pose but by its weight signal, or by an anchor or start
-        // that host time may yet reach.
-        if (this.pace?.stopped(this.u))
-            return this.cued.every((v) => v.state === 'done' ||
-                (v.state !== 'pending' &&
-                    typeof v.spec.weight !== 'function' &&
-                    v.spec.anchor === undefined));
-        return this.cued.every((v) => this.still(v, this.now));
+        const inert = this.restful();
+        if (inert && !Number.isNaN(this.now))
+            this.asleep = true;
+        return inert;
     }
     get rate() {
         return this.transport.rate;
@@ -492,22 +477,6 @@ export class Mixer {
     ramp(rate, over) {
         this.own('ramp').ramp(rate, over);
     }
-    /** Whether a voice will change no pose from `now` on, short of a change made to it. */
-    still(voice, now) {
-        if (voice.state === 'done')
-            return true;
-        if (voice.state !== 'frozen' && voice.state !== 'live')
-            return false;
-        if (typeof voice.spec.weight === 'function' || voice.parts !== null)
-            return false;
-        const fadeIn = this.reducedNow ? 0 : (voice.fade.in ?? 0);
-        if (fadeIn > 0 && now - this.sinceOf(voice, voice.latest) < fadeIn)
-            return false;
-        if (voice.state === 'frozen' || voice.holding !== null)
-            return true;
-        const motion = voice.motion;
-        return motion !== undefined && voice.elapsedAt(now) >= voice.latest && motion.landed();
-    }
     close() {
         unregister(this);
     }
@@ -518,80 +487,6 @@ export class Mixer {
         }
         record(this, 'mute', (stage) => stage.mix(this)?.mute(opts));
     }
-    drop(subject) {
-        this.frame = nextFrame();
-        const head = headOf(this, subject);
-        // Nothing that kept this head, such as `pull`'s remembered list, may take it as current again.
-        if (head !== undefined)
-            unlink(this, head);
-        // A number a seek carried over is released even where its chain is not linked since.
-        const slot = this.chains.get(subject)?.slot ?? -1;
-        if (slot >= 0 && this.lanes !== null)
-            this.lanes.release(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);
-        this.stir();
-        // 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);
-        for (const voice of this.general)
-            this.forgetIn(voice, subject, kept);
-        const named = this.named.get(subject);
-        if (named !== undefined)
-            for (const voice of [...named])
-                this.forgetIn(voice, subject, kept);
-        const gone = goneIndex(this);
-        for (const voice of gone.general)
-            this.forgetIn(voice, subject, kept);
-        const goneNaming = gone.named.get(subject);
-        if (goneNaming !== undefined)
-            for (const voice of goneNaming)
-                this.forgetIn(voice, subject, kept);
-        if (this.owners !== null)
-            for (const voice of this.owners)
-                this.forgetIn(voice, subject, kept);
-        for (const voice of this.parters) {
-            this.forgetIn(voice, subject, kept);
-            if (voice.parts?.size === 0)
-                voice.parts = null;
-            if (voice.parted?.size === 0)
-                voice.parted = null;
-            if (voice.parts === null && voice.parted === null)
-                this.parters.delete(voice);
-        }
-        const strays = this.strays.get(subject);
-        if (strays !== undefined)
-            for (const motion of strays)
-                this.releaseIn(motion, subject, kept);
-        this.strays.delete(subject);
-        for (const motion of this.strayAll)
-            this.releaseIn(motion, subject, kept);
-        this.recordDrop(subject);
-    }
-    /** Lets `voice` go of a dropped subject. Methods rather than closures, so a drop makes neither. */
-    forgetIn(voice, subject, kept) {
-        leaveVoice(this, voice, subject);
-        voice.subjects.delete(subject);
-        if (voice.motion !== undefined)
-            this.releaseIn(voice.motion, subject, kept);
-        voice.parts?.delete(subject);
-        voice.parted?.delete(subject);
-        voice.blend?.of.reads.delete(subject);
-    }
-    // A motion patch's state is the live mix's alone: a read ahead cannot start a subject afresh in it.
-    releaseIn(motion, subject, kept) {
-        if (!this.projecting)
-            motion.release(subject, kept[0], kept[1], kept[2]);
-        else if (motion.holds(subject))
-            unplayable('a drop of a subject a motion patch holds');
-    }
-    recordDrop(subject) {
-        record(this, 'drop', (stage) => stage.mix(this)?.drop(subject));
-    }
     touch(subject) {
         this.attached();
         touch(this, subject);
@@ -628,22 +523,6 @@ export class Mixer {
     restsStirs = -1;
     /** The pose `atRest` folds into where no probe this frame answers. */
     restScratch;
-    restsLaned() {
-        return this.lanes.whole && this.bounded.length === 0;
-    }
-    restsKey() {
-        if (this.frame !== this.restsFrame ||
-            this.version !== this.restsVersion ||
-            this.relinks !== this.restsRelinks ||
-            this.stirs !== this.restsStirs) {
-            this.restsEpoch++;
-            this.restsFrame = this.frame;
-            this.restsVersion = this.version;
-            this.restsRelinks = this.relinks;
-            this.restsStirs = this.stirs;
-        }
-        return this.restsEpoch;
-    }
 }
 // The probe's hot path is methods, installed here from the modules that own them: as functions
 // called directly they made probes and fills up to 9% slower (bench/ab.sh on teitou, 2026-10-05).
@@ -653,7 +532,7 @@ const methods = {
     linked,
     foldWith,
     owedBy,
-    foldLoci,
+    foldRoles,
     foldDetour,
     foldSharers,
     shared,
@@ -668,6 +547,7 @@ const methods = {
     baseFor,
     slopeFor,
     prime,
+    primeLaned,
     capped,
     horizonFor,
     weigh,
@@ -689,7 +569,22 @@ const methods = {
     sinceOf,
     shownOf,
     keep,
-    foldLocus,
+    foldRole,
+    atRest,
+    rests,
+    restful,
+    still,
+    restsLaned,
+    restsKey,
+    plot,
+    place,
+    moved,
+    put,
+    around,
+    drop,
+    forgetIn,
+    releaseIn,
+    recordDrop,
 };
 for (const [name, value] of Object.entries(methods))
     Object.defineProperty(Mixer.prototype, name, { value, writable: true, configurable: true });
@@ -711,7 +606,7 @@ export function made(kit, opts, lanes) {
     return m;
 }
 /**
- * The one that ships: every form on the CPU, probed per subject on demand.
+ * The engine that ships, running every form on the CPU. It probes per subject on demand.
  *
  * @category engine
  */
@@ -723,7 +618,7 @@ export const mixer = {
     },
 };
 /**
- * Makes a mix over a kit, on the engine the options name or the stock one.
+ * Makes a mix over a kit. It runs on the engine the options name, or the stock one.
  *
  * @category mix
  */