@msb235/blits 0.4.0 → 0.5.0

package/dist/place.js

@@ -0,0 +1,196 @@
+import { noted } from './history.js';
+import { markOf } from './marks.js';
+import { mixTime, ownerReading } from './owner.js';
+import { none } from './voice.js';
+/** What a voice's own owner's clock reads now: the mix clock for a voice no owner holds. */
+export function localNow(mix, voice) {
+    return voice.owner === null ? mix.now : ownerReading(voice.owner, mix.now);
+}
+/** A voice's start as mix time. */
+export function startOf(voice) {
+    return voice.owner === null ? voice.start : mixTime(voice.owner, voice.start);
+}
+/** Mix time at host time `u`, for something pinned there; Infinity while the mix may never get there. */
+export function mixAt(mix, u) {
+    return mix.pace === null ? u : mix.pace.at(u, mix.u);
+}
+export function pin(mix, voice, u) {
+    mix.pins ??= new Map();
+    mix.pins.set(voice, u);
+}
+/** Puts each pending voice's start, given in host time, where the mix's rate now puts it. */
+export function repin(mix) {
+    const pins = mix.pins;
+    for (const [voice, u] of pins) {
+        if (voice.state !== 'pending')
+            pins.delete(voice);
+        else
+            startAt(mix, voice, mixAt(mix, u));
+    }
+}
+/** Moves a pending voice's start, its clock with it; false where it is already there. */
+function startAt(mix, voice, start) {
+    if (start === voice.start)
+        return false;
+    voice.start = start;
+    voice.anchorNow = start;
+    voice.anchorElapsed = 0;
+    noted(mix, voice);
+    return true;
+}
+/** Refuses a placement that names a mark twice on one side, or that waits on itself. */
+export function checkPlacement(mix, spec, anchor, owner) {
+    if (anchor.start !== undefined && anchor.in !== undefined)
+        throw new Error('blits: a placement anchors start or in, not both');
+    if (anchor.out !== undefined && anchor.end !== undefined)
+        throw new Error('blits: a placement anchors out or end, not both');
+    if (spec.start !== undefined && (anchor.start !== undefined || anchor.in !== undefined))
+        throw new Error('blits: a voice takes start or an anchored start, not both');
+    const name = spec.name;
+    if (name === undefined)
+        return;
+    // A voice is known by its owner, its score and its name; a bare name in an anchor is in the
+    // asker's score under the asker's owner.
+    const key = (o, score, n) => `${o?.id ?? 0}\u0000${score ?? ''}\u0000${n}`;
+    const names = (p, score, o) => [p.start, p.in, p.out, p.end].flatMap((a) => {
+        if (a === undefined || typeof a === 'number')
+            return [];
+        const q = 'of' in a ? a.of : 'after' in a ? a.after : 'with' in a ? a.with : a.before;
+        if (typeof q === 'string')
+            return [key(o, score, q)];
+        return q.name === undefined ? [] : [key(o, q.score ?? score, q.name)];
+    });
+    const self = key(owner, spec.score, name);
+    const seen = new Set();
+    const waits = names(anchor, spec.score, owner);
+    while (waits.length > 0) {
+        const n = waits.pop();
+        if (n === self)
+            throw new Error(`blits: ${name}'s placement waits on itself`);
+        if (seen.has(n))
+            continue;
+        seen.add(n);
+        for (const v of mix.cued)
+            if (v.spec.name !== undefined &&
+                key(v.owner, v.spec.score, v.spec.name) === n &&
+                v.spec.anchor)
+                waits.push(...names(v.spec.anchor, v.spec.score, v.owner));
+    }
+}
+/**
+ * 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 function place(mix) {
+    for (let round = 0; round <= mix.cued.length; round++) {
+        let moved = false;
+        for (const voice of mix.cued) {
+            const anchor = voice.spec.anchor;
+            if (anchor === undefined || voice.state === 'done')
+                continue;
+            if (voice.placing && voice.state === 'pending') {
+                const by = anchor.start ?? anchor.in;
+                const t = by === undefined ? undefined : resolve(mix, by, voice);
+                if (t !== undefined) {
+                    const o = voice.owner;
+                    const fadeIn = voice.fade.in ?? 0;
+                    const start = anchor.start !== undefined
+                        ? t
+                        : o === null
+                            ? t - fadeIn
+                            : ownerReading(o, mixTime(o, t) - fadeIn);
+                    if (Number.isFinite(start) && startAt(mix, voice, start))
+                        moved = true;
+                }
+            }
+            if (voice.state !== 'fading') {
+                const by = anchor.out ?? anchor.end;
+                const t = by === undefined ? undefined : resolve(mix, by, voice);
+                if (t !== undefined) {
+                    const m = voice.owner === null ? t : mixTime(voice.owner, t);
+                    const at = anchor.out !== undefined ? m : m - (voice.fade.out ?? 0);
+                    if (at !== voice.outAt) {
+                        voice.outAt = at;
+                        noted(mix, voice);
+                        moved = true;
+                    }
+                }
+            }
+        }
+        if (!moved)
+            return;
+    }
+}
+/** The time an anchor answers on its voice's owner's clock, or undefined while its target has none. */
+function resolve(mix, a, self) {
+    const o = self.owner;
+    if (typeof a === 'number')
+        return o === null ? mixAt(mix, a - mix.offset) : a;
+    let query;
+    let mark;
+    let by = a.by ?? 0;
+    if ('of' in a) {
+        query = a.of;
+        mark = a.mark;
+    }
+    else if ('after' in a) {
+        query = a.after;
+        mark = 'end';
+    }
+    else if ('with' in a) {
+        query = a.with;
+        mark = 'start';
+    }
+    else {
+        query = a.before;
+        mark = 'start';
+        by = -by;
+    }
+    const t = timeOf(mix, typeof query === 'string' ? { name: query } : query, mark, self);
+    if (t === undefined)
+        return undefined;
+    if (o === null)
+        return t + by;
+    const local = ownerReading(o, t);
+    return Number.isFinite(local) ? local + by : undefined;
+}
+/**
+ * The mix time a query answers: `mark` of the voice it picks, among those cued and those that have
+ * left, never the asker; or a mark the host announced on the score, which is the same time for
+ * any of the four. Undefined while what it picks has no such time. A query naming no score looks
+ * among the asker's siblings, the voices its owner holds.
+ */
+function timeOf(mix, q, mark, self) {
+    const score = q.score ?? self.spec.score;
+    const anywhere = q.score !== undefined;
+    const found = [];
+    for (const v of [...mix.gone, ...mix.cued])
+        if (v !== self &&
+            v.spec.score === score &&
+            (anywhere || v.owner === self.owner) &&
+            (q.name === undefined || v.spec.name === q.name) &&
+            (q.tag === undefined || (v.spec.tags ?? none).includes(q.tag)) &&
+            (q.writes === undefined || v.patch.writes.includes(q.writes)))
+            found.push({ order: v.id, t: markOf(mix, v, mark) });
+    if (q.writes === undefined && (anywhere || self.owner === null))
+        for (const a of mix.announced)
+            if (a.score === score &&
+                (q.name === undefined || a.name === q.name) &&
+                (q.tag === undefined || a.tags.includes(q.tag)))
+                found.push({ order: a.order, t: Number.isNaN(a.at) ? undefined : mixAt(mix, a.at) });
+    if (found.length === 0)
+        return undefined;
+    found.sort((x, y) => x.order - y.order);
+    const resolver = q.resolver ?? 'last';
+    if (resolver === 'first')
+        return found[0]?.t;
+    if (resolver === 'last')
+        return found[found.length - 1]?.t;
+    const times = found.flatMap((e) => (e.t === undefined ? [] : [e.t])).sort((x, y) => x - y);
+    if (resolver === 'next') {
+        const now = Number.isNaN(mix.now) ? Number.NEGATIVE_INFINITY : mix.now;
+        return times.find((t) => t >= now);
+    }
+    return resolver === 'earliest' ? times[0] : times[times.length - 1];
+}

