tint_me 1.0.0

data/benchmark/2025-09-08-style-caching-optimization/02_with_full_caching_results.txt

@@ -0,0 +1,54 @@
+OPTIMIZED BENCHMARK RESULTS (After Caching Implementation)
+==========================================================
+Date: 2025-09-08
+
+## Performance Summary
+
+### Style Application (operations/second)
+- Simple style: ~5.44M ops/s (184ns per call)
+- Complex style: ~3.83M ops/s (261ns per call)  
+- Hex color style: ~4.66M ops/s (215ns per call)
+
+### Repeated Application (1000x)
+- Simple style: 6,383 ops/s (157μs total)
+- Complex style: 4,294 ops/s (233μs total)
+- Hex style: 5,343 ops/s (187μs total)
+
+### Memory Usage
+- Simple style creation: 6.1KB, 58 objects (+350 bytes, +6 objects)
+- Complex style creation: 7.8KB, 79 objects (+1.2KB, +13 objects)
+- Simple style application: 424 bytes, 3 objects
+- Complex style application: 264 bytes, 2 objects
+
+### Object Allocations (100 applications)
+- Simple style: 104 objects (85% reduction)
+- Complex style: 104 objects (91% reduction)
+
+## Performance Improvements
+
+### Speed Improvements
+- Simple style: 7.1x faster (766k → 5.44M ops/s)
+- Complex style: 8.8x faster (437k → 3.83M ops/s)
+- Hex color style: 17.5x faster (266k → 4.66M ops/s)
+
+### Object Allocation Reductions
+- Simple style: 85% fewer objects (703 → 104)
+- Complex style: 91% fewer objects (1203 → 104)
+
+### Repeated Application Improvements
+- Simple style: 8.2x faster (781 → 6,383 ops/s)
+- Complex style: 9.9x faster (433 → 4,294 ops/s)
+- Hex style: 20.2x faster (265 → 5,343 ops/s)
+
+## Memory Trade-offs
+- Style creation memory increase: 6-18% higher
+- Per-application memory usage: Dramatically reduced
+- Overall memory efficiency: Much better for repeated use
+
+## Key Observations
+
+1. **Massive performance gains**: 7-18x faster style application
+2. **Dramatic allocation reduction**: 85-91% fewer objects
+3. **Consistent performance**: Style complexity no longer impacts speed significantly
+4. **Memory trade-off acceptable**: Small creation overhead, huge runtime savings
+5. **Hex colors now fast**: RGB conversion cached at creation time

data/benchmark/2025-09-08-style-caching-optimization/03_prefix_only_caching_results.txt

