@msb235/blits 0.4.0 → 0.5.0

package/dist/pace.d.ts

@@ -0,0 +1,40 @@
+import { type Clock } from './clock.js';
+/**
+ * A mix's own rate, as a clock: mix time as a function of host time, which here means the host's
+ * timestamp less what `rebase` took out. Each entry is the clock from the host time it took effect,
+ * oldest first, and the last is in force; under `history` the entries a read back may reach are
+ * kept, and without it only the last. Entries are never changed once logged, so a copy of the log
+ * stays as it was.
+ */
+export declare class Pace {
+    private readonly keeps;
+    private log;
+    constructor(keeps: boolean, log?: Clock[]);
+    private get clock();
+    /** Set before the first sync, the clock waits to be anchored there, reading host time until then. */
+    private get waiting();
+    /** Mix time at host time `u`, anchoring a clock set before the first sync there. */
+    sync(u: number): number;
+    /** What the mix clock reads at host time `u`, by the clock in force then. */
+    reading(u: number): number;
+    /**
+     * The mix time of something pinned to host time `u`, seen from host time `now`: what the clock
+     * will read there, or Infinity where `u` lies ahead and the clock stands still before it, since
+     * the moment the mix reaches is then not `u`'s alone.
+     */
+    at(u: number, now: number): number;
+    /** The earliest host time the mix clock reads `t`; Infinity where it never will. */
+    timeOf(t: number): number;
+    /** The rate at host time `u`; before the first sync, the rate the first frame starts at. */
+    rateAt(u: number): number;
+    /** Whether the mix clock stands still from host time `u` on, short of another change. */
+    stopped(u: number): boolean;
+    /**
+     * Sets the rate from host time `u`, at once or over `over` host ms, the way a handle sets a
+     * voice's. Under history, lets go of the entries a read no longer reaches: those over before mix
+     * time `reach`.
+     */
+    change(u: number, rate: number, over: number, reach: number): void;
+    /** A copy holding the clocks that took effect before host time `u`, for a read back to then. */
+    until(u: number): Pace;
+}

package/dist/pace.js

@@ -0,0 +1,113 @@
+import { elapsedWith, rateWith, retime, timeWith } from './clock.js';
+/**
+ * A mix's own rate, as a clock: mix time as a function of host time, which here means the host's
+ * timestamp less what `rebase` took out. Each entry is the clock from the host time it took effect,
+ * oldest first, and the last is in force; under `history` the entries a read back may reach are
+ * kept, and without it only the last. Entries are never changed once logged, so a copy of the log
+ * stays as it was.
+ */
+export class Pace {
+    keeps;
+    log;
+    constructor(keeps, log = [{ anchorNow: 0, anchorElapsed: 0, rate: 1, ramp: null }]) {
+        this.keeps = keeps;
+        this.log = log;
+    }
+    get clock() {
+        return this.log[this.log.length - 1];
+    }
+    /** Set before the first sync, the clock waits to be anchored there, reading host time until then. */
+    get waiting() {
+        return Number.isNaN(this.clock.anchorNow);
+    }
+    /** Mix time at host time `u`, anchoring a clock set before the first sync there. */
+    sync(u) {
+        if (this.waiting)
+            this.log = [{ ...this.clock, anchorNow: u, anchorElapsed: u }];
+        return this.reading(u);
+    }
+    /** What the mix clock reads at host time `u`, by the clock in force then. */
+    reading(u) {
+        if (this.waiting)
+            return u;
+        const log = this.log;
+        let i = log.length - 1;
+        while (i > 0 && log[i].anchorNow > u)
+            i--;
+        return elapsedWith(log[i], u);
+    }
+    /**
+     * The mix time of something pinned to host time `u`, seen from host time `now`: what the clock
+     * will read there, or Infinity where `u` lies ahead and the clock stands still before it, since
+     * the moment the mix reaches is then not `u`'s alone.
+     */
+    at(u, now) {
+        if (!(u > now) || this.waiting)
+            return this.reading(u);
+        const c = this.clock;
+        const r = c.ramp;
+        const still = r === null ? c.rate <= 0 : r.to <= 0 && u > c.anchorNow + r.over;
+        return still ? Number.POSITIVE_INFINITY : elapsedWith(c, u);
+    }
+    /** The earliest host time the mix clock reads `t`; Infinity where it never will. */
+    timeOf(t) {
+        if (this.waiting)
+            return t;
+        const log = this.log;
+        let i = 0;
+        while (i + 1 < log.length && t > log[i + 1].anchorElapsed)
+            i++;
+        return timeWith(log[i], t);
+    }
+    /** The rate at host time `u`; before the first sync, the rate the first frame starts at. */
+    rateAt(u) {
+        const c = this.clock;
+        if (this.waiting || Number.isNaN(u))
+            return c.ramp === null ? c.rate : c.ramp.from;
+        return rateWith(c, u);
+    }
+    /** Whether the mix clock stands still from host time `u` on, short of another change. */
+    stopped(u) {
+        const c = this.clock;
+        const r = c.ramp;
+        if (r === null)
+            return c.rate === 0;
+        return r.to === 0 && !this.waiting && u >= c.anchorNow + r.over;
+    }
+    /**
+     * Sets the rate from host time `u`, at once or over `over` host ms, the way a handle sets a
+     * voice's. Under history, lets go of the entries a read no longer reaches: those over before mix
+     * time `reach`.
+     */
+    change(u, rate, over, reach) {
+        const was = this.clock;
+        const next = { ...was };
+        if (Number.isNaN(u) || this.waiting) {
+            const from = this.rateAt(Number.NaN);
+            next.ramp = over > 0 && rate !== from ? { from, to: rate, over } : null;
+            next.rate = rate;
+            next.anchorNow = Number.NaN;
+            this.log = [next];
+            return;
+        }
+        retime(next, u, rate, over);
+        const log = this.log;
+        if (this.keeps && was.anchorNow < u)
+            log.push(next);
+        else
+            log[log.length - 1] = next;
+        let drop = 0;
+        while (drop + 1 < log.length && log[drop + 1].anchorElapsed <= reach)
+            drop++;
+        if (drop > 0)
+            log.splice(0, drop);
+    }
+    /** A copy holding the clocks that took effect before host time `u`, for a read back to then. */
+    until(u) {
+        const log = this.log;
+        let n = 1;
+        while (n < log.length && log[n].anchorNow < u)
+            n++;
+        return new Pace(this.keeps, log.slice(0, n));
+    }
+}

