@msb235/blits 0.7.1 → 0.8.1

package/dist/everyone.d.ts

@@ -0,0 +1,56 @@
+import type { Mixer } from './mixer.js';
+import type { Subject, Voice } from './voice.js';
+/**
+ * Whether a voice can keep one record for every subject, decided when it is cued. A record holds
+ * what a voice knows of one subject; where the voice is over every subject with no stagger, keeps
+ * no state, weighs every subject alike and writes only channels with a rest, a subject's record
+ * differs from another's only in the weight last given it and in what its patch was last called
+ * for it. The voice keeps those by subject number (`weights`, and for a patch that is called,
+ * `stamps` and `deltas`) and one record, `everyone`, that `open` points at a subject before a read
+ * and `shut` takes back after. About 32 B a subject where a record and its place in the voice's
+ * store took about 370 (bench/allocs.mjs on the `swap` row, 2026-10-09). It needs lanes for the
+ * numbers. What only shows later (a subject faded out of it alone, a fade at rest, state kept
+ * through `setting.keep`) turns it back with `unshare`.
+ */
+export declare function shares<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): boolean;
+/**
+ * A sharing voice's one record, made when a chain first asks; null where its origin is still
+ * ahead, which a record of its own per subject follows as the clock moves, so it shares no more.
+ */
+export declare function everyoneOf<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): Subject<unknown> | null;
+/** Whether a chain has asked a sharing voice about the subject numbered `slot`. */
+export declare function sighted<I, O>(voice: Voice<I, O>, slot: number): boolean;
+/** A chain asks a sharing voice about a subject: counted once, as a record of its own would be. */
+export declare function sight<I, O>(voice: Voice<I, O>, slot: number, cap: number): void;
+/** The weight a sharing voice last gave the subject numbered `slot`, 0 where it gave none. */
+export declare function weightAt<I, O>(voice: Voice<I, O>, slot: number): number;
+/** Keeps the weight a sharing voice gave the subject numbered `slot`. */
+export declare function weighAt<I, O>(voice: Voice<I, O>, slot: number, w: number, cap: number): void;
+/**
+ * Points a sharing voice's record at the subject numbered `slot` before a read: it holds when the
+ * voice's patch was last called for that subject and the delta it gave, as a record of the
+ * subject's own would, so the patch is called once a frame for a subject however its probes fall
+ * among other subjects'. A keys voice reads no subject, so its record needs no pointing.
+ */
+export declare function open<I, O>(voice: Voice<I, O>, rec: Subject<unknown>, slot: number): void;
+/** Takes back what a read left on a sharing voice's record for the subject numbered `slot`. */
+export declare function shut<I, O>(voice: Voice<I, O>, rec: Subject<unknown>, slot: number, cap: number): void;
+/** Makes stale what a sharing voice last read for the subject numbered `slot`, as `touch` asks. */
+export declare function restamp<I, O>(voice: Voice<I, O>, slot: number): void;
+/** A subject's number was let go of: the next subject to take it is one the voice has not seen. */
+export declare function unsight<I, O>(voice: Voice<I, O>, slot: number): void;
+/**
+ * Turns a sharing voice back to a record per subject, each made as it is next asked for from what
+ * the voice kept for the subject. With `kept`, a call just kept state on its one record, which is
+ * open on `keeper`, the subject called for: that subject takes the record as its own. A lane's
+ * positions take their own records now, since each held the one.
+ */
+export declare function unshare<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, kept?: boolean, keeper?: I): void;
+/**
+ * Counts what makes a mix's fold more than a walk of each chain: a locus, a voice sharing one
+ * record, a voice that stopped sharing this frame. Called wherever one of the three changes, so
+ * `foldWith` asks one number.
+ */
+export declare function detour<I, O>(mix: Mixer<I, O>): void;
+/** Gives a record just made for a subject a sharing voice had seen what the voice kept for it. */
+export declare function inherit<I, O>(voice: Voice<I, O>, held: Subject<unknown>, slot: number): void;

package/dist/everyone.js

