@msb235/blits 0.14.0 → 0.15.0

package/dist/lane.js

@@ -1,6 +1,15 @@
 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 +79,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 +91,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 +143,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;

package/dist/lanes.d.ts

@@ -1,15 +1,16 @@
 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 { 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>[];
@@ -79,15 +80,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 +108,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 +146,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;
     /**

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';
@@ -33,14 +34,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 +62,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 +100,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;
     /**
@@ -275,8 +290,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 +398,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`

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.
  */

package/dist/meet.js

@@ -1,6 +1,7 @@
+import { open, shut } from './everyone.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.
  */
@@ -88,13 +89,98 @@ export function meet(lanes, slot, subject, head, lane) {
     // after every other laned voice, the general path folds just those onto the lanes' values;
     // 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.metN);
-        return true;
+    if (lane && lanes.per[o + 2 /* Per.IDLE */] === 0) {
+        const again = foldsAgain(lanes, slot);
+        if (again || owable(lanes, slot)) {
+            if (!foldNow(lanes, slot, subject, again))
+                lanes.owed.owe(slot, lanes.met, lanes.metN);
+            return true;
+        }
     }
     lanes.per[o + 0 /* Per.FILLED */] = lanes.fills;
     return false;
 }
+/**
+ * Whether the subject at `slot` met the lanes the last subject `foldNow` folded met, in the same
+ * fill: `owable` and `foldNow`'s own checks then answer as they did for that one.
+ */
+function foldsAgain(lanes, slot) {
+    if (lanes.foldsFill !== lanes.fills || lanes.metCrowd || lanes.owes(slot))
+        return false;
+    const folds = lanes.folds;
+    const n = lanes.metN;
+    if (folds.length !== n)
+        return false;
+    for (let i = 0; i < n; i++)
+        if (folds[i] !== lanes.met[i])
+            return false;
+    return true;
+}
+/**
+ * Folds the lanes a probe of the subject at `slot` just met onto the lanes' values, making each
+ * one's first call or read for the subject as the general path would for this probe, where every
+ * one is a stateless fn or keys voice that ran this fill; false, leaving them owed, where any is
+ * not. The fold is last in voice order, as `owable` found, so it folds as the general path would
+ * after the fill.
+ */
+function foldNow(lanes, slot, subject, again) {
+    if (lanes.filling)
+        return false;
+    // What `unread` answers, which `one` asks before this probe's own stamp is written.
+    const lately = lanes.lately;
+    const o = slot * 6 /* Per.SLOT */;
+    if (lately >= 0 &&
+        !(lanes.per[o + 3 /* Per.LANE_PROBE */] > lately ||
+            lanes.per[o + 4 /* Per.GENERAL_PROBE */] > lately))
+        return false;
+    const met = lanes.met;
+    const n = lanes.metN;
+    for (let i = 0; i < n && !again; i++) {
+        const lane = lanes.byId.get(met[i]);
+        const v = lane.voice;
+        if (lane.ran !== lanes.fills ||
+            lane.motion !== undefined ||
+            v.keeping ||
+            typeof v.spec.weight === 'function' ||
+            (v.sharing && v.everyone === null))
+            return false;
+    }
+    if (!again) {
+        lanes.folds = met.slice(0, n);
+        lanes.foldsFill = lanes.fills;
+    }
+    // The subject is at hand: `call` would look it up again by its number.
+    if (lanes.subjects[slot] === undefined) {
+        lanes.subjects[slot] = subject;
+        lanes.holding = true;
+    }
+    lanes.meeting = true;
+    try {
+        for (let i = 0; i < n; i++) {
+            const lane = lanes.byId.get(met[i]);
+            const v = lane.voice;
+            const p = lane.positionOf(slot);
+            if (!v.sharing) {
+                lanes.one(lane, p, slot);
+                continue;
+            }
+            const rec = v.everyone;
+            open(v, rec, slot);
+            lanes.one(lane, p, slot);
+            // Its patch just made kept state, and the record is now that subject's own.
+            if (!v.keeping)
+                shut(v, rec, slot, lanes.cap);
+        }
+    }
+    finally {
+        lanes.meeting = false;
+    }
+    // A patch that just made kept state takes its voice off its lane: check the next subject again.
+    for (let i = 0; i < n; i++)
+        if (lanes.byId.get(met[i]).voice.keeping)
+            lanes.foldsFill = -1;
+    return true;
+}
 /** Places a crowd voice's row on the subject a probe met, as `Lane.add` adds a position. */
 function place(lanes, voice, slot, subject, from, head) {
     const c = lanes.crowdOf.get(voice.id);