@@ -39,7 +39,7 @@ Open `index.html` in a browser, or serve the folder with any static file server.
 - **Stats**: a dialog, opened from the chart icon in the header, with your best WPM for every setting you have played, the average of your last ten runs, and a list of recorded runs. Export saves everything in `localStorage` to a JSON file, Import loads such a file and replaces the stored data, and Clear data (two clicks) removes history, bests, and key stats.
 - **Themes**: System (follows the OS light/dark and increased-contrast settings), Dark, Light, and High contrast, chosen in Settings. `theme.js`, loaded in `<head>`, applies the saved theme before the page paints.
 - **Offline and install**: `sw.js`, a service worker, saves the app's files on the first visit, so later visits load without a network connection. It tries the network first, so a new version is used as soon as you are online. `manifest.webmanifest` and the icons in `icons/` let browsers install the page as an app.
-- **Sound**: short tones made with the Web Audio API for keypress, mistake, and completion. Can be turned off.
+- **Sound**: short tones made with the Web Audio API for keypress, mistake, and completion, defined as a table of recipes in `script.js`. The audio context is created on the first keystroke, at most 16 tones play at once, and nothing is created while sound is off. Can be turned off.
 - **Keyboard**: Tab restarts while you are typing. Escape closes a dialog. Opening Settings during a run abandons the run.
 - **Focus**: if the typing input loses focus, a hint appears over the text. Pressing a letter key moves focus back to the input.
 - **Screen readers**: the passage is available as the input's description, settings buttons report whether they are selected, and the result dialog reads out WPM and accuracy.
 
@@ -261,73 +261,101 @@ function currentBest() {
 }
 
 // --- Audio ---
