@msb235/blits 0.14.0 → 0.15.1

package/dist/motions.js

@@ -1,52 +1,20 @@
+import { applied, change, commit, cut, dueTo, insert, peek, queue, rewind } from './changes.js';
 import { closed } from './closed.js';
+import { made, pack, prune, reclaim, release, restretch, runAt, runThen, unpack, unrelease, } from './lives.js';
 import { absent, Numbers } from './numbers.js';
 import { reading } from './reading.js';
 import { Store } from './store.js';
+import { numbers, } from './stretch.js';
 import { sloped } from './tweened.js';
-/**
- * A patch's law, `[form, settle, k1, k2, k3]`: which closed form its stretches follow, its `settle`,
- * and up to three constants that form reads. It heads the patch's `runs`, so `solve` finds them in
- * the buffer a sample already reads rather than in an object of their own.
- */
-const HEAD = 5;
-/** 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];
-}
+const HEAD = 5 /* Law.HEAD */;
 /** Where every patch's `sample` leaves a value on its way to the mix; none outlives its call. */
 let shared = { xs: new Float64Array(4), vs: new Float64Array(4) };
 /** What a patch's `xs` and `vs` are before its first subject sets its axes. */
 const unsized = new Float64Array(0);
-/** Where `applied` reads a stretch at the time a change lands; copied out before it returns. */
-let landing = { x: new Float64Array(4), v: new Float64Array(4) };
-/** Where `numbers` gathers what it copies, kept an array of doubles so every copy is one too. */
-const gathered = [0.5];
-/** `n` numbers of `from` from `at`, as an array of their own. */
-function numbers(from, at, n) {
-    // `Array.from` walks a typed array by its iterator: about 500 B a call for three axes.
-    for (let i = 0; i < n; i++)
-        gathered[i] = from[at + i];
-    return gathered.slice(0, n);
-}
-/**
- * A subject's flags: its value is a number; it has changes pending; it has older stretches; the
- * stretch it is playing was found landed, which holds until another replaces it.
- */
-const SCALAR = 1;
-const PENDING = 2;
-const OLDER = 4;
-const LANDED = 8;
+const SCALAR = 1 /* RunFlag.SCALAR */;
+const PENDING = 2 /* RunFlag.PENDING */;
+const OLDER = 4 /* RunFlag.OLDER */;
+const LANDED = 8 /* RunFlag.LANDED */;
 const wrongKind = (channel, holdsNumber) => new Error(`blits: channel ${channel} holds ${holdsNumber ? 'a number' : 'an array'}, and this motion patch gives a subject ${holdsNumber ? 'an array' : 'a number'}`);
 /**
  * A motion patch's subjects: the stretch each is playing, in one flat array by a number the patch
@@ -58,6 +26,7 @@ const wrongKind = (channel, holdsNumber) => new Error(`blits: channel ${channel}
  * 10k springs of one subject each, a buffer per field, a map lookup per sample and the law in an
  * object of its own took a call from 130 ns to 490.
  */
