@msb235/blits 0.5.0 → 0.7.0

package/dist/history.js

@@ -1,6 +1,8 @@
 import { elapsedWith } from './clock.js';
 import { clone } from './clone.js';
 import { schedule } from './due.js';
+import { packHeld } from './pack.js';
+import { pageOut } from './paging.js';
 import { none } from './voice.js';
 /**
  * The last entry taken before `t`, or at it where `inclusive` says so, as it does for a change a
@@ -61,7 +63,15 @@ export function noted(mix, voice) {
     while (drop + 1 < log.length && log[drop + 1].at <= reach)
         drop++;
     if (drop > 0)
-        log.splice(0, drop);
+        pageOut(mix, 'controls', voice.id, undefined, log.splice(0, drop), copied, reach);
+}
+const copied = (e) => ({ ...e });
+/** Takes off the front of a list kept by time what a read back to `reach` no longer needs. */
+function older(list, reach) {
+    let n = 0;
+    while (n + 1 < list.length && list[n + 1].at <= reach)
+        n++;
+    return n === 0 ? [] : list.splice(0, n);
 }
 /** A copy of a subject's record that shares nothing a read could change. */
 export function copyHeld(voice, h) {
@@ -77,6 +87,7 @@ export function copyHeld(voice, h) {
         bands: h.bands === null ? null : h.bands.slice(),
         state: h.state === undefined ? undefined : patch.clone ? patch.clone(h.state) : clone(h.state),
         kept,
+        unkept: h.unkept?.map(clone),
         probed: Number.NaN,
         delta: null,
         phase: 0,
@@ -107,11 +118,10 @@ export function recordHost(mix, now) {
         return;
     log.push({ at: now, fields });
     const reach = now - mix.opts.history.ms;
-    while (log.length > 1 && log[1].at <= reach)
-        log.shift();
+    pageOut(mix, 'host', undefined, undefined, older(log, reach), (e) => e.fields, reach);
 }
 /** Under `history` with `inputs`, keeps what an input signal read, each time it changes. */
-export function record(mix, held, value) {
+export function record(mix, voice, subject, held, value) {
     const history = mix.opts.history;
     if (!history?.inputs || mix.projecting)
         return;
@@ -125,11 +135,12 @@ export function record(mix, held, value) {
     }
     inputs.push({ at: mix.now, value });
     const reach = mix.now - history.ms;
-    while (inputs.length > 1 && inputs[1].at <= reach)
-        inputs.shift();
+    const out = older(inputs, reach);
+    if (out.length > 0)
+        pageOut(mix, 'input', voice.id, mix.keys?.key(subject), out, (e) => e.value, reach);
 }
 /** Under `history`, keeps a copy of a stateful voice's record for this subject every so often. */
-export function remember(mix, voice, held) {
+export function remember(mix, voice, subject, held) {
     const history = mix.opts.history;
     if (!history || mix.projecting)
         return;
@@ -144,6 +155,40 @@ export function remember(mix, voice, held) {
         return;
     snaps.push({ at: mix.now, held: copyHeld(voice, held) });
     const reach = mix.now - history.ms;
-    while (snaps.length > 1 && snaps[1].at <= reach)
-        snaps.shift();
+    const out = older(snaps, reach);
+    if (out.length > 0)
+        pageOut(mix, 'snap', voice.id, mix.keys?.key(subject), out, (e) => packHeld(voice, e.held), reach);
+}
+/**
+ * Under history, keeps the record a subject had when it left a voice, faded out of it or dropped,
+ * for a seek or a read back to before then; without history, keeps nothing.
+ */
+export function leave(mix, voice, subject, held) {
+    const history = mix.opts.history;
+    if (history === undefined || held === undefined)
+        return;
+    const reach = mix.now - history.ms;
+    const left = [];
+    for (const e of voice.left ?? [])
+        if (e.at >= reach)
+            left.push(e);
+        else if (mix.keys !== null)
+            pageOut(mix, 'left', voice.id, mix.keys.key(e.subject), [e], (x) => packHeld(voice, x.held), reach);
+    left.push({ subject, at: Number.isNaN(mix.now) ? Number.NEGATIVE_INFINITY : mix.now, held });
+    voice.left = left;
+}
+/** The record a subject had at mix time `t` and left a voice with after it, if it left after `t`. */
+export function leftAt(left, subject, t) {
+    let found;
+    for (const e of left ?? [])
+        if (e.at > t && Object.is(e.subject, subject) && (found === undefined || e.at < found.at))
+            found = e;
+    return found?.held;
+}
+/** The mix time a motion patch keeps a released subject from, and how far back, under history. */
+export function releasing(mix) {
+    const history = mix.opts.history;
+    if (history === undefined || Number.isNaN(mix.now))
+        return [];
+    return [mix.now, mix.now - history.ms];
 }

package/dist/hosts.d.ts

@@ -7,8 +7,8 @@ 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
  * kept state on a record through `setting.keep` is stateful from then on, and leaves its lane;
- * one that starts keeping partway through may advance that state once for one subject not
- * probed on the frame it starts, which declaring `state` avoids.
+ * one that starts keeping partway through may advance that state once for one subject probed the
+ * frame before it starts and not on that frame, which declaring `state` avoids.
  */
 export declare function fits<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): boolean;
 /** A voice's patch kept state on a record: it is stateful from now on. */

package/dist/hosts.js

@@ -1,6 +1,8 @@
 import { Book } from './book.js';
+import { numericOf } from './channels.js';
+import { crowdable } from './crowd.js';
 import { schedule } from './due.js';
-import { beginFade, fadeSubject } from './fade.js';
+import { beginFade, beginRise, fadeAt, fadeSubject } from './fade.js';
 import { VoiceHandle } from './handle.js';
 import { noted, remember } from './history.js';
 import { hostOf, listed, markOf, readingAt } from './marks.js';
@@ -8,6 +10,7 @@ import { nextFrame } from './move.js';
 import { descendants, ownWeight, signalled } from './owner.js';
 import { localNow } from './place.js';
 import { reading } from './reading.js';
+import { record } from './tape.js';
 import { unreach } from './unreached.js';
 export function book(mix, opts) {
     if (mix.projecting)
@@ -42,6 +45,7 @@ export function laneHost(mix) {
         },
         channels: mix.channels,
         names: mix.names,
+        clock: mix,
         fits: (voice) => fits(mix, voice),
         meet: (voice, subject, head, slot) => {
             for (let held = head; held !== null; held = held.next)
@@ -56,6 +60,7 @@ export function laneHost(mix) {
             for (const voice of mix.gone)
                 unreach(voice, slot, false);
         },
+        passes: (was, w) => mix.passes(was, w),
         naming: (subject) => (mix.naming === 0 ? undefined : mix.named.get(subject)),
         slotOf: (subject) => mix.chains.get(subject)?.slot ?? -1,
         envelope: (voice, since) => voice.owner === null
@@ -84,22 +89,22 @@ export function laneHost(mix) {
             reading.horizon = mix.horizonFor(voice, delay, mix.now);
         },
         keeps: mix.opts.history !== undefined,
-        after: (voice, held) => remember(mix, voice, held),
+        after: (voice, subject, held) => remember(mix, voice, subject, held),
         kept: (voice) => stateful(mix, voice),
     };
 }
 /**
  * Whether a voice's patch and spec can run on a lane, its channels aside. A voice whose patch has
  * kept state on a record through `setting.keep` is stateful from then on, and leaves its lane;
- * one that starts keeping partway through may advance that state once for one subject not
- * probed on the frame it starts, which declaring `state` avoids.
+ * one that starts keeping partway through may advance that state once for one subject probed the
+ * frame before it starts and not on that frame, which declaring `state` avoids.
  */
 export function fits(mix, voice) {
     const spec = voice.spec;
     const patch = voice.patch;
     if (voice.keeping)
         return false;
-    if (voice.state === 'pending' && voice.holdsBefore)
+    if (voice.state === 'pending' && voice.freezesBefore)
         return false;
     // A fill weighs a voice's owners once for every subject, which a signal on one would not be.
     if (voice.owner !== null && signalled(voice))
@@ -112,6 +117,10 @@ export function fits(mix, voice) {
         return false;
     if (spec.from === 'current')
         return false;
+    // A rest-less channel's band is read on the record `one` folds; crowds, motions and loci fold elsewhere.
+    if ((voice.motion !== undefined || spec.locus !== undefined || crowdable(voice)) &&
+        voice.slots.some((s) => numericOf(mix.channels[s])?.op === 'last'))
+        return false;
     if (voice.out?.rest)
         return false;
     if (patch.state !== undefined || patch.step !== undefined)
@@ -159,9 +168,12 @@ function handleHost(mix) {
                 throw new Error('blits: an owner fades as a whole, not by subject or at rest');
             if (opts !== undefined && 'subject' in opts)
                 fadeSubject(mix, voice, opts.subject, opts.over);
+            else if (typeof opts?.at === 'number')
+                fadeAt(mix, voice, opts.at, opts.over);
             else
-                beginFade(mix, voice, opts ?? {});
+                beginFade(mix, voice, (opts ?? {}));
         },
+        rise: (voice, opts) => beginRise(mix, voice, opts ?? {}),
         weightOf: (voice, subject) => {
             if (voice.state === 'done')
                 return 0;
@@ -174,5 +186,6 @@ function handleHost(mix) {
             }
             return voice.subjects.get(subject)?.weight ?? 0;
         },
+        record: (label, again) => record(mix, label, again),
     };
 }

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/lane.d.ts

@@ -1,5 +1,5 @@
 import type { Numeric } from './channels.js';
-import { type Motions } from './motion.js';
+import type { Motions } from './motions.js';
 import type { Scratch } from './patch.js';
 import type { Subject, Voice } from './voice.js';
 /** One laned channel: its arithmetic, and every numbered subject's folded value, `axes` per subject. */
@@ -204,7 +204,7 @@ export declare class Lane<I, O> implements Positions<I, O> {
     remove(slot: number): void;
 }
 /**
- * A subject's voice time once its voice's holds apply: held at 0 before it starts and at the end of
- * its passes after, and NaN where it shows nothing.
+ * 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.
  */
-export declare function held<I, O>(voice: Voice<I, O>, elapsed: number): number;
+export declare function frozenAt<I, O>(voice: Voice<I, O>, elapsed: number): number;

package/dist/lane.js

@@ -1,5 +1,5 @@
 import { unbareLane } from './bare.js';
-import { heldTime } from './clock.js';
+import { frozenTime } from './clock.js';
 import { motionOf } from './motion.js';
 /**
  * Below what share of its subjects probed last frame a lane stops filling, and above what share it
@@ -179,9 +179,9 @@ export class Lane {
     }
 }
 /**
- * A subject's voice time once its voice's holds apply: held at 0 before it starts and at the end of
- * its passes after, and NaN where it shows nothing.
+ * 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.
  */
-export function held(voice, elapsed) {
-    return heldTime(elapsed, voice.holdsBefore, voice.holdsAfter, voice.span);
+export function frozenAt(voice, elapsed) {
+    return frozenTime(elapsed, voice.freezesBefore, voice.freezesAfter, voice.span);
 }

package/dist/lanes.d.ts

@@ -1,9 +1,9 @@
 import type { Column } from './columns.js';
 import { type Crowd, row } from './crowd.js';
 import { call, foldKeys, one, parting, readKeyed, reset, run, signalled, subjectAt } from './fill.js';
-import { fold, foldDelta, foldInto, foldRun, gather } from './gather.js';
+import { fold, foldDelta, foldInto, foldRun, gate, gather } from './gather.js';
 import { type Lane, type Laned, type Locus } from './lane.js';
-import type { Watcher } from './motion.js';
+import type { Watcher } from './motions.js';
 import { type absent, Numbers } from './numbers.js';
 import { Owed } from './owed.js';
 import type { Channel } from './types.js';
@@ -13,6 +13,10 @@ export interface LaneHost<I, O> {
     readonly voices: readonly Voice<I, O>[];
     readonly channels: readonly Channel<unknown>[];
     readonly names: readonly string[];
+    /** The mix itself, for its clock: a getter V8 does not inline would box `now` on return. */
+    readonly clock: {
+        readonly now: number;
+    };
     /** Whether a voice's patch and spec can run on a lane, its channels aside. */
     fits(voice: Voice<I, O>): boolean;
     /** The voice's record for a subject this probe has already linked it to, from `head` if there. */
@@ -35,12 +39,14 @@ export interface LaneHost<I, O> {
      * stateful if the signal keeps state. `slot` is the subject's number.
      */
     signal(voice: Voice<I, O>, subject: I, held: Subject<unknown>, elapsed: number, pass: number, slot: number): number;
+    /** Whether a rest-less channel's contribution passes the band, as the general path decides it. */
+    passes(was: boolean | undefined, w: number): boolean;
     /** Sets `reading.horizon` for the voice and a subject delayed `delay` voice ms. */
     horizon(voice: Voice<I, O>, delay: number): void;
     /** Whether the mix keeps history, so a record a patch call changed may need a copy kept. */
     readonly keeps: boolean;
     /** After a patch call, keeps history of a record that grew kept state. */
-    after(voice: Voice<I, O>, held: Subject<unknown>): void;
+    after(voice: Voice<I, O>, subject: I, held: Subject<unknown>): void;
     /** A patch call left kept state on a record: the voice is stateful from now on. */
     kept(voice: Voice<I, O>): void;
 }
@@ -62,6 +68,9 @@ export declare class Lanes<I, O> implements Watcher {
     overlap: boolean;
     /** The loci whose voices are on lanes, every member of each on one. */
     loci: Locus<I, O>[];
+    /** The lane and record `one` is folding, whose band state a rest-less channel reads. */
+    folding: Lane<I, O> | null;
+    rec: Subject<unknown> | null;
     /** While a fill gathers a locus: that locus and the member gathering, where folds go instead. */
     into: Locus<I, O> | null;
     intoId: number;
@@ -88,14 +97,17 @@ export declare class Lanes<I, O> implements Watcher {
     /** The highest voice id the last qualify or settling of `touched` considered. */
     known: number;
     /**
-     * Per subject number, `SLOT` numbers side by side, so a probe reads one place in memory: which
-     * fill last wrote it (0 for none); the latest lane epoch a probe of it has checked it against;
-     * how many idle lanes reach it, since a probe reads lanes only where none do; and the probe count
-     * at its last probe read from the lanes and at its last probe folded by the general path, with
-     * the fill the former read, which say whether a lane or a record holds what `weightOf` reports.
+     * Per subject number, `SLOT` numbers side by side, so a probe reads one place in memory: the
+     * fill that last left it to the general path, being late, owing, newly numbered or forgotten;
+     * the latest lane epoch a probe of it has checked it against; how many idle lanes reach it,
+     * since a probe reads lanes only where none do; and the probe count at its last probe read from
+     * the lanes and at its last probe folded by the general path, with the fill the former read,
+     * which say whether a lane or a record holds what `weightOf` reports.
      */
     per: Float64Array<ArrayBuffer>;
     fills: number;
+    /** The latest fill if it ran a lane, else 0: a subject whose `FILLED` is below it reads it. */
+    busyFill: number;
     probes: number;
     /**
      * Each subject by number as last probed, held from that probe until the next fill uses it, so a
@@ -140,6 +152,11 @@ export declare class Lanes<I, O> implements Watcher {
     lastDistinct: number;
     /** Numbered subjects alive. */
     live: number;
+    /**
+     * The probe count a subject's last probe must pass for this fill to fill it: the start of the
+     * last frame with a probe, or -1 while every subject alive was probed then, when it fills all.
+     */
+    lately: number;
     filledVersion: number;
     qualifiedVersion: number;
     constructor(host: LaneHost<I, O>);
@@ -171,7 +188,7 @@ export declare class Lanes<I, O> implements Watcher {
      * them. One that a lane has not met yet, newly numbered or newly reached, takes the general path
      * this frame, which is where it is first seen; so does one probed from inside a fill.
      */
-    prepare(slot: number, subject: I, now: number, version: number, head: Subject<unknown> | null): boolean;
+    prepare(slot: number, subject: I, version: number, head: Subject<unknown> | null): boolean;
     /** Whether this frame's lanes are filled and nothing since asks `begin` to look again. */
     filled(now: number, version: number): boolean;
     /**
@@ -180,6 +197,11 @@ export declare class Lanes<I, O> implements Watcher {
      */
     begin(now: number, version: number): number;
     general(slot: number): false;
+    /**
+     * Whether this fill leaves the subject at `slot` to the general path, for not having been probed
+     * this frame or the last: a probe of it before the next fill then takes the general path.
+     */
+    unread(slot: number): boolean;
     /** Whether a probe has read the subject since the frame began, on either path. */
     probedThisFrame(slot: number): boolean;
     /** Whether the subject at `slot` reads some laned voice from the general path this fill. */
@@ -221,6 +243,7 @@ declare const methods: {
     foldDelta: typeof foldDelta;
     foldRun: typeof foldRun;
     foldInto: typeof foldInto;
+    gate: typeof gate;
 };
 type Methods = typeof methods;
 export interface Lanes<I, O> extends Methods {

package/dist/lanes.js

@@ -1,7 +1,7 @@
 import { row } from './crowd.js';
 import { call, fillAll, foldKeys, one, parting, readKeyed, reset, run, signalled, subjectAt, } from './fill.js';
-import { fold, foldDelta, foldInto, foldRun, gather } from './gather.js';
-import { meet, owable, reach } from './meet.js';
+import { fold, foldDelta, foldInto, foldRun, gate, gather } from './gather.js';
+import { meet, reach } from './meet.js';
 import { Numbers } from './numbers.js';
 import { Owed } from './owed.js';
 import { requalify, retouch } from './qualify.js';
@@ -26,6 +26,9 @@ export class Lanes {
     overlap = false;
     /** The loci whose voices are on lanes, every member of each on one. */
     loci = [];
+    /** The lane and record `one` is folding, whose band state a rest-less channel reads. */
+    folding = null;
+    rec = null;
     /** While a fill gathers a locus: that locus and the member gathering, where folds go instead. */
     into = null;
     intoId = 0;
@@ -52,14 +55,17 @@ export class Lanes {
     /** The highest voice id the last qualify or settling of `touched` considered. */
     known = 0;
     /**
-     * Per subject number, `SLOT` numbers side by side, so a probe reads one place in memory: which
-     * fill last wrote it (0 for none); the latest lane epoch a probe of it has checked it against;
-     * how many idle lanes reach it, since a probe reads lanes only where none do; and the probe count
-     * at its last probe read from the lanes and at its last probe folded by the general path, with
-     * the fill the former read, which say whether a lane or a record holds what `weightOf` reports.
+     * Per subject number, `SLOT` numbers side by side, so a probe reads one place in memory: the
+     * fill that last left it to the general path, being late, owing, newly numbered or forgotten;
+     * the latest lane epoch a probe of it has checked it against; how many idle lanes reach it,
+     * since a probe reads lanes only where none do; and the probe count at its last probe read from
+     * the lanes and at its last probe folded by the general path, with the fill the former read,
+     * which say whether a lane or a record holds what `weightOf` reports.
      */
     per = new Float64Array(0);
     fills = 0;
+    /** The latest fill if it ran a lane, else 0: a subject whose `FILLED` is below it reads it. */
+    busyFill = 0;
     probes = 0;
     /**
      * Each subject by number as last probed, held from that probe until the next fill uses it, so a
@@ -104,6 +110,11 @@ export class Lanes {
     lastDistinct = 0;
     /** Numbered subjects alive. */
     live = 0;
+    /**
+     * The probe count a subject's last probe must pass for this fill to fill it: the start of the
+     * last frame with a probe, or -1 while every subject alive was probed then, when it fills all.
+     */
+    lately = -1;
     filledVersion = Number.NaN;
     qualifiedVersion = Number.NaN;
     constructor(host) {
@@ -132,7 +143,7 @@ export class Lanes {
         const slot = this.numbers.take(subject);
         this.live++;
         this.grow(slot + 1);
-        this.per[slot * 6 /* Per.SLOT */ + 0 /* Per.FILLED */] = 0;
+        this.per[slot * 6 /* Per.SLOT */ + 0 /* Per.FILLED */] = this.fills;
         this.per[slot * 6 /* Per.SLOT */ + 1 /* Per.SEEN */] = -1;
         this.per[slot * 6 /* Per.SLOT */ + 2 /* Per.IDLE */] = 0;
         this.per[slot * 6 /* Per.SLOT */ + 3 /* Per.LANE_PROBE */] = 0;
@@ -195,9 +206,10 @@ export class Lanes {
      * them. One that a lane has not met yet, newly numbered or newly reached, takes the general path
      * this frame, which is where it is first seen; so does one probed from inside a fill.
      */
-    prepare(slot, subject, now, version, head) {
-        const ready = this.filled(now, version) ? 1 /* Begin.READY */ : this.begin(now, version);
-        if (ready === 0 /* Begin.GENERAL */)
+    prepare(slot, subject, version, head) {
+        // Read, not passed: a double passed to a call V8 does not inline is boxed, once a probe.
+        const now = this.host.clock.now;
+        if (!this.filled(now, version) && this.begin(now, version) === 0 /* Begin.GENERAL */)
             return this.general(slot);
         if (slot < 0)
             return false;
@@ -206,18 +218,9 @@ export class Lanes {
         const probe = ++this.probes;
         const per = this.per;
         const o = slot * 6 /* Per.SLOT */;
-        let lane = per[o + 0 /* Per.FILLED */] === this.fills && per[o + 2 /* Per.IDLE */] === 0;
-        if (per[o + 1 /* Per.SEEN */] < this.wide && meet(this, slot, subject, head)) {
-            // The fill ran before the subject had these positions. Where every voice it just met folds
-            // after every other laned voice, the general path folds just those onto the lanes' values;
-            // otherwise it reads the general path all frame.
-            if (lane && per[o + 2 /* Per.IDLE */] === 0 && owable(this, slot))
-                this.owed.owe(slot, this.met);
-            else {
-                per[o + 0 /* Per.FILLED */] = 0;
-                lane = false;
-            }
-        }
+        let lane = per[o + 0 /* Per.FILLED */] < this.busyFill && per[o + 2 /* Per.IDLE */] === 0;
+        if (per[o + 1 /* Per.SEEN */] < this.wide)
+            lane = meet(this, slot, subject, head, lane);
         if (lane) {
             per[o + 3 /* Per.LANE_PROBE */] = probe;
             per[o + 5 /* Per.LANE_FILL */] = this.fills;
@@ -283,6 +286,20 @@ export class Lanes {
             this.per[slot * 6 /* Per.SLOT */ + 4 /* Per.GENERAL_PROBE */] = ++this.probes;
         return false;
     }
+    /**
+     * Whether this fill leaves the subject at `slot` to the general path, for not having been probed
+     * this frame or the last: a probe of it before the next fill then takes the general path.
+     */
+    unread(slot) {
+        const per = this.per;
+        const o = slot * 6 /* Per.SLOT */;
+        const lately = this.lately;
+        if (per[o + 3 /* Per.LANE_PROBE */] > lately ||
+            per[o + 4 /* Per.GENERAL_PROBE */] > lately)
+            return false;
+        per[o + 0 /* Per.FILLED */] = this.fills;
+        return true;
+    }
     /** Whether a probe has read the subject since the frame began, on either path. */
     probedThisFrame(slot) {
         const from = this.frameProbes;
@@ -312,6 +329,11 @@ export class Lanes {
     rests(slot) {
         for (const ch of this.laned) {
             const values = ch.values;
+            if (ch.op === 'last') {
+                if (!Number.isNaN(values[slot * ch.axes]))
+                    return false;
+                continue;
+            }
             if (ch.scalar) {
                 if (!(Math.abs(values[slot] - ch.rest) < 1e-9))
                     return false;
@@ -333,6 +355,12 @@ export class Lanes {
         for (let c = 0; c < laned.length; c++) {
             const ch = laned[c];
             const axes = ch.axes;
+            // Never `delete`: it drops a reused out object into dictionary mode for good.
+            if (ch.op === 'last' && Number.isNaN(ch.values[slot * axes])) {
+                if (pose[ch.name] !== undefined)
+                    pose[ch.name] = undefined;
+                continue;
+            }
             if (ch.scalar) {
                 pose[ch.name] = ch.values[slot];
                 continue;
@@ -355,7 +383,7 @@ export class Lanes {
                 if (c.list[p] === slot)
                     unplace(this, c, p);
         if (slot < this.cap)
-            this.per[slot * 6 /* Per.SLOT */ + 0 /* Per.FILLED */] = 0;
+            this.per[slot * 6 /* Per.SLOT */ + 0 /* Per.FILLED */] = this.fills;
         this.subjects[slot] = undefined;
     }
     grow(size) {
@@ -417,6 +445,7 @@ const methods = {
     foldDelta,
     foldRun,
     foldInto,
+    gate,
 };
 for (const [name, value] of Object.entries(methods))
     Object.defineProperty(Lanes.prototype, name, { value, writable: true, configurable: true });

package/dist/locus.d.ts

@@ -1,7 +1,7 @@
 import type { Mixer } from './mixer.js';
 import type { Subject, Voice } from './voice.js';
 /**
- * What a fold with a locus in play gathers, kept from one fold to the next: the influences in
+ * What a fold with a locus in play gathers, kept from one fold to the next: the contributions in
  * voice order, each a voice's own or a locus's first member; every locus member; and per channel
  * slot, a locus's folding value, the weight taken into it and the array it owns.
  */
@@ -11,7 +11,7 @@ export interface LocusScratch<I, O> {
     helds: (Subject<unknown> | null)[];
     deltas: (Record<string, unknown> | null)[];
     weights: number[];
-    /** Per influence, -1 for a voice's own, or which of `names` it is. */
+    /** Per contribution, -1 for a voice's own, or which of `names` it is. */
     groups: number[];
     names: string[];
     m: number;
@@ -32,7 +32,7 @@ export declare function locusScratch<I, O>(channels: number): LocusScratch<I, O>
  */
 export declare function own<I, O>(k: LocusScratch<I, O>, slot: number, value: number[], rest: number[]): number[];
 /**
- * Folds one locus's members into one influence through each channel's own `lerp`: its value per
+ * Folds one locus's members into one contribution through each channel's own `lerp`: its value per
  * channel goes in `k.values`, the channels in `k.touched` in the order first met, and its weight
  * is returned. A channel folding by scale takes its value in an array of `k`'s own, lerped in
  * place, since the fold only reads it.

package/dist/locus.js

@@ -35,7 +35,7 @@ export function own(k, slot, value, rest) {
     return out;
 }
 /**
- * Folds one locus's members into one influence through each channel's own `lerp`: its value per
+ * Folds one locus's members into one contribution through each channel's own `lerp`: its value per
  * channel goes in `k.values`, the channels in `k.touched` in the order first met, and its weight
  * is returned. A channel folding by scale takes its value in an array of `k`'s own, lerped in
  * place, since the fold only reads it.

package/dist/marks.d.ts

@@ -1,5 +1,6 @@
 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 Voice } from './voice.js';
 /** The host timestamp the mix clock reads mix time `t` at; Infinity where it never will. */
@@ -8,5 +9,7 @@ export declare function hostOf<I, O>(mix: Mixer<I, O>, t: number): number;
 export declare function readingAt<I, O>(mix: Mixer<I, O>, u: number): number;
 /** Every mark between two host timestamps, earliest first, with the order that tells each apart. */
 export declare function listed<I, O>(mix: Mixer<I, O>, from: number, to: number): Listed[];
+/** 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;