refactor: simplify variable declarations and update cache builder references

Author: Mykyta Zotov

README.md

@@ -144,23 +144,17 @@ For detailed comparison and guidance, see `docs/storage-strategies.md`.
 
 ```csharp
 using SlidingWindowCache;
-using SlidingWindowCache.Configuration;
+using SlidingWindowCache.Public.Cache;
+using SlidingWindowCache.Public.Configuration;
 using Intervals.NET;
 using Intervals.NET.Domain.Default.Numeric;
 
-var options = new WindowCacheOptions(
-    leftCacheSize: 1.0,    // Cache 100% of requested range size to the left
-    rightCacheSize: 2.0,   // Cache 200% of requested range size to the right
-    leftThreshold: 0.2,    // Rebalance if <20% left buffer remains
-    rightThreshold: 0.2    // Rebalance if <20% right buffer remains
-);
-
-var cache = WindowCache<int, string, IntegerFixedStepDomain>.Create(
-    dataSource: myDataSource,
-    domain: new IntegerFixedStepDomain(),
-    options: options,
-    readMode: UserCacheReadMode.Snapshot
-);
+await using var cache = WindowCacheBuilder.For(myDataSource, new IntegerFixedStepDomain())
+    .WithOptions(o => o
+        .WithCacheSize(left: 1.0, right: 2.0)   // 100% left / 200% right of requested range
+        .WithReadMode(UserCacheReadMode.Snapshot)
+        .WithThresholds(0.2))                    // rebalance if <20% buffer remains
+    .Build();
 
 var result = await cache.GetDataAsync(Range.Closed(100, 200), cancellationToken);
 
@@ -495,8 +489,7 @@ This is the per-request programmatic alternative to the `UserRequestFullCacheHit
 For workloads with high-latency data sources, you can compose multiple `WindowCache` instances into a layered stack. Each layer uses the layer below it as its data source, allowing you to trade memory for reduced data-source I/O.
 
 ```csharp
-await using var cache = LayeredWindowCacheBuilder<int, byte[], IntegerFixedStepDomain>
-    .Create(realDataSource, domain)
+await using var cache = WindowCacheBuilder.Layered(realDataSource, domain)
     .AddLayer(new WindowCacheOptions(        // L2: deep background cache
         leftCacheSize: 10.0,
         rightCacheSize: 10.0,
@@ -547,8 +540,7 @@ layeredCache.UpdateRuntimeOptions(u => u.WithRightCacheSize(1.0));
 
 **Three-layer example:**
 ```csharp
-await using var cache = LayeredWindowCacheBuilder<int, byte[], IntegerFixedStepDomain>
-    .Create(realDataSource, domain)
+await using var cache = WindowCacheBuilder.Layered(realDataSource, domain)
     .AddLayer(l3Options)   // L3: 10× CopyOnRead — network/disk absorber
     .AddLayer(l2Options)   // L2: 2× CopyOnRead  — mid-level buffer
     .AddLayer(l1Options)   // L1: 0.5× Snapshot  — user-facing

docs/components/public-api.md

@@ -227,22 +227,21 @@ Typically created via `LayeredWindowCacheBuilder.Build()` rather than directly.
 
 ### LayeredWindowCacheBuilder\<TRange, TData, TDomain\>
 
-**File**: `src/SlidingWindowCache/Public/LayeredWindowCacheBuilder.cs`
+**File**: `src/SlidingWindowCache/Public/Cache/LayeredWindowCacheBuilder.cs`
 
 **Type**: `sealed class` — fluent builder
 
 ```csharp
-await using var cache = LayeredWindowCacheBuilder<int, byte[], IntegerFixedStepDomain>
-    .Create(realDataSource, domain)
+await using var cache = WindowCacheBuilder.Layered(realDataSource, domain)
     .AddLayer(deepOptions)   // L2: inner layer (CopyOnRead, large buffers)
     .AddLayer(userOptions)   // L1: outer layer (Snapshot, small buffers)
     .Build();
 ```
 