+// biome-ignore lint/suspicious/noUnsafeDeclarationMerging: every member of `Methods` is installed below
 export class Motions {
     shape;
     numbers = new Numbers(this);
@@ -68,6 +37,7 @@ export class Motions {
     /** Axes per subject; -1 until the first subject sets it. */
     n = -1;
     cap = 0;
+    /** Numbers in each subject's run; a run starts at `base`. Written only here. */
     stride = 0;
     /**
      * The law, then each subject's run; empty until the first subject, the law read from `shape`.
@@ -124,6 +94,16 @@ export class Motions {
         const known = this.known(subject);
         if (known !== undefined)
             return known;
+        const seg = this.fresh(subject);
+        const s = this.take(subject);
+        this.runs[this.base(s) + 1] = this.freshFlags;
+        this.write(s, seg);
+        return s;
+    }
+    /** The flags of the run `fresh` last started. */
+    freshFlags = 0;
+    /** The stretch a subject met afresh starts with, its axes and the law set up for it, numbering no one. */
+    fresh(subject) {
         const x = this.shape.from(subject);
         const v = this.shape.velocity(subject, x);
         const to = this.shape.aim(x, v, null, subject, false);
@@ -136,10 +116,14 @@ export class Motions {
             throw wrongKind(this.channel, this.holdsNumber);
         if (this.n < 0)
             this.size(n);
-        const s = this.take(subject);
-        this.runs[this.base(s) + 1] = scalar ? SCALAR : 0;
-        this.write(s, { at: 0, ms: this.shape.ms?.(subject) ?? 0, x0: x, v0: v, to });
-        return s;
+        this.grow(1);
+        this.freshFlags = scalar ? SCALAR : 0;
+        return { at: 0, ms: this.shape.ms?.(subject) ?? 0, x0: x, v0: v, to };
+    }
+    /** The run `fresh` starts, as plain data. */
+    freshRun(subject) {
+        const seg = this.fresh(subject);
+        return { flags: this.freshFlags, stretches: [seg], pending: undefined };
     }
     /** Sets the axes every subject moves on, at the first. */
     size(n) {
@@ -175,120 +159,10 @@ export class Motions {
      * rewind before the release plays them on from there. Empty without history.
      */
     released = [];
-    /**
-     * 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.
-     */
-    release(subject, at, reach = Number.NEGATIVE_INFINITY, seq = Number.NaN) {
-        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) },
-                    ]);
-            this.released = kept;
-            this.released.push({ subject, at, seq, ...this.runAt(s) });
-        }
-        this.slots.delete(subject);
-        this.numbers.release(s);
-    }
-    /** Puts back each subject released after frame `seq`, as it stood when released. */
-    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. */
-    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],
-        };
-    }
     /** Whether the patch holds a run for `subject`. */
     holds(subject) {
         return this.known(subject) !== undefined;
     }
-    /** A subject's run as plain data, for a voice leaving memory; undefined where it has none. */
-    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. */
-    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. */
-    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 });
-    }
-    /**
-     * 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.
-     */
-    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);
-    }
     /**
      * Told, with `watchId`, whenever a subject's stretch or what is pending for it changes, so a mix
      * keeping a copy of it knows to read it again. Set by the mix, cleared when its voice retires. An
@@ -339,7 +213,11 @@ export class Motions {
     }
     /** The value `at` hands the mix: the first axis for a number, a fresh array otherwise. */
     value(s, xs) {
-        if ((this.runs[this.base(s) + 1] & SCALAR) !== 0)
+        return this.valueOf(this.runs[this.base(s) + 1], xs);
+    }
+    /** The value `at` hands the mix for a run with `flags`. */
+    valueOf(flags, xs) {
+        if ((flags & SCALAR) !== 0)
             return xs[0];
         const n = this.n;
         const out = new Array(n);
@@ -464,80 +342,6 @@ export class Motions {
         }
         return { x, v, s };
     }
