@msb235/blits 0.6.0 → 0.7.1

package/dist/fade.d.ts

@@ -16,4 +16,17 @@ export declare function beginFade<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, op
     at?: 'rest';
     deadline?: number;
 }, at?: number): void;
+/**
+ * Turns a fading voice around: it climbs back from where its fade out had got to, up the same
+ * curve, at the whole curve per `over` ms. A fade waiting for rest is taken back at once. A voice
+ * not fading is left as it is.
+ */
+export declare function beginRise<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, opts: {
+    over?: number;
+}): void;
+/**
+ * Fades a voice out from mix time `at`: ahead, it plays untouched until then and begins its fade
+ * 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;
 export declare function retire<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, at?: number): void;

package/dist/fade.js

@@ -1,9 +1,11 @@
 import { changed } from './chain.js';
 import { envelope } from './clock.js';
 import { schedule } from './due.js';
-import { noted } from './history.js';
+import { leave, noted, releasing } from './history.js';
 import { orphan } from './owner.js';
 import { startOf } from './place.js';
+import { scoreTouched } from './scored.js';
+import { lingers, refit } from './spans.js';
 import { unreach } from './unreached.js';
 /** Starts one subject's ramp out of a voice, or takes it out at once for a ramp of 0. */
 export function fadeSubject(mix, voice, subject, over) {
@@ -43,7 +45,7 @@ export function part(mix, voice, subject, at) {
     forgetIn(mix, voice, subject);
     const motion = voice.motion;
     if (motion !== undefined && asks(mix, motion, voice))
-        motion.release(subject);
+        motion.release(subject, ...releasing(mix));
 }
 /** Brings a subject faded out of a voice back, to be met afresh on its next probe. */
 export function unpart(mix, voice, subject) {
@@ -63,6 +65,7 @@ function forgetIn(mix, voice, subject) {
         unreach(voice, head.slot, false);
     const held = voice.subjects.get(subject);
     if (held !== undefined) {
+        leave(mix, voice, subject, held);
         voice.subjects.delete(subject);
         if (held.reaches)
             voice.seen--;
@@ -102,6 +105,52 @@ export function beginFade(mix, voice, opts, at) {
     if (over === 0 && opts.at !== 'rest')
         retire(mix, voice, voice.out.at);
 }
+/**
+ * Turns a fading voice around: it climbs back from where its fade out had got to, up the same
+ * curve, at the whole curve per `over` ms. A fade waiting for rest is taken back at once. A voice
+ * not fading is left as it is.
+ */
+export function beginRise(mix, voice, opts) {
+    const out = voice.out;
+    if (voice.state !== 'fading' && voice.outSet) {
+        // A fade set ahead and not begun is taken back, and the weight never moved.
+        voice.outAt = Number.POSITIVE_INFINITY;
+        voice.outOver = Number.NaN;
+        voice.outSet = false;
+        noted(mix, voice);
+        return;
+    }
+    if (voice.state !== 'fading' || out === null)
+        return;
+    const at = Number.isNaN(mix.now) ? startOf(voice) : mix.now;
+    const over = mix.reduced ? 0 : (opts.over ?? voice.fade.in ?? voice.fade.out ?? 0);
+    const left = out.rest || out.over === 0 ? 1 : 1 - (at - out.at) / out.over;
+    const from = left < 0 ? 0 : left > 1 ? 1 : left;
+    voice.out = null;
+    voice.outAt = Number.POSITIVE_INFINITY;
+    voice.state = 'live';
+    voice.back = over > 0 && from < 1 ? { from, at, over } : null;
+    noted(mix, voice);
+    mix.lanes?.refill();
+}
+/**
+ * Fades a voice out from mix time `at`: ahead, it plays untouched until then and begins its fade
+ * exactly there; at or behind now, the fade began then and is partway.
+ */
+export function fadeAt(mix, voice, at, over) {
+    if (voice.state === 'done' || voice.state === 'fading')
+        return;
+    const now = Number.isNaN(mix.now) ? startOf(voice) : mix.now;
+    if (at <= now) {
+        beginFade(mix, voice, { over }, Math.max(startOf(voice), at));
+        mix.stir();
+        return;
+    }
+    voice.outAt = at;
+    voice.outOver = over ?? Number.NaN;
+    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) {
@@ -114,11 +163,12 @@ export function retire(mix, voice, at) {
     if (motion !== undefined && asks(mix, motion, voice))
         motion.owner = null;
     voice.state = 'done';
+    scoreTouched(mix, voice);
     // The record its setting last wrote to, which a retired voice no longer calls for.
     voice.keepOn = null;
     mix.retired.push(voice);
     voice.doneAt = at ?? (Number.isNaN(mix.now) ? Number.NEGATIVE_INFINITY : mix.now);
-    voice.play(false);
+    voice.play(false, voice.doneAt);
     voice.resolve();
     // An owner takes what it holds with it, and leaves with its last child.
     if (voice.holding !== null)
@@ -126,8 +176,11 @@ export function retire(mix, voice, at) {
             if (child.state !== 'done')
                 retire(mix, child, voice.doneAt);
     if (voice.owner !== null) {
+        const span = voice.owner;
         const owner = orphan(voice);
-        if (owner !== null)
+        if (owner !== null && !lingers(owner, voice.doneAt))
             retire(mix, owner, voice.doneAt);
+        else if (span.fitting !== null && span.state !== 'done')
+            refit(mix, span);
     }
 }

package/dist/fill.d.ts

@@ -23,7 +23,7 @@ export declare function reset<I, O>(this: Lanes<I, O>, lane: Lane<I, O>): void;
 export declare function run<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 `influence` does where it returns one, which is what makes a voice in a
+ * 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;

package/dist/fill.js

@@ -39,6 +39,7 @@ export function fillAll(lanes, now, version) {
         const decide = lanes.fresh;
         lanes.fresh = false;
         const share = lanes.live > 0 ? lanes.lastDistinct / lanes.live : 1;
+        lanes.lately = share < 1 ? lanes.lastFrom : -1;
         // Deciding which lanes and crowds go idle first, then running them, in voice order: a crowd's
         // rows are folded between the lanes on either side of their voices, as the general path
         // folds every voice in order.
@@ -95,11 +96,9 @@ export function fillAll(lanes, now, version) {
                 }
         }
         // With every lane idle there was nothing to fill, and no subject reads a lane this frame.
-        if (busy)
-            for (let s = 0; s < size; s++)
-                lanes.per[s * 6 /* Per.SLOT */ + 0 /* Per.FILLED */] = lanes.fills;
+        lanes.busyFill = busy ? lanes.fills : 0;
         for (const slot of lanes.late)
-            lanes.per[slot * 6 /* Per.SLOT */ + 0 /* Per.FILLED */] = 0;
+            lanes.per[slot * 6 /* Per.SLOT */ + 0 /* Per.FILLED */] = lanes.fills;
         if (lanes.holding) {
             lanes.subjects.fill(undefined, 0, size);
             lanes.holding = false;
@@ -208,7 +207,11 @@ export function reset(lane) {
     lane.read = false;
     lane.weighed = false;
     // With no fade in or out the envelope is 1 for every subject, which is what it would return.
-    lane.flat = !((voice.fade.in ?? 0) > 0) && voice.out === null && voice.owner === null;
+    lane.flat =
+        !((voice.fade.in ?? 0) > 0) &&
+            voice.out === null &&
+            voice.back === null &&
+            voice.owner === null;
     lane.fade = 1;
 }
 /** One voice's contribution to every subject it plays on. */
@@ -238,7 +241,7 @@ export function run(lane) {
 }
 /**
  * One subject's contribution from a lane's voice. True where the voice gave the subject a delta,
- * as the general path's `influence` does where it returns one, which is what makes a voice in a
+ * 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 function one(lane, p, slot, elapsedNow, duration, passes) {
@@ -249,6 +252,8 @@ export function one(lane, p, slot, elapsedNow, duration, passes) {
     // A probe read this subject from the last fill: keep the weight it read for `weightOf`.
     if (this.per[slot * 6 /* Per.SLOT */ + 5 /* Per.LANE_FILL */] === this.fills - 1)
         data[o + 3 /* Row.PROBED */] = data[o + 2 /* Row.WEIGHT */];
+    if (this.lately >= 0 && this.unread(slot))
+        return false;
     const delay = data[o + 0 /* Row.DELAY */];
     const elapsed = frozenAt(voice, elapsedNow - delay);
     if (!(elapsed >= 0)) {
@@ -278,6 +283,8 @@ export function one(lane, p, slot, elapsedNow, duration, passes) {
     else
         w = weighed(voice.weight, lane.fade, this.parting(voice, slot));
     data[o + 2 /* Row.WEIGHT */] = w;
+    this.folding = lane;
+    this.rec = lane.records[p] ?? null;
     if (voice.built !== null) {
         if (!lane.read || !Object.is(elapsed, lane.readAt)) {
             this.readKeyed(voice, lane.phase, lane.delta, lane.scratch);
@@ -367,12 +374,12 @@ export function call(voice, chans, rec, slot, elapsed, phase, pass, delay, w) {
     else
         reading.horizon = Number.POSITIVE_INFINITY;
     const delta = voice.patch.at(phase, subject, voice.setting);
-    // What `influence` leaves on the record, so a probe on the general path this frame reuses it.
+    // What `contribution` leaves on the record, so a probe on the general path this frame reuses it.
     rec.delta = delta;
     rec.probed = this.now;
     rec.seeks = voice.seeks;
     if (this.keeps)
-        host.after(voice, rec);
+        host.after(voice, subject, rec);
     if (reading.kept !== kept && !voice.keeping)
         host.kept(voice);
     if (w > 0)

package/dist/fit.d.ts

@@ -0,0 +1,144 @@
+/**
+ * How hard a claim on time holds when it meets another: the weaker gives way.
+ *
+ * @category score
+ */
+export type Strength = 'weak' | 'strong' | 'required';
+/**
+ * How a span lays its children out: each after the one before has ended, partway through it, or
+ * all at once.
+ *
+ * @category score
+ */
+export type Order = 'queue' | 'stagger' | 'together';
+/**
+ * One child of a span as a fit sees it: what is left of it, and the ways it may give way.
+ *
+ * @category score
+ */
+export interface Claim {
+    /** Span ms left of it at its own rate. */
+    natural: number;
+    /** A playing child has started, and stays at the front. */
+    state: 'pending' | 'playing';
+    /** How many times faster it may play; 1 for no faster. */
+    faster: number;
+    /** How many times slower it may play; 1 for no slower. */
+    slower: number;
+    /** Whether it may run alongside the one before it where the span's order would not have it. */
+    overlap: boolean;
+    /** Whether it may jump to its end instead of playing. */
+    ballast: boolean;
+    priority: Strength;
+}
+/**
+ * The span as a fit sees it.
+ *
+ * @category score
+ */
+export interface SpanClaim {
+    /** Span ms left of its budget; Infinity for a span with none. */
+    left: number;
+    /** Its whole budget. */
+    budget: number;
+    priority: Strength;
+    order: Order;
+    /** How far through the one before a staggered child starts, 0..1. */
+    share: number;
+}
+/**
+ * What a fit decides, per child in the order given: a rate over its own, and whether it is
+ * skipped. `share` is how far through the one before a child that may overlap starts, and `allow`
+ * the span ms the span may run past its budget.
+ *
+ * @category score
+ */
+export interface FitPlan {
+    rate: number[];
+    skip: boolean[];
+    share: number;
+    allow: number;
+}
+/**
+ * A strategy for fitting a span's children into its budget: from the plan so far to a new one.
+ *
+ * @category score
+ */
+export type Fit = (span: SpanClaim, kids: readonly Claim[], plan: FitPlan) => FitPlan;
+/** How far through the one before a child starts under each order, before any fit. */
+export declare function shareOf(order: Order, stagger: number): number;
+/**
+ * The plan before any fit: every child at its own rate, played, in the span's order.
+ *
+ * @category score
+ */
+export declare function plain(span: SpanClaim, kids: readonly Claim[]): FitPlan;
+/**
+ * Where a plan puts each child, span ms from now, and how long they take together. A playing child
+ * is where it is, at 0; each pending one starts its share through the one before it.
+ *
+ * @category score
+ */
+export declare function layout(span: SpanClaim, kids: readonly Claim[], plan: FitPlan): {
+    at: number[];
+    length: number;
+};
+/**
+ * Moves every child's rate by one factor toward the budget, before the span's fit: faster where
+ * they run past it, each no faster than its `faster` allows, and slower where they leave room in
+ * it, each no slower than its `slower` allows, so they fill it.
+ */
+export declare function rescale(span: SpanClaim, kids: readonly Claim[], plan: FitPlan): FitPlan;
+/**
+ * Starts children that may overlap sooner after the one before, toward all at once, until they
+ * fit.
+ *
+ * @category score
+ */
+export declare function condense(): Fit;
+/**
+ * Jumps children that may be skipped to their end, latest first, until they fit.
+ *
+ * @category score
+ */
+export declare function shed(): Fit;
+/**
+ * Jumps every child left to its end at once, whether or not it fits otherwise.
+ *
+ * @category score
+ */
+export declare function conclude(): Fit;
+/**
+ * Lets the span run past its budget: up to `cap` times it, or without limit.
+ *
+ * @category score
+ */
+export declare function overrun(opts?: {
+    cap?: number;
+}): Fit;
+/**
+ * Tries each fit in turn, handing the plan on, and stops once the children fit.
+ *
+ * @category score
+ */
+export declare function pipe(...fits_: readonly Fit[]): Fit;
+/**
+ * Every way of giving way after the span's retiming, overrunning only once the rest are spent.
+ *
+ * @category score
+ */
+export declare function lax(opts?: {
+    cap?: number;
+}): Fit;
+/** The fit a span takes without one of its own. */
+export declare const defaultFit: Fit;
+/**
+ * A span's fit settled: the plan, and what it had to do past the strategy, which starts from the
+ * children retimed toward the budget. Where the children still
+ * do not fit, a span weaker than `strong` lets them run long; otherwise `spill` either skips
+ * every child weaker than the span (`instant`), or lets them run long (`overrun`).
+ */
+export declare function settle(span: SpanClaim, kids: readonly Claim[], fit: Fit, spill: 'instant' | 'overrun'): {
+    plan: FitPlan;
+    fell: boolean;
+};

package/dist/fit.js

@@ -0,0 +1,181 @@
+/** How far through the one before a child starts under each order, before any fit. */
+export function shareOf(order, stagger) {
+    return order === 'queue' ? 1 : order === 'together' ? 0 : stagger;
+}
+/**
+ * The plan before any fit: every child at its own rate, played, in the span's order.
+ *
+ * @category score
+ */
+export function plain(span, kids) {
+    return {
+        rate: kids.map(() => 1),
+        skip: kids.map(() => false),
+        share: shareOf(span.order, span.share),
+        allow: 0,
+    };
+}
+/**
+ * Where a plan puts each child, span ms from now, and how long they take together. A playing child
+ * is where it is, at 0; each pending one starts its share through the one before it.
+ *
+ * @category score
+ */
+export function layout(span, kids, plan) {
+    const base = shareOf(span.order, span.share);
+    const at = [];
+    let length = 0;
+    let prevAt = 0;
+    let prevLen = 0;
+    kids.forEach((k, i) => {
+        const len = plan.skip[i] ? 0 : k.natural / plan.rate[i];
+        const t = k.state === 'playing' || i === 0
+            ? 0
+            : prevAt + (k.overlap ? Math.min(plan.share, base) : base) * prevLen;
+        at.push(t);
+        length = Math.max(length, t + len);
+        prevAt = t;
+        prevLen = len;
+    });
+    return { at, length };
+}
+const fits = (span, kids, plan) => layout(span, kids, plan).length <= span.left + plan.allow + 1e-9;
+/** The smallest value in `lo..hi` at which `ok` holds, where it holds from some point up. */
+function least(lo, hi, ok) {
+    if (ok(lo))
+        return lo;
+    if (!ok(hi))
+        return hi;
+    for (let i = 0; i < 60; i++) {
+        const mid = (lo + hi) / 2;
+        if (ok(mid))
+            hi = mid;
+        else
+            lo = mid;
+    }
+    return hi;
+}
+/**
+ * Moves every child's rate by one factor toward the budget, before the span's fit: faster where
+ * they run past it, each no faster than its `faster` allows, and slower where they leave room in
+ * it, each no slower than its `slower` allows, so they fill it.
+ */
+export function rescale(span, kids, plan) {
+    if (!fits(span, kids, plan)) {
+        const top = Math.max(1, ...kids.map((k) => k.faster));
+        const at = (f) => ({
+            ...plan,
+            rate: kids.map((k, i) => Math.max(plan.rate[i], Math.min(f, k.faster))),
+        });
+        return at(least(1, top, (f) => fits(span, kids, at(f))));
+    }
+    if (!Number.isFinite(span.left))
+        return plan;
+    const top = Math.max(1, ...kids.map((k) => k.slower));
+    if (top === 1)
+        return plan;
+    const at = (f) => ({
+        ...plan,
+        rate: kids.map((k, i) => plan.rate[i] / Math.min(f, k.slower)),
+    });
+    // The largest factor that still fits: `least` over the factors that do not.
+    const f = least(1, top, (x) => !fits(span, kids, at(x)));
+    return fits(span, kids, at(f)) ? at(f) : at(Math.max(1, f - 1e-9));
+}
+/**
+ * Starts children that may overlap sooner after the one before, toward all at once, until they
+ * fit.
+ *
+ * @category score
+ */
+export function condense() {
+    return (span, kids, plan) => {
+        if (fits(span, kids, plan) || !kids.some((k) => k.overlap))
+            return plan;
+        const at = (s) => ({ ...plan, share: s });
+        // `least` finds the smallest x that fits; the share wanted is the largest, so search 1 - share.
+        const x = least(0, plan.share, (d) => fits(span, kids, at(plan.share - d)));
+        return at(plan.share - x);
+    };
+}
+/**
+ * Jumps children that may be skipped to their end, latest first, until they fit.
+ *
+ * @category score
+ */
+export function shed() {
+    return (span, kids, plan) => {
+        let p = plan;
+        for (let i = kids.length - 1; i >= 0 && !fits(span, kids, p); i--) {
+            if (!kids[i].ballast || p.skip[i])
+                continue;
+            const s = p.skip.slice();
+            s[i] = true;
+            p = { ...p, skip: s };
+        }
+        return p;
+    };
+}
+/**
+ * Jumps every child left to its end at once, whether or not it fits otherwise.
+ *
+ * @category score
+ */
+export function conclude() {
+    return (_span, kids, plan) => ({ ...plan, skip: kids.map(() => true) });
+}
+/**
+ * Lets the span run past its budget: up to `cap` times it, or without limit.
+ *
+ * @category score
+ */
+export function overrun(opts = {}) {
+    return (span, _kids, plan) => {
+        const cap = opts.cap;
+        const allow = cap === undefined ? Number.POSITIVE_INFINITY : Math.max(0, (cap - 1) * span.budget);
+        return { ...plan, allow: Math.max(plan.allow, allow) };
+    };
+}
+/**
+ * Tries each fit in turn, handing the plan on, and stops once the children fit.
+ *
+ * @category score
+ */
+export function pipe(...fits_) {
+    return (span, kids, plan) => {
+        let p = plan;
+        for (const f of fits_) {
+            if (fits(span, kids, p))
+                break;
+            p = f(span, kids, p);
+        }
+        return p;
+    };
+}
+/**
+ * Every way of giving way after the span's retiming, overrunning only once the rest are spent.
+ *
+ * @category score
+ */
+export function lax(opts = {}) {
+    return pipe(condense(), shed(), overrun(opts));
+}
+/** The fit a span takes without one of its own. */
+export const defaultFit = pipe(condense(), shed());
+const rank = { weak: 0, strong: 1, required: 2 };
+/**
+ * A span's fit settled: the plan, and what it had to do past the strategy, which starts from the
+ * children retimed toward the budget. Where the children still
+ * do not fit, a span weaker than `strong` lets them run long; otherwise `spill` either skips
+ * every child weaker than the span (`instant`), or lets them run long (`overrun`).
+ */
+export function settle(span, kids, fit, spill) {
+    let plan = fit(span, kids, rescale(span, kids, plain(span, kids)));
+    if (fits(span, kids, plan) || rank[span.priority] === 0 || spill === 'overrun')
+        return { plan, fell: !fits(span, kids, plan) && rank[span.priority] > 0 };
+    plan = {
+        ...plan,
+        skip: kids.map((k, i) => plan.skip[i] || rank[k.priority] < rank[span.priority]),
+    };
+    return { plan, fell: true };
+}

package/dist/fold.d.ts

@@ -7,7 +7,7 @@ export type Values = Record<string, unknown>;
  * One live voice's delta for one subject this frame, through its record for the subject, or null
  * when it does not reach. Its weight is left in `w`.
  */
-export declare function influence<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, now: number, held: Subject<unknown>): Record<string, unknown> | null;
+export declare function contribution<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, now: number, held: Subject<unknown>): Record<string, unknown> | null;
 /** Reads a keys voice's stops at `held.phase` into the subject's delta, through the voice's scratch. */
 export declare function keyed<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, held: Subject<unknown>): Record<string, unknown>;
 /**
@@ -28,7 +28,7 @@ export declare function baseFor<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, sub
  */
 export declare function slopeFor<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I): Record<string, unknown> | undefined;
 export declare function isRest<I, O>(this: Mixer<I, O>, delta: Record<string, unknown>): boolean;
-/** Whether a rest-less channel's influence is switched on, across a band rather than an edge. */
+/** Whether a rest-less channel's contribution is switched on, across a band rather than an edge. */
 export declare function passes<I, O>(this: Mixer<I, O>, was: boolean | undefined, w: number): boolean;
 /** Folds one voice's delta into the pose, its band state kept on the subject's record. */
 export declare function apply<I, O>(this: Mixer<I, O>, pose: Record<string, unknown>, voice: Voice<I, O>, held: Subject<unknown>, delta: Record<string, unknown>, weight: number): void;
@@ -47,5 +47,5 @@ export declare function foldWith<I, O>(this: Mixer<I, O>, subject: I, out: O, he
 export declare function owedBy<I, O>(this: Mixer<I, O>, owed: number, voice: Voice<I, O>): boolean;
 /** `foldWith`'s voices with a locus in play: each locus folds at its first member's place. */
 export declare function foldLoci<I, O>(this: Mixer<I, O>, subject: I, pose: Record<string, unknown>, head: Subject<unknown>, laned: boolean, dry: boolean, except: number | undefined, owed: number): O;
-/** `influence`, or for a dry fold a subject already probed this frame, without advancing it. */
+/** `contribution`, or for a dry fold a subject already probed this frame, without advancing it. */
 export declare function read<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, now: number, dry: boolean, held: Subject<unknown>): Record<string, unknown> | null;

package/dist/fold.js

@@ -39,7 +39,7 @@ function merged(channel, acc, b) {
  * One live voice's delta for one subject this frame, through its record for the subject, or null
  * when it does not reach. Its weight is left in `w`.
  */
-export function influence(voice, subject, now, held) {
+export function contribution(voice, subject, now, held) {
     held.weight = 0;
     if (!held.reaches)
         return null;
@@ -89,19 +89,27 @@ export function influence(voice, subject, now, held) {
         }
     }
     let delta = null;
-    // Keys read even when silent: a `from: 'current'` voice takes its base on its first read.
-    if (voice.built) {
+    // A keys voice in a locus reads at weight 0 too: having a delta makes it a member, and the
+    // locus folds at its first member's place.
+    if (silent(voice, weight) && (voice.built === null || voice.spec.locus === undefined)) {
+        // A `from: 'current'` voice takes its base on its first read, silent or not.
+        if (voice.built && voice.spec.from === 'current' && held.base === undefined) {
+            held.base = this.baseFor(voice, subject);
+            held.slope = this.slopeFor(voice, subject);
+        }
+    }
+    else if (voice.built) {
         held.phase = phase;
         delta = this.keyed(voice, subject, held);
     }
-    else if (!silent(voice, weight)) {
+    else {
         delta = voice.patch.at(phase, subject, setting);
     }
     held.delta = delta;
     held.probed = now;
     held.seeks = voice.seeks;
     if (history !== undefined)
-        remember(this, voice, held);
+        remember(this, voice, subject, held);
     if (reading.kept !== keptBefore && !voice.keeping)
         stateful(this, voice);
     if (delta === null)
@@ -222,7 +230,7 @@ export function isRest(delta) {
     }
     return true;
 }
-/** Whether a rest-less channel's influence is switched on, across a band rather than an edge. */
+/** Whether a rest-less channel's contribution is switched on, across a band rather than an edge. */
 export function passes(was, w) {
     const { on, off } = this.band;
     return w >= on ? true : w <= off ? false : (was ?? w >= on);
@@ -281,10 +289,9 @@ export function folded(subject, out, dry = false, except) {
  * voices on them; a subject numbered since the frame's fill folds every voice, laned ones included.
  */
 export function linked(subject) {
-    const now = this.now;
-    const head = Number.isNaN(now) ? null : this.chain(subject, now);
+    const head = Number.isNaN(this.now) ? null : this.chain(subject);
     this.linkedLaned =
-        head !== null && this.lanes?.prepare(head.slot, subject, now, this.version, head) === true;
+        head !== null && this.lanes?.prepare(head.slot, subject, this.version, head) === true;
     return head;
 }
 /** The fold after a subject's chain is linked and its lanes asked whether it reads from them. */
@@ -450,7 +457,7 @@ export function foldLoci(subject, pose, head, laned, dry, except, owed) {
         this.locusDepth--;
     }
 }
-/** `influence`, or for a dry fold a subject already probed this frame, without advancing it. */
+/** `contribution`, or for a dry fold a subject already probed this frame, without advancing it. */
 export function read(voice, subject, now, dry, held) {
     if (dry) {
         if (held.reaches && held.probed === now && held.delta && held.seeks === voice.seeks) {
@@ -471,5 +478,5 @@ export function read(voice, subject, now, dry, held) {
             return held.delta;
         }
     }
-    return this.influence(voice, subject, now, held);
+    return this.contribution(voice, subject, now, held);
 }

package/dist/gather.d.ts

@@ -22,3 +22,9 @@ export declare function foldDelta<I, O>(this: Lanes<I, O>, chans: readonly Laned
 /** Folds a motion sample's axes, kept apart from `foldInto` so neither reads two array kinds. */
 export declare function foldRun<I, O>(this: Lanes<I, O>, ch: Laned, slot: number, xs: Float64Array, w: number): void;
 export declare function foldInto<I, O>(this: Lanes<I, O>, ch: Laned, slot: number, value: unknown, w: number): void;
+/**
+ * Whether a rest-less channel's contribution passes the band, for the record `one` is folding: the
+ * general path's `apply` decides it from the same band state on the same record, so a subject
+ * moving between the paths carries it.
+ */
+export declare function gate<I, O>(this: Lanes<I, O>, ch: Laned, w: number): boolean;