tempest-react-sdk 0.77.0 → 0.79.0

package/dist/audio/sfx-pool.js.map

@@ -1 +1 @@
-{"version":3,"file":"sfx-pool.js","names":[],"sources":["../../src/audio/sfx-pool.ts"],"sourcesContent":["/** Options for {@link createSfxPool}. */\nexport interface SfxPoolOptions {\n    /**\n     * Master volume, `0`–`1`, multiplied into every per-play volume. Default\n     * `1`. Wire it to the app's sound setting so one value governs the lot.\n     */\n    volume?: number;\n    /**\n     * Prefix applied to sources that are not absolute URLs — typically Vite's\n     * `import.meta.env.BASE_URL`, so a build served from a subpath resolves.\n     * Default `\"\"`.\n     */\n    baseUrl?: string;\n    /**\n     * Elements kept per source. `1` (the default) restarts the clip on every\n     * play, which is what a menu blip wants. Raise it to let a sound overlap\n     * itself — a hit landing while the previous one is still ringing.\n     */\n    voices?: number;\n    /**\n     * Maximum number of distinct sources held. When exceeded, the least\n     * recently played source is released. Default `48`.\n     */\n    maxSources?: number;\n}\n\n/** Per-play overrides. */\nexport interface PlaySfxOptions {\n    /** Volume for this play, `0`–`1`, multiplied by the pool's master. Default `1`. */\n    volume?: number;\n}\n\n/** Imperative handle over a pool of short sound effects. */\nexport interface SfxPool {\n    /** Play a clip, allocating and caching its element on first use. */\n    play: (src: string, options?: PlaySfxOptions) => void;\n    /** Fetch clips ahead of the first play, so it is not silent while the file downloads. */\n    preload: (src: string | string[]) => void;\n    /** Set the master volume, applying it to anything already sounding. */\n    setVolume: (volume: number) => void;\n    /** Stop one source, or every source when called with no argument. */\n    stop: (src?: string) => void;\n    /** Release every element. Call on unmount. */\n    dispose: () => void;\n}\n\n/** Clamp to the range `HTMLMediaElement.volume` accepts, rejecting `NaN`. */\nfunction clampVolume(value: number): number {\n    if (!Number.isFinite(value)) return 1;\n    return Math.min(1, Math.max(0, value));\n}\n\n/**\n * A pool of preallocated `<audio>` elements for short sound effects.\n *\n * `new Audio(src)` on every play allocates an element and re-enters the network\n * stack for a file the browser already has, which is the wrong shape for a\n * sound that fires dozens of times a minute — a UI blip, a hit, a pickup. The\n * pool allocates once per source and replays.\n *\n * This is deliberately not {@link createAudioPlayer}: that handle tracks a\n * single \"current\" clip with loop, sink routing and lifecycle callbacks, which\n * is what background music needs. Effects are the opposite case — many\n * sources, all short, fire-and-forget, and the only thing that matters is that\n * firing one is cheap.\n *\n * A blocked `play()` is swallowed. Browsers reject playback until the user has\n * interacted with the page, and a sound effect is by definition not worth\n * interrupting anything over; call {@link SfxPool.preload} after the first\n * interaction if you want the pool warm.\n *\n * @param options - Master volume, base URL, voices per source and pool size.\n * @returns The pool handle.\n *\n * @example\n * const sfx = createSfxPool({ volume: 0.6, baseUrl: import.meta.env.BASE_URL });\n * sfx.preload([\"sfx/select.mp3\", \"sfx/back.mp3\"]);\n *\n * <button onClick={() => sfx.play(\"sfx/select.mp3\")}>Confirmar</button>\n */\n/** One source's voices plus the round-robin cursor over them. */\ninterface SourceEntry {\n    /** The audio elements sharing this source. */\n    elements: HTMLAudioElement[];\n    /** Index of the element the next play claims. */\n    next: number;\n}\n\n/**\n * Resolve a source against the pool's base URL.\n *\n * An absolute URL, a protocol-relative one and a `data:` URI are already\n * addresses — prefixing them would produce a path that resolves to nothing.\n *\n * @param baseUrl - Pool base, possibly empty.\n * @param src - Source as the caller wrote it.\n * @returns The URL to load.\n */\nfunction resolveSource(baseUrl: string, src: string): string {\n    if (!baseUrl || /^(https?:)?\\/\\//.test(src) || src.startsWith(\"data:\")) return src;\n    return `${baseUrl.replace(/\\/$/, \"\")}/${src.replace(/^\\//, \"\")}`;\n}\n\n/**\n * Stop every voice of an entry and let the browser drop its buffer.\n *\n * Removing `src` before `load()` is what frees the decoded audio: `load()` on an\n * element that still has a source re-fetches it instead.\n *\n * @param entry - The entry being evicted.\n */\nfunction releaseEntry(entry: { elements: HTMLAudioElement[] }): void {\n    for (const element of entry.elements) {\n        element.pause();\n        element.removeAttribute(\"src\");\n        element.load();\n    }\n}\n\n/**\n * Drop the least recently played source once the pool is over its cap.\n *\n * The map is insertion-ordered by last play, so the first key is the coldest.\n * The source that was just admitted is never the one evicted, which would\n * otherwise happen with a cap of one.\n *\n * @param sources - The live pool, mutated in place.\n * @param keepUrl - The source that must survive this eviction.\n * @param maxSources - How many sources the pool may hold.\n */\nfunction evictLeastRecent(\n    sources: Map<string, SourceEntry>,\n    keepUrl: string,\n    maxSources: number,\n): void {\n    if (sources.size <= maxSources) return;\n    const oldest = sources.keys().next();\n    if (oldest.done || oldest.value === keepUrl) return;\n    const evicted = sources.get(oldest.value);\n    if (evicted) releaseEntry(evicted);\n    sources.delete(oldest.value);\n}\n\nexport function createSfxPool(options: SfxPoolOptions = {}): SfxPool {\n    const { baseUrl = \"\", voices = 1, maxSources = 48 } = options;\n\n    let master = clampVolume(options.volume ?? 1);\n    const voiceCount = Math.max(1, Math.floor(voices));\n\n    /**\n     * Insertion-ordered by last play, so evicting the first key drops the\n     * least recently used source.\n     */\n    const sources = new Map<string, SourceEntry>();\n\n    /**\n     * Per-play gain of whatever each element last played at.\n     *\n     * `setVolume` has to rescale live playback by the same factor it was\n     * started with; assigning the master directly would yank a clip that\n     * started at half volume up to full.\n     */\n    const gains = new WeakMap<HTMLAudioElement, number>();\n\n    /**\n     * The pool entry for a source, creating and admitting it when it is new.\n     *\n     * Re-inserts an existing entry so the map order stays \"least recently used\n     * first\", which is what makes evicting the first key correct.\n     *\n     * `created` is reported because assigning `src` on an element whose `preload`\n     * is `\"auto\"` already starts the fetch: calling `load()` on an entry that was\n     * merely looked up would abort that fetch and discard whatever is already\n     * buffered, per the media element load algorithm.\n     *\n     * @param src - Raw source, resolved against `baseUrl`.\n     * @returns The entry and whether this call created it, or `null` where\n     *   `Audio` does not exist.\n     */\n    function acquire(src: string): { entry: SourceEntry; created: boolean } | null {\n        if (typeof Audio === \"undefined\") return null;\n\n        const url = resolveSource(baseUrl, src);\n        const existing = sources.get(url);\n        if (existing) {\n            sources.delete(url);\n            sources.set(url, existing);\n            return { entry: existing, created: false };\n        }\n\n        const entry: SourceEntry = {\n            elements: Array.from({ length: voiceCount }, () => {\n                const element = new Audio(url);\n                element.preload = \"auto\";\n                return element;\n            }),\n            next: 0,\n        };\n        sources.set(url, entry);\n\n        evictLeastRecent(sources, url, maxSources);\n\n        return { entry, created: true };\n    }\n\n    return {\n        play(src, playOptions = {}) {\n            const acquired = acquire(src);\n            if (!acquired) return;\n\n            const entry = acquired.entry;\n            const element = entry.elements[entry.next];\n            entry.next = (entry.next + 1) % entry.elements.length;\n\n            const gain = clampVolume(playOptions.volume ?? 1);\n            gains.set(element, gain);\n\n            element.pause();\n            element.currentTime = 0;\n            element.volume = clampVolume(gain * master);\n            void element.play().catch(() => {});\n        },\n\n        preload(src) {\n            for (const one of Array.isArray(src) ? src : [src]) {\n                const acquired = acquire(one);\n                if (!acquired?.created) continue;\n                for (const element of acquired.entry.elements) element.load();\n            }\n        },\n\n        setVolume(volume) {\n            master = clampVolume(volume);\n            for (const entry of sources.values()) {\n                for (const element of entry.elements) {\n                    if (element.paused) continue;\n                    element.volume = clampVolume((gains.get(element) ?? 1) * master);\n                }\n            }\n        },\n\n        stop(src) {\n            const targets = src\n                ? [sources.get(resolveSource(baseUrl, src))]\n                : [...sources.values()];\n            for (const entry of targets) {\n                if (!entry) continue;\n                for (const element of entry.elements) {\n                    element.pause();\n                    element.currentTime = 0;\n                }\n            }\n        },\n\n        dispose() {\n            for (const entry of sources.values()) releaseEntry(entry);\n            sources.clear();\n        },\n    };\n}\n"],"mappings":"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"}
+{"version":3,"file":"sfx-pool.js","names":["clampVolume","value","resolveSource","baseUrl","src","releaseEntry","element","entry","evictLeastRecent","sources","maxSources","oldest","keepUrl","evicted","createSfxPool","options","master","voiceCount","voices","gains","acquire","url","existing","acquired","gain","playOptions","one","volume","targets"],"sources":["../../src/audio/sfx-pool.ts"],"sourcesContent":["/** Options for {@link createSfxPool}. */\nexport interface SfxPoolOptions {\n    /**\n     * Master volume, `0`–`1`, multiplied into every per-play volume. Default\n     * `1`. Wire it to the app's sound setting so one value governs the lot.\n     */\n    volume?: number;\n    /**\n     * Prefix applied to sources that are not absolute URLs — typically Vite's\n     * `import.meta.env.BASE_URL`, so a build served from a subpath resolves.\n     * Default `\"\"`.\n     */\n    baseUrl?: string;\n    /**\n     * Elements kept per source. `1` (the default) restarts the clip on every\n     * play, which is what a menu blip wants. Raise it to let a sound overlap\n     * itself — a hit landing while the previous one is still ringing.\n     */\n    voices?: number;\n    /**\n     * Maximum number of distinct sources held. When exceeded, the least\n     * recently played source is released. Default `48`.\n     */\n    maxSources?: number;\n}\n\n/** Per-play overrides. */\nexport interface PlaySfxOptions {\n    /** Volume for this play, `0`–`1`, multiplied by the pool's master. Default `1`. */\n    volume?: number;\n}\n\n/** Imperative handle over a pool of short sound effects. */\nexport interface SfxPool {\n    /** Play a clip, allocating and caching its element on first use. */\n    play: (src: string, options?: PlaySfxOptions) => void;\n    /** Fetch clips ahead of the first play, so it is not silent while the file downloads. */\n    preload: (src: string | string[]) => void;\n    /** Set the master volume, applying it to anything already sounding. */\n    setVolume: (volume: number) => void;\n    /** Stop one source, or every source when called with no argument. */\n    stop: (src?: string) => void;\n    /** Release every element. Call on unmount. */\n    dispose: () => void;\n}\n\n/** Clamp to the range `HTMLMediaElement.volume` accepts, rejecting `NaN`. */\nfunction clampVolume(value: number): number {\n    if (!Number.isFinite(value)) return 1;\n    return Math.min(1, Math.max(0, value));\n}\n\n/**\n * A pool of preallocated `<audio>` elements for short sound effects.\n *\n * `new Audio(src)` on every play allocates an element and re-enters the network\n * stack for a file the browser already has, which is the wrong shape for a\n * sound that fires dozens of times a minute — a UI blip, a hit, a pickup. The\n * pool allocates once per source and replays.\n *\n * This is deliberately not {@link createAudioPlayer}: that handle tracks a\n * single \"current\" clip with loop, sink routing and lifecycle callbacks, which\n * is what background music needs. Effects are the opposite case — many\n * sources, all short, fire-and-forget, and the only thing that matters is that\n * firing one is cheap.\n *\n * A blocked `play()` is swallowed. Browsers reject playback until the user has\n * interacted with the page, and a sound effect is by definition not worth\n * interrupting anything over; call {@link SfxPool.preload} after the first\n * interaction if you want the pool warm.\n *\n * @param options - Master volume, base URL, voices per source and pool size.\n * @returns The pool handle.\n *\n * @example\n * const sfx = createSfxPool({ volume: 0.6, baseUrl: import.meta.env.BASE_URL });\n * sfx.preload([\"sfx/select.mp3\", \"sfx/back.mp3\"]);\n *\n * <button onClick={() => sfx.play(\"sfx/select.mp3\")}>Confirmar</button>\n */\n/** One source's voices plus the round-robin cursor over them. */\ninterface SourceEntry {\n    /** The audio elements sharing this source. */\n    elements: HTMLAudioElement[];\n    /** Index of the element the next play claims. */\n    next: number;\n}\n\n/**\n * Resolve a source against the pool's base URL.\n *\n * An absolute URL, a protocol-relative one and a `data:` URI are already\n * addresses — prefixing them would produce a path that resolves to nothing.\n *\n * @param baseUrl - Pool base, possibly empty.\n * @param src - Source as the caller wrote it.\n * @returns The URL to load.\n */\nfunction resolveSource(baseUrl: string, src: string): string {\n    if (!baseUrl || /^(https?:)?\\/\\//.test(src) || src.startsWith(\"data:\")) return src;\n    return `${baseUrl.replace(/\\/$/, \"\")}/${src.replace(/^\\//, \"\")}`;\n}\n\n/**\n * Stop every voice of an entry and let the browser drop its buffer.\n *\n * Removing `src` before `load()` is what frees the decoded audio: `load()` on an\n * element that still has a source re-fetches it instead.\n *\n * @param entry - The entry being evicted.\n */\nfunction releaseEntry(entry: { elements: HTMLAudioElement[] }): void {\n    for (const element of entry.elements) {\n        element.pause();\n        element.removeAttribute(\"src\");\n        element.load();\n    }\n}\n\n/**\n * Drop the least recently played source once the pool is over its cap.\n *\n * The map is insertion-ordered by last play, so the first key is the coldest.\n * The source that was just admitted is never the one evicted, which would\n * otherwise happen with a cap of one.\n *\n * @param sources - The live pool, mutated in place.\n * @param keepUrl - The source that must survive this eviction.\n * @param maxSources - How many sources the pool may hold.\n */\nfunction evictLeastRecent(\n    sources: Map<string, SourceEntry>,\n    keepUrl: string,\n    maxSources: number,\n): void {\n    if (sources.size <= maxSources) return;\n    const oldest = sources.keys().next();\n    if (oldest.done || oldest.value === keepUrl) return;\n    const evicted = sources.get(oldest.value);\n    if (evicted) releaseEntry(evicted);\n    sources.delete(oldest.value);\n}\n\nexport function createSfxPool(options: SfxPoolOptions = {}): SfxPool {\n    const { baseUrl = \"\", voices = 1, maxSources = 48 } = options;\n\n    let master = clampVolume(options.volume ?? 1);\n    const voiceCount = Math.max(1, Math.floor(voices));\n\n    /**\n     * Insertion-ordered by last play, so evicting the first key drops the\n     * least recently used source.\n     */\n    const sources = new Map<string, SourceEntry>();\n\n    /**\n     * Per-play gain of whatever each element last played at.\n     *\n     * `setVolume` has to rescale live playback by the same factor it was\n     * started with; assigning the master directly would yank a clip that\n     * started at half volume up to full.\n     */\n    const gains = new WeakMap<HTMLAudioElement, number>();\n\n    /**\n     * The pool entry for a source, creating and admitting it when it is new.\n     *\n     * Re-inserts an existing entry so the map order stays \"least recently used\n     * first\", which is what makes evicting the first key correct.\n     *\n     * `created` is reported because assigning `src` on an element whose `preload`\n     * is `\"auto\"` already starts the fetch: calling `load()` on an entry that was\n     * merely looked up would abort that fetch and discard whatever is already\n     * buffered, per the media element load algorithm.\n     *\n     * @param src - Raw source, resolved against `baseUrl`.\n     * @returns The entry and whether this call created it, or `null` where\n     *   `Audio` does not exist.\n     */\n    function acquire(src: string): { entry: SourceEntry; created: boolean } | null {\n        if (typeof Audio === \"undefined\") return null;\n\n        const url = resolveSource(baseUrl, src);\n        const existing = sources.get(url);\n        if (existing) {\n            sources.delete(url);\n            sources.set(url, existing);\n            return { entry: existing, created: false };\n        }\n\n        const entry: SourceEntry = {\n            elements: Array.from({ length: voiceCount }, () => {\n                const element = new Audio(url);\n                element.preload = \"auto\";\n                return element;\n            }),\n            next: 0,\n        };\n        sources.set(url, entry);\n\n        evictLeastRecent(sources, url, maxSources);\n\n        return { entry, created: true };\n    }\n\n    return {\n        play(src, playOptions = {}) {\n            const acquired = acquire(src);\n            if (!acquired) return;\n\n            const entry = acquired.entry;\n            const element = entry.elements[entry.next];\n            entry.next = (entry.next + 1) % entry.elements.length;\n\n            const gain = clampVolume(playOptions.volume ?? 1);\n            gains.set(element, gain);\n\n            element.pause();\n            element.currentTime = 0;\n            element.volume = clampVolume(gain * master);\n            void element.play().catch(() => {});\n        },\n\n        preload(src) {\n            for (const one of Array.isArray(src) ? src : [src]) {\n                const acquired = acquire(one);\n                if (!acquired?.created) continue;\n                for (const element of acquired.entry.elements) element.load();\n            }\n        },\n\n        setVolume(volume) {\n            master = clampVolume(volume);\n            for (const entry of sources.values()) {\n                for (const element of entry.elements) {\n                    if (element.paused) continue;\n                    element.volume = clampVolume((gains.get(element) ?? 1) * master);\n                }\n            }\n        },\n\n        stop(src) {\n            const targets = src\n                ? [sources.get(resolveSource(baseUrl, src))]\n                : [...sources.values()];\n            for (const entry of targets) {\n                if (!entry) continue;\n                for (const element of entry.elements) {\n                    element.pause();\n                    element.currentTime = 0;\n                }\n            }\n        },\n\n        dispose() {\n            for (const entry of sources.values()) releaseEntry(entry);\n            sources.clear();\n        },\n    };\n}\n"],"mappings":"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"}

package/dist/audio/use-audio-bus.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-audio-bus.cjs","names":[],"sources":["../../src/audio/use-audio-bus.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\nimport { createAudioBus, type AudioBus, type AudioBusOptions } from \"./audio-bus\";\n\n/**\n * Keep one {@link AudioBus} alive for as long as the component is mounted.\n *\n * The bus is built on the first render and closed on unmount, which matters more\n * than it looks: browsers cap the number of live `AudioContext`s (Chrome allows\n * around six), so a bus leaked on unmount eventually breaks every later one on\n * the page.\n *\n * Options are read once. A bus is a device route and a mixing graph, not a\n * render output — rebuilding it because a prop changed would drop every attached\n * source mid-sentence. Change gain and output through the bus itself.\n *\n * @param options - See {@link AudioBusOptions}. Read on the first render only.\n * @returns The bus, stable for the component's lifetime.\n *\n * @example\n * const bus = useAudioBus({ maxGain: 3 });\n *\n * useEffect(() => {\n *   const handle = bus.attach(stream, { gain: 1 });\n *   return () => handle.stop();\n * }, [bus, stream]);\n */\nexport function useAudioBus(options: AudioBusOptions = {}): AudioBus {\n    const [bus] = useState<AudioBus>(() => createAudioBus(options));\n\n    useEffect(() => {\n        return () => bus.close();\n    }, [bus]);\n\n    return bus;\n}\n"],"mappings":"0DA0BA,SAAgB,EAAY,EAA2B,CAAC,EAAa,CACjE,GAAM,CAAC,IAAA,EAAO,EAAA,SAAA,KAAyB,EAAA,eAAe,CAAO,CAAC,EAM9D,OAJA,EAAA,EAAA,UAAA,SACiB,EAAI,MAAM,EACxB,CAAC,CAAG,CAAC,EAED,CACX"}
+{"version":3,"file":"use-audio-bus.cjs","names":["useState","createAudioBus","require_audio_bus","react","useAudioBus","bus","options"],"sources":["../../src/audio/use-audio-bus.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\nimport { createAudioBus, type AudioBus, type AudioBusOptions } from \"./audio-bus\";\n\n/**\n * Keep one {@link AudioBus} alive for as long as the component is mounted.\n *\n * The bus is built on the first render and closed on unmount, which matters more\n * than it looks: browsers cap the number of live `AudioContext`s (Chrome allows\n * around six), so a bus leaked on unmount eventually breaks every later one on\n * the page.\n *\n * Options are read once. A bus is a device route and a mixing graph, not a\n * render output — rebuilding it because a prop changed would drop every attached\n * source mid-sentence. Change gain and output through the bus itself.\n *\n * @param options - See {@link AudioBusOptions}. Read on the first render only.\n * @returns The bus, stable for the component's lifetime.\n *\n * @example\n * const bus = useAudioBus({ maxGain: 3 });\n *\n * useEffect(() => {\n *   const handle = bus.attach(stream, { gain: 1 });\n *   return () => handle.stop();\n * }, [bus, stream]);\n */\nexport function useAudioBus(options: AudioBusOptions = {}): AudioBus {\n    const [bus] = useState<AudioBus>(() => createAudioBus(options));\n\n    useEffect(() => {\n        return () => bus.close();\n    }, [bus]);\n\n    return bus;\n}\n"],"mappings":"A,0DA0BA,SAAgBI,EAAY,EAA2B,CAAC,EAAa,CACjE,GAAM,CAACC,IAAA,EAAOL,EAAAA,SAAAA,KAAyBC,EAAAA,eAAeK,CAAO,CAAC,EAM9D,OAJA,EAAAH,EAAA,UAAA,SACiBE,EAAI,MAAM,EACxB,CAACA,CAAG,CAAC,EAEDA,CACX,C"}

package/dist/audio/use-audio-bus.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-audio-bus.js","names":[],"sources":["../../src/audio/use-audio-bus.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\nimport { createAudioBus, type AudioBus, type AudioBusOptions } from \"./audio-bus\";\n\n/**\n * Keep one {@link AudioBus} alive for as long as the component is mounted.\n *\n * The bus is built on the first render and closed on unmount, which matters more\n * than it looks: browsers cap the number of live `AudioContext`s (Chrome allows\n * around six), so a bus leaked on unmount eventually breaks every later one on\n * the page.\n *\n * Options are read once. A bus is a device route and a mixing graph, not a\n * render output — rebuilding it because a prop changed would drop every attached\n * source mid-sentence. Change gain and output through the bus itself.\n *\n * @param options - See {@link AudioBusOptions}. Read on the first render only.\n * @returns The bus, stable for the component's lifetime.\n *\n * @example\n * const bus = useAudioBus({ maxGain: 3 });\n *\n * useEffect(() => {\n *   const handle = bus.attach(stream, { gain: 1 });\n *   return () => handle.stop();\n * }, [bus, stream]);\n */\nexport function useAudioBus(options: AudioBusOptions = {}): AudioBus {\n    const [bus] = useState<AudioBus>(() => createAudioBus(options));\n\n    useEffect(() => {\n        return () => bus.close();\n    }, [bus]);\n\n    return bus;\n}\n"],"mappings":";;;AA0BA,SAAgB,EAAY,IAA2B,CAAC,GAAa;CACjE,IAAM,CAAC,KAAO,QAAyB,EAAe,CAAO,CAAC;CAM9D,OAJA,cACiB,EAAI,MAAM,GACxB,CAAC,CAAG,CAAC,GAED;AACX"}
+{"version":3,"file":"use-audio-bus.js","names":["useAudioBus","bus","useState","createAudioBus","options","useEffect"],"sources":["../../src/audio/use-audio-bus.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\nimport { createAudioBus, type AudioBus, type AudioBusOptions } from \"./audio-bus\";\n\n/**\n * Keep one {@link AudioBus} alive for as long as the component is mounted.\n *\n * The bus is built on the first render and closed on unmount, which matters more\n * than it looks: browsers cap the number of live `AudioContext`s (Chrome allows\n * around six), so a bus leaked on unmount eventually breaks every later one on\n * the page.\n *\n * Options are read once. A bus is a device route and a mixing graph, not a\n * render output — rebuilding it because a prop changed would drop every attached\n * source mid-sentence. Change gain and output through the bus itself.\n *\n * @param options - See {@link AudioBusOptions}. Read on the first render only.\n * @returns The bus, stable for the component's lifetime.\n *\n * @example\n * const bus = useAudioBus({ maxGain: 3 });\n *\n * useEffect(() => {\n *   const handle = bus.attach(stream, { gain: 1 });\n *   return () => handle.stop();\n * }, [bus, stream]);\n */\nexport function useAudioBus(options: AudioBusOptions = {}): AudioBus {\n    const [bus] = useState<AudioBus>(() => createAudioBus(options));\n\n    useEffect(() => {\n        return () => bus.close();\n    }, [bus]);\n\n    return bus;\n}\n"],"mappings":";;;AA0BA,SAAgBA,EAAY,IAA2B,CAAC,GAAa;CACjE,IAAM,CAACC,KAAOC,QAAyBC,EAAeC,CAAO,CAAC;CAM9D,OAJAC,cACiBJ,EAAI,MAAM,GACxB,CAACA,CAAG,CAAC,GAEDA;AACX"}

