@johnmorrisdotca/kyogijo-stadiums 0.60.1 → 0.61.0

package/dist/sound.mix.js

@@ -0,0 +1,234 @@
+import { SOUND_BEDS, SOUND_LEVELS, SOUND_OF_SPORT, SOUND_SETS } from "./sound.sets.js";
+const clamp = (value, least, greatest) => Math.min(greatest, Math.max(least, value));
+const isNum = (value) => typeof value === "number" && Number.isFinite(value);
+const round = (value) => Math.round(value * 1000) / 1000;
+/** The set of a surface's sport, or `undefined` when it has none (a surface with no sound shows no sound controls). */
+export function soundSetOf(sport) {
+    const id = SOUND_OF_SPORT[sport];
+    return id === undefined ? undefined : SOUND_SETS[id];
+}
+/** The crowd levels a surface offers, quietest first: none for a surface with no sound. */
+export function soundLevelsOf(sport) {
+    const found = soundSetOf(sport);
+    if (found === undefined)
+        return [];
+    return found.levels ?? SOUND_BEDS[found.bed].levels;
+}
+/** The voices a surface's cues use, each once, in the order of `CUE_KINDS`: what a page loads when it has files for them. */
+export function soundVoicesOf(sport) {
+    const found = soundSetOf(sport);
+    if (found === undefined)
+        return [];
+    return [...new Set(Object.values(found.cues).flat())];
+}
+/** How closed in each kind of roof leaves the crowd. */
+const ENCLOSURE = { open: 0, canopy: 0.3, cable: 0.7, panels: 0.6, retractable: 0.6, fixed: 1, dome: 1, saddle: 1, barrel: 1 };
+/**
+ * The room of a surface in its context: how closed in the venue is (its roof, else its bed's), how long it rings (longer closed in and larger), how much echo, and how loud the crowd is for the
+ * people in it (the seats times the share taken, on a scale that grows as a crowd's sound does, slower than its number). `undefined` for a surface with no sound.
+ * @example
+ * ```ts
+ * import { soundRoom } from "@johnmorrisdotca/kyogijo-stadiums/sound";
+ * const arena = soundRoom({ sport: "nhl", venue: { roof: "fixed", seats: 18000 } })!;
+ * const field = soundRoom({ sport: "soccer", venue: { roof: "open", seats: 50000 } })!;
+ * console.log(arena.bed.id, arena.decay > field.decay, arena.wet > field.wet);
+ * console.log(soundRoom({ sport: "nhl", crowd: 0 })!.crowd);
+ * // arena true true
+ * // 0
+ * ```
+ */
+export function soundRoom(context) {
+    const found = soundSetOf(context.sport);
+    if (found === undefined)
+        return undefined;
+    const bed = SOUND_BEDS[found.bed];
+    const roof = context.venue?.roof;
+    const enclosure = roof !== undefined && Object.hasOwn(ENCLOSURE, roof) ? ENCLOSURE[roof] : bed.indoor ? 1 : 0;
+    const seats = isNum(context.venue?.seats) && context.venue.seats > 0 ? context.venue.seats : bed.seats;
+    const share = isNum(context.crowd) ? clamp(context.crowd, 0, 1) : 1;
+    const people = Math.round(seats * share);
+    const size = clamp((seats / bed.seats) ** 0.25, 0.7, 1.3);
+    const flat = context.view === "2d";
+    const decay = round((0.6 + 1.8 * enclosure) * size);
+    const wet = round((0.12 + 0.33 * enclosure) * (flat ? 0.5 : 1));
+    const crowd = people === 0 ? 0 : round(clamp(0.35 + (0.65 * Math.log10(1 + people)) / Math.log10(1 + bed.seats), 0, 1.15));
+    return { bed, enclosure, decay, wet, people, crowd, gain: flat ? 0.7 : 1 };
+}
+/** Each layer's gain at each level, before the crowd's size: the room and the water stay, the voices come up. */
+export const LEVEL_MIX = {
+    quiet: { room: 1, water: 0.8, murmur: 0.12, applause: 0, roar: 0 },
+    murmur: { room: 0.7, water: 0.7, murmur: 0.55, applause: 0.03, roar: 0.04 },
+    engaged: { room: 0.5, water: 0.6, murmur: 0.7, applause: 0.2, roar: 0.18 },
+    loud: { room: 0.4, water: 0.5, murmur: 0.6, applause: 0.4, roar: 0.5 },
+    roar: { room: 0.3, water: 0.4, murmur: 0.45, applause: 0.55, roar: 0.95 },
+};
+const VOICES = ["murmur", "applause", "roar"];
+/** The nearest level a surface offers to the one asked for: a dojo asked to roar is loud. */
+export function levelFor(sport, level) {
+    const offered = soundLevelsOf(sport);
+    if (offered.length === 0 || offered.includes(level))
+        return level;
+    const want = SOUND_LEVELS.indexOf(level);
+    return offered.reduce((best, l) => (Math.abs(SOUND_LEVELS.indexOf(l) - want) < Math.abs(SOUND_LEVELS.indexOf(best) - want) ? l : best), offered[0]);
+}
+/**
+ * The mix of a surface in its context at a crowd level: each of its bed's layers' gain (the crowd's voices scaled by the people in the room; a layer the bed does not have is 0) and the room.
+ * `undefined` for a surface with no sound.
+ * @example
+ * ```ts
+ * import { soundMix } from "@johnmorrisdotca/kyogijo-stadiums/sound";
+ * const quiet = soundMix({ sport: "nhl" }, "quiet")!;
+ * const roar = soundMix({ sport: "nhl" }, "roar")!;
+ * console.log(quiet.layers.roar, roar.layers.roar > roar.layers.murmur, soundMix({ sport: "kyudo" }, "roar")!.level);
+ * // 0 true murmur
+ * ```
+ */
+export function soundMix(context, level) {
+    const room = soundRoom(context);
+    if (room === undefined)
+        return undefined;
+    const at = levelFor(context.sport, level);
+    const base = LEVEL_MIX[at];
+    const layers = Object.fromEntries(["room", "water", "murmur", "applause", "roar"].map((layer) => [layer, room.bed.layers.includes(layer) ? round(base[layer] * (VOICES.includes(layer) ? room.crowd : 1)) : 0]));
+    return { ...room, level: at, layers };
+}
+/**
+ * How excited the crowd is at a moment of a game: a murmur before the start, between periods and after the end; engaged while it plays; loud late in a close game; a roar for a few seconds
+ * after a goal; and back to a murmur when one side is far ahead late on.
+ * @example
+ * ```ts
+ * import { excitementAt } from "@johnmorrisdotca/kyogijo-stadiums/sound";
+ * const periods = [{ start: 0, end: 100 }, { start: 120, end: 220 }];
+ * console.log(excitementAt({ t: 50, start: 0, end: 220, periods, score: { home: 0, away: 0 } }));
+ * console.log(excitementAt({ t: 110, start: 0, end: 220, periods }));
+ * console.log(excitementAt({ t: 200, start: 0, end: 220, periods, score: { home: 2, away: 1 } }));
+ * console.log(excitementAt({ t: 60, start: 0, end: 220, periods, sinceGoal: 2 }));
+ * // engaged
+ * // murmur
+ * // loud
+ * // roar
+ * ```
+ */
+export function excitementAt(moment) {
+    const periods = moment.periods !== undefined && moment.periods.length > 0 ? moment.periods : [{ start: moment.start, end: moment.end }];
+    const inPlay = periods.some((p) => moment.t >= p.start && moment.t < p.end);
+    if (!inPlay)
+        return "murmur";
+    if (isNum(moment.sinceGoal) && moment.sinceGoal >= 0 && moment.sinceGoal < 6)
+        return "roar";
+    const first = periods[0].start;
+    const last = periods[periods.length - 1].end;
+    const progress = last > first ? (moment.t - first) / (last - first) : 0;
+    const gap = moment.score === undefined ? 0 : Math.abs(moment.score.home - moment.score.away);
+    if (gap >= 3 && progress > 0.6)
+        return "murmur";
+    if (gap <= 1 && progress >= 2 / 3)
+        return "loud";
+    return "engaged";
+}
+/** The words of a timeline's events that are read as each kind of moment (lower case): a timeline of a sport with its own words (a `try`, a `touchdown`) calls the cues of its kind. */
+const KIND_WORDS = {
+    goal: "goal",
+    touchdown: "goal",
+    try: "goal",
+    run: "goal",
+    "home-run": "goal",
+    basket: "point",
+    point: "point",
+    score: "point",
+    "field-goal": "point",
+    behind: "point",
+    ippon: "goal",
+    knockout: "goal",
+    ko: "goal",
+    shot: "shot",
+    save: "shot",
+    miss: "shot",
+    post: "shot",
+    whistle: "whistle",
+    foul: "whistle",
+    penalty: "whistle",
+    offside: "whistle",
+    stoppage: "whistle",
+    "period-start": "period-start",
+    "faceoff": "period-start",
+    "kick-off": "period-start",
+    kickoff: "period-start",
+    "period-end": "period-end",
+    "half-time": "period-end",
+    halftime: "period-end",
+    "game-end": "game-end",
+    "full-time": "game-end",
+    final: "game-end",
+    start: "start",
+    gun: "start",
+    finish: "finish",
+    "round-start": "round-start",
+    "round-end": "round-end",
+    bell: "round-end",
+};
+/** The kind of moment a timeline's event is, or `undefined` for one with no cue (a pass). */
+export function cueKindOf(event) {
+    const word = String(event.kind).toLowerCase().trim();
+    return Object.hasOwn(KIND_WORDS, word) ? KIND_WORDS[word] : undefined;
+}
+/**
+ * The voices an event calls on a surface: its kind's cue in the sport's set, or none.
+ * @example
+ * ```ts
+ * import { cuesOf } from "@johnmorrisdotca/kyogijo-stadiums/sound";
+ * console.log(cuesOf({ kind: "goal" }, "nhl").join(), cuesOf({ kind: "goal" }, "soccer").join(), cuesOf({ kind: "whistle" }, "nba").join());
+ * console.log(cuesOf({ kind: "pass" }, "nhl").length, cuesOf({ kind: "goal" }, "a-surface-with-no-sound").length);
+ * // horn,swell swell whistle
+ * // 0 0
+ * ```
+ */
+export function cuesOf(event, sport) {
+    const kind = cueKindOf(event);
+    const found = soundSetOf(sport);
+    if (kind === undefined || found === undefined)
+        return [];
+    return found.cues[kind] ?? [];
+}
+/**
+ * The cues of a move of a replay: the events it went by and the periods it began or ended, each with its voices. Only a move made by the clock playing (`tick`) or by a step forward calls
+ * cues; a seek, a jump back, a pause or a change of speed calls none, as scrubbing announces nothing. The end of the last period is the game's end.
+ * @example
+ * ```ts
+ * import { cuesOfChange } from "@johnmorrisdotca/kyogijo-stadiums/sound";
+ * const state = { t: 10, start: 0, end: 60, playing: true, ended: false, speed: 1, loop: false, motion: "smooth" as const, follow: "off" as const, followHeld: false };
+ * const change = { state, reason: "tick" as const, crossed: [{ t: 9.5, kind: "goal", team: "home" as const }] };
+ * console.log(cuesOfChange(change, 9, "nhl").map((c) => c.voice).join());
+ * console.log(cuesOfChange({ ...change, reason: "seek" as const }, 9, "nhl").length);
+ * // horn,swell
+ * // 0
+ * ```
+ */
+export function cuesOfChange(change, from, sport, periods = []) {
+    if (change.reason !== "tick" && change.reason !== "step")
+        return [];
+    const to = change.state.t;
+    if (!(to > from))
+        return [];
+    const found = soundSetOf(sport);
+    if (found === undefined)
+        return [];
+    const marks = [];
+    for (const event of change.crossed) {
+        const kind = cueKindOf(event);
+        if (kind !== undefined)
+            marks.push(event.team === undefined ? { t: event.t, kind } : { t: event.t, kind, team: event.team });
+    }
+    periods.forEach((p, i) => {
+        if (p.start > from && p.start <= to)
+            marks.push({ t: p.start, kind: "period-start" });
+        if (p.end > from && p.end <= to)
+            marks.push({ t: p.end, kind: i === periods.length - 1 ? "game-end" : "period-end" });
+    });
+    marks.sort((a, b) => a.t - b.t);
+    const out = [];
+    for (const mark of marks)
+        for (const voice of found.cues[mark.kind] ?? [])
+            out.push(mark.team === undefined ? { voice, kind: mark.kind, t: mark.t } : { voice, kind: mark.kind, t: mark.t, team: mark.team });
+    return out;
+}