@@ -0,0 +1,221 @@
+import { numericOf } from './channels.js';
+import { record } from './record.js';
+/**
+ * Whether a voice can keep one record for every subject, decided when it is cued. A record holds
+ * what a voice knows of one subject; where the voice is over every subject with no stagger, keeps
+ * no state, weighs every subject alike and writes only channels with a rest, a subject's record
+ * differs from another's only in the weight last given it and in what its patch was last called
+ * for it. The voice keeps those by subject number (`weights`, and for a patch that is called,
+ * `stamps` and `deltas`) and one record, `everyone`, that `open` points at a subject before a read
+ * and `shut` takes back after. About 32 B a subject where a record and its place in the voice's
+ * store took about 370 (bench/allocs.mjs on the `swap` row, 2026-10-09). It needs lanes for the
+ * numbers. What only shows later (a subject faded out of it alone, a fade at rest, state kept
+ * through `setting.keep`) turns it back with `unshare`.
+ */
+export function shares(mix, voice) {
+    const spec = voice.spec;
+    const patch = voice.patch;
+    return (mix.lanes !== null &&
+        !mix.projecting &&
+        mix.opts.history === undefined &&
+        voice.named === null &&
+        spec.target === undefined &&
+        spec.stagger === undefined &&
+        spec.locus === undefined &&
+        spec.anchor === undefined &&
+        spec.from !== 'current' &&
+        typeof spec.weight !== 'function' &&
+        patch.state === undefined &&
+        patch.step === undefined &&
+        voice.motion === undefined &&
+        voice.owner === null &&
+        voice.holding === null &&
+        voice.blend === null &&
+        !voice.freezesBefore &&
+        voice.slots.every((s) => {
+            const channel = mix.channels[s];
+            return channel.rest !== undefined && numericOf(channel)?.op !== 'last';
+        }));
+}
+/**
+ * A sharing voice's one record, made when a chain first asks; null where its origin is still
+ * ahead, which a record of its own per subject follows as the clock moves, so it shares no more.
+ */
+export function everyoneOf(mix, voice) {
+    if (voice.everyone !== null)
+        return voice.everyone;
+    const since = mix.sinceOf(voice, 0);
+    if (!(since <= mix.now)) {
+        unshare(mix, voice);
+        return null;
+    }
+    const all = record(voice, true, undefined);
+    all.since = since;
+    all.shown = mix.shownOf(voice, since);
+    all.stepped = since;
+    all.rebuilt = voice.rebuilds;
+    voice.everyone = all;
+    return all;
+}
+/** Whether a chain has asked a sharing voice about the subject numbered `slot`. */
+export function sighted(voice, slot) {
+    const bits = voice.sighted;
+    const word = slot >>> 5;
+    return (bits !== null &&
+        slot >= 0 &&
+        word < bits.length &&
+        (bits[word] & (1 << (slot & 31))) !== 0);
+}
+/** A chain asks a sharing voice about a subject: counted once, as a record of its own would be. */
+export function sight(voice, slot, cap) {
+    let bits = voice.sighted;
+    const word = slot >>> 5;
+    if (bits === null || word >= bits.length) {
+        const grown = new Uint32Array(Math.max(word + 1, (cap >>> 5) + 1));
+        if (bits !== null)
+            grown.set(bits);
+        voice.sighted = grown;
+        bits = grown;
+    }
+    const bit = 1 << (slot & 31);
+    if ((bits[word] & bit) !== 0)
+        return;
+    bits[word] = bits[word] | bit;
+    voice.seen++;
+}
+/** The weight a sharing voice last gave the subject numbered `slot`, 0 where it gave none. */
+export function weightAt(voice, slot) {
+    const weights = voice.weights;
+    return weights !== null && slot >= 0 && slot < weights.length ? weights[slot] : 0;
+}
+/** Keeps the weight a sharing voice gave the subject numbered `slot`. */
+export function weighAt(voice, slot, w, cap) {
+    let weights = voice.weights;
+    if (weights === null || slot >= weights.length) {
+        if (w === 0)
+            return;
+        const grown = new Float64Array(Math.max(slot + 1, cap));
+        if (weights !== null)
+            grown.set(weights);
+        voice.weights = grown;
+        weights = grown;
+    }
+    weights[slot] = w;
+}
+/**
+ * Points a sharing voice's record at the subject numbered `slot` before a read: it holds when the
+ * voice's patch was last called for that subject and the delta it gave, as a record of the
+ * subject's own would, so the patch is called once a frame for a subject however its probes fall
+ * among other subjects'. A keys voice reads no subject, so its record needs no pointing.
+ */
+export function open(voice, rec, slot) {
+    if (voice.built !== null)
+        return;
+    const stamps = voice.stamps;
+    const o = slot * 2 /* Stamp.SIZE */;
+    if (stamps === null || o >= stamps.length) {
+        rec.probed = Number.NaN;
+        rec.seeks = 0;
+        rec.delta = null;
+        return;
+    }
+    const at = stamps[o + 0 /* Stamp.PROBED */];
+    rec.probed = at;
+    rec.seeks = stamps[o + 1 /* Stamp.SEEKS */];
+    // A subject never read holds no delta, and its place in `deltas` may never have been written.
+    rec.delta = Number.isNaN(at)
+        ? null
+        : (voice.deltas[slot] ?? null);
+}
+/** Takes back what a read left on a sharing voice's record for the subject numbered `slot`. */
+export function shut(voice, rec, slot, cap) {
+    if (voice.built !== null)
+        return;
+    let stamps = voice.stamps;
+    const o = slot * 2 /* Stamp.SIZE */;
+    if (stamps === null || o >= stamps.length) {
+        if (Number.isNaN(rec.probed))
+            return;
+        const grown = new Float64Array(Math.max(slot + 1, cap) * 2 /* Stamp.SIZE */).fill(Number.NaN);
+        if (stamps !== null)
+            grown.set(stamps);
+        voice.stamps = grown;
+        stamps = grown;
+        voice.deltas ??= [];
+    }
+    stamps[o + 0 /* Stamp.PROBED */] = rec.probed;
+    stamps[o + 1 /* Stamp.SEEKS */] = rec.seeks;
+    voice.deltas[slot] = rec.delta;
+}
+/** Makes stale what a sharing voice last read for the subject numbered `slot`, as `touch` asks. */
+export function restamp(voice, slot) {
+    const stamps = voice.stamps;
+    const o = slot * 2 /* Stamp.SIZE */;
+    if (stamps !== null && slot >= 0 && o < stamps.length)
+        stamps[o + 1 /* Stamp.SEEKS */] = -1;
+    // A keys voice's one record holds its one delta.
+    if (voice.built !== null && voice.everyone !== null)
+        voice.everyone.seeks = -1;
+}
+/** A subject's number was let go of: the next subject to take it is one the voice has not seen. */
+export function unsight(voice, slot) {
+    const bits = voice.sighted;
+    const word = slot >>> 5;
+    if (bits !== null && word < bits.length)
+        bits[word] = bits[word] & ~(1 << (slot & 31));
+    const weights = voice.weights;
+    if (weights !== null && slot < weights.length)
+        weights[slot] = 0;
+    const stamps = voice.stamps;
+    const o = slot * 2 /* Stamp.SIZE */;
+    if (stamps !== null && o < stamps.length) {
+        stamps[o + 0 /* Stamp.PROBED */] = Number.NaN;
+        voice.deltas[slot] = null;
+    }
+}
+/**
+ * Turns a sharing voice back to a record per subject, each made as it is next asked for from what
+ * the voice kept for the subject. With `kept`, a call just kept state on its one record, which is
+ * open on `keeper`, the subject called for: that subject takes the record as its own. A lane's
+ * positions take their own records now, since each held the one.
+ */
+export function unshare(mix, voice, kept = false, keeper) {
+    if (!voice.sharing)
+        return;
+    voice.sharing = false;
+    const all = voice.everyone;
+    voice.everyone = null;
+    const at = mix.sharers.indexOf(voice);
+    if (at >= 0)
+        mix.sharers.splice(at, 1);
+    const slot = kept ? (mix.chains.get(keeper)?.slot ?? -1) : -1;
+    // A projection numbers no subject, so its copy's record is the keeper's without being asked.
+    if (all !== null && kept && (mix.projecting || sighted(voice, slot))) {
+        if (slot >= 0)
+            unsight(voice, slot);
+        voice.subjects.set(keeper, all);
+    }
+    else if (voice.holder === all)
+        voice.holder = null;
+    mix.lanes?.rerecord(voice.id, (subject, s) => mix.held(voice, subject, s));
+    // Every chain links it from here on.
+    if (voice.state !== 'done')
+        mix.steps.push(voice, ++mix.version);
+    mix.unshared = true;
+    detour(mix);
+    mix.lanes?.refill();
+}
+/**
+ * Counts what makes a mix's fold more than a walk of each chain: a locus, a voice sharing one
+ * record, a voice that stopped sharing this frame. Called wherever one of the three changes, so
+ * `foldWith` asks one number.
+ */
+export function detour(mix) {
+    mix.detours = mix.loci + mix.sharers.length + (mix.unshared ? 1 : 0);
+}
+/** Gives a record just made for a subject a sharing voice had seen what the voice kept for it. */
+export function inherit(voice, held, slot) {
+    held.weight = weightAt(voice, slot);
+    open(voice, held, slot);
+    unsight(voice, slot);
+}