package/dist/audio/use-audio-recorder.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-audio-recorder.cjs","names":[],"sources":["../../src/audio/use-audio-recorder.ts"],"sourcesContent":["/**\n * @tempest-limits hook-lines — the hook is the recorder's lifecycle seen from React:\n * permission, the recorder handle, the clock, the level meter and the auto-stop\n * timer, all of which have to be torn down together on unmount. A second hook would\n * own half the teardown.\n */\nimport { useCallback, useEffect, useRef, useState } from \"react\";\n\nimport { useStableCallback } from \"@/hooks/use-stable-callback\";\n\nimport {\n    createAudioRecorder,\n    type AudioRecorderHandle,\n    type AudioRecorderOptions,\n    type AudioRecorderStatus,\n    type AudioRecording,\n} from \"./audio-recorder\";\nimport { createLevelMeter, type LevelMeter } from \"./level-meter\";\n\n/** Options for {@link useAudioRecorder}. */\nexport interface UseAudioRecorderOptions extends AudioRecorderOptions {\n    /**\n     * Stop automatically after this many milliseconds.\n     *\n     * Worth setting on anything user-facing: a recording left running by accident is\n     * a memory buffer that grows until the tab dies.\n     */\n    maxDurationMs?: number;\n    /** Called once the recording is assembled, whether by `stop()` or `maxDurationMs`. */\n    onRecorded?: (recording: AudioRecording) => void;\n    /** How often the clock and the level are published, in ms. Default 100. */\n    tickMs?: number;\n    /** Skip the level meter — it costs an `AudioContext`. Default `false`. */\n    disableLevelMeter?: boolean;\n}\n\n/** Value returned by {@link useAudioRecorder}. */\nexport interface UseAudioRecorderResult {\n    status: AudioRecorderStatus;\n    /** Recorded length so far, excluding paused time. */\n    durationMs: number;\n    /** Loudness 0–1, or `0` when the meter is off or nothing is recording. */\n    level: number;\n    /** The finished recording, or `null` before the first `stop()`. */\n    recording: AudioRecording | null;\n    /** Recorder-level error (encoder failure, device pulled mid-recording). */\n    error: unknown;\n    /** `false` when there is no stream yet, or the browser cannot record. */\n    ready: boolean;\n    start: () => void;\n    pause: () => void;\n    resume: () => void;\n    /** Stop and resolve with the recording. Also published on `recording`. */\n    stop: () => Promise<AudioRecording | null>;\n    /** Stop and throw the audio away. */\n    cancel: () => void;\n}\n\n/**\n * Record the given stream, with a clock, a level meter and a state machine.\n *\n * Pass the stream from {@link useMicrophone}; the hook stays `ready: false` until\n * there is one, so a page can render the whole recorder UI before permission is\n * granted and simply have it disabled.\n *\n * The clock and the level are published on an interval (`tickMs`, default 100 ms)\n * rather than per animation frame. A hook that set state 60 times a second would\n * re-render everything the recorder is inside; 10 Hz is smooth enough for a timer and\n * a meter, and the underlying `createLevelMeter` is still available for anyone who\n * wants a frame-accurate bar written straight to the DOM.\n *\n * @param stream - The stream to record, or `null` while permission is pending.\n * @param options - See {@link UseAudioRecorderOptions}.\n *\n * @example\n * const mic = useMicrophone();\n * const rec = useAudioRecorder(mic.stream, { maxDurationMs: 120_000 });\n * <button disabled={!rec.ready} onClick={rec.start}>Gravar</button>\n */\nexport function useAudioRecorder(\n    stream: MediaStream | null,\n    options: UseAudioRecorderOptions = {},\n): UseAudioRecorderResult {\n    const {\n        maxDurationMs,\n        onRecorded,\n        onChunk,\n        onError,\n        mimeType,\n        audioBitsPerSecond,\n        timesliceMs,\n        tickMs = 100,\n        disableLevelMeter = false,\n    } = options;\n\n    const [status, setStatus] = useState<AudioRecorderStatus>(\"idle\");\n    const [durationMs, setDurationMs] = useState(0);\n    const [level, setLevel] = useState(0);\n    const [recording, setRecording] = useState<AudioRecording | null>(null);\n    const [error, setError] = useState<unknown>(null);\n    const [ready, setReady] = useState(false);\n\n    const recorderRef = useRef<AudioRecorderHandle | null>(null);\n    const meterRef = useRef<LevelMeter | null>(null);\n\n    const emitRecorded = useStableCallback((result: AudioRecording) => onRecorded?.(result));\n    const emitChunk = useStableCallback((chunk: Blob) => onChunk?.(chunk));\n    const emitError = useStableCallback((err: unknown) => {\n        setError(err);\n        onError?.(err);\n    });\n\n    /**\n     * Build the recorder and the meter for a stream, and tear both down when it\n     * changes.\n     *\n     * The recorder is rebuilt per stream because `MediaRecorder` is bound to the\n     * stream it was constructed with — swapping microphones mid-session hands us a\n     * new `MediaStream`, and reusing the old recorder would keep recording the device\n     * the user just switched away from. It is rebuilt on a container or bitrate change\n     * for the same reason: both are constructor arguments.\n     */\n    useEffect(() => {\n        if (!stream) {\n            setReady(false);\n            return;\n        }\n        let recorder: AudioRecorderHandle;\n        try {\n            recorder = createAudioRecorder(stream, {\n                mimeType,\n                audioBitsPerSecond,\n                timesliceMs,\n                onChunk: emitChunk,\n                onError: emitError,\n            });\n        } catch (err) {\n            setError(err);\n            setReady(false);\n            return;\n        }\n        recorderRef.current = recorder;\n        meterRef.current = disableLevelMeter ? null : createLevelMeter(stream);\n        setReady(true);\n        setStatus(\"idle\");\n\n        return () => {\n            if (recorder.status() === \"recording\" || recorder.status() === \"paused\") {\n                recorder.cancel();\n            }\n            meterRef.current?.stop();\n            meterRef.current = null;\n            recorderRef.current = null;\n            setReady(false);\n        };\n    }, [\n        stream,\n        disableLevelMeter,\n        mimeType,\n        audioBitsPerSecond,\n        timesliceMs,\n        emitChunk,\n        emitError,\n    ]);\n\n    const stop = useCallback(async (): Promise<AudioRecording | null> => {\n        const recorder = recorderRef.current;\n        if (!recorder) return null;\n        const current = recorder.status();\n        if (current !== \"recording\" && current !== \"paused\") return null;\n        const result = await recorder.stop();\n        setStatus(\"stopped\");\n        setDurationMs(result.durationMs);\n        setLevel(0);\n        setRecording(result);\n        emitRecorded(result);\n        return result;\n    }, [emitRecorded]);\n\n    /**\n     * Publish the clock and the level while something is running, and enforce\n     * `maxDurationMs`.\n     *\n     * The cap is checked on the same tick rather than with a `setTimeout` armed at\n     * `start()`, because a paused recording must not keep counting toward it — a\n     * timeout would fire while the user is paused mid-sentence.\n     */\n    useEffect(() => {\n        if (status !== \"recording\" && status !== \"paused\") {\n            setLevel(0);\n            return;\n        }\n        const id = setInterval(() => {\n            const recorder = recorderRef.current;\n            if (!recorder) return;\n            const elapsed = recorder.durationMs();\n            setDurationMs(elapsed);\n            setLevel(status === \"recording\" ? (meterRef.current?.level() ?? 0) : 0);\n            if (maxDurationMs !== undefined && elapsed >= maxDurationMs) void stop();\n        }, tickMs);\n        return () => clearInterval(id);\n    }, [status, tickMs, maxDurationMs, stop]);\n\n    const start = useCallback((): void => {\n        const recorder = recorderRef.current;\n        if (!recorder) return;\n        setRecording(null);\n        setError(null);\n        setDurationMs(0);\n        recorder.start();\n        setStatus(recorder.status());\n    }, []);\n\n    const pause = useCallback((): void => {\n        const recorder = recorderRef.current;\n        if (!recorder) return;\n        recorder.pause();\n        setDurationMs(recorder.durationMs());\n        setStatus(recorder.status());\n    }, []);\n\n    const resume = useCallback((): void => {\n        const recorder = recorderRef.current;\n        if (!recorder) return;\n        recorder.resume();\n        setStatus(recorder.status());\n    }, []);\n\n    const cancel = useCallback((): void => {\n        const recorder = recorderRef.current;\n        if (!recorder) return;\n        recorder.cancel();\n        setStatus(\"idle\");\n        setDurationMs(0);\n        setLevel(0);\n        setRecording(null);\n    }, []);\n\n    return {\n        status,\n        durationMs,\n        level,\n        recording,\n        error,\n        ready,\n        start,\n        pause,\n        resume,\n        stop,\n        cancel,\n    };\n}\n"],"mappings":"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"}
+{"version":3,"file":"use-audio-recorder.cjs","names":["useState","useRef","useStableCallback","createAudioRecorder","createLevelMeter","useCallback","require_use_stable_callback","require_audio_recorder","require_level_meter","react","useAudioRecorder","options","status","setStatus","durationMs","setDurationMs","level","setLevel","recording","setRecording","error","setError","ready","setReady","recorderRef","meterRef","emitRecorded","onRecorded","result","emitChunk","onChunk","chunk","emitError","err","onError","stream","recorder","disableLevelMeter","mimeType","audioBitsPerSecond","timesliceMs","stop","current","id","elapsed","maxDurationMs","tickMs"],"sources":["../../src/audio/use-audio-recorder.ts"],"sourcesContent":["/**\n * @tempest-limits hook-lines — the hook is the recorder's lifecycle seen from React:\n * permission, the recorder handle, the clock, the level meter and the auto-stop\n * timer, all of which have to be torn down together on unmount. A second hook would\n * own half the teardown.\n */\nimport { useCallback, useEffect, useRef, useState } from \"react\";\n\nimport { useStableCallback } from \"@/hooks/use-stable-callback\";\n\nimport {\n    createAudioRecorder,\n    type AudioRecorderHandle,\n    type AudioRecorderOptions,\n    type AudioRecorderStatus,\n    type AudioRecording,\n} from \"./audio-recorder\";\nimport { createLevelMeter, type LevelMeter } from \"./level-meter\";\n\n/** Options for {@link useAudioRecorder}. */\nexport interface UseAudioRecorderOptions extends AudioRecorderOptions {\n    /**\n     * Stop automatically after this many milliseconds.\n     *\n     * Worth setting on anything user-facing: a recording left running by accident is\n     * a memory buffer that grows until the tab dies.\n     */\n    maxDurationMs?: number;\n    /** Called once the recording is assembled, whether by `stop()` or `maxDurationMs`. */\n    onRecorded?: (recording: AudioRecording) => void;\n    /** How often the clock and the level are published, in ms. Default 100. */\n    tickMs?: number;\n    /** Skip the level meter — it costs an `AudioContext`. Default `false`. */\n    disableLevelMeter?: boolean;\n}\n\n/** Value returned by {@link useAudioRecorder}. */\nexport interface UseAudioRecorderResult {\n    status: AudioRecorderStatus;\n    /** Recorded length so far, excluding paused time. */\n    durationMs: number;\n    /** Loudness 0–1, or `0` when the meter is off or nothing is recording. */\n    level: number;\n    /** The finished recording, or `null` before the first `stop()`. */\n    recording: AudioRecording | null;\n    /** Recorder-level error (encoder failure, device pulled mid-recording). */\n    error: unknown;\n    /** `false` when there is no stream yet, or the browser cannot record. */\n    ready: boolean;\n    start: () => void;\n    pause: () => void;\n    resume: () => void;\n    /** Stop and resolve with the recording. Also published on `recording`. */\n    stop: () => Promise<AudioRecording | null>;\n    /** Stop and throw the audio away. */\n    cancel: () => void;\n}\n\n/**\n * Record the given stream, with a clock, a level meter and a state machine.\n *\n * Pass the stream from {@link useMicrophone}; the hook stays `ready: false` until\n * there is one, so a page can render the whole recorder UI before permission is\n * granted and simply have it disabled.\n *\n * The clock and the level are published on an interval (`tickMs`, default 100 ms)\n * rather than per animation frame. A hook that set state 60 times a second would\n * re-render everything the recorder is inside; 10 Hz is smooth enough for a timer and\n * a meter, and the underlying `createLevelMeter` is still available for anyone who\n * wants a frame-accurate bar written straight to the DOM.\n *\n * @param stream - The stream to record, or `null` while permission is pending.\n * @param options - See {@link UseAudioRecorderOptions}.\n *\n * @example\n * const mic = useMicrophone();\n * const rec = useAudioRecorder(mic.stream, { maxDurationMs: 120_000 });\n * <button disabled={!rec.ready} onClick={rec.start}>Gravar</button>\n */\nexport function useAudioRecorder(\n    stream: MediaStream | null,\n    options: UseAudioRecorderOptions = {},\n): UseAudioRecorderResult {\n    const {\n        maxDurationMs,\n        onRecorded,\n        onChunk,\n        onError,\n        mimeType,\n        audioBitsPerSecond,\n        timesliceMs,\n        tickMs = 100,\n        disableLevelMeter = false,\n    } = options;\n\n    const [status, setStatus] = useState<AudioRecorderStatus>(\"idle\");\n    const [durationMs, setDurationMs] = useState(0);\n    const [level, setLevel] = useState(0);\n    const [recording, setRecording] = useState<AudioRecording | null>(null);\n    const [error, setError] = useState<unknown>(null);\n    const [ready, setReady] = useState(false);\n\n    const recorderRef = useRef<AudioRecorderHandle | null>(null);\n    const meterRef = useRef<LevelMeter | null>(null);\n\n    const emitRecorded = useStableCallback((result: AudioRecording) => onRecorded?.(result));\n    const emitChunk = useStableCallback((chunk: Blob) => onChunk?.(chunk));\n    const emitError = useStableCallback((err: unknown) => {\n        setError(err);\n        onError?.(err);\n    });\n\n    /**\n     * Build the recorder and the meter for a stream, and tear both down when it\n     * changes.\n     *\n     * The recorder is rebuilt per stream because `MediaRecorder` is bound to the\n     * stream it was constructed with — swapping microphones mid-session hands us a\n     * new `MediaStream`, and reusing the old recorder would keep recording the device\n     * the user just switched away from. It is rebuilt on a container or bitrate change\n     * for the same reason: both are constructor arguments.\n     */\n    useEffect(() => {\n        if (!stream) {\n            setReady(false);\n            return;\n        }\n        let recorder: AudioRecorderHandle;\n        try {\n            recorder = createAudioRecorder(stream, {\n                mimeType,\n                audioBitsPerSecond,\n                timesliceMs,\n                onChunk: emitChunk,\n                onError: emitError,\n            });\n        } catch (err) {\n            setError(err);\n            setReady(false);\n            return;\n        }\n        recorderRef.current = recorder;\n        meterRef.current = disableLevelMeter ? null : createLevelMeter(stream);\n        setReady(true);\n        setStatus(\"idle\");\n\n        return () => {\n            if (recorder.status() === \"recording\" || recorder.status() === \"paused\") {\n                recorder.cancel();\n            }\n            meterRef.current?.stop();\n            meterRef.current = null;\n            recorderRef.current = null;\n            setReady(false);\n        };\n    }, [\n        stream,\n        disableLevelMeter,\n        mimeType,\n        audioBitsPerSecond,\n        timesliceMs,\n        emitChunk,\n        emitError,\n    ]);\n\n    const stop = useCallback(async (): Promise<AudioRecording | null> => {\n        const recorder = recorderRef.current;\n        if (!recorder) return null;\n        const current = recorder.status();\n        if (current !== \"recording\" && current !== \"paused\") return null;\n        const result = await recorder.stop();\n        setStatus(\"stopped\");\n        setDurationMs(result.durationMs);\n        setLevel(0);\n        setRecording(result);\n        emitRecorded(result);\n        return result;\n    }, [emitRecorded]);\n\n    /**\n     * Publish the clock and the level while something is running, and enforce\n     * `maxDurationMs`.\n     *\n     * The cap is checked on the same tick rather than with a `setTimeout` armed at\n     * `start()`, because a paused recording must not keep counting toward it — a\n     * timeout would fire while the user is paused mid-sentence.\n     */\n    useEffect(() => {\n        if (status !== \"recording\" && status !== \"paused\") {\n            setLevel(0);\n            return;\n        }\n        const id = setInterval(() => {\n            const recorder = recorderRef.current;\n            if (!recorder) return;\n            const elapsed = recorder.durationMs();\n            setDurationMs(elapsed);\n            setLevel(status === \"recording\" ? (meterRef.current?.level() ?? 0) : 0);\n            if (maxDurationMs !== undefined && elapsed >= maxDurationMs) void stop();\n        }, tickMs);\n        return () => clearInterval(id);\n    }, [status, tickMs, maxDurationMs, stop]);\n\n    const start = useCallback((): void => {\n        const recorder = recorderRef.current;\n        if (!recorder) return;\n        setRecording(null);\n        setError(null);\n        setDurationMs(0);\n        recorder.start();\n        setStatus(recorder.status());\n    }, []);\n\n    const pause = useCallback((): void => {\n        const recorder = recorderRef.current;\n        if (!recorder) return;\n        recorder.pause();\n        setDurationMs(recorder.durationMs());\n        setStatus(recorder.status());\n    }, []);\n\n    const resume = useCallback((): void => {\n        const recorder = recorderRef.current;\n        if (!recorder) return;\n        recorder.resume();\n        setStatus(recorder.status());\n    }, []);\n\n    const cancel = useCallback((): void => {\n        const recorder = recorderRef.current;\n        if (!recorder) return;\n        recorder.cancel();\n        setStatus(\"idle\");\n        setDurationMs(0);\n        setLevel(0);\n        setRecording(null);\n    }, []);\n\n    return {\n        status,\n        durationMs,\n        level,\n        recording,\n        error,\n        ready,\n        start,\n        pause,\n        resume,\n        stop,\n        cancel,\n    };\n}\n"],"mappings":"A,4IA+EA,SAAgBU,EACZ,EACA,EAAmC,CAAC,EACd,CACtB,GAAM,CACF,gBACA,aACA,UACA,UACA,WACA,qBACA,cACA,SAAS,IACT,oBAAoB,IACpBC,EAEE,CAACC,EAAQC,IAAA,EAAab,EAAAA,SAAAA,CAA8B,MAAM,EAC1D,CAACc,EAAYC,IAAA,EAAiBf,EAAAA,SAAAA,CAAS,CAAC,EACxC,CAACgB,EAAOC,IAAA,EAAYjB,EAAAA,SAAAA,CAAS,CAAC,EAC9B,CAACkB,EAAWC,IAAA,EAAgBnB,EAAAA,SAAAA,CAAgC,IAAI,EAChE,CAACoB,EAAOC,IAAA,EAAYrB,EAAAA,SAAAA,CAAkB,IAAI,EAC1C,CAACsB,EAAOC,IAAA,EAAYvB,EAAAA,SAAAA,CAAS,EAAK,EAElCwB,GAAA,EAAcvB,EAAAA,OAAAA,CAAmC,IAAI,EACrDwB,GAAA,EAAWxB,EAAAA,OAAAA,CAA0B,IAAI,EAEzCyB,EAAexB,EAAAA,kBAAmB,GAA2ByB,IAAaC,CAAM,CAAC,EACjFC,EAAY3B,EAAAA,kBAAmB,GAAgB4B,IAAUC,CAAK,CAAC,EAC/DC,EAAY9B,EAAAA,kBAAmB,GAAiB,CAClDmB,EAASY,CAAG,EACZC,IAAUD,CAAG,CACjB,CAAC,GAYD,EAAAxB,EAAA,UAAA,KAAgB,CACZ,GAAI,CAAC0B,EAAQ,CACTZ,EAAS,EAAK,EACd,MACJ,CACA,IAAIa,EACJ,GAAI,CACA,EAAWjC,EAAAA,oBAAoBgC,EAAQ,CACnC,WACA,qBACA,cACA,QAASN,EACT,QAASG,CACb,CAAC,CACL,OAASC,EAAK,CACVZ,EAASY,CAAG,EACZV,EAAS,EAAK,EACd,MACJ,CAMA,MALA,GAAY,QAAUa,EACtB,EAAS,QAAUC,EAAoB,KAAOjC,EAAAA,iBAAiB+B,CAAM,EACrEZ,EAAS,EAAI,EACbV,EAAU,MAAM,MAEH,EACLuB,EAAS,OAAO,IAAM,aAAeA,EAAS,OAAO,IAAM,WAC3DA,EAAS,OAAO,EAEpBX,EAAS,SAAS,KAAK,EACvB,EAAS,QAAU,KACnB,EAAY,QAAU,KACtBF,EAAS,EAAK,CAClB,CACJ,EAAG,CACCY,EACAE,EACAC,EACAC,EACAC,EACAX,EACAG,CACJ,CAAC,EAED,IAAMS,GAAA,EAAOpC,EAAAA,YAAAA,CAAY,SAA4C,CACjE,IAAM+B,EAAWZ,EAAY,QAC7B,GAAI,CAACY,EAAU,OAAO,KACtB,IAAMM,EAAUN,EAAS,OAAO,EAChC,GAAIM,IAAY,aAAeA,IAAY,SAAU,OAAO,KAC5D,IAAMd,EAAS,MAAMQ,EAAS,KAAK,EAMnC,OALAvB,EAAU,SAAS,EACnBE,EAAca,EAAO,UAAU,EAC/BX,EAAS,CAAC,EACVE,EAAaS,CAAM,EACnBF,EAAaE,CAAM,EACZA,CACX,EAAG,CAACF,CAAY,CAAC,EA6DjB,OAnDA,EAAAjB,EAAA,UAAA,KAAgB,CACZ,GAAIG,IAAW,aAAeA,IAAW,SAAU,CAC/CK,EAAS,CAAC,EACV,MACJ,CACA,IAAM0B,EAAK,gBAAkB,CACzB,IAAMP,EAAWZ,EAAY,QAC7B,GAAI,CAACY,EAAU,OACf,IAAMQ,EAAUR,EAAS,WAAW,EACpCrB,EAAc6B,CAAO,EACrB3B,EAASL,IAAW,YAAea,EAAS,SAAS,MAAM,GAAK,EAAK,CAAC,EAClEoB,IAAkB,IAAA,IAAaD,GAAWC,GAAeJ,EAAU,CAC3E,EAAGK,CAAM,EACT,UAAa,cAAcH,CAAE,CACjC,EAAG,CAAC/B,EAAQkC,EAAQD,EAAeJ,CAAI,CAAC,EAqCjC,CACH,SACA,aACA,QACA,YACA,QACA,QACA,OAAA,EA1CUpC,EAAAA,YAAAA,KAAwB,CAClC,IAAM+B,EAAWZ,EAAY,QACxBY,IACLjB,EAAa,IAAI,EACjBE,EAAS,IAAI,EACbN,EAAc,CAAC,EACfqB,EAAS,MAAM,EACfvB,EAAUuB,EAAS,OAAO,CAAC,EAC/B,EAAG,CAAC,CAkCA,EACA,OAAA,EAjCU/B,EAAAA,YAAAA,KAAwB,CAClC,IAAM+B,EAAWZ,EAAY,QACxBY,IACLA,EAAS,MAAM,EACfrB,EAAcqB,EAAS,WAAW,CAAC,EACnCvB,EAAUuB,EAAS,OAAO,CAAC,EAC/B,EAAG,CAAC,CA2BA,EACA,QAAA,EA1BW/B,EAAAA,YAAAA,KAAwB,CACnC,IAAM+B,EAAWZ,EAAY,QACxBY,IACLA,EAAS,OAAO,EAChBvB,EAAUuB,EAAS,OAAO,CAAC,EAC/B,EAAG,CAAC,CAqBA,EACA,OACA,QAAA,EArBW/B,EAAAA,YAAAA,KAAwB,CACnC,IAAM+B,EAAWZ,EAAY,QACxBY,IACLA,EAAS,OAAO,EAChBvB,EAAU,MAAM,EAChBE,EAAc,CAAC,EACfE,EAAS,CAAC,EACVE,EAAa,IAAI,EACrB,EAAG,CAAC,CAaA,CACJ,CACJ,C"}