@@ -0,0 +1,107 @@
+============================================================
+TIntMe Style Performance Benchmark
+============================================================
+
+Memory Usage Analysis:
+----------------------------------------
+Calculating -------------------------------------
+ Create simple style     6.048k memsize (     0.000  retained)
+                        58.000  objects (     0.000  retained)
+                         2.000  strings (     0.000  retained)
+Create complex style     7.744k memsize (     0.000  retained)
+                        79.000  objects (     0.000  retained)
+                         9.000  strings (     0.000  retained)
+Apply simple style (short text)
+                       616.000  memsize (     0.000  retained)
+                         4.000  objects (     0.000  retained)
+                         1.000  strings (     0.000  retained)
+Apply complex style (short text)
+                       264.000  memsize (     0.000  retained)
+                         2.000  objects (     0.000  retained)
+                         1.000  strings (     0.000  retained)
+
+Comparison:
+Apply complex style (short text):        264 allocated
+Apply simple style (short text):        616 allocated - 2.33x more
+ Create simple style:       6048 allocated - 22.91x more
+Create complex style:       7744 allocated - 29.33x more
+
+Performance Benchmark (operations per second):
+----------------------------------------
+ruby 3.2.9 (2025-07-24 revision 8f611e0c46) [arm64-darwin24]
+Warming up --------------------------------------
+ Create simple style     2.927k i/100ms
+Create complex style     2.413k i/100ms
+Apply simple style (short)
+                       443.590k i/100ms
+Apply simple style (medium)
+                       395.847k i/100ms
+Apply simple style (long)
+                       378.681k i/100ms
+Apply complex style (short)
+                       321.759k i/100ms
+Apply complex style (medium)
+                       382.195k i/100ms
+Apply complex style (long)
+                       356.585k i/100ms
+Apply hex style (short)
+                       373.664k i/100ms
+Calculating -------------------------------------
+ Create simple style     29.037k (± 3.1%) i/s   (34.44 μs/i) -    146.350k in   5.045026s
+Create complex style     24.894k (± 1.7%) i/s   (40.17 μs/i) -    125.476k in   5.042000s
+Apply simple style (short)
+                          4.428M (± 0.8%) i/s  (225.85 ns/i) -     22.180M in   5.009439s
+Apply simple style (medium)
+                          3.847M (± 1.4%) i/s  (259.95 ns/i) -     19.397M in   5.043123s
+Apply simple style (long)
+                          3.764M (± 1.6%) i/s  (265.69 ns/i) -     18.934M in   5.031865s
+Apply complex style (short)
+                          3.275M (± 1.0%) i/s  (305.32 ns/i) -     16.410M in   5.010664s
+Apply complex style (medium)
+                          3.748M (± 4.8%) i/s  (266.82 ns/i) -     18.728M in   5.012920s
+Apply complex style (long)
+                          3.469M (± 5.5%) i/s  (288.30 ns/i) -     17.473M in   5.056096s
+Apply hex style (short)
+                          3.747M (± 3.1%) i/s  (266.90 ns/i) -     19.057M in   5.092324s
+
+Comparison:
+Apply simple style (short):  4427800.1 i/s
+Apply simple style (medium):  3846907.6 i/s - 1.15x  slower
+Apply simple style (long):  3763792.3 i/s - 1.18x  slower
+Apply complex style (medium):  3747858.3 i/s - 1.18x  slower
+Apply hex style (short):  3746719.7 i/s - 1.18x  slower
+Apply complex style (long):  3468603.6 i/s - 1.28x  slower
+Apply complex style (short):  3275289.7 i/s - 1.35x  slower
+ Create simple style:    29037.4 i/s - 152.49x  slower
+Create complex style:    24894.1 i/s - 177.87x  slower
+
+
+Repeated Application Benchmark:
+----------------------------------------
+Applying the same style 1000 times to measure caching benefit...
+ruby 3.2.9 (2025-07-24 revision 8f611e0c46) [arm64-darwin24]
+Warming up --------------------------------------
+  1000x simple style   497.000 i/100ms
+ 1000x complex style   357.000 i/100ms
+     1000x hex style   426.000 i/100ms
+Calculating -------------------------------------
+  1000x simple style      4.961k (± 0.9%) i/s  (201.59 μs/i) -     24.850k in   5.009943s
+ 1000x complex style      3.553k (± 3.4%) i/s  (281.45 μs/i) -     17.850k in   5.031381s
+     1000x hex style      4.171k (± 5.0%) i/s  (239.76 μs/i) -     20.874k in   5.019703s
+
+Comparison:
+  1000x simple style:     4960.5 i/s
+     1000x hex style:     4170.9 i/s - 1.19x  slower
+ 1000x complex style:     3553.0 i/s - 1.40x  slower
+
+
+Object Allocation Analysis:
+----------------------------------------
+Create simple style: 117 objects allocated
+Create complex style: 136 objects allocated
+Apply simple style 100x: 104 objects allocated
+Apply complex style 100x: 104 objects allocated
+
+============================================================
+Benchmark complete!
+============================================================

data/benchmark/2025-09-08-style-caching-optimization/04_baseline_vs_optimized_analysis.txt

