@msb235/blits 0.7.1 → 0.8.0

package/dist/keyfill.d.ts

@@ -0,0 +1,7 @@
+import { type Lane } from './lane.js';
+import type { Lanes } from './lanes.js';
+/**
+ * A keys voice's fill outside a locus, its weight a number: what `one` does for each subject, in
+ * one loop, so no weight or time crosses a call as a boxed double per subject.
+ */
+export declare function runKeys<I, O>(lanes: Lanes<I, O>, lane: Lane<I, O>): void;

package/dist/keyfill.js

@@ -0,0 +1,124 @@
+import { foldNumber } from './channels.js';
+import { clampWeight, frozenTime, phaseAt, same, weighed } from './clock.js';
+import { shortWay } from './turns.js';
+/**
+ * A keys voice's fill outside a locus, its weight a number: what `one` does for each subject, in
+ * one loop, so no weight or time crosses a call as a boxed double per subject.
+ */
+export function runKeys(lanes, lane) {
+    const voice = lane.voice;
+    const data = lane.data;
+    const per = lanes.per;
+    const list = lane.list;
+    const records = lane.records;
+    const chans = lane.chans;
+    const read = lane.values;
+    const n = chans.length;
+    const fills = lanes.fills;
+    const lately = lanes.lately;
+    const elapsedNow = voice.elapsedAt(lanes.now);
+    const duration = voice.duration;
+    const passes = voice.passes;
+    const before = voice.freezesBefore;
+    const after = voice.freezesAfter;
+    const span = voice.span;
+    const flat = lane.flat;
+    const parts = voice.parts !== null;
+    const whole = clampWeight(voice.weight);
+    let width = 0;
+    for (let i = 0; i < n; i++)
+        width += chans[i].axes;
+    if (lane.nums.length < width)
+        lane.nums = new Float64Array(width);
+    if (lane.kinds.length < n)
+        lane.kinds = new Uint8Array(n);
+    const nums = lane.nums;
+    const kinds = lane.kinds;
+    for (let p = 0; p < list.length; p++) {
+        const slot = list[p];
+        const o = p * 8 /* Row.STRIDE */;
+        if (per[slot * 6 /* Per.SLOT */ + 5 /* Per.LANE_FILL */] === fills - 1)
+            data[o + 3 /* Row.PROBED */] = data[o + 2 /* Row.WEIGHT */];
+        if (lately >= 0 && lanes.unread(slot))
+            continue;
+        const elapsed = frozenTime(elapsedNow - data[o + 0 /* Row.DELAY */], before, after, span);
+        if (!(elapsed >= 0)) {
+            data[o + 2 /* Row.WEIGHT */] = 0;
+            continue;
+        }
+        if (!flat) {
+            const since = data[o + 1 /* Row.SINCE */];
+            if (!lane.weighed || !same(since, lane.weighedSince)) {
+                lane.fade = lanes.host.envelope(voice, since);
+                lane.weighed = true;
+                lane.weighedSince = since;
+            }
+        }
+        const w = flat && !parts ? whole : weighed(voice.weight, lane.fade, lanes.parting(voice, slot));
+        data[o + 2 /* Row.WEIGHT */] = w;
+        if (!lane.read || !same(elapsed, lane.readAt)) {
+            lanes.readKeyed(voice, phaseAt(elapsed, duration, passes), lane.delta, lane.scratch);
+            lane.read = true;
+            lane.readAt = elapsed;
+            lanes.gather(lane, lane.delta);
+            flatten(chans, read, nums, kinds);
+        }
+        if (!(w > 0))
+            continue;
+        let k = 0;
+        for (let i = 0; i < n; i++) {
+            const ch = chans[i];
+            const axes = ch.axes;
+            const kind = kinds[i];
+            if (kind === 1 /* Kind.NUMBERS */) {
+                const values = ch.values;
+                const base = slot * axes;
+                for (let a = 0; a < axes; a++)
+                    values[base + a] = foldNumber(ch.op, values[base + a], nums[k + a], w);
+            }
+            else if (kind === 2 /* Kind.GATED */) {
+                lanes.folding = lane;
+                lanes.rec = records[p] ?? null;
+                lanes.arg[0 /* Arg.WEIGHT */] = w;
+                lanes.foldInto(ch, slot, read[i]);
+            }
+            k += axes;
+        }
+    }
+}
+/**
+ * A keys read's values as the numbers `foldInto` would fold, an array read past its end as the rest:
+ * read here once per read, since reading a number out of a delta's array for each subject boxes it.
+ */
+function flatten(chans, read, nums, kinds) {
+    let k = 0;
+    for (let i = 0; i < chans.length; i++) {
+        const ch = chans[i];
+        const value = read[i];
+        if (value === undefined)
+            kinds[i] = 0 /* Kind.ABSENT */;
+        else if (!ch.plain)
+            kinds[i] = unplain(ch, value, nums, k);
+        else {
+            kinds[i] = 1 /* Kind.NUMBERS */;
+            if (ch.scalar)
+                nums[k] = value;
+            else {
+                const arr = Array.isArray(value) || ArrayBuffer.isView(value) ? value : null;
+                for (let a = 0; a < ch.axes; a++)
+                    nums[k + a] = arr === null ? ch.rest : (arr[a] ?? ch.rest);
+            }
+        }
+        k += ch.axes;
+    }
+}
+/**
+ * `flatten` for a channel that is not plain. An angle's number is taken the short way round here,
+ * and then folds as the sum it is; a rest-less channel and a quat fold through `foldInto`.
+ */
+function unplain(ch, value, nums, k) {
+    if (!(ch.turn > 0))
+        return 2 /* Kind.GATED */;
+    nums[k] = shortWay(value, ch.turn);
+    return 1 /* Kind.NUMBERS */;
+}