package/dist/project.d.ts

@@ -0,0 +1,4 @@
+import type { Mixer } from './mixer.js';
+import type { Projection } from './types.js';
+/** A projection to `timestamp` through `c`, a mixer of its own the mix has just made. */
+export declare function project<I, O>(mix: Mixer<I, O>, c: Mixer<I, O>, timestamp: number): Projection<I, O>;

package/dist/project.js

@@ -0,0 +1,233 @@
+import { ownBlends } from './blend.js';
+import { index } from './chain.js';
+import { copyHeld, last } from './history.js';
+import { readingAt } from './marks.js';
+import { move } from './move.js';
+import { heldByInput, ownerReading, relink } from './owner.js';
+import { pin } from './place.js';
+import { reading } from './reading.js';
+import { Store } from './store.js';
+import { unreached } from './unreached.js';
+/** A projection to `timestamp` through `c`, a mixer of its own the mix has just made. */
+export function project(mix, c, timestamp) {
+    const u = timestamp - mix.offset;
+    const pace = mix.pace;
+    const t = readingAt(mix, u);
+    c.projecting = true;
+    c.pose = mix.pose;
+    c.offset = mix.offset;
+    c.u = u;
+    c.wantsPose = mix.wantsPose;
+    c.nextId = mix.nextId;
+    c.reducedNow = mix.reducedNow;
+    if (Number.isNaN(mix.now) || t >= mix.now) {
+        c.now = mix.now;
+        c.pace = pace === null ? null : pace.until(Number.POSITIVE_INFINITY);
+        c.cued = mix.cued
+            .filter((v) => v.state !== 'done')
+            .map((v) => {
+            const copy = v.copy((subject) => carry(mix, v, subject));
+            const at = mix.pins?.get(v);
+            if (at !== undefined)
+                pin(c, copy, at);
+            return copy;
+        });
+        ownBlends(c.cued);
+        if (mix.owners !== null)
+            relink(c.cued);
+        c.announced = mix.announced.map((a) => ({ ...a }));
+        count(c);
+        move(c, t);
+    }
+    else {
+        const history = mix.opts.history;
+        if (!history)
+            throw new Error('blits: reading back needs a mix made with history');
+        if (t < mix.now - history.ms)
+            throw new Error(`blits: ${timestamp} is older than this mix's history reaches`);
+        c.now = t;
+        c.pace = pace === null ? null : pace.until(u);
+        c.backward = true;
+        const was = last(mix.hostLog, t, true);
+        const host = mix.opts.host;
+        const then = was && typeof host === 'object' && host !== null
+            ? Object.assign(Object.create(host), was.fields)
+            : undefined;
+        if (was)
+            c.hostThen = was;
+        c.announced = mix.announced.filter((a) => a.made < t).map((a) => ({ ...a }));
+        c.cued = [...mix.cued, ...mix.gone]
+            .filter((v) => v.cuedAt <= t && v.doneAt > t)
+            .sort((a, b) => a.id - b.id)
+            .map((v) => {
+            const log = v.log;
+            const copy = v.copy((subject) => recall(mix, v, subject, t), last(log, t, (e) => e.sync) ?? log[0]);
+            if (then !== undefined)
+                copy.setting.host = then;
+            return copy;
+        });
+        ownBlends(c.cued);
+        if (mix.owners !== null)
+            relink(c.cued);
+        for (const copy of c.cued)
+            copy.state =
+                (copy.owner === null ? t : ownerReading(copy.owner, t)) < copy.start
+                    ? 'pending'
+                    : copy.out && copy.out.at <= t
+                        ? 'fading'
+                        : copy.holdsAfter && copy.elapsedAt(t) >= copy.span + copy.latest
+                            ? 'held'
+                            : 'live';
+        count(c);
+    }
+    const read = (f) => {
+        reading.live = false;
+        try {
+            return f();
+        }
+        finally {
+            reading.live = true;
+        }
+    };
+    return {
+        timestamp,
+        probe: (subject, out) => read(() => c.fold(subject, out)),
+        assess: (subject) => read(() => {
+            c.fold(subject);
+            return doubts(c, subject);
+        }),
+    };
+}
+/** Recounts what the fold's shortcuts depend on, for a projection's freshly copied voices. */
+function count(mix) {
+    mix.named = new Store();
+    mix.naming = 0;
+    mix.general = [];
+    for (const voice of mix.cued)
+        index(mix, voice);
+    mix.loci = mix.cued.filter((v) => v.spec.locus !== undefined).length;
+    mix.anchored = mix.cued.filter((v) => v.spec.anchor !== undefined).length;
+    mix.steps.push(null, ++mix.version);
+}
+/** A voice's record of a subject, the one it shares among those it does not reach included. */
+function recordOf(mix, voice, subject) {
+    const held = voice.subjects.get(subject);
+    if (held !== undefined || voice.unreachedBits === null)
+        return held;
+    return unreached(voice, mix.chains.get(subject)?.slot ?? -1)
+        ? voice.unreached
+        : undefined;
+}
+/** A projection ahead starts each subject from where the live mix holds it. */
+function carry(mix, voice, subject) {
+    const live = recordOf(mix, voice, subject);
+    if (live === undefined)
+        return undefined;
+    const h = copyHeld(voice, live);
+    h.from = h.stepped;
+    return h;
+}
+/**
+ * A projection back starts each subject from the latest copy kept at or before `t`, else from its
+ * voice's start with fresh state, which is exact for a voice stepped at a fixed interval.
+ */
+function recall(mix, voice, subject, t) {
+    const live = recordOf(mix, voice, subject);
+    if (live === undefined)
+        return undefined;
+    const snap = live.snaps && last(live.snaps, t, true);
+    if (snap) {
+        const h = copyHeld(voice, snap.held);
+        h.from = h.stepped;
+        h.replay = live.inputs;
+        return h;
+    }
+    const stepped = live.since < t ? live.since : t;
+    return {
+        reaches: live.reaches,
+        delay: live.delay,
+        since: live.since,
+        shown: live.shown,
+        weight: 0,
+        rested: false,
+        bands: null,
+        state: live.reaches && voice.patch.state
+            ? voice.patch.state(subject)
+            : undefined,
+        stepped,
+        ticks: 0,
+        probed: Number.NaN,
+        delta: null,
+        phase: 0,
+        seeks: 0,
+        kept: null,
+        voice,
+        next: null,
+        version: Number.NaN,
+        loci: null,
+        slot: -1,
+        from: stepped,
+        unknown: voice.spec.from === 'current',
+        replay: live.inputs,
+    };
+}
+/** Per channel, the least sure voice that fed it this frame. */
+function doubts(mix, subject) {
+    const out = {};
+    for (const name of mix.names)
+        out[name] = 'exact';
+    const rank = { exact: 0, stepped: 1, held: 2 };
+    // A voice still waiting on an anchor nothing has answered may yet play, or stop, by now.
+    for (const voice of mix.cued) {
+        const anchor = voice.spec.anchor;
+        if (anchor === undefined || voice.state === 'done')
+            continue;
+        const waiting = (voice.state === 'pending' && !Number.isFinite(voice.start)) ||
+            (voice.state !== 'pending' &&
+                voice.state !== 'fading' &&
+                (anchor.out !== undefined || anchor.end !== undefined) &&
+                !Number.isFinite(voice.outAt));
+        if (!waiting || !mix.aims(voice, subject))
+            continue;
+        for (const slot of voice.slots)
+            out[mix.names[slot]] = 'held';
+    }
+    for (let held = mix.chain(subject, mix.now); held !== null; held = held.next) {
+        const voice = held.voice;
+        if (voice === null || voice.state === 'done')
+            continue;
+        if (held.weight <= 0)
+            continue;
+        const d = doubtOf(mix, voice, held);
+        for (const slot of voice.slots) {
+            const name = mix.names[slot];
+            if (rank[d] > rank[out[name]])
+                out[name] = d;
+        }
+    }
+    return out;
+}
+function doubtOf(mix, voice, held) {
+    const weight = voice.spec.weight;
+    if (held.unknown)
+        return 'held';
+    // A weight read back from a recording is what the mix used then, so its signal's state is moot.
+    const replayed = held.replay !== undefined && last(held.replay, mix.now, true) !== undefined;
+    if (typeof weight === 'function' && weight.input && !replayed)
+        return 'held';
+    if (voice.owner !== null && heldByInput(voice))
+        return 'held';
+    const reads = voice.patch.reads;
+    if (reads !== undefined && reads.length > 0) {
+        const then = mix.hostThen?.fields;
+        if (then === undefined || !reads.every((f) => f in then))
+            return 'held';
+    }
+    if (mix.now > (held.from ?? mix.now)) {
+        const tick = mix.opts.stepMs;
+        const fixed = tick !== undefined && tick > 0 && !mix.reducedNow;
+        if ((voice.patch.step && !fixed) || (held.kept !== null && held.kept.size > 0 && !replayed))
+            return 'stepped';
+    }
+    return 'exact';
+}

