@msb235/blits 0.7.1 → 0.8.0

package/dist/handle.js

@@ -1,4 +1,16 @@
 import { retime } from './clock.js';
+import { motionOf } from './motion.js';
+import { leave } from './origin.js';
+/** Refuses a voice rate no clock can run at. */
+export function finiteRate(rate) {
+    if (!Number.isFinite(rate))
+        throw new RangeError(`blits: a voice's rate is a finite number, not ${rate}`);
+}
+/** Refuses a voice weight that is no number: NaN would fold into every channel the voice writes. */
+export function plainWeight(weight) {
+    if (Number.isNaN(weight))
+        throw new RangeError('blits: a voice’s weight is a number, not NaN');
+}
 /**
  * A voice's handle: the host's only way to control a voice once cued. A voice a history store
  * pages out is let go of here too, so the handle answers as a gone voice's does, and a seek that
@@ -49,9 +61,11 @@ export class VoiceHandle {
     }
     // A write to a paged voice changes nothing: it had left when the host made it, as it has on replay.
     set weight(w) {
+        plainWeight(w);
         const voice = this.#voice;
         if (voice === null)
             return;
+        voice.written = true;
         voice.weight = w;
         this.#host.changed(voice);
         this.#host.record('weight', () => {
@@ -66,28 +80,40 @@ export class VoiceHandle {
         this.ramp(r, 0);
     }
     ramp(r, over) {
+        finiteRate(r);
         const voice = this.#voice;
         if (voice === null)
             return;
-        retime(voice, this.#host.nowFor(voice), r, over);
+        voice.written = true;
+        const now = this.#host.nowFor(voice);
+        // A pending voice's clock reads 0 at its start, and a rate taken from now would cross 0 sooner:
+        // a subject it freezes before would play, and step, ahead of a voice that has not started.
+        const u = voice.state === 'pending' && voice.start > now && r > 0 ? voice.start : now;
+        leave(voice, u);
+        retime(voice, u, r, over);
         this.#host.changed(voice);
         this.#host.record('rate', () => this.ramp(r, over));
     }
-    seek(elapsed) {
+    seek(elapsed, opts) {
         const voice = this.#voice;
         if (voice === null)
-            return;
-        voice.rebase(this.#host.nowFor(voice));
+            return 'exact';
+        voice.written = true;
+        const u = this.#host.nowFor(voice);
+        leave(voice, u);
+        voice.rebase(u);
         voice.anchorElapsed = elapsed;
         voice.seeks++;
-        this.#host.sought(voice);
+        const doubt = this.#host.sought(voice, opts?.state !== 'keep');
         this.#host.changed(voice);
-        this.#host.record('seek', () => this.seek(elapsed));
+        this.#host.record('seek', () => this.seek(elapsed, opts));
+        return doubt;
     }
     fade(opts) {
         const voice = this.#voice;
         if (voice === null)
             return;
+        voice.written = true;
         this.#host.fade(voice, opts);
         this.#host.record('fade', () => this.fade(opts));
     }
@@ -95,6 +121,7 @@ export class VoiceHandle {
         const voice = this.#voice;
         if (voice === null)
             return;
+        voice.written = true;
         this.#host.rise(voice, opts);
         this.#host.record('rise', () => this.rise(opts));
     }
@@ -102,4 +129,27 @@ export class VoiceHandle {
         const voice = this.#voice;
         return voice === null ? 0 : this.#host.weightOf(voice, subject);
     }
+    // The patch records each of these itself, so a seek plays them again without the handle.
+    to(subject, target, at) {
+        const voice = this.#voice;
+        if (voice !== null)
+            moves(voice.patch, 'to', 'a spring or a tween').to(subject, target, at);
+    }
+    push(subject, velocity, at) {
+        const voice = this.#voice;
+        if (voice !== null)
+            moves(voice.patch, 'push', 'a spring or a glide').push(subject, velocity, at);
+    }
+    read(subject, at) {
+        const voice = this.#voice;
+        if (voice === null || motionOf(voice.patch) === undefined)
+            return undefined;
+        return voice.patch.read(subject, at);
+    }
+}
+/** A voice's patch as a motion that takes `verb`, or a throw naming the kinds that do. */
+function moves(patch, verb, kinds) {
+    if (motionOf(patch) === undefined || typeof patch[verb] !== 'function')
+        throw new Error(`blits: ${verb} needs a voice playing ${kinds}`);
+    return patch;
 }

