@msb235/blits 0.7.0 → 0.8.0

package/dist/hosts.js

@@ -2,14 +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) {
@@ -51,13 +55,16 @@ 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);
-            for (const voice of mix.gone)
+                if (voice.sighted !== null)
+                    unsight(voice, slot);
+            }
+            for (const voice of goneIndex(mix).general)
                 unreach(voice, slot, false);
         },
         passes: (was, w) => mix.passes(was, w),
@@ -109,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)
@@ -125,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) {
@@ -152,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'))
@@ -179,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. */

package/dist/lanes.d.ts

@@ -1,10 +1,11 @@
 import type { Column } from './columns.js';
+import { copy } from './copyout.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, gate, gather } from './gather.js';
+import { call, foldKeys, one, parting, readKeyed, reset, run, runEveryone, signalled, subjectAt } from './fill.js';
+import { fold, foldDelta, foldInto, foldRun, gate, gather, unplain } from './gather.js';
 import { type Lane, type Laned, type Locus } from './lane.js';
 import type { Watcher } from './motions.js';
-import { type absent, Numbers } from './numbers.js';
+import { absent, Numbers } from './numbers.js';
 import { Owed } from './owed.js';
 import type { Channel } from './types.js';
 import type { Subject, Voice } from './voice.js';
@@ -61,7 +62,7 @@ export declare class Lanes<I, O> implements Watcher {
     /** The lanes over every subject that have started playing, by epoch. */
     dense: Lane<I, O>[];
     readonly byId: Map<number, Lane<I, O>>;
-    /** The crowds of single-subject motion voices, one per channel, and which holds each voice. */
+    /** The crowds of single-subject voices, one per list of channels, and which holds each voice. */
     crowds: Crowd<I, O>[];
     readonly crowdOf: Map<number, Crowd<I, O>>;
     /** Whether two crowds share a channel, so their rows must interleave in voice order. */
@@ -71,13 +72,20 @@ export declare class Lanes<I, O> implements Watcher {
     /** The lane and record `one` is folding, whose band state a rest-less channel reads. */
     folding: Lane<I, O> | null;
     rec: Subject<unknown> | null;
+    /** The numbers a fill's methods hand each other: see `Arg`. */
+    readonly arg: Float64Array<ArrayBuffer>;
     /** While a fill gathers a locus: that locus and the member gathering, where folds go instead. */
     into: Locus<I, O> | null;
     intoId: number;
     readonly lawsByKey: Map<string, Float64Array<ArrayBufferLike>>;
     lastLaw: Float64Array | null;
-    /** The lanes the last `meet` gave a position, and whether it placed a crowd row. */
+    /**
+     * The lanes the last `meet` gave a position, the first `metN` of `met`, and whether it placed a
+     * crowd row. Counted, not cut to length: an array emptied by its length takes new room at its
+     * next push, about 150 B a subject met (the `swap` row, bench/allocs.mjs, 2026-10-09).
+     */
     readonly met: number[];
+    metN: number;
     metCrowd: boolean;
     /** By subject number, the laned voices its probes fold on the general path this fill. */
     readonly owed: Owed;
@@ -137,8 +145,9 @@ export declare class Lanes<I, O> implements Watcher {
     keeps: boolean;
     now: number;
     filledAt: number;
-    /** `reading.moved` at the last fill, so a retarget or push between two probes refills. */
+    /** `reading.moved` and `reading.inputs` at the last fill: see `current`. */
     moved: number;
+    inputs: number;
     /** The `now` of the latest probe, and the probe count before its first, to tell a probe this frame. */
     frameAt: number;
     frameProbes: number;
@@ -191,6 +200,13 @@ export declare class Lanes<I, O> implements Watcher {
     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;
+    /**
+     * Whether the last fill still stands: everything a fill reads that can change between two probes,
+     * each stamped by `fillAll`. The clock; the mix's version, which voices coming, going, starting
+     * and stopping move; a motion's retargets and pushes; and a `level` set. Whatever else can change
+     * between probes keeps its voice off lanes in `fits`.
+     */
+    current(now: number, version: number): boolean;
     /**
      * What a probe does before its subject, once a frame's lanes are settled: qualifies and fills as
      * needed. Says whether the subject takes the general path or the lanes are filled.
@@ -215,8 +231,6 @@ export declare class Lanes<I, O> implements Watcher {
      * would write: each number within 1e-9 of its rest.
      */
     rests(slot: number): boolean;
-    /** Writes a subject's laned values into a pose, each array channel into a new array. */
-    copy(slot: number, pose: Record<string, unknown>): void;
     forget(slot: number): void;
     grow(size: number): void;
     /**
@@ -224,16 +238,25 @@ export declare class Lanes<I, O> implements Watcher {
      * next fill, and a lane keeps the sample the old one gave.
      */
     stretchChanged(id: number, s: number): void;
+    /**
+     * A voice that kept one record for every subject keeps one each from now on: each of its lane's
+     * positions takes the record `of` gives its subject.
+     */
+    rerecord(id: number, of: (subject: I, slot: number) => Subject<unknown>): void;
+    /** A voice's clock moved the `shown` of records it had already placed: copies them again. */
+    reshown(id: number): void;
     /** Something on a voice changed: a crowd copies it again at the next fill. */
     voiceChanged(id: number): void;
 }
 declare const methods: {
+    copy: typeof copy;
     row: typeof row;
     signalled: typeof signalled;
     parting: typeof parting;
     subjectAt: typeof subjectAt;
     reset: typeof reset;
     run: typeof run;
+    runEveryone: typeof runEveryone;
     one: typeof one;
     foldKeys: typeof foldKeys;
     readKeyed: typeof readKeyed;
@@ -244,6 +267,7 @@ declare const methods: {
     foldRun: typeof foldRun;
     foldInto: typeof foldInto;
     gate: typeof gate;
+    unplain: typeof unplain;
 };
 type Methods = typeof methods;
 export interface Lanes<I, O> extends Methods {