@msb235/blits 0.15.1 → 0.16.1

package/dist/place.js

@@ -56,39 +56,75 @@ export function checkPlacement(mix, spec, anchor, owner) {
         throw new Error('blits: a placement anchors out or end, not both');
     if (spec.start !== undefined && (anchor.start !== undefined || anchor.in !== undefined))
         throw new Error('blits: a voice takes start or an anchored start, not both');
-    const name = spec.name;
-    if (name === undefined)
-        return;
-    // A voice is known by its owner, its score and its name, and by its mix where it names no score;
-    // a bare name in an anchor is in the asker's score under the asker's owner.
-    const key = (o, score, n, slot) => `${score === undefined ? slot : ''}\u0000${o?.id ?? 0}\u0000${score ?? ''}\u0000${n}`;
-    const named = (a, score, o, slot) => {
+    const self = {
+        id: mix.nextId,
+        spec,
+        owner,
+        slot: mix.slot,
+        writes: spec.patch?.writes ?? none,
+    };
+    const voices = [self];
+    for (const m of mix.transport.members)
+        for (const list of [m.gone, m.cued])
+            for (const v of list)
+                voices.push({
+                    id: v.id,
+                    spec: v.spec,
+                    owner: v.owner,
+                    slot: m.slot,
+                    writes: v.patch.writes,
+                });
+    const refuse = () => {
+        throw new Error(`blits: ${spec.name ?? 'a voice'}'s placement waits on itself`);
+    };
+    // Where the marks a query asks for are fixed: a voice's start, in, coast and inner marks by its
+    // start's anchors, its out and end by its out's anchors and its start.
+    const targets = (asker, a) => {
         if ('all' in a)
-            return a.all.flatMap((m) => named(m, score, o, slot));
+            return a.all.flatMap((m) => targets(asker, m));
         if ('any' in a)
-            return a.any.flatMap((m) => named(m, score, o, slot));
-        const q = 'of' in a ? a.of : 'after' in a ? a.after : 'with' in a ? a.with : a.before;
-        if (typeof q === 'string')
-            return [key(o, score, q, slot)];
-        return q.name === undefined ? [] : [key(o, q.score ?? score, q.name, slot)];
+            return a.any.flatMap((m) => targets(asker, m));
+        const given = 'of' in a ? a.of : 'after' in a ? a.after : 'with' in a ? a.with : a.before;
+        const mark = 'of' in a ? a.mark : 'after' in a ? 'end' : 'start';
+        const q = typeof given === 'string' ? { name: given } : given;
+        const score = q.score ?? asker.spec.score;
+        const anywhere = q.score !== undefined;
+        if (asker === self && q.name !== undefined && q.name === spec.name && score === spec.score)
+            refuse();
+        const met = voices.filter((v) => v !== asker &&
+            v.spec.score === score &&
+            (anywhere || (v.owner === asker.owner && v.slot === asker.slot)) &&
+            (q.name === undefined || v.spec.name === q.name) &&
+            (q.tag === undefined || (v.spec.tags ?? none).includes(q.tag)) &&
+            (q.writes === undefined || v.writes.includes(q.writes)));
+        const resolver = q.resolver ?? 'last';
+        const picked = met.length > 1 && (resolver === 'first' || resolver === 'last')
+            ? [met.reduce((p, v) => ((resolver === 'last' ? v.id > p.id : v.id < p.id) ? v : p))]
+            : met;
+        const side = mark === 'out' || mark === 'end' ? 'out' : 'start';
+        return picked.map((v) => ({ voice: v, side }));
     };
-    const names = (p, score, o, slot) => [p.start, p.in, p.out, p.end].flatMap((a) => a === undefined || typeof a === 'number' ? [] : named(a, score, o, slot));
-    const self = key(owner, spec.score, name, mix.slot);
-    const seen = new Set();
-    const waits = names(anchor, spec.score, owner, mix.slot);
-    while (waits.length > 0) {
-        const n = waits.pop();
-        if (n === self)
-            throw new Error(`blits: ${name}'s placement waits on itself`);
-        if (seen.has(n))
-            continue;
-        seen.add(n);
-        for (const m of mix.transport.members)
-            for (const v of m.cued)
-                if (v.spec.name !== undefined &&
-                    key(v.owner, v.spec.score, v.spec.name, m.slot) === n &&
-                    v.spec.anchor)
-                    waits.push(...names(v.spec.anchor, v.spec.score, v.owner, m.slot));
+    const waitsOf = (p, side) => {
+        const a = p.spec.anchor;
+        const by = side === 'start' ? [a?.start, a?.in] : [a?.out, a?.end];
+        const out = side === 'out' ? [{ voice: p, side: 'start' }] : [];
+        for (const b of by)
+            if (b !== undefined && typeof b !== 'number')
+                out.push(...targets(p, b));
+        return out;
+    };
+    for (const from of ['start', 'out']) {
+        const seen = { start: new Set(), out: new Set() };
+        const stack = waitsOf(self, from);
+        while (stack.length > 0) {
+            const { voice, side } = stack.pop();
+            if (voice === self && side === from)
+                refuse();
+            if (seen[side].has(voice))
+                continue;
+            seen[side].add(voice);
+            stack.push(...waitsOf(voice, side));
+        }
     }
 }
 /**
@@ -158,7 +194,7 @@ export function place(mix) {
 export function resolve(mix, a, self, before) {
     const o = self.owner;
     if (typeof a === 'number')
-        return o === null ? mixAt(mix, a - mix.offset) : a;
+        return o === null ? mixAt(mix, a - self.offset) : a;
     if ('all' in a) {
         let latest = Number.NEGATIVE_INFINITY;
         for (const m of a.all) {

package/dist/project.d.ts

@@ -12,8 +12,11 @@ import type { Voice } from './voice.js';
 export declare function projectAll(transport: Transport, at: number | {
     readonly frame: number;
 }): TransportProjection;
-/** Sets each copied voice's state to what its clock and fade make it at `t`. */
-export declare function stateAt<I, O>(c: Mixer<I, O>, t: number): void;
+/**
+ * Sets each copied voice's state to what its clock and fade make it at `t`; with `cut`, the frames
+ * up to which history says which had started.
+ */
+export declare function stateAt<I, O>(c: Mixer<I, O>, t: number, cut?: Cut): void;
 /**
  * A projection back starts each subject from the latest copy kept at or before `t`, else from its
  * voice's start with fresh state, which is exact for a voice stepped at a fixed interval.

package/dist/project.js

@@ -7,7 +7,7 @@ import { fadesAt } from './fade.js';
 import { meet, origin } from './held.js';
 import { copyHeld, last, lastWithin } from './history.js';
 import { Mixer } from './mixer.js';
-import { heldByInput, ownerReading, relink } from './owner.js';
+import { heldByInput, relink } from './owner.js';
 import { reading } from './reading.js';
 import { record } from './record.js';
 import { recount } from './roster.js';
@@ -72,6 +72,7 @@ export function projectAll(transport, at) {
         }, null);
         copy.slot = mix.slot;
         copy.projecting = true;
+        copy.share = mix.share;
         copy.places = mix.places;
         copies.set(mix, copy);
         if (ahead)
@@ -177,19 +178,16 @@ function copyBack(mix, c, t, cut) {
     ownBlends(c.cued);
     if (mix.owners !== null)
         relink(c.cued, cut.seq);
-    stateAt(c, t);
+    stateAt(c, t, cut);
     recount(c);
 }
-/** Sets each copied voice's state to what its clock and fade make it at `t`. */
-export function stateAt(c, t) {
+/**
+ * Sets each copied voice's state to what its clock and fade make it at `t`; with `cut`, the frames
+ * up to which history says which had started.
+ */
+export function stateAt(c, t, cut) {
     for (const copy of c.cued)
-        copy.state = copy.out
-            ? 'fading'
-            : (copy.owner === null ? t : ownerReading(copy.owner, t)) < copy.start
-                ? 'pending'
-                : copy.freezesAfter && copy.elapsedAt(t) >= copy.span + copy.latest
-                    ? 'frozen'
-                    : 'live';
+        copy.state = copy.stateAt(t, cut);
 }
 /**
  * A projection back starts each subject from the latest copy kept at or before `t`, else from its

package/dist/pull.d.ts

@@ -1,5 +1,16 @@
 import type { Mixer } from './mixer.js';
 import type { Columns } from './types.js';
+/** One channel `pull` writes: where in the kit, how many numbers a subject, and its rest. */
+export interface Column {
+    key: string;
+    slot: number;
+    axes: number;
+    out: Float64Array;
+    /** The rest, clamped, or NaN for a channel with none. */
+    rest: Float64Array;
+    bounds: readonly [number, number] | undefined;
+}
+export declare function clampRun(out: Float64Array, at: number, n: number, [lo, hi]: readonly [number, number]): void;
 /** After a probe, keeps the pose a retarget from `'current'` reads as the subject's last. */
 export declare function keep<I, O>(this: Mixer<I, O>, subject: I, pose: O, out: O | undefined): void;
 export declare function pull<I, O>(mix: Mixer<I, O>, subjects: Iterable<I>, into: Columns<O>): void;

package/dist/pull.js

@@ -1,9 +1,13 @@
 import { axesOf } from './channels.js';
 import { copy } from './clone.js';
-import { clampRun, flush, pullRun, writeLater } from './columns.js';
-import { renumber } from './renumber.js';
 /** What `pull` remembers at a position it has read no subject at. */
 const UNREAD = Symbol('unread');
+export function clampRun(out, at, n, [lo, hi]) {
+    for (let i = at; i < at + n; i++) {
+        const x = out[i];
+        out[i] = x < lo ? lo : x > hi ? hi : x;
+    }
+}
 /** Writes a folded pose's value into subject `n`'s places in a column. */
 function writeValue(c, v, n) {
     const at = n * c.axes;
@@ -112,7 +116,7 @@ export function pull(mix, subjects, into) {
     }
     finally {
         if (lanes !== null)
-            flush(lanes);
+            lanes.pulls.flush(lanes);
     }
     // Every head is current only if nothing relinked or changed version while they were read.
     const unchanged = live && mix.version === version && mix.relinks === relinks;
@@ -136,7 +140,7 @@ function readAll(mix, list, columns, live, current, since, whole) {
     const runs = live && whole;
     for (let n = 0; n < list.length; n++) {
         if (runs) {
-            n = pullRun(lanes, slots, list, was, since, n, columns, now, mix.version);
+            n = lanes.pulls.pullRun(lanes, slots, list, was, since, n, columns, now, mix.version);
             if (n === list.length)
                 break;
         }
@@ -156,7 +160,7 @@ function readAll(mix, list, columns, live, current, since, whole) {
                 // Numbered out of the list's order, as swap-remove leaves a subject: renumbered into it.
                 const to = n === 0 ? 0 : slots[n - 1] + 1;
                 if (runs && slot >= 0 && slot !== to && to >= 0) {
-                    if (renumber(mix, subject, head, to)) {
+                    if (lanes.pulls.renumber(mix, subject, head, to)) {
                         for (let j = was.indexOf(subject); j >= 0; j = was.indexOf(subject, j + 1))
                             slots[j] = to;
                         slot = to;
@@ -167,7 +171,7 @@ function readAll(mix, list, columns, live, current, since, whole) {
         }
         const laned = live && lanes?.prepare(slot, subject, mix.version, heads[n] ?? null) === true;
         if (laned && whole && lanes.whole && !lanes.owes(slot)) {
-            writeLater(lanes, slot, columns, n, slots);
+            lanes.pulls.writeLater(lanes, slot, columns, n, slots);
             continue;
         }
         const head = live ? heads[n] : null;

package/dist/qualify.js

@@ -1,9 +1,9 @@
 import { numericOf } from './channels.js';
 import { flush } from './columns.js';
-import { crowdable } from './crowd.js';
 import { byId } from './due.js';
 import { weighAt } from './everyone.js';
 import { wake } from './fill.js';
+import { crowdable } from './hosts.js';
 import { Lane } from './lane.js';
 import { reach } from './meet.js';
 import { bury, compactSparse, join, regroup, retouchRow, sameCrowds } from './rows.js';
@@ -96,7 +96,11 @@ export function requalify(lanes, version) {
             crowded++;
             continue;
         }
-        const lane = lanes.byId.get(v.id) ?? new Lane(v);
+        let lane = lanes.byId.get(v.id);
+        if (lane === undefined) {
+            lane = new Lane(v);
+            lane.made = lanes.probes;
+        }
         v.laned = true;
         if (lane.epoch === 0 && v.state !== 'pending')
             opened(lanes, lane);
@@ -395,6 +399,7 @@ function placeAll(lanes, lane) {
  */
 function enlane(lanes, v) {
     const lane = new Lane(v);
+    lane.made = lanes.probes;
     v.laned = true;
     if (v.state !== 'pending')
         opened(lanes, lane);

package/dist/rests.js

@@ -56,7 +56,15 @@ export function still(voice, now) {
     if (voice.state === 'frozen' || voice.holding !== null)
         return true;
     const motion = voice.motion;
-    return motion !== undefined && voice.elapsedAt(now) >= voice.latest && motion.landed();
+    if (motion === undefined || !(voice.elapsedAt(now) >= voice.latest))
+        return false;
+    // A subject met inside its stagger and not read since has no run yet, and moves once it is.
+    const early = voice.early;
+    if (early !== null)
+        for (const h of early)
+            if (h.since <= now && !(h.probed >= h.since))
+                return false;
+    return motion.landed();
 }
 export function restsLaned() {
     return this.lanes.whole && this.bounded.length === 0;

package/dist/revive.d.ts

@@ -5,7 +5,7 @@ import { type Key } from './paging.js';
 import type { Run } from './stretch.js';
 import type { Parted, Parting } from './subject.js';
 import type { Described } from './types.js';
-import { type Controls, type Ramp, type Rise, Voice } from './voice.js';
+import { type Controls, type Earlier, type Ramp, type Rise, Voice } from './voice.js';
 /** A voice that has left, as plain data: the descriptor it was cued with, its controls and its records. */
 interface PackedVoice {
     as: Described;
@@ -21,6 +21,8 @@ interface PackedVoice {
     weight: number;
     out: Ramp | null;
     back: Rise | null;
+    /** Absent from a store written before a voice kept them. */
+    stalls?: readonly number[] | null;
     outAt: number;
     outOver: number;
     outSet: boolean;
@@ -28,12 +30,20 @@ interface PackedVoice {
     hold: number;
     past: number;
     clocks: Past[] | null;
+    /** Absent from a store written before a voice kept it. */
+    earlier?: Earlier | null;
+    /** Absent from a store written before a voice kept it. */
+    later?: Earlier | null;
     cuedAt: number;
     cuedSeq: number;
+    /** Absent from a store written before a voice kept it. */
+    begunSeq?: number;
     doneAt: number;
     doneSeq: number;
     opened: number;
     pinned: number;
+    /** Absent from a store written before a voice kept it. */
+    offset?: number;
     latest: number;
     /** Absent from a store written before a voice kept it. */
     soonest?: number;

package/dist/revive.js

@@ -79,19 +79,24 @@ function packVoice(voice, keys) {
         weight: voice.weight,
         out: voice.out,
         back: voice.back,
+        stalls: voice.stalls,
         outAt: voice.outAt,
         outOver: voice.outOver,
         outSet: voice.outSet,
         rebuilds: voice.rebuilds,
         hold: voice.hold,
         past: voice.clocks?.length ?? 0,
+        earlier: voice.earlier,
+        later: voice.later,
         clocks: voice.clocks,
         cuedAt: voice.cuedAt,
         cuedSeq: voice.cuedSeq,
+        begunSeq: voice.begunSeq,
         doneAt: voice.doneAt,
         doneSeq: voice.doneSeq,
         opened: voice.opened,
         pinned: voice.pinned,
+        offset: voice.offset,
         latest: voice.latest,
         soonest: voice.soonest,
         keeping: voice.keeping,
@@ -127,10 +132,12 @@ export function reviveVoice(mix, id, d) {
     voice.take(d);
     voice.cuedAt = d.cuedAt;
     voice.cuedSeq = d.cuedSeq;
+    voice.begunSeq = d.begunSeq ?? Number.POSITIVE_INFINITY;
     voice.doneAt = d.doneAt;
     voice.doneSeq = d.doneSeq;
     voice.opened = d.opened;
     voice.pinned = d.pinned;
+    voice.offset = d.offset ?? 0;
     voice.latest = d.latest;
     voice.soonest = d.soonest ?? 0;
     voice.keeping = d.keeping;

package/dist/roles.js

@@ -1,9 +1,7 @@
 import { first } from './clone.js';
-import { open as openRecord } from './everyone.js';
 import { merged, unband } from './fold.js';
 import { roleScratch } from './role.js';
 // V8 reads a local const as a constant, where it reads an import from its module on every call.
-const open = openRecord;
 /**
  * Whether a fold's next voice is its chain's next record, `held`, and not the next voice sharing
  * one record, `sharers[q]`: the two lists are each in voice order, and a fold takes them as one.
@@ -54,15 +52,18 @@ export function foldRoles(subject, pose, head, laned, dry, except, owed) {
                 continue;
             const held = rec;
             if (!mine)
-                open(voice, held, head.slot);
+                this.share.open(voice, held, head.slot);
             const delta = this.read(voice, subject, now, dry, held);
             if (owed >= 0 && voice.laned)
                 this.lanes.paid(voice.id, owed, held.weight);
             if (!mine)
                 q = this.shared(voice, head.slot, held, q);
-            if (delta === null)
-                continue;
             const role = voice.spec.role;
+            if (delta === null) {
+                if (role === undefined && !(held.weight > 0))
+                    unband(held);
+                continue;
+            }
             let group = -1;
             if (role !== undefined) {
                 group = k.names.indexOf(role);

package/dist/roster.d.ts

@@ -1,5 +1,11 @@
 import type { Mixer } from './mixer.js';
 import type { Voice } from './voice.js';
+/**
+ * Counts what makes a mix's fold more than a walk of each chain: a role, a voice sharing one
+ * record, a voice that stopped sharing this frame. Called wherever one of the three changes, so
+ * `foldWith` asks one number.
+ */
+export declare function detour<I, O>(mix: Mixer<I, O>): void;
 /** Counts a voice just put in the list into everything a sync and a fold skip work by. */
 export declare function enlist<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): void;
 /**

package/dist/roster.js

@@ -1,6 +1,13 @@
 import { index, unindex } from './chain.js';
-import { detour } from './everyone.js';
 import { Store } from './store.js';
+/**
+ * Counts what makes a mix's fold more than a walk of each chain: a role, a voice sharing one
+ * record, a voice that stopped sharing this frame. Called wherever one of the three changes, so
+ * `foldWith` asks one number.
+ */
+export function detour(mix) {
+    mix.detours = mix.roleVoices + mix.sharers.length + (mix.unshared ? 1 : 0);
+}
 function tally(mix, voice, by) {
     if (voice.spec.role !== undefined)
         mix.roleVoices += by;

package/dist/rows.js

@@ -106,7 +106,7 @@ export function join(lanes, v, from, at, old) {
         newRow(lanes, c, p, v);
     if (c.hot[p * c.stride + 6 /* Hot.EPOCH */] === 0 && v.state !== 'pending')
         c.hot[p * c.stride + 6 /* Hot.EPOCH */] = open(lanes, v);
-    const seat = new Seat(lanes, c, p);
+    const seat = new Seat(lanes, c, p, from === undefined ? lanes.probes : 0);
     lanes.seats.set(v.id, seat);
     v.seat = seat;
     v.laned = true;
@@ -298,5 +298,8 @@ export function reportedRow(lanes, c, p, slot) {
         return undefined;
     if (c.list[p] !== slot)
         return undefined;
+    const made = seatOf(lanes, c.voices[p])?.made ?? 0;
+    if (!(lanes.per[o + 3 /* Per.LANE_PROBE */] > made))
+        return undefined;
     return c.data[p * 8 /* Row.STRIDE */ + (lanes.per[o + 5 /* Per.LANE_FILL */] === lanes.fills ? 2 /* Row.WEIGHT */ : 3 /* Row.PROBED */)];
 }

package/dist/sample.js

@@ -43,7 +43,8 @@ export function runMotion(lanes, lane, run) {
     }
     const samples = lane.samples;
     const xs = run.xs;
-    const ease = run.ease;
+    // A tween round the hue is no straight line between its ends: `sampleBare` reads it round the hue.
+    const ease = run.round ? undefined : run.ease;
     // A tween whose stretches tell the lane before they change keeps no sample: see `unbareLane`.
     if (run.watcher === null) {
         run.watcher = lanes;

package/dist/seat.d.ts

@@ -9,7 +9,11 @@ export declare class Seat<I, O> {
     lanes: object | null;
     readonly crowd: Crowd<I, O>;
     row: number;
-    constructor(lanes: object | null, crowd: Crowd<I, O>, row: number);
+    /** The lanes' probe count when its row was made new, 0 for a row copied from another crowd. */
+    readonly made: number;
+    constructor(lanes: object | null, crowd: Crowd<I, O>, row: number, 
+    /** The lanes' probe count when its row was made new, 0 for a row copied from another crowd. */
+    made?: number);
 }
 /** `voice`'s seat in `lanes`, null where it has none there. */
 export declare function seatOf<I, O>(lanes: object, voice: Voice<I, O>): Seat<I, O> | null;

package/dist/seat.js

@@ -7,10 +7,14 @@ export class Seat {
     lanes;
     crowd;
     row;
-    constructor(lanes, crowd, row) {
+    made;
+    constructor(lanes, crowd, row, 
+    /** The lanes' probe count when its row was made new, 0 for a row copied from another crowd. */
+    made = 0) {
         this.lanes = lanes;
         this.crowd = crowd;
         this.row = row;
+        this.made = made;
     }
 }
 /** `voice`'s seat in `lanes`, null where it has none there. */

package/dist/seek.js

@@ -6,13 +6,11 @@ import { apart, copyHeld, copyHeldInto, lastIndex, lastWithin, unread } from './
 import { laneHost } from './hosts.js';
 import { Leavings } from './leavings.js';
 import { move, nextFrame } from './move.js';
-import { ownerReading } from './owner.js';
 import { place } from './place.js';
 import { unpull } from './pull.js';
 import { isRested } from './record.js';
 import { Restored } from './restored.js';
 import { recount } from './roster.js';
-import { refitAll } from './spans.js';
 import { Store } from './store.js';
 import { hostAhead, hostAt, replay } from './tape.js';
 import { cover, coverFrame, cut } from './unpage.js';
@@ -209,17 +207,6 @@ function restoreVoice(mix, voice, t, seq) {
     }
     records.back(t, cut, future);
 }
-/** Each voice's state at mix time `t`, once every clock above it is back where it was. */
-function stateAt(voice, t) {
-    // A fade begins at once, even one whose ramp starts later, at the voice's start.
-    if (voice.out !== null)
-        return 'fading';
-    if ((voice.owner === null ? t : ownerReading(voice.owner, t)) < voice.start)
-        return 'pending';
-    if (voice.freezesAfter && voice.elapsedAt(t) >= voice.span + voice.latest)
-        return 'frozen';
-    return 'live';
-}
 /**
  * Moves every mix on the transport to mix time `to`, as it stood at the end of that frame, or to
  * the end of the frame numbered `to.frame`.
@@ -333,8 +320,12 @@ function back(mix, t, seq, on) {
             kept.push(voice);
     for (const voice of kept)
         restoreVoice(mix, voice, t, seq);
-    for (const voice of kept)
-        voice.state = stateAt(voice, t);
+    const cut = { seq, strict: false };
+    for (const voice of kept) {
+        voice.state = voice.stateAt(t, cut);
+        if (voice.begunSeq > seq)
+            voice.begunSeq = Number.POSITIVE_INFINITY;
+    }
     mix.cued = kept;
     mix.gone = gone;
     mix.retired = [];
@@ -400,7 +391,6 @@ function back(mix, t, seq, on) {
             mix.pins ??= new Map();
             mix.pins.set(voice, voice.pinned);
         }
-    refitAll(mix);
     mix.due.clear();
     for (const voice of kept)
         schedule(mix, voice);

package/dist/shared.d.ts

@@ -2,7 +2,7 @@
  * The package version, for a fact whose shape follows the code too closely to version by hand:
  * copies of different releases keep apart. `test/copies.test.ts` holds it to `package.json`.
  */
-export declare const release = "0.15.1";
+export declare const release = "0.16.1";
 /**
  * A WeakMap every copy of blits loaded in one realm shares, so a fact one copy records about a
  * patch or channel it made is read by another copy's mix. The name carries a version, bumped when

package/dist/shared.js

@@ -2,7 +2,7 @@
  * The package version, for a fact whose shape follows the code too closely to version by hand:
  * copies of different releases keep apart. `test/copies.test.ts` holds it to `package.json`.
  */
-export const release = '0.15.1';
+export const release = '0.16.1';
 /**
  * A WeakMap every copy of blits loaded in one realm shares, so a fact one copy records about a
  * patch or channel it made is read by another copy's mix. The name carries a version, bumped when

package/dist/spans.d.ts

@@ -15,11 +15,17 @@ export declare class Fitting {
 }
 /** Refuses a voice a span cannot fit: one it would not own the timing of, or one with no end. */
 export declare function checkChild<I, O>(spec: VoiceSpec<I, O>, child: Voice<I, O>): void;
+/**
+ * Puts a child whose owner's clock ran back to before a fit changed its rate, or skipped it, back
+ * on the clock it ran on before, so it reads, run back over, what it read going forward; and once
+ * the owner's clock reaches that change again, takes the change again, as the layout stands.
+ */
+export declare function unfit<I, O>(mix: Mixer<I, O>, child: Voice<I, O>, now: number): void;
 /**
  * Lays out a span's children and fits them into what is left of its budget, from its clock at mix
  * time `from`, default now. Only what is still to come moves: a playing child keeps its place and
  * may change rate, a pending one is placed. A span held by a span is fitted again by its own span
- * after.
+ * after. A span its clock ran back over keeps the layout it made going forward.
  */
 export declare function refit<I, O>(mix: Mixer<I, O>, span: Voice<I, O>, from?: number): void;
 /**
@@ -29,7 +35,10 @@ export declare function refit<I, O>(mix: Mixer<I, O>, span: Voice<I, O>, from?:
 export declare function refloor<I, O>(mix: Mixer<I, O>): void;
 /** Whether a span whose last child just left at mix time `at` stays, its budget not yet out. */
 export declare function lingers<I, O>(span: Voice<I, O>, at: number): boolean;
-/** Lets the spans that are empty and out of budget leave, at the moment their budget ran out. */
+/**
+ * Lets the spans out of budget that hold no child still playing leave, at the moment their budget
+ * ran out, or, under history, stay quiet with an owner holding them.
+ */
 export declare function lapse<I, O>(mix: Mixer<I, O>, now: number): void;
-/** Fits every span again, as after a seek put its children back. */
-export declare function refitAll<I, O>(mix: Mixer<I, O>): void;
+/** Whether a span's budget is out by `now` with no child of it still playing. */
+export declare function lapses<I, O>(span: Voice<I, O>, now: number): boolean;