@msb235/blits 0.14.0 → 0.15.1

package/dist/types/watch.d.ts

@@ -1,10 +1,10 @@
 import type { HistoryOptions } from './history.js';
 import type { Mix } from './mix.js';
 import type { Sent } from './patch.js';
-import type { Handle } from './voice.js';
+import type { Circle, Finder, Handle } from './voice.js';
 /**
- * Every mix made on the page, for a debugger: shared by every copy of blits loaded, so a mix one
- * copy made is listed by another. `watched()` returns it.
+ * Every mix made on the page, for a debugger. It is shared by every copy of blits loaded, so a
+ * mix one copy made is listed by another. `watched()` returns it.
  *
  * @category mix
  */
@@ -12,19 +12,27 @@ export interface Registry {
     /** The mixes still alive, in the order they were made. */
     entries(): Watched[];
     /** Hears each mix made, and each one collected, by its entry's `id`. Returns an unsubscribe. */
-    on(fn: (change: {
-        kind: 'add';
-        entry: Watched;
-    } | {
-        kind: 'gone';
-        id: number;
-    }) => void): () => void;
+    on(fn: (change: RegistryChange) => void): () => void;
     /**
-     * The history a mix made from now on keeps when its options name none and it is on no
-     * transport, so a debugger present before the page's mixes can scrub them. Undefined by default.
+     * The history new mixes keep when they name none. It applies to a mix made from now on whose
+     * options name no history and that is on no transport, so a debugger present before the page's
+     * mixes can scrub them. Undefined by default.
      */
     history: HistoryOptions | undefined;
 }
+/**
+ * What `Registry.on` hears. It is a mix made, with its entry, or a mix collected, by its entry's
+ * `id`.
+ *
+ * @category mix
+ */
+export type RegistryChange = {
+    kind: 'add';
+    entry: Watched;
+} | {
+    kind: 'gone';
+    id: number;
+};
 /**
  * One mix as a debugger sees it. Built by the copy of blits that made the mix, so a debugger
  * reads mixes from other releases through it alike.
@@ -39,21 +47,17 @@ export interface Watched<I = unknown, O = unknown> {
     readonly name: string | undefined;
     readonly mix: Mix<I, O>;
     /** What history it keeps, and whether the registry's `history` gave it; undefined for none. */
-    readonly history: {
-        readonly ms: number;
-        readonly tape: boolean;
-        readonly added: boolean;
-    } | undefined;
-    /** The earliest mix time `read` reaches back to: `mix.now` without history. */
+    readonly history: WatchedHistory | undefined;
+    /** The earliest mix time `read` reaches back to. It is `mix.now` without history. */
     readonly reach: number;
     /** The kit's channel names, in kit order. */
     readonly channels: readonly string[];
-    /** What a voice was cued with that its handle does not carry; undefined for a handle not on this mix. */
-    voice(handle: Handle<I>): {
-        readonly name: string | undefined;
-        readonly tags: readonly string[];
-    } | undefined;
-    /** What to call a subject: the mix's `labelOf`, else a guess from the subject itself. */
+    /**
+     * What a voice was cued with that its handle does not carry. Undefined for a handle not on this
+     * mix.
+     */
+    voice(handle: Handle<I>): WatchedVoice | undefined;
+    /** What to call a subject. It is the mix's `labelOf`, else a guess from the subject itself. */
     label(subject: I): string;
     /**
      * Calls `fn` with each frame the host read, once the next one begins. While anyone watches, the
@@ -61,16 +65,46 @@ export interface Watched<I = unknown, O = unknown> {
      * a function that stops watching.
      */
     watch(fn: (frame: WatchedFrame<I, O>) => void): () => void;
