@msb235/blits 0.9.0 → 0.11.0

package/dist/held.js

@@ -1,4 +1,5 @@
 import { changed } from './chain.js';
+import { stepOf } from './clock.js';
 import { schedule } from './due.js';
 import { everyoneOf, inherit, sighted } from './everyone.js';
 import { originOf } from './origin.js';
@@ -53,11 +54,11 @@ export function held(voice, subject, slot) {
     held.delay = delay;
     held.since = since;
     held.shown = shown;
-    held.stepped = since < now ? since : now;
+    const fresh = meet(this, voice, held, now);
     held.rebuilt = voice.rebuilds;
     if (this.projecting) {
         held.from = held.stepped;
-        held.unknown = this.backward && voice.spec.from === 'current';
+        held.unknown = (this.backward && voice.spec.from === 'current') || fresh;
     }
     voice.subjects.set(subject, held);
     if (!(since <= now)) {
@@ -91,6 +92,30 @@ export function held(voice, subject, slot) {
     }
     return held;
 }
+/**
+ * Where a new record met at `now` starts stepping: from its `since`, or from `now` for a voice that
+ * catches up `fresh`, on the `stepMs` grid. True where that skipped steps, so the state depends on
+ * when the subject was first probed.
+ */
+export function meet(mix, voice, held, now) {
+    const since = held.since;
+    if (!(since < now)) {
+        held.stepped = now;
+        return false;
+    }
+    if (voice.spec.catchUp !== 'fresh' || voice.patch.step === undefined) {
+        held.stepped = since;
+        return false;
+    }
+    const tick = stepOf(mix, voice);
+    if (tick === undefined)
+        held.stepped = now;
+    else {
+        held.ticks = Math.floor((now - since) / tick + 1e-9);
+        held.stepped = since + held.ticks * tick;
+    }
+    return held.stepped > since;
+}
 /**
  * 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.
@@ -118,10 +143,19 @@ export function begin(mix, voice, now) {
     if (voice.anchorElapsed !== 0) {
         voice.seeks++;
         voice.rebuilds++;
+        // Kept with its controls, so a seek back to after this puts back the count its records hold.
+        voice.note(now, mix.transport.seq, true);
     }
     reorigin(mix, voice, now);
     changed(mix, voice);
 }
+/** Counts a record whose `since` was still ahead from where its voice's clock now puts it. */
+export function origin(mix, voice, held) {
+    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;
+}
 /**
  * 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.
@@ -132,10 +166,7 @@ export function reorigin(mix, voice, now) {
         return;
     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;
+        origin(mix, voice, held);
         if (!(held.since <= now))
             early[kept++] = held;
     }

package/dist/history.d.ts

@@ -19,12 +19,18 @@ export declare function same(a: unknown, b: unknown): boolean;
 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. */
 export declare function noted<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): void;
+/** A copy of the state a voice's patch keeps for a subject. */
+export declare function copyState<I, O>(voice: Voice<I, O>, state: unknown): unknown;
 /** A copy of a subject's record that shares nothing a read could change. */
 export declare function copyHeld<I, O>(voice: Voice<I, O>, h: Subject<unknown>): Subject<unknown>;
 /** Under `history` with `inputs`, copies the host fields any voice reads, once a frame, when they changed. */
 export declare function recordHost<I, O>(mix: Mixer<I, O>, now: number): void;
 /** Under `history` with `inputs`, keeps what an input signal read, each time it changes. */
 export declare function record<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject: I, held: Subject<unknown>, value: number): void;