package/dist/audio/use-audio-recorder.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-audio-recorder.js","names":[],"sources":["../../src/audio/use-audio-recorder.ts"],"sourcesContent":["/**\n * @tempest-limits hook-lines — the hook is the recorder's lifecycle seen from React:\n * permission, the recorder handle, the clock, the level meter and the auto-stop\n * timer, all of which have to be torn down together on unmount. A second hook would\n * own half the teardown.\n */\nimport { useCallback, useEffect, useRef, useState } from \"react\";\n\nimport { useStableCallback } from \"@/hooks/use-stable-callback\";\n\nimport {\n    createAudioRecorder,\n    type AudioRecorderHandle,\n    type AudioRecorderOptions,\n    type AudioRecorderStatus,\n    type AudioRecording,\n} from \"./audio-recorder\";\nimport { createLevelMeter, type LevelMeter } from \"./level-meter\";\n\n/** Options for {@link useAudioRecorder}. */\nexport interface UseAudioRecorderOptions extends AudioRecorderOptions {\n    /**\n     * Stop automatically after this many milliseconds.\n     *\n     * Worth setting on anything user-facing: a recording left running by accident is\n     * a memory buffer that grows until the tab dies.\n     */\n    maxDurationMs?: number;\n    /** Called once the recording is assembled, whether by `stop()` or `maxDurationMs`. */\n    onRecorded?: (recording: AudioRecording) => void;\n    /** How often the clock and the level are published, in ms. Default 100. */\n    tickMs?: number;\n    /** Skip the level meter — it costs an `AudioContext`. Default `false`. */\n    disableLevelMeter?: boolean;\n}\n\n/** Value returned by {@link useAudioRecorder}. */\nexport interface UseAudioRecorderResult {\n    status: AudioRecorderStatus;\n    /** Recorded length so far, excluding paused time. */\n    durationMs: number;\n    /** Loudness 0–1, or `0` when the meter is off or nothing is recording. */\n    level: number;\n    /** The finished recording, or `null` before the first `stop()`. */\n    recording: AudioRecording | null;\n    /** Recorder-level error (encoder failure, device pulled mid-recording). */\n    error: unknown;\n    /** `false` when there is no stream yet, or the browser cannot record. */\n    ready: boolean;\n    start: () => void;\n    pause: () => void;\n    resume: () => void;\n    /** Stop and resolve with the recording. Also published on `recording`. */\n    stop: () => Promise<AudioRecording | null>;\n    /** Stop and throw the audio away. */\n    cancel: () => void;\n}\n\n/**\n * Record the given stream, with a clock, a level meter and a state machine.\n *\n * Pass the stream from {@link useMicrophone}; the hook stays `ready: false` until\n * there is one, so a page can render the whole recorder UI before permission is\n * granted and simply have it disabled.\n *\n * The clock and the level are published on an interval (`tickMs`, default 100 ms)\n * rather than per animation frame. A hook that set state 60 times a second would\n * re-render everything the recorder is inside; 10 Hz is smooth enough for a timer and\n * a meter, and the underlying `createLevelMeter` is still available for anyone who\n * wants a frame-accurate bar written straight to the DOM.\n *\n * @param stream - The stream to record, or `null` while permission is pending.\n * @param options - See {@link UseAudioRecorderOptions}.\n *\n * @example\n * const mic = useMicrophone();\n * const rec = useAudioRecorder(mic.stream, { maxDurationMs: 120_000 });\n * <button disabled={!rec.ready} onClick={rec.start}>Gravar</button>\n */\nexport function useAudioRecorder(\n    stream: MediaStream | null,\n    options: UseAudioRecorderOptions = {},\n): UseAudioRecorderResult {\n    const {\n        maxDurationMs,\n        onRecorded,\n        onChunk,\n        onError,\n        mimeType,\n        audioBitsPerSecond,\n        timesliceMs,\n        tickMs = 100,\n        disableLevelMeter = false,\n    } = options;\n\n    const [status, setStatus] = useState<AudioRecorderStatus>(\"idle\");\n    const [durationMs, setDurationMs] = useState(0);\n    const [level, setLevel] = useState(0);\n    const [recording, setRecording] = useState<AudioRecording | null>(null);\n    const [error, setError] = useState<unknown>(null);\n    const [ready, setReady] = useState(false);\n\n    const recorderRef = useRef<AudioRecorderHandle | null>(null);\n    const meterRef = useRef<LevelMeter | null>(null);\n\n    const emitRecorded = useStableCallback((result: AudioRecording) => onRecorded?.(result));\n    const emitChunk = useStableCallback((chunk: Blob) => onChunk?.(chunk));\n    const emitError = useStableCallback((err: unknown) => {\n        setError(err);\n        onError?.(err);\n    });\n\n    /**\n     * Build the recorder and the meter for a stream, and tear both down when it\n     * changes.\n     *\n     * The recorder is rebuilt per stream because `MediaRecorder` is bound to the\n     * stream it was constructed with — swapping microphones mid-session hands us a\n     * new `MediaStream`, and reusing the old recorder would keep recording the device\n     * the user just switched away from. It is rebuilt on a container or bitrate change\n     * for the same reason: both are constructor arguments.\n     */\n    useEffect(() => {\n        if (!stream) {\n            setReady(false);\n            return;\n        }\n        let recorder: AudioRecorderHandle;\n        try {\n            recorder = createAudioRecorder(stream, {\n                mimeType,\n                audioBitsPerSecond,\n                timesliceMs,\n                onChunk: emitChunk,\n                onError: emitError,\n            });\n        } catch (err) {\n            setError(err);\n            setReady(false);\n            return;\n        }\n        recorderRef.current = recorder;\n        meterRef.current = disableLevelMeter ? null : createLevelMeter(stream);\n        setReady(true);\n        setStatus(\"idle\");\n\n        return () => {\n            if (recorder.status() === \"recording\" || recorder.status() === \"paused\") {\n                recorder.cancel();\n            }\n            meterRef.current?.stop();\n            meterRef.current = null;\n            recorderRef.current = null;\n            setReady(false);\n        };\n    }, [\n        stream,\n        disableLevelMeter,\n        mimeType,\n        audioBitsPerSecond,\n        timesliceMs,\n        emitChunk,\n        emitError,\n    ]);\n\n    const stop = useCallback(async (): Promise<AudioRecording | null> => {\n        const recorder = recorderRef.current;\n        if (!recorder) return null;\n        const current = recorder.status();\n        if (current !== \"recording\" && current !== \"paused\") return null;\n        const result = await recorder.stop();\n        setStatus(\"stopped\");\n        setDurationMs(result.durationMs);\n        setLevel(0);\n        setRecording(result);\n        emitRecorded(result);\n        return result;\n    }, [emitRecorded]);\n\n    /**\n     * Publish the clock and the level while something is running, and enforce\n     * `maxDurationMs`.\n     *\n     * The cap is checked on the same tick rather than with a `setTimeout` armed at\n     * `start()`, because a paused recording must not keep counting toward it — a\n     * timeout would fire while the user is paused mid-sentence.\n     */\n    useEffect(() => {\n        if (status !== \"recording\" && status !== \"paused\") {\n            setLevel(0);\n            return;\n        }\n        const id = setInterval(() => {\n            const recorder = recorderRef.current;\n            if (!recorder) return;\n            const elapsed = recorder.durationMs();\n            setDurationMs(elapsed);\n            setLevel(status === \"recording\" ? (meterRef.current?.level() ?? 0) : 0);\n            if (maxDurationMs !== undefined && elapsed >= maxDurationMs) void stop();\n        }, tickMs);\n        return () => clearInterval(id);\n    }, [status, tickMs, maxDurationMs, stop]);\n\n    const start = useCallback((): void => {\n        const recorder = recorderRef.current;\n        if (!recorder) return;\n        setRecording(null);\n        setError(null);\n        setDurationMs(0);\n        recorder.start();\n        setStatus(recorder.status());\n    }, []);\n\n    const pause = useCallback((): void => {\n        const recorder = recorderRef.current;\n        if (!recorder) return;\n        recorder.pause();\n        setDurationMs(recorder.durationMs());\n        setStatus(recorder.status());\n    }, []);\n\n    const resume = useCallback((): void => {\n        const recorder = recorderRef.current;\n        if (!recorder) return;\n        recorder.resume();\n        setStatus(recorder.status());\n    }, []);\n\n    const cancel = useCallback((): void => {\n        const recorder = recorderRef.current;\n        if (!recorder) return;\n        recorder.cancel();\n        setStatus(\"idle\");\n        setDurationMs(0);\n        setLevel(0);\n        setRecording(null);\n    }, []);\n\n    return {\n        status,\n        durationMs,\n        level,\n        recording,\n        error,\n        ready,\n        start,\n        pause,\n        resume,\n        stop,\n        cancel,\n    };\n}\n"],"mappings":"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"}
+{"version":3,"file":"use-audio-recorder.js","names":["useAudioRecorder","options","status","setStatus","useState","durationMs","setDurationMs","level","setLevel","recording","setRecording","error","setError","ready","setReady","recorderRef","useRef","meterRef","emitRecorded","useStableCallback","onRecorded","result","emitChunk","onChunk","chunk","emitError","err","onError","stream","recorder","createAudioRecorder","disableLevelMeter","createLevelMeter","mimeType","audioBitsPerSecond","timesliceMs","stop","useCallback","current","useEffect","id","elapsed","maxDurationMs","tickMs"],"sources":["../../src/audio/use-audio-recorder.ts"],"sourcesContent":["/**\n * @tempest-limits hook-lines — the hook is the recorder's lifecycle seen from React:\n * permission, the recorder handle, the clock, the level meter and the auto-stop\n * timer, all of which have to be torn down together on unmount. A second hook would\n * own half the teardown.\n */\nimport { useCallback, useEffect, useRef, useState } from \"react\";\n\nimport { useStableCallback } from \"@/hooks/use-stable-callback\";\n\nimport {\n    createAudioRecorder,\n    type AudioRecorderHandle,\n    type AudioRecorderOptions,\n    type AudioRecorderStatus,\n    type AudioRecording,\n} from \"./audio-recorder\";\nimport { createLevelMeter, type LevelMeter } from \"./level-meter\";\n\n/** Options for {@link useAudioRecorder}. */\nexport interface UseAudioRecorderOptions extends AudioRecorderOptions {\n    /**\n     * Stop automatically after this many milliseconds.\n     *\n     * Worth setting on anything user-facing: a recording left running by accident is\n     * a memory buffer that grows until the tab dies.\n     */\n    maxDurationMs?: number;\n    /** Called once the recording is assembled, whether by `stop()` or `maxDurationMs`. */\n    onRecorded?: (recording: AudioRecording) => void;\n    /** How often the clock and the level are published, in ms. Default 100. */\n    tickMs?: number;\n    /** Skip the level meter — it costs an `AudioContext`. Default `false`. */\n    disableLevelMeter?: boolean;\n}\n\n/** Value returned by {@link useAudioRecorder}. */\nexport interface UseAudioRecorderResult {\n    status: AudioRecorderStatus;\n    /** Recorded length so far, excluding paused time. */\n    durationMs: number;\n    /** Loudness 0–1, or `0` when the meter is off or nothing is recording. */\n    level: number;\n    /** The finished recording, or `null` before the first `stop()`. */\n    recording: AudioRecording | null;\n    /** Recorder-level error (encoder failure, device pulled mid-recording). */\n    error: unknown;\n    /** `false` when there is no stream yet, or the browser cannot record. */\n    ready: boolean;\n    start: () => void;\n    pause: () => void;\n    resume: () => void;\n    /** Stop and resolve with the recording. Also published on `recording`. */\n    stop: () => Promise<AudioRecording | null>;\n    /** Stop and throw the audio away. */\n    cancel: () => void;\n}\n\n/**\n * Record the given stream, with a clock, a level meter and a state machine.\n *\n * Pass the stream from {@link useMicrophone}; the hook stays `ready: false` until\n * there is one, so a page can render the whole recorder UI before permission is\n * granted and simply have it disabled.\n *\n * The clock and the level are published on an interval (`tickMs`, default 100 ms)\n * rather than per animation frame. A hook that set state 60 times a second would\n * re-render everything the recorder is inside; 10 Hz is smooth enough for a timer and\n * a meter, and the underlying `createLevelMeter` is still available for anyone who\n * wants a frame-accurate bar written straight to the DOM.\n *\n * @param stream - The stream to record, or `null` while permission is pending.\n * @param options - See {@link UseAudioRecorderOptions}.\n *\n * @example\n * const mic = useMicrophone();\n * const rec = useAudioRecorder(mic.stream, { maxDurationMs: 120_000 });\n * <button disabled={!rec.ready} onClick={rec.start}>Gravar</button>\n */\nexport function useAudioRecorder(\n    stream: MediaStream | null,\n    options: UseAudioRecorderOptions = {},\n): UseAudioRecorderResult {\n    const {\n        maxDurationMs,\n        onRecorded,\n        onChunk,\n        onError,\n        mimeType,\n        audioBitsPerSecond,\n        timesliceMs,\n        tickMs = 100,\n        disableLevelMeter = false,\n    } = options;\n\n    const [status, setStatus] = useState<AudioRecorderStatus>(\"idle\");\n    const [durationMs, setDurationMs] = useState(0);\n    const [level, setLevel] = useState(0);\n    const [recording, setRecording] = useState<AudioRecording | null>(null);\n    const [error, setError] = useState<unknown>(null);\n    const [ready, setReady] = useState(false);\n\n    const recorderRef = useRef<AudioRecorderHandle | null>(null);\n    const meterRef = useRef<LevelMeter | null>(null);\n\n    const emitRecorded = useStableCallback((result: AudioRecording) => onRecorded?.(result));\n    const emitChunk = useStableCallback((chunk: Blob) => onChunk?.(chunk));\n    const emitError = useStableCallback((err: unknown) => {\n        setError(err);\n        onError?.(err);\n    });\n\n    /**\n     * Build the recorder and the meter for a stream, and tear both down when it\n     * changes.\n     *\n     * The recorder is rebuilt per stream because `MediaRecorder` is bound to the\n     * stream it was constructed with — swapping microphones mid-session hands us a\n     * new `MediaStream`, and reusing the old recorder would keep recording the device\n     * the user just switched away from. It is rebuilt on a container or bitrate change\n     * for the same reason: both are constructor arguments.\n     */\n    useEffect(() => {\n        if (!stream) {\n            setReady(false);\n            return;\n        }\n        let recorder: AudioRecorderHandle;\n        try {\n            recorder = createAudioRecorder(stream, {\n                mimeType,\n                audioBitsPerSecond,\n                timesliceMs,\n                onChunk: emitChunk,\n                onError: emitError,\n            });\n        } catch (err) {\n            setError(err);\n            setReady(false);\n            return;\n        }\n        recorderRef.current = recorder;\n        meterRef.current = disableLevelMeter ? null : createLevelMeter(stream);\n        setReady(true);\n        setStatus(\"idle\");\n\n        return () => {\n            if (recorder.status() === \"recording\" || recorder.status() === \"paused\") {\n                recorder.cancel();\n            }\n            meterRef.current?.stop();\n            meterRef.current = null;\n            recorderRef.current = null;\n            setReady(false);\n        };\n    }, [\n        stream,\n        disableLevelMeter,\n        mimeType,\n        audioBitsPerSecond,\n        timesliceMs,\n        emitChunk,\n        emitError,\n    ]);\n\n    const stop = useCallback(async (): Promise<AudioRecording | null> => {\n        const recorder = recorderRef.current;\n        if (!recorder) return null;\n        const current = recorder.status();\n        if (current !== \"recording\" && current !== \"paused\") return null;\n        const result = await recorder.stop();\n        setStatus(\"stopped\");\n        setDurationMs(result.durationMs);\n        setLevel(0);\n        setRecording(result);\n        emitRecorded(result);\n        return result;\n    }, [emitRecorded]);\n\n    /**\n     * Publish the clock and the level while something is running, and enforce\n     * `maxDurationMs`.\n     *\n     * The cap is checked on the same tick rather than with a `setTimeout` armed at\n     * `start()`, because a paused recording must not keep counting toward it — a\n     * timeout would fire while the user is paused mid-sentence.\n     */\n    useEffect(() => {\n        if (status !== \"recording\" && status !== \"paused\") {\n            setLevel(0);\n            return;\n        }\n        const id = setInterval(() => {\n            const recorder = recorderRef.current;\n            if (!recorder) return;\n            const elapsed = recorder.durationMs();\n            setDurationMs(elapsed);\n            setLevel(status === \"recording\" ? (meterRef.current?.level() ?? 0) : 0);\n            if (maxDurationMs !== undefined && elapsed >= maxDurationMs) void stop();\n        }, tickMs);\n        return () => clearInterval(id);\n    }, [status, tickMs, maxDurationMs, stop]);\n\n    const start = useCallback((): void => {\n        const recorder = recorderRef.current;\n        if (!recorder) return;\n        setRecording(null);\n        setError(null);\n        setDurationMs(0);\n        recorder.start();\n        setStatus(recorder.status());\n    }, []);\n\n    const pause = useCallback((): void => {\n        const recorder = recorderRef.current;\n        if (!recorder) return;\n        recorder.pause();\n        setDurationMs(recorder.durationMs());\n        setStatus(recorder.status());\n    }, []);\n\n    const resume = useCallback((): void => {\n        const recorder = recorderRef.current;\n        if (!recorder) return;\n        recorder.resume();\n        setStatus(recorder.status());\n    }, []);\n\n    const cancel = useCallback((): void => {\n        const recorder = recorderRef.current;\n        if (!recorder) return;\n        recorder.cancel();\n        setStatus(\"idle\");\n        setDurationMs(0);\n        setLevel(0);\n        setRecording(null);\n    }, []);\n\n    return {\n        status,\n        durationMs,\n        level,\n        recording,\n        error,\n        ready,\n        start,\n        pause,\n        resume,\n        stop,\n        cancel,\n    };\n}\n"],"mappings":"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"}

package/dist/audio/use-audio.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-audio.cjs","names":[],"sources":["../../src/audio/use-audio.ts"],"sourcesContent":["import { useCallback, useEffect, useState } from \"react\";\nimport { createAudioPlayer, type AudioPlayerHandle, type PlayAudioOptions } from \"./audio-player\";\n\nexport interface UseAudioResult {\n    /** Play `src` on the hook's private player. */\n    play: (src: string, options?: PlayAudioOptions) => Promise<void>;\n    /** Stop the current clip. */\n    stop: () => void;\n    /**\n     * Whether the browser's autoplay policy has been satisfied. Becomes\n     * `true` after the first successful `play()`.\n     */\n    unlocked: boolean;\n}\n\n/**\n * The player lives in a state initializer, not in a lazily-written ref: the\n * initializer runs exactly once and is not a side effect during render, which is\n * what the ref version was. The player identity never changes, so state holds it\n * fine and the value is non-null from the first render.\n *\n * Hook-managed audio player. Each component instance gets its own\n * {@link AudioPlayerHandle}, so unmounting cleanly stops playback. Useful for\n * notification chimes, UI feedback sounds, and per-component soundtracks.\n */\nexport function useAudio(): UseAudioResult {\n    const [player] = useState<AudioPlayerHandle>(() => createAudioPlayer());\n    const [unlocked, setUnlocked] = useState<boolean>(false);\n\n    useEffect(() => {\n        return () => {\n            player.stop();\n        };\n    }, [player]);\n\n    const play = useCallback(\n        async (src: string, options?: PlayAudioOptions): Promise<void> => {\n            const result = await player.play(src, options);\n            if (result) setUnlocked(true);\n        },\n        [player],\n    );\n\n    const stop = useCallback((): void => {\n        player.stop();\n    }, [player]);\n\n    return { play, stop, unlocked };\n}\n"],"mappings":"6DAyBA,SAAgB,GAA2B,CACvC,GAAM,CAAC,IAAA,EAAU,EAAA,SAAA,KAAkC,EAAA,kBAAkB,CAAC,EAChE,CAAC,EAAU,IAAA,EAAe,EAAA,SAAA,CAAkB,EAAK,EAoBvD,OAlBA,EAAA,EAAA,UAAA,SACiB,CACT,EAAO,KAAK,CAChB,EACD,CAAC,CAAM,CAAC,EAcJ,CAAE,MAAA,EAZI,EAAA,YAAA,CACT,MAAO,EAAa,IAA8C,CAE1D,MADiB,EAAO,KAAK,EAAK,CAAO,GACjC,EAAY,EAAI,CAChC,EACA,CAAC,CAAM,CAOF,EAAM,MAAA,EAJF,EAAA,YAAA,KAAwB,CACjC,EAAO,KAAK,CAChB,EAAG,CAAC,CAAM,CAEK,EAAM,UAAS,CAClC"}
+{"version":3,"file":"use-audio.cjs","names":["useState","createAudioPlayer","useCallback","require_audio_player","react","useAudio","player","unlocked","setUnlocked","src","options"],"sources":["../../src/audio/use-audio.ts"],"sourcesContent":["import { useCallback, useEffect, useState } from \"react\";\nimport { createAudioPlayer, type AudioPlayerHandle, type PlayAudioOptions } from \"./audio-player\";\n\nexport interface UseAudioResult {\n    /** Play `src` on the hook's private player. */\n    play: (src: string, options?: PlayAudioOptions) => Promise<void>;\n    /** Stop the current clip. */\n    stop: () => void;\n    /**\n     * Whether the browser's autoplay policy has been satisfied. Becomes\n     * `true` after the first successful `play()`.\n     */\n    unlocked: boolean;\n}\n\n/**\n * The player lives in a state initializer, not in a lazily-written ref: the\n * initializer runs exactly once and is not a side effect during render, which is\n * what the ref version was. The player identity never changes, so state holds it\n * fine and the value is non-null from the first render.\n *\n * Hook-managed audio player. Each component instance gets its own\n * {@link AudioPlayerHandle}, so unmounting cleanly stops playback. Useful for\n * notification chimes, UI feedback sounds, and per-component soundtracks.\n */\nexport function useAudio(): UseAudioResult {\n    const [player] = useState<AudioPlayerHandle>(() => createAudioPlayer());\n    const [unlocked, setUnlocked] = useState<boolean>(false);\n\n    useEffect(() => {\n        return () => {\n            player.stop();\n        };\n    }, [player]);\n\n    const play = useCallback(\n        async (src: string, options?: PlayAudioOptions): Promise<void> => {\n            const result = await player.play(src, options);\n            if (result) setUnlocked(true);\n        },\n        [player],\n    );\n\n    const stop = useCallback((): void => {\n        player.stop();\n    }, [player]);\n\n    return { play, stop, unlocked };\n}\n"],"mappings":"A,6DAyBA,SAAgBK,GAA2B,CACvC,GAAM,CAACC,IAAA,EAAUN,EAAAA,SAAAA,KAAkCC,EAAAA,kBAAkB,CAAC,EAChE,CAACM,EAAUC,IAAA,EAAeR,EAAAA,SAAAA,CAAkB,EAAK,EAoBvD,OAlBA,EAAAI,EAAA,UAAA,SACiB,CACTE,EAAO,KAAK,CAChB,EACD,CAACA,CAAM,CAAC,EAcJ,CAAE,MAAA,EAZIJ,EAAAA,YAAAA,CACT,MAAO,EAAa,IAA8C,CAE1D,MADiBI,EAAO,KAAKG,EAAKC,CAAO,GACjCF,EAAY,EAAI,CAChC,EACA,CAACF,CAAM,CAOF,EAAM,MAAA,EAJFJ,EAAAA,YAAAA,KAAwB,CACjCI,EAAO,KAAK,CAChB,EAAG,CAACA,CAAM,CAEK,EAAM,UAAS,CAClC,C"}