package/dist/held.d.ts

@@ -3,12 +3,15 @@ import type { Subject, Voice } from './voice.js';
 /** The record a voice gives every subject it does not reach. */
 export declare function unreachedOf<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, now: number): Subject<unknown>;
 /** What this voice holds for this subject, made on first sight with `target` and `stagger` asked once. */
-export declare function held<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, now: number, slot: number): Subject<unknown>;
+export declare function held<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, slot: number): Subject<unknown>;
 /**
- * When the voice clock reads `delay`, from where it is anchored now; during a ramp this assumes
- * the rate it is ramping to.
+ * The mix time the voice clock first read `delay`, or will by its controls now. A stateful voice
+ * counts from its last seek that rebuilt state, as its records do.
  */
 export declare function sinceOf<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, delay: number): number;
 export declare function shownOf<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, since: number): number;
-/** A voice has gone live: the records it made while pending count from where it started. */
-export declare function started<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): void;
+/**
+ * A voice's start or clock moved, or it went live at `now`: the records whose `since` was still
+ * ahead count from where its clock now puts them.
+ */
+export declare function reorigin<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, now: number): void;

package/dist/held.js

@@ -1,41 +1,32 @@
 import { schedule } from './due.js';
-import { mixTime } from './owner.js';
+import { everyoneOf, inherit, sighted } from './everyone.js';
+import { originOf } from './origin.js';
+import { record } from './record.js';
 import { unreach, unreached } from './unreached.js';
 /** The record a voice gives every subject it does not reach. */
 export function unreachedOf(voice, now) {
     const since = this.sinceOf(voice, 0);
-    const none = {
-        reaches: false,
-        delay: 0,
-        since,
-        shown: this.shownOf(voice, since),
-        weight: 0,
-        rested: false,
-        bands: null,
-        state: undefined,
-        stepped: now,
-        ticks: 0,
-        probed: Number.NaN,
-        delta: null,
-        phase: 0,
-        seeks: 0,
-        kept: null,
-        voice,
-        next: null,
-        version: Number.NaN,
-        loci: null,
-        slot: -1,
-    };
+    const none = record(voice, false, undefined);
+    none.since = since;
+    none.shown = this.shownOf(voice, since);
+    none.stepped = now;
+    none.rebuilt = voice.rebuilds;
     voice.unreached = none;
     return none;
 }
 /** What this voice holds for this subject, made on first sight with `target` and `stagger` asked once. */
