@msb235/blits 0.13.0 → 0.15.0

package/dist/pull.js

@@ -18,12 +18,10 @@ function writeValue(c, v, n) {
 }
 /** After a probe, keeps the pose a retarget from `'current'` reads as the subject's last. */
 export function keep(subject, pose, out) {
-    // Keeping last frame's pose is free when the mix allocated it; a host sampling into its own
-    // object only pays for the copy once something in the mix has asked to retarget from it.
+    // A pose handed back without `out` is the host's to edit, so it is copied too. A host sampling
+    // into its own object only pays for the copy once something has asked to retarget from it.
     let kept;
-    if (out === undefined)
-        kept = pose;
-    else if (this.wantsPose) {
+    if (out === undefined || this.wantsPose) {
         kept = {};
         for (const key of this.names) {
             const v = pose[key];
@@ -32,9 +30,14 @@ export function keep(subject, pose, out) {
         }
     }
     if (kept !== undefined) {
-        const rec = this.pose.get(subject);
+        const rec = this.lastPoses.get(subject);
         if (rec === undefined)
-            this.pose.set(subject, { pose: kept, at: this.now, prev: undefined, prevAt: Number.NaN });
+            this.lastPoses.set(subject, {
+                pose: kept,
+                at: this.now,
+                prev: undefined,
+                prevAt: Number.NaN,
+            });
         else if (rec.at === this.now)
             rec.pose = kept;
         else {
@@ -50,7 +53,7 @@ export function pull(mix, subjects, into) {
     const lanes = mix.lanes;
     const now = mix.now;
     if (mix.scratch === undefined)
-        mix.scratch = {};
+        mix.scratch = mix.pose();
     let room = Number.POSITIVE_INFINITY;
     let tightest = '';
     for (const c of columns) {

package/dist/qualify.js

@@ -5,6 +5,7 @@ import { byId } from './due.js';
 import { weighAt } from './everyone.js';
 import { wake } from './fill.js';
 import { Lane } from './lane.js';
+import { reach } from './meet.js';
 import { bury, compactSparse, join, regroup, retouchRow, sameCrowds } from './rows.js';
 import { settle } from './sample.js';
 /**
@@ -57,21 +58,21 @@ export function requalify(lanes, version) {
         keepCallsOff(present, fits, host.channels);
     const candidates = () => present.map((v, i) => ({ id: v.id, fits: fits[i], slots: v.slots }));
     let { channels, voices } = qualify(numeric, candidates());
-    // A locus folds its members together, so they run on lanes all together or not at all.
+    // A role folds its members together, so they run on lanes all together or not at all.
     for (let split = true; split;) {
         split = false;
-        const loci = new Map();
+        const roles = new Map();
         present.forEach((v, i) => {
-            const name = v.spec.locus;
+            const name = v.spec.role;
             if (name === undefined)
                 return;
-            const at = loci.get(name);
+            const at = roles.get(name);
             if (at === undefined)
-                loci.set(name, [i]);
+                roles.set(name, [i]);
             else
                 at.push(i);
         });
-        for (const at of loci.values()) {
+        for (const at of roles.values()) {
             const on = at.filter((i) => voices.has(present[i].id)).length;
             if (on === 0 || on === at.length)
                 continue;
@@ -97,18 +98,18 @@ export function requalify(lanes, version) {
         const lane = lanes.byId.get(v.id) ?? new Lane(v);
         v.laned = true;
         if (lane.epoch === 0 && v.state !== 'pending')
-            lane.epoch = open(lanes, v);
+            opened(lanes, lane);
         kept.push(lane);
     }
     lanes.lanes = kept;
-    lanes.loci = [];
-    const loci = new Map();
+    lanes.roles = [];
+    const roles = new Map();
     for (const lane of kept) {
         lane.group = null;
-        const name = lane.voice.spec.locus;
+        const name = lane.voice.spec.role;
         if (name === undefined)
             continue;
-        let g = loci.get(name);
+        let g = roles.get(name);
         if (g === undefined) {
             g = {
                 members: [],
@@ -117,13 +118,17 @@ export function requalify(lanes, version) {
                 sum: new Float64Array(lanes.cap),
                 values: [],
                 taken: [],
+                contiguous: false,
+                inline: false,
             };
-            loci.set(name, g);
-            lanes.loci.push(g);
+            roles.set(name, g);
+            lanes.roles.push(g);
         }
         g.members.push(lane);
         lane.group = g;
     }
+    for (const [name, g] of roles)
+        g.contiguous = contiguous(present, voices, name, g.members);
     lanes.dense = kept
         .filter((l) => l.voice.named === null && l.epoch > 0)
         .sort((a, b) => a.epoch - b.epoch);
@@ -161,6 +166,7 @@ export function requalify(lanes, version) {
         return;
     }
     lanes.laned = [];
+    lanes.copier = null;
     lanes.bySlot = host.channels.map(() => undefined);
     channels.forEach((on, slot) => {
         if (!on)
@@ -170,10 +176,12 @@ export function requalify(lanes, version) {
         // A rest-less channel's values are NaN until some voice passes the band: absent from the pose.
         const rest = (channel.rest ?? Number.NaN);
         const scalar = typeof rest === 'number' && n.axes === 1;
+        const op = n.folds ?? n.op;
         const ch = {
             name: host.names[slot],
-            op: n.op,
-            plain: n.op !== 'last' && n.op !== 'own' && n.turn === undefined,
+            op,
+            plain: op !== 'last' && op !== 'own' && n.turn === undefined,
+            straight: n.folds === undefined,
             turn: n.turn ?? 0,
             channel,
             scalar,
@@ -263,7 +271,7 @@ export function open(lanes, v) {
         lanes.wide = epoch;
         return epoch;
     }
-    for (const subject of v.named) {
+    for (const subject of v.named.list) {
         const slot = lanes.host.slotOf(subject);
         if (slot < 0 || slot >= lanes.cap)
             continue;
@@ -318,8 +326,8 @@ export function retouch(lanes) {
         }
         if (v.state === 'done')
             return qualify();
-        // A locus's members are on lanes together or not at all, so one joining may move the others.
-        if (v.spec.locus !== undefined)
+        // A role's members are on lanes together or not at all, so one joining may move the others.
+        if (v.spec.role !== undefined)
             return qualify();
         const laned = v.slots.some((slot) => lanes.bySlot[slot] !== undefined);
         const fits = v.slots.length > 0 && lanes.host.fits(v);
@@ -341,6 +349,46 @@ export function retouch(lanes) {
         lanes.subjects = [];
     return true;
 }
+/** A lane's voice started playing: its epoch, and room up front where it reaches every subject. */
+function opened(lanes, lane) {
+    const v = lane.voice;
+    lane.epoch = open(lanes, v);
+    if (v.named === null && v.spec.target === undefined) {
+        lane.reserve(lanes.live, lanes.cap);
+        if (placesAll(lanes, lane))
+            placeAll(lanes, lane);
+    }
+}
+/**
+ * Whether a lane just opened can take every numbered subject now, its first call or read for each
+ * made by the fill: a stateless fn or keys voice sharing one record, which every subject would meet
+ * at its next probe, in a host that probed every subject last frame. One by one, each probe would
+ * meet it and make its first call or read there (`foldNow` in `meet.ts`).
+ */
+function placesAll(lanes, lane) {
+    const v = lane.voice;
+    return (v.sharing &&
+        v.everyone !== null &&
+        lane.motion === undefined &&
+        !v.keeping &&
+        typeof v.spec.weight !== 'function' &&
+        lane.list.length === 0 &&
+        lanes.lastDistinct >= lanes.live);
+}
+/** Gives every numbered subject a position on a lane `placesAll` passed. */
+function placeAll(lanes, lane) {
+    const rec = lane.voice.everyone;
+    const numbers = lanes.numbers;
+    const size = Math.min(numbers.size, lanes.cap);
+    for (let slot = 0; slot < size; slot++) {
+        if (!numbers.has(slot))
+            continue;
+        lane.add(slot, rec);
+        if (lane.idle)
+            reach(lanes, slot, 1);
+    }
+    lane.every = true;
+}
 /**
  * A new voice that fits and writes only laned channels, and that no crowd takes, gets a lane at
  * the end of the order, its id being past every other: what a qualify would give it, since such a
@@ -350,7 +398,7 @@ function enlane(lanes, v) {
     const lane = new Lane(v);
     v.laned = true;
     if (v.state !== 'pending')
-        lane.epoch = open(lanes, v);
+        opened(lanes, lane);
     lane.chans = v.slots.map((s) => lanes.bySlot[s]);
     lane.values = lane.chans.map(() => undefined);
     lanes.lanes.push(lane);
@@ -360,13 +408,13 @@ function enlane(lanes, v) {
 }
 /**
  * A laned voice that started playing or finished, as a qualify would take it: a lane leaving
- * cannot lane or unlane another channel. False for a locus member, which a qualify must take.
+ * cannot lane or unlane another channel. False for a role member, which a qualify must take.
  */
 function relane(lanes, lane) {
     const v = lane.voice;
     if (v.state !== 'done') {
         if (lane.epoch === 0 && v.state !== 'pending') {
-            lane.epoch = open(lanes, v);
+            opened(lanes, lane);
             if (v.named === null)
                 lanes.dense.push(lane);
         }
@@ -410,3 +458,18 @@ function leave(lanes, lane) {
     }
     lane.voice.laned = false;
 }
+/**
+ * Whether a role's members, in the order lanes run, have no laned or crowded voice of another
+ * role or none between them, so its every subject folds at its first member's turn.
+ */
+function contiguous(present, voices, name, members) {
+    for (let i = 1; i < members.length; i++)
+        if (members[i].voice.id <= members[i - 1].voice.id)
+            return false;
+    const lo = members[0].voice.id;
+    const hi = members[members.length - 1].voice.id;
+    for (const v of present)
+        if (v.id > lo && v.id < hi && voices.has(v.id) && v.spec.role !== name)
+            return false;
+    return true;
+}

package/dist/reading.d.ts

@@ -1,3 +1,4 @@
+import type { Cut } from './cut.js';
 /**
  * Internal: what kind of read the mix is making right now, for patches that keep state of their own
  * outside the mix. Not exported from the package.
@@ -32,4 +33,9 @@ export declare const reading: {
      * commits none. Null for every other read.
      */
     ahead: Map<object, Map<unknown, unknown[]>> | null;
+    /**
+     * While a read back under history reads: the frame it reads, so a motion patch reads the run a
+     * subject had then and only the changes made by then. Null for every other read.
+     */
+    back: Cut | null;
 };

package/dist/reading.js

@@ -32,4 +32,9 @@ export const reading = {
      * commits none. Null for every other read.
      */
     ahead: null,
+    /**
+     * While a read back under history reads: the frame it reads, so a motion patch reads the run a
+     * subject had then and only the changes made by then. Null for every other read.
+     */
+    back: null,
 };

package/dist/record.d.ts

@@ -1,4 +1,8 @@
-import type { Subject } from './voice.js';
+import type { Subject } from './subject.js';
+/** Whether a record was left at rest during a handover. */
+export declare const isRested: (h: {
+    restedAt: number;
+}) => boolean;
 /** A record with every field written out, optional ones too, as every record in a mix is built. */
 export type WholeRecord = {
     [K in Field]: Subject<unknown>[K];

package/dist/record.js

@@ -1,3 +1,5 @@
+/** Whether a record was left at rest during a handover. */
+export const isRested = (h) => !Number.isNaN(h.restedAt);
 /**
  * A subject's record for `voice` holding every field one can come to hold, in one order, so every
  * record in a mix shares one hidden class: a record built elsewhere, or given `base`, `snaps` or
@@ -12,7 +14,7 @@ export function record(voice, reaches, state) {
         since: 0,
         shown: 0,
         weight: 0,
-        rested: false,
+        restedAt: Number.NaN,
         bands: null,
         state,
         // -0, not 0: a field first given a small integer is boxed on every later write of a double.
@@ -36,7 +38,7 @@ export function record(voice, reaches, state) {
         voice,
         next: null,
         version: Number.NaN,
-        loci: null,
+        roles: null,
         slot: -1,
         run: -1,
         freed: -1,

package/dist/relink.d.ts

@@ -1,4 +1,4 @@
-import type { Subject } from './voice.js';
+import type { Subject } from './subject.js';
 /** What `patch` needs of a voice: its place in voice order. */
 interface Ordered {
     readonly id: number;

package/dist/restored.d.ts

@@ -1,7 +1,7 @@
+import type { Cut } from './cut.js';
 import type { Leavings } from './leavings.js';
 import { Store } from './store.js';
-import type { Cut } from './transport.js';
-import type { Subject } from './voice.js';
+import type { Subject } from './subject.js';
 /**
  * The seeks back after the one a record was last put back, written or deleted at, which every
  * record stamped then shares. The next seek fills it; a later seek to as early a moment joins it

package/dist/restored.js

@@ -138,7 +138,7 @@ export class Restored extends Store {
     }
     /** `get`, given what `own` holds for `key`. */
     from(key, own) {
-        const mark = own !== undefined && own.reaches;
+        const mark = own?.reaches;
         const at = (mark ? own.restored : this.at.get(key)) ?? this.first;
         const now = this.stamp;
         if (at === now)

package/dist/rests.d.ts

@@ -0,0 +1,9 @@
+import type { Mixer } from './mixer.js';
+import type { Voice } from './voice.js';
+export declare function atRest<I, O>(this: Mixer<I, O>, subject: I): boolean;
+export declare function rests<I, O>(this: Mixer<I, O>, pose: O): boolean;
+export declare function restful<I, O>(this: Mixer<I, O>): boolean;
+/** Whether a voice will change no pose from `now` on, short of a change made to it. */
+export declare function still<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, now: number): boolean;
+export declare function restsLaned<I, O>(this: Mixer<I, O>): boolean;
+export declare function restsKey<I, O>(this: Mixer<I, O>): number;

package/dist/rests.js

@@ -0,0 +1,76 @@
+import { near } from './fold.js';
+import { Store } from './store.js';
+export function atRest(subject) {
+    this.restStamps ??= new Store();
+    const head = this.linked(subject);
+    const laned = this.linkedLaned;
+    const lanes = this.lanes;
+    // Every voice on lanes and nothing to clamp: the pose a fold would make is the lanes' values.
+    if (laned && this.restsLaned()) {
+        const slot = head.slot;
+        if (!lanes.owes(slot))
+            return lanes.rests(slot);
+    }
+    // A probe this frame answers for the pose it gave the host.
+    const since = (this.restStamps.get(subject) ?? Number.NaN) - 2 * this.restsKey();
+    if (since >= 0)
+        return since === 1;
+    this.restScratch ??= this.pose();
+    const pose = this.foldWith(subject, this.restScratch, head, laned, true);
+    return this.rests((this.bounded.length === 0 ? pose : this.clamp(pose)));
+}
+export function rests(pose) {
+    for (let i = 0; i < this.names.length; i++) {
+        const channel = this.channels[i];
+        const value = pose[this.names[i]];
+        if (channel.rest === undefined) {
+            if (value !== undefined)
+                return false;
+        }
+        else if (!near(value, channel.rest))
+            return false;
+    }
+    return true;
+}
+export function restful() {
+    // Standing still, a voice changes no pose but by its weight signal, or by an anchor or start
+    // that host time may yet reach.
+    if (this.pace?.stopped(this.u))
+        return this.cued.every((v) => v.state === 'done' ||
+            (v.state !== 'pending' &&
+                typeof v.spec.weight !== 'function' &&
+                v.spec.anchor === undefined));
+    return this.cued.every((v) => this.still(v, this.now));
+}
+/** Whether a voice will change no pose from `now` on, short of a change made to it. */
+export function still(voice, now) {
+    if (voice.state === 'done')
+        return true;
+    if (voice.state !== 'frozen' && voice.state !== 'live')
+        return false;
+    if (typeof voice.spec.weight === 'function' || voice.parts !== null)
+        return false;
+    const fadeIn = this.reducedNow ? 0 : (voice.fade.in ?? 0);
+    if (fadeIn > 0 && now - this.sinceOf(voice, voice.latest) < fadeIn)
+        return false;
+    if (voice.state === 'frozen' || voice.holding !== null)
+        return true;
+    const motion = voice.motion;
+    return motion !== undefined && voice.elapsedAt(now) >= voice.latest && motion.landed();
+}
+export function restsLaned() {
+    return this.lanes.whole && this.bounded.length === 0;
+}
+export function restsKey() {
+    if (this.frame !== this.restsFrame ||
+        this.version !== this.restsVersion ||
+        this.relinks !== this.restsRelinks ||
+        this.stirs !== this.restsStirs) {
+        this.restsEpoch++;
+        this.restsFrame = this.frame;
+        this.restsVersion = this.version;
+        this.restsRelinks = this.relinks;
+        this.restsStirs = this.stirs;
+    }
+    return this.restsEpoch;
+}

package/dist/revive.d.ts

@@ -1,10 +1,11 @@
 import type { Mixer } from './mixer.js';
-import type { Run } from './motions.js';
 import type { Past } from './origin.js';
 import { type PackedRecord } from './pack.js';
 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 Parted, type Parting, type Ramp, type Rise, Voice } from './voice.js';
+import { type Controls, 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;

package/dist/revive.js

@@ -1,4 +1,4 @@
-import { playable } from './cue.js';
+import { playable, roleOf } from './cue.js';
 import { VoiceHandle } from './handle.js';
 import { handle } from './hosts.js';
 import { Leavings } from './leavings.js';
@@ -120,7 +120,7 @@ export function reviveVoice(mix, id, d) {
     const revive = mix.opts.history?.revive;
     if (revive === undefined)
         throw new Error('blits: a paged voice needs history.revive');
-    const spec = { ...revive(d.as), as: d.as };
+    const spec = roleOf(mix, { ...revive(d.as), as: d.as });
     playable(mix, spec);
     const voice = new Voice(id, spec, spec.patch, spec.fade ?? {}, Number.NEGATIVE_INFINITY, d.start, mix.slotOf, mix.channels, mix.opts.host, mix.send, null);
     voice.clocks = d.clocks;

package/dist/{locus.d.ts → role.d.ts}

@@ -1,11 +1,12 @@
 import type { Mixer } from './mixer.js';
-import type { Subject, Voice } from './voice.js';
+import type { Subject } from './subject.js';
+import type { Voice } from './voice.js';
 /**
- * What a fold with a locus in play gathers, kept from one fold to the next: the contributions in
- * voice order, each a voice's own or a locus's first member; every locus member; and per channel
- * slot, a locus's folding value, the weight taken into it and the array it owns.
+ * What a fold with a role in play gathers, kept from one fold to the next: the contributions in
+ * voice order, each a voice's own or a role's first member; every role member; and per channel
+ * slot, a role's folding value, the weight taken into it and the array it owns.
  */
-export interface LocusScratch<I, O> {
+export interface RoleScratch<I, O> {
     n: number;
     voices: (Voice<I, O> | null)[];
     helds: (Subject<unknown> | null)[];
@@ -27,17 +28,17 @@ export interface LocusScratch<I, O> {
     touched: number[];
     owned: (number[] | undefined)[];
 }
-export declare function locusScratch<I, O>(channels: number): LocusScratch<I, O>;
+export declare function roleScratch<I, O>(channels: number): RoleScratch<I, O>;
 /**
  * `value` copied into the array `k` owns for the slot, as long as the channel's rest, where a
  * shorter value leaves the rest's own fill: what the channel's fold and lerp read past its end.
  */
-export declare function own<I, O>(k: LocusScratch<I, O>, slot: number, value: number[], rest: number[]): number[];
+export declare function own<I, O>(k: RoleScratch<I, O>, slot: number, value: number[], rest: number[]): number[];
 /**
- * Folds one locus's members into one contribution through each channel's own `lerp`: its value per
+ * Folds one role's members into one contribution through each channel's own `lerp`: its value per
  * channel goes in `k.values`, the channels in `k.touched` in the order first met, and its weight
  * is returned. A stock `last` channel has nothing to lerp, so it takes its heaviest member's value,
  * the later cued of two as heavy. A channel folding by scale takes its value in an array of `k`'s own, lerped in
  * place, since the fold only reads it.
  */
-export declare function foldLocus<I, O>(this: Mixer<I, O>, k: LocusScratch<I, O>, group: number): number;
+export declare function foldRole<I, O>(this: Mixer<I, O>, k: RoleScratch<I, O>, group: number): number;

package/dist/{locus.js → role.js}

@@ -1,5 +1,5 @@
 import { first } from './clone.js';
-export function locusScratch(channels) {
+export function roleScratch(channels) {
     return {
         n: 0,
         voices: [],
@@ -36,13 +36,13 @@ export function own(k, slot, value, rest) {
     return out;
 }
 /**
- * Folds one locus's members into one contribution through each channel's own `lerp`: its value per
+ * Folds one role's members into one contribution through each channel's own `lerp`: its value per
  * channel goes in `k.values`, the channels in `k.touched` in the order first met, and its weight
  * is returned. A stock `last` channel has nothing to lerp, so it takes its heaviest member's value,
  * the later cued of two as heavy. A channel folding by scale takes its value in an array of `k`'s own, lerped in
  * place, since the fold only reads it.
  */
-export function foldLocus(k, group) {
+export function foldRole(k, group) {
     k.touched.length = 0;
     let sum = 0;
     for (let m = 0; m < k.m; m++)

package/dist/roles.d.ts

@@ -0,0 +1,10 @@
+import type { Mixer } from './mixer.js';
+import type { Subject } from './subject.js';
+import type { Voice } from './voice.js';
+/**
+ * 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.
+ */
+export declare function chainFirst<I, O>(held: Subject<unknown> | null, sharers: readonly Voice<I, O>[], q: number): boolean;
+/** `foldWith`'s voices with a role in play: each role folds at its first member's place. */
+export declare function foldRoles<I, O>(this: Mixer<I, O>, subject: I, pose: Record<string, unknown>, head: Subject<unknown>, laned: boolean, dry: boolean, except: number | undefined, owed: number): O;