package/dist/fade.d.ts

@@ -1,5 +1,5 @@
 import type { Mixer } from './mixer.js';
-import type { Voice } from './voice.js';
+import type { Subject, Voice } from './voice.js';
 /** Starts one subject's ramp out of a voice, or takes it out at once for a ramp of 0. */
 export declare function fadeSubject<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject: I, over?: number): void;
 /** What a subject's own ramp out of a voice leaves of its weight this frame, 0..1. */
@@ -11,6 +11,12 @@ export declare function parting<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, sub
 export declare function part<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject: I, at: number): void;
 /** Brings a subject faded out of a voice back, to be met afresh on its next probe. */
 export declare function unpart<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject: I): void;
+/**
+ * The record a read back finds a subject left a voice with: its own, or the voice's record for
+ * subjects it does not reach while faded out of it, since a probe on either path may have left a
+ * record of that or none.
+ */
+export declare function leftWith<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject: I): Subject<unknown> | undefined;
 export declare function beginFade<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, opts: {
     over?: number;
     at?: 'rest';
@@ -29,4 +35,5 @@ export declare function beginRise<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, op
  * exactly there; at or behind now, the fade began then and is partway.
  */
 export declare function fadeAt<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, at: number, over: number | undefined): void;
+/** Removes a voice, recording that it left at `at`, default now. */
 export declare function retire<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, at?: number): void;