@@ -0,0 +1,65 @@
+PERFORMANCE COMPARISON ANALYSIS
+===============================
+
+## Before vs After Optimization Summary
+
+### Style Application Performance (ops/second)
+| Style Type | Before    | After     | Improvement |
+|------------|-----------|-----------|-------------|
+| Simple     | 766,000   | 5,444,000 | 7.1x faster |
+| Complex    | 437,000   | 3,834,000 | 8.8x faster |
+| Hex Color  | 266,000   | 4,656,000 | 17.5x faster|
+
+### Repeated Application (1000x, ops/second)
+| Style Type | Before | After | Improvement |
+|------------|--------|-------|-------------|
+| Simple     | 781    | 6,383 | 8.2x faster |
+| Complex    | 433    | 4,294 | 9.9x faster |
+| Hex        | 265    | 5,343 | 20.2x faster|
+
+### Object Allocations (100 applications)
+| Style Type | Before | After | Reduction |
+|------------|--------|-------|-----------|
+| Simple     | 703    | 104   | 85% less  |
+| Complex    | 1,203  | 104   | 91% less  |
+
+### Memory Usage Per Style Creation
+| Style Type | Before        | After         | Increase |
+|------------|---------------|---------------|----------|
+| Simple     | 5.8KB, 52 obj| 6.1KB, 58 obj | +6%      |
+| Complex    | 6.6KB, 66 obj| 7.8KB, 79 obj | +18%     |
+
+## Key Insights
+
+### Performance Gains
+1. **Hex colors see biggest improvement**: 17.5-20x faster
+   - RGB conversion now happens once at creation instead of every call
+   
+2. **Complex styles benefit most**: 8.8-9.9x faster
+   - Multiple SGR parameters cached as single string
+   
+3. **Simple styles still significant**: 7.1-8.2x faster
+   - Even basic styles benefit from eliminating repeated calculation
+
+### Memory Trade-offs
+1. **Creation cost acceptable**: 6-18% increase in creation memory
+   - Small price for immutable objects that may be called many times
+   
+2. **Runtime memory much better**: Massive reduction in per-call allocations
+   - 85-91% fewer objects created during style application
+   
+3. **Net positive for typical usage**: Any style called >2-3 times benefits
+
+### Algorithm Complexity Improvements
+1. **Before**: O(n) per call where n = number of style attributes
+2. **After**: O(1) per call - just string concatenation
+3. **One-time cost**: SGR sequence building moved to initialization
+
+## Recommendation
+The optimization is highly successful with minimal downsides:
+- Dramatic performance improvements across all scenarios
+- Acceptable memory trade-off for creation
+- Maintains identical API and behavior
+- Especially beneficial for repeated use (the common case)
+
+This change transforms Style from a computation-heavy operation to a simple string concatenation, making it suitable for high-frequency styling operations.

data/benchmark/2025-09-08-style-caching-optimization/05_caching_approaches_comparison.txt

@@ -0,0 +1,59 @@
+CACHING APPROACH COMPARISON
+===========================
+Date: 2025-09-08
+
+## Memory Usage Comparison (Style Creation)
+
+### With reset_code caching:
+- Simple style: 6.1KB, 58 objects
+- Complex style: 7.8KB, 79 objects
+
+### Without reset_code caching:
+- Simple style: 6.0KB, 58 objects (-8 bytes)
+- Complex style: 7.7KB, 79 objects (-8 bytes)
+
+**Memory savings: ~8 bytes per Style instance (negligible)**
+
+## Performance Comparison (ops/second)
+
+### Style Application Performance:
+| Style Type | With reset_code cache | Without reset_code cache | Difference |
+|------------|----------------------|---------------------------|------------|
+| Simple     | 5.44M                | 4.43M                     | 18% slower |
+| Complex    | 3.83M                | 3.28M                     | 14% slower |
+| Hex        | 4.66M                | 3.75M                     | 20% slower |
+
+### Repeated Application (1000x):
+| Style Type | With cache | Without cache | Difference |
+|------------|------------|---------------|------------|
+| Simple     | 6,383      | 4,961         | 22% slower |
+| Complex    | 4,294      | 3,553         | 17% slower |
+| Hex        | 5,343      | 4,171         | 22% slower |
+
+### Memory Usage Per Application:
+| Style Type | With cache | Without cache | Difference |
+|------------|------------|---------------|------------|
+| Simple     | 424 bytes  | 616 bytes     | +45% more |
+| Complex    | 264 bytes  | 264 bytes     | same      |
+
+## Analysis
+
+### Performance Impact:
+- **14-22% performance decrease** without reset_code caching
+- Simple styles show highest impact (22% slower)
+- Memory allocation per call increases for simple styles
+
+### Memory Trade-off:
+- **Minimal creation savings**: Only 8 bytes per Style instance
+- **Higher runtime cost**: Simple styles use 45% more memory per call
+- **Net negative**: More allocations during frequent usage
+
+### Recommendations:
+
+**Keep reset_code caching** because:
+1. Negligible memory savings (8 bytes) when removed
+2. Significant performance cost (14-22% slower)
+3. Increased runtime memory allocations
+4. Reset code is a constant string ("\e[0m") - perfect for caching
+
+The reset_code caching provides substantial performance benefits with minimal memory overhead, making it an optimal trade-off for the typical use case of applying styles multiple times.

