# Understanding the EPatchType Enum in Wand-Enhancer: Core Architecture for Modular Patching

> Discover the significance of the EPatchType enum in Wand-Enhancer. This core architecture defines, configures, and executes all JavaScript patches for type-safe patching and validation.

- Repository: [k1tbyte/Wand-Enhancer](https://github.com/k1tbyte/Wand-Enhancer)
- Tags: architecture
- Published: 2026-09-01

---

**The `EPatchType` enum in Wand-Enhancer serves as the central declarative system that defines, configures, and executes all JavaScript patches to the Wand Electron application, enabling type-safe selection, mapping to concrete patch definitions, and validation of patch completion.**

The `EPatchType` enum in the [k1tbyte/Wand-Enhancer](https://github.com/k1tbyte/Wand-Enhancer) repository represents the foundational abstraction that drives the entire modification pipeline. This C# enumeration transforms the patching process from manual file editing into a structured, configurable workflow where each value corresponds to a distinct functional alteration of the original Wand application.

## What Is the EPatchType Enum?

Located in [`WandEnhancer/Models/PatchConfig.cs`](https://github.com/k1tbyte/Wand-Enhancer/blob/main/WandEnhancer/Models/PatchConfig.cs) at lines 9–15, the `EPatchType` enumeration defines five distinct modification types using bitwise flag values. This design allows the system to represent multiple simultaneous selections through a single `HashSet<EPatchType>` while maintaining compile-time type safety.

```csharp
public enum EPatchType
{
    ActivatePro = 1,
    DisableUpdates = 2,
    DisableTelemetry = 4,
    DevToolsOnF12 = 8,
    RemoteWebPanelPreview = 16
}

```

Each value represents a specific capability: **ActivatePro** unlocks premium features, **DisableUpdates** prevents automatic application updates, **DisableTelemetry** stops analytics collection, **DevToolsOnF12** enables Chrome Developer Tools via the F12 key, and **RemoteWebPanelPreview** activates remote web panel functionality. The powers-of-two values (1, 2, 4, 8, 16) follow the flag enum pattern, though the implementation primarily uses `HashSet<EPatchType>` for storage rather than bitwise operations.

## How EPatchType Drives the Patch Pipeline

The enum operates as the primary key throughout three critical phases of the enhancement process: user selection, definition mapping, and execution validation.

### User Selection and Configuration

The patch selection interface in [`WandEnhancer/View/Popups/PatchVectorsPopup.xaml.cs`](https://github.com/k1tbyte/Wand-Enhancer/blob/main/WandEnhancer/View/Popups/PatchVectorsPopup.xaml.cs) (lines 77–96) translates UI checkbox states into a strongly-typed `HashSet<EPatchType>`. This declarative approach ensures that only valid, predefined modifications can be selected.

```csharp
var selected = new HashSet<EPatchType>();
if (ActivateProBox.IsChecked == true) 
    selected.Add(EPatchType.ActivatePro);
if (DisableUpdatesBox.IsChecked == true) 
    selected.Add(EPatchType.DisableUpdates);
if (DevToolsOnF12Box.IsChecked == true) 
    selected.Add(EPatchType.DevToolsOnF12);
if (RemoteWebPanelPreviewBox.IsChecked == true) 
    selected.Add(EPatchType.RemoteWebPanelPreview);

var config = new PatchConfig 
{ 
    PatchTypes = selected, 
    AutoApplyPatches = false 
};

```

The `PatchConfig` class stores this selection in its `PatchTypes` property (lines 21–22 of [`PatchConfig.cs`](https://github.com/k1tbyte/Wand-Enhancer/blob/main/PatchConfig.cs)), creating a serializable configuration object that separates user intent from execution logic.

### Mapping to PatchEntry Definitions

The `EnhancerConfig.GetInstance()` method in [`WandEnhancer/Core/EnhancerConfig.cs`](https://github.com/k1tbyte/Wand-Enhancer/blob/main/WandEnhancer/Core/EnhancerConfig.cs) (lines 100–110) returns a comprehensive dictionary that maps each `EPatchType` value to one or more `PatchEntry` objects. This dictionary bridges the abstract enum values with concrete implementation details including regex patterns and JavaScript replacement code.

```csharp
return new Dictionary<EPatchType, PatchEntry[]>()
{
    { 
        EPatchType.ActivatePro, 
        new[] 
        { 
            new PatchEntry
            {
                SearchHints = new[] { "getUserAccount()", "/v3/account" },
                Resolver = new ResolveContext
                {
                    Handler = target => Regex.Match(target, @"return\s+this\.#(\w+)\.fetch").Groups[1].Value,
                    Placeholder = "<service_name>"
                },
                Name = "getUserAccount",
                Target = new Regex(@"getUserAccount\(\)\{.*?return\s+this\.#\w+\.fetch\(\{.*?\}\)\}", RegexOptions.Singleline),
                Patch = "getUserAccount(){return this.#<service_name>.fetch({endpoint:\"/v3/account\",method:\"GET\",name:\"/v3/account\",collectMetrics:0}).then(response=>{response.subscription={period:\"yearly\",state:\"active\"};return response;})}"
            }
        } 
    }
    // ... additional mappings
};

```

Each `PatchEntry` contains the **regex target**, **search hints** for locating the code block, and the **JavaScript patch** string to inject. This architecture isolates the modification logic from the enum definition, allowing engineers to update patch implementations without changing the public API.

### Execution and Validation

The `Enhancer` class in [`WandEnhancer/Core/Enhancer.cs`](https://github.com/k1tbyte/Wand-Enhancer/blob/main/WandEnhancer/Core/Enhancer.cs) orchestrates the actual file modification. Lines 33–55 demonstrate the engine iterating over the selected enum values, applying corresponding patches to the extracted Electron bundle files.

```csharp
var remainingPatches = new HashSet<EPatchType>(_config.PatchTypes);

foreach (var entry in remainingPatches.ToList())
{
    var patchEntries = enhancerConfig[entry];
    bool patchApplied = false;
    
    // Apply patches to target files
    data = ApplyJsPatch(item, data, patchEntry, entry, out patchApplied);
    
    if (patchApplied)
    {
        fileChanged = true;
        remainingPatches.Remove(entry);
    }
}

```

The engine maintains a `remainingPatches` tracking set to ensure complete application. Lines 73–78 implement the critical validation step: if any `EPatchType` values remain in the set after processing all files, the system throws an exception indicating the current Wand version lacks support for those specific modifications.

```csharp
if (remainingPatches.Count > 0)
    throw new Exception("[ENHANCER] Failed to apply patches: " + 
        string.Join(", ", remainingPatches));

```

## Architectural Benefits of the Enum-Based Design

The `EPatchType` enum provides three structural advantages that make Wand-Enhancer maintainable and extensible:

- **Separation of concerns**: The enum isolates *what* should be modified from *how* the modification occurs. UI components reference only the abstract type, while the `Enhancer` class handles file system operations and regex replacements.

- **Type-safe extensibility**: Adding new functionality requires only three steps: adding an enum value to [`PatchConfig.cs`](https://github.com/k1tbyte/Wand-Enhancer/blob/main/PatchConfig.cs), defining the corresponding `PatchEntry` array in [`EnhancerConfig.cs`](https://github.com/k1tbyte/Wand-Enhancer/blob/main/EnhancerConfig.cs), and optionally adding a UI checkbox. The compiler enforces exhaustiveness in `switch` statements and dictionary mappings.

- **Validation and safety**: By tracking unapplied patches through the `remainingPatches` mechanism, the system prevents partial modifications that could corrupt the application bundle or leave the user with inconsistent feature states.

## Working with EPatchType in Practice

### Selecting Patches Programmatically

When building custom tooling or automated workflows, you construct the configuration object directly using the enum values:

```csharp
var aggressiveConfig = new PatchConfig
{
    PatchTypes = new HashSet<EPatchType>
    {
        EPatchType.ActivatePro,
        EPatchType.DisableTelemetry,
        EPatchType.DisableUpdates
    },
    AutoApplyPatches = true
};

```

### Executing Individual Patch Types

During the enhancement process, the engine passes the specific `EPatchType` to the application method for logging and tracking purposes:

```csharp
bool wasApplied;
data = ApplyJsPatch(
    fileEntry: targetFile,
    content: bundleContent,
    patch: patchDefinition,
    type: EPatchType.DisableTelemetry,
    applied: out wasApplied
);

```

## Summary

- The `EPatchType` enum in [`PatchConfig.cs`](https://github.com/k1tbyte/Wand-Enhancer/blob/main/PatchConfig.cs) defines five distinct modification flags using powers-of-two values for potential bitwise operations, though the system primarily utilizes `HashSet<EPatchType>`.

- User selections in [`PatchVectorsPopup.xaml.cs`](https://github.com/k1tbyte/Wand-Enhancer/blob/main/PatchVectorsPopup.xaml.cs) compile into strongly-typed enum sets that populate the `PatchConfig.PatchTypes` property.

- [`EnhancerConfig.cs`](https://github.com/k1tbyte/Wand-Enhancer/blob/main/EnhancerConfig.cs) maps each enum value to concrete `PatchEntry` objects containing regex patterns and JavaScript replacement code.

- The [`Enhancer.cs`](https://github.com/k1tbyte/Wand-Enhancer/blob/main/Enhancer.cs) engine iterates through selected enum values, applies patches to bundle files, and validates completion via the `remainingPatches` tracking mechanism.

- The architecture supports safe extensibility by separating patch definition (enum), implementation (PatchEntry), and execution (Enhancer) into distinct layers.

## Frequently Asked Questions

### What does each EPatchType value represent?

**ActivatePro** unlocks premium subscription features by intercepting account API responses. **DisableUpdates** prevents the application from checking for or downloading new versions. **DisableTelemetry** stops analytics and usage data collection. **DevToolsOnF12** enables Chrome Developer Tools when pressing the F12 key. **RemoteWebPanelPreview** activates experimental remote web panel capabilities. Each value corresponds to a specific JavaScript injection target defined in [`EnhancerConfig.cs`](https://github.com/k1tbyte/Wand-Enhancer/blob/main/EnhancerConfig.cs).

### Why are the EPatchType values defined as powers of two?

The values (1, 2, 4, 8, 16) follow the traditional flag enum pattern allowing bitwise combination into a single integer. While Wand-Enhancer currently uses `HashSet<EPatchType>` for storage and iteration, the flag values preserve compatibility with bitwise operations for compact serialization or database storage scenarios. This pattern also visually distinguishes the enum as representing composable options rather than sequential states.

### How does Wand-Enhancer handle unsupported patches?

The system validates patch application through the `remainingPatches` HashSet in [`Enhancer.cs`](https://github.com/k1tbyte/Wand-Enhancer/blob/main/Enhancer.cs) (lines 73–78). If the engine cannot locate the target code patterns for a selected patch type in the extracted bundle files, that enum value remains in the set after processing completes. The code explicitly checks `if (remainingPatches.Count > 0)` and throws an exception listing the unapplied patches, preventing the tool from producing a partially modified or broken application bundle.

### Can developers extend EPatchType with custom patches?

Yes, the architecture supports extensibility through three specific modifications: First, add a new value to the `EPatchType` enum in [`PatchConfig.cs`](https://github.com/k1tbyte/Wand-Enhancer/blob/main/PatchConfig.cs). Second, define the corresponding `PatchEntry` array in the dictionary returned by `EnhancerConfig.GetInstance()`, including the target regex and replacement JavaScript. Third, expose the selection option in the UI by adding a checkbox to `PatchVectorsPopup.xaml` and handling its state in [`PatchVectorsPopup.xaml.cs`](https://github.com/k1tbyte/Wand-Enhancer/blob/main/PatchVectorsPopup.xaml.cs). The `Enhancer` engine automatically processes new enum values without requiring changes to the core execution logic.