@msb235/blits 0.14.0 → 0.15.1

package/dist/contribution.d.ts

@@ -0,0 +1,30 @@
+import type { Mixer } from './mixer.js';
+import type { Subject } from './subject.js';
+import { type Voice } from './voice.js';
+/**
+ * One live voice's delta for one subject this frame, through its record for the subject, or null
+ * when it does not reach. Its weight is left in `w`.
+ */
+export declare function contribution<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, now: number, held: Subject<unknown>): Record<string, unknown> | null;
+/** Reads a keys voice's stops at `held.phase` into the subject's delta, through the voice's scratch. */
+export declare function keyed<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, held: Subject<unknown>): Record<string, unknown>;
+/**
+ * Runs `step` once per whole interval between where this subject last stopped and now, on a grid
+ * counted from when its delay ran out, and leaves the remainder for the next sample. Counting
+ * rather than adding keeps the grid where it is however many samples it is reached through.
+ */
+export declare function tick<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, held: Subject<unknown>, tick: number, to: number): void;
+/**
+ * Stop 0 for a retargeting voice: the subject's pose in the frame before this voice contributes.
+ * With no such frame on record — a voice cued before the subject was ever probed, or a host that
+ * samples into its own object — it is this frame's pose with every other voice folded in.
+ */
+export declare function baseFor<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I): Record<string, unknown>;
+/**
+ * How fast each numeric channel this voice writes was moving, from the subject's last two probed
+ * poses, in units per ms. Undefined with fewer than two on record, which starts the voice at rest.
+ */
+export declare function slopeFor<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I): Record<string, unknown> | undefined;
+export declare function isRest<I, O>(this: Mixer<I, O>, delta: Record<string, unknown>): boolean;
+/** `contribution`, or for a dry fold a subject already probed this frame, without advancing it. */
+export declare function read<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, now: number, dry: boolean, held: Subject<unknown>): Record<string, unknown> | null;

package/dist/contribution.js