data/benchmark/2025-09-08-style-caching-optimization/06_append_operator_results.txt

@@ -0,0 +1,107 @@
+============================================================
+TIntMe Style Performance Benchmark
+============================================================
+
+Memory Usage Analysis:
+----------------------------------------
+Calculating -------------------------------------
+ Create simple style     6.056k memsize (     0.000  retained)
+                        58.000  objects (     0.000  retained)
+                         2.000  strings (     0.000  retained)
+Create complex style     7.752k memsize (     0.000  retained)
+                        79.000  objects (     0.000  retained)
+                         9.000  strings (     0.000  retained)
+Apply simple style (short text)
+                       424.000  memsize (     0.000  retained)
+                         3.000  objects (     0.000  retained)
+                         1.000  strings (     0.000  retained)
+Apply complex style (short text)
+                       264.000  memsize (     0.000  retained)
+                         2.000  objects (     0.000  retained)
+                         1.000  strings (     0.000  retained)
+
+Comparison:
+Apply complex style (short text):        264 allocated
+Apply simple style (short text):        424 allocated - 1.61x more
+ Create simple style:       6056 allocated - 22.94x more
+Create complex style:       7752 allocated - 29.36x more
+
+Performance Benchmark (operations per second):
+----------------------------------------
+ruby 3.2.9 (2025-07-24 revision 8f611e0c46) [arm64-darwin24]
+Warming up --------------------------------------
+ Create simple style     2.537k i/100ms
+Create complex style     2.341k i/100ms
+Apply simple style (short)
+                       466.725k i/100ms
+Apply simple style (medium)
+                       341.328k i/100ms
+Apply simple style (long)
+                       287.127k i/100ms
+Apply complex style (short)
+                       323.061k i/100ms
+Apply complex style (medium)
+                       336.757k i/100ms
+Apply complex style (long)
+                       303.412k i/100ms
+Apply hex style (short)
+                       237.369k i/100ms
+Calculating -------------------------------------
+ Create simple style     28.350k (± 3.5%) i/s   (35.27 μs/i) -    142.072k in   5.018115s
+Create complex style     22.956k (± 8.6%) i/s   (43.56 μs/i) -    114.709k in   5.048226s
+Apply simple style (short)
+                          4.604M (± 1.7%) i/s  (217.20 ns/i) -     23.336M in   5.069941s
+Apply simple style (medium)
+                          3.365M (± 3.7%) i/s  (297.21 ns/i) -     17.066M in   5.080576s
+Apply simple style (long)
+                          3.071M (± 4.5%) i/s  (325.67 ns/i) -     15.505M in   5.059977s
+Apply complex style (short)
+                          3.362M (± 4.0%) i/s  (297.41 ns/i) -     16.799M in   5.006339s
+Apply complex style (medium)
+                          3.337M (± 1.8%) i/s  (299.70 ns/i) -     16.838M in   5.047809s
+Apply complex style (long)
+                          3.027M (± 6.1%) i/s  (330.32 ns/i) -     15.171M in   5.032030s
+Apply hex style (short)
+                          2.473M (± 1.8%) i/s  (404.40 ns/i) -     12.581M in   5.089276s
+
+Comparison:
+Apply simple style (short):  4604142.2 i/s
+Apply simple style (medium):  3364580.5 i/s - 1.37x  slower
+Apply complex style (short):  3362358.4 i/s - 1.37x  slower
+Apply complex style (medium):  3336720.3 i/s - 1.38x  slower
+Apply simple style (long):  3070605.6 i/s - 1.50x  slower
+Apply complex style (long):  3027356.7 i/s - 1.52x  slower
+Apply hex style (short):  2472779.1 i/s - 1.86x  slower
+ Create simple style:    28349.6 i/s - 162.41x  slower
+Create complex style:    22956.2 i/s - 200.56x  slower
+
+
+Repeated Application Benchmark:
+----------------------------------------
+Applying the same style 1000 times to measure caching benefit...
+ruby 3.2.9 (2025-07-24 revision 8f611e0c46) [arm64-darwin24]
+Warming up --------------------------------------
+  1000x simple style   528.000 i/100ms
+ 1000x complex style   362.000 i/100ms
+     1000x hex style   238.000 i/100ms
+Calculating -------------------------------------
+  1000x simple style      5.013k (± 7.6%) i/s  (199.47 μs/i) -     25.344k in   5.092091s
+ 1000x complex style      3.694k (± 2.3%) i/s  (270.71 μs/i) -     18.462k in   5.000406s
+     1000x hex style      2.608k (± 5.6%) i/s  (383.40 μs/i) -     13.090k in   5.040010s
+
+Comparison:
+  1000x simple style:     5013.4 i/s
+ 1000x complex style:     3694.0 i/s - 1.36x  slower
+     1000x hex style:     2608.3 i/s - 1.92x  slower
+
+
+Object Allocation Analysis:
+----------------------------------------
+Create simple style: 117 objects allocated
+Create complex style: 136 objects allocated
+Apply simple style 100x: 104 objects allocated
+Apply complex style 100x: 104 objects allocated
+
+============================================================
+Benchmark complete!
+============================================================