package/dist/keyrows.d.ts

@@ -5,6 +5,7 @@ import { type Built } from './patch.js';
 export interface KeyChannel {
     scalar: boolean;
     op: Numeric['op'];
+    plain: boolean;
     rest: number;
     axes: number;
     values: Float64Array;

package/dist/keyrows.js

@@ -23,7 +23,7 @@ export class KeyRows {
         for (let i = 0; i < built.tracks.length; i++) {
             const track = built.tracks[i];
             const ch = chans[i];
-            if (track === undefined || ch === undefined)
+            if (track === undefined || ch === undefined || !ch.plain)
                 return -1;
             for (const pt of track.all)
                 if (!flat(pt.value, ch))

package/dist/lane.d.ts

@@ -1,6 +1,7 @@
 import type { Numeric } from './channels.js';
 import type { Motions } from './motions.js';
 import type { Scratch } from './patch.js';
+import type { Channel } from './types.js';
 import type { Subject, Voice } from './voice.js';
 /** One laned channel: its arithmetic, and every numbered subject's folded value, `axes` per subject. */
 export interface Laned {
@@ -8,6 +9,12 @@ export interface Laned {
     /** Its value is a number, its rest a number; otherwise an array, which `vec(1)` is too. */
     scalar: boolean;
     op: Numeric['op'];
+    /** Its values fold as its `op` alone: not through a band as `'last'` does, and not a rotation. */
+    plain: boolean;
+    /** An angle's full turn, and 0 for any other channel. */
+    turn: number;
+    /** The channel, whose own `fold` and `lerp` an `'own'` lane calls. */
+    channel: Channel<unknown>;
     rest: number;
     axes: number;
     values: Float64Array;
@@ -56,6 +63,24 @@ export declare const enum Begin {
     GENERAL = 0,
     READY = 1
 }
+/**
+ * Where each number a fill hands from one of its methods to the next sits in `Lanes.arg`. Passed as
+ * an argument, a double is boxed wherever V8 does not inline the call: 16 bytes a number a subject
+ * (bench/allocs.mjs, 2026-10-09). The caller writes them just before the call, and the callee reads
+ * them before it calls anything else.
+ */
+export declare const enum Arg {
+    /** The weight to fold at. */
+    WEIGHT = 0,
+    /** The subject's voice time, its freezes applied. */
+    ELAPSED = 1,
+    PHASE = 2,
+    PASS = 3,
+    DELAY = 4,
+    /** The voice's own fade, for `signalled`. */
+    FADE = 5,
+    SIZE = 6
+}
 /** Where each of a subject's `SLOT` numbers in `Lanes.per` sits. */
 export declare const enum Per {
     SLOT = 6,
@@ -98,8 +123,8 @@ export interface Paced {
     data: Float64Array;
 }
 /**
- * Where a motion voice's per-subject numbers live, by position: a lane of one voice, or the crowd
- * of single-subject motion voices, whose positions each belong to a voice of their own.
+ * Where a motion voice's per-subject numbers live, by position: a lane of one voice, or a crowd
+ * of single-subject voices, whose positions each belong to a voice of their own.
  */
 export interface Positions<I, O> {
     /** `STRIDE` numbers per position. */
@@ -164,6 +189,9 @@ export declare class Lane<I, O> implements Positions<I, O> {
     chans: Laned[];
     /** The value read for each of `chans`, for the subject being folded. */
     values: unknown[];
+    /** A keys read's `values` as numbers, each channel's axes side by side, and how each folds. */
+    nums: Float64Array<ArrayBuffer>;
+    kinds: Uint8Array<ArrayBuffer>;
     /**
      * Within one fill, the last elapsed placed and the last `since` weighed, with what they gave, so
      * subjects sharing a delay or a start share the arithmetic: the same inputs give the same bits.
@@ -179,6 +207,8 @@ export declare class Lane<I, O> implements Positions<I, O> {
     fade: number;
     /** Whether the voice has no fade in or out this fill, so its envelope is 1 for every subject. */
     flat: boolean;
+    /** The voice's clock at this fill, set before `one` runs its subjects. */
+    elapsedNow: number;
     /** A motion patch's state, which the lane samples in place of calling the patch. */
     readonly motion: Motions<I> | undefined;
     /** By the motion patch's number for a subject, its position plus one, 0 where it has none. */

package/dist/lane.js

@@ -52,6 +52,9 @@ export class Lane {
     chans = [];
     /** The value read for each of `chans`, for the subject being folded. */
     values = [];
+    /** A keys read's `values` as numbers, each channel's axes side by side, and how each folds. */
+    nums = new Float64Array(0);
+    kinds = new Uint8Array(0);
     /**
      * Within one fill, the last elapsed placed and the last `since` weighed, with what they gave, so
      * subjects sharing a delay or a start share the arithmetic: the same inputs give the same bits.
@@ -67,6 +70,8 @@ export class Lane {
     fade = 1;
     /** Whether the voice has no fade in or out this fill, so its envelope is 1 for every subject. */
     flat = false;
+    /** The voice's clock at this fill, set before `one` runs its subjects. */
+    elapsedNow = 0;
     /** A motion patch's state, which the lane samples in place of calling the patch. */
     motion;
     /** By the motion patch's number for a subject, its position plus one, 0 where it has none. */

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);
+    }
+}