package/dist/audio/use-audio.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-audio.js","names":[],"sources":["../../src/audio/use-audio.ts"],"sourcesContent":["import { useCallback, useEffect, useState } from \"react\";\nimport { createAudioPlayer, type AudioPlayerHandle, type PlayAudioOptions } from \"./audio-player\";\n\nexport interface UseAudioResult {\n    /** Play `src` on the hook's private player. */\n    play: (src: string, options?: PlayAudioOptions) => Promise<void>;\n    /** Stop the current clip. */\n    stop: () => void;\n    /**\n     * Whether the browser's autoplay policy has been satisfied. Becomes\n     * `true` after the first successful `play()`.\n     */\n    unlocked: boolean;\n}\n\n/**\n * The player lives in a state initializer, not in a lazily-written ref: the\n * initializer runs exactly once and is not a side effect during render, which is\n * what the ref version was. The player identity never changes, so state holds it\n * fine and the value is non-null from the first render.\n *\n * Hook-managed audio player. Each component instance gets its own\n * {@link AudioPlayerHandle}, so unmounting cleanly stops playback. Useful for\n * notification chimes, UI feedback sounds, and per-component soundtracks.\n */\nexport function useAudio(): UseAudioResult {\n    const [player] = useState<AudioPlayerHandle>(() => createAudioPlayer());\n    const [unlocked, setUnlocked] = useState<boolean>(false);\n\n    useEffect(() => {\n        return () => {\n            player.stop();\n        };\n    }, [player]);\n\n    const play = useCallback(\n        async (src: string, options?: PlayAudioOptions): Promise<void> => {\n            const result = await player.play(src, options);\n            if (result) setUnlocked(true);\n        },\n        [player],\n    );\n\n    const stop = useCallback((): void => {\n        player.stop();\n    }, [player]);\n\n    return { play, stop, unlocked };\n}\n"],"mappings":";;;AAyBA,SAAgB,IAA2B;CACvC,IAAM,CAAC,KAAU,QAAkC,EAAkB,CAAC,GAChE,CAAC,GAAU,KAAe,EAAkB,EAAK;CAoBvD,OAlBA,cACiB;EACT,EAAO,KAAK;CAChB,GACD,CAAC,CAAM,CAAC,GAcJ;EAAE,MAZI,EACT,OAAO,GAAa,MAA8C;GAE9D,AAAI,MADiB,EAAO,KAAK,GAAK,CAAO,KACjC,EAAY,EAAI;EAChC,GACA,CAAC,CAAM,CAOF;EAAM,MAJF,QAAwB;GACjC,EAAO,KAAK;EAChB,GAAG,CAAC,CAAM,CAEK;EAAM;CAAS;AAClC"}
+{"version":3,"file":"use-audio.js","names":["useAudio","player","useState","createAudioPlayer","unlocked","setUnlocked","useEffect","useCallback","src","options"],"sources":["../../src/audio/use-audio.ts"],"sourcesContent":["import { useCallback, useEffect, useState } from \"react\";\nimport { createAudioPlayer, type AudioPlayerHandle, type PlayAudioOptions } from \"./audio-player\";\n\nexport interface UseAudioResult {\n    /** Play `src` on the hook's private player. */\n    play: (src: string, options?: PlayAudioOptions) => Promise<void>;\n    /** Stop the current clip. */\n    stop: () => void;\n    /**\n     * Whether the browser's autoplay policy has been satisfied. Becomes\n     * `true` after the first successful `play()`.\n     */\n    unlocked: boolean;\n}\n\n/**\n * The player lives in a state initializer, not in a lazily-written ref: the\n * initializer runs exactly once and is not a side effect during render, which is\n * what the ref version was. The player identity never changes, so state holds it\n * fine and the value is non-null from the first render.\n *\n * Hook-managed audio player. Each component instance gets its own\n * {@link AudioPlayerHandle}, so unmounting cleanly stops playback. Useful for\n * notification chimes, UI feedback sounds, and per-component soundtracks.\n */\nexport function useAudio(): UseAudioResult {\n    const [player] = useState<AudioPlayerHandle>(() => createAudioPlayer());\n    const [unlocked, setUnlocked] = useState<boolean>(false);\n\n    useEffect(() => {\n        return () => {\n            player.stop();\n        };\n    }, [player]);\n\n    const play = useCallback(\n        async (src: string, options?: PlayAudioOptions): Promise<void> => {\n            const result = await player.play(src, options);\n            if (result) setUnlocked(true);\n        },\n        [player],\n    );\n\n    const stop = useCallback((): void => {\n        player.stop();\n    }, [player]);\n\n    return { play, stop, unlocked };\n}\n"],"mappings":";;;AAyBA,SAAgBA,IAA2B;CACvC,IAAM,CAACC,KAAUC,QAAkCC,EAAkB,CAAC,GAChE,CAACC,GAAUC,KAAeH,EAAkB,EAAK;CAoBvD,OAlBAI,cACiB;EACT,EAAO,KAAK;CAChB,GACD,CAACL,CAAM,CAAC,GAcJ;EAAE,MAZIM,EACT,OAAO,GAAa,MAA8C;GAE9D,AAAI,MADiBN,EAAO,KAAKO,GAAKC,CAAO,KACjCJ,EAAY,EAAI;EAChC,GACA,CAACJ,CAAM,CAOF;EAAM,MAJFM,QAAwB;GACjC,EAAO,KAAK;EAChB,GAAG,CAACN,CAAM,CAEK;EAAM;CAAS;AAClC"}

package/dist/audio/use-microphone.cjs

@@ -1,2 +1,2 @@
-const e=require("./media-access.cjs");let t=require("react");function n(n={}){let{autoStart:r=!1,deviceId:i,echoCancellation:a=!0,noiseSuppression:o=!0,autoGainControl:s=!0,constraints:c}=n,[l,u]=(0,t.useState)(`idle`),[d,f]=(0,t.useState)(null),[p,m]=(0,t.useState)(null),h=(0,t.useRef)(null),g=(0,t.useRef)(0),_=(0,t.useCallback)(()=>{h.current?.getTracks().forEach(e=>e.stop()),h.current=null},[]),v=(0,t.useCallback)(()=>{g.current+=1,_(),f(null),u(`idle`),m(null)},[_]),y=(0,t.useCallback)(()=>{if(h.current)return;let t=g.current+=1;if(u(`requesting`),m(null),!e.isMediaCaptureSupported()){m(e.missingCaptureApiError(`microphone`)),u(`error`);return}let n=c??{audio:{echoCancellation:a,noiseSuppression:o,autoGainControl:s,...i?{deviceId:{exact:i}}:{}},video:!1};navigator.mediaDevices.getUserMedia(n).then(e=>{if(t!==g.current){e.getTracks().forEach(e=>e.stop());return}h.current=e,f(e),u(`ready`)}).catch(n=>{t===g.current&&(m(e.classifyMediaError(n,`microphone`)),u(`error`))})},[c,i,a,o,s]);return(0,t.useEffect)(()=>{r&&y()},[r]),(0,t.useEffect)(()=>_,[_]),{status:l,stream:d,error:p,start:y,stop:v}}exports.useMicrophone=n;
+const e=require("./media-access.cjs");let t=require("react");function n(n={}){let{autoStart:r=!1,deviceId:i,echoCancellation:a=!0,noiseSuppression:o=!0,autoGainControl:s=!0,constraints:c}=n,[l,u]=(0,t.useState)(`idle`),[d,f]=(0,t.useState)(null),[p,m]=(0,t.useState)(null),h=(0,t.useRef)(null),g=(0,t.useRef)(0),_=(0,t.useCallback)(()=>{h.current?.getTracks().forEach(e=>e.stop()),h.current=null},[]),v=(0,t.useCallback)(()=>{g.current+=1,_(),f(null),u(`idle`),m(null)},[_]),y=(0,t.useCallback)(()=>{if(h.current)return;let t=g.current+=1;if(u(`requesting`),m(null),!e.isMediaCaptureSupported()){m(e.missingCaptureApiError(`microphone`)),u(`error`);return}let n=c??{audio:{echoCancellation:a,noiseSuppression:o,autoGainControl:s,...i?{deviceId:{exact:i}}:{}},video:!1};navigator.mediaDevices.getUserMedia(n).then(e=>{t===g.current?(h.current=e,f(e),u(`ready`)):e.getTracks().forEach(e=>e.stop())}).catch(n=>{t===g.current&&(m(e.classifyMediaError(n,`microphone`)),u(`error`))})},[c,i,a,o,s]);return(0,t.useEffect)(()=>{r&&y()},[r]),(0,t.useEffect)(()=>_,[_]),{status:l,stream:d,error:p,start:y,stop:v}}exports.useMicrophone=n;
 //# sourceMappingURL=use-microphone.cjs.map

package/dist/audio/use-microphone.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-microphone.cjs","names":[],"sources":["../../src/audio/use-microphone.ts"],"sourcesContent":["import { useCallback, useEffect, useRef, useState } from \"react\";\n\nimport {\n    classifyMediaError,\n    isMediaCaptureSupported,\n    missingCaptureApiError,\n    type MediaAccessError,\n} from \"./media-access\";\n\n/** Lifecycle of a microphone stream. */\nexport type MicrophoneStatus = \"idle\" | \"requesting\" | \"ready\" | \"error\";\n\n/** Options for {@link useMicrophone}. */\nexport interface UseMicrophoneOptions {\n    /**\n     * Open the stream on mount instead of waiting for `start()`. Default `false`.\n     *\n     * Left off on purpose. Opening on mount means prompting on mount, and a\n     * permission prompt the user did not provoke is the most reliable way to earn a\n     * permanent \"Block\" — after which `getUserMedia` rejects without ever prompting\n     * again. Wire `start()` to the button that needs the microphone.\n     */\n    autoStart?: boolean;\n    /** Specific microphone, from `useMediaDevices().audioInputs`. */\n    deviceId?: string;\n    /**\n     * Browser voice processing. All three default to `true`, which is what speech\n     * wants; turn them off for music, where a gate chewing on a decaying note is\n     * worse than the room noise it removes.\n     */\n    echoCancellation?: boolean;\n    noiseSuppression?: boolean;\n    autoGainControl?: boolean;\n    /** Escape hatch: full constraints, replacing everything above. */\n    constraints?: MediaStreamConstraints;\n}\n\n/** Value returned by {@link useMicrophone}. */\nexport interface UseMicrophoneResult {\n    status: MicrophoneStatus;\n    /** The live stream, or `null`. Feed it to {@link useAudioRecorder} or an analyser. */\n    stream: MediaStream | null;\n    /** Classified error, or `null` outside the `error` status. */\n    error: MediaAccessError | null;\n    /** Open the stream. Safe to call when already open — it is a no-op. */\n    start: () => void;\n    /** Release the microphone. The browser's recording indicator only clears here. */\n    stop: () => void;\n}\n\n/**\n * Acquire a microphone `MediaStream`, classified errors included, and release it\n * properly.\n *\n * Releasing matters more than it looks. Every track has to be stopped by hand:\n * dropping the last reference to a `MediaStream` does **not** turn off the\n * microphone, so the browser keeps showing its recording indicator and the OS keeps\n * the device busy — which then makes the *next* `getUserMedia` fail with\n * `NotReadableError` in another tab. The hook stops tracks on `stop()`, on unmount,\n * and before re-opening.\n *\n * @param options - See {@link UseMicrophoneOptions}.\n * @returns The stream, its status, a classified error, and `start`/`stop`.\n *\n * @example\n * const mic = useMicrophone();\n * const recorder = useAudioRecorder(mic.stream);\n * <button onClick={mic.start}>Liberar microfone</button>\n */\nexport function useMicrophone(options: UseMicrophoneOptions = {}): UseMicrophoneResult {\n    const {\n        autoStart = false,\n        deviceId,\n        echoCancellation = true,\n        noiseSuppression = true,\n        autoGainControl = true,\n        constraints,\n    } = options;\n\n    const [status, setStatus] = useState<MicrophoneStatus>(\"idle\");\n    const [stream, setStream] = useState<MediaStream | null>(null);\n    const [error, setError] = useState<MediaAccessError | null>(null);\n    const streamRef = useRef<MediaStream | null>(null);\n    const generation = useRef(0);\n\n    const release = useCallback((): void => {\n        streamRef.current?.getTracks().forEach((track) => track.stop());\n        streamRef.current = null;\n    }, []);\n\n    const stop = useCallback((): void => {\n        generation.current += 1;\n        release();\n        setStream(null);\n        setStatus(\"idle\");\n        setError(null);\n    }, [release]);\n\n    const start = useCallback((): void => {\n        if (streamRef.current) return;\n        const run = (generation.current += 1);\n        setStatus(\"requesting\");\n        setError(null);\n\n        if (!isMediaCaptureSupported()) {\n            setError(missingCaptureApiError(\"microphone\"));\n            setStatus(\"error\");\n            return;\n        }\n\n        const request: MediaStreamConstraints = constraints ?? {\n            audio: {\n                echoCancellation,\n                noiseSuppression,\n                autoGainControl,\n                ...(deviceId ? { deviceId: { exact: deviceId } } : {}),\n            },\n            video: false,\n        };\n\n        void navigator.mediaDevices\n            .getUserMedia(request)\n            .then((next) => {\n                if (run !== generation.current) {\n                    next.getTracks().forEach((track) => track.stop());\n                    return;\n                }\n                streamRef.current = next;\n                setStream(next);\n                setStatus(\"ready\");\n            })\n            .catch((err: unknown) => {\n                if (run !== generation.current) return;\n                setError(classifyMediaError(err, \"microphone\"));\n                setStatus(\"error\");\n            });\n    }, [constraints, deviceId, echoCancellation, noiseSuppression, autoGainControl]);\n\n    useEffect(() => {\n        if (autoStart) start();\n        // `start` is stable per constraint set; re-running on every identity change\n        // would reopen the device on each render.\n        // eslint-disable-next-line react-hooks/exhaustive-deps\n    }, [autoStart]);\n\n    useEffect(() => release, [release]);\n\n    return { status, stream, error, start, stop };\n}\n"],"mappings":"6DAqEA,SAAgB,EAAc,EAAgC,CAAC,EAAwB,CACnF,GAAM,CACF,YAAY,GACZ,WACA,mBAAmB,GACnB,mBAAmB,GACnB,kBAAkB,GAClB,eACA,EAEE,CAAC,EAAQ,IAAA,EAAa,EAAA,SAAA,CAA2B,MAAM,EACvD,CAAC,EAAQ,IAAA,EAAa,EAAA,SAAA,CAA6B,IAAI,EACvD,CAAC,EAAO,IAAA,EAAY,EAAA,SAAA,CAAkC,IAAI,EAC1D,GAAA,EAAY,EAAA,OAAA,CAA2B,IAAI,EAC3C,GAAA,EAAa,EAAA,OAAA,CAAO,CAAC,EAErB,GAAA,EAAU,EAAA,YAAA,KAAwB,CACpC,EAAU,SAAS,UAAU,CAAC,CAAC,QAAS,GAAU,EAAM,KAAK,CAAC,EAC9D,EAAU,QAAU,IACxB,EAAG,CAAC,CAAC,EAEC,GAAA,EAAO,EAAA,YAAA,KAAwB,CACjC,EAAW,SAAW,EACtB,EAAQ,EACR,EAAU,IAAI,EACd,EAAU,MAAM,EAChB,EAAS,IAAI,CACjB,EAAG,CAAC,CAAO,CAAC,EAEN,GAAA,EAAQ,EAAA,YAAA,KAAwB,CAClC,GAAI,EAAU,QAAS,OACvB,IAAM,EAAO,EAAW,SAAW,EAInC,GAHA,EAAU,YAAY,EACtB,EAAS,IAAI,EAET,CAAC,EAAA,wBAAwB,EAAG,CAC5B,EAAS,EAAA,uBAAuB,YAAY,CAAC,EAC7C,EAAU,OAAO,EACjB,MACJ,CAEA,IAAM,EAAkC,GAAe,CACnD,MAAO,CACH,mBACA,mBACA,kBACA,GAAI,EAAW,CAAE,SAAU,CAAE,MAAO,CAAS,CAAE,EAAI,CAAC,CACxD,EACA,MAAO,EACX,EAEA,UAAe,aACV,aAAa,CAAO,CAAC,CACrB,KAAM,GAAS,CACZ,GAAI,IAAQ,EAAW,QAAS,CAC5B,EAAK,UAAU,CAAC,CAAC,QAAS,GAAU,EAAM,KAAK,CAAC,EAChD,MACJ,CACA,EAAU,QAAU,EACpB,EAAU,CAAI,EACd,EAAU,OAAO,CACrB,CAAC,CAAC,CACD,MAAO,GAAiB,CACjB,IAAQ,EAAW,UACvB,EAAS,EAAA,mBAAmB,EAAK,YAAY,CAAC,EAC9C,EAAU,OAAO,EACrB,CAAC,CACT,EAAG,CAAC,EAAa,EAAU,EAAkB,EAAkB,CAAe,CAAC,EAW/E,OATA,EAAA,EAAA,UAAA,KAAgB,CACR,GAAW,EAAM,CAIzB,EAAG,CAAC,CAAS,CAAC,GAEd,EAAA,EAAA,UAAA,KAAgB,EAAS,CAAC,CAAO,CAAC,EAE3B,CAAE,SAAQ,SAAQ,QAAO,QAAO,MAAK,CAChD"}
+{"version":3,"file":"use-microphone.cjs","names":["useState","useRef","useCallback","isMediaCaptureSupported","missingCaptureApiError","classifyMediaError","require_media_access","react","useMicrophone","options","status","setStatus","stream","setStream","error","setError","streamRef","generation","release","track","stop","start","run","request","constraints","deviceId","next","err","echoCancellation","noiseSuppression","autoGainControl","autoStart"],"sources":["../../src/audio/use-microphone.ts"],"sourcesContent":["import { useCallback, useEffect, useRef, useState } from \"react\";\n\nimport {\n    classifyMediaError,\n    isMediaCaptureSupported,\n    missingCaptureApiError,\n    type MediaAccessError,\n} from \"./media-access\";\n\n/** Lifecycle of a microphone stream. */\nexport type MicrophoneStatus = \"idle\" | \"requesting\" | \"ready\" | \"error\";\n\n/** Options for {@link useMicrophone}. */\nexport interface UseMicrophoneOptions {\n    /**\n     * Open the stream on mount instead of waiting for `start()`. Default `false`.\n     *\n     * Left off on purpose. Opening on mount means prompting on mount, and a\n     * permission prompt the user did not provoke is the most reliable way to earn a\n     * permanent \"Block\" — after which `getUserMedia` rejects without ever prompting\n     * again. Wire `start()` to the button that needs the microphone.\n     */\n    autoStart?: boolean;\n    /** Specific microphone, from `useMediaDevices().audioInputs`. */\n    deviceId?: string;\n    /**\n     * Browser voice processing. All three default to `true`, which is what speech\n     * wants; turn them off for music, where a gate chewing on a decaying note is\n     * worse than the room noise it removes.\n     */\n    echoCancellation?: boolean;\n    noiseSuppression?: boolean;\n    autoGainControl?: boolean;\n    /** Escape hatch: full constraints, replacing everything above. */\n    constraints?: MediaStreamConstraints;\n}\n\n/** Value returned by {@link useMicrophone}. */\nexport interface UseMicrophoneResult {\n    status: MicrophoneStatus;\n    /** The live stream, or `null`. Feed it to {@link useAudioRecorder} or an analyser. */\n    stream: MediaStream | null;\n    /** Classified error, or `null` outside the `error` status. */\n    error: MediaAccessError | null;\n    /** Open the stream. Safe to call when already open — it is a no-op. */\n    start: () => void;\n    /** Release the microphone. The browser's recording indicator only clears here. */\n    stop: () => void;\n}\n\n/**\n * Acquire a microphone `MediaStream`, classified errors included, and release it\n * properly.\n *\n * Releasing matters more than it looks. Every track has to be stopped by hand:\n * dropping the last reference to a `MediaStream` does **not** turn off the\n * microphone, so the browser keeps showing its recording indicator and the OS keeps\n * the device busy — which then makes the *next* `getUserMedia` fail with\n * `NotReadableError` in another tab. The hook stops tracks on `stop()`, on unmount,\n * and before re-opening.\n *\n * @param options - See {@link UseMicrophoneOptions}.\n * @returns The stream, its status, a classified error, and `start`/`stop`.\n *\n * @example\n * const mic = useMicrophone();\n * const recorder = useAudioRecorder(mic.stream);\n * <button onClick={mic.start}>Liberar microfone</button>\n */\nexport function useMicrophone(options: UseMicrophoneOptions = {}): UseMicrophoneResult {\n    const {\n        autoStart = false,\n        deviceId,\n        echoCancellation = true,\n        noiseSuppression = true,\n        autoGainControl = true,\n        constraints,\n    } = options;\n\n    const [status, setStatus] = useState<MicrophoneStatus>(\"idle\");\n    const [stream, setStream] = useState<MediaStream | null>(null);\n    const [error, setError] = useState<MediaAccessError | null>(null);\n    const streamRef = useRef<MediaStream | null>(null);\n    const generation = useRef(0);\n\n    const release = useCallback((): void => {\n        streamRef.current?.getTracks().forEach((track) => track.stop());\n        streamRef.current = null;\n    }, []);\n\n    const stop = useCallback((): void => {\n        generation.current += 1;\n        release();\n        setStream(null);\n        setStatus(\"idle\");\n        setError(null);\n    }, [release]);\n\n    const start = useCallback((): void => {\n        if (streamRef.current) return;\n        const run = (generation.current += 1);\n        setStatus(\"requesting\");\n        setError(null);\n\n        if (!isMediaCaptureSupported()) {\n            setError(missingCaptureApiError(\"microphone\"));\n            setStatus(\"error\");\n            return;\n        }\n\n        const request: MediaStreamConstraints = constraints ?? {\n            audio: {\n                echoCancellation,\n                noiseSuppression,\n                autoGainControl,\n                ...(deviceId ? { deviceId: { exact: deviceId } } : {}),\n            },\n            video: false,\n        };\n\n        void navigator.mediaDevices\n            .getUserMedia(request)\n            .then((next) => {\n                if (run !== generation.current) {\n                    next.getTracks().forEach((track) => track.stop());\n                    return;\n                }\n                streamRef.current = next;\n                setStream(next);\n                setStatus(\"ready\");\n            })\n            .catch((err: unknown) => {\n                if (run !== generation.current) return;\n                setError(classifyMediaError(err, \"microphone\"));\n                setStatus(\"error\");\n            });\n    }, [constraints, deviceId, echoCancellation, noiseSuppression, autoGainControl]);\n\n    useEffect(() => {\n        if (autoStart) start();\n        // `start` is stable per constraint set; re-running on every identity change\n        // would reopen the device on each render.\n        // eslint-disable-next-line react-hooks/exhaustive-deps\n    }, [autoStart]);\n\n    useEffect(() => release, [release]);\n\n    return { status, stream, error, start, stop };\n}\n"],"mappings":"A,6DAqEA,SAAgBQ,EAAc,EAAgC,CAAC,EAAwB,CACnF,GAAM,CACF,YAAY,GACZ,WACA,mBAAmB,GACnB,mBAAmB,GACnB,kBAAkB,GAClB,eACAC,EAEE,CAACC,EAAQC,IAAA,EAAaX,EAAAA,SAAAA,CAA2B,MAAM,EACvD,CAACY,EAAQC,IAAA,EAAab,EAAAA,SAAAA,CAA6B,IAAI,EACvD,CAACc,EAAOC,IAAA,EAAYf,EAAAA,SAAAA,CAAkC,IAAI,EAC1DgB,GAAA,EAAYf,EAAAA,OAAAA,CAA2B,IAAI,EAC3CgB,GAAA,EAAahB,EAAAA,OAAAA,CAAO,CAAC,EAErBiB,GAAA,EAAUhB,EAAAA,YAAAA,KAAwB,CACpCc,EAAU,SAAS,UAAU,CAAC,CAAC,QAAS,GAAUG,EAAM,KAAK,CAAC,EAC9D,EAAU,QAAU,IACxB,EAAG,CAAC,CAAC,EAECC,GAAA,EAAOlB,EAAAA,YAAAA,KAAwB,CACjC,EAAW,SAAW,EACtBgB,EAAQ,EACRL,EAAU,IAAI,EACdF,EAAU,MAAM,EAChBI,EAAS,IAAI,CACjB,EAAG,CAACG,CAAO,CAAC,EAENG,GAAA,EAAQnB,EAAAA,YAAAA,KAAwB,CAClC,GAAIc,EAAU,QAAS,OACvB,IAAMM,EAAO,EAAW,SAAW,EAInC,GAHAX,EAAU,YAAY,EACtBI,EAAS,IAAI,EAET,CAACZ,EAAAA,wBAAwB,EAAG,CAC5BY,EAASX,EAAAA,uBAAuB,YAAY,CAAC,EAC7CO,EAAU,OAAO,EACjB,MACJ,CAEA,IAAMY,EAAkCC,GAAe,CACnD,MAAO,CACH,mBACA,mBACA,kBACA,GAAIC,EAAW,CAAE,SAAU,CAAE,MAAOA,CAAS,CAAE,EAAI,CAAC,CACxD,EACA,MAAO,EACX,EAEA,UAAe,aACV,aAAaF,CAAO,CAAC,CACrB,KAAM,GAAS,CACRD,IAAQL,EAAW,SAIvB,EAAU,QAAUS,EACpBb,EAAUa,CAAI,EACdf,EAAU,OAAO,GALbe,EAAK,UAAU,CAAC,CAAC,QAAS,GAAUP,EAAM,KAAK,CAAC,CAMxD,CAAC,CAAC,CACD,MAAO,GAAiB,CACjBG,IAAQL,EAAW,UACvBF,EAASV,EAAAA,mBAAmBsB,EAAK,YAAY,CAAC,EAC9ChB,EAAU,OAAO,EACrB,CAAC,CACT,EAAG,CAACa,EAAaC,EAAUG,EAAkBC,EAAkBC,CAAe,CAAC,EAW/E,OATA,EAAAvB,EAAA,UAAA,KAAgB,CACRwB,GAAWV,EAAM,CAIzB,EAAG,CAACU,CAAS,CAAC,GAEd,EAAAxB,EAAA,UAAA,KAAgBW,EAAS,CAACA,CAAO,CAAC,EAE3B,CAAE,SAAQ,SAAQ,QAAO,QAAO,MAAK,CAChD,C"}

