@msb235/blits 0.7.1 → 0.8.1

package/dist/history.js

@@ -1,15 +1,13 @@
 import { elapsedWith } from './clock.js';
 import { clone } from './clone.js';
 import { schedule } from './due.js';
+import { Leavings } from './leavings.js';
 import { packHeld } from './pack.js';
 import { pageOut } from './paging.js';
 import { scoreTouched } from './scored.js';
+import { within } from './transport.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
- * sync made. A host's change between frames is taken strictly: it shows from the next frame on, as
- * it did live.
- */
+/** The last entry taken before `t`, or at it where `inclusive` says so. */
 export function last(list, t, inclusive) {
     let lo = 0;
     let hi = list.length - 1;
@@ -26,8 +24,28 @@ export function last(list, t, inclusive) {
     }
     return found;
 }
+/**
+ * The last entry of a list kept in the order it was made that falls inside `cut`, an entry made
+ * before its frame was read counting as `early`.
+ */
+export function lastWithin(list, cut) {
+    let lo = 0;
+    let hi = list.length - 1;
+    let found;
+    while (lo <= hi) {
+        const mid = (lo + hi) >> 1;
+        const e = list[mid];
+        if (within(cut, e.seq, e.sync)) {
+            found = e;
+            lo = mid + 1;
+        }
+        else
+            hi = mid - 1;
+    }
+    return found;
+}
 /** Deep equality over plain data, for telling whether a host field changed. */