-// Created on first use so the browser does not warn about an AudioContext
-// started before any user gesture.
-let audioContext = null;
+// Each sound is a recipe: oscillator shape, start and end frequency,
+// duration, and volume. `steps` lists sub-recipes with start offsets in
+// seconds, for sounds made of several notes.
+const SOUNDS = {
+    click: { wave: 'sine', freq: 800, toFreq: 400, duration: 0.05, volume: 0.05, jitter: 0.03 },
+    error: {
+        wave: 'sawtooth',
+        freq: 100,
+        toFreq: 80,
+        slide: 'linear',
+        duration: 0.15,
+        volume: 0.08,
+    },
+    // C5, E5, G5, C6
+    success: {
+        steps: [523.25, 659.25, 783.99, 1046.5].map((freq, i) => ({
+            at: i * 0.1,
+            wave: 'sine',
+            freq,
+            duration: 0.5,
+            volume: 0.05,
+        })),
+    },
+};
+
+const MAX_VOICES = 16; // oldest voice is stopped beyond this
+const GAIN_FLOOR = 0.0001; // exponential ramps cannot reach 0
+
+// The context is created on the first sound, after a keystroke, so the
+// browser does not start it suspended. Every voice goes through one master
+// gain node. If Web Audio is missing or blocked, sounds are skipped.
+const audio = { context: null, master: null, failed: false, voices: [] };
 
 function getAudioContext() {
-    if (!audioContext) {
-        const Ctx = window.AudioContext || window.webkitAudioContext;
-        if (!Ctx) return null;
-        audioContext = new Ctx();
+    if (audio.failed) return null;
+    if (!audio.context) {
+        try {
+            const Ctx = window.AudioContext || window.webkitAudioContext;
+            audio.context = new Ctx();
+            audio.master = audio.context.createGain();
+            audio.master.connect(audio.context.destination);
+        } catch {
+            audio.failed = true;
+            audio.context = null;
+            return null;
+        }
     }
-    if (audioContext.state === 'suspended') audioContext.resume();
-    return audioContext;
+    if (audio.context.state === 'suspended') audio.context.resume().catch(() => {});
+    return audio.context;
 }
 
-function playTone(ctx, { type, startFreq, endFreq, ramp, gain, duration, at }) {
+function playVoice(ctx, recipe, at) {
+    while (audio.voices.length >= MAX_VOICES) audio.voices.shift().stop();
+
+    // A few percent of random pitch keeps repeated clicks from sounding identical.
+    const jitter = recipe.jitter ? 1 + (Math.random() * 2 - 1) * recipe.jitter : 1;
+    const duration = recipe.duration > 0 ? recipe.duration : 0.1;
     const osc = ctx.createOscillator();
-    const gainNode = ctx.createGain();
-    osc.connect(gainNode);
-    gainNode.connect(ctx.destination);
-    osc.type = type;
-    osc.frequency.setValueAtTime(startFreq, at);
-    if (endFreq !== undefined) {
-        if (ramp === 'linear') osc.frequency.linearRampToValueAtTime(endFreq, at + duration);
-        else osc.frequency.exponentialRampToValueAtTime(endFreq, at + duration);
+    const gain = ctx.createGain();
+    osc.connect(gain);
+    gain.connect(audio.master);
+    osc.type = recipe.wave || 'square';
+    osc.frequency.setValueAtTime(Math.max(recipe.freq * jitter, 1), at);
+    if (recipe.toFreq !== undefined) {
+        const target = Math.max(recipe.toFreq * jitter, 1);
+        if (recipe.slide === 'linear') osc.frequency.linearRampToValueAtTime(target, at + duration);
+        else osc.frequency.exponentialRampToValueAtTime(target, at + duration);
     }
-    gainNode.gain.setValueAtTime(gain, at);
-    gainNode.gain.exponentialRampToValueAtTime(0.001, at + duration);
+    gain.gain.setValueAtTime(Math.max(recipe.volume ?? 0.08, GAIN_FLOOR), at);
+    gain.gain.exponentialRampToValueAtTime(GAIN_FLOOR, at + duration);
     osc.start(at);
     osc.stop(at + duration);
+
+    audio.voices.push(osc);
+    osc.onended = () => {
+        osc.disconnect();
+        gain.disconnect();
+        const index = audio.voices.indexOf(osc);
+        if (index !== -1) audio.voices.splice(index, 1);
+    };
 }
 
-function playSound(type) {
+// Fire and forget: never throws, and returns before touching Web Audio when
+// sound is off.
+function playSound(name) {
     if (!gameState.isSoundEnabled) return;
+    const recipe = SOUNDS[name];
+    if (!recipe) return;
     const ctx = getAudioContext();
     if (!ctx) return;
-    const now = ctx.currentTime;
-
-    if (type === 'click') {
-        playTone(ctx, {
-            type: 'sine',
-            startFreq: 800,
-            endFreq: 400,
-            gain: 0.05,
-            duration: 0.05,
-            at: now,
-        });
-    } else if (type === 'error') {
-        playTone(ctx, {
-            type: 'sawtooth',
-            startFreq: 100,
-            endFreq: 80,
-            ramp: 'linear',
-            gain: 0.08,
-            duration: 0.15,
-            at: now,
-        });
-    } else if (type === 'success') {
-        // C5, E5, G5, C6
-        [523.25, 659.25, 783.99, 1046.5].forEach((note, i) => {
-            playTone(ctx, {
-                type: 'sine',
-                startFreq: note,
-                gain: 0.05,
-                duration: 0.5,
-                at: now + i * 0.1,
-            });
-        });
+    try {
+        const now = ctx.currentTime;
+        for (const step of recipe.steps || [recipe]) playVoice(ctx, step, now + (step.at || 0));
+    } catch {
+        // A failed sound must not interrupt typing.
     }
 }
 
 
@@ -2,7 +2,8 @@
 // browser, where script.js's top-level consts are in scope.
 /* global runtime, gameState, resultModal, typingInputElement, wpmElement, updateMetrics,
    getPassage, settingsKey, COMMON_WORDS, QUOTES, renderNewQuote, parseChallenge,
-   decodeChallenge, encodeChallenge, normalizeCustomText, CODE_SNIPPETS */
+   decodeChallenge, encodeChallenge, normalizeCustomText, CODE_SNIPPETS, playSound, playVoice,
+   getAudioContext, audio, SOUNDS */
 
 const { test, expect } = require('@playwright/test');
 const { default: AxeBuilder } = require('@axe-core/playwright');
@@ -626,27 +627,46 @@ test('hard mode blurs typed characters and leaves the rest readable', async ({ p
 test.describe('sound', () => {
     // Counts AudioContexts and tones without making noise.
     const stubAudio = () => {
-        window.audio = { contexts: 0, tones: 0 };
-        const param = {
-            setValueAtTime() {},
-            linearRampToValueAtTime() {},
-            exponentialRampToValueAtTime() {},
-        };
+        window.audioCalls = { contexts: 0, tones: 0, stopped: 0, rampTargets: [] };
+        const calls = window.audioCalls;
+        const param = () => ({
+            setValueAtTime(value) {
+                calls.rampTargets.push(value);
+            },
+            linearRampToValueAtTime(value) {
+                calls.rampTargets.push(value);
+            },
+            exponentialRampToValueAtTime(value) {
+                calls.rampTargets.push(value);
+            },
+        });
+        // Oscillators never end on their own here, so the voice cap is what
+        // limits how many stay alive.
         class FakeAudioContext {
             constructor() {
-                window.audio.contexts++;
+                calls.contexts++;
                 this.state = 'running';
                 this.currentTime = 0;
                 this.destination = {};
             }
             createOscillator() {
-                window.audio.tones++;
-                return { connect() {}, frequency: param, start() {}, stop() {} };
+                calls.tones++;
+                return {
+                    frequency: param(),
+                    connect() {},
+                    disconnect() {},
+                    start() {},
+                    stop() {
+                        calls.stopped++;
+                    },
+                };
             }
             createGain() {
-                return { connect() {}, gain: param };
+                return { gain: param(), connect() {}, disconnect() {} };
+            }
+            resume() {
+                return Promise.resolve();
             }
-            resume() {}
         }
         window.AudioContext = FakeAudioContext;
         window.webkitAudioContext = FakeAudioContext;
@@ -655,10 +675,17 @@ test.describe('sound', () => {
     test('creates the audio context on the first keystroke, not at load', async ({ page }) => {
         await page.addInitScript(stubAudio);
         await page.goto('/');
-        expect(await page.evaluate(() => window.audio)).toEqual({ contexts: 0, tones: 0 });
+        const counts = () =>
+            page.evaluate(() => ({
+                contexts: window.audioCalls.contexts,
+                tones: window.audioCalls.tones,
+            }));
+        expect(await counts()).toEqual({ contexts: 0, tones: 0 });
 
         await input(page).press((await currentQuote(page))[0]);
-        expect(await page.evaluate(() => window.audio)).toEqual({ contexts: 1, tones: 1 });
+        expect(await counts()).toEqual({ contexts: 1, tones: 1 });
+        await input(page).press((await currentQuote(page))[1]);
+        expect(await counts()).toEqual({ contexts: 1, tones: 2 });
     });
 
     test('plays nothing when turned off', async ({ page }) => {
@@ -668,7 +695,54 @@ test.describe('sound', () => {
         });
         await page.goto('/');
         await input(page).pressSequentially((await currentQuote(page)).slice(0, 5));
-        expect(await page.evaluate(() => window.audio)).toEqual({ contexts: 0, tones: 0 });
+        expect(
+            await page.evaluate(() => [window.audioCalls.contexts, window.audioCalls.tones])
+        ).toEqual([0, 0]);
+    });
+
+    test('caps live voices at 16 and stops the oldest', async ({ page }) => {
+        await page.addInitScript(stubAudio);
+        await page.goto('/');
+        const result = await page.evaluate(() => {
+            for (let n = 0; n < 100; n++) playSound('click');
+            return { live: audio.voices.length, stopped: window.audioCalls.stopped };
+        });
+        expect(result.live).toBe(16);
+        // Each voice calls stop() once when scheduled; 84 more were stopped early.
+        expect(result.stopped).toBe(100 + 84);
+    });
+
+    test('recipes compile to positive frequencies, durations, and ramp targets', async ({
+        page,
+    }) => {
+        await page.addInitScript(stubAudio);
+        await page.goto('/');
+        const result = await page.evaluate(() => {
+            const steps = Object.values(SOUNDS).flatMap((recipe) => recipe.steps || [recipe]);
+            const valid = steps.every((step) => step.freq > 0 && step.duration > 0);
+            // A recipe sliding to 0 Hz at volume 0 must not throw or ramp to 0.
+            getAudioContext();
+            window.audioCalls.rampTargets = [];
+            playVoice(audio.context, { freq: 440, toFreq: 0, volume: 0, duration: 0.1 }, 0);
+            return { valid, targets: window.audioCalls.rampTargets };
+        });
+        expect(result.valid).toBe(true);
+        expect(result.targets.length).toBeGreaterThan(0);
+        for (const value of result.targets) expect(value).toBeGreaterThan(0);
+    });
+
+    test('a missing or blocked AudioContext is skipped without errors', async ({ page }) => {
+        await page.addInitScript(() => {
+            window.AudioContext = function () {
+                throw new Error('blocked');
+            };
+            window.webkitAudioContext = undefined;
+        });
+        const errors = collectErrors(page);
+        await page.goto('/');
+        await input(page).pressSequentially((await currentQuote(page)).slice(0, 3));
+        expect(await page.evaluate(() => [audio.failed, runtime.typedChars])).toEqual([true, 3]);
+        expect(errors).toEqual([]);
     });
 });