package/dist/sound.sets.d.ts

@@ -0,0 +1,70 @@
+import type { Sport } from "./types.ts";
+/** How excited a crowd is, from a near-empty room to a roar. */
+export type SoundLevel = "quiet" | "murmur" | "engaged" | "loud" | "roar";
+/** The levels, quietest first. */
+export declare const SOUND_LEVELS: readonly SoundLevel[];
+/**
+ * The layers of a crowd bed, each a loop the engine keeps running while the sound is on, and turns up and down: `room` the air of the building, `murmur` people talking, `applause` hands, `roar`
+ * a crowd's voice together. The pool's bed has `water` as well.
+ */
+export type SoundLayer = "room" | "murmur" | "applause" | "roar" | "water";
+/** The voices a cue may use. Each is a short sound the engine makes in the browser, or plays from a file a page gives (`files`). */
+export type SoundVoice = 
+/** An arena's goal horn: one long blast of a low chord, never a tune. */
+"horn"
+/** A referee's pea whistle, with its trill. */
+ | "whistle"
+/** A long whistle and two short ones before it: the end of a game in football and the field games. */
+ | "whistle-end"
+/** A scoreboard's buzzer at the end of a period. */
+ | "buzzer"
+/** A ring's bell, struck three times. */
+ | "bell"
+/** A starting gun. */
+ | "gun"
+/** The electronic start of a swimming race. */
+ | "beep"
+/** A crowd that rises for a moment: "ooh", a near miss. */
+ | "ooh"
+/** A cheer of a few people, for a point in a quiet hall. */
+ | "cheer"
+/** Applause that comes and goes. */
+ | "applause"
+/** The whole crowd's roar, swelling and settling over some seconds: a goal. */
+ | "swell";
+/** What a kind of venue sounds like: the bed's layers and the room they are heard in. */
+export interface SoundBed {
+    /** The kind of venue, as in `SOUND_BEDS`. */
+    id: SoundBedId;
+    /** Indoors (an arena, a hall, a pool) or out (a stadium, a ballpark, a track) when the venue says nothing of its roof. */
+    indoor: boolean;
+    /** How long the room rings, in seconds, for a venue of `seats` people: a full arena is about 2 s, a stadium in the open about 0.6 s. */
+    decay: number;
+    /** The people the bed is made for: a venue of other size is louder or quieter than the bed by the share of people (the context's `seats`). */
+    seats: number;
+    /** The layers the bed has. */
+    layers: readonly SoundLayer[];
+    /** The crowd levels it offers, quietest first: a dojo for kyudo has no roar. */
+    levels: readonly SoundLevel[];
+}
+/** The kinds of venue that have a bed. */
+export type SoundBedId = "arena" | "stadium" | "ballpark" | "hall" | "pool" | "dojo" | "ring" | "track";
+/** The crowd beds, one for each kind of venue. */
+export declare const SOUND_BEDS: Readonly<Record<SoundBedId, SoundBed>>;
+/** The kinds of moment a cue answers. A timeline's own event kinds are read into these by `cueKindOf`. */
+export type CueKind = "goal" | "point" | "shot" | "whistle" | "period-start" | "period-end" | "game-end" | "start" | "finish" | "round-start" | "round-end";
+/** The kinds of moment, in the order the docs list them. */
+export declare const CUE_KINDS: readonly CueKind[];
+/** A sport's sound: the bed of its usual venue and what plays for each kind of moment (nothing, for a kind it does not list). */
+export interface SoundSet {
+    /** The set's id: the sport's family (`hockey`, `soccer`, `court`, ...). */
+    id: string;
+    bed: SoundBedId;
+    cues: Readonly<Partial<Record<CueKind, readonly SoundVoice[]>>>;
+    /** The crowd levels this sport offers, when fewer than its bed's (kyudo: a still hall). */
+    levels?: readonly SoundLevel[];
+}
+/** The sound sets, by family: a sport takes its family's (`SOUND_OF_SPORT`). */
+export declare const SOUND_SETS: Readonly<Record<string, SoundSet>>;
+/** Which set each sport takes: every surface the package draws has one. */
+export declare const SOUND_OF_SPORT: Readonly<Record<Sport, string>>;

