@msb235/blits 0.7.1 → 0.8.1

package/dist/lanes.d.ts

@@ -1,10 +1,11 @@
 import type { Column } from './columns.js';
+import { copy } from './copyout.js';
 import { type Crowd, row } from './crowd.js';
-import { call, foldKeys, one, parting, readKeyed, reset, run, signalled, subjectAt } from './fill.js';
-import { fold, foldDelta, foldInto, foldRun, gate, gather } from './gather.js';
+import { call, foldKeys, one, parting, readKeyed, reset, run, runEveryone, signalled, subjectAt } from './fill.js';
+import { fold, foldDelta, foldInto, foldRun, gate, gather, unplain } from './gather.js';
 import { type Lane, type Laned, type Locus } from './lane.js';
 import type { Watcher } from './motions.js';
-import { type absent, Numbers } from './numbers.js';
+import { absent, Numbers } from './numbers.js';
 import { Owed } from './owed.js';
 import type { Channel } from './types.js';
 import type { Subject, Voice } from './voice.js';
@@ -61,7 +62,7 @@ export declare class Lanes<I, O> implements Watcher {
     /** The lanes over every subject that have started playing, by epoch. */
     dense: Lane<I, O>[];
     readonly byId: Map<number, Lane<I, O>>;
-    /** The crowds of single-subject motion voices, one per channel, and which holds each voice. */
+    /** The crowds of single-subject voices, one per list of channels, and which holds each voice. */
     crowds: Crowd<I, O>[];
     readonly crowdOf: Map<number, Crowd<I, O>>;
     /** Whether two crowds share a channel, so their rows must interleave in voice order. */
@@ -71,13 +72,20 @@ export declare class Lanes<I, O> implements Watcher {
     /** The lane and record `one` is folding, whose band state a rest-less channel reads. */
     folding: Lane<I, O> | null;
     rec: Subject<unknown> | null;
+    /** The numbers a fill's methods hand each other: see `Arg`. */
+    readonly arg: Float64Array<ArrayBuffer>;
     /** While a fill gathers a locus: that locus and the member gathering, where folds go instead. */
     into: Locus<I, O> | null;
     intoId: number;
     readonly lawsByKey: Map<string, Float64Array<ArrayBufferLike>>;
     lastLaw: Float64Array | null;
-    /** The lanes the last `meet` gave a position, and whether it placed a crowd row. */
+    /**
+     * The lanes the last `meet` gave a position, the first `metN` of `met`, and whether it placed a
+     * crowd row. Counted, not cut to length: an array emptied by its length takes new room at its
+     * next push, about 150 B a subject met (the `swap` row, bench/allocs.mjs, 2026-10-09).
+     */
     readonly met: number[];
+    metN: number;
     metCrowd: boolean;
     /** By subject number, the laned voices its probes fold on the general path this fill. */
     readonly owed: Owed;
@@ -137,8 +145,9 @@ export declare class Lanes<I, O> implements Watcher {
     keeps: boolean;
     now: number;
     filledAt: number;
-    /** `reading.moved` at the last fill, so a retarget or push between two probes refills. */
+    /** `reading.moved` and `reading.inputs` at the last fill: see `current`. */
     moved: number;
+    inputs: number;
     /** The `now` of the latest probe, and the probe count before its first, to tell a probe this frame. */
     frameAt: number;
     frameProbes: number;
@@ -191,6 +200,13 @@ export declare class Lanes<I, O> implements Watcher {
     prepare(slot: number, subject: I, version: number, head: Subject<unknown> | null): boolean;
     /** Whether this frame's lanes are filled and nothing since asks `begin` to look again. */
     filled(now: number, version: number): boolean;
+    /**
+     * Whether the last fill still stands: everything a fill reads that can change between two probes,
+     * each stamped by `fillAll`. The clock; the mix's version, which voices coming, going, starting
+     * and stopping move; a motion's retargets and pushes; and a `level` set. Whatever else can change
+     * between probes keeps its voice off lanes in `fits`.
+     */
+    current(now: number, version: number): boolean;
     /**
      * What a probe does before its subject, once a frame's lanes are settled: qualifies and fills as
      * needed. Says whether the subject takes the general path or the lanes are filled.
@@ -215,8 +231,6 @@ export declare class Lanes<I, O> implements Watcher {
      * would write: each number within 1e-9 of its rest.
      */
     rests(slot: number): boolean;
-    /** Writes a subject's laned values into a pose, each array channel into a new array. */
-    copy(slot: number, pose: Record<string, unknown>): void;
     forget(slot: number): void;
     grow(size: number): void;
     /**
@@ -224,16 +238,25 @@ export declare class Lanes<I, O> implements Watcher {
      * next fill, and a lane keeps the sample the old one gave.
      */
     stretchChanged(id: number, s: number): void;
+    /**
+     * A voice that kept one record for every subject keeps one each from now on: each of its lane's
+     * positions takes the record `of` gives its subject.
+     */
+    rerecord(id: number, of: (subject: I, slot: number) => Subject<unknown>): void;
+    /** A voice's clock moved the `shown` of records it had already placed: copies them again. */
+    reshown(id: number): void;
     /** Something on a voice changed: a crowd copies it again at the next fill. */
     voiceChanged(id: number): void;
 }
 declare const methods: {
+    copy: typeof copy;
     row: typeof row;
     signalled: typeof signalled;
     parting: typeof parting;
     subjectAt: typeof subjectAt;
     reset: typeof reset;
     run: typeof run;
+    runEveryone: typeof runEveryone;
     one: typeof one;
     foldKeys: typeof foldKeys;
     readKeyed: typeof readKeyed;
@@ -244,6 +267,7 @@ declare const methods: {
     foldRun: typeof foldRun;
     foldInto: typeof foldInto;
     gate: typeof gate;
+    unplain: typeof unplain;
 };
 type Methods = typeof methods;
 export interface Lanes<I, O> extends Methods {

package/dist/lanes.js

@@ -1,8 +1,9 @@
+import { copy } from './copyout.js';
 import { row } from './crowd.js';
-import { call, fillAll, foldKeys, one, parting, readKeyed, reset, run, signalled, subjectAt, } from './fill.js';
-import { fold, foldDelta, foldInto, foldRun, gate, gather } from './gather.js';
+import { call, fillAll, foldKeys, one, parting, readKeyed, reset, run, runEveryone, signalled, subjectAt, } from './fill.js';
+import { fold, foldDelta, foldInto, foldRun, gate, gather, unplain } from './gather.js';
 import { meet, reach } from './meet.js';
-import { Numbers } from './numbers.js';
+import { absent, Numbers } from './numbers.js';
 import { Owed } from './owed.js';
 import { requalify, retouch } from './qualify.js';
 import { reading } from './reading.js';
@@ -19,7 +20,7 @@ export class Lanes {
     /** The lanes over every subject that have started playing, by epoch. */
     dense = [];
     byId = new Map();
-    /** The crowds of single-subject motion voices, one per channel, and which holds each voice. */
+    /** The crowds of single-subject voices, one per list of channels, and which holds each voice. */
     crowds = [];
     crowdOf = new Map();
     /** Whether two crowds share a channel, so their rows must interleave in voice order. */
@@ -29,13 +30,20 @@ export class Lanes {
     /** The lane and record `one` is folding, whose band state a rest-less channel reads. */
     folding = null;
     rec = null;
+    /** The numbers a fill's methods hand each other: see `Arg`. */
+    arg = new Float64Array(6 /* Arg.SIZE */);
     /** While a fill gathers a locus: that locus and the member gathering, where folds go instead. */
     into = null;
     intoId = 0;
     lawsByKey = new Map();
     lastLaw = null;
-    /** The lanes the last `meet` gave a position, and whether it placed a crowd row. */
+    /**
+     * The lanes the last `meet` gave a position, the first `metN` of `met`, and whether it placed a
+     * crowd row. Counted, not cut to length: an array emptied by its length takes new room at its
+     * next push, about 150 B a subject met (the `swap` row, bench/allocs.mjs, 2026-10-09).
+     */
     met = [];
+    metN = 0;
     metCrowd = false;
     /** By subject number, the laned voices its probes fold on the general path this fill. */
     owed = new Owed();
@@ -95,8 +103,9 @@ export class Lanes {
     keeps = false;
     now = Number.NaN;
     filledAt = Number.NaN;
-    /** `reading.moved` at the last fill, so a retarget or push between two probes refills. */
+    /** `reading.moved` and `reading.inputs` at the last fill: see `current`. */
     moved = 0;
+    inputs = 0;
     /** The `now` of the latest probe, and the probe count before its first, to tell a probe this frame. */
     frameAt = Number.NaN;
     frameProbes = 0;
@@ -233,13 +242,23 @@ export class Lanes {
     }
     /** Whether this frame's lanes are filled and nothing since asks `begin` to look again. */
     filled(now, version) {
+        return (this.frameAt === now &&
+            this.qualifiedVersion === version &&
+            this.touched.length === 0 &&
+            !this.filling &&
+            this.current(now, version));
+    }
+    /**
+     * Whether the last fill still stands: everything a fill reads that can change between two probes,
+     * each stamped by `fillAll`. The clock; the mix's version, which voices coming, going, starting
+     * and stopping move; a motion's retargets and pushes; and a `level` set. Whatever else can change
+     * between probes keeps its voice off lanes in `fits`.
+     */
+    current(now, version) {
         return (this.filledAt === now &&
-            this.frameAt === now &&
             this.filledVersion === version &&
-            this.qualifiedVersion === version &&
             this.moved === reading.moved &&
-            this.touched.length === 0 &&
-            !this.filling);
+            this.inputs === reading.inputs);
     }
     /**
      * What a probe does before its subject, once a frame's lanes are settled: qualifies and fills as
@@ -257,8 +276,9 @@ export class Lanes {
         }
         if (this.filling)
             return 0 /* Begin.GENERAL */;
-        // The mix's version moves only when a voice over every subject comes, goes, starts or stops
-        // waiting, each of which touches it, so a version past a qualify that stands is a set of touches.
+        // Past a qualify that stands, the mix's version moves when a voice over every subject comes,
+        // goes, starts or stops waiting, each of which touches it, or stops sharing one record, which
+        // moves no voice on or off a lane: so with voices touched it is a set of touches.
         if (this.qualifiedVersion !== version) {
             if (!Number.isNaN(this.qualifiedVersion) && this.touched.length > 0 && retouch(this))
                 this.qualifiedVersion = version;
@@ -269,7 +289,7 @@ export class Lanes {
             requalify(this, version);
         if (this.laned.length === 0)
             return 0 /* Begin.GENERAL */;
-        if (this.filledAt !== now || this.filledVersion !== version || this.moved !== reading.moved) {
+        if (!this.current(now, version)) {
             fillAll(this, now, version);
             // A patch call in that fill made kept state, which took its voice off its lane: fill without it.
             if (this.qualifiedVersion !== version) {
@@ -349,30 +369,6 @@ export class Lanes {
         }
         return true;
     }
-    /** Writes a subject's laned values into a pose, each array channel into a new array. */
-    copy(slot, pose) {
-        const laned = this.laned;
-        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;
-            }
-            // Made as the general path makes it, a copy of rest, so poses from either path share a shape.
-            const arr = [...ch.start];
-            const base = slot * axes;
-            for (let a = 0; a < axes; a++)
-                arr[a] = ch.values[base + a];
-            pose[ch.name] = arr;
-        }
-    }
     forget(slot) {
         this.host.forgot(slot);
         this.live--;
@@ -417,6 +413,39 @@ export class Lanes {
         if (q >= 0)
             lane.fix(q);
     }
+    /**
+     * A voice that kept one record for every subject keeps one each from now on: each of its lane's
+     * positions takes the record `of` gives its subject.
+     */
+    rerecord(id, of) {
+        const lane = this.byId.get(id);
+        if (lane === undefined)
+            return;
+        for (let p = 0; p < lane.list.length; p++) {
+            const slot = lane.list[p];
+            const subject = this.subjectAt(slot);
+            if (subject !== absent)
+                lane.records[p] = of(subject, slot);
+        }
+    }
+    /** A voice's clock moved the `shown` of records it had already placed: copies them again. */
+    reshown(id) {
+        const c = this.crowdOf.get(id);
+        const p = c?.rowOf.get(id);
+        if (c !== undefined && p !== undefined) {
+            const held = c.records[p];
+            if (held !== undefined)
+                c.data[p * 8 /* Row.STRIDE */ + 1 /* Row.SINCE */] = held.shown;
+        }
+        const lane = this.byId.get(id);
+        if (lane === undefined)
+            return;
+        for (let q = 0; q < lane.list.length; q++) {
+            const held = lane.records[q];
+            if (held !== undefined)
+                lane.data[q * 8 /* Row.STRIDE */ + 1 /* Row.SINCE */] = held.shown;
+        }
+    }
     /** Something on a voice changed: a crowd copies it again at the next fill. */
     voiceChanged(id) {
         const c = this.crowdOf.get(id);
@@ -430,12 +459,14 @@ export class Lanes {
 // A fill's per-subject path is methods, installed here from the modules that own them: as
 // functions called directly they made fills 5-8% slower (bench/ab.sh on teitou, 2026-10-05).
 const methods = {
+    copy,
     row,
     signalled,
     parting,
     subjectAt,
     reset,
     run,
+    runEveryone,
     one,
     foldKeys,
     readKeyed,
@@ -446,6 +477,7 @@ const methods = {
     foldRun,
     foldInto,
     gate,
+    unplain,
 };
 for (const [name, value] of Object.entries(methods))
     Object.defineProperty(Lanes.prototype, name, { value, writable: true, configurable: true });

package/dist/leavings.d.ts

@@ -0,0 +1,26 @@
+import { type Cut } from './transport.js';
+import type { Left, Subject } from './voice.js';
+/**
+ * Under history, the records subjects left a voice with, while a seek or a read back may reach
+ * them: in the order they left, the oldest let go of from the front, and each subject's found
+ * without looking through the others'.
+ */
+export declare class Leavings<I> {
+    private list;
+    /** How many at the front of `list` have been let go of, cleared out once they are half of it. */
+    private head;
+    private readonly by;
+    static from<I>(entries: readonly Left<I>[]): Leavings<I> | null;
+    push(e: Left<I>): void;
+    /**
+     * Lets go of every entry that left before `reach`, handing each to `out` first. They are at the
+     * front: entries are in the order they left, and mix time does not run back along it.
+     */
+    expire(reach: number, out: ((e: Left<I>) => void) | null): void;
+    /** The record `subject` had at `cut` and left with after it, if it left after `cut`. */
+    at(subject: I, cut: Cut): Subject<unknown> | undefined;
+    /** Each time `subject` left, oldest first. */
+    of(subject: I): readonly Left<I>[];
+    /** Every entry, oldest first. */
+    all(): readonly Left<I>[];
+}

package/dist/leavings.js

@@ -0,0 +1,70 @@
+import { Store } from './store.js';
+import { within } from './transport.js';
+/**
+ * Under history, the records subjects left a voice with, while a seek or a read back may reach
+ * them: in the order they left, the oldest let go of from the front, and each subject's found
+ * without looking through the others'.
+ */
+export class Leavings {
+    list = [];
+    /** How many at the front of `list` have been let go of, cleared out once they are half of it. */
+    head = 0;
+    by = new Store();
+    static from(entries) {
+        if (entries.length === 0)
+            return null;
+        const out = new Leavings();
+        for (const e of entries)
+            out.push(e);
+        return out;
+    }
+    push(e) {
+        this.list.push(e);
+        const own = this.by.get(e.subject);
+        if (own === undefined)
+            this.by.set(e.subject, [e]);
+        else
+            own.push(e);
+    }
+    /**
+     * Lets go of every entry that left before `reach`, handing each to `out` first. They are at the
+     * front: entries are in the order they left, and mix time does not run back along it.
+     */
+    expire(reach, out) {
+        const list = this.list;
+        let head = this.head;
+        while (head < list.length && !(list[head].at >= reach)) {
+            const e = list[head++];
+            if (out !== null)
+                out(e);
+            const own = this.by.get(e.subject);
+            if (own.length === 1)
+                this.by.delete(e.subject);
+            else
+                own.shift();
+        }
+        this.head = head;
+        if (head >= 32 && head * 2 >= list.length) {
+            this.list = list.slice(head);
+            this.head = 0;
+        }
+    }
+    /** The record `subject` had at `cut` and left with after it, if it left after `cut`. */
+    at(subject, cut) {
+        const own = this.by.get(subject);
+        if (own === undefined)
+            return undefined;
+        for (const e of own)
+            if (!within(cut, e.seq, e.sync))
+                return e.held;
+        return undefined;
+    }
+    /** Each time `subject` left, oldest first. */
+    of(subject) {
+        return this.by.get(subject) ?? [];
+    }
+    /** Every entry, oldest first. */
+    all() {
+        return this.head === 0 ? this.list : this.list.slice(this.head);
+    }
+}

package/dist/locus.js

@@ -1,4 +1,4 @@
-import { copy } from './clone.js';
+import { first } from './clone.js';
 export function locusScratch(channels) {
     return {
         n: 0,
@@ -70,7 +70,7 @@ export function foldLocus(k, group) {
                 k.values[slot] =
                     this.lerpsInto[slot] !== undefined && channel.scale && Array.isArray(value)
                         ? own(k, slot, value, channel.rest)
-                        : copy(value);
+                        : first(value);
                 continue;
             }
             const total = taken[slot] + weight;

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;