@msb235/blits 0.7.0 → 0.8.0

package/dist/signals.js

@@ -1,5 +1,16 @@
+import { reading } from './reading.js';
+/** Input signals whose every change bumps `reading.inputs`: `input`'s, and those built only on them. */
+const told = new WeakSet();
+/** Whether a change to an input signal reaches `reading.inputs`, so a lane fill can see it. */
+export const heard = (signal) => told.has(signal);
 const inputOf = (signals) => signals.some((s) => s.input);
-const marked = (read, input) => (input ? Object.assign(read, { input: true }) : read);
+const marked = (read, of) => {
+    if (!inputOf(of))
+        return read;
+    if (of.every((s) => !s.input || told.has(s)))
+        told.add(read);
+    return Object.assign(read, { input: true });
+};
 /**
  * The loudest of several signals.
  *
@@ -14,19 +25,46 @@ export function peak(...signals) {
                 out = v;
         }
         return out;
-    }, inputOf(signals));
+    }, signals);
 }
+const touch = () => {
+    reading.inputs++;
+};
 /**
- * A signal the host writes. klieg's `level`.
+ * Marks `read` as a signal driven from outside the clock, which a host's own signal has to be for
+ * `assess` and a history's `inputs` to treat it as one. Two uses:
+ *
+ * `input(read)` is an input of the host's own: a pointer, a volume, a value in a store. The host
+ * calls `touch()` after each change to what `read` reads, and a voice weighted by the signal, or by
+ * `peak`, `slew`, `lag` or `gate` over it, keeps its lane. A change nobody reports shows once the
+ * mix's clock next moves.
+ *
+ * `input(read, of)` is a signal built on others, as a wrapper that clamps one is: `of` lists every
+ * signal `read` calls, and the result is an input where any of them is, and reports its changes
+ * where they all do.
+ *
+ * @category signal
+ */
+export function input(read, of) {
+    if (of !== undefined)
+        return Object.assign(marked(read, of), { touch });
+    told.add(read);
+    return Object.assign(read, { input: true, touch });
+}
+/**
+ * A signal the host writes: `input` over one number, with `set` reporting each change. klieg's
+ * `level`.
  *
  * @category signal
  */
 export function level(initial = 0) {
     let value = initial;
-    return Object.assign(() => value, {
-        input: true,
+    return Object.assign(input(() => value), {
         set(v) {
+            if (Object.is(v, value))
+                return;
             value = v;
+            touch();
         },
     });
 }
@@ -38,7 +76,7 @@ const firstSight = (target, from, setting) => from === undefined || !Number.isFi
     ? { value: target, seen: Number.NaN }
     : { value: from, seen: setting.timestamp };
 /**
- * The package's one decay primitive: follows its input at a rate limit, no faster than `riseMs` per
+ * The package's linear decay primitive: follows its input at a rate limit, no faster than `riseMs` per
  * unit climbing or `fallMs` draining. The mix keeps its state per voice and subject, so two voices
  * handed the same slew each follow on their own. A subject starts on its input, or at `from`
  * unless `dt` is infinite.
@@ -56,7 +94,8 @@ export function slew(of, { riseMs = 0, fallMs = 0, from }) {
             const gap = target - held.value;
             const ms = gap > 0 ? riseMs : fallMs;
             if (ms > 0) {
-                const step = (setting.timestamp - held.seen) / ms;
+                // No longer than `dt`, which `maxDt` caps, as every step is.
+                const step = Math.min(setting.timestamp - held.seen, setting.dt) / ms;
                 next = gap > 0 ? Math.min(target, held.value + step) : Math.max(target, held.value - step);
             }
         }
@@ -64,7 +103,7 @@ export function slew(of, { riseMs = 0, fallMs = 0, from }) {
         held.seen = setting.timestamp;
         return next;
     };
-    return marked(read, inputOf([of]));
+    return marked(read, [of]);
 }
 /**
  * The exponential counterpart to `slew`: closes the same fraction of the distance to its input in
@@ -86,7 +125,7 @@ export function lag(of, { riseMs = 0, fallMs = 0, floor = 1e-6, from, }) {
         if (!Number.isNaN(held.seen) && Number.isFinite(setting.dt)) {
             const ms = target > held.value ? riseMs : fallMs;
             if (ms > 0) {
-                const gap = setting.timestamp - held.seen;
+                const gap = Math.min(setting.timestamp - held.seen, setting.dt);
                 next = held.value + (target - held.value) * (1 - Math.exp(-gap / ms));
                 if (Math.abs(target - next) <= floor)
                     next = target;
@@ -96,7 +135,7 @@ export function lag(of, { riseMs = 0, fallMs = 0, floor = 1e-6, from, }) {
         held.seen = setting.timestamp;
         return next;
     };
-    return marked(read, inputOf([of]));
+    return marked(read, [of]);
 }
 /**
  * The other half of the pair: a band, not an edge. It drops at `off`, passes at `on`, and between
@@ -116,5 +155,5 @@ export function gate(of, band) {
         }
         return held.on ? 1 : 0;
     };
-    return marked(read, inputOf([of]));
+    return marked(read, [of]);
 }

package/dist/spans.js

@@ -1,8 +1,10 @@
 import { elapsedWith, retime } from './clock.js';
 import { retire } from './fade.js';
 import { defaultFit, layout, settle } from './fit.js';
+import { reorigin } from './held.js';
 import { noted } from './history.js';
 import { nextFrame } from './move.js';
+import { leave } from './origin.js';
 import { ownerReading } from './owner.js';
 /** What a span keeps beside its owner: its claim, its fit, and how the last fit came out. */
 export class Fitting {
@@ -89,6 +91,7 @@ export function refit(mix, span) {
     kids.forEach((c, i) => {
         const rate = (c.spec.rate ?? 1) * plan.rate[i];
         const skipped = plan.skip[i] && c.holding === null;
+        c.skipped = skipped;
         let moved = false;
         if (c.state === 'pending') {
             const start = local + at[i];
@@ -99,23 +102,27 @@ export function refit(mix, span) {
                 c.anchorElapsed = elapsed;
                 c.rate = rate;
                 c.ramp = null;
+                c.clocks = null;
                 moved = true;
             }
         }
         else {
             if (skipped) {
+                leave(c, local);
                 c.rebase(local);
                 c.anchorElapsed = c.span;
                 c.seeks++;
                 moved = true;
             }
             if (c.rate !== rate || c.ramp !== null) {
+                leave(c, local);
                 retime(c, local, rate, 0);
                 moved = true;
             }
         }
         if (moved) {
             mix.frame = nextFrame();
+            reorigin(mix, c, mix.now);
             noted(mix, c);
         }
     });

package/dist/stack.d.ts

@@ -0,0 +1,11 @@
+import type { Kit } from './types.js';
+/**
+ * Folds deltas into one pose by a kit's arithmetic, in order, with no mix and no clock: what a mix
+ * gives for voices contributing these deltas at these weights. Each channel starts at its rest, a
+ * weight (default 1, held to 0..1) fades a delta toward rest, and the pose is clamped to each
+ * channel's bounds. A channel with no rest takes the last delta whose weight is 0.6 or more, where
+ * a mix's default band first switches one on, and stays undefined where none is.
+ *
+ * @category channel
+ */
+export declare function fold<O>(kit: Kit<O>, deltas: readonly Partial<O>[], weights?: readonly number[]): O;

package/dist/stack.js

@@ -0,0 +1,47 @@
+import { copy } from './clone.js';
+import { bound, merged } from './fold.js';
+/** The weight a mix's default band first switches a rest-less channel on at. */
+const ON = 0.6;
+/**
+ * Folds deltas into one pose by a kit's arithmetic, in order, with no mix and no clock: what a mix
+ * gives for voices contributing these deltas at these weights. Each channel starts at its rest, a
+ * weight (default 1, held to 0..1) fades a delta toward rest, and the pose is clamped to each
+ * channel's bounds. A channel with no rest takes the last delta whose weight is 0.6 or more, where
+ * a mix's default band first switches one on, and stays undefined where none is.
+ *
+ * @category channel
+ */
+export function fold(kit, deltas, weights) {
+    const pose = {};
+    const names = Object.keys(kit);
+    for (const key of names) {
+        const channel = kit[key];
+        const rest = channel.rest;
+        pose[key] = rest === undefined ? undefined : channel.copy ? channel.copy(rest) : copy(rest);
+    }
+    for (let i = 0; i < deltas.length; i++) {
+        const given = weights?.[i] ?? 1;
+        const w = given > 1 ? 1 : given;
+        if (!(w > 0))
+            continue;
+        const delta = deltas[i];
+        for (const key of names) {
+            const value = delta[key];
+            if (value === undefined)
+                continue;
+            const channel = kit[key];
+            if (channel.rest !== undefined && channel.scale)
+                pose[key] = channel.fold
+                    ? channel.fold(pose[key], value, w)
+                    : merged(channel, pose[key], channel.scale(value, w));
+            else if (w >= ON)
+                pose[key] = pose[key] === undefined ? copy(value) : merged(channel, pose[key], value);
+        }
+    }
+    for (const key of names) {
+        const channel = kit[key];
+        if (channel.bounds)
+            pose[key] = bound(channel, pose[key]);
+    }
+    return pose;
+}

package/dist/standing.d.ts

@@ -0,0 +1,10 @@
+import type { Mixer } from './mixer.js';
+import type { Cut, Transport } from './transport.js';
+/**
+ * Throws unless a read back to mix time `t` is exact with no history: every voice plays as it was
+ * cued and reads the same whenever it is asked, and no mix on the transport has changed since `t`.
+ * A mix keeps only how it stands now, which is how it has stood since its last change.
+ */
+export declare function stands(transport: Transport, t: number): void;
+/** A mix's copy for a read back to `t` with no history: its voices as they stand, each at `t`. */
+export declare function copyStanding<I, O>(mix: Mixer<I, O>, c: Mixer<I, O>, t: number, cut: Cut): void;

package/dist/standing.js

@@ -0,0 +1,79 @@
+import { ownBlends } from './blend.js';
+import { relink } from './owner.js';
+import { pin } from './place.js';
+import { mirror, recall, stateAt } from './project.js';
+import { recount } from './roster.js';
+/**
+ * Why a voice cannot be read at an earlier time from how it stands now, or undefined where it can:
+ * what it shows depends on more than its clock as cued, so the frames it has played decided it.
+ */
+function unfit(mix, voice) {
+    const patch = voice.patch;
+    const spec = voice.spec;
+    if (patch.state !== undefined || patch.step !== undefined)
+        return 'its patch keeps state';
+    if (voice.motion !== undefined)
+        return 'it plays a motion';
+    if (voice.keeping)
+        return 'its patch or its weight keeps state';
+    if (spec.from === 'current')
+        return 'it starts from the pose its subjects had';
+    if (voice.written)
+        return 'its handle has been written to';
+    if (spec.anchor !== undefined)
+        return 'an anchor places it';
+    if (voice.holding !== null)
+        return 'it is an owner';
+    if (voice.owner !== null)
+        return 'it plays under an owner';
+    // A rest-less channel switches on across a band, by the weights its voice has passed through.
+    const steady = typeof spec.weight !== 'function' &&
+        spec.locus === undefined &&
+        !((voice.fade.in ?? 0) > 0) &&
+        !((voice.fade.out ?? 0) > 0);
+    if (!steady && voice.slots.some((s) => mix.channels[s]?.rest === undefined))
+        return 'it writes a channel with no rest at a weight that moves';
+    return undefined;
+}
+/**
+ * Throws unless a read back to mix time `t` is exact with no history: every voice plays as it was
+ * cued and reads the same whenever it is asked, and no mix on the transport has changed since `t`.
+ * A mix keeps only how it stands now, which is how it has stood since its last change.
+ */
+export function stands(transport, t) {
+    const need = `blits: reading back to ${t} needs a mix made with history`;
+    if (transport.pace !== null)
+        throw new Error(`${need}: the mix's rate has been set`);
+    if (t < transport.settled)
+        throw new Error(`${need}: a mix changed or a voice left at ${transport.settled}, and without history a mix keeps only how it stands now`);
+    for (const mix of transport.members)
+        for (const voice of mix.cued) {
+            if (voice.state === 'done')
+                continue;
+            const why = unfit(mix, voice);
+            if (why !== undefined)
+                throw new Error(`${need}: voice ${voice.id} is cued, and ${why}`);
+        }
+}
+/** A mix's copy for a read back to `t` with no history: its voices as they stand, each at `t`. */
+export function copyStanding(mix, c, t, cut) {
+    mirror(mix, c);
+    c.backward = true;
+    c.cued = mix.cued
+        .filter((v) => v.state !== 'done')
+        .map((v) => {
+        const copy = v.copy((subject) => recall(mix, v, subject, t, cut));
+        // A fade its own end began after `t` had not begun then.
+        if (copy.out !== null && copy.out.at > t)
+            copy.out = null;
+        const at = mix.pins?.get(v);
+        if (at !== undefined)
+            pin(c, copy, at);
+        return copy;
+    });
+    ownBlends(c.cued);
+    if (mix.owners !== null)
+        relink(c.cued);
+    stateAt(c, t);
+    recount(c);
+}

package/dist/store.d.ts

@@ -1,9 +1,9 @@
 /**
  * Per-subject storage keyed by identity. Objects go in a WeakMap and are forgotten when the host
  * drops them; anything else — a string id, the unit subject of a mix with no subject dimension —
- * goes in a Map that only `drop` and `clear` empty, which is why a host keying by value should
- * call `drop`. Each map is made when first written, since a mix holds a store per voice and patch;
- * until then it is a shared empty one, so the field always holds a map.
+ * goes in a Map that only `delete` and `clear` empty, which is why a host keying by value should
+ * call `Mix.drop`. Each map is made when first written, since a mix holds a store per voice and
+ * patch; until then it is a shared empty one, so the field always holds a map.
  */
 export declare class Store<K, V> {
     private weak;

package/dist/store.js

@@ -4,9 +4,9 @@ const noStrong = new Map();
 /**
  * Per-subject storage keyed by identity. Objects go in a WeakMap and are forgotten when the host
  * drops them; anything else — a string id, the unit subject of a mix with no subject dimension —
- * goes in a Map that only `drop` and `clear` empty, which is why a host keying by value should
- * call `drop`. Each map is made when first written, since a mix holds a store per voice and patch;
- * until then it is a shared empty one, so the field always holds a map.
+ * goes in a Map that only `delete` and `clear` empty, which is why a host keying by value should
+ * call `Mix.drop`. Each map is made when first written, since a mix holds a store per voice and
+ * patch; until then it is a shared empty one, so the field always holds a map.
  */
 export class Store {
     weak = noWeak;

package/dist/strays.js

@@ -42,6 +42,9 @@ export function motionOwner(mix) {
         now() {
             return mix.deref()?.now ?? Number.NaN;
         },
+        seq() {
+            return mix.deref()?.transport.seq ?? Number.NaN;
+        },
         changed(id, motion, subject, change) {
             const m = mix.deref();
             if (m === undefined)

package/dist/tape.d.ts

@@ -1,7 +1,10 @@
 import type { Pace } from './pace.js';
 import type { Transport } from './transport.js';
 import type { Tape } from './types.js';
-/** The tape `history.tape` makes for a transport, stamping each call with the mix time it was made at. */
+/**
+ * The tape `history.tape` makes for a transport, stamping each call with the host time it was made
+ * at: rate 0 holds mix time still across frames, and host time tells them apart.
+ */
 export declare function tapeOf(transport: Transport): Tape | undefined;
 /** Records a host call, which `again` makes once more when the mix plays past it after a seek. */
 export declare function record(on: {
@@ -14,8 +17,8 @@ export declare function hostAt(clock: {
     readonly pace: Pace | null;
 }, t: number): number;
 /**
- * Makes the recorded calls due by mix time `to()` again, each with every mix on the transport
- * moved to the time it was made at, as the host made it then. `to` is asked again after every
- * call, since a call may change the rate and so where a host time lands.
+ * Makes the recorded calls `due` by the host time each was made at again, each host time's in a
+ * frame of its own with every mix on the transport moved to where it stood then, as the host made
+ * them. Answers the host time of the last frame it played, NaN for none.
  */
-export declare function replay(transport: Transport, to: () => number): void;
+export declare function replay(transport: Transport, due: (u: number) => boolean): number;

package/dist/tape.js

@@ -1,13 +1,16 @@
 import { move } from './move.js';
 /** What a recorded call's `invert` gives: a mix goes back by restoring, never by undoing a call. */
 const undone = { apply() { }, invert: () => undone };
-/** The tape `history.tape` makes for a transport, stamping each call with the mix time it was made at. */
+/**
+ * The tape `history.tape` makes for a transport, stamping each call with the host time it was made
+ * at: rate 0 holds mix time still across frames, and host time tells them apart.
+ */
 export function tapeOf(transport) {
     const make = transport.history?.tape;
     if (make === undefined)
         return undefined;
     return make(transport, {
-        now: () => (Number.isNaN(transport.now) ? Number.NEGATIVE_INFINITY : transport.now),
+        now: () => (Number.isNaN(transport.u) ? Number.NEGATIVE_INFINITY : transport.u),
         branching: true,
         coalesceWindowMs: 0,
     });
@@ -31,24 +34,29 @@ export function hostAt(clock, t) {
     return clock.pace === null ? t : clock.pace.timeOf(t);
 }
 /**
- * Makes the recorded calls due by mix time `to()` again, each with every mix on the transport
- * moved to the time it was made at, as the host made it then. `to` is asked again after every
- * call, since a call may change the rate and so where a host time lands.
+ * Makes the recorded calls `due` by the host time each was made at again, each host time's in a
+ * frame of its own with every mix on the transport moved to where it stood then, as the host made
+ * them. Answers the host time of the last frame it played, NaN for none.
  */
-export function replay(transport, to) {
+export function replay(transport, due) {
     const tape = transport.tape;
     if (tape === undefined)
-        return;
+        return Number.NaN;
     const u = transport.u;
+    let last = Number.NaN;
     try {
         for (;;) {
             const at = tape.timestampAt(tape.undoDepth());
-            if (at === undefined || !(at <= to()))
-                return;
-            if (at > transport.now) {
-                transport.u = hostAt(transport, at);
-                for (const m of transport.members)
-                    move(m, at);
+            if (at === undefined || !due(at))
+                return last;
+            if (at !== last) {
+                last = at;
+                transport.u = at;
+                const now = transport.pace === null ? at : transport.pace.reading(at);
+                if (now > transport.now)
+                    for (const m of transport.members)
+                        move(m, now);
+                transport.tick(transport.now);
             }
             transport.replaying = true;
             try {

package/dist/testing.d.ts

@@ -0,0 +1,35 @@
+import type { Kit, Patch, Setting } from './types.js';
+/**
+ * A `Setting` for calling a patch's `at` or `step` outside a mix: `keep` holds per owner as a mix's
+ * does, and `send` keeps what is sent in `sent`. Any field may be given; the rest read a voice at
+ * full weight at the start of its first pass, 1/60 s after the last frame.
+ *
+ * @category patch
+ */
+export declare function setting<S = void, H = unknown>(fields?: Partial<Omit<Setting<S, H>, 'keep' | 'send'>>): Setting<S, H> & {
+    sent: unknown[];
+};
+/** @category patch */
+export interface CheckOptions<I, O, H = unknown> {
+    /** The subject to read the patch for. */
+    subject: I;
+    /** A kit the patch should play in: each channel it writes, of the kind it was written for. */
+    kit?: Kit<O>;
+    /** What the patch's `reads` find on `setting.host`. */
+    host?: H;
+    /** The interval `step` is given, as under `stepMs`. Default 1000 / 60. */
+    stepMs?: number;
+    /** How many steps to run before reading state. Default 30. */
+    steps?: number;
+}
+/**
+ * What a patch does that a mix cannot rely on, one sentence per problem; empty when none. It reads
+ * `at` across its phase, twice from fresh state, and checks that it writes only its `writes`, gives
+ * the same delta each time, and leaves the subject alone; that `state` makes a new value per call,
+ * that `step` lands the same from the same start, and that `clone` and `pack`/`unpack` give back an
+ * equal state; that every field it `reads` is on `host`; and, given a kit, that `cue` would
+ * take it. Meant for a library's own tests: `expect(checkPatch(glow, { subject })).toEqual([])`.
+ *
+ * @category patch
+ */
+export declare function checkPatch<I, O, S = void, H = unknown>(patch: Patch<I, O, S, H>, opts: CheckOptions<I, O, H>): string[];

package/dist/testing.js

@@ -0,0 +1,116 @@
+import { clone } from './clone.js';
+import { fitsKit } from './cue.js';
+import { same } from './history.js';
+/**
+ * A `Setting` for calling a patch's `at` or `step` outside a mix: `keep` holds per owner as a mix's
+ * does, and `send` keeps what is sent in `sent`. Any field may be given; the rest read a voice at
+ * full weight at the start of its first pass, 1/60 s after the last frame.
+ *
+ * @category patch
+ */
+export function setting(fields = {}) {
+    const kept = new Map();
+    const sent = [];
+    return {
+        timestamp: 0,
+        dt: 1000 / 60,
+        elapsed: 0,
+        pass: 0,
+        weight: 1,
+        state: undefined,
+        host: undefined,
+        ...fields,
+        keep(owner, init) {
+            if (!kept.has(owner))
+                kept.set(owner, init());
+            return kept.get(owner);
+        },
+        send(event) {
+            sent.push(event);
+        },
+        sent,
+    };
+}
+/**
+ * What a patch does that a mix cannot rely on, one sentence per problem; empty when none. It reads
+ * `at` across its phase, twice from fresh state, and checks that it writes only its `writes`, gives
+ * the same delta each time, and leaves the subject alone; that `state` makes a new value per call,
+ * that `step` lands the same from the same start, and that `clone` and `pack`/`unpack` give back an
+ * equal state; that every field it `reads` is on `host`; and, given a kit, that `cue` would
+ * take it. Meant for a library's own tests: `expect(checkPatch(glow, { subject })).toEqual([])`.
+ *
+ * @category patch
+ */
+export function checkPatch(patch, opts) {
+    const problems = [];
+    const { subject, host } = opts;
+    const tick = opts.stepMs ?? 1000 / 60;
+    const steps = opts.steps ?? 30;
+    const writes = new Set(patch.writes);
+    if (opts.kit !== undefined)
+        try {
+            fitsKit(patch, opts.kit);
+        }
+        catch (e) {
+            problems.push(e.message);
+        }
+    for (const field of patch.reads ?? [])
+        if (typeof host !== 'object' || host === null || !(field in host))
+            problems.push(`reads host.${field}, which the host given lacks`);
+    const fresh = () => (patch.state ? patch.state(subject) : undefined);
+    if (patch.state) {
+        const a = fresh();
+        if (typeof a === 'object' && a !== null && a === fresh())
+            problems.push('state() hands every subject the same object, so they share state');
+    }
+    /** The state after `steps` steps from fresh. */
+    const stepped = () => {
+        const state = fresh();
+        if (patch.step)
+            for (let n = 1; n <= steps; n++)
+                patch.step(state, tick, subject, setting({ state, host, dt: tick, timestamp: n * tick }));
+        return state;
+    };
+    const before = clone(subject);
+    const phases = [0, 0.25, 0.5, 0.75, 1];
+    const read = (state) => phases.map((phase) => clone(patch.at(phase, subject, setting({ state, host, elapsed: phase * patch.duration }))));
+    let first = [];
+    try {
+        first = read(stepped());
+        const second = read(stepped());
+        const stray = new Set();
+        for (const delta of first)
+            for (const key of Object.keys(delta))
+                if (!writes.has(key))
+                    stray.add(key);
+        for (const key of stray)
+            problems.push(`at() writes ${key}, which is not in writes`);
+        if (!same(first, second))
+            problems.push('at() gives a different delta for the same phase, subject and state');
+    }
+    catch (e) {
+        problems.push(`at() or step() threw: ${e.message}`);
+    }
+    if (!same(subject, before))
+        problems.push('at() or step() changed the subject');
+    if (patch.step || patch.state) {
+        const state = stepped();
+        if (!same(state, stepped()))
+            problems.push('step() lands somewhere else from the same start and steps');
+        if (patch.clone) {
+            const c = patch.clone(state);
+            if (!same(c, state))
+                problems.push('clone() gives a state unequal to the one it was given');
+            else if (typeof state === 'object' && state !== null && c === state)
+                problems.push('clone() hands back the state itself, not a copy');
+        }
+        if ((patch.pack === undefined) !== (patch.unpack === undefined))
+            problems.push('pack and unpack come as a pair');
+        else if (patch.pack && patch.unpack) {
+            const back = patch.unpack(JSON.parse(JSON.stringify(patch.pack(state))));
+            if (!same(back, state))
+                problems.push('unpack(pack(state)) through JSON gives another state');
+        }
+    }
+    return problems;
+}

package/dist/touch.d.ts

@@ -0,0 +1,6 @@
+import type { Mixer } from './mixer.js';
+/**
+ * What `Mix.touch` does: makes stale every delta read this frame, for one subject or for all, so
+ * the next probe calls each patch again, on either path.
+ */
+export declare function touch<I, O>(mix: Mixer<I, O>, subject?: I): void;

package/dist/touch.js

@@ -0,0 +1,28 @@
+import { restamp } from './everyone.js';
+import { nextFrame } from './move.js';
+/**
+ * What `Mix.touch` does: makes stale every delta read this frame, for one subject or for all, so
+ * the next probe calls each patch again, on either path.
+ */
+export function touch(mix, subject) {
+    mix.frame = nextFrame();
+    if (subject === undefined) {
+        // A motion patch reads nothing from outside the mix, and an owner has no delta.
+        for (const voice of mix.cued)
+            if (voice.motion === undefined && voice.holding === null) {
+                voice.seeks++;
+                voice.touches++;
+            }
+    }
+    else {
+        // No voice's `seeks` is below 0, so no record stamped with it reads as current.
+        let held = mix.chains.get(subject) ?? null;
+        for (; held !== null; held = held.next)
+            held.seeks = -1;
+        const slot = mix.chains.get(subject)?.slot ?? -1;
+        for (const voice of mix.sharers)
+            restamp(voice, slot);
+    }
+    mix.lanes?.refill();
+    mix.stir();
+}