@msb235/blits 0.10.0 → 0.11.0

package/dist/mixer.js

@@ -1,13 +1,13 @@
 import { blended, blendOf, laneRead, shareKept } from './blend.js';
-import { aims, chain, linkable, relink } from './chain.js';
+import { aims, chain, linkable, relink, unlink } from './chain.js';
 import { lerpInto } from './channels.js';
 import { cue } from './cue.js';
 import { DepartedIndex } from './departed.js';
-import { beginFade, leftWith, parting } from './fade.js';
+import { beginFade, leaveVoice, parting } from './fade.js';
 import { apply, baseFor, clamp, contribution, fold, foldDetour, folded, foldLoci, foldSharers, foldWith, isRest, keyed, linked, near, owedBy, passes, read, shared, slopeFor, tick, } from './fold.js';
 import { GoneIndex, goneIndex } from './gone.js';
 import { held, shownOf, sinceOf, unreachedOf } from './held.js';
-import { leave, releasing } from './history.js';
+import { releasing } from './history.js';
 import { book, laneHost } from './hosts.js';
 import { Lanes } from './lanes.js';
 import { foldLocus } from './locus.js';
@@ -22,8 +22,8 @@ import { Outs } from './revive.js';
 import { ScoreIndex } from './scored.js';
 import { seek } from './seek.js';
 import { Fitting, refit } from './spans.js';
-import { Store } from './store.js';
-import { record } from './tape.js';
+import { Masked, Store } from './store.js';
+import { record, unplayable } from './tape.js';
 import { touch } from './touch.js';
 import { announce, Transport } from './transport.js';
 import { none } from './voice.js';