-    /** The subjects its voices still playing name, and those the host read in the last two frames while watched. */
+    /**
+     * The subjects its voices still playing name. It also lists those the host read in the last two
+     * frames while watched.
+     */
     subjects(): I[];
     /**
-     * One subject's pose at mix time `at`, default now, read through `project`, which moves nothing:
-     * never a probe. A time behind now needs history that reaches it.
+     * One subject's pose at mix time `at`, default now. It is read through `project`, which moves
+     * nothing, never a probe. A time behind now needs history that reaches it.
      */
     read(subject: I, at?: number): O;
-    /** Takes the clock from the host: see `Hold`. Throws while another hold has it. */
+    /** Takes the clock from the host. See `Hold`. Throws while another hold has it. */
     hold(): Hold;
 }
+/**
+ * What history a watched mix keeps, as `Watched.history` reports it.
+ *
+ * @category mix
+ */
+export interface WatchedHistory {
+    /** How much stays in memory, ms of mix time. */
+    readonly ms: number;
+    /** Whether it records a tape. */
+    readonly tape: boolean;
+    /** Whether the registry's `history` gave it. */
+    readonly added: boolean;
+}
+/**
+ * What a voice was cued with that its handle does not carry. `Watched.voice` reports it.
+ *
+ * @category mix
+ */
+export interface WatchedVoice {
+    readonly name: string | undefined;
+    readonly tags: readonly string[];
+    /**
+     * What it is bounded to, by `within` or an `around` weight. It is a circle, read live, or the
+     * host's finder; undefined for none.
+     */
+    readonly within: Readonly<Circle> | Finder | undefined;
+}
 /**
  * What the host read in one frame.
  *
@@ -83,19 +117,33 @@ export interface WatchedFrame<I, O> {
     /** The host's timestamp at the frame's sync. */
     timestamp: number;
     /** Each probe, in order, with a copy of the pose it returned. */
-    probed: {
-        subject: I;
-        pose: O;
-    }[];
+    probed: Probed<I, O>[];
     /** Each pull, with copies of the columns it wrote. */
-    pulled: {
-        subjects: I[];
-        columns: Record<string, Float64Array>;
-    }[];
+    pulled: Pulled<I>[];
     /** What `drain` handed the host. */
     sent: Sent<I, unknown>[];
     voices: Handle<I>[];
 }
+/**
+ * One probe a watched frame recorded.
+ *
+ * @category mix
+ */
+export interface Probed<I, O> {
+    subject: I;
+    /** A copy of the pose the probe returned. */
+    pose: O;
+}
+/**
+ * One pull a watched frame recorded.
+ *
+ * @category mix
+ */
+export interface Pulled<I> {
+    subjects: I[];
+    /** Copies of the columns it wrote, by channel. */
+    columns: Record<string, Float64Array>;
+}
 /**
  * A mix's clock in a debugger's hands, and every mix's on the same transport. The host's `sync`
  * still begins each frame, but the frame's gap counts at `rate`, so the mix moves at `rate` times
@@ -109,7 +157,7 @@ export interface Hold {
     readonly mixes: Mix<unknown, unknown>[];
     /** The mix clock. */
     readonly now: number;
-    /** The earliest mix time `seek` reaches: `now` without history and a tape. */
+    /** The earliest mix time `seek` reaches. It is `now` without history and a tape. */
     readonly reach: number;
     /** How much of each of the host's frames the held mix plays; 0 pauses it. Starts at 0. */
     rate: number;
@@ -118,9 +166,9 @@ export interface Hold {
     /** Plays the mixes `ms` of mix time further on, in one frame. */
     step(ms: number): void;
     /**
-     * Gives the clock back: the host's next sync carries on from where the hold left the mix, and
-     * its clock calls made meanwhile are made, in order. A call made while the tape holds later
-     * calls acts on the mix but is not recorded, so those calls still play.
+     * Gives the clock back to the host. The host's next sync carries on from where the hold left the
+     * mix, and its clock calls made meanwhile are made, in order. A call made while the tape holds
+     * later calls acts on the mix but is not recorded, so those calls still play.
      */
     free(): void;
 }

