tempest-react-sdk 0.78.0 → 0.80.0

package/dist/audio/noise-floor.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"noise-floor.cjs","names":[],"sources":["../../src/audio/noise-floor.ts"],"sourcesContent":["import { windowRms } from \"./voice-chain-stages\";\n\n/** How long the measurement listens by default, in milliseconds. */\nconst DEFAULT_DURATION_MS = 3000;\n\n/** How often it samples the room, in milliseconds. */\nconst SAMPLE_MS = 50;\n\n/**\n * Headroom over the measured floor, so ordinary speech clears the gate.\n *\n * A gate set exactly at the noise level chatters, opening and closing on the\n * room's own variation. Ported from `tempest-mirror-screen`'s `voiceChain.ts`,\n * where it was arrived at by listening.\n */\nconst GATE_MARGIN = 2.4;\n\n/** The narrowest and widest thresholds worth suggesting. */\nconst GATE_MIN = 0.004;\nconst GATE_MAX = 0.12;\n\n/** Options for {@link measureNoiseFloor}. */\nexport interface NoiseFloorOptions {\n    /** Called with `0..1` so a dialog can show the wait. */\n    onProgress?: (fraction: number) => void;\n    /** How long to listen. Default `3000`. */\n    durationMs?: number;\n    /** Reuse an existing `AudioContext` rather than opening one. */\n    context?: AudioContext;\n}\n\n/** The `AudioContext` constructor this engine exposes, prefixed or not. */\nfunction audioContextConstructor(): typeof AudioContext | undefined {\n    if (typeof AudioContext !== \"undefined\") return AudioContext;\n    return (globalThis as { webkitAudioContext?: typeof AudioContext }).webkitAudioContext;\n}\n\n/**\n * Listen to a room at rest and report how loud its silence is.\n *\n * The number a person cannot guess. Setting a gate by ear means switching it on\n * and hearing what disappeared, which only works if you already know what should\n * have disappeared — so the usual outcome is leaving it at a default that is\n * wrong for that room. Measuring replaces the guess.\n *\n * The result is the **peak** RMS window observed, not the average: a threshold\n * under the loudest thing the quiet room did will be opened by that thing.\n *\n * @param stream - A live capture of the room while nobody speaks.\n * @param options - See {@link NoiseFloorOptions}.\n * @returns The peak RMS observed, `0..1`. `0` when this engine has no Web Audio\n *   or the stream carries no audio track — which {@link suggestGateThreshold}\n *   turns into its own floor rather than into a gate that never opens.\n *\n * @example\n * const floor = await measureNoiseFloor(stream, { onProgress: setProgress });\n * setThreshold(suggestGateThreshold(floor));\n */\nexport async function measureNoiseFloor(\n    stream: MediaStream,\n    {\n        onProgress,\n        durationMs = DEFAULT_DURATION_MS,\n        context: injectedContext,\n    }: NoiseFloorOptions = {},\n): Promise<number> {\n    const Ctor = audioContextConstructor();\n    const context = injectedContext ?? (Ctor ? new Ctor() : null);\n    const track = stream.getAudioTracks()[0];\n    if (!context || !track) return 0;\n\n    const source = context.createMediaStreamSource(stream);\n    const analyser = context.createAnalyser();\n    analyser.fftSize = 2048;\n    source.connect(analyser);\n\n    const buffer = new Float32Array(analyser.fftSize);\n    const started = performance.now();\n    let peak = 0;\n\n    await new Promise<void>((resolve) => {\n        const timer = setInterval(() => {\n            analyser.getFloatTimeDomainData(buffer);\n            peak = Math.max(peak, windowRms(buffer));\n\n            const elapsed = performance.now() - started;\n            onProgress?.(Math.min(1, elapsed / durationMs));\n            if (elapsed < durationMs) return;\n            clearInterval(timer);\n            resolve();\n        }, SAMPLE_MS);\n    });\n\n    source.disconnect();\n    analyser.disconnect();\n    return peak;\n}\n\n/**\n * Turn a measured noise floor into a threshold worth using.\n *\n * Sits above the floor by a margin rather than on it, and is clamped at both\n * ends: a room measured as perfectly silent (or not measured at all) would\n * otherwise get a threshold of zero, which is a gate that never closes, and a\n * room measured while somebody talked would get one nothing opens.\n *\n * @param noiseFloor - Peak RMS measured while nobody spoke.\n * @returns A threshold for {@link VoiceChainSettings.gateThreshold}, `0.004..0.12`.\n */\nexport function suggestGateThreshold(noiseFloor: number): number {\n    if (!Number.isFinite(noiseFloor)) return GATE_MIN;\n    return Math.min(GATE_MAX, Math.max(GATE_MIN, noiseFloor * GATE_MARGIN));\n}\n"],"mappings":"4CAGA,IAAM,EAAsB,IAGtB,EAAY,GASZ,EAAc,IAGd,EAAW,KACX,EAAW,IAajB,SAAS,GAA2D,CAEhE,OADI,OAAO,aAAiB,IAAoB,aACxC,WAA4D,kBACxE,CAuBA,eAAsB,EAClB,EACA,CACI,aACA,aAAa,EACb,QAAS,GACU,CAAC,EACT,CACf,IAAM,EAAO,EAAwB,EAC/B,EAAU,IAAoB,EAAO,IAAI,EAAS,MAClD,EAAQ,EAAO,eAAe,CAAC,CAAC,GACtC,GAAI,CAAC,GAAW,CAAC,EAAO,MAAO,GAE/B,IAAM,EAAS,EAAQ,wBAAwB,CAAM,EAC/C,EAAW,EAAQ,eAAe,EACxC,EAAS,QAAU,KACnB,EAAO,QAAQ,CAAQ,EAEvB,IAAM,EAAS,IAAI,aAAa,EAAS,OAAO,EAC1C,EAAU,YAAY,IAAI,EAC5B,EAAO,EAiBX,OAfA,MAAM,IAAI,QAAe,GAAY,CACjC,IAAM,EAAQ,gBAAkB,CAC5B,EAAS,uBAAuB,CAAM,EACtC,EAAO,KAAK,IAAI,EAAM,EAAA,UAAU,CAAM,CAAC,EAEvC,IAAM,EAAU,YAAY,IAAI,EAAI,EACpC,IAAa,KAAK,IAAI,EAAG,EAAU,CAAU,CAAC,EAC1C,IAAU,KACd,cAAc,CAAK,EACnB,EAAQ,EACZ,EAAG,CAAS,CAChB,CAAC,EAED,EAAO,WAAW,EAClB,EAAS,WAAW,EACb,CACX,CAaA,SAAgB,EAAqB,EAA4B,CAE7D,OADK,OAAO,SAAS,CAAU,EACxB,KAAK,IAAI,EAAU,KAAK,IAAI,EAAU,EAAa,CAAW,CAAC,EAD7B,CAE7C"}
+{"version":3,"file":"noise-floor.cjs","names":["windowRms","require_voice_chain_stages","DEFAULT_DURATION_MS","SAMPLE_MS","GATE_MARGIN","GATE_MIN","GATE_MAX","audioContextConstructor","measureNoiseFloor","injectedContext","Ctor","context","track","stream","source","analyser","buffer","started","peak","timer","elapsed","onProgress","durationMs","resolve","suggestGateThreshold","noiseFloor"],"sources":["../../src/audio/noise-floor.ts"],"sourcesContent":["import { windowRms } from \"./voice-chain-stages\";\n\n/** How long the measurement listens by default, in milliseconds. */\nconst DEFAULT_DURATION_MS = 3000;\n\n/** How often it samples the room, in milliseconds. */\nconst SAMPLE_MS = 50;\n\n/**\n * Headroom over the measured floor, so ordinary speech clears the gate.\n *\n * A gate set exactly at the noise level chatters, opening and closing on the\n * room's own variation. Ported from `tempest-mirror-screen`'s `voiceChain.ts`,\n * where it was arrived at by listening.\n */\nconst GATE_MARGIN = 2.4;\n\n/** The narrowest and widest thresholds worth suggesting. */\nconst GATE_MIN = 0.004;\nconst GATE_MAX = 0.12;\n\n/** Options for {@link measureNoiseFloor}. */\nexport interface NoiseFloorOptions {\n    /** Called with `0..1` so a dialog can show the wait. */\n    onProgress?: (fraction: number) => void;\n    /** How long to listen. Default `3000`. */\n    durationMs?: number;\n    /** Reuse an existing `AudioContext` rather than opening one. */\n    context?: AudioContext;\n}\n\n/** The `AudioContext` constructor this engine exposes, prefixed or not. */\nfunction audioContextConstructor(): typeof AudioContext | undefined {\n    if (typeof AudioContext !== \"undefined\") return AudioContext;\n    return (globalThis as { webkitAudioContext?: typeof AudioContext }).webkitAudioContext;\n}\n\n/**\n * Listen to a room at rest and report how loud its silence is.\n *\n * The number a person cannot guess. Setting a gate by ear means switching it on\n * and hearing what disappeared, which only works if you already know what should\n * have disappeared — so the usual outcome is leaving it at a default that is\n * wrong for that room. Measuring replaces the guess.\n *\n * The result is the **peak** RMS window observed, not the average: a threshold\n * under the loudest thing the quiet room did will be opened by that thing.\n *\n * @param stream - A live capture of the room while nobody speaks.\n * @param options - See {@link NoiseFloorOptions}.\n * @returns The peak RMS observed, `0..1`. `0` when this engine has no Web Audio\n *   or the stream carries no audio track — which {@link suggestGateThreshold}\n *   turns into its own floor rather than into a gate that never opens.\n *\n * @example\n * const floor = await measureNoiseFloor(stream, { onProgress: setProgress });\n * setThreshold(suggestGateThreshold(floor));\n */\nexport async function measureNoiseFloor(\n    stream: MediaStream,\n    {\n        onProgress,\n        durationMs = DEFAULT_DURATION_MS,\n        context: injectedContext,\n    }: NoiseFloorOptions = {},\n): Promise<number> {\n    const Ctor = audioContextConstructor();\n    const context = injectedContext ?? (Ctor ? new Ctor() : null);\n    const track = stream.getAudioTracks()[0];\n    if (!context || !track) return 0;\n\n    const source = context.createMediaStreamSource(stream);\n    const analyser = context.createAnalyser();\n    analyser.fftSize = 2048;\n    source.connect(analyser);\n\n    const buffer = new Float32Array(analyser.fftSize);\n    const started = performance.now();\n    let peak = 0;\n\n    await new Promise<void>((resolve) => {\n        const timer = setInterval(() => {\n            analyser.getFloatTimeDomainData(buffer);\n            peak = Math.max(peak, windowRms(buffer));\n\n            const elapsed = performance.now() - started;\n            onProgress?.(Math.min(1, elapsed / durationMs));\n            if (elapsed < durationMs) return;\n            clearInterval(timer);\n            resolve();\n        }, SAMPLE_MS);\n    });\n\n    source.disconnect();\n    analyser.disconnect();\n    return peak;\n}\n\n/**\n * Turn a measured noise floor into a threshold worth using.\n *\n * Sits above the floor by a margin rather than on it, and is clamped at both\n * ends: a room measured as perfectly silent (or not measured at all) would\n * otherwise get a threshold of zero, which is a gate that never closes, and a\n * room measured while somebody talked would get one nothing opens.\n *\n * @param noiseFloor - Peak RMS measured while nobody spoke.\n * @returns A threshold for {@link VoiceChainSettings.gateThreshold}, `0.004..0.12`.\n */\nexport function suggestGateThreshold(noiseFloor: number): number {\n    if (!Number.isFinite(noiseFloor)) return GATE_MIN;\n    return Math.min(GATE_MAX, Math.max(GATE_MIN, noiseFloor * GATE_MARGIN));\n}\n"],"mappings":"A,4CAGA,IAAME,EAAsB,IAGtBC,EAAY,GASZC,EAAc,IAGdC,EAAW,KACXC,EAAW,IAajB,SAASC,GAA2D,CAEhE,OADI,OAAO,aAAiB,IAAoB,aACxC,WAA4D,kBACxE,CAuBA,eAAsBC,EAClB,EACA,CACI,aACA,aAAaN,EACb,QAASO,GACU,CAAC,EACT,CACf,IAAMC,EAAOH,EAAwB,EAC/BI,EAAUF,IAAoBC,EAAO,IAAIA,EAAS,MAClDE,EAAQC,EAAO,eAAe,CAAC,CAAC,GACtC,GAAI,CAACF,GAAW,CAACC,EAAO,MAAO,GAE/B,IAAME,EAASH,EAAQ,wBAAwBE,CAAM,EAC/CE,EAAWJ,EAAQ,eAAe,EACxC,EAAS,QAAU,KACnBG,EAAO,QAAQC,CAAQ,EAEvB,IAAMC,EAAS,IAAI,aAAaD,EAAS,OAAO,EAC1CE,EAAU,YAAY,IAAI,EAC5BC,EAAO,EAiBX,OAfA,MAAM,IAAI,QAAe,GAAY,CACjC,IAAMC,EAAQ,gBAAkB,CAC5BJ,EAAS,uBAAuBC,CAAM,EACtC,EAAO,KAAK,IAAIE,EAAMlB,EAAAA,UAAUgB,CAAM,CAAC,EAEvC,IAAMI,EAAU,YAAY,IAAI,EAAIH,EACpCI,IAAa,KAAK,IAAI,EAAGD,EAAUE,CAAU,CAAC,EAC1C,IAAUA,KACd,cAAcH,CAAK,EACnBI,EAAQ,EACZ,EAAGpB,CAAS,CAChB,CAAC,EAEDW,EAAO,WAAW,EAClBC,EAAS,WAAW,EACbG,CACX,CAaA,SAAgBM,EAAqB,EAA4B,CAE7D,OADK,OAAO,SAASC,CAAU,EACxB,KAAK,IAAInB,EAAU,KAAK,IAAID,EAAUoB,EAAarB,CAAW,CAAC,EAD7BC,CAE7C,C"}