package/dist/pull.d.ts

@@ -0,0 +1,5 @@
+import type { Mixer } from './mixer.js';
+import type { Columns } from './types.js';
+/** After a probe, keeps the pose a retarget from `'current'` reads as the subject's last. */
+export declare function keep<I, O>(this: Mixer<I, O>, subject: I, pose: O, out: O | undefined): void;
+export declare function pull<I, O>(mix: Mixer<I, O>, subjects: Iterable<I>, into: Columns<O>): void;

package/dist/pull.js

@@ -0,0 +1,175 @@
+import { copy } from './clone.js';
+import { clampRun, flush, pullRun, writeLater } from './columns.js';
+/** Writes a folded pose's value into subject `n`'s places in a column. */
+function writeValue(c, v, n) {
+    const at = n * c.axes;
+    if (typeof v === 'number' && c.axes === 1)
+        c.out[at] = v;
+    else if (Array.isArray(v) && v.length === c.axes)
+        for (let a = 0; a < c.axes; a++)
+            c.out[at + a] = v[a];
+    else if (v === undefined)
+        c.out.fill(Number.NaN, at, at + c.axes);
+    else
+        throw new TypeError(`blits: pull reads ${c.key} as ${c.axes === 1 ? 'a number' : `${c.axes} numbers`} a subject, and the pose has ${String(v)}`);
+}
+/** After a probe, keeps the pose a retarget from `'current'` reads as the subject's last. */
+export function keep(subject, pose, out) {
+    // Keeping last frame's pose is free when the mix allocated it; a host sampling into its own
+    // object only pays for the copy once something in the mix has asked to retarget from it.
+    let kept;
+    if (out === undefined)
+        kept = pose;
+    else if (this.wantsPose) {
+        kept = {};
+        for (const key of this.names) {
+            const v = pose[key];
+            if (v !== undefined)
+                kept[key] = copy(v);
+        }
+    }
+    if (kept !== undefined) {
+        const rec = this.pose.get(subject);
+        if (rec === undefined)
+            this.pose.set(subject, { pose: kept, at: this.now, prev: undefined, prevAt: Number.NaN });
+        else if (rec.at === this.now)
+            rec.pose = kept;
+        else {
+            rec.prev = rec.pose;
+            rec.prevAt = rec.at;
+            rec.pose = kept;
+            rec.at = this.now;
+        }
+    }
+}
+export function pull(mix, subjects, into) {
+    const columns = columnsOf(mix, into);
+    const lanes = mix.lanes;
+    const now = mix.now;
+    if (mix.scratch === undefined)
+        mix.scratch = {};
+    let room = Number.POSITIVE_INFINITY;
+    let tightest = '';
+    for (const c of columns) {
+        const fits = Math.floor(c.out.length / c.axes);
+        if (fits < room) {
+            room = fits;
+            tightest = c.key;
+        }
+    }
+    // Any other iterable is read into an array first, no further than one past the room there is.
+    let list;
+    if (Array.isArray(subjects))
+        list = subjects;
+    else {
+        const taken = [];
+        for (const subject of subjects)
+            if (taken.push(subject) > room)
+                break;
+        list = taken;
+    }
+    if (list.length > room)
+        throw new RangeError(`blits: pull's array for ${tightest} has room for ${room} subjects, and was given more`);
+    const whole = lanes !== null && !mix.wantsPose;
+    // An array read again in the same order reuses each position's chain head while it is current:
+    // all of them at once while nothing has relinked since the last pull, else one by one.
+    const was = mix.pulled;
+    const heads = mix.pulledHeads;
+    was.length = list.length;
+    heads.length = list.length;
+    if (mix.pulledSlots.length < list.length) {
+        const slots = new Int32Array(Math.max(64, list.length));
+        slots.set(mix.pulledSlots);
+        mix.pulledSlots = slots;
+    }
+    const version = mix.version;
+    const relinks = mix.relinks;
+    const live = !Number.isNaN(now);
+    const current = live && mix.pulledVersion === version && mix.pulledRelinks === relinks;
+    try {
+        readAll(mix, list, columns, live, current, whole);
+    }
+    finally {
+        if (lanes !== null)
+            flush(lanes);
+    }
+    // Every head is current only if nothing relinked or changed version while they were read.
+    const unchanged = live && mix.version === version && mix.relinks === relinks;
+    mix.pulledVersion = unchanged ? version : Number.NaN;
+    mix.pulledRelinks = relinks;
+}
+/**
+ * Reads every subject in `list` into the columns, kept apart from `pull` so a list long enough to
+ * compile the loop on the stack does not leave `pull`'s own code compiled before its tail had run:
+ * under churn that code deoptimized at the tail on every frame.
+ */
+function readAll(mix, list, columns, live, current, whole) {
+    const lanes = mix.lanes;
+    const now = mix.now;
+    const scratch = mix.scratch;
+    const was = mix.pulled;
+    const heads = mix.pulledHeads;
+    const slots = mix.pulledSlots;
+    const version = mix.version;
+    // Every subject read from the lanes, at the positions it had last time, goes in one run.
+    const runs = live && whole;
+    for (let n = 0; n < list.length; n++) {
+        if (runs) {
+            n = pullRun(lanes, slots, list, was, current ? null : heads, n, columns, now, mix.version);
+            if (n === list.length)
+                break;
+        }
+        const subject = list[n];
+        let slot = -1;
+        if (live) {
+            if (current && was[n] === subject)
+                slot = slots[n];
+            else {
+                const kept = heads[n];
+                const head = was[n] === subject && kept !== undefined && kept.version === version
+                    ? kept
+                    : mix.chain(subject, now);
+                was[n] = subject;
+                heads[n] = head;
+                slot = head.slot;
+                slots[n] = slot;
+            }
+        }
+        const laned = live && lanes?.prepare(slot, subject, now, mix.version, heads[n] ?? null) === true;
+        if (laned && whole && lanes.whole && !lanes.owes(slot)) {
+            writeLater(lanes, slot, columns, n);
+            continue;
+        }
+        const head = live ? heads[n] : null;
+        const folded = mix.foldWith(subject, scratch, head, laned, false);
+        const pose = (mix.bounded.length === 0 ? folded : mix.clamp(folded));
+        mix.keep(subject, pose, scratch);
+        for (const c of columns)
+            writeValue(c, pose[c.key], n);
+    }
+}
+/** The kit slot, width, rest and bounds of every channel `pull` was handed an array for. */
+function columnsOf(mix, into) {
+    const columns = [];
+    for (const key of Object.keys(into)) {
+        const out = into[key];
+        if (out === undefined)
+            continue;
+        const slot = mix.slotOf.get(key);
+        if (slot === undefined)
+            throw new Error(`blits: pull was handed ${key}, which the kit lacks`);
+        const channel = mix.channels[slot];
+        const rest = channel.rest;
+        const axes = Array.isArray(rest) ? rest.length : 1;
+        const bounds = channel.bounds;
+        const at = new Float64Array(axes).fill(Number.NaN);
+        if (typeof rest === 'number')
+            at[0] = rest;
+        else if (Array.isArray(rest))
+            at.set(rest);
+        if (bounds !== undefined)
+            clampRun(at, 0, axes, bounds);
+        columns.push({ key, slot, axes, out, rest: at, bounds });
+    }
+    return columns;
+}