-function same(a, b) {
+export function same(a, b) {
     if (a === b)
         return true;
     if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null)
@@ -59,7 +77,7 @@ export function noted(mix, voice) {
     const log = voice.log;
     if (log === null)
         return;
-    voice.note(Number.isNaN(mix.now) ? Number.NEGATIVE_INFINITY : mix.now, mix.moving);
+    voice.note(Number.isNaN(mix.now) ? Number.NEGATIVE_INFINITY : mix.now, mix.transport.seq, mix.moving || !mix.looked);
     const reach = mix.now - mix.opts.history.ms;
     let drop = 0;
     while (drop + 1 < log.length && log[drop + 1].at <= reach)
@@ -108,7 +126,8 @@ export function copyHeld(voice, h) {
 export function recordHost(mix, now) {
     const log = mix.hostLog;
     const prev = log[log.length - 1];
-    if (prev !== undefined && prev.at === now)
+    const seq = mix.transport.seq;
+    if (prev !== undefined && prev.seq === seq)
         return;
     const host = mix.opts.host;
     const fields = {};
@@ -118,7 +137,7 @@ export function recordHost(mix, now) {
                 fields[f] = clone(host[f]);
     if (prev !== undefined && same(prev.fields, fields))
         return;
-    log.push({ at: now, fields });
+    log.push({ at: now, seq, fields });
     const reach = now - mix.opts.history.ms;
     pageOut(mix, 'host', undefined, undefined, older(log, reach), (e) => e.fields, reach);
 }
@@ -135,7 +154,7 @@ export function record(mix, voice, subject, held, value) {
             prev.value = value;
         return;
     }
-    inputs.push({ at: mix.now, value });
+    inputs.push({ at: mix.now, seq: mix.transport.seq, value });
     const reach = mix.now - history.ms;
     const out = older(inputs, reach);
     if (out.length > 0)
@@ -155,7 +174,7 @@ export function remember(mix, voice, subject, held) {
     const prev = snaps[snaps.length - 1];
     if (prev !== undefined && mix.now - prev.at < (history.every ?? 200))
         return;
-    snaps.push({ at: mix.now, held: copyHeld(voice, held) });
+    snaps.push({ at: mix.now, seq: mix.transport.seq, held: copyHeld(voice, held) });
     const reach = mix.now - history.ms;
     const out = older(snaps, reach);
     if (out.length > 0)
@@ -170,27 +189,27 @@ export function leave(mix, voice, subject, held) {
     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 });
+    const left = voice.left ?? new Leavings();
     voice.left = left;
+    const keys = mix.keys;
+    left.expire(reach, keys === null
+        ? null
+        : (e) => pageOut(mix, 'left', voice.id, keys.key(e.subject), [e], (x) => [packHeld(voice, x.held), x.sync], reach));
+    left.push({
+        subject,
+        at: Number.isNaN(mix.now) ? Number.NEGATIVE_INFINITY : mix.now,
+        seq: mix.transport.seq,
+        sync: mix.syncing,
+        held,
+    });
 }
-/** 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. */
+/**
+ * The mix time a motion patch keeps a released subject from, how far back, and the frame, 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];
+    return [mix.now, mix.now - history.ms, mix.transport.seq];
 }

package/dist/hosts.js

@@ -2,15 +2,18 @@ import { Book } from './book.js';
 import { numericOf } from './channels.js';
 import { crowdable } from './crowd.js';
 import { schedule } from './due.js';
+import { unshare, unsight, weightAt } from './everyone.js';
 import { beginFade, beginRise, fadeAt, fadeSubject } from './fade.js';
 import { goneIndex } from './gone.js';
 import { VoiceHandle } from './handle.js';
+import { reorigin } from './held.js';
 import { noted, remember } from './history.js';
 import { hostOf, listed, markOf, readingAt } from './marks.js';
 import { nextFrame } from './move.js';
 import { descendants, ownWeight, signalled } from './owner.js';
 import { localNow } from './place.js';
 import { reading } from './reading.js';
+import { heard } from './signals.js';
 import { record } from './tape.js';
 import { unreach } from './unreached.js';
 export function book(mix, opts) {
@@ -52,12 +55,15 @@ export function laneHost(mix) {
             for (let held = head; held !== null; held = held.next)
                 if (held.voice === voice)
                     return held;
-            return mix.held(voice, subject, mix.now, slot);
+            return mix.held(voice, subject, slot);
         },
         forgot: (slot) => {
             // Only a voice over every subject keeps bits, and one gone may still be read back.
-            for (const voice of mix.general)
+            for (const voice of mix.general) {
                 unreach(voice, slot, false);
+                if (voice.sighted !== null)
+                    unsight(voice, slot);
+            }
             for (const voice of goneIndex(mix).general)
                 unreach(voice, slot, false);
         },
@@ -110,8 +116,13 @@ export function fits(mix, voice) {
     // 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))
         return false;
-    // A signal reading host input records it per probe under history, which a fill cannot.
-    if (typeof spec.weight === 'function' && spec.weight.input && mix.opts.history?.inputs)
+    // What can change between two probes without `Lanes.current` hearing of it keeps a voice off:
+    // an input signal that does not report its changes, one that history records per probe, and a
+    // host field.
+    const w = spec.weight;
+    if (typeof w === 'function' && w.input && (mix.opts.history?.inputs || !heard(w)))
+        return false;
+    if (patch.reads !== undefined && patch.reads.length > 0)
         return false;
     // A locus on lanes gathers keys and fn members; a motion member keeps it on the general path.
     if (spec.locus !== undefined && voice.motion !== undefined)
@@ -126,17 +137,38 @@ export function fits(mix, voice) {
         return false;
     if (patch.state !== undefined || patch.step !== undefined)
         return false;
-    if (mix.opts.history?.inputs && patch.reads !== undefined && patch.reads.length > 0)
-        return false;
     const built = voice.built;
     return (built === null ||
         built.tracks.every((t, i) => t.lerp === undefined || t.lerp === voice.lerps[i]));
 }
+const RANK = { exact: 0, stepped: 1, held: 2 };
+/** How sure a seek leaves a voice's state: kept is held; rebuilt is exact only on a fixed step. */
+function seekDoubt(mix, voice, rebuild) {
+    const patch = voice.patch;
+    if (patch.state === undefined && patch.step === undefined && !voice.keeping)
+        return 'exact';
+    if (!rebuild)
+        return 'held';
+    const weight = voice.spec.weight;
+    if ((patch.reads !== undefined && patch.reads.length > 0) ||
+        (typeof weight === 'function' && weight.input))
+        return 'held';
+    if (voice.keeping)
+        return 'stepped';
+    if (patch.step === undefined)
+        return 'exact';
+    const tick = mix.opts.stepMs;
+    const fixed = tick !== undefined && tick > 0 && !mix.reducedNow && mix.opts.maxDt === undefined;
+    return fixed ? 'exact' : 'stepped';
+}
 /** A voice's patch kept state on a record: it is stateful from now on. */
 export function stateful(mix, voice) {
     if (voice.keeping)
         return;
     voice.keeping = true;
+    // The call that kept state was for the subject last sent to, whose record the state is on.
+    if (voice.sharing)
+        unshare(mix, voice, true, mix.sending.subject);
     mix.lanes?.invalidate();
 }
 export function handle(mix, voice) {
@@ -153,16 +185,28 @@ function handleHost(mix) {
         },
         changed: (voice) => {
             mix.frame = nextFrame();
+            reorigin(mix, voice, mix.now);
+            if (voice.holding !== null)
+                descendants(voice, (v) => reorigin(mix, v, mix.now));
             noted(mix, voice);
             mix.lanes?.refill();
         },
         // A delta read before an owner's seek, or a hit booked, is not taken as standing after it.
-        sought: (voice) => {
+        sought: (voice, rebuild) => {
+            if (rebuild)
+                voice.rebuilds++;
+            let doubt = seekDoubt(mix, voice, rebuild);
             if (voice.holding !== null)
                 descendants(voice, (v) => {
                     v.seeks++;
+                    if (rebuild)
+                        v.rebuilds++;
+                    const d = seekDoubt(mix, v, rebuild);
+                    if (RANK[d] > RANK[doubt])
+                        doubt = d;
                     schedule(mix, v);
                 });
+            return doubt;
         },
         fade: (voice, opts) => {
             if (voice.holding !== null && opts !== undefined && ('subject' in opts || opts.at === 'rest'))
@@ -180,11 +224,14 @@ function handleHost(mix) {
                 return 0;
             if (voice.holding !== null)
                 return ownWeight(voice, mix.now, mix.reducedNow, (o) => mix.ownerBase(o, subject));
+            const slot = mix.lanes === null ? -1 : (mix.chains.get(subject)?.slot ?? -1);
             if (voice.laned && mix.lanes !== null) {
-                const w = mix.lanes.weightOf(voice.id, mix.chains.get(subject)?.slot ?? -1);
+                const w = mix.lanes.weightOf(voice.id, slot);
                 if (w !== undefined)
                     return w;
             }
+            if (voice.sharing)
+                return weightAt(voice, slot);
             return voice.subjects.get(subject)?.weight ?? 0;
         },
         record: (label, again) => record(mix, label, again),

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-export type { NumberOptions } from './channels.js';
+export type { NumberOptions, 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 { color, css, 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';
@@ -10,8 +10,13 @@ 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 { AngleOptions } from './rotation.js';
+export { angle, quat } from './rotation.js';
+export { gate, input, lag, level, peak, slew } from './signals.js';
+export { fold } from './stack.js';
 export type { Ticked, Ticker, TickerOptions } from './ticker.js';
 export { ticker } from './ticker.js';
 export { transport } from './transport.js';
-export type { Anchor, BookedHit, Booker, BookOptions, Channel, Columns, Described, Doubt, Easing, Engine, FadeOptions, FadeSpec, FitResult, Handle, HistoryOptions, HistoryStore, Hit, Keyframe, Kit, Mark, Marked, Mix, MixOptions, MotionSpec, OwnerSpec, Paged, PagedStream, Patch, Placement, Projection, Query, Sent, Setting, Signal, SpanHandle, SpanHints, SpanSpec, Tape, TapeBranch, TapeMaker, TapeOp, Transport, TransportOptions, TransportProjection, VoiceSpec, } from './types.js';
+export type { Anchor, BookedHit, Booker, BookOptions, Channel, Columns, Described, Doubt, Easing, Engine, FadeOptions, FadeSpec, FitResult, Handle, HistoryOptions, HistoryStore, Hit, Keyframe, Kit, Mark, Marked, Mix, MixOptions, MotionSpec, OwnerSpec, Paged, PagedStream, Patch, Placement, Projection, Query, SeekOptions, Sent, Setting, Signal, SpanHandle, SpanHints, SpanSpec, Tape, TapeBranch, TapeMaker, TapeOp, Transport, TransportOptions, TransportProjection, VoiceSpec, } from './types.js';
+export type { WaveOptions, WaveShape } from './wave.js';
+export { wave, waveAt } from './wave.js';

package/dist/index.js

@@ -1,10 +1,13 @@
 export { kit, last, max, mul, sum, vec } from './channels.js';
-export { color, css, hex, mixHex, oklab, toHex } from './color.js';
+export { color, css, 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 { angle, quat } from './rotation.js';
+export { gate, input, lag, level, peak, slew } from './signals.js';
+export { fold } from './stack.js';
 export { ticker } from './ticker.js';
 export { transport } from './transport.js';
+export { wave, waveAt } from './wave.js';

package/dist/keyfill.d.ts

@@ -0,0 +1,7 @@
+import { type Lane } from './lane.js';
+import type { Lanes } from './lanes.js';
+/**
+ * A keys voice's fill outside a locus, its weight a number: what `one` does for each subject, in
+ * one loop, so no weight or time crosses a call as a boxed double per subject.
+ */
+export declare function runKeys<I, O>(lanes: Lanes<I, O>, lane: Lane<I, O>): void;

package/dist/keyfill.js

@@ -0,0 +1,124 @@
+import { foldNumber } from './channels.js';
+import { clampWeight, frozenTime, phaseAt, same, weighed } from './clock.js';
+import { shortWay } from './turns.js';
+/**
+ * A keys voice's fill outside a locus, its weight a number: what `one` does for each subject, in
+ * one loop, so no weight or time crosses a call as a boxed double per subject.
+ */
+export function runKeys(lanes, lane) {
+    const voice = lane.voice;
+    const data = lane.data;
+    const per = lanes.per;
+    const list = lane.list;
+    const records = lane.records;
+    const chans = lane.chans;
+    const read = lane.values;
+    const n = chans.length;
+    const fills = lanes.fills;
+    const lately = lanes.lately;
+    const elapsedNow = voice.elapsedAt(lanes.now);
+    const duration = voice.duration;
+    const passes = voice.passes;
+    const before = voice.freezesBefore;
+    const after = voice.freezesAfter;
+    const span = voice.span;
+    const flat = lane.flat;
+    const parts = voice.parts !== null;
+    const whole = clampWeight(voice.weight);
+    let width = 0;
+    for (let i = 0; i < n; i++)
+        width += chans[i].axes;
+    if (lane.nums.length < width)
+        lane.nums = new Float64Array(width);
+    if (lane.kinds.length < n)
+        lane.kinds = new Uint8Array(n);
+    const nums = lane.nums;
+    const kinds = lane.kinds;
+    for (let p = 0; p < list.length; p++) {
+        const slot = list[p];
+        const o = p * 8 /* Row.STRIDE */;
+        if (per[slot * 6 /* Per.SLOT */ + 5 /* Per.LANE_FILL */] === fills - 1)
+            data[o + 3 /* Row.PROBED */] = data[o + 2 /* Row.WEIGHT */];
+        if (lately >= 0 && lanes.unread(slot))
+            continue;
+        const elapsed = frozenTime(elapsedNow - data[o + 0 /* Row.DELAY */], before, after, span);
+        if (!(elapsed >= 0)) {
+            data[o + 2 /* Row.WEIGHT */] = 0;
+            continue;
+        }
+        if (!flat) {
+            const since = data[o + 1 /* Row.SINCE */];
+            if (!lane.weighed || !same(since, lane.weighedSince)) {
+                lane.fade = lanes.host.envelope(voice, since);
+                lane.weighed = true;
+                lane.weighedSince = since;
+            }
+        }
+        const w = flat && !parts ? whole : weighed(voice.weight, lane.fade, lanes.parting(voice, slot));
+        data[o + 2 /* Row.WEIGHT */] = w;
+        if (!lane.read || !same(elapsed, lane.readAt)) {
+            lanes.readKeyed(voice, phaseAt(elapsed, duration, passes), lane.delta, lane.scratch);
+            lane.read = true;
+            lane.readAt = elapsed;
+            lanes.gather(lane, lane.delta);
+            flatten(chans, read, nums, kinds);
+        }
+        if (!(w > 0))
+            continue;
+        let k = 0;
+        for (let i = 0; i < n; i++) {
+            const ch = chans[i];
+            const axes = ch.axes;
+            const kind = kinds[i];
+            if (kind === 1 /* Kind.NUMBERS */) {
+                const values = ch.values;
+                const base = slot * axes;
+                for (let a = 0; a < axes; a++)
+                    values[base + a] = foldNumber(ch.op, values[base + a], nums[k + a], w);
+            }
+            else if (kind === 2 /* Kind.GATED */) {
+                lanes.folding = lane;
+                lanes.rec = records[p] ?? null;
+                lanes.arg[0 /* Arg.WEIGHT */] = w;
+                lanes.foldInto(ch, slot, read[i]);
+            }
+            k += axes;
+        }
+    }
+}
+/**
+ * A keys read's values as the numbers `foldInto` would fold, an array read past its end as the rest:
+ * read here once per read, since reading a number out of a delta's array for each subject boxes it.
+ */
+function flatten(chans, read, nums, kinds) {
+    let k = 0;
+    for (let i = 0; i < chans.length; i++) {
+        const ch = chans[i];
+        const value = read[i];
+        if (value === undefined)
+            kinds[i] = 0 /* Kind.ABSENT */;
+        else if (!ch.plain)
+            kinds[i] = unplain(ch, value, nums, k);
+        else {
+            kinds[i] = 1 /* Kind.NUMBERS */;
+            if (ch.scalar)
+                nums[k] = value;
+            else {
+                const arr = Array.isArray(value) || ArrayBuffer.isView(value) ? value : null;
+                for (let a = 0; a < ch.axes; a++)
+                    nums[k + a] = arr === null ? ch.rest : (arr[a] ?? ch.rest);
+            }
+        }
+        k += ch.axes;
+    }
+}
+/**
+ * `flatten` for a channel that is not plain. An angle's number is taken the short way round here,
+ * and then folds as the sum it is; a rest-less channel and a quat fold through `foldInto`.
+ */
+function unplain(ch, value, nums, k) {
+    if (!(ch.turn > 0))
+        return 2 /* Kind.GATED */;
+    nums[k] = shortWay(value, ch.turn);
+    return 1 /* Kind.NUMBERS */;
+}

package/dist/keyrows.d.ts

@@ -5,6 +5,7 @@ import { type Built } from './patch.js';
 export interface KeyChannel {
     scalar: boolean;
     op: Numeric['op'];
+    plain: boolean;
     rest: number;
     axes: number;
     values: Float64Array;

package/dist/keyrows.js

@@ -23,7 +23,7 @@ export class KeyRows {
         for (let i = 0; i < built.tracks.length; i++) {
             const track = built.tracks[i];
             const ch = chans[i];
-            if (track === undefined || ch === undefined)
+            if (track === undefined || ch === undefined || !ch.plain)
                 return -1;
             for (const pt of track.all)
                 if (!flat(pt.value, ch))

package/dist/lane.d.ts

@@ -1,6 +1,7 @@
 import type { Numeric } from './channels.js';
 import type { Motions } from './motions.js';
 import type { Scratch } from './patch.js';
+import type { Channel } from './types.js';
 import type { Subject, Voice } from './voice.js';
 /** One laned channel: its arithmetic, and every numbered subject's folded value, `axes` per subject. */
 export interface Laned {
@@ -8,6 +9,12 @@ export interface Laned {
     /** Its value is a number, its rest a number; otherwise an array, which `vec(1)` is too. */
     scalar: boolean;
     op: Numeric['op'];
+    /** Its values fold as its `op` alone: not through a band as `'last'` does, and not a rotation. */
+    plain: boolean;
+    /** An angle's full turn, and 0 for any other channel. */
+    turn: number;
+    /** The channel, whose own `fold` and `lerp` an `'own'` lane calls. */
+    channel: Channel<unknown>;
     rest: number;
     axes: number;
     values: Float64Array;
@@ -56,6 +63,24 @@ export declare const enum Begin {
     GENERAL = 0,
     READY = 1
 }
+/**
+ * Where each number a fill hands from one of its methods to the next sits in `Lanes.arg`. Passed as
+ * an argument, a double is boxed wherever V8 does not inline the call: 16 bytes a number a subject
+ * (bench/allocs.mjs, 2026-10-09). The caller writes them just before the call, and the callee reads
+ * them before it calls anything else.
+ */
+export declare const enum Arg {
+    /** The weight to fold at. */
+    WEIGHT = 0,
+    /** The subject's voice time, its freezes applied. */
+    ELAPSED = 1,
+    PHASE = 2,
+    PASS = 3,
+    DELAY = 4,
+    /** The voice's own fade, for `signalled`. */
+    FADE = 5,
+    SIZE = 6
+}
 /** Where each of a subject's `SLOT` numbers in `Lanes.per` sits. */
 export declare const enum Per {
     SLOT = 6,
@@ -98,8 +123,8 @@ export interface Paced {
     data: Float64Array;
 }
 /**
- * Where a motion voice's per-subject numbers live, by position: a lane of one voice, or the crowd
- * of single-subject motion voices, whose positions each belong to a voice of their own.
+ * Where a motion voice's per-subject numbers live, by position: a lane of one voice, or a crowd
+ * of single-subject voices, whose positions each belong to a voice of their own.
  */
 export interface Positions<I, O> {
     /** `STRIDE` numbers per position. */
@@ -164,6 +189,9 @@ export declare class Lane<I, O> implements Positions<I, O> {
     chans: Laned[];
     /** The value read for each of `chans`, for the subject being folded. */
     values: unknown[];
+    /** A keys read's `values` as numbers, each channel's axes side by side, and how each folds. */
+    nums: Float64Array<ArrayBuffer>;
+    kinds: Uint8Array<ArrayBuffer>;
     /**
      * Within one fill, the last elapsed placed and the last `since` weighed, with what they gave, so
      * subjects sharing a delay or a start share the arithmetic: the same inputs give the same bits.
@@ -179,6 +207,8 @@ export declare class Lane<I, O> implements Positions<I, O> {
     fade: number;
     /** Whether the voice has no fade in or out this fill, so its envelope is 1 for every subject. */
     flat: boolean;
+    /** The voice's clock at this fill, set before `one` runs its subjects. */
+    elapsedNow: number;
     /** A motion patch's state, which the lane samples in place of calling the patch. */
     readonly motion: Motions<I> | undefined;
     /** By the motion patch's number for a subject, its position plus one, 0 where it has none. */

package/dist/lane.js

@@ -52,6 +52,9 @@ export class Lane {
     chans = [];
     /** The value read for each of `chans`, for the subject being folded. */
     values = [];
+    /** A keys read's `values` as numbers, each channel's axes side by side, and how each folds. */
+    nums = new Float64Array(0);
+    kinds = new Uint8Array(0);
     /**
      * Within one fill, the last elapsed placed and the last `since` weighed, with what they gave, so
      * subjects sharing a delay or a start share the arithmetic: the same inputs give the same bits.
@@ -67,6 +70,8 @@ export class Lane {
     fade = 1;
     /** Whether the voice has no fade in or out this fill, so its envelope is 1 for every subject. */
     flat = false;
+    /** The voice's clock at this fill, set before `one` runs its subjects. */
+    elapsedNow = 0;
     /** A motion patch's state, which the lane samples in place of calling the patch. */
     motion;
     /** By the motion patch's number for a subject, its position plus one, 0 where it has none. */