+/** How far apart, in mix ms, a record's copies are kept. */
+export declare function apart(history: {
+    readonly every?: number;
+}): number;
 /** Under `history`, keeps a copy of a stateful voice's record for this subject every so often. */
 export declare function remember<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject: I, held: Subject<unknown>): void;
 /**

package/dist/history.js

@@ -93,6 +93,11 @@ function older(list, reach) {
         n++;
     return n === 0 ? [] : list.splice(0, n);
 }
+/** A copy of the state a voice's patch keeps for a subject. */
+export function copyState(voice, state) {
+    const patch = voice.patch;
+    return patch.clone ? patch.clone(state) : clone(state);
+}
 /** A copy of a subject's record that shares nothing a read could change. */
 export function copyHeld(voice, h) {
     let kept = null;
@@ -101,11 +106,10 @@ export function copyHeld(voice, h) {
         for (const [owner, value] of h.kept)
             kept.set(owner, clone(value));
     }
-    const patch = voice.patch;
     return {
         ...h,
         bands: h.bands === null ? null : h.bands.slice(),
-        state: h.state === undefined ? undefined : patch.clone ? patch.clone(h.state) : clone(h.state),
+        state: h.state === undefined ? undefined : copyState(voice, h.state),
         kept,
         unkept: h.unkept?.map(clone),
         probed: Number.NaN,
@@ -160,6 +164,10 @@ export function record(mix, voice, subject, held, value) {
     if (out.length > 0)
         pageOut(mix, 'input', voice.id, mix.keys?.key(subject), out, (e) => e.value, reach);
 }
+/** How far apart, in mix ms, a record's copies are kept. */
+export function apart(history) {
+    return history.every ?? 200;
+}
 /** Under `history`, keeps a copy of a stateful voice's record for this subject every so often. */
 export function remember(mix, voice, subject, held) {
     const history = mix.opts.history;
@@ -172,7 +180,7 @@ export function remember(mix, voice, subject, held) {
     const snaps = held.snaps ?? [];
     held.snaps = snaps;
     const prev = snaps[snaps.length - 1];
-    if (prev !== undefined && mix.now - prev.at < (history.every ?? 200))
+    if (prev !== undefined && mix.now - prev.at < apart(history))
         return;
     snaps.push({ at: mix.now, seq: mix.transport.seq, held: copyHeld(voice, held) });
     const reach = mix.now - history.ms;
@@ -194,13 +202,15 @@ export function leave(mix, voice, subject, held) {
     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));
+        : (e) => pageOut(mix, 'left', voice.id, keys.key(e.subject), [e], (x) => [packHeld(voice, x.held), x.sync, x.ramp, x.parted], reach));
     left.push({
         subject,
         at: Number.isNaN(mix.now) ? Number.NEGATIVE_INFINITY : mix.now,
         seq: mix.transport.seq,
-        sync: mix.syncing,
+        sync: mix.syncing || !mix.looked,
         held,
+        ramp: voice.parts?.get(subject) ?? null,
+        parted: voice.parted?.get(subject) ?? null,
     });
 }
 /**

package/dist/hosts.d.ts

@@ -2,7 +2,7 @@ import type { LaneHost } from './lanes.js';
 import type { Mixer } from './mixer.js';
 import type { Booker, BookOptions, Handle } from './types.js';
 import type { Voice } from './voice.js';
-export declare function book<I, O>(mix: Mixer<I, O>, opts: BookOptions): Booker;
+export declare function book<I, O>(mix: Mixer<I, O>, opts: BookOptions<unknown, I>): Booker;
 export declare function laneHost<I, O>(mix: Mixer<I, O>): LaneHost<I, O>;
 /**
  * Whether a voice's patch and spec can run on a lane, its channels aside. A voice whose patch has

package/dist/hosts.js

@@ -1,5 +1,6 @@
 import { Book } from './book.js';
 import { numericOf } from './channels.js';
+import { stepOf } from './clock.js';
 import { crowdable } from './crowd.js';
 import { schedule } from './due.js';
 import { unshare, unsight, weightAt } from './everyone.js';
@@ -14,6 +15,7 @@ import { descendants, ownWeight, signalled } from './owner.js';
 import { localNow } from './place.js';
 import { reading } from './reading.js';
 import { heard } from './signals.js';
+import { cuedById } from './strays.js';
 import { record } from './tape.js';
 import { unreach } from './unreached.js';
 export function book(mix, opts) {
@@ -161,8 +163,7 @@ function seekDoubt(mix, voice, rebuild) {
         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;
+    const fixed = stepOf(mix, voice) !== undefined && mix.opts.maxDt === undefined;
     return fixed ? 'exact' : 'stepped';
 }
 /** A voice's patch kept state on a record: it is stateful from now on. */
@@ -234,10 +235,21 @@ function handleHost(mix) {
                 if (w !== undefined)
                     return w;
             }
-            if (voice.sharing)
-                return weightAt(voice, slot);
-            return voice.subjects.get(subject)?.weight ?? 0;
+            const held = voice.sharing
+                ? undefined
+                : voice.subjects.get(subject);
+            // A voice that stopped sharing makes a subject's record at its next read, from what it kept.
+            return held !== undefined ? held.weight : weightAt(voice, slot);
         },
