@msb235/blits 0.14.0 → 0.15.1

package/dist/lane.js

@@ -1,6 +1,14 @@
 import { unbareLane } from './bare.js';
-import { frozenTime } from './clock.js';
 import { motionOf } from './motion.js';
+/**
+ * Keeps the weight a probe read from the last fill as `Row.PROBED`, for `weightOf`, before a fill
+ * writes the position's new weight; reads `per` only where the copy could change a bit.
+ */
+export function keepProbed(data, o, per, q, fills) {
+    const w = data[o + 2 /* Row.WEIGHT */];
+    if ((w !== data[o + 3 /* Row.PROBED */] || w === 0) && per[q + 5 /* Per.LANE_FILL */] === fills - 1)
+        data[o + 3 /* Row.PROBED */] = w;
+}
 /**
  * Below what share of its subjects probed last frame a lane stops filling, and above what share it
  * fills again; between the two it keeps doing what it did, so a host near the line does not flip
@@ -70,6 +78,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 fill that last ran it, so what it remembers within one fill is that fill's. */
+    ran = -1;
     /** 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. */
@@ -80,8 +90,12 @@ export class Lane {
     bareFill = -1;
     bareElapsed = Number.NaN;
     bareSeeks = Number.NaN;
-    /** The locus its voice shares, gathered before the voices are folded in order. */
+    /** The role its voice shares, gathered before the voices are folded in order. */
     group = null;
+    /** The `Arg.MARK` it was last placed under, for a role run a subject at a time to put back. */
+    mark = Number.NaN;
+    /** Whether it took every subject when it opened, so a fill makes each one's first call. */
+    every = false;
     voiceAt() {
         return this.voice;
     }
@@ -128,6 +142,22 @@ export class Lane {
     positionOf(slot) {
         return slot < this.at.length ? this.at[slot] - 1 : -1;
     }
+    /**
+     * Room for `n` positions and subject numbers below `cap`, for a voice that reaches every subject:
+     * grown as it met them, a voice replaced every frame regrew both from nothing each frame.
+     */
+    reserve(n, cap) {
+        if (n * 8 /* Row.STRIDE */ > this.data.length) {
+            const data = new Float64Array(n * 8 /* Row.STRIDE */);
+            data.set(this.data);
+            this.data = data;
+        }
+        if (cap > this.at.length) {
+            const at = new Int32Array(cap);
+            at.set(this.at);
+            this.at = at;
+        }
+    }
     /** Gives a subject the voice reaches a position, from what its record fixed on first sight. */
     add(slot, held) {
         const p = this.list.length;
@@ -154,6 +184,20 @@ export class Lane {
         this.records[p] = held;
         this.deltas[p] = null;
     }
+    /** The subject numbered `from` is numbered `to` now, a number no position holds: same position. */
+    renumber(from, to) {
+        const p = this.positionOf(from);
+        if (p < 0)
+            return;
+        if (to >= this.at.length) {
+            const at = new Int32Array(Math.max(to + 1, this.at.length * 2, 64));
+            at.set(this.at);
+            this.at = at;
+        }
+        this.list[p] = to;
+        this.at[to] = p + 1;
+        this.at[from] = 0;
+    }
     /** A subject lost its number: the last position moves into its place. */
     remove(slot) {
         const p = this.positionOf(slot);
@@ -183,12 +227,3 @@ export class Lane {
         this.deltas[last] = null;
     }
 }
-/**
- * A subject's voice time once its voice's freezes apply: frozen at 0 before it starts and at the end
- * of its passes after, and NaN where it shows nothing, as past its end running back.
- */
-export function frozenAt(voice, elapsed) {
-    if (elapsed > voice.span && voice.hidesPast)
-        return Number.NaN;
-    return frozenTime(elapsed, voice.freezesBefore, voice.freezesAfter, voice.span);
-}

package/dist/lanes.d.ts

@@ -1,15 +1,17 @@
 import type { Column } from './columns.js';
-import { copy } from './copyout.js';
+import { type Copier, copy } from './copyout.js';
 import { type Crowd, row } from './crowd.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 Lane, type Laned, type Role } from './lane.js';
 import { absent, Numbers } from './numbers.js';
 import { Owed } from './owed.js';
 import { Placed } from './placed.js';
+import { type Seat } from './seat.js';
+import type { Watcher } from './stretch.js';
+import type { Subject } from './subject.js';
 import type { Channel } from './types.js';
-import type { Subject, Voice } from './voice.js';
+import type { Voice } from './voice.js';
 /** What a lane fill asks of the mix it belongs to. */
 export interface LaneHost<I, O> {
     readonly voices: readonly Voice<I, O>[];
@@ -69,7 +71,7 @@ export declare class Lanes<I, O> implements Watcher {
     readonly byId: Map<number, Lane<I, O>>;
     /** 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>>;
+    readonly seats: Map<number, Seat<I, O>>;
     /** Which crowd voices' rows are placed on each subject. */
     readonly placed: Placed;
     /**
@@ -79,15 +81,20 @@ export declare class Lanes<I, O> implements Watcher {
     unlinked: Float64Array<ArrayBuffer>;
     /** Whether two crowds share a channel, so their rows must interleave in voice order. */
     overlap: boolean;
-    /** The loci whose voices are on lanes, every member of each on one. */
-    loci: Locus<I, O>[];
+    /** The roles whose voices are on lanes, every member of each on one. */
+    roles: Role<I, O>[];
     /** The lane and record `one` is folding, whose band state a rest-less channel reads. */
     folding: Lane<I, O> | null;
+    /** Whether a probe meeting lanes has `one` make their first call for its subject: see `meet`. */
+    meeting: boolean;
+    /** The lanes the last subject met and `foldNow` folded at its probe, and the fill it did so in. */
+    folds: number[];
+    foldsFill: number;
     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;
+    /** While a fill gathers a role: that role and the member gathering, where folds go instead. */
+    into: Role<I, O> | null;
     intoId: number;
     readonly lawsByKey: Map<string, Float64Array<ArrayBufferLike>>;
     lastLaw: Float64Array | null;
@@ -102,6 +109,8 @@ export declare class Lanes<I, O> implements Watcher {
     /** By subject number, the laned voices its probes fold on the general path this fill. */
     readonly owed: Owed;
     laned: Laned[];
+    /** Writes `laned`'s values for a subject into a pose; made at the first copy after they change. */
+    copier: Copier | null;
     /** By kit slot, the laned channel there. */
     bySlot: (Laned | undefined)[];
     /** By kit slot, whether a fill leaves the channel's values for probes to copy. */
@@ -138,6 +147,13 @@ export declare class Lanes<I, O> implements Watcher {
     subjects: (I | typeof absent | undefined)[];
     /** Whether a probe has held a subject since the last fill let them go. */
     holding: boolean;
+    /**
+     * Whether probes hold their subjects for the next fill: while the last fill looked one up. A
+     * fill of bare tweens never does, and holding cost a store a subject and a clear a frame.
+     */
+    holds: boolean;
+    /** How many times a fill or a probe has looked a subject up by number, for `holds`. */
+    lookups: number;
     /** While a fill runs, so a probe a patch makes from inside it takes the general path. */
     filling: boolean;
     /**
@@ -146,14 +162,16 @@ export declare class Lanes<I, O> implements Watcher {
      */
     readonly late: number[];
     /**
-     * What `writeLater` and `pullRun` have queued, for one set of columns, as runs: each run's first
-     * lane slot, the row it goes to, and how many subjects follow both one apart.
+     * What `writeLater` and `pullRun` have queued, for one set of columns, as runs of rows: each
+     * run's first row and how many follow, and its first lane slot where its slots follow one apart
+     * too, else -1, when each row's slot is read from `queueFrom` by row.
      */
     queueSlots: Int32Array<ArrayBuffer>;
     queueRows: Int32Array<ArrayBuffer>;
     queueCounts: Int32Array<ArrayBuffer>;
     queued: number;
     queuedFor: readonly Column[] | null;
+    queueFrom: Int32Array | null;
     keeps: boolean;
     now: number;
     filledAt: number;
@@ -270,7 +288,7 @@ export declare class Lanes<I, O> implements Watcher {
     /** 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;
+    voiceChanged(voice: Voice<I, O>): void;
 }
 declare const methods: {
     copy: typeof copy;

package/dist/lanes.js

@@ -1,3 +1,4 @@
+import { lit } from './bound.js';
 import { copy } from './copyout.js';
 import { row } from './crowd.js';
 import { call, fillAll, foldKeys, one, parting, readKeyed, reset, run, runEveryone, signalled, subjectAt, } from './fill.js';
@@ -9,6 +10,7 @@ import { Placed } from './placed.js';
 import { requalify, retouch } from './qualify.js';
 import { reading } from './reading.js';
 import { reportedRow, unplace } from './rows.js';
+import { seatOf } from './seat.js';
 /**
  * The lanes of one mix: subject numbers, which channels and voices run on lanes, and the values a
  * frame's fill leaves for probes to copy.
@@ -23,7 +25,7 @@ export class Lanes {
     byId = new Map();
     /** The crowds of single-subject voices, one per list of channels, and which holds each voice. */
     crowds = [];
-    crowdOf = new Map();
+    seats = new Map();
     /** Which crowd voices' rows are placed on each subject. */
     placed = new Placed();
     /**
@@ -33,14 +35,19 @@ export class Lanes {
     unlinked = new Float64Array(0);
     /** Whether two crowds share a channel, so their rows must interleave in voice order. */
     overlap = false;
-    /** The loci whose voices are on lanes, every member of each on one. */
-    loci = [];
+    /** The roles whose voices are on lanes, every member of each on one. */
+    roles = [];
     /** The lane and record `one` is folding, whose band state a rest-less channel reads. */
     folding = null;
+    /** Whether a probe meeting lanes has `one` make their first call for its subject: see `meet`. */
+    meeting = false;
+    /** The lanes the last subject met and `foldNow` folded at its probe, and the fill it did so in. */
+    folds = [];
+    foldsFill = -1;
     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. */
+    arg = new Float64Array(8 /* Arg.SIZE */);
+    /** While a fill gathers a role: that role and the member gathering, where folds go instead. */
     into = null;
     intoId = 0;
     lawsByKey = new Map();
@@ -56,6 +63,8 @@ export class Lanes {
     /** By subject number, the laned voices its probes fold on the general path this fill. */
     owed = new Owed();
     laned = [];
+    /** Writes `laned`'s values for a subject into a pose; made at the first copy after they change. */
+    copier = null;
     /** By kit slot, the laned channel there. */
     bySlot = [];
     /** By kit slot, whether a fill leaves the channel's values for probes to copy. */
@@ -92,6 +101,13 @@ export class Lanes {
     subjects = [];
     /** Whether a probe has held a subject since the last fill let them go. */
     holding = false;
+    /**
+     * Whether probes hold their subjects for the next fill: while the last fill looked one up. A
+     * fill of bare tweens never does, and holding cost a store a subject and a clear a frame.
+     */
+    holds = true;
+    /** How many times a fill or a probe has looked a subject up by number, for `holds`. */
+    lookups = 0;
     /** While a fill runs, so a probe a patch makes from inside it takes the general path. */
     filling = false;
     /**
@@ -100,14 +116,16 @@ export class Lanes {
      */
     late = [];
     /**
-     * What `writeLater` and `pullRun` have queued, for one set of columns, as runs: each run's first
-     * lane slot, the row it goes to, and how many subjects follow both one apart.
+     * What `writeLater` and `pullRun` have queued, for one set of columns, as runs of rows: each
+     * run's first row and how many follow, and its first lane slot where its slots follow one apart
+     * too, else -1, when each row's slot is read from `queueFrom` by row.
      */
     queueSlots = new Int32Array(0);
     queueRows = new Int32Array(0);
     queueCounts = new Int32Array(0);
     queued = 0;
     queuedFor = null;
+    queueFrom = null;
     keeps = false;
     now = Number.NaN;
     filledAt = Number.NaN;
@@ -218,10 +236,9 @@ export class Lanes {
             lane.remove(slot);
             return;
         }
-        const c = this.crowdOf.get(id);
-        const p = c?.rowOf.get(id);
-        if (c !== undefined && p !== undefined && c.list[p] === slot)
-            unplace(this, c, p);
+        const s = this.seats.get(id);
+        if (s !== undefined && s.crowd.list[s.row] === slot)
+            unplace(this, s.crowd, s.row);
     }
     /** A voice brought a subject back: its next probe meets every lane again, as it met them first. */
     rejoin(slot) {
@@ -239,9 +256,8 @@ export class Lanes {
         const lane = this.byId.get(id);
         if (lane !== undefined)
             return this.reported(lane, slot);
-        const c = this.crowdOf.get(id);
-        const p = c?.rowOf.get(id);
-        return c === undefined || p === undefined ? undefined : reportedRow(this, c, p, slot);
+        const s = this.seats.get(id);
+        return s === undefined ? undefined : reportedRow(this, s.crowd, s.row, slot);
     }
     reported(lane, slot) {
         const o = slot * 6 /* Per.SLOT */;
@@ -275,8 +291,10 @@ export class Lanes {
         if (lane) {
             per[o + 3 /* Per.LANE_PROBE */] = probe;
             per[o + 5 /* Per.LANE_FILL */] = this.fills;
-            this.subjects[slot] = subject;
-            this.holding = true;
+            if (this.holds) {
+                this.subjects[slot] = subject;
+                this.holding = true;
+            }
         }
         else
             per[o + 4 /* Per.GENERAL_PROBE */] = probe;
@@ -381,8 +399,12 @@ export class Lanes {
     paid(id, slot, w) {
         const lane = this.byId.get(id);
         const p = lane === undefined ? -1 : lane.positionOf(slot);
-        if (p >= 0)
-            lane.data[p * 8 /* Row.STRIDE */ + 2 /* Row.WEIGHT */] = w;
+        if (p < 0)
+            return;
+        lane.data[p * 8 /* Row.STRIDE */ + 2 /* Row.WEIGHT */] = w;
+        const b = lane.voice.bound;
+        if (b !== null && w !== 0)
+            lit(b, slot, this.fills);
     }
     /**
      * Whether a subject's laned values are at their channels' rest, as `atRest` reads the pose `copy`
@@ -418,10 +440,9 @@ export class Lanes {
             lane.remove(slot);
         const placed = this.placed;
         for (let id = placed.any(slot); id !== 0; id = placed.any(slot)) {
-            const c = this.crowdOf.get(id);
-            const p = c?.rowOf.get(id);
-            if (c !== undefined && p !== undefined && c.list[p] === slot)
-                unplace(this, c, p);
+            const s = this.seats.get(id);
+            if (s !== undefined && s.crowd.list[s.row] === slot)
+                unplace(this, s.crowd, s.row);
             else
                 placed.remove(slot, id);
         }
@@ -453,10 +474,10 @@ export class Lanes {
      * next fill, and a lane keeps the sample the old one gave.
      */
     stretchChanged(id, s) {
-        const c = this.crowdOf.get(id);
-        const p = c?.rowOf.get(id);
-        if (c !== undefined && p !== undefined) {
-            c.restale(p, c.hot[p * c.stride + 0 /* Hot.FLAGS */]);
+        const seat = this.seats.get(id);
+        if (seat !== undefined) {
+            const c = seat.crowd;
+            c.restale(seat.row, c.hot[seat.row * c.stride + 0 /* Hot.FLAGS */]);
             return;
         }
         const lane = this.byId.get(id);
@@ -481,12 +502,11 @@ export class Lanes {
     }
     /** 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];
+        const s = this.seats.get(id);
+        if (s !== undefined) {
+            const held = s.crowd.records[s.row];
             if (held !== undefined)
-                c.data[p * 8 /* Row.STRIDE */ + 1 /* Row.SINCE */] = held.shown;
+                s.crowd.data[s.row * 8 /* Row.STRIDE */ + 1 /* Row.SINCE */] = held.shown;
         }
         const lane = this.byId.get(id);
         if (lane === undefined)
@@ -498,12 +518,12 @@ export class Lanes {
         }
     }
     /** Something on a voice changed: a crowd copies it again at the next fill. */
-    voiceChanged(id) {
-        const c = this.crowdOf.get(id);
-        const p = c?.rowOf.get(id);
-        if (c === undefined || p === undefined)
+    voiceChanged(voice) {
+        const s = seatOf(this, voice);
+        if (s === null)
             return;
-        const f = p * c.stride + 0 /* Hot.FLAGS */;
+        const c = s.crowd;
+        const f = s.row * c.stride + 0 /* Hot.FLAGS */;
         c.hot[f] = c.hot[f] | 64 /* Flag.VOICE */;
     }
 }

package/dist/leavings.d.ts

@@ -1,5 +1,5 @@
-import { type Cut } from './transport.js';
-import type { Left, Subject } from './voice.js';
+import { type Cut } from './cut.js';
+import type { Left, Subject } from './subject.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

package/dist/leavings.js

@@ -1,5 +1,5 @@
+import { within } from './cut.js';
 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

package/dist/lives.d.ts

@@ -0,0 +1,47 @@
+import { type Cut } from './cut.js';
+import type { Motions } from './motions.js';
+import { type Change, type Paging, type Run } from './stretch.js';
+/** A run a release kept, with when: `early` where the release came before anything read its frame. */
+export type Released<I> = {
+    subject: I;
+    at: number;
+    seq: number;
+    early: boolean;
+} & Run;
+/**
+ * Forgets a subject, so a later ask starts it afresh from `from`. Given the mix time `at` and frame
+ * `seq`, under history, its run is kept for a rewind before then, until `reach` passes it.
+ */
+export declare function release<I>(this: Motions<I>, subject: I, at?: number, reach?: number, seq?: number, early?: boolean): void;
+/** Puts back each subject released after frame `seq`, as it stood when released. */
+export declare function unrelease<I>(this: Motions<I>, seq: number): void;
+/** Subject `s`'s run as it stands. */
+export declare function runAt<I>(this: Motions<I>, s: number): Run;
+/** A subject's run as plain data, for a voice leaving memory; undefined where it has none. */
+export declare function pack<I>(this: Motions<I>, subject: I): Run | undefined;
+/** Puts a subject's run back as `pack` or a release left it, replacing any it has now. */
+export declare function unpack<I>(this: Motions<I>, subject: I, run: Run): void;
+/** A released run a history store gave back, for a rewind to before its release. */
+export declare function reclaim<I>(this: Motions<I>, subject: I, at: number, seq: number, run: Run & {
+    early?: boolean;
+}): void;
+/**
+ * The run `subject` had in frame `cut`: the one a release after the cut kept, else the one it has
+ * now; undefined where it has neither. Its changes after the cut are still on it.
+ */
+export declare function runThen<I>(this: Motions<I>, subject: I, cut: Cut): Run | undefined;
+/**
+ * Stretches a history store gave back, each by the frame it was in force by: each life of the
+ * subject, ended by a release, takes those from its own, ahead of the earliest it still keeps.
+ */
+export declare function restretch<I>(this: Motions<I>, subject: I, back: readonly Paging[]): void;
+/**
+ * The mix time and frame a stretch was in force by, which a store keys it under: when the change
+ * that ended it was made, which falls in the same life of the subject.
+ */
+export declare function made<I>(this: Motions<I>, c: Change | undefined): {
+    at: number;
+    seq: number;
+};
+/** Lets go of stretches older than the one in force at `reading.horizon`. */
+export declare function prune<I>(this: Motions<I>, s: number): void;

package/dist/lives.js

@@ -0,0 +1,180 @@
+import { within } from './cut.js';
+import { absent } from './numbers.js';
+import { reading } from './reading.js';
+const PENDING = 2 /* RunFlag.PENDING */;
+const OLDER = 4 /* RunFlag.OLDER */;
+/** A run that shares nothing with the patch's own. */
+const runOf = (r) => ({
+    flags: r.flags,
+    stretches: r.stretches.map((seg) => ({ ...seg })),
+    pending: r.pending?.map((c) => ({ ...c })),
+});
+/** `segs`, in time order, ahead of `list`: those older than its first, one per time. */
+function ahead(segs, list) {
+    const first = list[0].at;
+    const out = [];
+    for (const seg of [...segs].sort((x, y) => x.at - y.at))
+        if (seg.at < first && out[out.length - 1]?.at !== seg.at)
+            out.push(seg);
+    return out.length === 0 ? list : [...out, ...list];
+}
+/**
+ * Forgets a subject, so a later ask starts it afresh from `from`. Given the mix time `at` and frame
+ * `seq`, under history, its run is kept for a rewind before then, until `reach` passes it.
+ */
+export function release(subject, at, reach = Number.NEGATIVE_INFINITY, seq = Number.NaN, early = false) {
+    const s = this.known(subject);
+    if (s === undefined)
+        return;
+    if (at !== undefined) {
+        const kept = [];
+        for (const e of this.released)
+            if (e.at >= reach)
+                kept.push(e);
+            else
+                this.owner?.page(this.ownerId, 'released', e.subject, [
+                    { at: e.at, seq: e.seq, data: { ...runOf(e), early: e.early } },
+                ]);
+        this.released = kept;
+        this.released.push({ subject, at, seq, early, ...this.runAt(s) });
+    }
+    this.slots.delete(subject);
+    this.numbers.release(s);
+}
+/** Puts back each subject released after frame `seq`, as it stood when released. */
+export function unrelease(seq) {
+    const back = this.released.filter((e) => e.seq > seq).sort((a, b) => a.seq - b.seq);
+    if (back.length === 0)
+        return;
+    this.released = this.released.filter((e) => e.seq <= seq);
+    const done = new Set();
+    for (const e of back) {
+        if (done.has(e.subject))
+            continue;
+        done.add(e.subject);
+        this.unpack(e.subject, e);
+    }
+}
+/** Subject `s`'s run as it stands. */
+export function runAt(s) {
+    const older = this.older?.[s];
+    const pending = this.pending?.[s];
+    return {
+        flags: this.runs[this.base(s) + 1],
+        stretches: older === undefined ? [this.latest(s)] : [...older, this.latest(s)],
+        pending: pending === undefined ? undefined : [...pending],
+    };
+}
+/** A subject's run as plain data, for a voice leaving memory; undefined where it has none. */
+export function pack(subject) {
+    const s = this.known(subject);
+    return s === undefined ? undefined : runOf(this.runAt(s));
+}
+/** Puts a subject's run back as `pack` or a release left it, replacing any it has now. */
+export function unpack(subject, run) {
+    const now = this.known(subject);
+    if (now !== undefined) {
+        this.slots.delete(subject);
+        this.numbers.release(now);
+    }
+    if (this.n < 0)
+        this.size(run.stretches[0].x0.length);
+    const s = this.take(subject);
+    this.runs[this.base(s) + 1] = run.flags & ~(OLDER | PENDING);
+    const latest = run.stretches[run.stretches.length - 1];
+    this.write(s, latest);
+    if (run.stretches.length > 1) {
+        if (this.older === null)
+            this.older = [undefined];
+        this.older[s] = run.stretches.slice(0, -1);
+        this.flag(s, OLDER, true);
+    }
+    if (run.pending !== undefined) {
+        if (this.pending === null)
+            this.pending = [undefined];
+        this.pending[s] = run.pending;
+        this.flag(s, PENDING, true);
+    }
+}
+/** A released run a history store gave back, for a rewind to before its release. */
+export function reclaim(subject, at, seq, run) {
+    if (this.released.some((e) => e.seq === seq && Object.is(e.subject, subject)))
+        return;
+    this.released.push({ subject, at, seq, ...run, early: run.early === true });
+}
+/**
+ * The run `subject` had in frame `cut`: the one a release after the cut kept, else the one it has
+ * now; undefined where it has neither. Its changes after the cut are still on it.
+ */
+export function runThen(subject, cut) {
+    let life;
+    for (const e of this.released)
+        if (Object.is(e.subject, subject) &&
+            !within(cut, e.seq, e.early) &&
+            (life === undefined || e.seq < life.seq))
+            life = e;
+    if (life !== undefined)
+        return life;
+    const s = this.known(subject);
+    return s === undefined ? undefined : this.runAt(s);
+}
+/**
+ * Stretches a history store gave back, each by the frame it was in force by: each life of the
+ * subject, ended by a release, takes those from its own, ahead of the earliest it still keeps.
+ */
+export function restretch(subject, back) {
+    const lives = this.released
+        .filter((e) => Object.is(e.subject, subject))
+        .sort((x, y) => x.seq - y.seq);
+    let from = Number.NEGATIVE_INFINITY;
+    const within = (to) => back.filter((r) => r.seq > from && r.seq <= to).map((r) => r.data);
+    for (const e of lives) {
+        e.stretches = ahead(within(e.seq), e.stretches);
+        from = e.seq;
+    }
+    const s = this.known(subject);
+    if (s === undefined)
+        return;
+    const older = this.older?.[s] ?? [];
+    const list = ahead(within(Number.POSITIVE_INFINITY), [...older, this.latest(s)]);
+    if (list.length === older.length + 1)
+        return;
+    if (this.older === null)
+        this.older = [undefined];
+    this.older[s] = list.slice(0, -1);
+    this.flag(s, OLDER, true);
+}
+/**
+ * The mix time and frame a stretch was in force by, which a store keys it under: when the change
+ * that ended it was made, which falls in the same life of the subject.
+ */
+export function made(c) {
+    const made = c?.made;
+    if (made === undefined || Number.isNaN(made))
+        return { at: this.owner?.now() ?? Number.NaN, seq: this.owner?.seq() ?? Number.NaN };
+    return { at: made, seq: c?.seq ?? Number.NaN };
+}
+/** Lets go of stretches older than the one in force at `reading.horizon`. */
+export function prune(s) {
+    const list = this.older?.[s];
+    if (list === undefined)
+        return;
+    let n = 0;
+    while (n < list.length &&
+        (n + 1 < list.length ? list[n + 1].at : this.runs[this.base(s)]) <=
+            reading.horizon)
+        n++;
+    if (n === 0)
+        return;
+    const out = list.splice(0, n);
+    const subject = this.numbers.subject(s);
+    if (this.owner !== null && subject !== absent)
+        this.owner.page(this.ownerId, 'stretch', subject, out.map((seg, i) => {
+            const next = out[i + 1] ?? list[0];
+            return { ...this.made(next === undefined ? this.causes?.[s] : next.change), data: seg };
+        }));
+    if (list.length === 0) {
+        this.older[s] = undefined;
+        this.flag(s, OLDER, false);
+    }
+}

package/dist/meet.d.ts

@@ -1,8 +1,8 @@
 import type { Lanes } from './lanes.js';
-import type { Subject } from './voice.js';
+import type { Subject } from './subject.js';
 /**
  * Whether the lanes a probe of the subject at `slot` just met (`met`) can be folded on the general
- * path after the lanes' values: none is in a locus or a crowd, the subject owes none already this
+ * path after the lanes' values: none is in a role or a crowd, the subject owes none already this
  * fill, and each comes after every other laned voice in voice order, so folding it last folds in
  * the general path's order.
  */