package/dist/audio/use-microphone.js

@@ -23,11 +23,7 @@ function s(s = {}) {
 			video: !1
 		};
 		navigator.mediaDevices.getUserMedia(i).then((e) => {
-			if (r !== x.current) {
-				e.getTracks().forEach((e) => e.stop());
-				return;
-			}
-			b.current = e, _(e), h("ready");
+			r === x.current ? (b.current = e, _(e), h("ready")) : e.getTracks().forEach((e) => e.stop());
 		}).catch((t) => {
 			r === x.current && (y(e(t, "microphone")), h("error"));
 		});

package/dist/audio/use-microphone.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-microphone.js","names":[],"sources":["../../src/audio/use-microphone.ts"],"sourcesContent":["import { useCallback, useEffect, useRef, useState } from \"react\";\n\nimport {\n    classifyMediaError,\n    isMediaCaptureSupported,\n    missingCaptureApiError,\n    type MediaAccessError,\n} from \"./media-access\";\n\n/** Lifecycle of a microphone stream. */\nexport type MicrophoneStatus = \"idle\" | \"requesting\" | \"ready\" | \"error\";\n\n/** Options for {@link useMicrophone}. */\nexport interface UseMicrophoneOptions {\n    /**\n     * Open the stream on mount instead of waiting for `start()`. Default `false`.\n     *\n     * Left off on purpose. Opening on mount means prompting on mount, and a\n     * permission prompt the user did not provoke is the most reliable way to earn a\n     * permanent \"Block\" — after which `getUserMedia` rejects without ever prompting\n     * again. Wire `start()` to the button that needs the microphone.\n     */\n    autoStart?: boolean;\n    /** Specific microphone, from `useMediaDevices().audioInputs`. */\n    deviceId?: string;\n    /**\n     * Browser voice processing. All three default to `true`, which is what speech\n     * wants; turn them off for music, where a gate chewing on a decaying note is\n     * worse than the room noise it removes.\n     */\n    echoCancellation?: boolean;\n    noiseSuppression?: boolean;\n    autoGainControl?: boolean;\n    /** Escape hatch: full constraints, replacing everything above. */\n    constraints?: MediaStreamConstraints;\n}\n\n/** Value returned by {@link useMicrophone}. */\nexport interface UseMicrophoneResult {\n    status: MicrophoneStatus;\n    /** The live stream, or `null`. Feed it to {@link useAudioRecorder} or an analyser. */\n    stream: MediaStream | null;\n    /** Classified error, or `null` outside the `error` status. */\n    error: MediaAccessError | null;\n    /** Open the stream. Safe to call when already open — it is a no-op. */\n    start: () => void;\n    /** Release the microphone. The browser's recording indicator only clears here. */\n    stop: () => void;\n}\n\n/**\n * Acquire a microphone `MediaStream`, classified errors included, and release it\n * properly.\n *\n * Releasing matters more than it looks. Every track has to be stopped by hand:\n * dropping the last reference to a `MediaStream` does **not** turn off the\n * microphone, so the browser keeps showing its recording indicator and the OS keeps\n * the device busy — which then makes the *next* `getUserMedia` fail with\n * `NotReadableError` in another tab. The hook stops tracks on `stop()`, on unmount,\n * and before re-opening.\n *\n * @param options - See {@link UseMicrophoneOptions}.\n * @returns The stream, its status, a classified error, and `start`/`stop`.\n *\n * @example\n * const mic = useMicrophone();\n * const recorder = useAudioRecorder(mic.stream);\n * <button onClick={mic.start}>Liberar microfone</button>\n */\nexport function useMicrophone(options: UseMicrophoneOptions = {}): UseMicrophoneResult {\n    const {\n        autoStart = false,\n        deviceId,\n        echoCancellation = true,\n        noiseSuppression = true,\n        autoGainControl = true,\n        constraints,\n    } = options;\n\n    const [status, setStatus] = useState<MicrophoneStatus>(\"idle\");\n    const [stream, setStream] = useState<MediaStream | null>(null);\n    const [error, setError] = useState<MediaAccessError | null>(null);\n    const streamRef = useRef<MediaStream | null>(null);\n    const generation = useRef(0);\n\n    const release = useCallback((): void => {\n        streamRef.current?.getTracks().forEach((track) => track.stop());\n        streamRef.current = null;\n    }, []);\n\n    const stop = useCallback((): void => {\n        generation.current += 1;\n        release();\n        setStream(null);\n        setStatus(\"idle\");\n        setError(null);\n    }, [release]);\n\n    const start = useCallback((): void => {\n        if (streamRef.current) return;\n        const run = (generation.current += 1);\n        setStatus(\"requesting\");\n        setError(null);\n\n        if (!isMediaCaptureSupported()) {\n            setError(missingCaptureApiError(\"microphone\"));\n            setStatus(\"error\");\n            return;\n        }\n\n        const request: MediaStreamConstraints = constraints ?? {\n            audio: {\n                echoCancellation,\n                noiseSuppression,\n                autoGainControl,\n                ...(deviceId ? { deviceId: { exact: deviceId } } : {}),\n            },\n            video: false,\n        };\n\n        void navigator.mediaDevices\n            .getUserMedia(request)\n            .then((next) => {\n                if (run !== generation.current) {\n                    next.getTracks().forEach((track) => track.stop());\n                    return;\n                }\n                streamRef.current = next;\n                setStream(next);\n                setStatus(\"ready\");\n            })\n            .catch((err: unknown) => {\n                if (run !== generation.current) return;\n                setError(classifyMediaError(err, \"microphone\"));\n                setStatus(\"error\");\n            });\n    }, [constraints, deviceId, echoCancellation, noiseSuppression, autoGainControl]);\n\n    useEffect(() => {\n        if (autoStart) start();\n        // `start` is stable per constraint set; re-running on every identity change\n        // would reopen the device on each render.\n        // eslint-disable-next-line react-hooks/exhaustive-deps\n    }, [autoStart]);\n\n    useEffect(() => release, [release]);\n\n    return { status, stream, error, start, stop };\n}\n"],"mappings":";;;AAqEA,SAAgB,EAAc,IAAgC,CAAC,GAAwB;CACnF,IAAM,EACF,eAAY,IACZ,aACA,sBAAmB,IACnB,sBAAmB,IACnB,qBAAkB,IAClB,mBACA,GAEE,CAAC,GAAQ,KAAa,EAA2B,MAAM,GACvD,CAAC,GAAQ,KAAa,EAA6B,IAAI,GACvD,CAAC,GAAO,KAAY,EAAkC,IAAI,GAC1D,IAAY,EAA2B,IAAI,GAC3C,IAAa,EAAO,CAAC,GAErB,IAAU,QAAwB;EAEpC,AADA,EAAU,SAAS,UAAU,CAAC,CAAC,SAAS,MAAU,EAAM,KAAK,CAAC,GAC9D,EAAU,UAAU;CACxB,GAAG,CAAC,CAAC,GAEC,IAAO,QAAwB;EAKjC,AAJA,EAAW,WAAW,GACtB,EAAQ,GACR,EAAU,IAAI,GACd,EAAU,MAAM,GAChB,EAAS,IAAI;CACjB,GAAG,CAAC,CAAO,CAAC,GAEN,IAAQ,QAAwB;EAClC,IAAI,EAAU,SAAS;EACvB,IAAM,IAAO,EAAW,WAAW;EAInC,IAHA,EAAU,YAAY,GACtB,EAAS,IAAI,GAET,CAAC,EAAwB,GAAG;GAE5B,AADA,EAAS,EAAuB,YAAY,CAAC,GAC7C,EAAU,OAAO;GACjB;EACJ;EAEA,IAAM,IAAkC,KAAe;GACnD,OAAO;IACH;IACA;IACA;IACA,GAAI,IAAW,EAAE,UAAU,EAAE,OAAO,EAAS,EAAE,IAAI,CAAC;GACxD;GACA,OAAO;EACX;EAEA,UAAe,aACV,aAAa,CAAO,CAAC,CACrB,MAAM,MAAS;GACZ,IAAI,MAAQ,EAAW,SAAS;IAC5B,EAAK,UAAU,CAAC,CAAC,SAAS,MAAU,EAAM,KAAK,CAAC;IAChD;GACJ;GAGA,AAFA,EAAU,UAAU,GACpB,EAAU,CAAI,GACd,EAAU,OAAO;EACrB,CAAC,CAAC,CACD,OAAO,MAAiB;GACjB,MAAQ,EAAW,YACvB,EAAS,EAAmB,GAAK,YAAY,CAAC,GAC9C,EAAU,OAAO;EACrB,CAAC;CACT,GAAG;EAAC;EAAa;EAAU;EAAkB;EAAkB;CAAe,CAAC;CAW/E,OATA,QAAgB;EACZ,AAAI,KAAW,EAAM;CAIzB,GAAG,CAAC,CAAS,CAAC,GAEd,QAAgB,GAAS,CAAC,CAAO,CAAC,GAE3B;EAAE;EAAQ;EAAQ;EAAO;EAAO;CAAK;AAChD"}
+{"version":3,"file":"use-microphone.js","names":["useMicrophone","options","status","setStatus","useState","stream","setStream","error","setError","streamRef","useRef","generation","release","useCallback","track","stop","start","run","isMediaCaptureSupported","missingCaptureApiError","request","constraints","deviceId","next","classifyMediaError","err","echoCancellation","noiseSuppression","autoGainControl","useEffect","autoStart"],"sources":["../../src/audio/use-microphone.ts"],"sourcesContent":["import { useCallback, useEffect, useRef, useState } from \"react\";\n\nimport {\n    classifyMediaError,\n    isMediaCaptureSupported,\n    missingCaptureApiError,\n    type MediaAccessError,\n} from \"./media-access\";\n\n/** Lifecycle of a microphone stream. */\nexport type MicrophoneStatus = \"idle\" | \"requesting\" | \"ready\" | \"error\";\n\n/** Options for {@link useMicrophone}. */\nexport interface UseMicrophoneOptions {\n    /**\n     * Open the stream on mount instead of waiting for `start()`. Default `false`.\n     *\n     * Left off on purpose. Opening on mount means prompting on mount, and a\n     * permission prompt the user did not provoke is the most reliable way to earn a\n     * permanent \"Block\" — after which `getUserMedia` rejects without ever prompting\n     * again. Wire `start()` to the button that needs the microphone.\n     */\n    autoStart?: boolean;\n    /** Specific microphone, from `useMediaDevices().audioInputs`. */\n    deviceId?: string;\n    /**\n     * Browser voice processing. All three default to `true`, which is what speech\n     * wants; turn them off for music, where a gate chewing on a decaying note is\n     * worse than the room noise it removes.\n     */\n    echoCancellation?: boolean;\n    noiseSuppression?: boolean;\n    autoGainControl?: boolean;\n    /** Escape hatch: full constraints, replacing everything above. */\n    constraints?: MediaStreamConstraints;\n}\n\n/** Value returned by {@link useMicrophone}. */\nexport interface UseMicrophoneResult {\n    status: MicrophoneStatus;\n    /** The live stream, or `null`. Feed it to {@link useAudioRecorder} or an analyser. */\n    stream: MediaStream | null;\n    /** Classified error, or `null` outside the `error` status. */\n    error: MediaAccessError | null;\n    /** Open the stream. Safe to call when already open — it is a no-op. */\n    start: () => void;\n    /** Release the microphone. The browser's recording indicator only clears here. */\n    stop: () => void;\n}\n\n/**\n * Acquire a microphone `MediaStream`, classified errors included, and release it\n * properly.\n *\n * Releasing matters more than it looks. Every track has to be stopped by hand:\n * dropping the last reference to a `MediaStream` does **not** turn off the\n * microphone, so the browser keeps showing its recording indicator and the OS keeps\n * the device busy — which then makes the *next* `getUserMedia` fail with\n * `NotReadableError` in another tab. The hook stops tracks on `stop()`, on unmount,\n * and before re-opening.\n *\n * @param options - See {@link UseMicrophoneOptions}.\n * @returns The stream, its status, a classified error, and `start`/`stop`.\n *\n * @example\n * const mic = useMicrophone();\n * const recorder = useAudioRecorder(mic.stream);\n * <button onClick={mic.start}>Liberar microfone</button>\n */\nexport function useMicrophone(options: UseMicrophoneOptions = {}): UseMicrophoneResult {\n    const {\n        autoStart = false,\n        deviceId,\n        echoCancellation = true,\n        noiseSuppression = true,\n        autoGainControl = true,\n        constraints,\n    } = options;\n\n    const [status, setStatus] = useState<MicrophoneStatus>(\"idle\");\n    const [stream, setStream] = useState<MediaStream | null>(null);\n    const [error, setError] = useState<MediaAccessError | null>(null);\n    const streamRef = useRef<MediaStream | null>(null);\n    const generation = useRef(0);\n\n    const release = useCallback((): void => {\n        streamRef.current?.getTracks().forEach((track) => track.stop());\n        streamRef.current = null;\n    }, []);\n\n    const stop = useCallback((): void => {\n        generation.current += 1;\n        release();\n        setStream(null);\n        setStatus(\"idle\");\n        setError(null);\n    }, [release]);\n\n    const start = useCallback((): void => {\n        if (streamRef.current) return;\n        const run = (generation.current += 1);\n        setStatus(\"requesting\");\n        setError(null);\n\n        if (!isMediaCaptureSupported()) {\n            setError(missingCaptureApiError(\"microphone\"));\n            setStatus(\"error\");\n            return;\n        }\n\n        const request: MediaStreamConstraints = constraints ?? {\n            audio: {\n                echoCancellation,\n                noiseSuppression,\n                autoGainControl,\n                ...(deviceId ? { deviceId: { exact: deviceId } } : {}),\n            },\n            video: false,\n        };\n\n        void navigator.mediaDevices\n            .getUserMedia(request)\n            .then((next) => {\n                if (run !== generation.current) {\n                    next.getTracks().forEach((track) => track.stop());\n                    return;\n                }\n                streamRef.current = next;\n                setStream(next);\n                setStatus(\"ready\");\n            })\n            .catch((err: unknown) => {\n                if (run !== generation.current) return;\n                setError(classifyMediaError(err, \"microphone\"));\n                setStatus(\"error\");\n            });\n    }, [constraints, deviceId, echoCancellation, noiseSuppression, autoGainControl]);\n\n    useEffect(() => {\n        if (autoStart) start();\n        // `start` is stable per constraint set; re-running on every identity change\n        // would reopen the device on each render.\n        // eslint-disable-next-line react-hooks/exhaustive-deps\n    }, [autoStart]);\n\n    useEffect(() => release, [release]);\n\n    return { status, stream, error, start, stop };\n}\n"],"mappings":";;;AAqEA,SAAgBA,EAAc,IAAgC,CAAC,GAAwB;CACnF,IAAM,EACF,eAAY,IACZ,aACA,sBAAmB,IACnB,sBAAmB,IACnB,qBAAkB,IAClB,mBACAC,GAEE,CAACC,GAAQC,KAAaC,EAA2B,MAAM,GACvD,CAACC,GAAQC,KAAaF,EAA6B,IAAI,GACvD,CAACG,GAAOC,KAAYJ,EAAkC,IAAI,GAC1DK,IAAYC,EAA2B,IAAI,GAC3CC,IAAaD,EAAO,CAAC,GAErBE,IAAUC,QAAwB;EAEpC,AADAJ,EAAU,SAAS,UAAU,CAAC,CAAC,SAAS,MAAUK,EAAM,KAAK,CAAC,GAC9D,EAAU,UAAU;CACxB,GAAG,CAAC,CAAC,GAECC,IAAOF,QAAwB;EAKjC,AAJA,EAAW,WAAW,GACtBD,EAAQ,GACRN,EAAU,IAAI,GACdH,EAAU,MAAM,GAChBK,EAAS,IAAI;CACjB,GAAG,CAACI,CAAO,CAAC,GAENI,IAAQH,QAAwB;EAClC,IAAIJ,EAAU,SAAS;EACvB,IAAMQ,IAAO,EAAW,WAAW;EAInC,IAHAd,EAAU,YAAY,GACtBK,EAAS,IAAI,GAET,CAACU,EAAwB,GAAG;GAE5B,AADAV,EAASW,EAAuB,YAAY,CAAC,GAC7ChB,EAAU,OAAO;GACjB;EACJ;EAEA,IAAMiB,IAAkCC,KAAe;GACnD,OAAO;IACH;IACA;IACA;IACA,GAAIC,IAAW,EAAE,UAAU,EAAE,OAAOA,EAAS,EAAE,IAAI,CAAC;GACxD;GACA,OAAO;EACX;EAEA,UAAe,aACV,aAAaF,CAAO,CAAC,CACrB,MAAM,MAAS;GACZ,AAAIH,MAAQN,EAAW,WAIvB,EAAU,UAAUY,GACpBjB,EAAUiB,CAAI,GACdpB,EAAU,OAAO,KALboB,EAAK,UAAU,CAAC,CAAC,SAAS,MAAUT,EAAM,KAAK,CAAC;EAMxD,CAAC,CAAC,CACD,OAAO,MAAiB;GACrB,AAAIG,MAAQN,EAAW,YACvBH,EAASgB,EAAmBC,GAAK,YAAY,CAAC,GAC9CtB,EAAU,OAAO;EACrB,CAAC;CACT,GAAG;EAACkB;EAAaC;EAAUI;EAAkBC;EAAkBC;CAAe,CAAC;CAW/E,OATAC,QAAgB;EACZ,AAAIC,KAAWd,EAAM;CAIzB,GAAG,CAACc,CAAS,CAAC,GAEdD,QAAgBjB,GAAS,CAACA,CAAO,CAAC,GAE3B;EAAE;EAAQ;EAAQ;EAAO;EAAO;CAAK;AAChD"}

package/dist/audio/use-sfx-pool.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-sfx-pool.cjs","names":[],"sources":["../../src/audio/use-sfx-pool.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\nimport { createSfxPool, type SfxPool, type SfxPoolOptions } from \"./sfx-pool\";\n\n/**\n * Component-scoped {@link createSfxPool}, with the lifecycle wired up.\n *\n * The pool is created once — through a lazy `useState` initializer, so no\n * element is allocated on a render that gets discarded — and disposed on\n * unmount, so its elements do not outlive the screen that owns them.\n *\n * `volume` is tracked separately: changing it calls `setVolume` on the existing\n * pool rather than rebuilding it, which would throw away every clip the user\n * has already downloaded — exactly the cost the pool exists to avoid.\n * `baseUrl`, `voices` and `maxSources` are read once, at creation. The options\n * object is forwarded whole rather than rebuilt field by field, so a field added\n * to {@link SfxPoolOptions} does not silently stop reaching the pool.\n *\n * @param options - Passed through to {@link createSfxPool}.\n * @returns A stable pool handle.\n *\n * @example\n * const sfx = useSfxPool({ volume: settings.sfxVolume / 100, baseUrl: import.meta.env.BASE_URL });\n *\n * useEffect(() => { sfx.preload([\"sfx/select.mp3\", \"sfx/back.mp3\"]); }, [sfx]);\n *\n * <button onClick={() => sfx.play(\"sfx/select.mp3\")}>Confirmar</button>\n */\nexport function useSfxPool(options: SfxPoolOptions = {}): SfxPool {\n    const { volume = 1 } = options;\n\n    const [pool] = useState(() => createSfxPool(options));\n\n    useEffect(() => {\n        pool.setVolume(volume);\n    }, [pool, volume]);\n\n    useEffect(() => () => pool.dispose(), [pool]);\n\n    return pool;\n}\n"],"mappings":"yDA2BA,SAAgB,EAAW,EAA0B,CAAC,EAAY,CAC9D,GAAM,CAAE,SAAS,GAAM,EAEjB,CAAC,IAAA,EAAQ,EAAA,SAAA,KAAe,EAAA,cAAc,CAAO,CAAC,EAQpD,OANA,EAAA,EAAA,UAAA,KAAgB,CACZ,EAAK,UAAU,CAAM,CACzB,EAAG,CAAC,EAAM,CAAM,CAAC,GAEjB,EAAA,EAAA,UAAA,SAAsB,EAAK,QAAQ,EAAG,CAAC,CAAI,CAAC,EAErC,CACX"}
+{"version":3,"file":"use-sfx-pool.cjs","names":["useState","createSfxPool","require_sfx_pool","react","useSfxPool","options","pool","volume"],"sources":["../../src/audio/use-sfx-pool.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\nimport { createSfxPool, type SfxPool, type SfxPoolOptions } from \"./sfx-pool\";\n\n/**\n * Component-scoped {@link createSfxPool}, with the lifecycle wired up.\n *\n * The pool is created once — through a lazy `useState` initializer, so no\n * element is allocated on a render that gets discarded — and disposed on\n * unmount, so its elements do not outlive the screen that owns them.\n *\n * `volume` is tracked separately: changing it calls `setVolume` on the existing\n * pool rather than rebuilding it, which would throw away every clip the user\n * has already downloaded — exactly the cost the pool exists to avoid.\n * `baseUrl`, `voices` and `maxSources` are read once, at creation. The options\n * object is forwarded whole rather than rebuilt field by field, so a field added\n * to {@link SfxPoolOptions} does not silently stop reaching the pool.\n *\n * @param options - Passed through to {@link createSfxPool}.\n * @returns A stable pool handle.\n *\n * @example\n * const sfx = useSfxPool({ volume: settings.sfxVolume / 100, baseUrl: import.meta.env.BASE_URL });\n *\n * useEffect(() => { sfx.preload([\"sfx/select.mp3\", \"sfx/back.mp3\"]); }, [sfx]);\n *\n * <button onClick={() => sfx.play(\"sfx/select.mp3\")}>Confirmar</button>\n */\nexport function useSfxPool(options: SfxPoolOptions = {}): SfxPool {\n    const { volume = 1 } = options;\n\n    const [pool] = useState(() => createSfxPool(options));\n\n    useEffect(() => {\n        pool.setVolume(volume);\n    }, [pool, volume]);\n\n    useEffect(() => () => pool.dispose(), [pool]);\n\n    return pool;\n}\n"],"mappings":"A,yDA2BA,SAAgBI,EAAW,EAA0B,CAAC,EAAY,CAC9D,GAAM,CAAE,SAAS,GAAMC,EAEjB,CAACC,IAAA,EAAQN,EAAAA,SAAAA,KAAeC,EAAAA,cAAcI,CAAO,CAAC,EAQpD,OANA,EAAAF,EAAA,UAAA,KAAgB,CACZG,EAAK,UAAUC,CAAM,CACzB,EAAG,CAACD,EAAMC,CAAM,CAAC,GAEjB,EAAAJ,EAAA,UAAA,SAAsBG,EAAK,QAAQ,EAAG,CAACA,CAAI,CAAC,EAErCA,CACX,C"}