package/dist/fade.js

@@ -1,6 +1,7 @@
 import { changed } from './chain.js';
 import { envelope } from './clock.js';
 import { schedule } from './due.js';
+import { unshare } from './everyone.js';
 import { leave, noted, releasing } from './history.js';
 import { orphan } from './owner.js';
 import { startOf } from './place.js';
@@ -11,6 +12,7 @@ import { unreach } from './unreached.js';
 export function fadeSubject(mix, voice, subject, over) {
     if (voice.state === 'done' || voice.parted?.has(subject) || voice.parts?.has(subject))
         return;
+    unshare(mix, voice);
     mix.stir();
     const ms = mix.reduced ? 0 : (over ?? voice.fade.out ?? 0);
     const at = Number.isNaN(mix.now) ? startOf(voice) : mix.now;
@@ -19,7 +21,7 @@ export function fadeSubject(mix, voice, subject, over) {
         return;
     }
     voice.parts ??= new Map();
-    voice.parts.set(subject, { at, over: ms });
+    voice.parts.set(subject, { at, over: ms, seq: mix.transport.seq });
     mix.parters.add(voice);
     schedule(mix, voice);
     mix.lanes?.refill();
@@ -40,7 +42,7 @@ export function part(mix, voice, subject, at) {
     if (voice.parts?.size === 0)
         voice.parts = null;
     voice.parted ??= new Map();
-    voice.parted.set(subject, at);
+    voice.parted.set(subject, { at, seq: mix.transport.seq });
     mix.parters.add(voice);
     forgetIn(mix, voice, subject);
     const motion = voice.motion;
@@ -49,8 +51,12 @@ export function part(mix, voice, subject, at) {
 }
 /** Brings a subject faded out of a voice back, to be met afresh on its next probe. */
 export function unpart(mix, voice, subject) {
-    if (voice.parted?.delete(subject) !== true)
+    if (voice.parted?.has(subject) !== true)
         return;
+    // `forgetIn` keeps the subject's own record for a read back; without one, keep the voice's.
+    if (voice.subjects.get(subject) === undefined)
+        leave(mix, voice, subject, leftWith(mix, voice, subject));
+    voice.parted.delete(subject);
     if (voice.parted.size === 0)
         voice.parted = null;
     forgetIn(mix, voice, subject);
@@ -58,6 +64,17 @@ export function unpart(mix, voice, subject) {
     if (slot >= 0)
         mix.lanes?.rejoin(slot);
 }
+/**
+ * The record a read back finds a subject left a voice with: its own, or the voice's record for
+ * subjects it does not reach while faded out of it, since a probe on either path may have left a
+ * record of that or none.
+ */
+export function leftWith(mix, voice, subject) {
+    const held = voice.subjects.get(subject);
+    if (held !== undefined || voice.parted?.has(subject) !== true)
+        return held;
+    return voice.unreached ?? mix.unreachedOf(voice, mix.now);
+}
 /** Drops a voice's record of a subject and relinks the subject's chain without it. */
 function forgetIn(mix, voice, subject) {
     const head = mix.chains.get(subject);
@@ -89,6 +106,12 @@ export function beginFade(mix, voice, opts, at) {
     // A voice is linked into its subjects' chains once it plays, and a fading one plays.
     if (voice.state === 'pending')
         changed(mix, voice);
+    // A fade at rest marks each subject's record as it comes to rest, at its next read: one already
+    // read this frame is read again, as after `touch`.
+    if (opts.at === 'rest') {
+        unshare(mix, voice);
+        voice.seeks++;
+    }
     voice.state = 'fading';
     voice.out = {
         from: 1,
@@ -151,11 +174,11 @@ export function fadeAt(mix, voice, at, over) {
     voice.outSet = true;
     noted(mix, voice);
 }
-/** Removes a voice, recording that it left at `at`, default now. */
 /** Whether a motion patch still asks this voice of this mix for its time. */
 function asks(mix, motion, voice) {
     return motion.owner === mix.owner && motion.ownerId === voice.id;
 }
+/** Removes a voice, recording that it left at `at`, default now. */
 export function retire(mix, voice, at) {
     if (voice.holding === null)
         mix.lanes?.touch(voice);
@@ -168,7 +191,10 @@ export function retire(mix, voice, at) {
     voice.keepOn = null;
     mix.retired.push(voice);
     voice.doneAt = at ?? (Number.isNaN(mix.now) ? Number.NEGATIVE_INFINITY : mix.now);
-    voice.play(false, voice.doneAt);
+    voice.doneSeq = mix.transport.seq;
+    // The frames up to this one showed it, though its fade ended before: it leaves the list now.
+    mix.transport.settle();
+    voice.play(false, voice.doneAt, voice.doneSeq);
     voice.resolve();
     // An owner takes what it holds with it, and leaves with its last child.
     if (voice.holding !== null)
@@ -180,7 +206,9 @@ export function retire(mix, voice, at) {
         const owner = orphan(voice);
         if (owner !== null && !lingers(owner, voice.doneAt))
             retire(mix, owner, voice.doneAt);
-        else if (span.fitting !== null && span.state !== 'done')
+        // A child the fit skipped had no time in it, so the rest of the fit stands: fitting again
+        // between siblings skipped together would play the ones still to leave.
+        else if (span.fitting !== null && span.state !== 'done' && !voice.skipped)
             refit(mix, span);
     }
 }

package/dist/fill.d.ts

@@ -8,12 +8,13 @@ export declare function fillAll<I, O>(lanes: Lanes<I, O>, now: number, version:
 export declare function rest<I, O>(lanes: Lanes<I, O>, lane: Paced): void;
 export declare function wake<I, O>(lanes: Lanes<I, O>, lane: Paced): void;
 /**
- * A voice with a signal weight: its weight for the subject at `slot` under the voice's fade `fade`,
- * through the general path's own arithmetic; NaN where that path has not made the voice's first
- * call for the subject, which it then makes this frame, so a signal that keeps state is first
- * called where the general path would call it.
+ * A voice with a signal weight: its weight for the subject at `slot`, left in `Arg.WEIGHT`, at the
+ * voice time, pass and fade in `Arg.ELAPSED`, `Arg.PASS` and `Arg.FADE`, through the general path's
+ * own arithmetic. False where that path has not made the voice's first call for the subject, which
+ * it then makes this frame, so a signal that keeps state is first called where the general path
+ * would call it.
  */
-export declare function signalled<I, O>(this: Lanes<I, O>, voice: Voice<I, O>, slot: number, rec: Subject<unknown>, elapsed: number, pass: number, fade: number): number;
+export declare function signalled<I, O>(this: Lanes<I, O>, voice: Voice<I, O>, slot: number, rec: Subject<unknown>): boolean;
 /** What a subject's own ramp out of a voice leaves of its weight: 1 with none. */
 export declare function parting<I, O>(this: Lanes<I, O>, voice: Voice<I, O>, slot: number): number;
 export declare function subjectAt<I, O>(this: Lanes<I, O>, slot: number): I | typeof absent;
@@ -21,22 +22,30 @@ export declare function subjectAt<I, O>(this: Lanes<I, O>, slot: number): I | ty
 export declare function reset<I, O>(this: Lanes<I, O>, lane: Lane<I, O>): void;
 /** One voice's contribution to every subject it plays on. */
 export declare function run<I, O>(this: Lanes<I, O>, lane: Lane<I, O>): void;
+/**
+ * `run`'s loop for a voice keeping one record for every subject: the record is pointed at each
+ * subject before its call and taken back after, so `one` and `call` read it as a record of the
+ * subject's own. A loop of its own, which leaves theirs as they were for every other voice.
+ */
+export declare function runEveryone<I, O>(this: Lanes<I, O>, lane: Lane<I, O>): void;
 /**
  * One subject's contribution from a lane's voice. True where the voice gave the subject a delta,
  * as the general path's `contribution` does where it returns one, which is what makes a voice in a
  * locus one of its members for the subject.
  */
-export declare function one<I, O>(this: Lanes<I, O>, lane: Lane<I, O>, p: number, slot: number, elapsedNow: number, duration: number, passes: number): boolean;
+export declare function one<I, O>(this: Lanes<I, O>, lane: Lane<I, O>, p: number, slot: number): boolean;
 /**
- * A keys voice's stops at `phase` folded straight into a subject's values, without a delta: what
- * `readKeyed` then `foldDelta` give, through the same segment search and the stock channels' own
- * lerp, which is all a laned keys voice can use.
+ * A keys voice's stops at `Arg.PHASE` folded straight into a subject's values at `Arg.WEIGHT`,
+ * without a delta: what `readKeyed` then `foldDelta` give, through the same segment search and the
+ * stock channels' own lerp, which is all a laned keys voice can use.
  */
-export declare function foldKeys<I, O>(this: Lanes<I, O>, voice: Voice<I, O>, chans: readonly Laned[], phase: number, slot: number, w: number): void;
+export declare function foldKeys<I, O>(this: Lanes<I, O>, voice: Voice<I, O>, chans: readonly Laned[], slot: number): void;
 /** Reads a keys voice's stops at `phase` into `delta`, interpolating into the reader's `scratch`. */
 export declare function readKeyed<I, O>(this: Lanes<I, O>, voice: Voice<I, O>, phase: number, delta: Record<string, unknown>, scratch: Scratch): void;
 /**
- * Calls a stateless fn voice's patch for a subject its general path has met, and folds the delta;
- * false for a subject the host has let go of.
+ * Calls a stateless fn voice's patch for a subject its general path has met, and folds the delta,
+ * at the voice time, phase, pass, delay and weight in `Arg`; false where it gave no delta, for a
+ * subject the host has let go of or a weight the voice is silent at. As arguments those cost nothing where V8 inlines the call and 31 bytes a call where it
+ * does not, which differs by V8 version: Node 26.1 does not (2026-10-09).
  */
-export declare function call<I, O>(this: Lanes<I, O>, voice: Voice<I, O>, chans: readonly Laned[], rec: Subject<unknown>, slot: number, elapsed: number, phase: number, pass: number, delay: number, w: number): boolean;
+export declare function call<I, O>(this: Lanes<I, O>, voice: Voice<I, O>, chans: readonly Laned[], rec: Subject<unknown>, slot: number): boolean;