package/dist/sound.sets.js

@@ -0,0 +1,85 @@
+/** The levels, quietest first. */
+export const SOUND_LEVELS = ["quiet", "murmur", "engaged", "loud", "roar"];
+const ALL = SOUND_LEVELS;
+const CROWD = ["room", "murmur", "applause", "roar"];
+/** The crowd beds, one for each kind of venue. */
+export const SOUND_BEDS = {
+    arena: { id: "arena", indoor: true, decay: 2.2, seats: 18000, layers: CROWD, levels: ALL },
+    stadium: { id: "stadium", indoor: false, decay: 0.7, seats: 50000, layers: CROWD, levels: ALL },
+    ballpark: { id: "ballpark", indoor: false, decay: 0.6, seats: 40000, layers: CROWD, levels: ALL },
+    hall: { id: "hall", indoor: true, decay: 1.6, seats: 4000, layers: CROWD, levels: ALL },
+    pool: { id: "pool", indoor: true, decay: 2.6, seats: 5000, layers: ["room", "water", "murmur", "applause", "roar"], levels: ALL },
+    dojo: { id: "dojo", indoor: true, decay: 1.3, seats: 2000, layers: ["room", "murmur", "applause"], levels: ["quiet", "murmur", "engaged", "loud"] },
+    ring: { id: "ring", indoor: true, decay: 1.8, seats: 8000, layers: CROWD, levels: ALL },
+    track: { id: "track", indoor: false, decay: 0.8, seats: 30000, layers: CROWD, levels: ALL },
+};
+/** The kinds of moment, in the order the docs list them. */
+export const CUE_KINDS = ["goal", "point", "shot", "whistle", "period-start", "period-end", "game-end", "start", "finish", "round-start", "round-end"];
+const FIELD = { goal: ["swell"], point: ["cheer"], shot: ["ooh"], whistle: ["whistle"], "period-start": ["whistle"], "period-end": ["whistle-end"], "game-end": ["whistle-end", "swell"] };
+const COURT = { goal: ["applause"], point: ["applause"], shot: ["ooh"], whistle: ["whistle"], "period-end": ["whistle"], "game-end": ["applause", "swell"] };
+const set = (id, bed, cues, levels) => (levels === undefined ? { id, bed, cues } : { id, bed, cues, levels });
+/** The sound sets, by family: a sport takes its family's (`SOUND_OF_SPORT`). */
+export const SOUND_SETS = {
+    hockey: set("hockey", "arena", { goal: ["horn", "swell"], point: ["horn", "swell"], shot: ["ooh"], whistle: ["whistle"], "period-end": ["buzzer"], "game-end": ["buzzer", "horn", "swell"] }),
+    basketball: set("basketball", "arena", { goal: ["cheer"], point: ["cheer"], shot: ["ooh"], whistle: ["whistle"], "period-end": ["buzzer"], "game-end": ["buzzer", "swell"] }),
+    football: set("football", "stadium", { ...FIELD, "period-end": ["whistle"], "game-end": ["whistle", "swell"] }),
+    soccer: set("soccer", "stadium", FIELD),
+    field: set("field", "stadium", FIELD),
+    baseball: set("baseball", "ballpark", { goal: ["swell"], point: ["swell"], shot: ["ooh"], "game-end": ["swell"] }),
+    cricket: set("cricket", "ballpark", { goal: ["applause"], point: ["applause"], shot: ["ooh"], "game-end": ["applause"] }),
+    court: set("court", "hall", COURT),
+    curling: set("curling", "hall", { goal: ["applause"], point: ["applause"], shot: ["ooh"], "game-end": ["applause"] }, ["quiet", "murmur", "engaged"]),
+    pool: set("pool", "pool", { start: ["beep"], goal: ["swell"], point: ["cheer"], finish: ["swell"], whistle: ["whistle"], "game-end": ["swell"] }),
+    track: set("track", "track", { start: ["gun"], finish: ["swell"], goal: ["swell"], point: ["cheer"], "game-end": ["applause"] }),
+    skating: set("skating", "arena", { start: ["gun"], finish: ["swell"], goal: ["swell"], point: ["applause"], "game-end": ["applause"] }),
+    budo: set("budo", "dojo", { goal: ["applause"], point: ["applause"], "game-end": ["applause"] }),
+    kyudo: set("kyudo", "dojo", { goal: ["applause"], point: ["applause"], "game-end": ["applause"] }, ["quiet", "murmur"]),
+    sumo: set("sumo", "ring", { goal: ["swell"], point: ["swell"], "game-end": ["swell"] }),
+    combat: set("combat", "ring", { goal: ["swell"], point: ["ooh"], shot: ["ooh"], "round-start": ["bell"], "round-end": ["bell"], "game-end": ["bell", "swell"] }),
+};
+/** Which set each sport takes: every surface the package draws has one. */
+export const SOUND_OF_SPORT = {
+    nfl: "football",
+    cfl: "football",
+    ifaf: "football",
+    nhl: "hockey",
+    nba: "basketball",
+    mlb: "baseball",
+    soccer: "soccer",
+    curling: "curling",
+    tennis: "court",
+    volleyball: "court",
+    badminton: "court",
+    pickleball: "court",
+    tabletennis: "court",
+    padel: "court",
+    squash: "court",
+    racquetball: "court",
+    sepaktakraw: "court",
+    teqball: "court",
+    roundnet: "court",
+    netball: "court",
+    handball: "court",
+    swimming: "pool",
+    waterpolo: "pool",
+    diving: "pool",
+    artisticswimming: "pool",
+    athletics: "track",
+    skating: "skating",
+    judo: "budo",
+    karate: "budo",
+    kendo: "budo",
+    dojo: "budo",
+    kyudo: "kyudo",
+    sumo: "sumo",
+    mma: "combat",
+    boxing: "combat",
+    wrestling: "combat",
+    prowrestling: "combat",
+    lacrosse: "field",
+    rugby: "field",
+    afl: "field",
+    gaelic: "field",
+    fieldhockey: "field",
+    cricket: "cricket",
+};