@@ -37,6 +37,7 @@ export const defaults = { lanes: true };
 export class Mixer {
     kit;
     opts;
+    lanesOf;
     cued = [];
     /** Under `history`, voices that have left but that a read back may still reach. */
     gone = [];
@@ -87,10 +88,15 @@ export class Mixer {
     /** The last array `pull` read, by position, with each subject's chain head, to skip the lookup. */
     pulled = [];
     pulledHeads = [];
-    /** Each remembered head's lane slot, and the `version` and `relinks` they were all current at. */
+    /**
+     * Each remembered head's lane slot, -1 at a position with none, and the `version` and `relinks`
+     * they were all current at.
+     */
     pulledSlots = new Int32Array(0);
     pulledVersion = Number.NaN;
     pulledRelinks = -1;
+    /** What `pull` knows of each channel it has written, by name; none until the first pull. */
+    pullColumns = null;
     /** Counts chains made stale one subject at a time, which `version` does not. */
     relinks = 0;
     /** Read once a sync, so a `reduce` function is not called per voice per subject. */
@@ -215,9 +221,12 @@ export class Mixer {
     keys = null;
     /** With a history store, the voices it paged out whose handles are still held; null without one. */
     outs = null;
-    constructor(kit, opts) {
+    constructor(kit, opts, 
+    /** The lanes an entry was built with; null in one that leaves them out. */
+    lanesOf) {
         this.kit = kit;
         this.opts = opts;
+        this.lanesOf = lanesOf;
         this.names = Object.keys(kit);
         this.channels = this.names.map((k) => kit[k]);
         this.bounded = this.channels.flatMap((c, i) => (c.bounds ? [i] : []));
@@ -225,7 +234,10 @@ export class Mixer {
         this.names.forEach((k, i) => {
             this.slotOf.set(k, i);
         });
-        this.lanes = (opts.lanes ?? defaults.lanes) ? new Lanes(laneHost(this)) : null;
+        if (lanesOf === null && opts.lanes === true)
+            throw new Error("blits: '@msb235/blits/lean' has no lanes; take mix from '@msb235/blits'");
+        this.lanes =
+            lanesOf !== null && (opts.lanes ?? defaults.lanes) ? new lanesOf(laneHost(this)) : null;
         this.name = opts.name;
         const shared = opts.transport;
         if (shared !== undefined) {
@@ -290,6 +302,9 @@ export class Mixer {
     get timestamp() {
         return this.transport.last;
     }
+    get seq() {
+        return this.transport.seq;
+    }
     get last() {
         return this.transport.last;
     }
@@ -308,16 +323,31 @@ export class Mixer {
     }
     cue(spec) {
         this.attached();
-        const engine = this.opts.engine ?? mixer;
-        if (!engine.runs.has(spec.patch.form))
+        const engine = this.opts.engine;
+        if (engine !== undefined && !engine.runs.has(spec.patch.form))
             throw new Error(`blits: engine ${engine.name} does not run ${spec.patch.form} patches`);
         return cue(this, spec);
     }
-    blend(patches, by, spec = {}) {
+    blend(members, by, spec = {}) {
         const locus = `blend:${this.nextId}`;
-        const of = blendOf(by, patches.length - 1);
-        return patches.map((patch, i) => {
-            const handle = this.cue({ ...spec, patch, weight: by, locus });
+        const of = blendOf(by, members.length - 1);
+        return members.map((member, i) => {
+            const own = {
+                ...spec,
+                patch: member,
+                weight: by,
+                locus,
+            };
+            if ('patch' in member) {
+                own.patch = member.patch;
+                if (member.name !== undefined)
+                    own.name = member.name;
+                if (member.tags !== undefined)
+                    own.tags = member.tags;
+                if (member.hits !== undefined)
+                    own.hits = member.hits;
+            }
+            const handle = this.cue(own);
             const voice = this.cued[this.cued.length - 1];
             voice.blend = { of, i };
             of.members.push(voice);
@@ -330,6 +360,8 @@ export class Mixer {
         return this.cue({ ...spec, patch: ownerPatch });
     }
     span(spec) {
+        if ((spec.rate ?? 1) < 0)
+            throw new Error('blits: a span lays out its children forward from its start, so it is not cued backward');
         this.fitting = new Fitting(spec);
         try {
             const handle = this.owns(spec);
@@ -359,16 +391,16 @@ export class Mixer {
         this.looked = true;
         pull(this, subjects, into);
     }
-    seek(time) {
+    seek(to) {
         if (this.projecting)
             throw new Error('blits: a projection does not seek');
-        seek(this.own('seek'), time);
+        seek(this.own('seek'), to);
     }
     prepare(time) {
         return this.own('prepare').prepare(time);
     }
-    project(time) {
-        return projectAll(this.transport, time).of(this);
+    project(at) {
+        return projectAll(this.transport, at).of(this);
     }
     announce(name, opts = {}) {
         this.attached();
@@ -469,18 +501,19 @@ export class Mixer {
             voice.written = true;
             beginFade(this, voice, { over: opts?.over });
         }
-        record(this, 'mute', () => this.mute(opts));
+        record(this, 'mute', (stage) => stage.mix(this)?.mute(opts));
     }
     drop(subject) {
         this.frame = nextFrame();
         const head = this.chains.get(subject);
         // Nothing that kept this head, such as `pull`'s remembered list, may take it as current again.
-        if (head !== undefined) {
-            head.version = Number.NaN;
-            this.relinks++;
-        }
+        if (head !== undefined)
+            unlink(this, head);
         if (head !== undefined && head.slot >= 0 && this.lanes !== null)
             this.lanes.release(head.slot);
+        // A read ahead's copy reads the live mix's poses, and so hides one where the mix deletes it.
+        if (this.projecting && !(this.pose instanceof Masked))
+            this.pose = new Masked(this.pose);
         this.pose.delete(subject);
         this.restStamps?.delete(subject);
         this.chains.delete(subject);
@@ -488,10 +521,18 @@ export class Mixer {
         // A record of it is only in a voice over every subject, one naming it, or one gone; a ramp out
         // of a voice that does not name it is in `parters`, and a patch's own state in `motions`.
         const kept = releasing(this);
+        // A motion patch's state is the live mix's alone: a read ahead cannot start a subject afresh in it.
+        const release = (motion) => {
+            if (!this.projecting)
+                motion.release(subject, ...kept);
+            else if (motion.holds(subject))
+                unplayable('a drop of a subject a motion patch holds');
+        };
         const forget = (voice) => {
-            leave(this, voice, subject, leftWith(this, voice, subject));
+            leaveVoice(this, voice, subject);
             voice.subjects.delete(subject);
-            voice.motion?.release(subject, ...kept);
+            if (voice.motion !== undefined)
+                release(voice.motion);
             voice.parts?.delete(subject);
             voice.parted?.delete(subject);
             voice.blend?.of.reads.delete(subject);
@@ -524,11 +565,11 @@ export class Mixer {
         const strays = this.strays.get(subject);
         if (strays !== undefined)
             for (const motion of strays)
-                motion.release(subject, ...kept);
+                release(motion);
         this.strays.delete(subject);
         for (const motion of this.strayAll)
-            motion.release(subject, ...kept);
-        record(this, 'drop', () => this.drop(subject));
+            release(motion);
+        record(this, 'drop', (stage) => stage.mix(this)?.drop(subject));
     }
     touch(subject) {
         this.attached();
@@ -648,7 +689,7 @@ export const mixer = {
     name: 'mixer',
     runs: new Set(['fn', 'keys', 'motion']),
     create(kit, opts) {
-        return new Mixer(kit, opts);
+        return new Mixer(kit, opts, Lanes);
     },
 };
 /**

package/dist/motion.d.ts

@@ -45,7 +45,10 @@ export type Moving<I, O, V extends Value> = Patch<I, O, void> & {
      */
     push(subject: I, velocity: V, at?: number): void;
 };
-/** The state behind a `'motion'` patch, for an engine that reads it directly. */
+/**
+ * The state behind a `'motion'` patch, for an engine that reads it directly; a patch another copy
+ * of the same release made counts.
+ */
 export declare function motionOf<I>(p: object): Motions<I> | undefined;
 interface Common<I, V extends Value> {
     /** Units per second each subject starts moving at. Default 0. */

package/dist/motion.js

@@ -1,11 +1,17 @@
 import { COAST, CRITICAL, EASED, OVER, UNDER } from './closed.js';
 import { curve } from './easing.js';
 import { Motions } from './motions.js';
+import { release } from './shared.js';
 const axes = (v) => (typeof v === 'number' ? [v] : [...v]);
 /** Zero on every axis `x` has: a motion's velocity where its options give none. */
 const still = (x) => new Array(x.length).fill(0);
 const per = (p, subject) => typeof p === 'function' ? p(subject) : p;
 const scalarOf = (p) => typeof p === 'function' ? undefined : typeof p === 'number';
+/**
+ * What marks a motion patch to every copy of blits of this release loaded in one realm, so a
+ * spring another copy made runs on this copy's lanes; it gives the patch's state.
+ */
+const MOTIONS = Symbol.for(`@msb235/blits/motions@${release}`);
 /** One `writes` array per channel, shared by every motion patch that writes it. */
 const writesOf = new Map();
 /**
@@ -29,6 +35,9 @@ class MotionPatch {
     get motion() {
         return this.motions.spec();
     }
+    get [MOTIONS]() {
+        return this.motions;
+    }
     at(_phase, subject, setting) {
         const state = this.motions;
         const s = state.slot(subject);
@@ -58,9 +67,14 @@ class GlidePatch extends MotionPatch {
         this.motions.change(subject, { at, v: axes(velocity) });
     }
 }
-/** The state behind a `'motion'` patch, for an engine that reads it directly. */
+/**
+ * The state behind a `'motion'` patch, for an engine that reads it directly; a patch another copy
+ * of the same release made counts.
+ */
 export function motionOf(p) {
-    return p instanceof MotionPatch ? p.motions : undefined;
+    return p instanceof MotionPatch
+        ? p.motions
+        : p[MOTIONS];
 }
 /**
  * The shapes of the stock motions, each one object over the options it reads, copied out of them so

package/dist/motions.d.ts

@@ -167,6 +167,8 @@ export declare class Motions<I> {
     private unrelease;
     /** Subject `s`'s run as it stands. */
     private runAt;
+    /** Whether the patch holds a run for `subject`. */
+    holds(subject: I): boolean;
     /** A subject's run as plain data, for a voice leaving memory; undefined where it has none. */
     pack(subject: I): Run | undefined;
     /** Puts a subject's run back as `pack` or a release left it, replacing any it has now. */
@@ -244,6 +246,8 @@ export declare class Motions<I> {
     private queue;
     /** Every change due by `t` applied to a copy of the stretch playing then, committing nothing. */
     private peek;
+    /** Subject `s`'s changes waiting, with those a read ahead's tape made filed among them by time. */
+    private dueTo;
     private check;
     private flag;
     forget(s: number): void;

package/dist/motions.js

@@ -28,6 +28,17 @@ function ahead(segs, list) {
 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.
@@ -211,6 +222,10 @@ export class Motions {
             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);
@@ -496,7 +511,7 @@ export class Motions {
     /** 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.pending?.[s];
+        const list = this.dueTo(s);
         if (list !== undefined)
             for (const change of list) {
                 const a = change.at;
@@ -507,6 +522,21 @@ export class Motions {
             }
         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');
@@ -611,9 +641,9 @@ export class Motions {
         return {
             at: this.runs[this.base(s)],
             ms: this.runs[this.base(s) + 2],
-            x0: Array.from(this.runs.subarray(x, x + n)),
-            v0: Array.from(this.runs.subarray(x + n, x + 2 * n)),
-            to: Array.from(this.runs.subarray(x + 2 * n, x + 3 * n)),
+            x0: numbers(this.runs, x, n),
+            v0: numbers(this.runs, x + n, n),
+            to: numbers(this.runs, x + 2 * n, n),
             change: this.causes?.[s],
         };
     }
@@ -636,11 +666,13 @@ export class Motions {
         return list[lo];
     }
     applied(s, seg, change, at) {
-        const x = new Float64Array(this.n);
-        const v = new Float64Array(this.n);
+        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 = Array.from(x);
-        const vs = change.v ?? Array.from(v);
+        const xs = 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 to = this.shape.aim(xs, vs, change.to ?? seg.to, known);
@@ -695,8 +727,7 @@ export class Motions {
      * 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(next) {
-        const c = next.change;
+    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 };
@@ -717,7 +748,10 @@ export class Motions {
         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) => ({ ...this.made(out[i + 1] ?? list[0] ?? this.latest(s)), data: seg })));
+            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/move.js

@@ -1,6 +1,6 @@
 import { changed } from './chain.js';
 import { elapsedWith } from './clock.js';
-import { popDue, schedule } from './due.js';
+import { byId, popDue, schedule } from './due.js';
 import { detour } from './everyone.js';
 import { beginFade, part, retire } from './fade.js';
 import { expireGone, keepGone } from './gone.js';
@@ -66,7 +66,13 @@ function moveTo(mix, now) {
             (voice.owner === null ? now : ownerReading(voice.owner, now)) >= voice.start)
             begin(mix, voice, now);
         // After it starts, so a fade due by now on a voice that started since the last frame begins.
-        if ((voice.state === 'live' || voice.state === 'frozen') && voice.outAt <= now)
+        // Not one set for after its passes run out, where a move across both would begin it first.
+        if ((voice.state === 'live' || voice.state === 'frozen') &&
+            voice.outAt <= now &&
+            !(voice.state === 'live' &&
+                !voice.freezesAfter &&
+                !voice.freezesBefore &&
+                voice.endsAt() < voice.outAt))
             beginFade(mix, voice, { over: Number.isNaN(voice.outOver) ? undefined : voice.outOver }, Math.max(startOf(voice), voice.outAt));
         if (voice.state !== 'pending') {
             if (voice.turns)
@@ -155,11 +161,16 @@ function turn(mix, voice, now) {
     voice.anchorNow = at;
     noted(mix, voice);
 }
-/** Past this many voices retiring in one frame, one pass over the list beats a search for each. */
+/**
+ * Past this many voices retiring in one frame, and more than one in `SPARSE` of the list, one pass
+ * over the list beats a search for each.
+ */
 const SEARCHED = 8;
+const SPARSE = 32;
 /**
- * Takes the voices retired since the last prune out of the list, in list order. A few are found by
- * their id, which the list is in order of, so the voices still in it are not read.
+ * Takes the voices retired since the last prune out of the list, in list order. A few, or a small
+ * share of a long list, are found by their id, which the list is in order of, so the voices still
+ * in it are not read.
  */
 function prune(mix) {
     const retired = mix.retired;
@@ -167,9 +178,8 @@ function prune(mix) {
     const voices = mix.cued;
     let at = null;
     // A projection's list holds copies of voices gone before it, which only a pass takes out.
-    if (retired.length <= SEARCHED && !mix.projecting) {
-        if (retired.length > 1)
-            retired.sort((a, b) => a.id - b.id);
+    if ((retired.length <= SEARCHED || retired.length * SPARSE <= voices.length) && !mix.projecting) {
+        byId(retired);
         at = [];
         for (let k = 0; k < retired.length; k++) {
             const voice = retired[k];
@@ -185,8 +195,16 @@ function prune(mix) {
     if (at !== null) {
         for (const voice of retired)
             pruned = leave(mix, voice) || pruned;
-        for (let k = at.length - 1; k >= 0; k--)
-            voices.splice(at[k], 1);
+        // Closed up in one pass from the first to go: a splice for each moves the tail once a voice.
+        let kept = at[0];
+        let k = 0;
+        for (let i = kept; i < voices.length; i++) {
+            if (at[k] === i)
+                k++;
+            else
+                voices[kept++] = voices[i];
+        }
+        voices.length = kept;
     }
     else {
         let kept = 0;

package/dist/owner.d.ts

@@ -9,6 +9,19 @@ export declare class Holding<V> {
     /** How many it has held, and how many of those finished their passes. */
     kids: number;
     played: number;
+    /**
+     * When the children that left coast, as pairs of the frame one left in and the latest coast so
+     * far, mix time: a pair only where the latest grew, so a seek back cuts it to a prefix.
+     */
+    coasts: number[];
+    /** The frame the first child to leave before its passes ended left in; Infinity for none. */
+    cutSeq: number;
+    /** The latest coast of a child that left; -Infinity for none. */
+    get coast(): number;
+    /** A child left in frame `seq`, coasting at `coast`, or before its passes ended for undefined. */
+    left(coast: number | undefined, seq: number): void;
+    /** Forgets the children that left after frame `seq`, for a seek or read back to it. */
+    back(seq: number): void;
 }
 /**
  * What an owner's clock reads at mix time `now`, through every owner above it: -Infinity before it
@@ -41,5 +54,8 @@ export declare function heldByInput<I, O>(voice: Voice<I, O>): boolean;
 export declare function ownWeight<I, O>(owner: Voice<I, O>, now: number, reduced: boolean, base: (owner: Voice<I, O>) => number): number;
 /** What every owner above a voice multiplies into its weight. */
 export declare function ownersWeight<I, O>(voice: Voice<I, O>, now: number, reduced: boolean, base: (owner: Voice<I, O>) => number): number;
-/** Points a projection's copies at each other's owners, each owner holding only copies. */
-export declare function relink<I, O>(copies: readonly Voice<I, O>[]): void;
+/**
+ * Points a projection's copies at each other's owners, each owner holding only copies; for a read
+ * back to frame `seq`, as its children that had left by then left it.
+ */
+export declare function relink<I, O>(copies: readonly Voice<I, O>[], seq?: number): void;

package/dist/owner.js

@@ -13,6 +13,35 @@ export class Holding {
     /** How many it has held, and how many of those finished their passes. */
     kids = 0;
     played = 0;
+    /**
+     * When the children that left coast, as pairs of the frame one left in and the latest coast so
+     * far, mix time: a pair only where the latest grew, so a seek back cuts it to a prefix.
+     */
+    coasts = [];
+    /** The frame the first child to leave before its passes ended left in; Infinity for none. */
+    cutSeq = Number.POSITIVE_INFINITY;
+    /** The latest coast of a child that left; -Infinity for none. */
+    get coast() {
+        const n = this.coasts.length;
+        return n === 0 ? Number.NEGATIVE_INFINITY : this.coasts[n - 1];
+    }
+    /** A child left in frame `seq`, coasting at `coast`, or before its passes ended for undefined. */
+    left(coast, seq) {
+        if (coast === undefined) {
+            if (seq < this.cutSeq)
+                this.cutSeq = seq;
+        }
+        else if (coast > this.coast)
+            this.coasts.push(seq, coast);
+    }
+    /** Forgets the children that left after frame `seq`, for a seek or read back to it. */
+    back(seq) {
+        const c = this.coasts;
+        while (c.length > 0 && c[c.length - 2] > seq)
+            c.length -= 2;
+        if (this.cutSeq > seq)
+            this.cutSeq = Number.POSITIVE_INFINITY;
+    }
 }
 /**
  * What an owner's clock reads at mix time `now`, through every owner above it: -Infinity before it
@@ -103,8 +132,11 @@ export function ownersWeight(voice, now, reduced, base) {
         w *= ownWeight(o, now, reduced, base);
     return w;
 }
-/** Points a projection's copies at each other's owners, each owner holding only copies. */
-export function relink(copies) {
+/**
+ * Points a projection's copies at each other's owners, each owner holding only copies; for a read
+ * back to frame `seq`, as its children that had left by then left it.
+ */
+export function relink(copies, seq) {
     const byId = new Map();
     for (const v of copies) {
         byId.set(v.id, v);
@@ -112,6 +144,10 @@ export function relink(copies) {
             const h = new Holding();
             h.kids = v.holding.kids;
             h.played = v.holding.played;
+            h.coasts = v.holding.coasts.slice();
+            h.cutSeq = v.holding.cutSeq;
+            if (seq !== undefined)
+                h.back(seq);
             v.holding = h;
         }
     }

package/dist/pack.d.ts

@@ -12,6 +12,7 @@ export interface PackedRecord {
     stepped: number;
     ticks: number;
     rebuilt: number;
+    copied?: true;
     /**
      * What `setting.keep` held, in the order its owners first kept it. An owner is code, which no
      * store keeps, and a voice revived from a descriptor has new ones; the same code keeps in the same

package/dist/pack.js

@@ -18,6 +18,8 @@ export function packHeld(voice, h) {
         rebuilt: h.rebuilt,
         kept: kept.length === 0 ? null : kept.map(clone),
     };
+    if (h.copied)
+        p.copied = true;
     if (h.base !== undefined)
         p.base = clone(h.base);
     if (h.slope !== undefined)
@@ -42,6 +44,7 @@ export function unpackHeld(voice, p) {
     h.stepped = p.stepped;
     h.ticks = p.ticks;
     h.rebuilt = p.rebuilt;
+    h.copied = p.copied === true;
     if (p.kept !== null)
         h.unkept = p.kept;
     if (p.base !== undefined)

package/dist/placed.d.ts

@@ -0,0 +1,19 @@
+/**
+ * By subject number, the crowd voices whose rows are placed on it, so letting a number go reaches
+ * its rows without walking every crowd's. Kept by voice id, which a row keeps as a crowd closes up
+ * or is rebuilt around it.
+ */
+export declare class Placed {
+    /** By subject number, one voice placed on it; 0, which is no voice's id, for none. */
+    private one;
+    /** The others, for a subject with several; null until some subject has two. */
+    private rest;
+    /** Makes room for subject numbers below `cap`. */
+    grow(cap: number): void;
+    /** Some voice placed on the subject at `slot`, 0 for none. */
+    any(slot: number): number;
+    /** Every voice placed on the subject at `slot`, in no order: for a test to read. */
+    all(slot: number): number[];
+    add(slot: number, id: number): void;
+    remove(slot: number, id: number): void;
+}