package/dist/audio/use-sfx-pool.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-sfx-pool.js","names":[],"sources":["../../src/audio/use-sfx-pool.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\nimport { createSfxPool, type SfxPool, type SfxPoolOptions } from \"./sfx-pool\";\n\n/**\n * Component-scoped {@link createSfxPool}, with the lifecycle wired up.\n *\n * The pool is created once — through a lazy `useState` initializer, so no\n * element is allocated on a render that gets discarded — and disposed on\n * unmount, so its elements do not outlive the screen that owns them.\n *\n * `volume` is tracked separately: changing it calls `setVolume` on the existing\n * pool rather than rebuilding it, which would throw away every clip the user\n * has already downloaded — exactly the cost the pool exists to avoid.\n * `baseUrl`, `voices` and `maxSources` are read once, at creation. The options\n * object is forwarded whole rather than rebuilt field by field, so a field added\n * to {@link SfxPoolOptions} does not silently stop reaching the pool.\n *\n * @param options - Passed through to {@link createSfxPool}.\n * @returns A stable pool handle.\n *\n * @example\n * const sfx = useSfxPool({ volume: settings.sfxVolume / 100, baseUrl: import.meta.env.BASE_URL });\n *\n * useEffect(() => { sfx.preload([\"sfx/select.mp3\", \"sfx/back.mp3\"]); }, [sfx]);\n *\n * <button onClick={() => sfx.play(\"sfx/select.mp3\")}>Confirmar</button>\n */\nexport function useSfxPool(options: SfxPoolOptions = {}): SfxPool {\n    const { volume = 1 } = options;\n\n    const [pool] = useState(() => createSfxPool(options));\n\n    useEffect(() => {\n        pool.setVolume(volume);\n    }, [pool, volume]);\n\n    useEffect(() => () => pool.dispose(), [pool]);\n\n    return pool;\n}\n"],"mappings":";;;AA2BA,SAAgB,EAAW,IAA0B,CAAC,GAAY;CAC9D,IAAM,EAAE,YAAS,MAAM,GAEjB,CAAC,KAAQ,QAAe,EAAc,CAAO,CAAC;CAQpD,OANA,QAAgB;EACZ,EAAK,UAAU,CAAM;CACzB,GAAG,CAAC,GAAM,CAAM,CAAC,GAEjB,cAAsB,EAAK,QAAQ,GAAG,CAAC,CAAI,CAAC,GAErC;AACX"}
+{"version":3,"file":"use-sfx-pool.js","names":["useSfxPool","options","pool","useState","createSfxPool","useEffect","volume"],"sources":["../../src/audio/use-sfx-pool.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\nimport { createSfxPool, type SfxPool, type SfxPoolOptions } from \"./sfx-pool\";\n\n/**\n * Component-scoped {@link createSfxPool}, with the lifecycle wired up.\n *\n * The pool is created once — through a lazy `useState` initializer, so no\n * element is allocated on a render that gets discarded — and disposed on\n * unmount, so its elements do not outlive the screen that owns them.\n *\n * `volume` is tracked separately: changing it calls `setVolume` on the existing\n * pool rather than rebuilding it, which would throw away every clip the user\n * has already downloaded — exactly the cost the pool exists to avoid.\n * `baseUrl`, `voices` and `maxSources` are read once, at creation. The options\n * object is forwarded whole rather than rebuilt field by field, so a field added\n * to {@link SfxPoolOptions} does not silently stop reaching the pool.\n *\n * @param options - Passed through to {@link createSfxPool}.\n * @returns A stable pool handle.\n *\n * @example\n * const sfx = useSfxPool({ volume: settings.sfxVolume / 100, baseUrl: import.meta.env.BASE_URL });\n *\n * useEffect(() => { sfx.preload([\"sfx/select.mp3\", \"sfx/back.mp3\"]); }, [sfx]);\n *\n * <button onClick={() => sfx.play(\"sfx/select.mp3\")}>Confirmar</button>\n */\nexport function useSfxPool(options: SfxPoolOptions = {}): SfxPool {\n    const { volume = 1 } = options;\n\n    const [pool] = useState(() => createSfxPool(options));\n\n    useEffect(() => {\n        pool.setVolume(volume);\n    }, [pool, volume]);\n\n    useEffect(() => () => pool.dispose(), [pool]);\n\n    return pool;\n}\n"],"mappings":";;;AA2BA,SAAgBA,EAAW,IAA0B,CAAC,GAAY;CAC9D,IAAM,EAAE,YAAS,MAAMC,GAEjB,CAACC,KAAQC,QAAeC,EAAcH,CAAO,CAAC;CAQpD,OANAI,QAAgB;EACZ,EAAK,UAAUC,CAAM;CACzB,GAAG,CAACJ,GAAMI,CAAM,CAAC,GAEjBD,cAAsBH,EAAK,QAAQ,GAAG,CAACA,CAAI,CAAC,GAErCA;AACX"}

package/dist/audio/voice-activity.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"voice-activity.cjs","names":[],"sources":["../../src/audio/voice-activity.ts"],"sourcesContent":["import { createLevelMeter } from \"./level-meter\";\n\n/** RMS at which a window counts as speech. */\nconst DEFAULT_THRESHOLD = 0.045;\n\n/**\n * How long the indicator stays on after the level drops.\n *\n * RMS falls to nothing in the gaps between words, so a bare threshold strobes on\n * every one of them. Ported from `tempest-mirror-screen`'s `voiceActivity.ts`,\n * where it was arrived at by watching a real call.\n */\nconst DEFAULT_RELEASE_MS = 350;\n\n/** How often the level is read. */\nconst DEFAULT_POLL_MS = 100;\n\n/** Options for {@link monitorVoiceActivity}. */\nexport interface VoiceActivityOptions {\n    /** RMS at or above which a window counts as speech. Default `0.045`. */\n    threshold?: number;\n    /** How long the state stays `true` after the level drops. Default `350`. */\n    releaseMs?: number;\n    /** How often the level is sampled, in ms. Default `100`. */\n    pollMs?: number;\n    /**\n     * Reuse an existing `AudioContext` instead of creating one.\n     *\n     * A monitor per remote participant hits the browser's cap on live contexts\n     * (Chrome allows around six) in a five-person call. Open one and share it.\n     */\n    context?: AudioContext;\n}\n\n/** A running voice-activity monitor. */\nexport interface VoiceActivityMonitor {\n    /** Whether the track is currently carrying speech. */\n    readonly speaking: boolean;\n    /** Stop sampling and release the analysis graph. */\n    stop: () => void;\n}\n\n/**\n * Report when a track is carrying speech.\n *\n * Runs entirely on the **receiving** side, over a track the connection already\n * delivers, and that is the whole point: a speaking indicator changes several\n * times per second, so signalling it through a server floods the room with\n * messages carrying information every client can derive for free.\n *\n * Two details separate this from a threshold on a level meter:\n *\n * 1. **The release.** RMS drops to nothing in the gaps between words, so a bare\n *    comparison strobes on every syllable. The state only falls after\n *    `releaseMs` of quiet.\n * 2. **`onChange` fires on the flip, not on the sample.** A callback per poll\n *    would re-render a participant list ten times a second to say the same thing.\n *\n * The meter underneath runs with smoothing off: its eased decay plus this release\n * would hold the indicator open long after the speech stopped.\n *\n * @param stream - The stream whose first audio track is measured.\n * @param onChange - Called only when the speaking state actually flips.\n * @param options - See {@link VoiceActivityOptions}.\n * @returns A handle carrying the current state and the teardown.\n *\n * @example\n * const vad = monitorVoiceActivity(remoteStream, (speaking) => setSpeaking(speaking));\n * // later\n * vad.stop();\n */\nexport function monitorVoiceActivity(\n    stream: MediaStream,\n    onChange: (speaking: boolean) => void,\n    {\n        threshold = DEFAULT_THRESHOLD,\n        releaseMs = DEFAULT_RELEASE_MS,\n        pollMs = DEFAULT_POLL_MS,\n        context,\n    }: VoiceActivityOptions = {},\n): VoiceActivityMonitor {\n    const meter = createLevelMeter(stream, { decay: 0, ...(context ? { context } : {}) });\n    let speaking = false;\n    let lastLoudAt = 0;\n\n    const timer = setInterval(() => {\n        const now = performance.now();\n        if (meter.level() >= threshold) lastLoudAt = now;\n        const next = lastLoudAt > 0 && now - lastLoudAt < releaseMs;\n        if (next === speaking) return;\n        speaking = next;\n        onChange(speaking);\n    }, pollMs);\n\n    return {\n        get speaking(): boolean {\n            return speaking;\n        },\n        stop: (): void => {\n            clearInterval(timer);\n            meter.stop();\n        },\n    };\n}\n"],"mappings":"qCAGA,IAAM,EAAoB,KASpB,EAAqB,IAGrB,EAAkB,IAwDxB,SAAgB,EACZ,EACA,EACA,CACI,YAAY,EACZ,YAAY,EACZ,SAAS,EACT,WACsB,CAAC,EACP,CACpB,IAAM,EAAQ,EAAA,iBAAiB,EAAQ,CAAE,MAAO,EAAG,GAAI,EAAU,CAAE,SAAQ,EAAI,CAAC,CAAG,CAAC,EAChF,EAAW,GACX,EAAa,EAEX,EAAQ,gBAAkB,CAC5B,IAAM,EAAM,YAAY,IAAI,EACxB,EAAM,MAAM,GAAK,IAAW,EAAa,GAC7C,IAAM,EAAO,EAAa,GAAK,EAAM,EAAa,EAC9C,IAAS,IACb,EAAW,EACX,EAAS,CAAQ,EACrB,EAAG,CAAM,EAET,MAAO,CACH,IAAI,UAAoB,CACpB,OAAO,CACX,EACA,SAAkB,CACd,cAAc,CAAK,EACnB,EAAM,KAAK,CACf,CACJ,CACJ"}
+{"version":3,"file":"voice-activity.cjs","names":["createLevelMeter","require_level_meter","DEFAULT_THRESHOLD","DEFAULT_RELEASE_MS","DEFAULT_POLL_MS","monitorVoiceActivity","meter","stream","context","speaking","lastLoudAt","timer","now","threshold","next","releaseMs","onChange","pollMs"],"sources":["../../src/audio/voice-activity.ts"],"sourcesContent":["import { createLevelMeter } from \"./level-meter\";\n\n/** RMS at which a window counts as speech. */\nconst DEFAULT_THRESHOLD = 0.045;\n\n/**\n * How long the indicator stays on after the level drops.\n *\n * RMS falls to nothing in the gaps between words, so a bare threshold strobes on\n * every one of them. Ported from `tempest-mirror-screen`'s `voiceActivity.ts`,\n * where it was arrived at by watching a real call.\n */\nconst DEFAULT_RELEASE_MS = 350;\n\n/** How often the level is read. */\nconst DEFAULT_POLL_MS = 100;\n\n/** Options for {@link monitorVoiceActivity}. */\nexport interface VoiceActivityOptions {\n    /** RMS at or above which a window counts as speech. Default `0.045`. */\n    threshold?: number;\n    /** How long the state stays `true` after the level drops. Default `350`. */\n    releaseMs?: number;\n    /** How often the level is sampled, in ms. Default `100`. */\n    pollMs?: number;\n    /**\n     * Reuse an existing `AudioContext` instead of creating one.\n     *\n     * A monitor per remote participant hits the browser's cap on live contexts\n     * (Chrome allows around six) in a five-person call. Open one and share it.\n     */\n    context?: AudioContext;\n}\n\n/** A running voice-activity monitor. */\nexport interface VoiceActivityMonitor {\n    /** Whether the track is currently carrying speech. */\n    readonly speaking: boolean;\n    /** Stop sampling and release the analysis graph. */\n    stop: () => void;\n}\n\n/**\n * Report when a track is carrying speech.\n *\n * Runs entirely on the **receiving** side, over a track the connection already\n * delivers, and that is the whole point: a speaking indicator changes several\n * times per second, so signalling it through a server floods the room with\n * messages carrying information every client can derive for free.\n *\n * Two details separate this from a threshold on a level meter:\n *\n * 1. **The release.** RMS drops to nothing in the gaps between words, so a bare\n *    comparison strobes on every syllable. The state only falls after\n *    `releaseMs` of quiet.\n * 2. **`onChange` fires on the flip, not on the sample.** A callback per poll\n *    would re-render a participant list ten times a second to say the same thing.\n *\n * The meter underneath runs with smoothing off: its eased decay plus this release\n * would hold the indicator open long after the speech stopped.\n *\n * @param stream - The stream whose first audio track is measured.\n * @param onChange - Called only when the speaking state actually flips.\n * @param options - See {@link VoiceActivityOptions}.\n * @returns A handle carrying the current state and the teardown.\n *\n * @example\n * const vad = monitorVoiceActivity(remoteStream, (speaking) => setSpeaking(speaking));\n * // later\n * vad.stop();\n */\nexport function monitorVoiceActivity(\n    stream: MediaStream,\n    onChange: (speaking: boolean) => void,\n    {\n        threshold = DEFAULT_THRESHOLD,\n        releaseMs = DEFAULT_RELEASE_MS,\n        pollMs = DEFAULT_POLL_MS,\n        context,\n    }: VoiceActivityOptions = {},\n): VoiceActivityMonitor {\n    const meter = createLevelMeter(stream, { decay: 0, ...(context ? { context } : {}) });\n    let speaking = false;\n    let lastLoudAt = 0;\n\n    const timer = setInterval(() => {\n        const now = performance.now();\n        if (meter.level() >= threshold) lastLoudAt = now;\n        const next = lastLoudAt > 0 && now - lastLoudAt < releaseMs;\n        if (next === speaking) return;\n        speaking = next;\n        onChange(speaking);\n    }, pollMs);\n\n    return {\n        get speaking(): boolean {\n            return speaking;\n        },\n        stop: (): void => {\n            clearInterval(timer);\n            meter.stop();\n        },\n    };\n}\n"],"mappings":"A,qCAGA,IAAME,EAAoB,KASpBC,EAAqB,IAGrBC,EAAkB,IAwDxB,SAAgBC,EACZ,EACA,EACA,CACI,YAAYH,EACZ,YAAYC,EACZ,SAASC,EACT,WACsB,CAAC,EACP,CACpB,IAAME,EAAQN,EAAAA,iBAAiBO,EAAQ,CAAE,MAAO,EAAG,GAAIC,EAAU,CAAE,SAAQ,EAAI,CAAC,CAAG,CAAC,EAChFC,EAAW,GACXC,EAAa,EAEXC,EAAQ,gBAAkB,CAC5B,IAAMC,EAAM,YAAY,IAAI,EACxBN,EAAM,MAAM,GAAKO,IAAW,EAAaD,GAC7C,IAAME,EAAOJ,EAAa,GAAKE,EAAMF,EAAaK,EAC9CD,IAASL,IACb,EAAWK,EACXE,EAASP,CAAQ,EACrB,EAAGQ,CAAM,EAET,MAAO,CACH,IAAI,UAAoB,CACpB,OAAOR,CACX,EACA,SAAkB,CACd,cAAcE,CAAK,EACnBL,EAAM,KAAK,CACf,CACJ,CACJ,C"}

package/dist/audio/voice-activity.js.map

@@ -1 +1 @@
-{"version":3,"file":"voice-activity.js","names":[],"sources":["../../src/audio/voice-activity.ts"],"sourcesContent":["import { createLevelMeter } from \"./level-meter\";\n\n/** RMS at which a window counts as speech. */\nconst DEFAULT_THRESHOLD = 0.045;\n\n/**\n * How long the indicator stays on after the level drops.\n *\n * RMS falls to nothing in the gaps between words, so a bare threshold strobes on\n * every one of them. Ported from `tempest-mirror-screen`'s `voiceActivity.ts`,\n * where it was arrived at by watching a real call.\n */\nconst DEFAULT_RELEASE_MS = 350;\n\n/** How often the level is read. */\nconst DEFAULT_POLL_MS = 100;\n\n/** Options for {@link monitorVoiceActivity}. */\nexport interface VoiceActivityOptions {\n    /** RMS at or above which a window counts as speech. Default `0.045`. */\n    threshold?: number;\n    /** How long the state stays `true` after the level drops. Default `350`. */\n    releaseMs?: number;\n    /** How often the level is sampled, in ms. Default `100`. */\n    pollMs?: number;\n    /**\n     * Reuse an existing `AudioContext` instead of creating one.\n     *\n     * A monitor per remote participant hits the browser's cap on live contexts\n     * (Chrome allows around six) in a five-person call. Open one and share it.\n     */\n    context?: AudioContext;\n}\n\n/** A running voice-activity monitor. */\nexport interface VoiceActivityMonitor {\n    /** Whether the track is currently carrying speech. */\n    readonly speaking: boolean;\n    /** Stop sampling and release the analysis graph. */\n    stop: () => void;\n}\n\n/**\n * Report when a track is carrying speech.\n *\n * Runs entirely on the **receiving** side, over a track the connection already\n * delivers, and that is the whole point: a speaking indicator changes several\n * times per second, so signalling it through a server floods the room with\n * messages carrying information every client can derive for free.\n *\n * Two details separate this from a threshold on a level meter:\n *\n * 1. **The release.** RMS drops to nothing in the gaps between words, so a bare\n *    comparison strobes on every syllable. The state only falls after\n *    `releaseMs` of quiet.\n * 2. **`onChange` fires on the flip, not on the sample.** A callback per poll\n *    would re-render a participant list ten times a second to say the same thing.\n *\n * The meter underneath runs with smoothing off: its eased decay plus this release\n * would hold the indicator open long after the speech stopped.\n *\n * @param stream - The stream whose first audio track is measured.\n * @param onChange - Called only when the speaking state actually flips.\n * @param options - See {@link VoiceActivityOptions}.\n * @returns A handle carrying the current state and the teardown.\n *\n * @example\n * const vad = monitorVoiceActivity(remoteStream, (speaking) => setSpeaking(speaking));\n * // later\n * vad.stop();\n */\nexport function monitorVoiceActivity(\n    stream: MediaStream,\n    onChange: (speaking: boolean) => void,\n    {\n        threshold = DEFAULT_THRESHOLD,\n        releaseMs = DEFAULT_RELEASE_MS,\n        pollMs = DEFAULT_POLL_MS,\n        context,\n    }: VoiceActivityOptions = {},\n): VoiceActivityMonitor {\n    const meter = createLevelMeter(stream, { decay: 0, ...(context ? { context } : {}) });\n    let speaking = false;\n    let lastLoudAt = 0;\n\n    const timer = setInterval(() => {\n        const now = performance.now();\n        if (meter.level() >= threshold) lastLoudAt = now;\n        const next = lastLoudAt > 0 && now - lastLoudAt < releaseMs;\n        if (next === speaking) return;\n        speaking = next;\n        onChange(speaking);\n    }, pollMs);\n\n    return {\n        get speaking(): boolean {\n            return speaking;\n        },\n        stop: (): void => {\n            clearInterval(timer);\n            meter.stop();\n        },\n    };\n}\n"],"mappings":";;AAGA,IAAM,IAAoB,MASpB,IAAqB,KAGrB,IAAkB;AAwDxB,SAAgB,EACZ,GACA,GACA,EACI,eAAY,GACZ,eAAY,GACZ,YAAS,GACT,eACsB,CAAC,GACP;CACpB,IAAM,IAAQ,EAAiB,GAAQ;EAAE,OAAO;EAAG,GAAI,IAAU,EAAE,WAAQ,IAAI,CAAC;CAAG,CAAC,GAChF,IAAW,IACX,IAAa,GAEX,IAAQ,kBAAkB;EAC5B,IAAM,IAAM,YAAY,IAAI;EAC5B,AAAI,EAAM,MAAM,KAAK,MAAW,IAAa;EAC7C,IAAM,IAAO,IAAa,KAAK,IAAM,IAAa;EAC9C,MAAS,MACb,IAAW,GACX,EAAS,CAAQ;CACrB,GAAG,CAAM;CAET,OAAO;EACH,IAAI,WAAoB;GACpB,OAAO;EACX;EACA,YAAkB;GAEd,AADA,cAAc,CAAK,GACnB,EAAM,KAAK;EACf;CACJ;AACJ"}
+{"version":3,"file":"voice-activity.js","names":["DEFAULT_THRESHOLD","DEFAULT_RELEASE_MS","DEFAULT_POLL_MS","monitorVoiceActivity","meter","createLevelMeter","stream","context","speaking","lastLoudAt","timer","now","threshold","next","releaseMs","onChange","pollMs"],"sources":["../../src/audio/voice-activity.ts"],"sourcesContent":["import { createLevelMeter } from \"./level-meter\";\n\n/** RMS at which a window counts as speech. */\nconst DEFAULT_THRESHOLD = 0.045;\n\n/**\n * How long the indicator stays on after the level drops.\n *\n * RMS falls to nothing in the gaps between words, so a bare threshold strobes on\n * every one of them. Ported from `tempest-mirror-screen`'s `voiceActivity.ts`,\n * where it was arrived at by watching a real call.\n */\nconst DEFAULT_RELEASE_MS = 350;\n\n/** How often the level is read. */\nconst DEFAULT_POLL_MS = 100;\n\n/** Options for {@link monitorVoiceActivity}. */\nexport interface VoiceActivityOptions {\n    /** RMS at or above which a window counts as speech. Default `0.045`. */\n    threshold?: number;\n    /** How long the state stays `true` after the level drops. Default `350`. */\n    releaseMs?: number;\n    /** How often the level is sampled, in ms. Default `100`. */\n    pollMs?: number;\n    /**\n     * Reuse an existing `AudioContext` instead of creating one.\n     *\n     * A monitor per remote participant hits the browser's cap on live contexts\n     * (Chrome allows around six) in a five-person call. Open one and share it.\n     */\n    context?: AudioContext;\n}\n\n/** A running voice-activity monitor. */\nexport interface VoiceActivityMonitor {\n    /** Whether the track is currently carrying speech. */\n    readonly speaking: boolean;\n    /** Stop sampling and release the analysis graph. */\n    stop: () => void;\n}\n\n/**\n * Report when a track is carrying speech.\n *\n * Runs entirely on the **receiving** side, over a track the connection already\n * delivers, and that is the whole point: a speaking indicator changes several\n * times per second, so signalling it through a server floods the room with\n * messages carrying information every client can derive for free.\n *\n * Two details separate this from a threshold on a level meter:\n *\n * 1. **The release.** RMS drops to nothing in the gaps between words, so a bare\n *    comparison strobes on every syllable. The state only falls after\n *    `releaseMs` of quiet.\n * 2. **`onChange` fires on the flip, not on the sample.** A callback per poll\n *    would re-render a participant list ten times a second to say the same thing.\n *\n * The meter underneath runs with smoothing off: its eased decay plus this release\n * would hold the indicator open long after the speech stopped.\n *\n * @param stream - The stream whose first audio track is measured.\n * @param onChange - Called only when the speaking state actually flips.\n * @param options - See {@link VoiceActivityOptions}.\n * @returns A handle carrying the current state and the teardown.\n *\n * @example\n * const vad = monitorVoiceActivity(remoteStream, (speaking) => setSpeaking(speaking));\n * // later\n * vad.stop();\n */\nexport function monitorVoiceActivity(\n    stream: MediaStream,\n    onChange: (speaking: boolean) => void,\n    {\n        threshold = DEFAULT_THRESHOLD,\n        releaseMs = DEFAULT_RELEASE_MS,\n        pollMs = DEFAULT_POLL_MS,\n        context,\n    }: VoiceActivityOptions = {},\n): VoiceActivityMonitor {\n    const meter = createLevelMeter(stream, { decay: 0, ...(context ? { context } : {}) });\n    let speaking = false;\n    let lastLoudAt = 0;\n\n    const timer = setInterval(() => {\n        const now = performance.now();\n        if (meter.level() >= threshold) lastLoudAt = now;\n        const next = lastLoudAt > 0 && now - lastLoudAt < releaseMs;\n        if (next === speaking) return;\n        speaking = next;\n        onChange(speaking);\n    }, pollMs);\n\n    return {\n        get speaking(): boolean {\n            return speaking;\n        },\n        stop: (): void => {\n            clearInterval(timer);\n            meter.stop();\n        },\n    };\n}\n"],"mappings":";;AAGA,IAAMA,IAAoB,MASpBC,IAAqB,KAGrBC,IAAkB;AAwDxB,SAAgBC,EACZ,GACA,GACA,EACI,eAAYH,GACZ,eAAYC,GACZ,YAASC,GACT,eACsB,CAAC,GACP;CACpB,IAAME,IAAQC,EAAiBC,GAAQ;EAAE,OAAO;EAAG,GAAIC,IAAU,EAAE,WAAQ,IAAI,CAAC;CAAG,CAAC,GAChFC,IAAW,IACXC,IAAa,GAEXC,IAAQ,kBAAkB;EAC5B,IAAMC,IAAM,YAAY,IAAI;EAC5B,AAAIP,EAAM,MAAM,KAAKQ,MAAW,IAAaD;EAC7C,IAAME,IAAOJ,IAAa,KAAKE,IAAMF,IAAaK;EAClD,AAAID,MAASL,MACb,IAAWK,GACXE,EAASP,CAAQ;CACrB,GAAGQ,CAAM;CAET,OAAO;EACH,IAAI,WAAoB;GACpB,OAAOR;EACX;EACA,YAAkB;GAEd,AADA,cAAcE,CAAK,GACnBN,EAAM,KAAK;EACf;CACJ;AACJ"}