package/dist/audio/noise-floor.js.map

@@ -1 +1 @@
-{"version":3,"file":"noise-floor.js","names":[],"sources":["../../src/audio/noise-floor.ts"],"sourcesContent":["import { windowRms } from \"./voice-chain-stages\";\n\n/** How long the measurement listens by default, in milliseconds. */\nconst DEFAULT_DURATION_MS = 3000;\n\n/** How often it samples the room, in milliseconds. */\nconst SAMPLE_MS = 50;\n\n/**\n * Headroom over the measured floor, so ordinary speech clears the gate.\n *\n * A gate set exactly at the noise level chatters, opening and closing on the\n * room's own variation. Ported from `tempest-mirror-screen`'s `voiceChain.ts`,\n * where it was arrived at by listening.\n */\nconst GATE_MARGIN = 2.4;\n\n/** The narrowest and widest thresholds worth suggesting. */\nconst GATE_MIN = 0.004;\nconst GATE_MAX = 0.12;\n\n/** Options for {@link measureNoiseFloor}. */\nexport interface NoiseFloorOptions {\n    /** Called with `0..1` so a dialog can show the wait. */\n    onProgress?: (fraction: number) => void;\n    /** How long to listen. Default `3000`. */\n    durationMs?: number;\n    /** Reuse an existing `AudioContext` rather than opening one. */\n    context?: AudioContext;\n}\n\n/** The `AudioContext` constructor this engine exposes, prefixed or not. */\nfunction audioContextConstructor(): typeof AudioContext | undefined {\n    if (typeof AudioContext !== \"undefined\") return AudioContext;\n    return (globalThis as { webkitAudioContext?: typeof AudioContext }).webkitAudioContext;\n}\n\n/**\n * Listen to a room at rest and report how loud its silence is.\n *\n * The number a person cannot guess. Setting a gate by ear means switching it on\n * and hearing what disappeared, which only works if you already know what should\n * have disappeared — so the usual outcome is leaving it at a default that is\n * wrong for that room. Measuring replaces the guess.\n *\n * The result is the **peak** RMS window observed, not the average: a threshold\n * under the loudest thing the quiet room did will be opened by that thing.\n *\n * @param stream - A live capture of the room while nobody speaks.\n * @param options - See {@link NoiseFloorOptions}.\n * @returns The peak RMS observed, `0..1`. `0` when this engine has no Web Audio\n *   or the stream carries no audio track — which {@link suggestGateThreshold}\n *   turns into its own floor rather than into a gate that never opens.\n *\n * @example\n * const floor = await measureNoiseFloor(stream, { onProgress: setProgress });\n * setThreshold(suggestGateThreshold(floor));\n */\nexport async function measureNoiseFloor(\n    stream: MediaStream,\n    {\n        onProgress,\n        durationMs = DEFAULT_DURATION_MS,\n        context: injectedContext,\n    }: NoiseFloorOptions = {},\n): Promise<number> {\n    const Ctor = audioContextConstructor();\n    const context = injectedContext ?? (Ctor ? new Ctor() : null);\n    const track = stream.getAudioTracks()[0];\n    if (!context || !track) return 0;\n\n    const source = context.createMediaStreamSource(stream);\n    const analyser = context.createAnalyser();\n    analyser.fftSize = 2048;\n    source.connect(analyser);\n\n    const buffer = new Float32Array(analyser.fftSize);\n    const started = performance.now();\n    let peak = 0;\n\n    await new Promise<void>((resolve) => {\n        const timer = setInterval(() => {\n            analyser.getFloatTimeDomainData(buffer);\n            peak = Math.max(peak, windowRms(buffer));\n\n            const elapsed = performance.now() - started;\n            onProgress?.(Math.min(1, elapsed / durationMs));\n            if (elapsed < durationMs) return;\n            clearInterval(timer);\n            resolve();\n        }, SAMPLE_MS);\n    });\n\n    source.disconnect();\n    analyser.disconnect();\n    return peak;\n}\n\n/**\n * Turn a measured noise floor into a threshold worth using.\n *\n * Sits above the floor by a margin rather than on it, and is clamped at both\n * ends: a room measured as perfectly silent (or not measured at all) would\n * otherwise get a threshold of zero, which is a gate that never closes, and a\n * room measured while somebody talked would get one nothing opens.\n *\n * @param noiseFloor - Peak RMS measured while nobody spoke.\n * @returns A threshold for {@link VoiceChainSettings.gateThreshold}, `0.004..0.12`.\n */\nexport function suggestGateThreshold(noiseFloor: number): number {\n    if (!Number.isFinite(noiseFloor)) return GATE_MIN;\n    return Math.min(GATE_MAX, Math.max(GATE_MIN, noiseFloor * GATE_MARGIN));\n}\n"],"mappings":";;AAGA,IAAM,IAAsB,KAGtB,IAAY,IASZ,IAAc,KAGd,IAAW,MACX,IAAW;AAajB,SAAS,IAA2D;CAEhE,OADI,OAAO,eAAiB,MAAoB,eACxC,WAA4D;AACxE;AAuBA,eAAsB,EAClB,GACA,EACI,eACA,gBAAa,GACb,SAAS,MACU,CAAC,GACT;CACf,IAAM,IAAO,EAAwB,GAC/B,IAAU,MAAoB,IAAO,IAAI,EAAK,IAAI,OAClD,IAAQ,EAAO,eAAe,CAAC,CAAC;CACtC,IAAI,CAAC,KAAW,CAAC,GAAO,OAAO;CAE/B,IAAM,IAAS,EAAQ,wBAAwB,CAAM,GAC/C,IAAW,EAAQ,eAAe;CAExC,AADA,EAAS,UAAU,MACnB,EAAO,QAAQ,CAAQ;CAEvB,IAAM,IAAS,IAAI,aAAa,EAAS,OAAO,GAC1C,IAAU,YAAY,IAAI,GAC5B,IAAO;CAiBX,OAfA,MAAM,IAAI,SAAe,MAAY;EACjC,IAAM,IAAQ,kBAAkB;GAE5B,AADA,EAAS,uBAAuB,CAAM,GACtC,IAAO,KAAK,IAAI,GAAM,EAAU,CAAM,CAAC;GAEvC,IAAM,IAAU,YAAY,IAAI,IAAI;GACpC,IAAa,KAAK,IAAI,GAAG,IAAU,CAAU,CAAC,GAC1C,MAAU,OACd,cAAc,CAAK,GACnB,EAAQ;EACZ,GAAG,CAAS;CAChB,CAAC,GAED,EAAO,WAAW,GAClB,EAAS,WAAW,GACb;AACX;AAaA,SAAgB,EAAqB,GAA4B;CAE7D,OADK,OAAO,SAAS,CAAU,IACxB,KAAK,IAAI,GAAU,KAAK,IAAI,GAAU,IAAa,CAAW,CAAC,IAD7B;AAE7C"}
+{"version":3,"file":"noise-floor.js","names":["windowRms","rms","DEFAULT_DURATION_MS","SAMPLE_MS","GATE_MARGIN","GATE_MIN","GATE_MAX","audioContextConstructor","measureNoiseFloor","injectedContext","Ctor","context","track","stream","source","analyser","buffer","started","peak","timer","elapsed","onProgress","durationMs","resolve","suggestGateThreshold","noiseFloor"],"sources":["../../src/audio/noise-floor.ts"],"sourcesContent":["import { windowRms } from \"./voice-chain-stages\";\n\n/** How long the measurement listens by default, in milliseconds. */\nconst DEFAULT_DURATION_MS = 3000;\n\n/** How often it samples the room, in milliseconds. */\nconst SAMPLE_MS = 50;\n\n/**\n * Headroom over the measured floor, so ordinary speech clears the gate.\n *\n * A gate set exactly at the noise level chatters, opening and closing on the\n * room's own variation. Ported from `tempest-mirror-screen`'s `voiceChain.ts`,\n * where it was arrived at by listening.\n */\nconst GATE_MARGIN = 2.4;\n\n/** The narrowest and widest thresholds worth suggesting. */\nconst GATE_MIN = 0.004;\nconst GATE_MAX = 0.12;\n\n/** Options for {@link measureNoiseFloor}. */\nexport interface NoiseFloorOptions {\n    /** Called with `0..1` so a dialog can show the wait. */\n    onProgress?: (fraction: number) => void;\n    /** How long to listen. Default `3000`. */\n    durationMs?: number;\n    /** Reuse an existing `AudioContext` rather than opening one. */\n    context?: AudioContext;\n}\n\n/** The `AudioContext` constructor this engine exposes, prefixed or not. */\nfunction audioContextConstructor(): typeof AudioContext | undefined {\n    if (typeof AudioContext !== \"undefined\") return AudioContext;\n    return (globalThis as { webkitAudioContext?: typeof AudioContext }).webkitAudioContext;\n}\n\n/**\n * Listen to a room at rest and report how loud its silence is.\n *\n * The number a person cannot guess. Setting a gate by ear means switching it on\n * and hearing what disappeared, which only works if you already know what should\n * have disappeared — so the usual outcome is leaving it at a default that is\n * wrong for that room. Measuring replaces the guess.\n *\n * The result is the **peak** RMS window observed, not the average: a threshold\n * under the loudest thing the quiet room did will be opened by that thing.\n *\n * @param stream - A live capture of the room while nobody speaks.\n * @param options - See {@link NoiseFloorOptions}.\n * @returns The peak RMS observed, `0..1`. `0` when this engine has no Web Audio\n *   or the stream carries no audio track — which {@link suggestGateThreshold}\n *   turns into its own floor rather than into a gate that never opens.\n *\n * @example\n * const floor = await measureNoiseFloor(stream, { onProgress: setProgress });\n * setThreshold(suggestGateThreshold(floor));\n */\nexport async function measureNoiseFloor(\n    stream: MediaStream,\n    {\n        onProgress,\n        durationMs = DEFAULT_DURATION_MS,\n        context: injectedContext,\n    }: NoiseFloorOptions = {},\n): Promise<number> {\n    const Ctor = audioContextConstructor();\n    const context = injectedContext ?? (Ctor ? new Ctor() : null);\n    const track = stream.getAudioTracks()[0];\n    if (!context || !track) return 0;\n\n    const source = context.createMediaStreamSource(stream);\n    const analyser = context.createAnalyser();\n    analyser.fftSize = 2048;\n    source.connect(analyser);\n\n    const buffer = new Float32Array(analyser.fftSize);\n    const started = performance.now();\n    let peak = 0;\n\n    await new Promise<void>((resolve) => {\n        const timer = setInterval(() => {\n            analyser.getFloatTimeDomainData(buffer);\n            peak = Math.max(peak, windowRms(buffer));\n\n            const elapsed = performance.now() - started;\n            onProgress?.(Math.min(1, elapsed / durationMs));\n            if (elapsed < durationMs) return;\n            clearInterval(timer);\n            resolve();\n        }, SAMPLE_MS);\n    });\n\n    source.disconnect();\n    analyser.disconnect();\n    return peak;\n}\n\n/**\n * Turn a measured noise floor into a threshold worth using.\n *\n * Sits above the floor by a margin rather than on it, and is clamped at both\n * ends: a room measured as perfectly silent (or not measured at all) would\n * otherwise get a threshold of zero, which is a gate that never closes, and a\n * room measured while somebody talked would get one nothing opens.\n *\n * @param noiseFloor - Peak RMS measured while nobody spoke.\n * @returns A threshold for {@link VoiceChainSettings.gateThreshold}, `0.004..0.12`.\n */\nexport function suggestGateThreshold(noiseFloor: number): number {\n    if (!Number.isFinite(noiseFloor)) return GATE_MIN;\n    return Math.min(GATE_MAX, Math.max(GATE_MIN, noiseFloor * GATE_MARGIN));\n}\n"],"mappings":";;AAGA,IAAME,IAAsB,KAGtBC,IAAY,IASZC,IAAc,KAGdC,IAAW,MACXC,IAAW;AAajB,SAASC,IAA2D;CAEhE,OADI,OAAO,eAAiB,MAAoB,eACxC,WAA4D;AACxE;AAuBA,eAAsBC,EAClB,GACA,EACI,eACA,gBAAaN,GACb,SAASO,MACU,CAAC,GACT;CACf,IAAMC,IAAOH,EAAwB,GAC/BI,IAAUF,MAAoBC,IAAO,IAAIA,EAAK,IAAI,OAClDE,IAAQC,EAAO,eAAe,CAAC,CAAC;CACtC,IAAI,CAACF,KAAW,CAACC,GAAO,OAAO;CAE/B,IAAME,IAASH,EAAQ,wBAAwBE,CAAM,GAC/CE,IAAWJ,EAAQ,eAAe;CAExC,AADA,EAAS,UAAU,MACnBG,EAAO,QAAQC,CAAQ;CAEvB,IAAMC,IAAS,IAAI,aAAaD,EAAS,OAAO,GAC1CE,IAAU,YAAY,IAAI,GAC5BC,IAAO;CAiBX,OAfA,MAAM,IAAI,SAAe,MAAY;EACjC,IAAMC,IAAQ,kBAAkB;GAE5B,AADAJ,EAAS,uBAAuBC,CAAM,GACtC,IAAO,KAAK,IAAIE,GAAMlB,EAAUgB,CAAM,CAAC;GAEvC,IAAMI,IAAU,YAAY,IAAI,IAAIH;GAEpC,AADAI,IAAa,KAAK,IAAI,GAAGD,IAAUE,CAAU,CAAC,GAC1C,MAAUA,OACd,cAAcH,CAAK,GACnBI,EAAQ;EACZ,GAAGpB,CAAS;CAChB,CAAC,GAEDW,EAAO,WAAW,GAClBC,EAAS,WAAW,GACbG;AACX;AAaA,SAAgBM,EAAqB,GAA4B;CAE7D,OADK,OAAO,SAASC,CAAU,IACxB,KAAK,IAAInB,GAAU,KAAK,IAAID,GAAUoB,IAAarB,CAAW,CAAC,IAD7BC;AAE7C"}

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