@@ -0,0 +1,374 @@
+import { inBound } from './bound.js';
+import { passAt, phaseAt, phaseBefore, silent, stepOf } from './clock.js';
+import { copy as copyValue } from './clone.js';
+import { near } from './fold.js';
+import { waits } from './held.js';
+import { apart, copyState, record, recordHost, remember } from './history.js';
+import { stateful } from './hosts.js';
+import { moved } from './moved.js';
+import { readKeys } from './patch.js';
+import { reading } from './reading.js';
+import { isRested } from './record.js';
+import { checkWrites } from './voice.js';
+// V8 reads a local const as a constant, where it reads an import from its module on every call.
+const copy = copyValue;
+/**
+ * A record after a seek that rebuilds: fresh state, stepped again from where the voice's clock now
+ * puts this subject's start, which under `stepMs` lands where a voice cued fresh would.
+ */
+function rebuild(mix, voice, subject, now, held) {
+    held.rebuilt = voice.rebuilds;
+    const patch = voice.patch;
+    if (patch.state === undefined && patch.step === undefined && held.kept === null)
+        return;
+    held.state = patch.state ? patch.state(subject) : undefined;
+    held.kept = null;
+    held.unkept = undefined;
+    held.since = mix.sinceOf(voice, held.delay);
+    held.shown = mix.shownOf(voice, held.since);
+    held.ticks = 0;
+    held.stepped = held.since < now ? held.since : now;
+    held.probed = Number.NaN;
+}
+/** Whether a seek since its last read moved a stateful record's origin, as one back before it does. */
+function sentBack(mix, voice, held) {
+    const p = voice.patch;
+    if (p.state === undefined && p.step === undefined && !voice.keeping)
+        return false;
+    return mix.sinceOf(voice, held.delay) !== held.since;
+}
+/** The phase `elapsed` voice ms puts a voice at, before its start included. */
+function phaseOf(elapsed, duration, passes) {
+    return elapsed < 0 ? phaseBefore(elapsed, duration) : phaseAt(elapsed, duration, passes);
+}
+/**
+ * One live voice's delta for one subject this frame, through its record for the subject, or null
+ * when it does not reach. Its weight is left in `w`.
+ */
+export function contribution(voice, subject, now, held) {
+    held.weight = 0;
+    if (!held.reaches)
+        return null;
+    // Outside its bound the signal reads 0 unread. What a read at weight 0 still does is done there:
+    // a patch that steps steps, a `from: 'current'` voice takes its base, and an input is recorded.
+    // A read back of recorded inputs reads them, not the bound as it stands now.
+    const outside = voice.bound !== null && held.replay === undefined && !inBound(this, voice.bound, subject);
+    const recorded = outside && voice.spec.weight.input === true && !!this.opts.history?.inputs;
+    if (outside && !recorded && voice.patch.step === undefined && voice.spec.from !== 'current')
+        return null;
+    if (voice.out?.rest && isRested(held))
+        return null;
+    if (held.rebuilt !== voice.rebuilds)
+        rebuild(this, voice, subject, now, held);
+    else if (held.seeks !== voice.seeks && sentBack(this, voice, held)) {
+        // A seek sent it back before its start, so it starts afresh there, whatever state it kept.
+        rebuild(this, voice, subject, now, held);
+        waits(voice, held, now);
+    }
+    const raw = voice.rawAt(now, held.delay);
+    const early = voice.before(raw, now);
+    if (early && !voice.holdsFirst)
+        return null;
+    const elapsed = voice.shownAt(raw);
+    if (Number.isNaN(elapsed))
+        return null;
+    // A frozen subject's clock stands still at the edge it freezes at: -1 before, 1 after, 0 playing.
+    const still = early ? -1 : voice.freezesAfter && raw > voice.span ? 1 : 0;
+    const duration = voice.duration;
+    const pass = passAt(elapsed, duration, voice.passes);
+    const primed = this.primed;
+    primed[0 /* Primed.NOW */] = now;
+    primed[1 /* Primed.ELAPSED */] = elapsed;
+    primed[2 /* Primed.PASS */] = pass;
+    this.prime(voice, held);
+    const setting = voice.setting;
+    // A signal that keeps state makes its voice stateful, as a patch that does: a lane would call
+    // it for subjects no probe asked about.
+    const keptAtWeigh = reading.kept;
+    const weight = outside ? 0 : this.weigh(voice, subject, now, held);
+    if (recorded)
+        record(this, voice, subject, held, 0);
+    if (reading.kept !== keptAtWeigh && !voice.keeping)
+        stateful(this, voice);
+    setting.weight = weight;
+    held.weight = weight;
+    if (held.probed === now && held.delta && held.seeks === voice.seeks) {
+        if (voice.holder !== held && voice.scratch.length > 0)
+            this.keyed(voice, subject, held);
+        this.w = weight;
+        return held.delta;
+    }
+    const keptBefore = reading.kept;
+    const history = this.opts.history;
+    if (history?.inputs && voice.patch.reads !== undefined && !this.projecting)
+        recordHost(this, now);
+    // Only a motion reads it.
+    if (voice.motion !== undefined)
+        reading.horizon = this.horizonFor(voice, held.delay, now);
+    if (voice.patch.step && held.probed !== now) {
+        // Frozen after, it steps once more to where its last pass ended, and no further; run back
+        // past its start, to where it reached it. Before a start it has yet to reach, it does not step.
+        const to = still === 0
+            ? now
+            : still === 1
+                ? voice.timeAt(held.delay + voice.span)
+                : voice.ranBackTo(held.delay, now);
+        // Never probed, it may be a record a seek put back, sharing its copy's state until it steps.
+        const snaps = held.snaps;
+        const sought = Number.isNaN(held.probed) && snaps !== undefined;
+        if (!Number.isNaN(to)) {
+            if (held.stepped < held.since) {
+                held.stepped = held.since;
+                setting.dt = this.capped(now - held.since);
+            }
+            const tick = stepOf(this, voice);
+            if (tick !== undefined && sought)
+                ahead(this, voice, subject, held, snaps, tick, to);
+            if (sought)
+                own(voice, held);
+            if (tick !== undefined)
+                this.tick(voice, subject, held, tick, to);
+            else if (still === 0 ? now !== held.stepped : to > held.stepped) {
+                if (still !== 0)
+                    setting.dt = this.capped(to - held.stepped);
+                voice.patch.step(held.state, setting.dt, subject, setting);
+                held.stepped = to;
+            }
+        }
+        else if (sought)
+            own(voice, held);
+    }
+    let delta = null;
+    // A keys voice in a role reads at weight 0 too: having a delta makes it a member, and the
+    // role folds at its first member's place.
+    if (silent(voice, weight) && (voice.built === null || voice.spec.role === undefined)) {
+        // A `from: 'current'` voice takes its base on its first read, silent or not.
+        if (voice.built && voice.spec.from === 'current' && held.base === undefined) {
+            held.base = this.baseFor(voice, subject);
+            held.slope = this.slopeFor(voice, subject);
+        }
+    }
+    else if (voice.built) {
+        held.phase = phaseOf(elapsed, duration, voice.passes);
+        delta = this.keyed(voice, subject, held);
+    }
+    else if (voice.motion !== undefined) {
+        delta = moved(voice.motion, voice.patch.writes[0], subject, setting, held);
+    }
+    else {
+        const phase = phaseOf(elapsed, duration, voice.passes);
+        delta = voice.patch.at(phase, subject, setting);
+        if (voice.unchecked)
+            checkWrites(voice, delta);
+    }
+    held.delta = delta;
+    held.probed = now;
+    held.seeks = voice.seeks;
+    if (history !== undefined)
+        remember(this, voice, subject, held);
+    if (reading.kept !== keptBefore && !voice.keeping)
+        stateful(this, voice);
+    if (delta === null)
+        return null;
+    if (voice.out?.rest && this.isRest(delta)) {
+        held.weight = 0;
+        held.restedAt = now;
+        voice.restedCount++;
+        return null;
+    }
+    this.w = weight;
+    return delta;
+}
+/** Reads a keys voice's stops at `held.phase` into the subject's delta, through the voice's scratch. */
+export function keyed(voice, subject, held) {
+    let base;
+    if (voice.spec.from === 'current') {
+        if (held.base === undefined) {
+            held.base = this.baseFor(voice, subject);
+            held.slope = this.slopeFor(voice, subject);
+        }
+        base = held.base;
+    }
+    const delta = readKeys(voice.built, held.phase, held.delta ?? {}, base, voice.lerps, held.slope, voice.intos, voice.scratch);
+    held.delta = delta;
+    if (voice.scratch.length > 0)
+        voice.holder = held;
+    return delta;
+}
+/** How many whole intervals of `tick` a subject's step grid holds by mix time `to`. */
+function dueBy(held, tick, to) {
+    // The epsilon keeps an interval like 1000 / 120 from landing a hair short of a whole count.
+    return Math.floor((to - held.since) / tick + 1e-9);
+}
+/**
+ * The first step of a record a seek put back from a copy: takes up the furthest state stepped on
+ * from that copy that the steps due now run past, the one the record the seek replaced reached or
+ * the one the copy was last stepped ahead to, and otherwise keeps the copy's stepped ahead to the
+ * moment sought, so a mix sought back time after time does not step from the copy each time, nor a
+ * mix sought back and returned step again to where it was. Only where the same steps give the same
+ * state: a fixed interval, no `maxDt`, no host field read.
+ */
+function ahead(mix, voice, subject, held, snaps, tick, to) {
+    const from = snaps[snaps.length - 1];
+    const got = from?.ahead;
+    if (from === undefined || got === undefined || got.put !== held)
+        return;
+    got.put = null;
+    const reads = voice.patch.reads;
+    if (mix.opts.maxDt !== undefined || (reads !== undefined && reads.length > 0))
+        return;
+    // Stepped, rebuilt or placed anew since it was put back, its steps are no longer the copy's.
+    const was = from.held;
+    if (held.ticks !== was.ticks || held.since !== got.since || held.rebuilt !== was.rebuilt)
+        return;
+    const at = got.sought;
+    const due = dueBy(held, tick, to);
+    const usable = got.state !== undefined && got.ticks <= due;
+    if (got.left !== undefined && got.leftTicks <= due && !(usable && got.ticks > got.leftTicks)) {
+        // Taken, not copied: the next seek back keeps the state this record steps on to in its place.
+        held.state = got.left;
+        got.left = undefined;
+        voice.setting.state = held.state;
+        held.ticks = got.leftTicks;
+        return;
+    }
+    if (usable) {
+        held.state = copyState(voice, got.state);
+        voice.setting.state = held.state;
+        held.ticks = got.ticks;
+    }
+    const last = usable ? got.at : from.at;
+    if (!(at < to) || at - last < apart(mix.opts.history))
+        return;
+    own(voice, held);
+    mix.tick(voice, subject, held, tick, at);
+    got.state = copyState(voice, held.state);
+    got.ticks = held.ticks;
+    got.at = at;
+}
+/**
+ * A record a seek put back shares the state of the copy it was made from, which no read changes,
+ * until its first probe: before it steps, it takes a copy of its own.
+ */
+function own(voice, held) {
+    const snaps = held.snaps;
+    const from = snaps[snaps.length - 1];
+    if (from !== undefined && held.state !== undefined && held.state === from.held.state) {
+        held.state = copyState(voice, held.state);
+        voice.setting.state = held.state;
+    }
+}
+/**
+ * Runs `step` once per whole interval between where this subject last stopped and now, on a grid
+ * counted from when its delay ran out, and leaves the remainder for the next sample. Counting
+ * rather than adding keeps the grid where it is however many samples it is reached through.
+ */
+export function tick(voice, subject, held, tick, to) {
+    const now = this.now;
+    const setting = voice.setting;
+    const frameDt = setting.dt;
+    let n = held.ticks;
+    const due = dueBy(held, tick, to);
+    const cap = this.opts.maxDt;
+    if (cap !== undefined) {
+        const most = Math.floor(cap / tick);
+        if (due - n > most)
+            n = due - most;
+    }
+    const step = voice.patch.step;
+    setting.dt = tick;
+    for (n++; n <= due; n++) {
+        setting.timestamp = held.since + n * tick;
+        step(held.state, tick, subject, setting);
+    }
+    held.ticks = due > held.ticks ? due : held.ticks;
+    held.stepped = held.since + held.ticks * tick;
+    setting.timestamp = now;
+    setting.dt = frameDt;
+}
+/**
+ * Stop 0 for a retargeting voice: the subject's pose in the frame before this voice contributes.
+ * With no such frame on record — a voice cued before the subject was ever probed, or a host that
+ * samples into its own object — it is this frame's pose with every other voice folded in.
+ */
+export function baseFor(voice, subject) {
+    let prior = this.lastPoses.get(subject)?.pose;
+    if (prior === undefined && !this.folding.has(voice.id)) {
+        this.folding.add(voice.id);
+        try {
+            prior = this.fold(subject, undefined, false, voice.id);
+        }
+        finally {
+            this.folding.delete(voice.id);
+        }
+    }
+    const base = {};
+    for (const key of voice.patch.writes) {
+        const channel = this.kit[key];
+        const value = prior?.[key];
+        const fallback = channel.rest;
+        if (value !== undefined)
+            base[key] = copy(value);
+        else if (fallback !== undefined)
+            base[key] = copy(fallback);
+    }
+    return base;
+}
+/**
+ * How fast each numeric channel this voice writes was moving, from the subject's last two probed
+ * poses, in units per ms. Undefined with fewer than two on record, which starts the voice at rest.
+ */
+export function slopeFor(voice, subject) {
+    const rec = this.lastPoses.get(subject);
+    if (rec?.prev === undefined || !(rec.at > rec.prevAt))
+        return undefined;
+    const dt = rec.at - rec.prevAt;
+    const now = rec.pose;
+    const before = rec.prev;
+    const slope = {};
+    for (const key of voice.patch.writes) {
+        const a = before[key];
+        const b = now[key];
+        if (typeof a === 'number' && typeof b === 'number')
+            slope[key] = (b - a) / dt;
+        else if (Array.isArray(a) && Array.isArray(b) && a.length === b.length)
+            slope[key] = b.map((v, i) => (v - a[i]) / dt);
+    }
+    return slope;
+}
+export function isRest(delta) {
+    for (const key of Object.keys(delta)) {
+        if (delta[key] === undefined)
+            continue;
+        const channel = this.kit[key];
+        if (channel.rest === undefined)
+            return false;
+        if (!near(delta[key], channel.rest))
+            return false;
+    }
+    return true;
+}
+/** `contribution`, or for a dry fold a subject already probed this frame, without advancing it. */
+export function read(voice, subject, now, dry, held) {
+    if (dry) {
+        if (held.reaches && held.probed === now && held.delta && held.seeks === voice.seeks) {
+            const setting = voice.setting;
+            // The setting the probe that read the delta had, but for `dt`: a dry read advances nothing.
+            const elapsed = voice.shownAt(voice.rawAt(now, held.delay));
+            setting.timestamp = now;
+            setting.dt = 0;
+            setting.elapsed = elapsed;
+            setting.pass = passAt(elapsed, voice.duration, voice.passes);
+            setting.weight = 0;
+            setting.state = held.state;
+            setting.mark = 0;
+            voice.keepOn = held;
+            this.w = this.weigh(voice, subject, now, held);
+            held.weight = this.w;
+            if (voice.holder !== held && voice.scratch.length > 0)
+                this.keyed(voice, subject, held);
+            return held.delta;
+        }
+    }
+    return this.contribution(voice, subject, now, held);
+}