package/dist/qualify.d.ts

@@ -0,0 +1,31 @@
+import type { Lanes } from './lanes.js';
+import type { Voice } from './voice.js';
+/** What qualifying needs of one voice: whether its patch and spec can run on a lane, and its channels. */
+export interface Candidate {
+    readonly id: number;
+    readonly fits: boolean;
+    readonly slots: readonly number[];
+}
+/**
+ * Which channels run as lanes and which voices run on them: the fixed point where every voice
+ * writing a laned channel fits and writes only laned channels. Only channels some laned voice
+ * writes are laned.
+ */
+export declare function qualify(numeric: readonly boolean[], voices: readonly Candidate[]): {
+    channels: boolean[];
+    voices: Set<number>;
+};
+export declare function requalify<I, O>(lanes: Lanes<I, O>, version: number): void;
+/**
+ * A voice starts playing on a lane or crowd: its epoch. Every subject meets a voice over all of
+ * them on its next probe; a voice naming its subjects marks only those.
+ */
+export declare function open<I, O>(lanes: Lanes<I, O>, v: Voice<I, O>): number;
+/**
+ * Takes the voices `touch` named on or off their crowds, each as it now stands; false at the
+ * first that cannot be, which needs a qualify: one that leaves a lane or the general path, which
+ * may open a channel, or one that joins anything but a crowd on a laned channel. Neither a voice
+ * that fits joining laned channels nor a laned one leaving moves the fixed point `qualify` finds.
+ * A crowd a quarter empty rows is compacted.
+ */
+export declare function retouch<I, O>(lanes: Lanes<I, O>): boolean;