@@ -1 +1 @@
-{"version":3,"file":"sfx-pool.cjs","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.cjs","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/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":"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"}

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":";;;;;AA+EA,SAAgB,EACZ,GACA,IAAmC,CAAC,GACd;CACtB,IAAM,EACF,kBACA,eACA,YACA,YACA,aACA,uBACA,gBACA,YAAS,KACT,uBAAoB,OACpB,GAEE,CAAC,GAAQ,KAAa,EAA8B,MAAM,GAC1D,CAAC,GAAY,KAAiB,EAAS,CAAC,GACxC,CAAC,GAAO,KAAY,EAAS,CAAC,GAC9B,CAAC,GAAW,KAAgB,EAAgC,IAAI,GAChE,CAAC,GAAO,KAAY,EAAkB,IAAI,GAC1C,CAAC,GAAO,KAAY,EAAS,EAAK,GAElC,IAAc,EAAmC,IAAI,GACrD,IAAW,EAA0B,IAAI,GAEzC,IAAe,GAAmB,MAA2B,IAAa,CAAM,CAAC,GACjF,IAAY,GAAmB,MAAgB,IAAU,CAAK,CAAC,GAC/D,IAAY,GAAmB,MAAiB;EAElD,AADA,EAAS,CAAG,GACZ,IAAU,CAAG;CACjB,CAAC;CAYD,QAAgB;EACZ,IAAI,CAAC,GAAQ;GACT,EAAS,EAAK;GACd;EACJ;EACA,IAAI;EACJ,IAAI;GACA,IAAW,EAAoB,GAAQ;IACnC;IACA;IACA;IACA,SAAS;IACT,SAAS;GACb,CAAC;EACL,SAAS,GAAK;GAEV,AADA,EAAS,CAAG,GACZ,EAAS,EAAK;GACd;EACJ;EAMA,OALA,EAAY,UAAU,GACtB,EAAS,UAAU,IAAoB,OAAO,EAAiB,CAAM,GACrE,EAAS,EAAI,GACb,EAAU,MAAM,SAEH;GAOT,CANI,EAAS,OAAO,MAAM,eAAe,EAAS,OAAO,MAAM,aAC3D,EAAS,OAAO,GAEpB,EAAS,SAAS,KAAK,GACvB,EAAS,UAAU,MACnB,EAAY,UAAU,MACtB,EAAS,EAAK;EAClB;CACJ,GAAG;EACC;EACA;EACA;EACA;EACA;EACA;EACA;CACJ,CAAC;CAED,IAAM,IAAO,EAAY,YAA4C;EACjE,IAAM,IAAW,EAAY;EAC7B,IAAI,CAAC,GAAU,OAAO;EACtB,IAAM,IAAU,EAAS,OAAO;EAChC,IAAI,MAAY,eAAe,MAAY,UAAU,OAAO;EAC5D,IAAM,IAAS,MAAM,EAAS,KAAK;EAMnC,OALA,EAAU,SAAS,GACnB,EAAc,EAAO,UAAU,GAC/B,EAAS,CAAC,GACV,EAAa,CAAM,GACnB,EAAa,CAAM,GACZ;CACX,GAAG,CAAC,CAAY,CAAC;CA6DjB,OAnDA,QAAgB;EACZ,IAAI,MAAW,eAAe,MAAW,UAAU;GAC/C,EAAS,CAAC;GACV;EACJ;EACA,IAAM,IAAK,kBAAkB;GACzB,IAAM,IAAW,EAAY;GAC7B,IAAI,CAAC,GAAU;GACf,IAAM,IAAU,EAAS,WAAW;GAGpC,AAFA,EAAc,CAAO,GACrB,EAAS,MAAW,cAAe,EAAS,SAAS,MAAM,KAAK,IAAK,CAAC,GAClE,MAAkB,KAAA,KAAa,KAAW,KAAe,EAAU;EAC3E,GAAG,CAAM;EACT,aAAa,cAAc,CAAE;CACjC,GAAG;EAAC;EAAQ;EAAQ;EAAe;CAAI,CAAC,GAqCjC;EACH;EACA;EACA;EACA;EACA;EACA;EACA,OA1CU,QAAwB;GAClC,IAAM,IAAW,EAAY;GACxB,MACL,EAAa,IAAI,GACjB,EAAS,IAAI,GACb,EAAc,CAAC,GACf,EAAS,MAAM,GACf,EAAU,EAAS,OAAO,CAAC;EAC/B,GAAG,CAAC,CAkCA;EACA,OAjCU,QAAwB;GAClC,IAAM,IAAW,EAAY;GACxB,MACL,EAAS,MAAM,GACf,EAAc,EAAS,WAAW,CAAC,GACnC,EAAU,EAAS,OAAO,CAAC;EAC/B,GAAG,CAAC,CA2BA;EACA,QA1BW,QAAwB;GACnC,IAAM,IAAW,EAAY;GACxB,MACL,EAAS,OAAO,GAChB,EAAU,EAAS,OAAO,CAAC;EAC/B,GAAG,CAAC,CAqBA;EACA;EACA,QArBW,QAAwB;GACnC,IAAM,IAAW,EAAY;GACxB,MACL,EAAS,OAAO,GAChB,EAAU,MAAM,GAChB,EAAc,CAAC,GACf,EAAS,CAAC,GACV,EAAa,IAAI;EACrB,GAAG,CAAC,CAaA;CACJ;AACJ"}
+{"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"}