-    /**
-     * Queues a retarget, set or push, untimed at the latest frame, for `subject`'s next read past its time.
-     * The queue keeps the changes with a time in time order, ahead of any still waiting for one.
-     */
-    change(subject, c) {
-        const back = this.owner === null ? Number.NaN : this.owner.revive(this.ownerId, subject);
-        const s = this.slot(subject);
-        this.check(c.to, this.n);
-        this.check(c.x, this.n);
-        this.check(c.v, this.n);
-        c.made = this.owner === null ? Number.NaN : this.owner.now();
-        c.seq = this.owner === null ? Number.NaN : this.owner.seq();
-        if (c.at === undefined) {
-            const at = this.frame(subject);
-            if (!Number.isNaN(at))
-                c.at = at;
-            else if (!Number.isNaN(back))
-                c.at = back;
-        }
-        const list = this.pending?.[s];
-        if (list === undefined) {
-            if (this.pending === null)
-                this.pending = [undefined];
-            this.pending[s] = [c];
-            this.flag(s, PENDING, true);
-        }
-        else if (c.at === undefined)
-            list.push(c);
-        else
-            this.queue(list, c, c.at);
-        reading.moved++;
-        const made = { at: c.at, to: c.to, x: c.x, v: c.v };
-        this.owner?.changed(this.ownerId, this, subject, made);
-    }
-    /** Files a change with a time after every one due by then, ahead of those still waiting for one. */
-    queue(list, c, at) {
-        let i = list.length;
-        while (i > 0) {
-            const before = list[i - 1].at;
-            if (before !== undefined && before <= at)
-                break;
-            i--;
-        }
-        list.splice(i, 0, c);
-    }
-    /** Every change due by `t` applied to a copy of the stretch playing then, committing nothing. */
-    peek(s, t, xo, vo) {
-        let seg = this.playing(s, t);
-        const list = this.dueTo(s);
-        if (list !== undefined)
-            for (const change of list) {
-                const a = change.at;
-                if (a === undefined || !(a <= t))
-                    break;
-                if (a >= seg.at)
-                    seg = this.applied(s, seg, change, a);
-            }
-        this.evaluateSegment(seg, t, xo, vo);
-    }
-    /** Subject `s`'s changes waiting, with those a read ahead's tape made filed among them by time. */
-    dueTo(s) {
-        const own = this.pending?.[s];
-        const ahead = reading.ahead?.get(this);
-        if (ahead === undefined)
-            return own;
-        const subject = this.numbers.subject(s);
-        const made = subject === absent ? undefined : ahead.get(subject);
-        if (made === undefined)
-            return own;
-        if (own === undefined)
-            return made;
-        // The patch's own were made first, and a stable sort keeps them first at one time.
-        return [...own.filter((c) => c.at !== undefined), ...made].sort((a, b) => a.at - b.at);
-    }
     check(a, n) {
         if (a !== undefined && a.length !== n)
             throw new Error('blits: a motion patch moves every subject on the same number of axes');
@@ -557,54 +361,6 @@ export class Motions {
         if (this.causes !== null)
             this.causes[s] = undefined;
     }
-    /**
-     * Takes back every change made after frame `seq`: each subject plays from its earliest stretch
-     * kept, with the changes made by then queued to be applied again.
-     */
-    rewind(seq) {
-        this.unrelease(seq);
-        for (let s = 0; s < this.numbers.size; s++)
-            if (this.numbers.subject(s) !== absent)
-                this.cut(s, seq);
-    }
-    cut(s, seq) {
-        const older = this.older?.[s];
-        const pending = this.pending?.[s];
-        const current = this.latest(s);
-        const stretches = older === undefined ? [current] : [...older, current];
-        const kept = [];
-        let cut = false;
-        for (const c of [...stretches.slice(1).map((seg) => seg.change), ...(pending ?? [])])
-            if (c === undefined || c.seq === undefined || !(c.seq > seq)) {
-                if (c !== undefined)
-                    kept.push(c);
-            }
-            else
-                cut = true;
-        if (!cut)
-            return;
-        if (older !== undefined) {
-            this.older[s] = undefined;
-            this.flag(s, OLDER, false);
-        }
-        this.write(s, stretches[0]);
-        // Applied again in the order they take effect; one never stamped waits for the next read.
-        const timed = kept
-            .filter((c) => c.at !== undefined)
-            .sort((a, b) => a.at - b.at);
-        const list = [...timed, ...kept.filter((c) => c.at === undefined)];
-        if (list.length === 0) {
-            if (pending !== undefined) {
-                this.pending[s] = undefined;
-                this.flag(s, PENDING, false);
-            }
-            return;
-        }
-        if (this.pending === null)
-            this.pending = [undefined];
-        this.pending[s] = list;
-        this.flag(s, PENDING, true);
-    }
     /** Where subject `s`'s run starts in `runs`. */
     base(s) {
         return HEAD + s * this.stride;
@@ -666,99 +422,6 @@ export class Motions {
         }
         return list[lo];
     }
-    applied(s, seg, change, at) {
-        const n = this.n;
-        if (landing.x.length < n)
-            landing = { x: new Float64Array(n), v: new Float64Array(n) };
-        const { x, v } = landing;
-        this.evaluateSegment(seg, at, x, v);
-        const xs = change.x ?? numbers(x, 0, n);
-        const vs = change.v ?? numbers(v, 0, n);
-        const subject = this.numbers.subject(s);
-        const known = subject === absent ? undefined : subject;
-        const put = change.x !== undefined && change.v === undefined;
-        const to = this.shape.aim(xs, vs, change.to ?? seg.to, known, put);
-        const ms = subject === absent ? seg.ms : (this.shape.ms?.(known) ?? 0);
-        return { at, ms, x0: xs, v0: vs, to, change };
-    }
-    commit(s, t) {
-        const list = this.pending[s];
-        // The first read of a subject no frame had met: those waiting for a time take this one.
-        if (list[list.length - 1].at === undefined) {
-            let i = list.length;
-            while (i > 0 && list[i - 1].at === undefined)
-                i--;
-            for (const c of list.splice(i)) {
-                c.at = t;
-                this.queue(list, c, t);
-            }
-        }
-        while (list.length > 0) {
-            const change = list[0];
-            const a = change.at;
-            if (a > t)
-                break;
-            list.shift();
-            this.insert(s, this.applied(s, this.playing(s, a), change, a));
-        }
-        if (list.length === 0) {
-            this.pending[s] = undefined;
-            this.flag(s, PENDING, false);
-        }
-    }
-    insert(s, seg) {
-        let list = this.older?.[s];
-        if (list === undefined) {
-            list = [];
-            if (this.older === null)
-                this.older = [undefined];
-            this.older[s] = list;
-            this.flag(s, OLDER, true);
-        }
-        if (seg.at >= this.runs[this.base(s)]) {
-            list.push(this.latest(s));
-            this.write(s, seg);
-            return;
-        }
-        let i = list.length;
-        while (i > 0 && list[i - 1].at > seg.at)
-            i--;
-        list.splice(i, 0, seg);
-    }
-    /**
-     * 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.
-     */
-    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`. */
-    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);
-        }
-    }
     evaluateSegment(seg, t, xo, vo) {
         this.evaluate(seg.at, seg.ms, seg.x0, 0, seg.v0, 0, seg.to, 0, t, xo, vo);
     }
@@ -766,3 +429,26 @@ export class Motions {
         return closed(this.runs, this.shape.ease, this.n, at, ms, x0, x, v0, v, to, g, t, xo, vo);
     }
 }
+const methods = {
+    release,
+    unrelease,
+    runAt,
+    pack,
+    unpack,
+    reclaim,
+    runThen,
+    restretch,
+    made,
+    prune,
+    change,
+    queue,
+    peek,
+    dueTo,
+    rewind,
+    cut,
+    applied,
+    commit,
+    insert,
+};
+for (const [name, value] of Object.entries(methods))
+    Object.defineProperty(Motions.prototype, name, { value, writable: true, configurable: true });

package/dist/moved.d.ts

@@ -1,5 +1,5 @@
 import type { Motions } from './motions.js';
-import type { Subject } from './voice.js';
+import type { Subject } from './subject.js';
 /**
  * A motion voice's delta for a subject on the general path: what its patch's `at` gives, written
  * into the record's last delta and the array that holds, where `at` makes an object and an array a

package/dist/moved.js

@@ -1,4 +1,6 @@
 import { doubles } from './channels.js';
+import { reading } from './reading.js';
+import { sampleThen } from './then.js';
 /**
  * A motion voice's delta for a subject on the general path: what its patch's `at` gives, written
  * into the record's last delta and the array that holds, where `at` makes an object and an array a
@@ -6,16 +8,23 @@ import { doubles } from './channels.js';
  * `setting` has the voice time to sample at.
  */
 export function moved(run, key, subject, setting, rec) {
-    let s = rec.run;
-    if (rec.freed !== run.freed) {
-        s = run.slot(subject);
-        rec.run = s;
-        rec.freed = run.freed;
+    let scalar;
+    const back = reading.back;
+    if (back !== null)
+        scalar = (sampleThen(run, subject, setting.elapsed, back) & 1 /* RunFlag.SCALAR */) !== 0;
+    else {
+        let s = rec.run;
+        if (rec.freed !== run.freed) {
+            s = run.slot(subject);
+            rec.run = s;
+            rec.freed = run.freed;
+        }
+        run.sample(s, setting.elapsed, run.xs, run.vs);
+        scalar = run.scalar(s);
     }
     const xs = run.xs;
-    run.sample(s, setting.elapsed, xs, run.vs);
     const delta = rec.delta ?? {};
-    if (run.scalar(s)) {
+    if (scalar) {
         delta[key] = xs[0];
         return delta;
     }

package/dist/named.d.ts

@@ -5,8 +5,12 @@
 export declare class Named<I> {
     readonly list: readonly I[];
     private readonly set;
-    constructor(subjects: Iterable<I>);
+    /** Each subject's `stagger` answer, asked at cue; null for a voice with no stagger. */
+    readonly delays: Map<I, number> | null;
+    /** The longest of `delays`, 0 at least, and the least, 0 at most: a voice's bounds at cue. */
+    readonly latest: number;
+    readonly soonest: number;
+    constructor(subjects: Iterable<I>, stagger?: (subject: I) => number);
     get size(): number;
     has(subject: I): boolean;
-    [Symbol.iterator](): Iterator<I>;
 }

package/dist/named.js

@@ -7,7 +7,21 @@ const FEW = 8;
 export class Named {
     list;
     set;
-    constructor(subjects) {
+    /** Each subject's `stagger` answer, asked at cue; null for a voice with no stagger. */
+    delays = null;
+    /** The longest of `delays`, 0 at least, and the least, 0 at most: a voice's bounds at cue. */
+    latest = 0;
+    soonest = 0;
+    constructor(subjects, stagger) {
+        // An array of distinct subjects, as nearly every voice names, is copied without iterating it.
+        if (Array.isArray(subjects) && distinct(subjects)) {
+            this.list = subjects.slice();
+            this.set = null;
+            if (stagger)
+                this.delays = delaysOf(this.list, stagger);
+            [this.latest, this.soonest] = boundsOf(this.delays);
+            return;
+        }
         const list = [];
         let set = null;
         for (const s of subjects) {
@@ -26,6 +40,9 @@ export class Named {
         // Exactly as long as it is: a list grown by push keeps room for 17.
         this.list = list.slice();
         this.set = set;
+        if (stagger)
+            this.delays = delaysOf(this.list, stagger);
+        [this.latest, this.soonest] = boundsOf(this.delays);
     }
     get size() {
         return this.list.length;
@@ -33,7 +50,36 @@ export class Named {
     has(subject) {
         return this.set === null ? this.list.includes(subject) : this.set.has(subject);
     }
-    [Symbol.iterator]() {
-        return this.list[Symbol.iterator]();
+}
+function delaysOf(list, stagger) {
+    const delays = new Map();
+    for (const s of list)
+        delays.set(s, stagger(s));
+    return delays;
+}
+function boundsOf(delays) {
+    let latest = 0;
+    let soonest = 0;
+    for (const delay of delays?.values() ?? []) {
+        if (delay > latest)
+            latest = delay;
+        if (delay < soonest)
+            soonest = delay;
+    }
+    return [latest, soonest];
+}
+/** Whether a short array names no subject twice, as `includes` compares; a long one says no. */
+function distinct(subjects) {
+    const n = subjects.length;
+    if (n > FEW)
+        return false;
+    for (let i = 1; i < n; i++) {
+        const a = subjects[i];
+        for (let j = 0; j < i; j++) {
+            const b = subjects[j];
+            if (a === b || (Number.isNaN(a) && Number.isNaN(b)))
+                return false;
+        }
     }
+    return true;
 }

package/dist/numbers.d.ts

@@ -33,6 +33,13 @@ export declare class Numbers<I> {
     /** One past the highest number handed out, so a loop over 0..size meets every live one. */
     get size(): number;
     take(subject: I): number;
+    /** Whether `slot` is a number in use, its subject perhaps collected and not yet released. */
+    has(slot: number): boolean;
     subject(slot: number): I | typeof absent;
+    /**
+     * Hands the subject numbered `from` the free number `to`, and frees `from` without telling the
+     * owner, whose stores the caller moves; false, changing nothing, where either does not hold.
+     */
+    move(from: number, to: number): boolean;
     release(slot: number): void;
 }