-export function held(voice, subject, now, slot) {
+export function held(voice, subject, slot) {
+    if (voice.sharing) {
+        const all = everyoneOf(this, voice);
+        if (all !== null)
+            return all;
+    }
     if (unreached(voice, slot))
         return voice.unreached;
     let held = voice.subjects.get(subject);
     if (held !== undefined)
         return held;
+    const now = this.now;
     const reaches = this.aims(voice, subject);
     if (!reaches) {
         // Nothing is kept for a subject the voice does not reach, so one record stands for them all:
@@ -55,38 +46,36 @@ export function held(voice, subject, now, slot) {
     }
     const delay = voice.spec.stagger ? voice.spec.stagger(subject) : 0;
     const since = this.sinceOf(voice, delay);
-    held = {
-        reaches: true,
-        delay,
-        since,
-        shown: this.shownOf(voice, since),
-        weight: 0,
-        rested: false,
-        bands: null,
-        state: voice.patch.state ? voice.patch.state(subject) : undefined,
-        stepped: this.backward && since < now ? since : now,
-        ticks: 0,
-        probed: Number.NaN,
-        delta: null,
-        phase: 0,
-        seeks: 0,
-        kept: null,
-        voice,
-        next: null,
-        version: Number.NaN,
-        loci: null,
-        slot: -1,
-    };
+    const shown = this.shownOf(voice, since);
+    held = record(voice, true, voice.patch.state ? voice.patch.state(subject) : undefined);
+    held.delay = delay;
+    held.since = since;
+    held.shown = shown;
+    held.stepped = since < now ? since : now;
+    held.rebuilt = voice.rebuilds;
     if (this.projecting) {
         held.from = held.stepped;
         held.unknown = this.backward && voice.spec.from === 'current';
     }
     voice.subjects.set(subject, held);
-    if (voice.state === 'pending') {
+    if (!(since <= now)) {
         voice.early ??= [];
-        voice.early.push(held);
+        const early = voice.early;
+        // Prunes at each doubling, so records whose origin has passed are not kept to the voice's end.
+        if (early.length >= 64 && (early.length & (early.length - 1)) === 0) {
+            let kept = 0;
+            for (const h of early)
+                if (!(h.since <= now))
+                    early[kept++] = h;
+            early.length = kept;
+        }
+        early.push(held);
     }
-    voice.seen++;
+    // A subject a voice saw while it shared one record was counted then.
+    if (sighted(voice, slot))
+        inherit(voice, held, slot);
+    else
+        voice.seen++;
     if (delay > voice.latest) {
         voice.latest = delay;
         // A later end can take a frozen voice live again.
@@ -96,26 +85,35 @@ export function held(voice, subject, now, slot) {
     return held;
 }
 /**
- * When the voice clock reads `delay`, from where it is anchored now; during a ramp this assumes
- * the rate it is ramping to.
+ * The mix time the voice clock first read `delay`, or will by its controls now. A stateful voice
+ * counts from its last seek that rebuilt state, as its records do.
  */
 export function sinceOf(voice, delay) {
-    const t = voice.rate > 0
-        ? voice.anchorNow + (delay - voice.anchorElapsed) / voice.rate
-        : voice.start + delay;
-    return voice.owner === null ? t : mixTime(voice.owner, t);
+    const p = voice.patch;
+    return originOf(voice, delay, p.state !== undefined || p.step !== undefined || voice.keeping);
 }
 export function shownOf(voice, since) {
     return voice.freezesBefore && voice.opened < since ? voice.opened : since;
 }
-/** A voice has gone live: the records it made while pending count from where it started. */
-export function started(mix, voice) {
+/**
+ * A voice's start or clock moved, or it went live at `now`: the records whose `since` was still
+ * ahead count from where its clock now puts them.
+ */
+export function reorigin(mix, voice, now) {
     const early = voice.early;
     if (early === null)
         return;
-    voice.early = null;
+    let kept = 0;
     for (const held of early) {
         held.since = mix.sinceOf(voice, held.delay);
         held.shown = mix.shownOf(voice, held.since);
+        if (held.ticks === 0 && held.stepped > held.since)
+            held.stepped = held.since;
+        if (!(held.since <= now))
+            early[kept++] = held;
     }
+    early.length = kept;
+    if (kept === 0)
+        voice.early = null;
+    mix.lanes?.reshown(voice.id);
 }

package/dist/history.d.ts

@@ -1,13 +1,20 @@
 import type { Mixer } from './mixer.js';
+import { type Cut } from './transport.js';
 import { type Subject, type Voice } from './voice.js';
-/**
- * The last entry taken before `t`, or at it where `inclusive` says so, as it does for a change a
- * sync made. A host's change between frames is taken strictly: it shows from the next frame on, as
- * it did live.
- */
+/** The last entry taken before `t`, or at it where `inclusive` says so. */
 export declare function last<T extends {
     at: number;
 }>(list: readonly T[], t: number, inclusive: boolean | ((e: T) => boolean)): T | undefined;
+/**
+ * The last entry of a list kept in the order it was made that falls inside `cut`, an entry made
+ * before its frame was read counting as `early`.
+ */
+export declare function lastWithin<T extends {
+    seq: number;
+    sync?: boolean;
+}>(list: readonly T[], cut: Cut): T | undefined;
+/** Deep equality over plain data, for telling whether a host field changed. */
+export declare function same(a: unknown, b: unknown): boolean;
 /** A voice's elapsed at an earlier mix time, by the controls it had then. */
 export declare function elapsedThen<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, t: number): number;
 /** Records a change to a voice's controls under `history`, and lets go of what it no longer reaches. */
@@ -25,11 +32,8 @@ export declare function remember<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, sub
  * for a seek or a read back to before then; without history, keeps nothing.
  */
 export declare function leave<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject: I, held: Subject<unknown> | undefined): void;
-/** The record a subject had at mix time `t` and left a voice with after it, if it left after `t`. */
-export declare function leftAt<I>(left: readonly {
-    subject: I;
-    at: number;
-    held: Subject<unknown>;
-}[] | null, subject: I, t: number): Subject<unknown> | undefined;
-/** The mix time a motion patch keeps a released subject from, and how far back, under history. */
-export declare function releasing<I, O>(mix: Mixer<I, O>): [at?: number, reach?: number];
+/**
+ * The mix time a motion patch keeps a released subject from, how far back, and the frame, under
+ * history.
+ */
+export declare function releasing<I, O>(mix: Mixer<I, O>): [at?: number, reach?: number, seq?: number];

package/dist/history.js

@@ -1,15 +1,13 @@
 import { elapsedWith } from './clock.js';
 import { clone } from './clone.js';
 import { schedule } from './due.js';
+import { Leavings } from './leavings.js';
 import { packHeld } from './pack.js';
 import { pageOut } from './paging.js';
 import { scoreTouched } from './scored.js';
+import { within } from './transport.js';
 import { none } from './voice.js';
-/**
- * The last entry taken before `t`, or at it where `inclusive` says so, as it does for a change a
- * sync made. A host's change between frames is taken strictly: it shows from the next frame on, as
- * it did live.
- */
+/** The last entry taken before `t`, or at it where `inclusive` says so. */
 export function last(list, t, inclusive) {
     let lo = 0;
     let hi = list.length - 1;
@@ -26,8 +24,28 @@ export function last(list, t, inclusive) {
     }
     return found;
 }
+/**
+ * The last entry of a list kept in the order it was made that falls inside `cut`, an entry made
+ * before its frame was read counting as `early`.
+ */
+export function lastWithin(list, cut) {
+    let lo = 0;
+    let hi = list.length - 1;
+    let found;
+    while (lo <= hi) {
+        const mid = (lo + hi) >> 1;
+        const e = list[mid];
+        if (within(cut, e.seq, e.sync)) {
+            found = e;
+            lo = mid + 1;
+        }
+        else
+            hi = mid - 1;
+    }
+    return found;
+}
 /** Deep equality over plain data, for telling whether a host field changed. */
-function same(a, b) {
+export function same(a, b) {
     if (a === b)
         return true;
     if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null)
@@ -59,7 +77,7 @@ export function noted(mix, voice) {
     const log = voice.log;
     if (log === null)
         return;
-    voice.note(Number.isNaN(mix.now) ? Number.NEGATIVE_INFINITY : mix.now, mix.moving);
+    voice.note(Number.isNaN(mix.now) ? Number.NEGATIVE_INFINITY : mix.now, mix.transport.seq, mix.moving || !mix.looked);
     const reach = mix.now - mix.opts.history.ms;
     let drop = 0;
     while (drop + 1 < log.length && log[drop + 1].at <= reach)
@@ -108,7 +126,8 @@ export function copyHeld(voice, h) {
 export function recordHost(mix, now) {
     const log = mix.hostLog;
     const prev = log[log.length - 1];
-    if (prev !== undefined && prev.at === now)
+    const seq = mix.transport.seq;
+    if (prev !== undefined && prev.seq === seq)
         return;
     const host = mix.opts.host;
     const fields = {};
@@ -118,7 +137,7 @@ export function recordHost(mix, now) {
                 fields[f] = clone(host[f]);
     if (prev !== undefined && same(prev.fields, fields))
         return;
-    log.push({ at: now, fields });
+    log.push({ at: now, seq, fields });
     const reach = now - mix.opts.history.ms;
     pageOut(mix, 'host', undefined, undefined, older(log, reach), (e) => e.fields, reach);
 }
@@ -135,7 +154,7 @@ export function record(mix, voice, subject, held, value) {
             prev.value = value;
         return;
     }
-    inputs.push({ at: mix.now, value });
+    inputs.push({ at: mix.now, seq: mix.transport.seq, value });
     const reach = mix.now - history.ms;
     const out = older(inputs, reach);
     if (out.length > 0)
@@ -155,7 +174,7 @@ export function remember(mix, voice, subject, held) {
     const prev = snaps[snaps.length - 1];
     if (prev !== undefined && mix.now - prev.at < (history.every ?? 200))
         return;
-    snaps.push({ at: mix.now, held: copyHeld(voice, held) });
+    snaps.push({ at: mix.now, seq: mix.transport.seq, held: copyHeld(voice, held) });
     const reach = mix.now - history.ms;
     const out = older(snaps, reach);
     if (out.length > 0)
@@ -170,27 +189,27 @@ export function leave(mix, voice, subject, held) {
     if (history === undefined || held === undefined)
         return;
     const reach = mix.now - history.ms;
-    const left = [];
-    for (const e of voice.left ?? [])
-        if (e.at >= reach)
-            left.push(e);
-        else if (mix.keys !== null)
-            pageOut(mix, 'left', voice.id, mix.keys.key(e.subject), [e], (x) => packHeld(voice, x.held), reach);
-    left.push({ subject, at: Number.isNaN(mix.now) ? Number.NEGATIVE_INFINITY : mix.now, held });
+    const left = voice.left ?? new Leavings();
     voice.left = left;
+    const keys = mix.keys;
+    left.expire(reach, keys === null
+        ? null
+        : (e) => pageOut(mix, 'left', voice.id, keys.key(e.subject), [e], (x) => [packHeld(voice, x.held), x.sync], reach));
+    left.push({
+        subject,
+        at: Number.isNaN(mix.now) ? Number.NEGATIVE_INFINITY : mix.now,
+        seq: mix.transport.seq,
+        sync: mix.syncing,
+        held,
+    });
 }
-/** The record a subject had at mix time `t` and left a voice with after it, if it left after `t`. */
-export function leftAt(left, subject, t) {
-    let found;
-    for (const e of left ?? [])
-        if (e.at > t && Object.is(e.subject, subject) && (found === undefined || e.at < found.at))
-            found = e;
-    return found?.held;
-}
-/** The mix time a motion patch keeps a released subject from, and how far back, under history. */
+/**
+ * The mix time a motion patch keeps a released subject from, how far back, and the frame, under
+ * history.
+ */
 export function releasing(mix) {
     const history = mix.opts.history;
     if (history === undefined || Number.isNaN(mix.now))
         return [];
-    return [mix.now, mix.now - history.ms];
+    return [mix.now, mix.now - history.ms, mix.transport.seq];
 }

package/dist/hosts.js

@@ -2,15 +2,18 @@ import { Book } from './book.js';
 import { numericOf } from './channels.js';
 import { crowdable } from './crowd.js';
 import { schedule } from './due.js';
+import { unshare, unsight, weightAt } from './everyone.js';
 import { beginFade, beginRise, fadeAt, fadeSubject } from './fade.js';
 import { goneIndex } from './gone.js';
 import { VoiceHandle } from './handle.js';
+import { reorigin } from './held.js';
 import { noted, remember } from './history.js';
 import { hostOf, listed, markOf, readingAt } from './marks.js';
 import { nextFrame } from './move.js';
 import { descendants, ownWeight, signalled } from './owner.js';
 import { localNow } from './place.js';
 import { reading } from './reading.js';
+import { heard } from './signals.js';
 import { record } from './tape.js';
 import { unreach } from './unreached.js';
 export function book(mix, opts) {
@@ -52,12 +55,15 @@ export function laneHost(mix) {
             for (let held = head; held !== null; held = held.next)
                 if (held.voice === voice)
                     return held;
-            return mix.held(voice, subject, mix.now, slot);
+            return mix.held(voice, subject, slot);
         },
         forgot: (slot) => {
             // Only a voice over every subject keeps bits, and one gone may still be read back.
-            for (const voice of mix.general)
+            for (const voice of mix.general) {
                 unreach(voice, slot, false);
+                if (voice.sighted !== null)
+                    unsight(voice, slot);
+            }
             for (const voice of goneIndex(mix).general)
                 unreach(voice, slot, false);
         },
@@ -110,8 +116,13 @@ export function fits(mix, voice) {
     // A fill weighs a voice's owners once for every subject, which a signal on one would not be.
     if (voice.owner !== null && signalled(voice))
         return false;
-    // A signal reading host input records it per probe under history, which a fill cannot.
-    if (typeof spec.weight === 'function' && spec.weight.input && mix.opts.history?.inputs)
+    // What can change between two probes without `Lanes.current` hearing of it keeps a voice off:
+    // an input signal that does not report its changes, one that history records per probe, and a
+    // host field.
+    const w = spec.weight;
+    if (typeof w === 'function' && w.input && (mix.opts.history?.inputs || !heard(w)))
+        return false;
+    if (patch.reads !== undefined && patch.reads.length > 0)
         return false;
     // A locus on lanes gathers keys and fn members; a motion member keeps it on the general path.
     if (spec.locus !== undefined && voice.motion !== undefined)
@@ -126,17 +137,38 @@ export function fits(mix, voice) {
         return false;
     if (patch.state !== undefined || patch.step !== undefined)
         return false;
-    if (mix.opts.history?.inputs && patch.reads !== undefined && patch.reads.length > 0)
-        return false;
     const built = voice.built;
     return (built === null ||
         built.tracks.every((t, i) => t.lerp === undefined || t.lerp === voice.lerps[i]));
 }
+const RANK = { exact: 0, stepped: 1, held: 2 };
+/** How sure a seek leaves a voice's state: kept is held; rebuilt is exact only on a fixed step. */
+function seekDoubt(mix, voice, rebuild) {
+    const patch = voice.patch;
+    if (patch.state === undefined && patch.step === undefined && !voice.keeping)
+        return 'exact';
+    if (!rebuild)
+        return 'held';
+    const weight = voice.spec.weight;
+    if ((patch.reads !== undefined && patch.reads.length > 0) ||
+        (typeof weight === 'function' && weight.input))
+        return 'held';
+    if (voice.keeping)
+        return 'stepped';
+    if (patch.step === undefined)
+        return 'exact';
+    const tick = mix.opts.stepMs;
+    const fixed = tick !== undefined && tick > 0 && !mix.reducedNow && mix.opts.maxDt === undefined;
+    return fixed ? 'exact' : 'stepped';
+}
 /** A voice's patch kept state on a record: it is stateful from now on. */
 export function stateful(mix, voice) {
     if (voice.keeping)
         return;
     voice.keeping = true;
+    // The call that kept state was for the subject last sent to, whose record the state is on.
+    if (voice.sharing)
+        unshare(mix, voice, true, mix.sending.subject);
     mix.lanes?.invalidate();
 }
 export function handle(mix, voice) {
@@ -153,16 +185,28 @@ function handleHost(mix) {
         },
         changed: (voice) => {
             mix.frame = nextFrame();
+            reorigin(mix, voice, mix.now);
+            if (voice.holding !== null)
+                descendants(voice, (v) => reorigin(mix, v, mix.now));
             noted(mix, voice);
             mix.lanes?.refill();
         },
         // A delta read before an owner's seek, or a hit booked, is not taken as standing after it.
-        sought: (voice) => {
+        sought: (voice, rebuild) => {
+            if (rebuild)
+                voice.rebuilds++;
+            let doubt = seekDoubt(mix, voice, rebuild);
             if (voice.holding !== null)
                 descendants(voice, (v) => {
                     v.seeks++;
+                    if (rebuild)
+                        v.rebuilds++;
+                    const d = seekDoubt(mix, v, rebuild);
+                    if (RANK[d] > RANK[doubt])
+                        doubt = d;
                     schedule(mix, v);
                 });
+            return doubt;
         },
         fade: (voice, opts) => {
             if (voice.holding !== null && opts !== undefined && ('subject' in opts || opts.at === 'rest'))
@@ -180,11 +224,14 @@ function handleHost(mix) {
                 return 0;
             if (voice.holding !== null)
                 return ownWeight(voice, mix.now, mix.reducedNow, (o) => mix.ownerBase(o, subject));
+            const slot = mix.lanes === null ? -1 : (mix.chains.get(subject)?.slot ?? -1);
             if (voice.laned && mix.lanes !== null) {
-                const w = mix.lanes.weightOf(voice.id, mix.chains.get(subject)?.slot ?? -1);
+                const w = mix.lanes.weightOf(voice.id, slot);
                 if (w !== undefined)
                     return w;
             }
+            if (voice.sharing)
+                return weightAt(voice, slot);
             return voice.subjects.get(subject)?.weight ?? 0;
         },
         record: (label, again) => record(mix, label, again),

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-export type { NumberOptions } from './channels.js';
+export type { NumberOptions, Vec } from './channels.js';
 export { kit, last, max, mul, sum, vec } from './channels.js';
 export type { ColorOptions } from './color.js';
-export { color, css, hex, mixHex, oklab, toHex } from './color.js';
+export { color, css, mixHex, oklab, toHex } from './color.js';
 export type { Claim, Fit, FitPlan, Order, SpanClaim, Strength } from './fit.js';
 export { conclude, condense, lax, layout, overrun, pipe, plain, shed, } from './fit.js';
 export { mix, mixer } from './mixer.js';
@@ -10,8 +10,13 @@ export { glide, spring, tween } from './motion.js';
 export { HistoryMiss } from './paging.js';
 export type { KeysOptions, PatchOptions } from './patch.js';
 export { keys, patch } from './patch.js';
-export { gate, lag, level, peak, slew } from './signals.js';
+export type { AngleOptions } from './rotation.js';
+export { angle, quat } from './rotation.js';
+export { gate, input, lag, level, peak, slew } from './signals.js';
+export { fold } from './stack.js';
 export type { Ticked, Ticker, TickerOptions } from './ticker.js';
 export { ticker } from './ticker.js';
 export { transport } from './transport.js';
-export type { Anchor, BookedHit, Booker, BookOptions, Channel, Columns, Described, Doubt, Easing, Engine, FadeOptions, FadeSpec, FitResult, Handle, HistoryOptions, HistoryStore, Hit, Keyframe, Kit, Mark, Marked, Mix, MixOptions, MotionSpec, OwnerSpec, Paged, PagedStream, Patch, Placement, Projection, Query, Sent, Setting, Signal, SpanHandle, SpanHints, SpanSpec, Tape, TapeBranch, TapeMaker, TapeOp, Transport, TransportOptions, TransportProjection, VoiceSpec, } from './types.js';
+export type { Anchor, BookedHit, Booker, BookOptions, Channel, Columns, Described, Doubt, Easing, Engine, FadeOptions, FadeSpec, FitResult, Handle, HistoryOptions, HistoryStore, Hit, Keyframe, Kit, Mark, Marked, Mix, MixOptions, MotionSpec, OwnerSpec, Paged, PagedStream, Patch, Placement, Projection, Query, SeekOptions, Sent, Setting, Signal, SpanHandle, SpanHints, SpanSpec, Tape, TapeBranch, TapeMaker, TapeOp, Transport, TransportOptions, TransportProjection, VoiceSpec, } from './types.js';
+export type { WaveOptions, WaveShape } from './wave.js';
+export { wave, waveAt } from './wave.js';

package/dist/index.js

@@ -1,10 +1,13 @@
 export { kit, last, max, mul, sum, vec } from './channels.js';
-export { color, css, hex, mixHex, oklab, toHex } from './color.js';
+export { color, css, mixHex, oklab, toHex } from './color.js';
 export { conclude, condense, lax, layout, overrun, pipe, plain, shed, } from './fit.js';
 export { mix, mixer } from './mixer.js';
 export { glide, spring, tween } from './motion.js';
 export { HistoryMiss } from './paging.js';
 export { keys, patch } from './patch.js';
-export { gate, lag, level, peak, slew } from './signals.js';
+export { angle, quat } from './rotation.js';
+export { gate, input, lag, level, peak, slew } from './signals.js';
+export { fold } from './stack.js';
 export { ticker } from './ticker.js';
 export { transport } from './transport.js';
+export { wave, waveAt } from './wave.js';