-        record: (label, again) => record(mix, label, again),
+        record: (h, label, again) => record(mix, label, (stage) => {
+            const to = stage.mix(mix);
+            if (to === mix)
+                again(h);
+            else if (to !== undefined) {
+                const voice = cuedById(to, h.id);
+                if (voice !== undefined)
+                    again(handle(to, voice));
+            }
+        }),
     };
 }

package/dist/index.d.ts

@@ -12,11 +12,11 @@ export type { KeysOptions, PatchOptions } from './patch.js';
 export { keys, patch } from './patch.js';
 export type { AngleOptions } from './rotation.js';
 export { angle, quat } from './rotation.js';
-export { gate, input, lag, level, peak, slew } from './signals.js';
+export { gate, input, lag, level, peak, share, 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, SeekOptions, Sent, Setting, Signal, SpanHandle, SpanHints, SpanSpec, Tape, TapeBranch, TapeMaker, TapeOp, Transport, TransportOptions, TransportProjection, VoiceSpec, } from './types.js';
+export type { Anchor, BlendMember, BookedHit, Booker, BookOptions, Channel, Columns, Described, Doubt, Easing, Engine, FadeOptions, FadeSpec, FitResult, Handle, HistoryOptions, HistoryStore, Hit, Keyframe, Kit, Mark, Marked, MarkName, 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

@@ -6,7 +6,7 @@ export { glide, spring, tween } from './motion.js';
 export { HistoryMiss } from './paging.js';
 export { keys, patch } from './patch.js';
 export { angle, quat } from './rotation.js';
-export { gate, input, lag, level, peak, slew } from './signals.js';
+export { gate, input, lag, level, peak, share, slew } from './signals.js';
 export { fold } from './stack.js';
 export { ticker } from './ticker.js';
 export { transport } from './transport.js';

package/dist/keyfill.js

@@ -23,6 +23,7 @@ export function runKeys(lanes, lane) {
     const before = voice.freezesBefore;
     const after = voice.freezesAfter;
     const span = voice.span;
+    const hides = voice.hidesPast;
     const flat = lane.flat;
     const parts = voice.parts !== null;
     const whole = clampWeight(voice.weight);
@@ -42,7 +43,8 @@ export function runKeys(lanes, lane) {
             data[o + 3 /* Row.PROBED */] = data[o + 2 /* Row.WEIGHT */];
         if (lately >= 0 && lanes.unread(slot))
             continue;
-        const elapsed = frozenTime(elapsedNow - data[o + 0 /* Row.DELAY */], before, after, span);
+        const raw = elapsedNow - data[o + 0 /* Row.DELAY */];
+        const elapsed = raw > span && hides ? Number.NaN : frozenTime(raw, before, after, span);
         if (!(elapsed >= 0)) {
             data[o + 2 /* Row.WEIGHT */] = 0;
             unband(records[p]);

package/dist/lane.d.ts

@@ -235,6 +235,6 @@ export declare class Lane<I, O> implements Positions<I, O> {
 }
 /**
  * A subject's voice time once its voice's freezes apply: frozen at 0 before it starts and at the end
- * of its passes after, and NaN where it shows nothing.
+ * of its passes after, and NaN where it shows nothing, as past its end running back.
  */
 export declare function frozenAt<I, O>(voice: Voice<I, O>, elapsed: number): number;

package/dist/lane.js

@@ -185,8 +185,10 @@ export class Lane {
 }
 /**
  * A subject's voice time once its voice's freezes apply: frozen at 0 before it starts and at the end
- * of its passes after, and NaN where it shows nothing.
+ * of its passes after, and NaN where it shows nothing, as past its end running back.
  */
 export function frozenAt(voice, elapsed) {
+    if (elapsed > voice.span && voice.hidesPast)
+        return Number.NaN;
     return frozenTime(elapsed, voice.freezesBefore, voice.freezesAfter, voice.span);
 }

package/dist/lanes.d.ts

@@ -7,6 +7,7 @@ import { type Lane, type Laned, type Locus } from './lane.js';
 import type { Watcher } from './motions.js';
 import { absent, Numbers } from './numbers.js';
 import { Owed } from './owed.js';
+import { Placed } from './placed.js';
 import type { Channel } from './types.js';
 import type { Subject, Voice } from './voice.js';
 /** What a lane fill asks of the mix it belongs to. */
@@ -65,6 +66,13 @@ export declare class Lanes<I, O> implements Watcher {
     /** The crowds of single-subject voices, one per list of channels, and which holds each voice. */
     crowds: Crowd<I, O>[];
     readonly crowdOf: Map<number, Crowd<I, O>>;
+    /** Which crowd voices' rows are placed on each subject. */
+    readonly placed: Placed;
+    /**
+     * By subject number, the mix's `relinks` when the subject's chain was last made stale by itself,
+     * so `pull` tells a head it remembers is stale without reading the head.
+     */
+    unlinked: Float64Array<ArrayBuffer>;
     /** Whether two crowds share a channel, so their rows must interleave in voice order. */
     overlap: boolean;
     /** The loci whose voices are on lanes, every member of each on one. */

package/dist/lanes.js

@@ -5,6 +5,7 @@ import { fold, foldDelta, foldInto, foldRun, gate, gather, unplain } from './gat
 import { meet, reach } from './meet.js';
 import { absent, Numbers } from './numbers.js';
 import { Owed } from './owed.js';
+import { Placed } from './placed.js';
 import { requalify, retouch } from './qualify.js';
 import { reading } from './reading.js';
 import { reportedRow, unplace } from './rows.js';
@@ -23,6 +24,13 @@ export class Lanes {
     /** The crowds of single-subject voices, one per list of channels, and which holds each voice. */
     crowds = [];
     crowdOf = new Map();
+    /** Which crowd voices' rows are placed on each subject. */
+    placed = new Placed();
+    /**
+     * By subject number, the mix's `relinks` when the subject's chain was last made stale by itself,
+     * so `pull` tells a head it remembers is stale without reading the head.
+     */
+    unlinked = new Float64Array(0);
     /** Whether two crowds share a channel, so their rows must interleave in voice order. */
     overlap = false;
     /** The loci whose voices are on lanes, every member of each on one. */
@@ -374,10 +382,15 @@ export class Lanes {
         this.live--;
         for (const lane of this.lanes)
             lane.remove(slot);
-        for (const c of this.crowds)
-            for (let p = 0; p < c.size; p++)
-                if (c.list[p] === slot)
-                    unplace(this, c, p);
+        const placed = this.placed;
+        for (let id = placed.any(slot); id !== 0; id = placed.any(slot)) {
+            const c = this.crowdOf.get(id);
+            const p = c?.rowOf.get(id);
+            if (c !== undefined && p !== undefined && c.list[p] === slot)
+                unplace(this, c, p);
+            else
+                placed.remove(slot, id);
+        }
         if (slot < this.cap)
             this.per[slot * 6 /* Per.SLOT */ + 0 /* Per.FILLED */] = this.fills;
         this.subjects[slot] = undefined;
@@ -390,6 +403,10 @@ export class Lanes {
         per.set(this.per);
         this.per = per;
         this.owed.grow(cap);
+        this.placed.grow(cap);
+        const unlinked = new Float64Array(cap);
+        unlinked.set(this.unlinked);
+        this.unlinked = unlinked;
         for (const ch of this.laned) {
             const values = new Float64Array(cap * ch.axes);
             values.set(ch.values);

package/dist/lean.d.ts

@@ -0,0 +1,15 @@
+import type { Engine, Kit, Mix, MixOptions } from './types.js';
+export * from './index.js';
+/**
+ * The stock engine without lanes: every voice folds subject by subject, to the same values, and a
+ * bundle that takes `mix` from here leaves the lanes' code out. `lanes: true` is refused.
+ *
+ * @category engine
+ */
+export declare const lean: Engine;
+/**
+ * Makes a mix over a kit, on the engine the options name or the lean one.
+ *
+ * @category mix
+ */
+export declare function mix<I, O, H = unknown>(kit: Kit<O>, opts?: MixOptions<H>): Mix<I, O, H>;

package/dist/lean.js

@@ -0,0 +1,23 @@
+import { Mixer } from './mixer.js';
+export * from './index.js';
+/**
+ * The stock engine without lanes: every voice folds subject by subject, to the same values, and a
+ * bundle that takes `mix` from here leaves the lanes' code out. `lanes: true` is refused.
+ *
+ * @category engine
+ */
+export const lean = {
+    name: 'lean',
+    runs: new Set(['fn', 'keys', 'motion']),
+    create(kit, opts) {
+        return new Mixer(kit, opts, null);
+    },
+};
+/**
+ * Makes a mix over a kit, on the engine the options name or the lean one.
+ *
+ * @category mix
+ */
+export function mix(kit, opts = {}) {
+    return (opts.engine ?? lean).create(kit, opts);
+}

package/dist/leavings.d.ts

@@ -17,8 +17,13 @@ export declare class Leavings<I> {
      * front: entries are in the order they left, and mix time does not run back along it.
      */
     expire(reach: number, out: ((e: Left<I>) => void) | null): void;
-    /** The record `subject` had at `cut` and left with after it, if it left after `cut`. */
+    /**
+     * The record `subject` had at `cut` and left with after it, if it left after `cut`. None where it
+     * left saying only that it had faded out, after `cut`, of a voice that had not met it.
+     */
     at(subject: I, cut: Cut): Subject<unknown> | undefined;
+    /** Each subject's first leaving after `cut`, which holds what it had at `cut`. */
+    after(cut: Cut): Left<I>[];
     /** Each time `subject` left, oldest first. */
     of(subject: I): readonly Left<I>[];
     /** Every entry, oldest first. */

package/dist/leavings.js

@@ -49,16 +49,30 @@ export class Leavings {
             this.head = 0;
         }
     }
-    /** The record `subject` had at `cut` and left with after it, if it left after `cut`. */
+    /**
+     * The record `subject` had at `cut` and left with after it, if it left after `cut`. None where it
+     * left saying only that it had faded out, after `cut`, of a voice that had not met it.
+     */
     at(subject, cut) {
         const own = this.by.get(subject);
         if (own === undefined)
             return undefined;
         for (const e of own)
             if (!within(cut, e.seq, e.sync))
-                return e.held;
+                return !e.held.reaches && e.parted !== null && e.parted.seq > cut.seq ? undefined : e.held;
         return undefined;
     }
+    /** Each subject's first leaving after `cut`, which holds what it had at `cut`. */
+    after(cut) {
+        const out = [];
+        const seen = new Set();
+        for (const e of this.all())
+            if (!within(cut, e.seq, e.sync) && !seen.has(e.subject)) {
+                seen.add(e.subject);
+                out.push(e);
+            }
+        return out;
+    }
     /** Each time `subject` left, oldest first. */
     of(subject) {
         return this.by.get(subject) ?? [];

package/dist/marks.d.ts

@@ -1,8 +1,12 @@
-import type { Listed } from './book.js';
+import { type Listed } from './book.js';
 import type { Mixer } from './mixer.js';
 import type { Transport } from './transport.js';
-import type { Mark } from './types.js';
+import type { MarkName } from './types.js';
 import { type Voice } from './voice.js';
+/** A voice's marks, in the order `marks` lists those at one time. */
+export declare const voiceMarks: readonly ["start", "in", "coast", "out", "end"];
+/** Refuses marks placed inside a voice under one of its own five names, or that it could never reach. */
+export declare function checkMarks(marks: Readonly<Record<string, number>>, duration: number): void;
 /** The host timestamp the mix clock reads mix time `t` at; Infinity where it never will. */
 export declare function hostOf<I, O>(mix: Mixer<I, O>, t: number): number;
 /** What the mix clock reads at host time `u`, by the clock in force then. */
@@ -12,4 +16,4 @@ export declare function listed<I, O>(mix: Mixer<I, O>, from: number, to: number)
 /** Every mark of every mix on a transport and every one announced on it, earliest first. */
 export declare function listedAll(transport: Transport, from: number, to: number): Listed[];
 /** When a voice reaches a mark, mix time, or undefined while nothing has fixed it. */
-export declare function markOf<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, mark: Mark): number | undefined;
+export declare function markOf<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, mark: MarkName): number | undefined;