package/dist/audio/voice-chain-stages.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"voice-chain-stages.cjs","names":[],"sources":["../../src/audio/voice-chain-stages.ts"],"sourcesContent":["/**\n * The individual stages a voice chain is built from, and the two side-chains\n * Web Audio cannot express declaratively.\n *\n * Split out of `voice-chain.ts` because every number here is a tuning decision\n * with a reason attached, and the file that assembles them should read as the\n * signal path rather than as a wall of constants.\n */\n\n/** Everything below this is rumble, not speech. */\nconst HIGH_PASS_HZ = 85;\n\n/** Where consonants live — the band that decides whether a word is understood. */\nconst PRESENCE_HZ = 3000;\nconst PRESENCE_GAIN_DB = 3;\nconst PRESENCE_Q = 1;\n\n/** Where microphone hiss lives, above anything speech needs. */\nconst HISS_HZ = 9000;\n\n/** The sibilance band a de-esser rides. */\nconst SIBILANCE_HZ = 7000;\nconst SIBILANCE_Q = 2;\n\n/** Deepest cut the de-esser applies, in dB. */\nconst DEESSER_MAX_CUT_DB = 10;\n\n/** Band energy above which the cut starts, as RMS. */\nconst DEESSER_THRESHOLD = 0.02;\n\n/** How steeply the cut follows the band's energy above the threshold. */\nconst DEESSER_SLOPE_DB_PER_RMS = 200;\n\n/** Seconds the de-esser takes to reach a new cut. */\nconst DEESSER_SMOOTHING = 0.02;\n\n/**\n * A leveller, not a limiter: 3:1 with a soft knee evens out the distance between\n * a whisper and a shout without audibly pumping.\n */\nconst COMPRESSOR = {\n    threshold: -24,\n    knee: 30,\n    ratio: 3,\n    attack: 0.003,\n    release: 0.25,\n} as const;\n\n/**\n * The ceiling the limiter holds, in dB relative to full scale.\n *\n * Just under zero, because digital clipping is not a degradation the other end\n * can recover from — it arrives as squared-off samples that no amount of\n * processing undoes.\n */\nconst LIMITER = {\n    threshold: -1,\n    knee: 0,\n    ratio: 20,\n    attack: 0.001,\n    release: 0.1,\n} as const;\n\n/** How often the gate and the de-esser look at the signal, in milliseconds. */\nexport const DETECTOR_POLL_MS = 20;\n\n/** Time constant for opening the gate. Short, so a first syllable survives. */\nconst GATE_ATTACK = 0.005;\n\n/** Time constant for closing it. Long, so a word does not end abruptly. */\nconst GATE_RELEASE = 0.12;\n\n/**\n * How long the gate stays open after the level drops.\n *\n * RMS falls to nothing between syllables, so a gate without hold chops speech\n * into pieces — it closes inside a word and reopens on the next one. This is the\n * difference between a gate that works and one everybody turns off again.\n */\nexport const GATE_HOLD_MS = 220;\n\n/** The window each detector reads. */\nconst DETECTOR_FFT_SIZE = 1024;\n\n/**\n * Root-mean-square of a time-domain window.\n *\n * RMS rather than peak because both detectors here answer \"how much energy is\n * there\", not \"did one sample spike\": a peak reading opens a gate on a keyboard\n * click and drives a de-esser off a single transient.\n *\n * @param buffer - Time-domain samples, -1..1.\n * @returns The window's RMS, 0..1.\n */\nfunction rms(buffer: Float32Array): number {\n    let sum = 0;\n    for (const sample of buffer) sum += sample * sample;\n    return Math.sqrt(sum / buffer.length);\n}\n\n/** Build the analyser both detectors read through. */\nfunction detectorFor(context: AudioContext): AnalyserNode {\n    const analyser = context.createAnalyser();\n    analyser.fftSize = DETECTOR_FFT_SIZE;\n    return analyser;\n}\n\n/** A high-pass at 85 Hz: fans, traffic, desk knocks, plosives. */\nexport function highPassStage(context: AudioContext): BiquadFilterNode {\n    const filter = context.createBiquadFilter();\n    filter.type = \"highpass\";\n    filter.frequency.value = HIGH_PASS_HZ;\n    return filter;\n}\n\n/** A 3:1 leveller with a soft knee. */\nexport function compressorStage(context: AudioContext): DynamicsCompressorNode {\n    const comp = context.createDynamicsCompressor();\n    comp.threshold.value = COMPRESSOR.threshold;\n    comp.knee.value = COMPRESSOR.knee;\n    comp.ratio.value = COMPRESSOR.ratio;\n    comp.attack.value = COMPRESSOR.attack;\n    comp.release.value = COMPRESSOR.release;\n    return comp;\n}\n\n/** A +3 dB peak at 3 kHz: speech that reads without getting louder. */\nexport function presenceStage(context: AudioContext): BiquadFilterNode {\n    const eq = context.createBiquadFilter();\n    eq.type = \"peaking\";\n    eq.frequency.value = PRESENCE_HZ;\n    eq.Q.value = PRESENCE_Q;\n    eq.gain.value = PRESENCE_GAIN_DB;\n    return eq;\n}\n\n/** A low-pass at 9 kHz: the hiss of a cheap microphone. */\nexport function hissCutStage(context: AudioContext): BiquadFilterNode {\n    const filter = context.createBiquadFilter();\n    filter.type = \"lowpass\";\n    filter.frequency.value = HISS_HZ;\n    return filter;\n}\n\n/** A hard 20:1 ceiling at -1 dBFS, placed after the output gain. */\nexport function limiterStage(context: AudioContext): DynamicsCompressorNode {\n    const limiter = context.createDynamicsCompressor();\n    limiter.threshold.value = LIMITER.threshold;\n    limiter.knee.value = LIMITER.knee;\n    limiter.ratio.value = LIMITER.ratio;\n    limiter.attack.value = LIMITER.attack;\n    limiter.release.value = LIMITER.release;\n    return limiter;\n}\n\n/** The nodes a gate stage owns. */\nexport interface GateStage {\n    /** Reads the signal entering the gate. */\n    detector: AnalyserNode;\n    /** The gain the detector drives, 0 when closed. */\n    gain: GainNode;\n    /** Stop the detector's timer. */\n    stop: () => void;\n}\n\n/**\n * Silence the line between phrases, without cutting inside a word.\n *\n * Measured on a timer rather than in an `AudioWorklet`. A worklet would gate\n * sample-accurately at the cost of a separate module file the consumer has to\n * serve and a second graph to keep in sync; at 20 ms the difference is inaudible\n * for speech, because the hold and the release are an order of magnitude longer\n * than the polling interval and are what actually shape how a gate sounds.\n *\n * The gate starts closed and opens on the first window over the threshold, so a\n * chain built while the room is quiet does not leak the first 20 ms of it.\n *\n * @param context - The graph's context.\n * @param threshold - Read on every tick, so the caller can move a slider while\n *     the chain is live rather than rebuild it.\n * @returns The stage's nodes and its teardown.\n */\nexport function gateStage(context: AudioContext, threshold: () => number): GateStage {\n    const detector = detectorFor(context);\n    const gain = context.createGain();\n    gain.gain.value = 0;\n\n    const buffer = new Float32Array(detector.fftSize);\n    let lastLoudAt = 0;\n\n    const timer = setInterval(() => {\n        detector.getFloatTimeDomainData(buffer);\n        const now = performance.now();\n        if (rms(buffer) >= threshold()) lastLoudAt = now;\n        const open = lastLoudAt > 0 && now - lastLoudAt < GATE_HOLD_MS;\n        gain.gain.setTargetAtTime(\n            open ? 1 : 0,\n            context.currentTime,\n            open ? GATE_ATTACK : GATE_RELEASE,\n        );\n    }, DETECTOR_POLL_MS);\n\n    return { detector, gain, stop: () => clearInterval(timer) };\n}\n\n/** The nodes a de-esser stage owns. */\nexport interface DeEsserStage {\n    /** Band-pass feeding the detector — the side-chain's input. */\n    band: BiquadFilterNode;\n    /** Reads 6-8 kHz only. */\n    detector: AnalyserNode;\n    /** The peaking filter in the signal path, whose gain rides the band. */\n    shaper: BiquadFilterNode;\n    /** Stop the detector's timer. */\n    stop: () => void;\n}\n\n/**\n * Pull the sibilance band down while it is loud, and let go when it is not.\n *\n * Web Audio has no side-chain, so the detector is built by hand: a band-pass\n * feeds an analyser watching only 6-8 kHz, and that analyser's energy drives the\n * gain of a peaking filter sitting in the main path. The distinction is the whole\n * stage — the cut has to answer to the *band*, not to how loud the person is. A\n * static cut at the same frequency would dull every consonant instead of the\n * syllables that actually hiss.\n *\n * @param context - The graph's context.\n * @returns The stage's nodes and its teardown.\n */\nexport function deEsserStage(context: AudioContext): DeEsserStage {\n    const band = context.createBiquadFilter();\n    band.type = \"bandpass\";\n    band.frequency.value = SIBILANCE_HZ;\n    band.Q.value = SIBILANCE_Q;\n\n    const detector = detectorFor(context);\n    band.connect(detector);\n\n    const shaper = context.createBiquadFilter();\n    shaper.type = \"peaking\";\n    shaper.frequency.value = SIBILANCE_HZ;\n    shaper.Q.value = SIBILANCE_Q;\n    shaper.gain.value = 0;\n\n    const buffer = new Float32Array(detector.fftSize);\n    const timer = setInterval(() => {\n        detector.getFloatTimeDomainData(buffer);\n        const over = Math.max(0, rms(buffer) - DEESSER_THRESHOLD);\n        const cut = Math.min(DEESSER_MAX_CUT_DB, over * DEESSER_SLOPE_DB_PER_RMS);\n        shaper.gain.setTargetAtTime(-cut, context.currentTime, DEESSER_SMOOTHING);\n    }, DETECTOR_POLL_MS);\n\n    return { band, detector, shaper, stop: () => clearInterval(timer) };\n}\n\nexport { rms as windowRms };\n"],"mappings":"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"}
+{"version":3,"file":"voice-chain-stages.cjs","names":["SIBILANCE_HZ","COMPRESSOR","LIMITER","GATE_ATTACK","GATE_RELEASE","DETECTOR_FFT_SIZE","rms","sum","sample","buffer","detectorFor","analyser","context","highPassStage","filter","compressorStage","comp","presenceStage","eq","hissCutStage","limiterStage","limiter","gateStage","detector","gain","lastLoudAt","timer","now","threshold","open","deEsserStage","band","shaper","over","cut"],"sources":["../../src/audio/voice-chain-stages.ts"],"sourcesContent":["/**\n * The individual stages a voice chain is built from, and the two side-chains\n * Web Audio cannot express declaratively.\n *\n * Split out of `voice-chain.ts` because every number here is a tuning decision\n * with a reason attached, and the file that assembles them should read as the\n * signal path rather than as a wall of constants.\n */\n\n/** Everything below this is rumble, not speech. */\nconst HIGH_PASS_HZ = 85;\n\n/** Where consonants live — the band that decides whether a word is understood. */\nconst PRESENCE_HZ = 3000;\nconst PRESENCE_GAIN_DB = 3;\nconst PRESENCE_Q = 1;\n\n/** Where microphone hiss lives, above anything speech needs. */\nconst HISS_HZ = 9000;\n\n/** The sibilance band a de-esser rides. */\nconst SIBILANCE_HZ = 7000;\nconst SIBILANCE_Q = 2;\n\n/** Deepest cut the de-esser applies, in dB. */\nconst DEESSER_MAX_CUT_DB = 10;\n\n/** Band energy above which the cut starts, as RMS. */\nconst DEESSER_THRESHOLD = 0.02;\n\n/** How steeply the cut follows the band's energy above the threshold. */\nconst DEESSER_SLOPE_DB_PER_RMS = 200;\n\n/** Seconds the de-esser takes to reach a new cut. */\nconst DEESSER_SMOOTHING = 0.02;\n\n/**\n * A leveller, not a limiter: 3:1 with a soft knee evens out the distance between\n * a whisper and a shout without audibly pumping.\n */\nconst COMPRESSOR = {\n    threshold: -24,\n    knee: 30,\n    ratio: 3,\n    attack: 0.003,\n    release: 0.25,\n} as const;\n\n/**\n * The ceiling the limiter holds, in dB relative to full scale.\n *\n * Just under zero, because digital clipping is not a degradation the other end\n * can recover from — it arrives as squared-off samples that no amount of\n * processing undoes.\n */\nconst LIMITER = {\n    threshold: -1,\n    knee: 0,\n    ratio: 20,\n    attack: 0.001,\n    release: 0.1,\n} as const;\n\n/** How often the gate and the de-esser look at the signal, in milliseconds. */\nexport const DETECTOR_POLL_MS = 20;\n\n/** Time constant for opening the gate. Short, so a first syllable survives. */\nconst GATE_ATTACK = 0.005;\n\n/** Time constant for closing it. Long, so a word does not end abruptly. */\nconst GATE_RELEASE = 0.12;\n\n/**\n * How long the gate stays open after the level drops.\n *\n * RMS falls to nothing between syllables, so a gate without hold chops speech\n * into pieces — it closes inside a word and reopens on the next one. This is the\n * difference between a gate that works and one everybody turns off again.\n */\nexport const GATE_HOLD_MS = 220;\n\n/** The window each detector reads. */\nconst DETECTOR_FFT_SIZE = 1024;\n\n/**\n * Root-mean-square of a time-domain window.\n *\n * RMS rather than peak because both detectors here answer \"how much energy is\n * there\", not \"did one sample spike\": a peak reading opens a gate on a keyboard\n * click and drives a de-esser off a single transient.\n *\n * @param buffer - Time-domain samples, -1..1.\n * @returns The window's RMS, 0..1.\n */\nfunction rms(buffer: Float32Array): number {\n    let sum = 0;\n    for (const sample of buffer) sum += sample * sample;\n    return Math.sqrt(sum / buffer.length);\n}\n\n/** Build the analyser both detectors read through. */\nfunction detectorFor(context: AudioContext): AnalyserNode {\n    const analyser = context.createAnalyser();\n    analyser.fftSize = DETECTOR_FFT_SIZE;\n    return analyser;\n}\n\n/** A high-pass at 85 Hz: fans, traffic, desk knocks, plosives. */\nexport function highPassStage(context: AudioContext): BiquadFilterNode {\n    const filter = context.createBiquadFilter();\n    filter.type = \"highpass\";\n    filter.frequency.value = HIGH_PASS_HZ;\n    return filter;\n}\n\n/** A 3:1 leveller with a soft knee. */\nexport function compressorStage(context: AudioContext): DynamicsCompressorNode {\n    const comp = context.createDynamicsCompressor();\n    comp.threshold.value = COMPRESSOR.threshold;\n    comp.knee.value = COMPRESSOR.knee;\n    comp.ratio.value = COMPRESSOR.ratio;\n    comp.attack.value = COMPRESSOR.attack;\n    comp.release.value = COMPRESSOR.release;\n    return comp;\n}\n\n/** A +3 dB peak at 3 kHz: speech that reads without getting louder. */\nexport function presenceStage(context: AudioContext): BiquadFilterNode {\n    const eq = context.createBiquadFilter();\n    eq.type = \"peaking\";\n    eq.frequency.value = PRESENCE_HZ;\n    eq.Q.value = PRESENCE_Q;\n    eq.gain.value = PRESENCE_GAIN_DB;\n    return eq;\n}\n\n/** A low-pass at 9 kHz: the hiss of a cheap microphone. */\nexport function hissCutStage(context: AudioContext): BiquadFilterNode {\n    const filter = context.createBiquadFilter();\n    filter.type = \"lowpass\";\n    filter.frequency.value = HISS_HZ;\n    return filter;\n}\n\n/** A hard 20:1 ceiling at -1 dBFS, placed after the output gain. */\nexport function limiterStage(context: AudioContext): DynamicsCompressorNode {\n    const limiter = context.createDynamicsCompressor();\n    limiter.threshold.value = LIMITER.threshold;\n    limiter.knee.value = LIMITER.knee;\n    limiter.ratio.value = LIMITER.ratio;\n    limiter.attack.value = LIMITER.attack;\n    limiter.release.value = LIMITER.release;\n    return limiter;\n}\n\n/** The nodes a gate stage owns. */\nexport interface GateStage {\n    /** Reads the signal entering the gate. */\n    detector: AnalyserNode;\n    /** The gain the detector drives, 0 when closed. */\n    gain: GainNode;\n    /** Stop the detector's timer. */\n    stop: () => void;\n}\n\n/**\n * Silence the line between phrases, without cutting inside a word.\n *\n * Measured on a timer rather than in an `AudioWorklet`. A worklet would gate\n * sample-accurately at the cost of a separate module file the consumer has to\n * serve and a second graph to keep in sync; at 20 ms the difference is inaudible\n * for speech, because the hold and the release are an order of magnitude longer\n * than the polling interval and are what actually shape how a gate sounds.\n *\n * The gate starts closed and opens on the first window over the threshold, so a\n * chain built while the room is quiet does not leak the first 20 ms of it.\n *\n * @param context - The graph's context.\n * @param threshold - Read on every tick, so the caller can move a slider while\n *     the chain is live rather than rebuild it.\n * @returns The stage's nodes and its teardown.\n */\nexport function gateStage(context: AudioContext, threshold: () => number): GateStage {\n    const detector = detectorFor(context);\n    const gain = context.createGain();\n    gain.gain.value = 0;\n\n    const buffer = new Float32Array(detector.fftSize);\n    let lastLoudAt = 0;\n\n    const timer = setInterval(() => {\n        detector.getFloatTimeDomainData(buffer);\n        const now = performance.now();\n        if (rms(buffer) >= threshold()) lastLoudAt = now;\n        const open = lastLoudAt > 0 && now - lastLoudAt < GATE_HOLD_MS;\n        gain.gain.setTargetAtTime(\n            open ? 1 : 0,\n            context.currentTime,\n            open ? GATE_ATTACK : GATE_RELEASE,\n        );\n    }, DETECTOR_POLL_MS);\n\n    return { detector, gain, stop: () => clearInterval(timer) };\n}\n\n/** The nodes a de-esser stage owns. */\nexport interface DeEsserStage {\n    /** Band-pass feeding the detector — the side-chain's input. */\n    band: BiquadFilterNode;\n    /** Reads 6-8 kHz only. */\n    detector: AnalyserNode;\n    /** The peaking filter in the signal path, whose gain rides the band. */\n    shaper: BiquadFilterNode;\n    /** Stop the detector's timer. */\n    stop: () => void;\n}\n\n/**\n * Pull the sibilance band down while it is loud, and let go when it is not.\n *\n * Web Audio has no side-chain, so the detector is built by hand: a band-pass\n * feeds an analyser watching only 6-8 kHz, and that analyser's energy drives the\n * gain of a peaking filter sitting in the main path. The distinction is the whole\n * stage — the cut has to answer to the *band*, not to how loud the person is. A\n * static cut at the same frequency would dull every consonant instead of the\n * syllables that actually hiss.\n *\n * @param context - The graph's context.\n * @returns The stage's nodes and its teardown.\n */\nexport function deEsserStage(context: AudioContext): DeEsserStage {\n    const band = context.createBiquadFilter();\n    band.type = \"bandpass\";\n    band.frequency.value = SIBILANCE_HZ;\n    band.Q.value = SIBILANCE_Q;\n\n    const detector = detectorFor(context);\n    band.connect(detector);\n\n    const shaper = context.createBiquadFilter();\n    shaper.type = \"peaking\";\n    shaper.frequency.value = SIBILANCE_HZ;\n    shaper.Q.value = SIBILANCE_Q;\n    shaper.gain.value = 0;\n\n    const buffer = new Float32Array(detector.fftSize);\n    const timer = setInterval(() => {\n        detector.getFloatTimeDomainData(buffer);\n        const over = Math.max(0, rms(buffer) - DEESSER_THRESHOLD);\n        const cut = Math.min(DEESSER_MAX_CUT_DB, over * DEESSER_SLOPE_DB_PER_RMS);\n        shaper.gain.setTargetAtTime(-cut, context.currentTime, DEESSER_SMOOTHING);\n    }, DETECTOR_POLL_MS);\n\n    return { band, detector, shaper, stop: () => clearInterval(timer) };\n}\n\nexport { rms as windowRms };\n"],"mappings":"AAUA,IAWMA,EAAe,IAmBfC,EAAa,CACf,UAAW,IACX,KAAM,GACN,MAAO,EACP,OAAQ,KACR,QAAS,GACb,EASMC,EAAU,CACZ,UAAW,GACX,KAAM,EACN,MAAO,GACP,OAAQ,KACR,QAAS,EACb,EAMMC,EAAc,KAGdC,EAAe,IAYfC,EAAoB,KAY1B,SAASC,EAAI,EAA8B,CACvC,IAAIC,EAAM,EACV,IAAK,IAAMC,KAAUC,EAAQ,GAAOD,EAASA,EAC7C,OAAO,KAAK,KAAKD,EAAME,EAAO,MAAM,CACxC,CAGA,SAASC,EAAY,EAAqC,CACtD,IAAMC,EAAWC,EAAQ,eAAe,EAExC,MADA,GAAS,QAAUP,EACZM,CACX,CAGA,SAAgBE,EAAc,EAAyC,CACnE,IAAMC,EAASF,EAAQ,mBAAmB,EAG1C,MAFA,GAAO,KAAO,WACd,EAAO,UAAU,MAAQ,GAClBE,CACX,CAGA,SAAgBC,EAAgB,EAA+C,CAC3E,IAAMC,EAAOJ,EAAQ,yBAAyB,EAM9C,MALA,GAAK,UAAU,MAAQX,EAAW,UAClC,EAAK,KAAK,MAAQA,EAAW,KAC7B,EAAK,MAAM,MAAQA,EAAW,MAC9B,EAAK,OAAO,MAAQA,EAAW,OAC/B,EAAK,QAAQ,MAAQA,EAAW,QACzBe,CACX,CAGA,SAAgBC,EAAc,EAAyC,CACnE,IAAMC,EAAKN,EAAQ,mBAAmB,EAKtC,MAJA,GAAG,KAAO,UACV,EAAG,UAAU,MAAQ,IACrB,EAAG,EAAE,MAAQ,EACb,EAAG,KAAK,MAAQ,EACTM,CACX,CAGA,SAAgBC,EAAa,EAAyC,CAClE,IAAML,EAASF,EAAQ,mBAAmB,EAG1C,MAFA,GAAO,KAAO,UACd,EAAO,UAAU,MAAQ,IAClBE,CACX,CAGA,SAAgBM,EAAa,EAA+C,CACxE,IAAMC,EAAUT,EAAQ,yBAAyB,EAMjD,MALA,GAAQ,UAAU,MAAQV,EAAQ,UAClC,EAAQ,KAAK,MAAQA,EAAQ,KAC7B,EAAQ,MAAM,MAAQA,EAAQ,MAC9B,EAAQ,OAAO,MAAQA,EAAQ,OAC/B,EAAQ,QAAQ,MAAQA,EAAQ,QACzBmB,CACX,CA6BA,SAAgBC,EAAU,EAAuB,EAAoC,CACjF,IAAMC,EAAWb,EAAYE,CAAO,EAC9BY,EAAOZ,EAAQ,WAAW,EAChC,EAAK,KAAK,MAAQ,EAElB,IAAMH,EAAS,IAAI,aAAac,EAAS,OAAO,EAC5CE,EAAa,EAEXC,EAAQ,gBAAkB,CAC5BH,EAAS,uBAAuBd,CAAM,EACtC,IAAMkB,EAAM,YAAY,IAAI,EACxBrB,EAAIG,CAAM,GAAKmB,EAAU,IAAG,EAAaD,GAC7C,IAAME,EAAOJ,EAAa,GAAKE,EAAMF,EAAA,IACrCD,EAAK,KAAK,gBACN,KACAZ,EAAQ,YACRiB,EAAO1B,EAAcC,CACzB,CACJ,EAAA,EAAmB,EAEnB,MAAO,CAAE,WAAU,OAAM,SAAY,cAAcsB,CAAK,CAAE,CAC9D,CA2BA,SAAgBI,EAAa,EAAqC,CAC9D,IAAMC,EAAOnB,EAAQ,mBAAmB,EACxC,EAAK,KAAO,WACZ,EAAK,UAAU,MAAQZ,EACvB,EAAK,EAAE,MAAQ,EAEf,IAAMuB,EAAWb,EAAYE,CAAO,EACpCmB,EAAK,QAAQR,CAAQ,EAErB,IAAMS,EAASpB,EAAQ,mBAAmB,EAC1C,EAAO,KAAO,UACd,EAAO,UAAU,MAAQZ,EACzB,EAAO,EAAE,MAAQ,EACjB,EAAO,KAAK,MAAQ,EAEpB,IAAMS,EAAS,IAAI,aAAac,EAAS,OAAO,EAC1CG,EAAQ,gBAAkB,CAC5BH,EAAS,uBAAuBd,CAAM,EACtC,IAAMwB,EAAO,KAAK,IAAI,EAAG3B,EAAIG,CAAM,EAAI,GAAiB,EAClDyB,EAAM,KAAK,IAAI,GAAoBD,EAAO,GAAwB,EACxED,EAAO,KAAK,gBAAgB,CAACE,EAAKtB,EAAQ,YAAa,GAAiB,CAC5E,EAAA,EAAmB,EAEnB,MAAO,CAAE,OAAM,WAAU,SAAQ,SAAY,cAAcc,CAAK,CAAE,CACtE,C"}