package/dist/types.d.ts

@@ -2,8 +2,10 @@ export type * from './types/arc.js';
 export type * from './types/channel.js';
 export type * from './types/history.js';
 export type * from './types/mix.js';
+export type * from './types/motion.js';
 export type * from './types/patch.js';
 export type * from './types/place.js';
+export type * from './types/trace.js';
 export type * from './types/transport.js';
 export type * from './types/voice.js';
 export type * from './types/watch.js';

package/dist/unreached.d.ts

@@ -3,3 +3,5 @@ import type { Voice } from './voice.js';
 export declare function unreached<I, O>(voice: Voice<I, O>, slot: number): boolean;
 /** Marks or clears the subject numbered `slot` as one the voice does not reach. */
 export declare function unreach<I, O>(voice: Voice<I, O>, slot: number, on: boolean): void;
+/** The subject numbered `from` is numbered `to` now, a number let go of: its mark moves along. */
+export declare function reunreach<I, O>(voice: Voice<I, O>, from: number, to: number): void;

package/dist/unreached.js

@@ -22,3 +22,10 @@ export function unreach(voice, slot, on) {
     const bit = 1 << (slot & 31);
     bits[word] = on ? bits[word] | bit : bits[word] & ~bit;
 }
+/** The subject numbered `from` is numbered `to` now, a number let go of: its mark moves along. */
+export function reunreach(voice, from, to) {
+    if (!unreached(voice, from))
+        return;
+    unreach(voice, to, true);
+    unreach(voice, from, false);
+}

package/dist/voice.d.ts

@@ -1,5 +1,6 @@
 import type { Arc } from './arcs.js';
 import type { Blend } from './blend.js';
+import type { Bound } from './bound.js';
 import { type Clock } from './clock.js';
 import { type Curve } from './easing.js';
 import type { Leavings } from './leavings.js';
@@ -8,151 +9,13 @@ import { Named } from './named.js';
 import type { Past } from './origin.js';
 import { Holding } from './owner.js';
 import { type Built, intosOf, type Scratch } from './patch.js';
-import type { Stamp } from './restored.js';
+import type { Seat } from './seat.js';
+import { VoiceSetting } from './setting.js';
 import type { Fitting } from './spans.js';
 import { Store } from './store.js';
-import type { Anchor, Channel, FadeSpec, Handle, Patch, Setting, VoiceSpec } from './types.js';
-/**
- * A subject's record as it left a voice, faded out of it or dropped: the mix time and frame it
- * left at, and `sync` where it shows in its own frame: left in the frame's sync, or before anything
- * read the mix that frame.
- */
-export interface Left<I> {
-    subject: I;
-    at: number;
-    seq: number;
-    sync: boolean;
-    held: Subject<unknown>;
-    /**
-     * The voice's fade of the subject as it stood on leaving, which a seek or read back to before
-     * puts back: its ramp out, while running, or its having faded out.
-     */
-    ramp: Parting | null;
-    parted: Parted | null;
-}
-/** A subject's ramp out of one voice: when it began, how long it runs, and the frame it was asked in. */
-export interface Parting {
-    at: number;
-    over: number;
-    seq: number;
-}
-export interface Parted {
-    at: number;
-    seq: number;
-    ramp: Parting | undefined;
-}
+import type { Parted, Parting, Snap, Subject } from './subject.js';
+import type { Anchor, Channel, FadeSpec, Handle, Patch, VoiceSpec } from './types.js';
 export declare const none: readonly string[];