-- `Create(dataSource, domain)` — factory entry point; validates both `dataSource` and `domain` are not null.
-- `AddLayer(options, diagnostics?)` — adds a layer on top; first call = innermost layer, last call = outermost (user-facing).
-- `Build()` — constructs all `WindowCache` instances, wires them via `WindowCacheDataSourceAdapter`, and wraps them in `LayeredWindowCache`.
-- Throws `InvalidOperationException` from `Build()` if no layers were added.
+- Obtain an instance via `WindowCacheBuilder.Layered(dataSource, domain)` — enables full generic type inference.
+- `AddLayer(options, diagnostics?)` — adds a layer on top; first call = innermost layer, last call = outermost (user-facing). Also accepts `Action<WindowCacheOptionsBuilder>` for inline configuration.
+- `Build()` — constructs all `WindowCache` instances, wires them via `WindowCacheDataSourceAdapter`, and wraps them in `LayeredWindowCache`. Returns `IWindowCache<TRange, TData, TDomain>`; concrete type is `LayeredWindowCache<>`.
+- Throws `InvalidOperationException` from `Build()` if no layers were added, or if an inline delegate fails validation.
 
 **See**: `README.md` (Multi-Layer Cache section) and `docs/storage-strategies.md` for recommended layer configuration patterns.
 

docs/diagnostics.md

@@ -782,8 +782,7 @@ Pass a diagnostics instance as the second argument to `AddLayer`:
 var l2Diagnostics = new EventCounterCacheDiagnostics();
 var l1Diagnostics = new EventCounterCacheDiagnostics();
 
-await using var cache = LayeredWindowCacheBuilder<int, byte[], IntegerFixedStepDomain>
-    .Create(realDataSource, domain)
+await using var cache = WindowCacheBuilder.Layered(realDataSource, domain)
     .AddLayer(deepOptions, l2Diagnostics)   // L2: inner / deep layer
     .AddLayer(userOptions, l1Diagnostics)   // L1: outermost / user-facing layer
     .Build();

docs/glossary.md

@@ -163,7 +163,7 @@ WindowCacheDataSourceAdapter
 - Adapts an `IWindowCache` to the `IDataSource` interface, enabling it to act as the backing store for an outer `WindowCache`. This is the composition point for building layered caches. The adapter does not own the inner cache; ownership is managed by `LayeredWindowCache`. See `src/SlidingWindowCache/Public/WindowCacheDataSourceAdapter.cs`.
 
 LayeredWindowCacheBuilder
-- Fluent builder that wires `WindowCache` layers into a `LayeredWindowCache`. Layers are added bottom-up (deepest/innermost first, user-facing last). Each `AddLayer` call adds one `WindowCache` on top of the current stack. `Build()` returns a `LayeredWindowCache` that owns all layers. See `src/SlidingWindowCache/Public/LayeredWindowCacheBuilder.cs`.
+- Fluent builder that wires `WindowCache` layers into a `LayeredWindowCache`. Obtain an instance via `WindowCacheBuilder.Layered(dataSource, domain)`. Layers are added bottom-up (deepest/innermost first, user-facing last). Each `AddLayer` call accepts either a pre-built `WindowCacheOptions` or an `Action<WindowCacheOptionsBuilder>` for inline configuration. `Build()` returns `IWindowCache<>` (concrete type: `LayeredWindowCache<>`). See `src/SlidingWindowCache/Public/Cache/LayeredWindowCacheBuilder.cs`.
 
 LayeredWindowCache
 - A thin `IWindowCache` wrapper that owns a stack of `WindowCache` layers. Delegates `GetDataAsync` to the outermost layer. `WaitForIdleAsync` awaits all layers sequentially, outermost to innermost, ensuring full-stack convergence (required for correct behavior of `GetDataAndWaitForIdleAsync`). Disposes all layers outermost-first on `DisposeAsync`. Exposes `LayerCount` and `Layers`. See `src/SlidingWindowCache/Public/LayeredWindowCache.cs`.

docs/scenarios.md

@@ -438,8 +438,7 @@ from Lₙ's new window, and finally L1 expands from L2.
 var l2Diagnostics = new EventCounterCacheDiagnostics();
 var l1Diagnostics = new EventCounterCacheDiagnostics();
 
-await using var cache = LayeredWindowCacheBuilder<int, byte[], IntegerFixedStepDomain>
-    .Create(dataSource, domain)
+await using var cache = WindowCacheBuilder.Layered(dataSource, domain)
     .AddLayer(deepOptions,  l2Diagnostics)   // L2
     .AddLayer(userOptions,  l1Diagnostics)   // L1
     .Build();

docs/storage-strategies.md

@@ -205,8 +205,7 @@ The library provides built-in support for layered cache composition via `Layered
 
 ```csharp
 // Two-layer cache: L2 (CopyOnRead, large) → L1 (Snapshot, small)