data/benchmark/2025-09-08-style-caching-optimization/07_string_concatenation_comparison.txt

@@ -0,0 +1,66 @@
+STRING CONCATENATION METHOD COMPARISON
+======================================
+Date: 2025-09-08
+
+## Performance Comparison: String Interpolation vs << Operator
+
+### Method Implementations
+
+#### String Interpolation (Original)
+```ruby
+def call(text)
+  return text if @prefix.empty?
+  "#{@prefix}#{text}#{@reset_code}"
+end
+```
+
+#### << Operator (Experimental) 
+```ruby
+def call(text)
+  return text if @prefix.empty?
+  @prefix.dup << text << @reset_code
+end
+```
+
+### Performance Results (ops/second)
+
+| Style Type | String Interpolation | << Operator | Performance Loss |
+|------------|---------------------|-------------|------------------|
+| Simple     | 5.44M/s             | 4.55M/s     | **16% slower**   |
+| Complex    | 3.83M/s             | 3.35M/s     | **13% slower**   |
+| Hex Color  | 4.66M/s             | 2.45M/s     | **47% slower**   |
+
+### Memory Usage (per application)
+
+| Implementation | Simple Style | Complex Style |
+|----------------|-------------|---------------|
+| String Interpolation | 424 bytes, 3 objects | 264 bytes, 2 objects |
+| << Operator          | 424 bytes, 3 objects | 264 bytes, 2 objects |
+
+*Memory usage appears identical*
+
+### Analysis
+
+#### Why << Operator is Slower:
+
+1. **Extra Copy Cost**: `@prefix.dup` creates unnecessary string copy
+2. **Multiple Operations**: Three separate `<<` calls vs single interpolation
+3. **Ruby Optimization**: String interpolation is highly optimized in Ruby
+4. **Hex Colors Impact**: Most significant performance hit (47% slower)
+
+#### Performance Loss Breakdown:
+
+- **Simple styles**: 16% slower due to dup + concatenation overhead
+- **Complex styles**: 13% slower, similar pattern
+- **Hex colors**: 47% slower, suggests interpolation especially optimized for longer strings
+
+### Conclusion
+
+**String interpolation (`"#{a}#{b}#{c}"`) is definitively superior** for this use case:
+
+- Consistently faster across all style types
+- No additional memory allocation overhead  
+- Leverages Ruby's built-in string interpolation optimizations
+- Simpler, more readable code
+
+The experiment confirms that the original implementation choice was optimal. Ruby's string interpolation is highly optimized and should be preferred over manual concatenation methods for performance-critical string building operations.