-/**
- * What a copy of a record keeps for the seeks that put a record back from it: the copy's state
- * stepped on to `ticks`, as it stood near `at`, a moment one of them sought.
- */
-export interface Ahead<S> {
-    /** The record the last seek put back, and the moment it sought, until that record steps. */
-    put: Subject<S> | null;
-    sought: number;
-    /** The `since` of the record put back, which the steps in `state` were counted from. */
-    since: number;
-    at: number;
-    ticks: number;
-    /** Undefined until a record has stepped on from the copy. */
-    state: S | undefined;
-    /**
-     * The state the record a seek replaced had stepped on to from the copy, at `leftTicks`; undefined
-     * until one had.
-     */
-    leftTicks: number;
-    left: S | undefined;
-}
-/** A copy of a record kept under `history`, by the mix time and frame it was taken at. */
-export interface Snap<S> {
-    at: number;
-    seq: number;
-    held: Subject<S>;
-    ahead?: Ahead<S>;
-    /** Set where another record's list holds it too, so a seek cutting it from one lets go of it. */
-    shared?: true;
-}
-/** Everything one voice holds for one subject, chained through the next voice that reaches it. */
-export interface Subject<S> {
-    /** The voice's `target` answer, fixed on first sight. */
-    reaches: boolean;
-    /** The voice's `stagger` answer in voice ms, fixed on first sight. */
-    delay: number;
-    /** The mix timestamp this subject's delay ran out at, which its step grid counts from. */
-    since: number;
-    /** The mix timestamp its fade in counts from: `since`, or earlier for a voice freezing before. */
-    shown: number;
-    /** The weight this voice gave this subject the last frame it was probed, 0 where it gave none. */
-    weight: number;
-    /** Left at rest during a handover, so it stops contributing. */
-    rested: boolean;
-    /** The mix time it rested at, which a seek reads to know whether it had by then; NaN until it does. */
-    restedAt: number;
-    /**
-     * Per written channel, whether a rest-less contribution is on: 0 unknown, 1 on, 2 off; null until
-     * a rest-less channel asks.
-     */
-    bands: Uint8Array | null;
-    state: S;
-    /** The `now` this subject last caught up to, for this voice. */
-    stepped: number;
-    /** Under `stepMs`, how many intervals have run since `since`; `stepped` is where that lands. */
-    ticks: number;
-    /** The `now` this subject was last probed at, so twelve probes in a frame step once. */
-    probed: number;
-    /** The last delta computed this frame, handed back to a repeat probe unchanged. */
-    delta: Record<string, unknown> | null;
-    /** The phase `delta` was read at, to read it again once its voice's scratch has moved on. */
-    phase: number;
-    /** The voice's `seeks` when `delta` was read, so a seek later in the frame reads it again. */
-    seeks: number;
-    /** The voice's `rebuilds` when its state was last made, so a seek's rebuild reaches it once. */
-    rebuilt: number;
-    /** Its kept signal state was stepped on in one go from a copy history kept, by a seek. */
-    copied: boolean;
-    /** Stop 0 for a `from: 'current'` voice, taken the first frame this subject is seen. */
-    base?: Record<string, unknown>;
-    /** The pose's velocity per channel at that moment, units per ms, so the first segment leaves at it. */
-    slope?: Record<string, unknown>;
-    /** What `setting.keep` holds for this voice and subject, by owner; null until it holds any. */
-    kept: Map<object, unknown> | null;
-    /** Kept state a history store gave back, which each owner takes in turn on its first keep. */
-    unkept?: unknown[];
-    /** Under `history`, copies of this record by the mix time they were taken, oldest first. */
-    snaps?: Snap<S>[];
-    /** In a projection: where this record started from, and whether nothing known could be. */
-    from?: number;
-    unknown?: boolean;
-    /** Under `history` with `inputs`, what an input weight signal read for this subject, when it changed. */
-    inputs?: {
-        at: number;
-        seq: number;
-        value: number;
-    }[];
-    /** In a projection reading back: that record, to read in place of the signal. */
-    replay?: {
-        at: number;
-        value: number;
-    }[];
-    /** The voice this is the record of; null on a subject's stub. */
-    voice: object | null;
-    /** The next voice's record for this subject, in voice order, among those that reach it. */
-    next: Subject<unknown> | null;
-    /**
-     * On the first record, which the mix keeps per subject so a probe makes one lookup: the `version`
-     * the chain was linked at, and per locus, by channel slot, whether a rest-less contribution is on:
-     * 0 never decided, 1 on, 2 off.
-     */
-    version: number;
-    loci: Map<string, Uint8Array> | null;
-    /** On the first record: the number lanes index this subject by, -1 without one. */
-    slot: number;
-    /** A motion voice's number for this subject in its patch, good while `freed` is the patch's own. */
-    run: number;
-    freed: number;
-    /** In a voice's store once a seek has gone back, the stamp of the seek it was last put back or written at. */
-    restored: Stamp | null;
-}
 /** A voice's clock, weight and fade from one mix time on, kept under `history`. */
 export interface Controls extends Clock {
     at: number;
@@ -239,6 +102,8 @@ export declare class Voice<I, O> {
     holder: Subject<unknown> | null;
     /** Whether its channels run as lanes this frame, so the general fold passes it by. */
     laned: boolean;
+    /** Its crowd row, while its channels run in a crowd. */
+    seat: Seat<I, O> | null;
     /**
      * How many times it has been sought or touched, so a delta read before either is not handed out
      * after it.
@@ -301,7 +166,7 @@ export declare class Voice<I, O> {
     /** The clocks it ran on before its current one, where a subject's origin may lie; null for none. */
     clocks: Past[] | null;
     /** Reused for every call this voice makes, so it is valid only during the call. */
-    readonly setting: Setting<unknown>;
+    readonly setting: VoiceSetting<I, O>;
     /** Every subject this voice has been asked about, so a handover knows when it is finished. */
     seen: number;
     /** The longest stagger of any subject seen, so a finite loop waits for the last of them. */
@@ -363,6 +228,8 @@ export declare class Voice<I, O> {
     unreachedBits: Uint32Array | null;
     /** Whether one record stands for every subject: see `shares` in `everyone.ts`. */
     sharing: boolean;
+    /** Where its signal is declared 0, its cue's `within`, so it is not read there: see `bound.ts`. */
+    bound: Bound<I, O> | null;
     /** The frames it has played sharing it. */
     shared: number;
     /** That record, null until a chain first asks and once the voice shares no more. */

package/dist/voice.js

@@ -4,87 +4,33 @@ import { motionOf } from './motion.js';
 import { Named } from './named.js';
 import { childPlayed, Holding, mixTime, ownedElapsed, ownerPatch, ownerReading, turnedBack, } from './owner.js';
 import { builtOf, intosOf } from './patch.js';
-import { reading } from './reading.js';
-import { Store } from './store.js';
+import { keeping, VoiceSetting } from './setting.js';
+import { Filled, Store } from './store.js';
 import { warnOnce } from './warn.js';
 export const none = Object.freeze([]);
-/**
- * A voice's `setting.keep`, one per voice: a setting is valid only during its call, so the state
- * goes on the record of the subject being called for, `keepOn`, or on the voice before any is.
- */
-function keeping(voice) {
-    return function keep(owner, init) {
-        const held = voice.keepOn;
-        let kept = held === null ? voice.ownKept : held.kept;
-        if (kept === null) {
-            kept = new Map();
-            if (held === null)
-                voice.ownKept = kept;
-            else
-                held.kept = kept;
-        }
-        if (kept.has(owner))
-            return kept.get(owner);
-        const unkept = held?.unkept;
-        const made = unkept === undefined ? init() : unkept.shift();
-        if (unkept?.length === 0 && held !== null)
-            held.unkept = undefined;
-        kept.set(owner, made);
-        reading.kept++;
-        return made;
-    };
-}
-/**
- * A voice's setting. `keep` is made on first read: most patches keep no state, and a closure and
- * its context per voice cost a one-subject tween voice about 100 bytes.
- */
-class VoiceSetting {
-    host;
-    send;
-    voice;
-    timestamp = 0;
-    dt = 0;
-    elapsed = 0;
-    pass = 0;
-    weight = 0;
-    state = undefined;
-    kept = null;
-    constructor(host, send, voice) {
-        this.host = host;
-        this.send = send;
-        this.voice = voice;
-    }
-    get keep() {
-        if (this.kept === null)
-            this.kept = keeping(this.voice);
-        return this.kept;
-    }
+const noSend = () => { };
+/** By a mix's `slotOf`, the slots and lerps of a patch writing one channel, shared by its voices. */
+const writings = new WeakMap();
+function writing(writes, slotOf, channels) {
+    if (writes.length !== 1)
+        return written(writes, slotOf, channels);
+    let known = writings.get(slotOf);
+    if (known === undefined) {
+        known = new Map();
+        writings.set(slotOf, known);
+    }
+    const key = writes[0];
+    let found = known.get(key);
+    if (found === undefined) {
+        found = written(writes, slotOf, channels);
+        known.set(key, found);
+    }
+    return found;
 }
-/** A store that fills a missing entry from `make` on first ask. */
-class Filled extends Store {
-    make;
-    /** Keys deleted here, which are made afresh by whoever asks and never again by `make`. */
-    gone = null;
-    constructor(make) {
-        super();
-        this.make = make;
-    }
-    get(key) {
-        let v = super.get(key);
-        if (v === undefined && this.gone?.get(key) !== true) {
-            v = this.make(key);
-            if (v !== undefined)
-                super.set(key, v);
-        }
-        return v;
-    }
-    delete(key) {
-        super.delete(key);
-        this.gone ??= new Store();
-        this.gone.set(key, true);
-    }
+function written(writes, slotOf, channels) {
+    const slots = writes.map((k) => slotOf.get(k));
+    return { slots, lerps: slots.map((slot) => channels[slot].lerp) };
 }
-const noSend = () => { };
 export class Voice {
     id;
     spec;
@@ -126,6 +72,8 @@ export class Voice {
     holder = null;
     /** Whether its channels run as lanes this frame, so the general fold passes it by. */
     laned = false;
+    /** Its crowd row, while its channels run in a crowd. */
+    seat = null;
     /**
      * How many times it has been sought or touched, so a delta read before either is not handed out
      * after it.
@@ -251,6 +199,8 @@ export class Voice {
     unreachedBits = null;
     /** Whether one record stands for every subject: see `shares` in `everyone.ts`. */
     sharing = false;
+    /** Where its signal is declared 0, its cue's `within`, so it is not read there: see `bound.ts`. */
+    bound = null;
     /** The frames it has played sharing it. */
     shared = 0;
     /** That record, null until a chain first asks and once the voice shares no more. */
@@ -410,8 +360,8 @@ export class Voice {
         this.dueToken++;
         this.early = null;
         this.seen = 0;
-        this.latest = 0;
-        this.soonest = 0;
+        this.latest = this.named?.latest ?? 0;
+        this.soonest = this.named?.soonest ?? 0;
         this.restedCount = 0;
         this.cuedAt = Number.NEGATIVE_INFINITY;
         this.cuedSeq = Number.NEGATIVE_INFINITY;
@@ -443,10 +393,14 @@ export class Voice {
         this.start = start;
         this.owner = owner;
         this.holding = patch === ownerPatch ? new Holding() : null;
-        this.slots = patch.writes.map((k) => slotOf.get(k));
-        this.named = spec.subjects ? new Named(spec.subjects) : null;
+        const wrote = writing(patch.writes, slotOf, channels);
+        this.slots = wrote.slots;
+        this.named = spec.subjects ? new Named(spec.subjects, spec.stagger) : null;
+        // Every subject's stagger is known at cue, so a finite loop ends by them all, read or not.
+        this.latest = this.named?.latest ?? 0;
+        this.soonest = this.named?.soonest ?? 0;
         this.built = patch.form === 'keys' && patch.keys ? builtOf(patch) : null;
-        this.lerps = this.slots.map((slot) => channels[slot].lerp);
+        this.lerps = wrote.lerps;
         this.intos = this.built
             ? intosOf(this.built, this.slots.map((slot) => channels[slot]))
             : undefined;
@@ -618,6 +572,7 @@ export class Voice {
         v.scratch = [];
         v.holder = null;
         v.laned = false;
+        v.seat = null;
         v.log = null;
         v.early = null;
         if (controls)

package/dist/warn.d.ts

@@ -1,2 +1,4 @@
+/** Whether this is a production build: a bundler's `NODE_ENV`, or Node's; false where neither is. */
+export declare function production(): boolean;
 /** Warns outside production, once for each `about`. */
 export declare function warnOnce(about: object, message: string): void;

package/dist/warn.js

@@ -1,5 +1,5 @@
 /** Whether this is a production build: a bundler's `NODE_ENV`, or Node's; false where neither is. */
-function production() {
+export function production() {
     try {
         return process.env.NODE_ENV === 'production';
     }

package/dist/watch.d.ts

@@ -2,8 +2,8 @@ import type { Mixer } from './mixer.js';
 import type { MixOptions, Registry } from './types.js';
 type Any = Mixer<unknown, unknown>;
 /**
- * Every mix made on the page, shared by every copy of blits loaded: what a debugger reads to find
- * them. See `Registry`.
+ * The registry a debugger reads to find every mix made on the page. It is shared by every copy of
+ * blits loaded. See `Registry`.
  *
  * @category mix
  */

package/dist/watch.js

@@ -4,8 +4,8 @@ import { hostAhead } from './tape.js';
 const KEY = Symbol.for('@msb235/blits/watch/1');
 const slot = globalThis;
 /**
- * Every mix made on the page, shared by every copy of blits loaded: what a debugger reads to find
- * them. See `Registry`.
+ * The registry a debugger reads to find every mix made on the page. It is shared by every copy of
+ * blits loaded. See `Registry`.
  *
  * @category mix
  */
@@ -90,7 +90,9 @@ export function register(mix) {
         channels: mix.names,
         voice: (handle) => {
             const v = mix.cued.find((c) => c.handle === handle) ?? mix.gone.find((c) => c.handle === handle);
-            return v === undefined ? undefined : { name: v.spec.name, tags: v.spec.tags ?? [] };
+            return v === undefined
+                ? undefined
+                : { name: v.spec.name, tags: v.spec.tags ?? [], within: v.bound?.area };
         },
         label: (subject) => labelOf(mix, subject),
         watch: (fn) => tap(mix, fn),

package/dist/wave.d.ts

@@ -11,7 +11,7 @@ export type WaveShape = 'sine' | 'triangle' | 'saw' | 'square';
  * @category patch
  */
 export interface WaveOptions<O> {
-    /** Default 'sine'. */
+    /** The wave's form: 'sine', 'triangle', 'saw' or 'square'. Default 'sine'. */
     shape?: WaveShape;
     /** Whole or fractional cycles per pass of the patch's duration. Default 1. */
     cycles?: number;
@@ -27,13 +27,14 @@ export interface WaveOptions<O> {
     kit?: Partial<Kit<O>>;
 }
 /**
- * The unit wave: -1..1 at `x` cycles, starting at 0 and rising (square: +1 for the first half).
+ * The unit wave's value at `x` cycles, from -1 to 1. It starts at 0 and rises (square: +1 for the
+ * first half).
  *
  * @category patch
  */
 export declare function waveAt(shape: WaveShape, x: number): number;
 /**
- * A periodic swing on each channel `depth` names, around its rest: an LFO for a bob, a sway or a
+ * A periodic swing on each channel `depth` names, around its rest. An LFO for a bob, a sway or a
  * pulse. An `fn` patch that keeps its options on `patch.wave`, for an engine reading the wave
  * rather than calling it.
  *