-await using var cache = LayeredWindowCacheBuilder<int, byte[], IntegerFixedStepDomain>
-    .Create(slowDataSource, domain)      // real (bottom-most) data source
+await using var cache = WindowCacheBuilder.Layered(slowDataSource, domain)
     .AddLayer(new WindowCacheOptions(    // L2: deep background cache
         leftCacheSize: 10.0,
         rightCacheSize: 10.0,

src/SlidingWindowCache.WasmValidation/WasmCompilationValidator.cs

@@ -250,8 +250,8 @@ public static async Task ValidateConfiguration4_CopyOnReadMode_BoundedQueue()
     /// <para><strong>Types Validated:</strong></para>
     /// <list type="bullet">
     /// <item><description>
-/// <see cref="WindowCacheConsistencyExtensions.GetDataAndWaitForIdleAsync{TRange,TData,TDomain}"/> —
-/// strong consistency extension method; composes GetDataAsync + unconditional WaitForIdleAsync
+    /// <see cref="WindowCacheConsistencyExtensions.GetDataAndWaitForIdleAsync{TRange,TData,TDomain}"/> —
+    /// strong consistency extension method; composes GetDataAsync + unconditional WaitForIdleAsync
     /// </description></item>
     /// <item><description>
     /// The <c>try { await WaitForIdleAsync } catch (OperationCanceledException) { }</c> pattern
@@ -309,8 +309,8 @@ public static async Task ValidateStrongConsistencyMode_GetDataAndWaitForIdleAsyn
     /// <para><strong>Types Validated:</strong></para>
     /// <list type="bullet">
     /// <item><description>
-/// <see cref="WindowCacheConsistencyExtensions.GetDataAndWaitOnMissAsync{TRange,TData,TDomain}"/> —
-/// hybrid consistency extension method; composes GetDataAsync + conditional WaitForIdleAsync
+    /// <see cref="WindowCacheConsistencyExtensions.GetDataAndWaitOnMissAsync{TRange,TData,TDomain}"/> —
+    /// hybrid consistency extension method; composes GetDataAsync + conditional WaitForIdleAsync
     /// gated on <see cref="CacheInteraction"/>
     /// </description></item>
     /// <item><description>
@@ -424,19 +424,18 @@ public static async Task ValidateLayeredCache_TwoLayer_RecommendedConfig()
 
         // Build the layered cache — exercises LayeredWindowCacheBuilder,
         // WindowCacheDataSourceAdapter, and LayeredWindowCache
-        await using var cache = LayeredWindowCacheBuilder<int, int, IntegerFixedStepDomain>
-            .Create(new SimpleDataSource(), domain)
+        await using var layered = (LayeredWindowCache<int, int, IntegerFixedStepDomain>)WindowCacheBuilder.Layered(new SimpleDataSource(), domain)
             .AddLayer(innerOptions)
             .AddLayer(outerOptions)
             .Build();
 
         var range = Intervals.NET.Factories.Range.Closed<int>(0, 10);
-        var result = await cache.GetDataAsync(range, CancellationToken.None);
+        var result = await layered.GetDataAsync(range, CancellationToken.None);
 
         // WaitForIdleAsync on LayeredWindowCache awaits all layers (outermost to innermost)
-        await cache.WaitForIdleAsync();
+        await layered.WaitForIdleAsync();
 
         _ = result.Data.Length;
-        _ = cache.LayerCount;
+        _ = layered.LayerCount;
     }
 }

src/SlidingWindowCache/Core/Rebalance/Execution/CacheDataExtensionService.cs

@@ -88,7 +88,7 @@ CancellationToken cancellationToken
         _cacheDiagnostics.DataSourceFetchMissingSegments();
 
         // Step 1: Calculate which ranges are missing (and record the expansion/replacement diagnostic)
-        var missingRanges = CalculateMissingRanges(currentCache.Range, requested, out bool isCacheExpanded);
+        var missingRanges = CalculateMissingRanges(currentCache.Range, requested, out var isCacheExpanded);
 
         // Step 2: Record the diagnostic event here (caller context), not inside the pure helper
         if (isCacheExpanded)

src/SlidingWindowCache/Core/Rebalance/Intent/IntentController.cs

@@ -185,7 +185,7 @@ private async Task ProcessIntentsAsync()
             {
                 // Track whether we successfully consumed a semaphore signal
                 // This prevents activity counter imbalance when disposal cancels WaitAsync
-                bool consumedSignal = false;
+                var consumedSignal = false;
 
                 try
                 {