feat: Add extensibility for text formatting and cleaning

- Add TextCleaner custom replacements (string and regex) with
  AddReplacement, AddRegexReplacement, and Clear methods
- Extract BuildSpeakerPrefixedText as public method in SpeechManager
  for reuse in FormatTextOverride delegates

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: LordLuceus

SpeechManager.cs

@@ -167,6 +167,18 @@ private static string FormatText(string speaker, string text, int textType)
             if (FormatTextOverride != null)
                 return FormatTextOverride(speaker, text, textType);
 
+            return BuildSpeakerPrefixedText(speaker, text, textType);
+        }
+
+        /// <summary>
+        /// Builds formatted text with optional speaker prefix based on text type.
+        /// </summary>
+        /// <param name="speaker">The speaker name (can be null or empty)</param>
+        /// <param name="text">The text content</param>
+        /// <param name="textType">The type of text being formatted</param>
+        /// <returns>Formatted text with speaker prefix for Dialogue type, or plain text otherwise</returns>
+        public static string BuildSpeakerPrefixedText(string speaker, string text, int textType)
+        {
             // Default: only Dialogue type gets speaker prefix
             if (textType == TextType.Dialogue && !Net35Extensions.IsNullOrWhiteSpace(speaker))
                 return $"{speaker}: {text}";

TextCleaner.cs

@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using System.Text;
 using System.Text.RegularExpressions;
 
@@ -6,9 +7,14 @@ namespace MelonAccessibilityLib
     /// <summary>
     /// Utility class to clean text for screen reader output.
     /// Removes Unity rich text tags, normalizes whitespace, and handles escape sequences.
+    /// Consumers can extend cleaning behavior via <see cref="AddReplacement"/> and <see cref="AddRegexReplacement(string, string, RegexOptions)"/>.
     /// </summary>
     public static class TextCleaner
     {
+        private static readonly object _lock = new object();
+        private static readonly List<KeyValuePair<string, string>> _customReplacements = new List<KeyValuePair<string, string>>();
+        private static readonly List<KeyValuePair<Regex, string>> _customRegexReplacements = new List<KeyValuePair<Regex, string>>();
+
         // Unity rich text tags
         private static readonly Regex ColorTagRegex = new Regex(
             @"<color[^>]*>|</color>",
@@ -47,8 +53,99 @@ public static class TextCleaner
             RegexOptions.Compiled
         );
 
+        /// <summary>
+        /// Adds a custom string replacement that will be applied during text cleaning.
+        /// Replacements are applied in the order they are added, after Unity rich text tags are removed.
+        /// </summary>
+        /// <param name="find">The string to find.</param>
+        /// <param name="replace">The string to replace it with.</param>
+        public static void AddReplacement(string find, string replace)
+        {
+            if (string.IsNullOrEmpty(find))
+                return;
+
+            lock (_lock)
+            {
+                _customReplacements.Add(new KeyValuePair<string, string>(find, replace ?? string.Empty));
+            }
+        }
+
+        /// <summary>
+        /// Adds a custom regex replacement that will be applied during text cleaning.
+        /// Regex replacements are applied in the order they are added, after string replacements.
+        /// </summary>
+        /// <param name="pattern">The regex pattern to match.</param>
+        /// <param name="replace">The replacement string (supports regex substitutions like $1).</param>
+        /// <param name="options">Optional regex options. Defaults to <see cref="RegexOptions.None"/>.</param>
+        public static void AddRegexReplacement(string pattern, string replace, RegexOptions options = RegexOptions.None)
+        {
+            if (string.IsNullOrEmpty(pattern))
+                return;
+
+            lock (_lock)
+            {
+                _customRegexReplacements.Add(new KeyValuePair<Regex, string>(
+                    new Regex(pattern, options),
+                    replace ?? string.Empty
+                ));
+            }
+        }
+
+        /// <summary>
+        /// Adds a custom regex replacement that will be applied during text cleaning.
+        /// Regex replacements are applied in the order they are added, after string replacements.
+        /// </summary>
+        /// <param name="regex">The compiled regex to use for matching.</param>
+        /// <param name="replace">The replacement string (supports regex substitutions like $1).</param>
+        public static void AddRegexReplacement(Regex regex, string replace)
+        {
+            if (regex == null)
+                return;
+
+            lock (_lock)
+            {
+                _customRegexReplacements.Add(new KeyValuePair<Regex, string>(regex, replace ?? string.Empty));
+            }
+        }
+
+        /// <summary>
+        /// Removes all custom string replacements (not regex replacements).
+        /// </summary>
+        public static void ClearReplacements()
+        {
+            lock (_lock)
+            {
+                _customReplacements.Clear();
+            }
+        }
+
+        /// <summary>
+        /// Removes all custom regex replacements (not string replacements).
+        /// </summary>
+        public static void ClearRegexReplacements()
+        {
+            lock (_lock)
+            {
+                _customRegexReplacements.Clear();
+            }
+        }
+
+        /// <summary>
+        /// Removes all custom replacements (both string and regex).
+        /// </summary>
+        public static void ClearAllCustomReplacements()
+        {
+            lock (_lock)
+            {
+                _customReplacements.Clear();
+                _customRegexReplacements.Clear();
+            }
+        }
+
         /// <summary>
         /// Clean text by removing Unity rich text tags and normalizing whitespace.
+        /// Custom replacements registered via <see cref="AddReplacement"/> and <see cref="AddRegexReplacement(string, string, RegexOptions)"/>
+        /// are applied after tag removal and before whitespace normalization.
         /// </summary>
         public static string Clean(string input)
         {
@@ -71,6 +168,9 @@ public static string Clean(string input)
             // Handle escape sequences
             cleaned = UnescapeText(cleaned);
 
+            // Apply custom replacements
+            cleaned = ApplyCustomReplacements(cleaned);
+
             // Normalize whitespace
             cleaned = MultipleSpacesRegex.Replace(cleaned, " ");
 
@@ -94,6 +194,31 @@ private static string UnescapeText(string input)
             return sb.ToString();
         }
 
+        private static string ApplyCustomReplacements(string input)
+        {
+            if (string.IsNullOrEmpty(input))
+                return input;
+
+            string result = input;
+
+            lock (_lock)
+            {
+                // Apply string replacements first
+                foreach (var replacement in _customReplacements)
+                {
+                    result = result.Replace(replacement.Key, replacement.Value);
+                }
+
+                // Apply regex replacements
+                foreach (var replacement in _customRegexReplacements)
+                {
+                    result = replacement.Key.Replace(result, replacement.Value);
+                }
+            }
+
+            return result;
+        }
+
         /// <summary>
         /// Combine multiple lines into a single string, cleaning each line.
         /// </summary>