package/dist/audio/voice-chain-stages.js.map

@@ -1 +1 @@
-{"version":3,"file":"voice-chain-stages.js","names":[],"sources":["../../src/audio/voice-chain-stages.ts"],"sourcesContent":["/**\n * The individual stages a voice chain is built from, and the two side-chains\n * Web Audio cannot express declaratively.\n *\n * Split out of `voice-chain.ts` because every number here is a tuning decision\n * with a reason attached, and the file that assembles them should read as the\n * signal path rather than as a wall of constants.\n */\n\n/** Everything below this is rumble, not speech. */\nconst HIGH_PASS_HZ = 85;\n\n/** Where consonants live — the band that decides whether a word is understood. */\nconst PRESENCE_HZ = 3000;\nconst PRESENCE_GAIN_DB = 3;\nconst PRESENCE_Q = 1;\n\n/** Where microphone hiss lives, above anything speech needs. */\nconst HISS_HZ = 9000;\n\n/** The sibilance band a de-esser rides. */\nconst SIBILANCE_HZ = 7000;\nconst SIBILANCE_Q = 2;\n\n/** Deepest cut the de-esser applies, in dB. */\nconst DEESSER_MAX_CUT_DB = 10;\n\n/** Band energy above which the cut starts, as RMS. */\nconst DEESSER_THRESHOLD = 0.02;\n\n/** How steeply the cut follows the band's energy above the threshold. */\nconst DEESSER_SLOPE_DB_PER_RMS = 200;\n\n/** Seconds the de-esser takes to reach a new cut. */\nconst DEESSER_SMOOTHING = 0.02;\n\n/**\n * A leveller, not a limiter: 3:1 with a soft knee evens out the distance between\n * a whisper and a shout without audibly pumping.\n */\nconst COMPRESSOR = {\n    threshold: -24,\n    knee: 30,\n    ratio: 3,\n    attack: 0.003,\n    release: 0.25,\n} as const;\n\n/**\n * The ceiling the limiter holds, in dB relative to full scale.\n *\n * Just under zero, because digital clipping is not a degradation the other end\n * can recover from — it arrives as squared-off samples that no amount of\n * processing undoes.\n */\nconst LIMITER = {\n    threshold: -1,\n    knee: 0,\n    ratio: 20,\n    attack: 0.001,\n    release: 0.1,\n} as const;\n\n/** How often the gate and the de-esser look at the signal, in milliseconds. */\nexport const DETECTOR_POLL_MS = 20;\n\n/** Time constant for opening the gate. Short, so a first syllable survives. */\nconst GATE_ATTACK = 0.005;\n\n/** Time constant for closing it. Long, so a word does not end abruptly. */\nconst GATE_RELEASE = 0.12;\n\n/**\n * How long the gate stays open after the level drops.\n *\n * RMS falls to nothing between syllables, so a gate without hold chops speech\n * into pieces — it closes inside a word and reopens on the next one. This is the\n * difference between a gate that works and one everybody turns off again.\n */\nexport const GATE_HOLD_MS = 220;\n\n/** The window each detector reads. */\nconst DETECTOR_FFT_SIZE = 1024;\n\n/**\n * Root-mean-square of a time-domain window.\n *\n * RMS rather than peak because both detectors here answer \"how much energy is\n * there\", not \"did one sample spike\": a peak reading opens a gate on a keyboard\n * click and drives a de-esser off a single transient.\n *\n * @param buffer - Time-domain samples, -1..1.\n * @returns The window's RMS, 0..1.\n */\nfunction rms(buffer: Float32Array): number {\n    let sum = 0;\n    for (const sample of buffer) sum += sample * sample;\n    return Math.sqrt(sum / buffer.length);\n}\n\n/** Build the analyser both detectors read through. */\nfunction detectorFor(context: AudioContext): AnalyserNode {\n    const analyser = context.createAnalyser();\n    analyser.fftSize = DETECTOR_FFT_SIZE;\n    return analyser;\n}\n\n/** A high-pass at 85 Hz: fans, traffic, desk knocks, plosives. */\nexport function highPassStage(context: AudioContext): BiquadFilterNode {\n    const filter = context.createBiquadFilter();\n    filter.type = \"highpass\";\n    filter.frequency.value = HIGH_PASS_HZ;\n    return filter;\n}\n\n/** A 3:1 leveller with a soft knee. */\nexport function compressorStage(context: AudioContext): DynamicsCompressorNode {\n    const comp = context.createDynamicsCompressor();\n    comp.threshold.value = COMPRESSOR.threshold;\n    comp.knee.value = COMPRESSOR.knee;\n    comp.ratio.value = COMPRESSOR.ratio;\n    comp.attack.value = COMPRESSOR.attack;\n    comp.release.value = COMPRESSOR.release;\n    return comp;\n}\n\n/** A +3 dB peak at 3 kHz: speech that reads without getting louder. */\nexport function presenceStage(context: AudioContext): BiquadFilterNode {\n    const eq = context.createBiquadFilter();\n    eq.type = \"peaking\";\n    eq.frequency.value = PRESENCE_HZ;\n    eq.Q.value = PRESENCE_Q;\n    eq.gain.value = PRESENCE_GAIN_DB;\n    return eq;\n}\n\n/** A low-pass at 9 kHz: the hiss of a cheap microphone. */\nexport function hissCutStage(context: AudioContext): BiquadFilterNode {\n    const filter = context.createBiquadFilter();\n    filter.type = \"lowpass\";\n    filter.frequency.value = HISS_HZ;\n    return filter;\n}\n\n/** A hard 20:1 ceiling at -1 dBFS, placed after the output gain. */\nexport function limiterStage(context: AudioContext): DynamicsCompressorNode {\n    const limiter = context.createDynamicsCompressor();\n    limiter.threshold.value = LIMITER.threshold;\n    limiter.knee.value = LIMITER.knee;\n    limiter.ratio.value = LIMITER.ratio;\n    limiter.attack.value = LIMITER.attack;\n    limiter.release.value = LIMITER.release;\n    return limiter;\n}\n\n/** The nodes a gate stage owns. */\nexport interface GateStage {\n    /** Reads the signal entering the gate. */\n    detector: AnalyserNode;\n    /** The gain the detector drives, 0 when closed. */\n    gain: GainNode;\n    /** Stop the detector's timer. */\n    stop: () => void;\n}\n\n/**\n * Silence the line between phrases, without cutting inside a word.\n *\n * Measured on a timer rather than in an `AudioWorklet`. A worklet would gate\n * sample-accurately at the cost of a separate module file the consumer has to\n * serve and a second graph to keep in sync; at 20 ms the difference is inaudible\n * for speech, because the hold and the release are an order of magnitude longer\n * than the polling interval and are what actually shape how a gate sounds.\n *\n * The gate starts closed and opens on the first window over the threshold, so a\n * chain built while the room is quiet does not leak the first 20 ms of it.\n *\n * @param context - The graph's context.\n * @param threshold - Read on every tick, so the caller can move a slider while\n *     the chain is live rather than rebuild it.\n * @returns The stage's nodes and its teardown.\n */\nexport function gateStage(context: AudioContext, threshold: () => number): GateStage {\n    const detector = detectorFor(context);\n    const gain = context.createGain();\n    gain.gain.value = 0;\n\n    const buffer = new Float32Array(detector.fftSize);\n    let lastLoudAt = 0;\n\n    const timer = setInterval(() => {\n        detector.getFloatTimeDomainData(buffer);\n        const now = performance.now();\n        if (rms(buffer) >= threshold()) lastLoudAt = now;\n        const open = lastLoudAt > 0 && now - lastLoudAt < GATE_HOLD_MS;\n        gain.gain.setTargetAtTime(\n            open ? 1 : 0,\n            context.currentTime,\n            open ? GATE_ATTACK : GATE_RELEASE,\n        );\n    }, DETECTOR_POLL_MS);\n\n    return { detector, gain, stop: () => clearInterval(timer) };\n}\n\n/** The nodes a de-esser stage owns. */\nexport interface DeEsserStage {\n    /** Band-pass feeding the detector — the side-chain's input. */\n    band: BiquadFilterNode;\n    /** Reads 6-8 kHz only. */\n    detector: AnalyserNode;\n    /** The peaking filter in the signal path, whose gain rides the band. */\n    shaper: BiquadFilterNode;\n    /** Stop the detector's timer. */\n    stop: () => void;\n}\n\n/**\n * Pull the sibilance band down while it is loud, and let go when it is not.\n *\n * Web Audio has no side-chain, so the detector is built by hand: a band-pass\n * feeds an analyser watching only 6-8 kHz, and that analyser's energy drives the\n * gain of a peaking filter sitting in the main path. The distinction is the whole\n * stage — the cut has to answer to the *band*, not to how loud the person is. A\n * static cut at the same frequency would dull every consonant instead of the\n * syllables that actually hiss.\n *\n * @param context - The graph's context.\n * @returns The stage's nodes and its teardown.\n */\nexport function deEsserStage(context: AudioContext): DeEsserStage {\n    const band = context.createBiquadFilter();\n    band.type = \"bandpass\";\n    band.frequency.value = SIBILANCE_HZ;\n    band.Q.value = SIBILANCE_Q;\n\n    const detector = detectorFor(context);\n    band.connect(detector);\n\n    const shaper = context.createBiquadFilter();\n    shaper.type = \"peaking\";\n    shaper.frequency.value = SIBILANCE_HZ;\n    shaper.Q.value = SIBILANCE_Q;\n    shaper.gain.value = 0;\n\n    const buffer = new Float32Array(detector.fftSize);\n    const timer = setInterval(() => {\n        detector.getFloatTimeDomainData(buffer);\n        const over = Math.max(0, rms(buffer) - DEESSER_THRESHOLD);\n        const cut = Math.min(DEESSER_MAX_CUT_DB, over * DEESSER_SLOPE_DB_PER_RMS);\n        shaper.gain.setTargetAtTime(-cut, context.currentTime, DEESSER_SMOOTHING);\n    }, DETECTOR_POLL_MS);\n\n    return { band, detector, shaper, stop: () => clearInterval(timer) };\n}\n\nexport { rms as windowRms };\n"],"mappings":"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"}
+{"version":3,"file":"voice-chain-stages.js","names":["SIBILANCE_HZ","COMPRESSOR","LIMITER","GATE_ATTACK","GATE_RELEASE","DETECTOR_FFT_SIZE","rms","sum","sample","buffer","detectorFor","analyser","context","highPassStage","filter","compressorStage","comp","presenceStage","eq","hissCutStage","limiterStage","limiter","gateStage","detector","gain","lastLoudAt","timer","now","threshold","open","deEsserStage","band","shaper","over","cut"],"sources":["../../src/audio/voice-chain-stages.ts"],"sourcesContent":["/**\n * The individual stages a voice chain is built from, and the two side-chains\n * Web Audio cannot express declaratively.\n *\n * Split out of `voice-chain.ts` because every number here is a tuning decision\n * with a reason attached, and the file that assembles them should read as the\n * signal path rather than as a wall of constants.\n */\n\n/** Everything below this is rumble, not speech. */\nconst HIGH_PASS_HZ = 85;\n\n/** Where consonants live — the band that decides whether a word is understood. */\nconst PRESENCE_HZ = 3000;\nconst PRESENCE_GAIN_DB = 3;\nconst PRESENCE_Q = 1;\n\n/** Where microphone hiss lives, above anything speech needs. */\nconst HISS_HZ = 9000;\n\n/** The sibilance band a de-esser rides. */\nconst SIBILANCE_HZ = 7000;\nconst SIBILANCE_Q = 2;\n\n/** Deepest cut the de-esser applies, in dB. */\nconst DEESSER_MAX_CUT_DB = 10;\n\n/** Band energy above which the cut starts, as RMS. */\nconst DEESSER_THRESHOLD = 0.02;\n\n/** How steeply the cut follows the band's energy above the threshold. */\nconst DEESSER_SLOPE_DB_PER_RMS = 200;\n\n/** Seconds the de-esser takes to reach a new cut. */\nconst DEESSER_SMOOTHING = 0.02;\n\n/**\n * A leveller, not a limiter: 3:1 with a soft knee evens out the distance between\n * a whisper and a shout without audibly pumping.\n */\nconst COMPRESSOR = {\n    threshold: -24,\n    knee: 30,\n    ratio: 3,\n    attack: 0.003,\n    release: 0.25,\n} as const;\n\n/**\n * The ceiling the limiter holds, in dB relative to full scale.\n *\n * Just under zero, because digital clipping is not a degradation the other end\n * can recover from — it arrives as squared-off samples that no amount of\n * processing undoes.\n */\nconst LIMITER = {\n    threshold: -1,\n    knee: 0,\n    ratio: 20,\n    attack: 0.001,\n    release: 0.1,\n} as const;\n\n/** How often the gate and the de-esser look at the signal, in milliseconds. */\nexport const DETECTOR_POLL_MS = 20;\n\n/** Time constant for opening the gate. Short, so a first syllable survives. */\nconst GATE_ATTACK = 0.005;\n\n/** Time constant for closing it. Long, so a word does not end abruptly. */\nconst GATE_RELEASE = 0.12;\n\n/**\n * How long the gate stays open after the level drops.\n *\n * RMS falls to nothing between syllables, so a gate without hold chops speech\n * into pieces — it closes inside a word and reopens on the next one. This is the\n * difference between a gate that works and one everybody turns off again.\n */\nexport const GATE_HOLD_MS = 220;\n\n/** The window each detector reads. */\nconst DETECTOR_FFT_SIZE = 1024;\n\n/**\n * Root-mean-square of a time-domain window.\n *\n * RMS rather than peak because both detectors here answer \"how much energy is\n * there\", not \"did one sample spike\": a peak reading opens a gate on a keyboard\n * click and drives a de-esser off a single transient.\n *\n * @param buffer - Time-domain samples, -1..1.\n * @returns The window's RMS, 0..1.\n */\nfunction rms(buffer: Float32Array): number {\n    let sum = 0;\n    for (const sample of buffer) sum += sample * sample;\n    return Math.sqrt(sum / buffer.length);\n}\n\n/** Build the analyser both detectors read through. */\nfunction detectorFor(context: AudioContext): AnalyserNode {\n    const analyser = context.createAnalyser();\n    analyser.fftSize = DETECTOR_FFT_SIZE;\n    return analyser;\n}\n\n/** A high-pass at 85 Hz: fans, traffic, desk knocks, plosives. */\nexport function highPassStage(context: AudioContext): BiquadFilterNode {\n    const filter = context.createBiquadFilter();\n    filter.type = \"highpass\";\n    filter.frequency.value = HIGH_PASS_HZ;\n    return filter;\n}\n\n/** A 3:1 leveller with a soft knee. */\nexport function compressorStage(context: AudioContext): DynamicsCompressorNode {\n    const comp = context.createDynamicsCompressor();\n    comp.threshold.value = COMPRESSOR.threshold;\n    comp.knee.value = COMPRESSOR.knee;\n    comp.ratio.value = COMPRESSOR.ratio;\n    comp.attack.value = COMPRESSOR.attack;\n    comp.release.value = COMPRESSOR.release;\n    return comp;\n}\n\n/** A +3 dB peak at 3 kHz: speech that reads without getting louder. */\nexport function presenceStage(context: AudioContext): BiquadFilterNode {\n    const eq = context.createBiquadFilter();\n    eq.type = \"peaking\";\n    eq.frequency.value = PRESENCE_HZ;\n    eq.Q.value = PRESENCE_Q;\n    eq.gain.value = PRESENCE_GAIN_DB;\n    return eq;\n}\n\n/** A low-pass at 9 kHz: the hiss of a cheap microphone. */\nexport function hissCutStage(context: AudioContext): BiquadFilterNode {\n    const filter = context.createBiquadFilter();\n    filter.type = \"lowpass\";\n    filter.frequency.value = HISS_HZ;\n    return filter;\n}\n\n/** A hard 20:1 ceiling at -1 dBFS, placed after the output gain. */\nexport function limiterStage(context: AudioContext): DynamicsCompressorNode {\n    const limiter = context.createDynamicsCompressor();\n    limiter.threshold.value = LIMITER.threshold;\n    limiter.knee.value = LIMITER.knee;\n    limiter.ratio.value = LIMITER.ratio;\n    limiter.attack.value = LIMITER.attack;\n    limiter.release.value = LIMITER.release;\n    return limiter;\n}\n\n/** The nodes a gate stage owns. */\nexport interface GateStage {\n    /** Reads the signal entering the gate. */\n    detector: AnalyserNode;\n    /** The gain the detector drives, 0 when closed. */\n    gain: GainNode;\n    /** Stop the detector's timer. */\n    stop: () => void;\n}\n\n/**\n * Silence the line between phrases, without cutting inside a word.\n *\n * Measured on a timer rather than in an `AudioWorklet`. A worklet would gate\n * sample-accurately at the cost of a separate module file the consumer has to\n * serve and a second graph to keep in sync; at 20 ms the difference is inaudible\n * for speech, because the hold and the release are an order of magnitude longer\n * than the polling interval and are what actually shape how a gate sounds.\n *\n * The gate starts closed and opens on the first window over the threshold, so a\n * chain built while the room is quiet does not leak the first 20 ms of it.\n *\n * @param context - The graph's context.\n * @param threshold - Read on every tick, so the caller can move a slider while\n *     the chain is live rather than rebuild it.\n * @returns The stage's nodes and its teardown.\n */\nexport function gateStage(context: AudioContext, threshold: () => number): GateStage {\n    const detector = detectorFor(context);\n    const gain = context.createGain();\n    gain.gain.value = 0;\n\n    const buffer = new Float32Array(detector.fftSize);\n    let lastLoudAt = 0;\n\n    const timer = setInterval(() => {\n        detector.getFloatTimeDomainData(buffer);\n        const now = performance.now();\n        if (rms(buffer) >= threshold()) lastLoudAt = now;\n        const open = lastLoudAt > 0 && now - lastLoudAt < GATE_HOLD_MS;\n        gain.gain.setTargetAtTime(\n            open ? 1 : 0,\n            context.currentTime,\n            open ? GATE_ATTACK : GATE_RELEASE,\n        );\n    }, DETECTOR_POLL_MS);\n\n    return { detector, gain, stop: () => clearInterval(timer) };\n}\n\n/** The nodes a de-esser stage owns. */\nexport interface DeEsserStage {\n    /** Band-pass feeding the detector — the side-chain's input. */\n    band: BiquadFilterNode;\n    /** Reads 6-8 kHz only. */\n    detector: AnalyserNode;\n    /** The peaking filter in the signal path, whose gain rides the band. */\n    shaper: BiquadFilterNode;\n    /** Stop the detector's timer. */\n    stop: () => void;\n}\n\n/**\n * Pull the sibilance band down while it is loud, and let go when it is not.\n *\n * Web Audio has no side-chain, so the detector is built by hand: a band-pass\n * feeds an analyser watching only 6-8 kHz, and that analyser's energy drives the\n * gain of a peaking filter sitting in the main path. The distinction is the whole\n * stage — the cut has to answer to the *band*, not to how loud the person is. A\n * static cut at the same frequency would dull every consonant instead of the\n * syllables that actually hiss.\n *\n * @param context - The graph's context.\n * @returns The stage's nodes and its teardown.\n */\nexport function deEsserStage(context: AudioContext): DeEsserStage {\n    const band = context.createBiquadFilter();\n    band.type = \"bandpass\";\n    band.frequency.value = SIBILANCE_HZ;\n    band.Q.value = SIBILANCE_Q;\n\n    const detector = detectorFor(context);\n    band.connect(detector);\n\n    const shaper = context.createBiquadFilter();\n    shaper.type = \"peaking\";\n    shaper.frequency.value = SIBILANCE_HZ;\n    shaper.Q.value = SIBILANCE_Q;\n    shaper.gain.value = 0;\n\n    const buffer = new Float32Array(detector.fftSize);\n    const timer = setInterval(() => {\n        detector.getFloatTimeDomainData(buffer);\n        const over = Math.max(0, rms(buffer) - DEESSER_THRESHOLD);\n        const cut = Math.min(DEESSER_MAX_CUT_DB, over * DEESSER_SLOPE_DB_PER_RMS);\n        shaper.gain.setTargetAtTime(-cut, context.currentTime, DEESSER_SMOOTHING);\n    }, DETECTOR_POLL_MS);\n\n    return { band, detector, shaper, stop: () => clearInterval(timer) };\n}\n\nexport { rms as windowRms };\n"],"mappings":"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"}