package/dist/sound.synth.d.ts

@@ -0,0 +1,38 @@
+import type { SoundLayer, SoundVoice } from "./sound.sets.ts";
+/** A seeded generator of numbers from 0 to 1 (mulberry32): the noise is the same every time. */
+export declare function seeded(seed: number): () => number;
+/** The colours of noise: `white` flat, `pink` falling 3 dB an octave (a crowd's), `brown` falling 6 (a building's air). */
+export type NoiseColour = "white" | "pink" | "brown";
+/** Samples of noise of a colour, from a seed, between -1 and 1. */
+export declare function noiseSamples(length: number, seed: number, colour?: NoiseColour): Float32Array;
+/** Samples of hands clapping: many short bursts of noise at random moments, `density` claps a second, for `length` samples at `rate`. */
+export declare function applauseSamples(length: number, rate: number, seed: number, density?: number): Float32Array;
+/** Samples of people talking: noise whose level rises and falls with syllables, about four a second from each of many voices, summed. */
+export declare function murmurSamples(length: number, rate: number, seed: number, voices?: number): Float32Array;
+/** A room's echo as an impulse response: noise falling 60 dB over `decay` seconds, two channels a little apart. */
+export declare function impulseSamples(decay: number, rate: number, seed: number): [Float32Array, Float32Array];
+/** A buffer of the context from samples (one channel, or two). */
+export declare function bufferOf(context: BaseAudioContext, channels: readonly Float32Array[]): AudioBuffer;
+/** How many seconds each made layer loops for: long enough that the loop is not heard. */
+export declare const LAYER_SECONDS = 6;
+/**
+ * How much each made layer is turned down or up so that, through its filter, it is as loud as the demo's recordings are made (an RMS of -20 dBFS; the pool's water -22, and the building's air
+ * a quiet -30): measured once in a browser by rendering each layer offline.
+ */
+export declare const LAYER_TRIM: Readonly<Record<SoundLayer, number>>;
+/** The buffer a layer loops when it has no recording. */
+export declare function layerBuffer(context: BaseAudioContext, layer: SoundLayer): AudioBuffer;
+/** The filter that shapes a made layer: the building's low air, water's hiss, talk's middle, a crowd's voice. */
+export declare function layerFilter(context: BaseAudioContext, layer: SoundLayer): AudioNode;
+/** The loops a made voice is cut from, made the first time a voice needs one and kept by the caller. */
+export interface VoiceBuffers {
+    /** Pink noise. */
+    noise(): AudioBuffer;
+    /** Hands clapping. */
+    applause(): AudioBuffer;
+}
+/**
+ * Make a voice in the browser at `when` on the context's clock, into `out`, from the noise of `noise` (a pink loop). Returns when it ends. The horn is one chord held, never a tune; the
+ * swell is not here, as it moves the bed's roar (the engine does it).
+ */
+export declare function makeVoice(context: BaseAudioContext, voice: Exclude<SoundVoice, "swell">, out: AudioNode, buffers: VoiceBuffers, when: number): number;