@@ -978,13 +978,13 @@ The Edge provider reads these keys from `SpeechParams.Config`:
 | `speed` | `float64` | `0` | Speech rate (1.0 = normal) |
 | `pitch` | `float64` | `0` | Pitch in Hz |
 
-#### Package-Level Variables
+#### Helper Functions
 
 ```go
-var EdgeTTSVoices map[string][]string  // language tag → voice IDs
+func Voices() map[string][]string
 ```
 
-#### Helper Functions
+Returns the voice catalog (language tag → voice IDs). Each call returns a new deep copy; modifying it does not affect the package.
 
 ```go
 func LookupVoiceLang(voiceID string) (string, bool)
 
@@ -150,13 +150,13 @@ The Edge provider reads these keys from `WithSpeechConfig`:
 
 ### Voices
 
-Edge TTS supports 400+ voices across 100+ languages. Use `speech.EdgeTTSVoices` to browse the full catalog:
+Edge TTS supports 400+ voices across 100+ languages. Use `speech.Voices()` to browse the full catalog. It returns a copy, so modifying the result does not affect the package:
 
 ```go
 import "github.com/felinics/twilight/provider/edge/speech"
 
 // Map of language tag → voice IDs
-for lang, voices := range speech.EdgeTTSVoices {
+for lang, voices := range speech.Voices() {
     fmt.Printf("%s: %v\n", lang, voices)
 }
 
 
@@ -3,6 +3,7 @@ package speech
 import (
 	_ "embed"
 	"encoding/json"
+	"slices"
 )
 
 const (
@@ -22,23 +23,36 @@ const (
 //go:embed voices.json
 var voicesJSON []byte
 
-// EdgeTTSVoices maps language tags to available voice IDs, loaded from voices.json.
-var EdgeTTSVoices map[string][]string
+// voicesByLang maps language tags to voice IDs. It is populated once in init
+// and never mutated afterwards, so concurrent reads are safe. It must not be
+// handed out directly; use Voices, which returns a copy.
+var voicesByLang map[string][]string
 
 var voiceToLang map[string]string
 
 func init() {
-	if err := json.Unmarshal(voicesJSON, &EdgeTTSVoices); err != nil {
+	if err := json.Unmarshal(voicesJSON, &voicesByLang); err != nil {
 		panic("edge: failed to parse voices.json: " + err.Error())
 	}
 	voiceToLang = make(map[string]string, 256)
-	for lang, voices := range EdgeTTSVoices {
+	for lang, voices := range voicesByLang {
 		for _, v := range voices {
 			voiceToLang[v] = lang
 		}
 	}
 }
 
+// Voices returns the Edge TTS voice catalog as a map from language tag to
+// voice IDs. The result is a fresh deep copy on every call; callers may modify
+// it freely without affecting the package or other callers.
+func Voices() map[string][]string {
+	out := make(map[string][]string, len(voicesByLang))
+	for lang, ids := range voicesByLang {
+		out[lang] = slices.Clone(ids)
+	}
+	return out
+}
+
 // LookupVoiceLang returns the language for a known Edge TTS voice ID.
 // Returns ("", false) if the voice is not recognized.
 func LookupVoiceLang(voiceID string) (string, bool) {
 
@@ -0,0 +1,67 @@
+package speech
+
+import (
+	"slices"
+	"sync"
+	"testing"
+)
+
+func TestVoices_ReturnsIndependentCopy(t *testing.T) {
+	t.Parallel()
+
+	first := Voices()
+	zh, ok := first["zh-CN"]
+	if !ok || !slices.Contains(zh, "zh-CN-XiaoxiaoNeural") {
+		t.Fatalf("zh-CN voices missing XiaoxiaoNeural: %v", zh)
+	}
+
+	zh[0] = "mutated"
+	first["zh-CN"] = nil
+	delete(first, "en-US")
+	first["xx-XX"] = []string{"xx-XX-FakeNeural"}
+
+	second := Voices()
+	if !slices.Contains(second["zh-CN"], "zh-CN-XiaoxiaoNeural") || slices.Contains(second["zh-CN"], "mutated") {
+		t.Fatalf("package data changed through returned slice: %v", second["zh-CN"])
+	}
+	if _, ok := second["en-US"]; !ok {
+		t.Fatal("deleting from returned map removed en-US from package data")
+	}
+	if _, ok := second["xx-XX"]; ok {
+		t.Fatal("inserting into returned map leaked into package data")
+	}
+	if lang, ok := LookupVoiceLang("zh-CN-XiaoxiaoNeural"); !ok || lang != "zh-CN" {
+		t.Fatalf("LookupVoiceLang = %q, %v", lang, ok)
+	}
+}
+
+// TestVoices_ConcurrentReadAndMutate is meaningful under -race: every goroutine
+// reads the catalog and mutates its own copy. If Voices returned shared state,
+// the race detector (or the runtime's concurrent map write check) would fire.
+func TestVoices_ConcurrentReadAndMutate(t *testing.T) {
+	t.Parallel()
+
+	var wg sync.WaitGroup
+	for i := range 16 {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for range 50 {
+				v := Voices()
+				for lang, ids := range v {
+					if len(ids) > 0 {
+						ids[0] = "mutated"
+					}
+					v[lang] = append(ids, "extra")
+				}
+				v["goroutine"] = []string{string(rune('a' + i))}
+				_, _ = LookupVoiceLang("en-US-EmmaMultilingualNeural")
+			}
+		}()
+	}
+	wg.Wait()
+
+	if slices.Contains(Voices()["en-US"], "mutated") {
+		t.Fatal("concurrent mutation of returned copies reached package data")
+	}
+}