data/benchmark/2025-09-08-style-caching-optimization/08_with_freeze_optimization_results.txt

@@ -0,0 +1,107 @@
+============================================================
+TIntMe Style Performance Benchmark
+============================================================
+
+Memory Usage Analysis:
+----------------------------------------
+Calculating -------------------------------------
+ Create simple style     6.056k memsize (     0.000  retained)
+                        58.000  objects (     0.000  retained)
+                         2.000  strings (     0.000  retained)
+Create complex style     7.752k memsize (     0.000  retained)
+                        79.000  objects (     0.000  retained)
+                         9.000  strings (     0.000  retained)
+Apply simple style (short text)
+                       424.000  memsize (     0.000  retained)
+                         3.000  objects (     0.000  retained)
+                         1.000  strings (     0.000  retained)
+Apply complex style (short text)
+                       264.000  memsize (     0.000  retained)
+                         2.000  objects (     0.000  retained)
+                         1.000  strings (     0.000  retained)
+
+Comparison:
+Apply complex style (short text):        264 allocated
+Apply simple style (short text):        424 allocated - 1.61x more
+ Create simple style:       6056 allocated - 22.94x more
+Create complex style:       7752 allocated - 29.36x more
+
+Performance Benchmark (operations per second):
+----------------------------------------
+ruby 3.2.9 (2025-07-24 revision 8f611e0c46) [arm64-darwin24]
+Warming up --------------------------------------
+ Create simple style     2.829k i/100ms
+Create complex style     2.405k i/100ms
+Apply simple style (short)
+                       551.851k i/100ms
+Apply simple style (medium)
+                       476.907k i/100ms
+Apply simple style (long)
+                       482.203k i/100ms
+Apply complex style (short)
+                       381.682k i/100ms
+Apply complex style (medium)
+                       455.559k i/100ms
+Apply complex style (long)
+                       417.965k i/100ms
+Apply hex style (short)
+                       470.351k i/100ms
+Calculating -------------------------------------
+ Create simple style     27.161k (± 6.4%) i/s   (36.82 μs/i) -    135.792k in   5.024378s
+Create complex style     23.009k (± 4.3%) i/s   (43.46 μs/i) -    115.440k in   5.027763s
+Apply simple style (short)
+                          5.264M (± 3.8%) i/s  (189.96 ns/i) -     26.489M in   5.039995s
+Apply simple style (medium)
+                          4.621M (± 3.1%) i/s  (216.40 ns/i) -     23.368M in   5.061823s
+Apply simple style (long)
+                          4.478M (± 4.8%) i/s  (223.34 ns/i) -     22.664M in   5.074611s
+Apply complex style (short)
+                          3.685M (± 2.4%) i/s  (271.36 ns/i) -     18.702M in   5.078168s
+Apply complex style (medium)
+                          4.536M (± 4.8%) i/s  (220.45 ns/i) -     22.778M in   5.036293s
+Apply complex style (long)
+                          4.271M (± 7.5%) i/s  (234.13 ns/i) -     21.316M in   5.031500s
+Apply hex style (short)
+                          4.558M (± 3.7%) i/s  (219.39 ns/i) -     23.047M in   5.063931s
+
+Comparison:
+Apply simple style (short):  5264329.5 i/s
+Apply simple style (medium):  4621101.0 i/s - 1.14x  slower
+Apply hex style (short):  4558064.1 i/s - 1.15x  slower
+Apply complex style (medium):  4536089.7 i/s - 1.16x  slower
+Apply simple style (long):  4477533.0 i/s - 1.18x  slower
+Apply complex style (long):  4271132.9 i/s - 1.23x  slower
+Apply complex style (short):  3685074.9 i/s - 1.43x  slower
+ Create simple style:    27161.3 i/s - 193.82x  slower
+Create complex style:    23008.5 i/s - 228.80x  slower
+
+
+Repeated Application Benchmark:
+----------------------------------------
+Applying the same style 1000 times to measure caching benefit...
+ruby 3.2.9 (2025-07-24 revision 8f611e0c46) [arm64-darwin24]
+Warming up --------------------------------------
+  1000x simple style   631.000 i/100ms
+ 1000x complex style   412.000 i/100ms
+     1000x hex style   540.000 i/100ms
+Calculating -------------------------------------
+  1000x simple style      6.203k (± 2.1%) i/s  (161.20 μs/i) -     31.550k in   5.088346s
+ 1000x complex style      4.119k (± 5.2%) i/s  (242.77 μs/i) -     20.600k in   5.018834s
+     1000x hex style      5.267k (± 2.8%) i/s  (189.85 μs/i) -     26.460k in   5.027249s
+
+Comparison:
+  1000x simple style:     6203.3 i/s
+     1000x hex style:     5267.4 i/s - 1.18x  slower
+ 1000x complex style:     4119.1 i/s - 1.51x  slower
+
+
+Object Allocation Analysis:
+----------------------------------------
+Create simple style: 117 objects allocated
+Create complex style: 136 objects allocated
+Apply simple style 100x: 103 objects allocated
+Apply complex style 100x: 103 objects allocated
+
+============================================================
+Benchmark complete!
+============================================================