package/dist/patch.d.ts

@@ -2,11 +2,11 @@ import { type LerpInto } from './channels.js';
 import { type Curve } from './easing.js';
 import type { Channel, Easing, Keyframe, Kit, Patch, Setting } from './types.js';
 /**
- * What `patch` takes besides its period and its function.
+ * What `patch` takes besides its duration and its function.
  *
  * @category patch
  */
-export interface PatchOptions<I, O, S> {
+export interface PatchOptions<I, O, S, H = unknown> {
     /** The channels this patch contributes to. Every key `at` sets, and no others. Default: `kit`'s. */
     writes?: readonly (keyof O)[];
     /** The channels this patch was written against, which `cue` checks a mix's kit against. */
@@ -14,16 +14,16 @@ export interface PatchOptions<I, O, S> {
     /** The fields of `setting.host` this patch reads, which `cue` checks the mix's host for. */
     reads?: readonly string[];
     state?(subject: I): S;
-    step?(state: S, dt: number, subject: I, setting: Setting<S>): void;
+    step?(state: S, dt: number, subject: I, setting: Setting<S, H>): void;
 }
 /**
  * The procedural form. Flicker, roving, a hash walk, a starter strike.
  *
  * @category patch
  */
-export declare function patch<I, O, S = void>(period: number, at: (phase: number, subject: I, setting: Setting<S>) => Partial<O>, opts: PatchOptions<I, O, S>): Patch<I, O, S>;
+export declare function patch<I, O, S = void, H = unknown>(duration: number, at: (phase: number, subject: I, setting: Setting<S, H>) => Partial<O>, opts: PatchOptions<I, O, S, H>): Patch<I, O, S, H>;
 /**
- * What `keys` takes besides its period and its stops.
+ * What `keys` takes besides its duration and its stops.
  *
  * @category patch
  */
@@ -32,7 +32,7 @@ export interface KeysOptions<O> {
     ease?: Easing;
     /** A curve for one channel, where it differs from the rest. */
     easeBy?: (channel: keyof O) => Easing | undefined;
-    /** Milliseconds one channel waits before it starts moving, within the period. */
+    /** Milliseconds one channel waits before it starts moving, within the duration. */
     delayBy?: (channel: keyof O) => number;
     /**
      * How one channel interpolates, where it should differ from the channel's own `lerp`. A mix hands
@@ -52,19 +52,58 @@ interface Point {
 }
 type Lerp = (a: never, b: never, u: number) => unknown;
 /** One channel of a stop list, sorted and resolved once, so a read is a binary search. */
-interface Track {
+export interface Track {
     channel: string;
     /** Every stop carrying this channel, by phase. */
     all: Point[];
     /** The same without stops at 0, which a `from: 'current'` base replaces. */
     tail: Point[];
+    /** The phases of `all`, which the search reads, and of `tail`, made on its first search. */
+    ats: number[];
+    tailAts: number[] | null;
     delay: number;
     lerp: ((a: never, b: never, u: number) => unknown) | undefined;
 }
 export interface Built {
     tracks: Track[];
-    period: number;
+    duration: number;
 }
+/** What `segment` found: nothing to read, one value, or a segment to interpolate along. */
+export declare const NOTHING = 0;
+export declare const AT = 1;
+export declare const BETWEEN = 2;
+/**
+ * Where `segment` leaves a track's reading: the value, or the segment's two ends, how far along it
+ * is before and after its easing, whether it leaves `base`, its length and its easing. Read it
+ * before anything else reads a track.
+ */
+export declare const seg: {
+    a: unknown;
+    b: unknown;
+    u: number;
+    eased: number;
+    first: boolean;
+    len: number;
+    ease: Curve | undefined;
+};
+/** A track's phase once its channel's own delay applies. */
+export declare function shifted(track: Track, phase: number, duration: number): number;
+/** A phase once a channel's delay of `delay` ms in a duration of `duration` applies. */
+export declare function shift(delay: number, phase: number, duration: number): number;
+/**
+ * Where `phase` falls among `n` stop phases `ats[off + k * stride]`, in order: -2 for no stops, -1
+ * at or before the first, `n` at or past the last, and otherwise the first stop past it, where the
+ * segment from the one before ends. With `segment`'s, the one copy of the search.
+ */
+export declare function locate(ats: ArrayLike<number>, off: number, stride: number, n: number, phase: number): number;
+/** How far along a segment from phase `a` to `b` a phase is, before easing. */
+export declare function fraction(phase: number, a: number, b: number): number;
+/**
+ * Finds where one track is at a phase, into `seg`: the one copy of the search, which `read` and a
+ * lane folding stops straight into a subject's values both make. `base` stands in for the value at
+ * phase 0, which is how `from: 'current'` starts a voice wherever the subject already is.
+ */
+export declare function segment(track: Track, phase: number, base: unknown): number;
 /**
  * Arrays a reader lets keyed reads interpolate into, by track. Each only ever holds what a read made,
  * never a stop's or a base's, and a delta read through it is good until the next read through it.
@@ -83,14 +122,16 @@ export declare function intosOf(built: Built, channels: readonly Channel<unknown
 export declare function readKeys(built: Built, phase: number, out: Record<string, unknown>, base?: Record<string, unknown>, lerps?: readonly (Lerp | undefined)[], 
 /** Per channel, how fast a retargeted subject was moving, units per ms. */
 slopes?: Record<string, unknown>, intos?: readonly (LerpInto | undefined)[], scratch?: Scratch): Record<string, unknown>;
+/** A patch's `duration`, or the deprecated `period` where only that is set. */
+export declare const durationOf: <I, O, S>(p: Patch<I, O, S>) => number;
 /** The built form of a patch's stops, made on first ask for a patch `keys()` did not build. */
 export declare function builtOf<I, O, S>(p: Patch<I, O, S>): Built;
 /** Evaluates a stop list into a fresh delta. */
-export declare function evalKeys<O>(stops: readonly Keyframe<O>[], writes: readonly (keyof O)[], phase: number, period: number, opts: KeysOptions<O>, base?: Partial<O>): Partial<O>;
+export declare function evalKeys<O>(stops: readonly Keyframe<O>[], writes: readonly (keyof O)[], phase: number, duration: number, opts: KeysOptions<O>, base?: Partial<O>): Partial<O>;
 /**
  * The declarative form. klieg's transition sugar and wod's keyframes.
  *
  * @category patch
  */
-export declare function keys<I, O>(period: number, stops: readonly Keyframe<O>[], opts?: KeysOptions<O>): Patch<I, O, void>;
+export declare function keys<I, O>(duration: number, stops: readonly Keyframe<O>[], opts?: KeysOptions<O>): Patch<I, O, void>;
 export {};

package/dist/patch.js

@@ -5,13 +5,14 @@ import { curve } from './easing.js';
  *
  * @category patch
  */
-export function patch(period, at, opts) {
+export function patch(duration, at, opts) {
     const writes = opts.writes ?? (opts.kit ? Object.keys(opts.kit) : undefined);
     if (writes === undefined)
         throw new Error('blits: a patch needs writes, or a kit to take them from');
     return {
         form: 'fn',
-        period,
+        duration,
+        period: duration,
         writes,
         kit: opts.kit,
         reads: opts.reads,
@@ -37,7 +38,7 @@ function interpolate(a, b, u) {
     }
     return u < 0.5 ? a : b;
 }
-function build(stops, writes, period, opts) {
+function build(stops, writes, duration, opts) {
     const fallback = opts.ease === undefined ? undefined : curve(opts.ease);
     const tracks = [];
     for (const channel of writes) {
@@ -50,72 +51,165 @@ function build(stops, writes, period, opts) {
                 continue;
             all.push({
                 at: stop.at,
-                value,
+                // A copy, so every reader sees the stop as it was built: a lane may hold its numbers.
+                value: Array.isArray(value)
+                    ? [...value]
+                    : ArrayBuffer.isView(value)
+                        ? value.slice()
+                        : value,
                 ease: stop.ease === undefined ? trackEase : curve(stop.ease),
             });
         }
         all.sort((x, y) => x.at - y.at);
+        const tail = all.filter((pt) => pt.at !== 0);
         tracks.push({
             channel: channel,
             all,
-            tail: all.filter((pt) => pt.at !== 0),
+            tail,
+            ats: all.map((pt) => pt.at),
+            tailAts: null,
             delay: opts.delayBy?.(channel) ?? 0,
             lerp: opts.lerpBy?.(channel) ?? opts.kit?.[channel]?.lerp,
         });
     }
-    return { tracks, period };
+    return { tracks, duration };
 }
+/** What `segment` found: nothing to read, one value, or a segment to interpolate along. */
+export const NOTHING = 0;
+export const AT = 1;
+export const BETWEEN = 2;
 /**
- * Reads one track at a phase. `base` stands in for the value at phase 0, which is how
- * `from: 'current'` starts a voice wherever the subject already is.
+ * Where `segment` leaves a track's reading: the value, or the segment's two ends, how far along it
+ * is before and after its easing, whether it leaves `base`, its length and its easing. Read it
+ * before anything else reads a track.
  */
-function read(track, phase, base, lerp, 
-/** Units per ms, for a retarget's first segment. */
-slope, period, into, reuse) {
-    const pts = base === undefined ? track.all : track.tail;
-    const o = base === undefined ? 0 : 1;
-    const n = pts.length + o;
+export const seg = {
+    a: undefined,
+    b: undefined,
+    u: 0,
+    eased: 0,
+    first: false,
+    len: 0,
+    ease: undefined,
+};
+/** A track's phase once its channel's own delay applies. */
+export function shifted(track, phase, duration) {
+    return shift(track.delay, phase, duration);
+}
+/** A phase once a channel's delay of `delay` ms in a duration of `duration` applies. */
+export function shift(delay, phase, duration) {
+    return delay === 0 || duration === 0 ? phase : Math.max(0, (phase * duration - delay) / duration);
+}
+/**
+ * Where `phase` falls among `n` stop phases `ats[off + k * stride]`, in order: -2 for no stops, -1
+ * at or before the first, `n` at or past the last, and otherwise the first stop past it, where the
+ * segment from the one before ends. With `segment`'s, the one copy of the search.
+ */
+export function locate(ats, off, stride, n, phase) {
     if (n === 0)
-        return undefined;
-    const firstAt = o === 1 ? 0 : pts[0].at;
-    if (phase <= firstAt)
-        return o === 1 ? base : pts[0].value;
-    const last = pts[pts.length - 1];
-    if (last === undefined || phase >= last.at)
-        return last === undefined ? base : last.value;
-    // The first point at or past phase; the segment ends there.
-    let lo = 1;
-    let hi = n - 1;
+        return -2;
+    if (phase <= ats[off])
+        return -1;
+    if (phase >= ats[off + (n - 1) * stride])
+        return n;
+    return firstPast(ats, off, stride, 1, n - 1, phase);
+}
+/** The first of stops `lo` to `hi` whose phase is at or past `phase`, the last known to be. */
+function firstPast(ats, off, stride, lo, hi, phase) {
     while (lo < hi) {
         const mid = (lo + hi) >> 1;
-        if (pts[mid - o].at >= phase)
+        if (ats[off + mid * stride] >= phase)
             hi = mid;
         else
             lo = mid + 1;
     }
+    return lo;
+}
+/** How far along a segment from phase `a` to `b` a phase is, before easing. */
+export function fraction(phase, a, b) {
+    return (phase - a) / (b - a);
+}
+/**
+ * Finds where one track is at a phase, into `seg`: the one copy of the search, which `read` and a
+ * lane folding stops straight into a subject's values both make. `base` stands in for the value at
+ * phase 0, which is how `from: 'current'` starts a voice wherever the subject already is.
+ */
+export function segment(track, phase, base) {
+    let lo;
+    const o = base === undefined ? 0 : 1;
+    const pts = o === 0 ? track.all : track.tail;
+    if (o === 0) {
+        const n = pts.length;
+        lo = locate(track.ats, 0, 1, n, phase);
+        if (lo === -2)
+            return NOTHING;
+        if (lo === -1 || lo === n) {
+            seg.a = pts[lo === -1 ? 0 : n - 1].value;
+            return AT;
+        }
+    }
+    else {
+        // Stop 0 is `base`, at phase 0, and stop k is the tail's k - 1.
+        const n = pts.length + 1;
+        if (phase <= 0) {
+            seg.a = base;
+            return AT;
+        }
+        const last = pts[pts.length - 1];
+        if (last === undefined || phase >= last.at) {
+            seg.a = last === undefined ? base : last.value;
+            return AT;
+        }
+        track.tailAts ??= pts.map((pt) => pt.at);
+        lo = firstPast(track.tailAts, -1, 1, 1, n - 1, phase);
+    }
     const b = pts[lo - o];
     const aAt = lo - 1 < o ? 0 : pts[lo - 1 - o].at;
-    const aValue = lo - 1 < o ? base : pts[lo - 1 - o].value;
-    const u = (phase - aAt) / (b.at - aAt);
+    const u = fraction(phase, aAt, b.at);
+    // Before any of `seg` is written, so an easing that reads stops itself cannot overwrite it.
     const eased = b.ease ? b.ease(u) : u;
+    seg.a = lo - 1 < o ? base : pts[lo - 1 - o].value;
+    seg.b = b.value;
+    seg.u = u;
+    seg.eased = eased;
+    seg.first = lo - 1 < o;
+    seg.len = b.at - aAt;
+    seg.ease = b.ease;
+    return BETWEEN;
+}
+/** Reads one track at a phase; `base` as `segment` takes it. */
+function read(track, phase, base, lerp, 
+/** Units per ms, for a retarget's first segment. */
+slope, duration, into, reuse) {
+    const found = segment(track, phase, base);
+    if (found === NOTHING)
+        return undefined;
+    if (found === AT)
+        return seg.a;
+    const aValue = seg.a;
+    const bValue = seg.b;
+    const u = seg.u;
+    const eased = seg.eased;
+    const first = seg.first;
+    const len = seg.len;
+    const ease = seg.ease;
     let value;
     if (into !== undefined) {
-        value = into(reuse, aValue, b.value, eased);
+        value = into(reuse, aValue, bValue, eased);
         lastRead.wrote = value;
     }
     else {
         const by = track.lerp ?? lerp;
-        value = by ? by(aValue, b.value, eased) : interpolate(aValue, b.value, eased);
+        value = by ? by(aValue, bValue, eased) : interpolate(aValue, bValue, eased);
     }
     // Leaving a retarget's base, bend the first segment so it starts at the slope the subject had:
     // add c·u(1−u)², which is 0 at both ends, flat at the end, and fixes the slope at the start.
-    if (slope === undefined || lo - 1 >= o)
+    if (slope === undefined || !first)
         return value;
-    const len = b.at - aAt;
-    const e0 = b.ease ? b.ease(1e-6) / 1e-6 : 1;
-    const bend = (s, a, z) => (s * period * len - (z - a) * e0) * u * (1 - u) * (1 - u);
+    const e0 = ease ? ease(1e-6) / 1e-6 : 1;
+    const bend = (s, a, z) => (s * duration * len - (z - a) * e0) * u * (1 - u) * (1 - u);
     if (typeof value === 'number' && typeof slope === 'number')
-        return value + bend(slope, aValue, b.value);
+        return value + bend(slope, aValue, bValue);
     if (Array.isArray(value) && Array.isArray(slope)) {
         const out = value === lastRead.wrote ? value : new Array(value.length);
         for (let i = 0; i < value.length; i++) {
@@ -123,7 +217,7 @@ slope, period, into, reuse) {
             const s = slope[i];
             out[i] =
                 typeof v === 'number' && typeof s === 'number'
-                    ? v + bend(s, aValue[i], b.value[i])
+                    ? v + bend(s, aValue[i], bValue[i])
                     : v;
         }
         return out;
@@ -150,15 +244,13 @@ export function intosOf(built, channels) {
 export function readKeys(built, phase, out, base, lerps, 
 /** Per channel, how fast a retargeted subject was moving, units per ms. */
 slopes, intos, scratch) {
-    const period = built.period;
+    const duration = built.duration;
     for (let i = 0; i < built.tracks.length; i++) {
         const track = built.tracks[i];
-        const delay = track.delay;
-        const shifted = delay === 0 || period === 0 ? phase : Math.max(0, (phase * period - delay) / period);
         const perMs = slopes?.[track.channel];
         const into = scratch === undefined ? undefined : intos?.[i];
         lastRead.wrote = undefined;
-        const value = read(track, shifted, base?.[track.channel], lerps?.[i], period === 0 ? undefined : perMs, period, into, into === undefined ? undefined : scratch[i]);
+        const value = read(track, shifted(track, phase, duration), base?.[track.channel], lerps?.[i], duration === 0 ? undefined : perMs, duration, into, into === undefined ? undefined : scratch[i]);
         if (into !== undefined && value === lastRead.wrote)
             scratch[i] = value;
         if (value !== undefined)
@@ -168,31 +260,34 @@ slopes, intos, scratch) {
     }
     return out;
 }
+/** A patch's `duration`, or the deprecated `period` where only that is set. */
+export const durationOf = (p) => p.duration ?? p.period ?? 0;
 const cache = new WeakMap();
 /** The built form of a patch's stops, made on first ask for a patch `keys()` did not build. */
 export function builtOf(p) {
     let held = cache.get(p);
     if (held === undefined) {
-        held = build(p.keys, p.writes, p.period, keysOptionsOf(p) ?? {});
+        held = build(p.keys, p.writes, durationOf(p), keysOptionsOf(p) ?? {});
         cache.set(p, held);
     }
     return held;
 }
 /** Evaluates a stop list into a fresh delta. */
-export function evalKeys(stops, writes, phase, period, opts, base) {
-    return readKeys(build(stops, writes, period, opts), phase, {}, base);
+export function evalKeys(stops, writes, phase, duration, opts, base) {
+    return readKeys(build(stops, writes, duration, opts), phase, {}, base);
 }
 /**
  * The declarative form. klieg's transition sugar and wod's keyframes.
  *
  * @category patch
  */
-export function keys(period, stops, opts = {}) {
+export function keys(duration, stops, opts = {}) {
     const writes = [...new Set(stops.flatMap((s) => Object.keys(s.delta)))];
-    const made = build(stops, writes, period, opts);
+    const made = build(stops, writes, duration, opts);
     const p = {
         form: 'keys',
-        period,
+        duration,
+        period: duration,
         writes,
         kit: opts.kit,
         keys: stops,

package/dist/place.d.ts

@@ -0,0 +1,20 @@
+import type { Mixer } from './mixer.js';
+import type { Placement, VoiceSpec } from './types.js';
+import { type Voice } from './voice.js';
+/** What a voice's own owner's clock reads now: the mix clock for a voice no owner holds. */
+export declare function localNow<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): number;
+/** A voice's start as mix time. */
+export declare function startOf<I, O>(voice: Voice<I, O>): number;
+/** Mix time at host time `u`, for something pinned there; Infinity while the mix may never get there. */
+export declare function mixAt<I, O>(mix: Mixer<I, O>, u: number): number;
+export declare function pin<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, u: number): void;
+/** Puts each pending voice's start, given in host time, where the mix's rate now puts it. */
+export declare function repin<I, O>(mix: Mixer<I, O>): void;
+/** Refuses a placement that names a mark twice on one side, or that waits on itself. */
+export declare function checkPlacement<I, O>(mix: Mixer<I, O>, spec: VoiceSpec<I, O>, anchor: Placement, owner: Voice<I, O> | null): void;
+/**
+ * Fixes every anchored voice's start and out from what its anchors answer now. A start is fixed
+ * while the voice waits and an out until its fade begins; a target that has left keeps the time it
+ * last gave. Repeated so a chain of anchors settles in one sync.
+ */
+export declare function place<I, O>(mix: Mixer<I, O>): void;