package/dist/copyout.d.ts

@@ -1,6 +1,16 @@
+import type { Laned } from './lane.js';
 import type { Lanes } from './lanes.js';
+/** Writes a subject's laned values into a pose. */
+export type Copier = (pose: Record<string, unknown>, slot: number) => void;
 /**
  * Writes a subject's laned values into a pose, each array channel into the array the pose holds
  * for it where that is the length a new one would be, as a host's `out` holds from its last probe.
  */
 export declare function copy<I, O>(this: Lanes<I, O>, slot: number, pose: Record<string, unknown>): void;
+/** The array to hold an array channel's values for `slot`: `held` written over where it fits. */
+export declare function filled(ch: Laned, slot: number, held: unknown): number[];
+/**
+ * A copier for these channels, written out with each channel's name in place: a store under a name
+ * that varies boxes every number it writes. Where `Function` is refused, a loop over them.
+ */
+export declare function copier(laned: readonly Laned[]): Copier;

package/dist/copyout.js

@@ -3,36 +3,81 @@
  * for it where that is the length a new one would be, as a host's `out` holds from its last probe.
  */
 export function copy(slot, pose) {
-    const laned = this.laned;
+    if (this.copier === null)
+        this.copier = copier(this.laned);
+    this.copier(pose, slot);
+}
+/** The array to hold an array channel's values for `slot`: `held` written over where it fits. */
+export function filled(ch, slot, held) {
+    // Made as the general path makes it, a copy of rest, so poses from either path share a shape.
+    const start = ch.start;
+    const axes = ch.axes;
+    const base = slot * axes;
+    if (Array.isArray(held) &&
+        held !== start &&
+        held.length === (start.length > axes ? start.length : axes)) {
+        for (let a = 0; a < axes; a++)
+            held[a] = ch.values[base + a];
+        for (let a = axes; a < start.length; a++)
+            held[a] = start[a];
+        return held;
+    }
+    const arr = [...start];
+    for (let a = 0; a < axes; a++)
+        arr[a] = ch.values[base + a];
+    return arr;
+}
+/** Each set of laned channels' copier, made once from its source and bound to the channels. */
+const made = new Map();
+/** `Function` refused once: under a CSP each refusal fires a violation, so it is not asked again. */
+let refused = false;
+/**
+ * A copier for these channels, written out with each channel's name in place: a store under a name
+ * that varies boxes every number it writes. Where `Function` is refused, a loop over them.
+ */
+export function copier(laned) {
+    const lines = [];
     for (let c = 0; c < laned.length; c++) {
         const ch = laned[c];
-        const axes = ch.axes;
+        const key = `o[${JSON.stringify(ch.name)}]`;
+        const at = ch.scalar ? 's' : `s * ${ch.axes}`;
         // Never `delete`: it drops a reused out object into dictionary mode for good.
-        if (ch.op === 'last' && Number.isNaN(ch.values[slot * axes])) {
+        const absent = `if (${key} !== undefined) ${key} = undefined;`;
+        const write = ch.scalar
+            ? `${key} = v;`
+            : `{ const h = ${key}, a = f(c${c}, s, h); if (a !== h) ${key} = a; }`;
+        lines.push(`{ const v = c${c}.values[${at}];`);
+        lines.push(ch.op === 'last' ? `if (v !== v) { ${absent} } else ${write} }` : `${write} }`);
+    }
+    const body = lines.join('\n');
+    let make = made.get(body);
+    if (make === undefined && !refused) {
+        const bind = laned.map((_, c) => `const c${c} = chans[${c}];`).join(' ');
+        try {
+            make = new Function('chans', 'f', `${bind}\nreturn function copyLaned(o, s) {\n${body}\n};`);
+            made.set(body, make);
+        }
+        catch {
+            refused = true;
+        }
+    }
+    return make === undefined ? (pose, slot) => loop(laned, pose, slot) : make(laned, filled);
+}
+function loop(laned, pose, slot) {
+    for (let c = 0; c < laned.length; c++) {
+        const ch = laned[c];
+        const v = ch.values[ch.scalar ? slot : slot * ch.axes];
+        if (ch.op === 'last' && Number.isNaN(v)) {
             if (pose[ch.name] !== undefined)
                 pose[ch.name] = undefined;
-            continue;
-        }
-        if (ch.scalar) {
-            pose[ch.name] = ch.values[slot];
-            continue;
         }
-        // Made as the general path makes it, a copy of rest, so poses from either path share a shape.
-        const start = ch.start;
-        const base = slot * axes;
-        const held = pose[ch.name];
-        if (Array.isArray(held) &&
-            held !== start &&
-            held.length === (start.length > axes ? start.length : axes)) {
-            for (let a = 0; a < axes; a++)
-                held[a] = ch.values[base + a];
-            for (let a = axes; a < start.length; a++)
-                held[a] = start[a];
-            continue;
+        else if (ch.scalar)
+            pose[ch.name] = v;
+        else {
+            const held = pose[ch.name];
+            const arr = filled(ch, slot, held);
+            if (arr !== held)
+                pose[ch.name] = arr;
         }
-        const arr = [...start];
-        for (let a = 0; a < axes; a++)
-            arr[a] = ch.values[base + a];
-        pose[ch.name] = arr;
     }
 }

package/dist/crowd.d.ts

@@ -4,7 +4,8 @@ import { type Laned, type Positions } from './lane.js';
 import type { Lanes } from './lanes.js';
 import type { Motions } from './motions.js';
 import type { Scratch } from './patch.js';
-import type { Subject, Voice } from './voice.js';
+import type { Subject } from './subject.js';
+import type { Voice } from './voice.js';
 /**
  * Whether a laned voice belongs in a crowd: one naming a single subject, which shares nothing
  * across subjects for a lane to save. A motion voice writes one channel; a keys or fn voice may
@@ -24,10 +25,15 @@ export declare const enum Hot {
     SEEKS = 5,
     EPOCH = 6,
     ID = 7,
-    AT = 8,
-    MS = 9,
+    /**
+     * A `Flag.READY` row's mix time from which its tween has landed, so a fill folds its `to` as it
+     * stands; Infinity until `bareRows` sees it land at a positive rate. Unread on any other row.
+     */
+    LANDED = 8,
+    AT = 9,
+    MS = 10,
     /** `x0`, `v0` and `to`, `axes` numbers each. */
-    X0 = 10
+    X0 = 11
 }
 /** A crowd row's flags, at `Hot.FLAGS`. */
 export declare const enum Flag {
@@ -52,7 +58,12 @@ export declare const enum Flag {
     /** A keys row whose stops `keys` holds, at `Hot.AT`, with its duration at `Hot.X0` and passes at `Hot.MS`. */
     FLAT = 512,
     /** The row's patch is a tween. */
-    TWEEN = 1024
+    TWEEN = 1024,
+    /**
+     * `bareRows` found its stretch numbered, its subject met and its sample `Sampled.BARE`; cleared
+     * by `unbare` and `restale`, through which everything that undoes one of those goes.
+     */
+    READY = 2048
 }
 /** Whether a row's flags let `bareRows` take it. */
 export declare function bare(f: number): boolean;
@@ -80,7 +91,6 @@ export declare class Crowd<I, O> implements Positions<I, O> {
     eases: (Curve | undefined)[];
     /** Each row's patch law, one array shared by every row whose law is the same. */
     laws: Float64Array[];
-    readonly rowOf: Map<number, number>;
     idle: boolean;
     readonly line: {
         stop: number;

package/dist/crowd.js

@@ -2,7 +2,7 @@ import { bareRows, clock, unbare } from './bare.js';
 import { clampWeight, passAt, phaseAt, weighed } from './clock.js';
 import { closed } from './closed.js';
 import { KeyRows } from './keyrows.js';
-import { frozenAt, SPARSE } from './lane.js';
+import { keepProbed, SPARSE } from './lane.js';
 import { move } from './sample.js';
 /**
  * Whether a laned voice belongs in a crowd: one naming a single subject, which shares nothing
@@ -12,7 +12,7 @@ import { move } from './sample.js';
 export function crowdable(v) {
     return (v.named !== null &&
         v.named.size === 1 &&
-        v.spec.locus === undefined &&
+        v.spec.role === undefined &&
         (v.slots.length === 1 || v.motion === undefined));
 }
 /** The law of a row that has none, a keys or fn voice's. */
@@ -45,7 +45,6 @@ export class Crowd {
     eases = [];
     /** Each row's patch law, one array shared by every row whose law is the same. */
     laws = [];
-    rowOf = new Map();
     idle = false;
     line = SPARSE.other;
     /** Where the fill now under way has reached. */
@@ -69,7 +68,7 @@ export class Crowd {
     constructor(chans, axes) {
         this.chans = chans;
         this.axes = axes;
-        this.stride = 10 /* Hot.X0 */ + 3 * axes;
+        this.stride = 11 /* Hot.X0 */ + 3 * axes;
         this.xs = new Float64Array(axes);
         this.vs = new Float64Array(axes);
     }
@@ -82,7 +81,7 @@ export class Crowd {
     numbered() { }
     /** Marks row `p` to copy its stretch from its patch again before the next fill reads it. */
     restale(p, flags) {
-        this.hot[p * this.stride + 0 /* Hot.FLAGS */] = flags | 4 /* Flag.STALE */;
+        this.hot[p * this.stride + 0 /* Hot.FLAGS */] = (flags | 4 /* Flag.STALE */) & ~2048 /* Flag.READY */;
         this.stale = true;
         this.staleRows.push(p);
     }
@@ -210,8 +209,7 @@ function rows(lanes, c, first, id) {
         const slot = list[p];
         const o = p * 8 /* Row.STRIDE */;
         const q = slot * 6 /* Per.SLOT */;
-        if (per[q + 5 /* Per.LANE_FILL */] === fills - 1)
-            data[o + 3 /* Row.PROBED */] = data[o + 2 /* Row.WEIGHT */];
+        keepProbed(data, o, per, q, fills);
         if (lanes.lately >= 0 && lanes.unread(slot))
             continue;
         const delay = data[o + 0 /* Row.DELAY */];
@@ -219,8 +217,19 @@ function rows(lanes, c, first, id) {
         const voice = c.voices[p];
         const elapsedNow = fast ? clock(hot, h, now) : voice.elapsedAt(now);
         let elapsed = elapsedNow - delay;
+        // Its freezes applied as `one` applies them, written out: a function for it stays out of line.
         if ((f & 256 /* Flag.FREEZES */) !== 0)
-            elapsed = frozenAt(voice, elapsed);
+            elapsed = !(elapsed >= 0)
+                ? voice.freezesBefore
+                    ? 0
+                    : Number.NaN
+                : elapsed > voice.span
+                    ? voice.hidesPast
+                        ? Number.NaN
+                        : voice.freezesAfter
+                            ? voice.span
+                            : elapsed
+                    : elapsed;
         if (!(elapsed >= 0)) {
             data[o + 2 /* Row.WEIGHT */] = 0;
             continue;
@@ -245,7 +254,7 @@ function rows(lanes, c, first, id) {
         data[o + 2 /* Row.WEIGHT */] = w;
         if ((f & 512 /* Flag.FLAT */) !== 0) {
             if (w > 0)
-                c.keys.fold(hot[h + 8 /* Hot.AT */], phaseAt(elapsed, hot[h + 10 /* Hot.X0 */], hot[h + 9 /* Hot.MS */]), c.chans, slot, w);
+                c.keys.fold(hot[h + 9 /* Hot.AT */], phaseAt(elapsed, hot[h + 11 /* Hot.X0 */], hot[h + 10 /* Hot.MS */]), c.chans, slot, w);
             continue;
         }
         arg[1 /* Arg.ELAPSED */] = elapsed;
@@ -275,7 +284,7 @@ function rows(lanes, c, first, id) {
                 c.restale(p, hot[h + 0 /* Hot.FLAGS */]);
             continue;
         }
-        closed(c.laws[p], c.eases[p], n, hot[h + 8 /* Hot.AT */], hot[h + 9 /* Hot.MS */], hot, h + 10 /* Hot.X0 */, hot, h + 10 /* Hot.X0 */ + n, hot, h + 10 /* Hot.X0 */ + 2 * n, elapsed, xs, vs);
+        closed(c.laws[p], c.eases[p], n, hot[h + 9 /* Hot.AT */], hot[h + 10 /* Hot.MS */], hot, h + 11 /* Hot.X0 */, hot, h + 11 /* Hot.X0 */ + n, hot, h + 11 /* Hot.X0 */ + 2 * n, elapsed, xs, vs);
         for (let a = 0; a < n; a++)
             samples[p * n + a] = xs[a];
         if (c.deltas[p] !== null)
@@ -372,7 +381,7 @@ function copyStretch(c, p, ms) {
     const h = p * c.stride;
     let f = c.hot[h + 0 /* Hot.FLAGS */] & ~(4 /* Flag.STALE */ | 8 /* Flag.BARE */ | 32 /* Flag.FOLDS */);
     const ch = c.chans[0];
-    if (run.n === c.axes && run.stretchInto(ms, c.hot, h + 8 /* Hot.AT */)) {
+    if (run.n === c.axes && run.stretchInto(ms, c.hot, h + 9 /* Hot.AT */)) {
         f |= 8 /* Flag.BARE */;
         if (run.scalar(ms) === ch.scalar && ch.plain)
             f |= 32 /* Flag.FOLDS */;