data/benchmark/2025-09-08-style-caching-optimization/09_freeze_optimization_analysis.txt

@@ -0,0 +1,49 @@
+FREEZE OPTIMIZATION ANALYSIS
+=============================
+Date: 2025-09-08
+
+## Implementation Change
+
+Added `.freeze` to the cached prefix string:
+
+```ruby
+# Before
+@prefix = sgr_builder.prefix_codes(...) 
+
+# After  
+@prefix = sgr_builder.prefix_codes(...).freeze
+```
+
+## Performance Comparison
+
+| Style Type | Without freeze | With freeze | Difference |
+|------------|----------------|-------------|------------|
+| Simple     | 5.44M/s        | 5.26M/s     | **3% slower** |
+| Complex    | 3.83M/s        | 3.69M/s     | **4% slower** |  
+| Hex Color  | 4.66M/s        | 4.56M/s     | **2% slower** |
+
+## Analysis
+
+### Why freeze didn't help (and slightly hurt):
+
+1. **String interpolation doesn't modify strings**: The operation `"#{@prefix}#{text}#{@reset_code}"` creates a new string without modifying the original strings, so freeze protection isn't needed.
+
+2. **Freeze call overhead**: The `.freeze` method call during initialization adds slight overhead without providing benefits for this use case.
+
+3. **Data.define already provides immutability**: The Style instance itself is frozen after `super`, providing sufficient protection.
+
+4. **Memory allocation patterns unchanged**: Freeze doesn't affect how string interpolation allocates memory.
+
+### When freeze would be beneficial:
+
+- If we were doing destructive operations like `@prefix << something`
+- If the strings were being passed to untrusted code
+- If we needed to prevent accidental modification in other parts of the codebase
+
+## Conclusion
+
+**Remove the freeze optimization** - it provides no performance benefit and adds unnecessary overhead.
+
+The original implementation without explicit freezing is optimal for this use case. Ruby's string interpolation is already highly optimized and doesn't require the strings to be frozen for maximum performance.
+
+**Recommendation**: Revert to the non-frozen version for best performance.