feat: Geutebruck GeViScope/GeViSoft Action Mapping System - MVP

This MVP release provides a complete full-stack solution for managing action mappings
in Geutebruck's GeViScope and GeViSoft video surveillance systems.

## Features

### Flutter Web Application (Port 8081)
- Modern, responsive UI for managing action mappings
- Action picker dialog with full parameter configuration
- Support for both GSC (GeViScope) and G-Core server actions
- Consistent UI for input and output actions with edit/delete capabilities
- Real-time action mapping creation, editing, and deletion
- Server categorization (GSC: prefix for GeViScope, G-Core: prefix for G-Core servers)

### FastAPI REST Backend (Port 8000)
- RESTful API for action mapping CRUD operations
- Action template service with comprehensive action catalog (247 actions)
- Server management (G-Core and GeViScope servers)
- Configuration tree reading and writing
- JWT authentication with role-based access control
- PostgreSQL database integration

### C# SDK Bridge (gRPC, Port 50051)
- Native integration with GeViSoft SDK (GeViProcAPINET_4_0.dll)
- Action mapping creation with correct binary format
- Support for GSC and G-Core action types
- Proper Camera parameter inclusion in action strings (fixes CrossSwitch bug)
- Action ID lookup table with server-specific action IDs
- Configuration reading/writing via SetupClient

## Bug Fixes
- **CrossSwitch Bug**: GSC and G-Core actions now correctly display camera/PTZ head parameters in GeViSet
- Action strings now include Camera parameter: `@ PanLeft (Comment: "", Camera: 101028)`
- Proper filter flags and VideoInput=0 for action mappings
- Correct action ID assignment (4198 for GSC, 9294 for G-Core PanLeft)

## Technical Stack
- **Frontend**: Flutter Web, Dart, Dio HTTP client
- **Backend**: Python FastAPI, PostgreSQL, Redis
- **SDK Bridge**: C# .NET 8.0, gRPC, GeViSoft SDK
- **Authentication**: JWT tokens
- **Configuration**: GeViSoft .set files (binary format)

## Credentials
- GeViSoft/GeViScope: username=sysadmin, password=masterkey
- Default admin: username=admin, password=admin123

## Deployment
All services run on localhost:
- Flutter Web: http://localhost:8081
- FastAPI: http://localhost:8000
- SDK Bridge gRPC: localhost:50051
- GeViServer: localhost (default port)

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

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

GeViSetEditor/GeViSetEditor.CLI/Commands/AnalyzeStructureCommand.cs

@@ -0,0 +1,74 @@
+using System;
+using System.IO;
+using System.Text.Json;
+using GeViSetEditor.Core.Parsers;
+
+namespace GeViSetEditor.CLI.Commands
+{
+    /// <summary>
+    /// Analyze binary structure to understand configuration format
+    /// </summary>
+    public static class AnalyzeStructureCommand
+    {
+        public static void Execute(string inputPath, string? outputReportPath = null)
+        {
+            if (!File.Exists(inputPath))
+            {
+                Console.WriteLine($"ERROR: File not found: {inputPath}");
+                return;
+            }
+
+            try
+            {
+                // Read file
+                byte[] data = File.ReadAllBytes(inputPath);
+                Console.WriteLine($"Analyzing: {inputPath}");
+                Console.WriteLine($"File size: {data.Length:N0} bytes");
+
+                // Run analysis
+                var analyzer = new AdvancedBinaryAnalyzer();
+                var report = analyzer.Analyze(data);
+
+                // Show summary
+                Console.WriteLine("\n=== Analysis Summary ===");
+                Console.WriteLine($"Header: '{report.Header}'");
+                Console.WriteLine($"Header ends at: {report.HeaderEndOffset} (0x{report.HeaderEndOffset:X})");
+                Console.WriteLine($"Sections identified: {report.Sections.Count}");
+
+                Console.WriteLine("\n=== Markers Found ===");
+                foreach (var marker in report.Markers)
+                {
+                    Console.WriteLine($"{marker.Key}: {marker.Value.Count} occurrences");
+                }
+
+                Console.WriteLine("\n=== Data Type Counts ===");
+                foreach (var type in report.DataTypeCounts)
+                {
+                    Console.WriteLine($"{type.Key}: {type.Value}");
+                }
+
+                // Export detailed report if requested
+                if (!string.IsNullOrEmpty(outputReportPath))
+                {
+                    var options = new JsonSerializerOptions
+                    {
+                        WriteIndented = true,
+                        PropertyNamingPolicy = JsonNamingPolicy.CamelCase
+                    };
+
+                    string json = JsonSerializer.Serialize(report, options);
+                    File.WriteAllText(outputReportPath, json);
+                    Console.WriteLine($"\nDetailed report saved to: {outputReportPath}");
+                }
+
+                Console.WriteLine("\n✓ Analysis complete!");
+
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"\n✗ ERROR: {ex.Message}");
+                Console.WriteLine($"Stack trace:\n{ex.StackTrace}");
+            }
+        }
+    }
+}

GeViSetEditor/GeViSetEditor.CLI/Commands/ComprehensiveParseCommand.cs

@@ -0,0 +1,92 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+using GeViSetEditor.Core.Parsers;
+
+namespace GeViSetEditor.CLI.Commands
+{
+    /// <summary>
+    /// Parse ALL configuration data comprehensively
+    /// </summary>
+    public static class ComprehensiveParseCommand
+    {
+        public static void Execute(string inputPath, string? outputJsonPath = null)
+        {
+            if (!File.Exists(inputPath))
+            {
+                Console.WriteLine($"ERROR: File not found: {inputPath}");
+                return;
+            }
+
+            try
+            {
+                // Read file
+                byte[] data = File.ReadAllBytes(inputPath);
+                Console.WriteLine($"Input: {inputPath}");
+                Console.WriteLine($"Size: {data.Length:N0} bytes");
+
+                // Parse with comprehensive parser
+                var parser = new ComprehensiveConfigParser();
+                var config = parser.Parse(data);
+
+                // Show sample properties
+                Console.WriteLine($"\n=== Sample Properties (first 20) ===");
+                foreach (var prop in config.Properties.Take(20))
+                {
+                    string valueStr = prop.Value?.ToString() ?? "null";
+                    if (valueStr.Length > 50)
+                        valueStr = valueStr.Substring(0, 47) + "...";
+                    Console.WriteLine($"  {prop.Name} = {valueStr} ({prop.ValueType})");
+                }
+
+                if (config.Properties.Count() > 20)
+                    Console.WriteLine($"  ... and {config.Properties.Count() - 20} more properties");
+
+                // Show Rules sections
+                Console.WriteLine($"\n=== Rules Sections (first 5) ===");
+                foreach (var rules in config.RulesSections.Take(5))
+                {
+                    if (rules.Value is List<string> actions)
+                    {
+                        Console.WriteLine($"\nRules at offset {rules.StartOffset}:");
+                        Console.WriteLine($"  Actions: {actions.Count}");
+                        foreach (var action in actions.Take(3))
+                        {
+                            Console.WriteLine($"    - {action}");
+                        }
+                        if (actions.Count > 3)
+                            Console.WriteLine($"    ... and {actions.Count - 3} more actions");
+                    }
+                }
+
+                // Export to JSON if requested
+                if (!string.IsNullOrEmpty(outputJsonPath))
+                {
+                    Console.WriteLine($"\n=== Exporting to JSON ===");
+
+                    var options = new JsonSerializerOptions
+                    {
+                        WriteIndented = true,
+                        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+                        Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping
+                    };
+
+                    string json = JsonSerializer.Serialize(config, options);
+                    File.WriteAllText(outputJsonPath, json);
+
+                    Console.WriteLine($"JSON written to: {outputJsonPath}");
+                    Console.WriteLine($"JSON size: {json.Length:N0} characters ({json.Length / 1024:N0} KB)");
+                }
+
+                Console.WriteLine("\n✓ Comprehensive parsing complete!");
+
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"\n✗ ERROR: {ex.Message}");
+                Console.WriteLine($"Stack trace:\n{ex.StackTrace}");
+            }
+        }
+    }
+}

GeViSetEditor/GeViSetEditor.CLI/Commands/EnhancedParseCommand.cs

@@ -0,0 +1,142 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using GeViSetEditor.Core.Models;
+using GeViSetEditor.Core.Parsers;
+
+namespace GeViSetEditor.CLI.Commands
+{
+    /// <summary>
+    /// Parse full configuration structure and export to JSON
+    /// </summary>
+    public static class EnhancedParseCommand
+    {
+        public static void Execute(string inputPath, string? outputJsonPath = null)
+        {
+            if (!File.Exists(inputPath))
+            {
+                Console.WriteLine($"ERROR: File not found: {inputPath}");
+                return;
+            }
+
+            try
+            {
+                // Read file
+                byte[] data = File.ReadAllBytes(inputPath);
+
+                // Parse with enhanced parser
+                var parser = new EnhancedSetFileParser();
+                var setFile = parser.Parse(data);
+
+                // Display results
+                Console.WriteLine("\n=== Full Configuration Structure ===");
+                Console.WriteLine($"File: {Path.GetFileName(inputPath)}");
+                Console.WriteLine($"Size: {setFile.FileSize:N0} bytes");
+                Console.WriteLine($"Header: '{setFile.Header}'\n");
+
+                // Show statistics
+                var stats = setFile.Statistics;
+                Console.WriteLine("=== Statistics ===");
+                Console.WriteLine($"Configuration Items: {stats.TotalConfigItems}");
+                Console.WriteLine($"Action Mappings: {stats.TotalActionMappings}");
+                Console.WriteLine($"Section Names: {stats.TotalSectionNames}");
+                Console.WriteLine($"Total Actions: {stats.TotalActions}");
+
+                if (stats.ConfigItemsByType.Count > 0)
+                {
+                    Console.WriteLine("\nConfig Items by Type:");
+                    foreach (var type in stats.ConfigItemsByType.OrderByDescending(kv => kv.Value))
+                    {
+                        Console.WriteLine($"  {type.Key}: {type.Value}");
+                    }
+                }
+
+                if (stats.ActionsPerMapping.Count > 0)
+                {
+                    Console.WriteLine("\nActions per Mapping:");
+                    foreach (var group in stats.ActionsPerMapping.OrderBy(kv => kv.Key))
+                    {
+                        Console.WriteLine($"  {group.Key} actions: {group.Value} mappings");
+                    }
+                }
+
+                // Show sample config items
+                if (setFile.ConfigItems.Count > 0)
+                {
+                    Console.WriteLine("\n=== Sample Config Items (first 10) ===");
+                    foreach (var item in setFile.ConfigItems.Take(10))
+                    {
+                        string valueStr = item.Value?.ToString() ?? "null";
+                        if (valueStr.Length > 50)
+                            valueStr = valueStr.Substring(0, 47) + "...";
+                        Console.WriteLine($"  {item.Key} = {valueStr} ({item.ValueType})");
+                    }
+                    if (setFile.ConfigItems.Count > 10)
+                        Console.WriteLine($"  ... and {setFile.ConfigItems.Count - 10} more");
+                }
+
+                // Show sample section names
+                if (setFile.SectionNames.Count > 0)
+                {
+                    Console.WriteLine("\n=== Section Names (top 20) ===");
+                    var topSections = setFile.SectionNames
+                        .GroupBy(s => s.Name)
+                        .OrderByDescending(g => g.Count())
+                        .Take(20);
+
+                    foreach (var group in topSections)
+                    {
+                        Console.WriteLine($"  {group.Key} ({group.Count()} occurrences)");
+                    }
+                }
+
+                // Show sample action mappings
+                if (setFile.ActionMappings.Count > 0)
+                {
+                    Console.WriteLine("\n=== Sample Action Mappings (first 5) ===");
+                    foreach (var mapping in setFile.ActionMappings.Take(5))
+                    {
+                        Console.WriteLine($"\nMapping at offset {mapping.FileOffset}:");
+                        Console.WriteLine($"  Actions ({mapping.Actions.Count}):");
+                        foreach (var action in mapping.Actions)
+                        {
+                            Console.WriteLine($"    - {action}");
+                        }
+                    }
+                    if (setFile.ActionMappings.Count > 5)
+                        Console.WriteLine($"\n  ... and {setFile.ActionMappings.Count - 5} more mappings");
+                }
+
+                // Export to JSON if requested
+                if (!string.IsNullOrEmpty(outputJsonPath))
+                {
+                    Console.WriteLine($"\n=== Exporting to JSON ===");
+
+                    var options = new JsonSerializerOptions
+                    {
+                        WriteIndented = true,
+                        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+                        DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
+                        Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping
+                    };
+
+                    string json = JsonSerializer.Serialize(setFile, options);
+                    File.WriteAllText(outputJsonPath, json);
+
+                    Console.WriteLine($"JSON written to: {outputJsonPath}");
+                    Console.WriteLine($"JSON size: {json.Length:N0} characters ({json.Length / 1024:N0} KB)");
+                }
+
+                Console.WriteLine("\n✓ Parsing complete!");
+
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"\n✗ ERROR: {ex.Message}");
+                Console.WriteLine($"Stack trace:\n{ex.StackTrace}");
+            }
+        }
+    }
+}

GeViSetEditor/GeViSetEditor.CLI/Commands/ExportJsonCommand.cs

@@ -0,0 +1,136 @@
+using System;
+using System.IO;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using GeViSetEditor.Core.Models;
+using GeViSetEditor.Core.Parsers;
+
+namespace GeViSetEditor.CLI.Commands
+{
+    /// <summary>
+    /// Export .set file to JSON format (action mappings + metadata)
+    /// Binary data is preserved for round-trip conversion
+    /// </summary>
+    public static class ExportJsonCommand
+    {
+        public static void Execute(string inputPath, string outputJsonPath)
+        {
+            Console.WriteLine("=== Export to JSON ===\n");
+
+            if (!File.Exists(inputPath))
+            {
+                Console.WriteLine($"ERROR: File not found: {inputPath}");
+                return;
+            }
+
+            try
+            {
+                // Parse with safe parser
+                byte[] data = File.ReadAllBytes(inputPath);
+                var parser = new SafeSetFileParser();
+                var setFile = parser.Parse(data);
+
+                Console.WriteLine($"\nFile: {inputPath}");
+                Console.WriteLine($"Size: {setFile.FileSize:N0} bytes");
+                Console.WriteLine($"Header: '{setFile.Header}'");
+                Console.WriteLine($"Action Mappings: {setFile.ActionMappings.Count}");
+
+                // Create JSON-friendly export model
+                var exportModel = new SetFileJsonExport
+                {
+                    Version = "1.0",
+                    SourceFile = Path.GetFileName(inputPath),
+                    FileSize = setFile.FileSize,
+                    Header = setFile.Header,
+                    ExportDate = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
+                    ActionMappings = setFile.ActionMappings.Select((m, index) => new ActionMappingJson
+                    {
+                        Id = index + 1,
+                        FileOffset = m.FileOffset,
+                        RulesMarkerOffset = m.RulesMarkerOffset,
+                        Actions = m.Actions.ToList(),
+                        TriggerConditions = m.TriggerConditions.ToDictionary(kv => kv.Key, kv => kv.Value)
+                    }).ToList()
+                };
+
+                // Serialize to JSON
+                var options = new JsonSerializerOptions
+                {
+                    WriteIndented = true,
+                    PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+                    DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
+                    Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping
+                };
+
+                string json = JsonSerializer.Serialize(exportModel, options);
+
+                // Write to file
+                File.WriteAllText(outputJsonPath, json);
+
+                Console.WriteLine($"\n✓ JSON exported successfully!");
+                Console.WriteLine($"Output: {outputJsonPath}");
+                Console.WriteLine($"JSON size: {json.Length:N0} characters ({json.Length / 1024:N0} KB)");
+
+                // Show statistics
+                Console.WriteLine($"\n=== Statistics ===");
+                Console.WriteLine($"Total mappings: {exportModel.ActionMappings.Count}");
+                Console.WriteLine($"Total actions: {exportModel.ActionMappings.Sum(m => m.Actions.Count)}");
+
+                var actionsPerMapping = exportModel.ActionMappings.GroupBy(m => m.Actions.Count);
+                Console.WriteLine($"\nActions per mapping:");
+                foreach (var group in actionsPerMapping.OrderBy(g => g.Key))
+                {
+                    Console.WriteLine($"  {group.Key} actions: {group.Count()} mappings");
+                }
+
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"\n✗ ERROR: {ex.Message}");
+                Console.WriteLine($"Stack trace:\n{ex.StackTrace}");
+            }
+        }
+    }
+
+    /// <summary>
+    /// JSON export model (without binary data)
+    /// </summary>
+    public class SetFileJsonExport
+    {
+        [JsonPropertyName("version")]
+        public string Version { get; set; }
+
+        [JsonPropertyName("sourceFile")]
+        public string SourceFile { get; set; }
+
+        [JsonPropertyName("exportDate")]
+        public string ExportDate { get; set; }
+
+        [JsonPropertyName("fileSize")]
+        public int FileSize { get; set; }
+
+        [JsonPropertyName("header")]
+        public string Header { get; set; }
+
+        [JsonPropertyName("actionMappings")]
+        public List<ActionMappingJson> ActionMappings { get; set; } = new();
+    }
+
+    public class ActionMappingJson
+    {
+        [JsonPropertyName("id")]
+        public int Id { get; set; }
+
+        [JsonPropertyName("fileOffset")]
+        public int FileOffset { get; set; }
+
+        [JsonPropertyName("rulesMarkerOffset")]
+        public int RulesMarkerOffset { get; set; }
+
+        [JsonPropertyName("actions")]
+        public List<string> Actions { get; set; } = new();
+
+        [JsonPropertyName("triggerConditions")]
+        public Dictionary<string, object> TriggerConditions { get; set; } = new();
+    }
+}

GeViSetEditor/GeViSetEditor.CLI/Commands/ModifyConfigCommand.cs

@@ -0,0 +1,249 @@
+using System;
+using System.IO;
+using System.Linq;
+using GeViSetEditor.Core.Parsers;
+using GeViSetEditor.Core.Models;
+
+namespace GeViSetEditor.CLI.Commands
+{
+    /// <summary>
+    /// Test modification capabilities: edit/add/delete configuration nodes
+    /// </summary>
+    public static class ModifyConfigCommand
+    {
+        public static void Execute(string inputPath, string outputPath = null)
+        {
+            if (!File.Exists(inputPath))
+            {
+                Console.WriteLine($"ERROR: File not found: {inputPath}");
+                return;
+            }
+
+            try
+            {
+                Console.WriteLine("=== Configuration Modification Test ===\n");
+
+                // Read and parse original file
+                byte[] originalData = File.ReadAllBytes(inputPath);
+                Console.WriteLine($"Input: {inputPath}");
+                Console.WriteLine($"Original size: {originalData.Length:N0} bytes\n");
+
+                var parser = new ComprehensiveConfigParser();
+                var config = parser.Parse(originalData);
+
+                Console.WriteLine($"Parsed {config.Statistics.TotalNodes:N0} nodes\n");
+
+                // Show original state
+                Console.WriteLine("=== Original Configuration (sample) ===");
+                ShowSampleNodes(config);
+
+                // Perform modifications
+                Console.WriteLine("\n=== Applying Modifications ===");
+                int modificationsCount = 0;
+
+                // 1. Modify some booleans
+                var booleans = config.RootNodes.Where(n => n.NodeType == "boolean").Take(3).ToList();
+                foreach (var node in booleans)
+                {
+                    bool oldValue = (bool)node.Value;
+                    node.Value = !oldValue;
+                    Console.WriteLine($"Modified boolean at offset {node.StartOffset}: {oldValue} → {node.Value}");
+                    modificationsCount++;
+                }
+
+                // 2. Modify some integers
+                var integers = config.RootNodes.Where(n => n.NodeType == "integer").Take(3).ToList();
+                foreach (var node in integers)
+                {
+                    int oldValue = (int)node.Value;
+                    node.Value = oldValue + 1000;
+                    Console.WriteLine($"Modified integer at offset {node.StartOffset}: {oldValue} → {node.Value}");
+                    modificationsCount++;
+                }
+
+                // 3. Modify some strings
+                var strings = config.RootNodes.Where(n => n.NodeType == "string" && !string.IsNullOrEmpty(n.Value?.ToString())).Take(2).ToList();
+                foreach (var node in strings)
+                {
+                    string oldValue = node.Value?.ToString() ?? "";
+                    node.Value = oldValue + "_MODIFIED";
+                    Console.WriteLine($"Modified string at offset {node.StartOffset}: '{oldValue}' → '{node.Value}'");
+                    modificationsCount++;
+                }
+
+                // 4. Add a new property
+                var newProperty = new ConfigNode
+                {
+                    NodeType = "property",
+                    Name = "TestProperty",
+                    Value = 12345,
+                    ValueType = "integer"
+                };
+                config.RootNodes.Add(newProperty);
+                Console.WriteLine($"Added new property: {newProperty.Name} = {newProperty.Value}");
+                modificationsCount++;
+
+                Console.WriteLine($"\nTotal modifications: {modificationsCount}");
+
+                // Apply modifications in-place (preserves binary structure)
+                Console.WriteLine("\n=== Applying In-Place Modifications ===");
+                byte[] modifiedData = config.GetDataForWriting();  // Get copy of original data
+                var inPlaceModifier = new InPlaceConfigModifier();
+
+                int appliedCount = 0;
+
+                // Apply boolean modifications
+                foreach (var node in booleans)
+                {
+                    if (inPlaceModifier.ModifyNode(modifiedData, node, node.Value))
+                    {
+                        Console.WriteLine($"✓ Applied boolean modification at offset {node.StartOffset}");
+                        appliedCount++;
+                    }
+                }
+
+                // Apply integer modifications
+                foreach (var node in integers)
+                {
+                    if (inPlaceModifier.ModifyNode(modifiedData, node, node.Value))
+                    {
+                        Console.WriteLine($"✓ Applied integer modification at offset {node.StartOffset}");
+                        appliedCount++;
+                    }
+                }
+
+                // Apply string modifications
+                foreach (var node in strings)
+                {
+                    if (inPlaceModifier.ModifyNode(modifiedData, node, node.Value))
+                    {
+                        Console.WriteLine($"✓ Applied string modification at offset {node.StartOffset}");
+                        appliedCount++;
+                    }
+                }
+
+                Console.WriteLine($"\n{appliedCount} out of {modificationsCount - 1} in-place modifications applied");
+                Console.WriteLine($"(Note: New property addition not supported in in-place mode)");
+
+                Console.WriteLine($"\nModified size: {modifiedData.Length:N0} bytes");
+                Console.WriteLine($"Size difference: {modifiedData.Length - originalData.Length:+#;-#;0} bytes (should be 0 for in-place)");
+
+                // Save to output file
+                string outputFilePath = outputPath ?? Path.Combine(
+                    Path.GetDirectoryName(inputPath),
+                    Path.GetFileNameWithoutExtension(inputPath) + "_modified" + Path.GetExtension(inputPath)
+                );
+
+                File.WriteAllBytes(outputFilePath, modifiedData);
+                Console.WriteLine($"Saved to: {outputFilePath}");
+
+                // Verify by parsing the modified file
+                Console.WriteLine("\n=== Verifying Modified File ===");
+                var verifyConfig = parser.Parse(modifiedData);
+
+                Console.WriteLine($"Parsed {verifyConfig.Statistics.TotalNodes:N0} nodes from modified file");
+
+                // Check if modifications persisted
+                Console.WriteLine("\n=== Verification Results ===");
+                int verifiedChanges = 0;
+                int expectedChanges = appliedCount;  // Only verify what was actually applied
+
+                // Check modified booleans
+                foreach (var originalNode in booleans)
+                {
+                    var modifiedNode = verifyConfig.RootNodes.FirstOrDefault(n =>
+                        n.NodeType == "boolean" && n.StartOffset == originalNode.StartOffset);
+
+                    if (modifiedNode != null && modifiedNode.Value.Equals(originalNode.Value))
+                    {
+                        Console.WriteLine($"✓ Boolean at {originalNode.StartOffset}: expected={originalNode.Value}, actual={modifiedNode.Value}");
+                        verifiedChanges++;
+                    }
+                    else
+                    {
+                        Console.WriteLine($"✗ Boolean at {originalNode.StartOffset}: expected={originalNode.Value}, actual={modifiedNode?.Value?.ToString() ?? "NOT FOUND"}");
+                    }
+                }
+
+                // Check modified integers
+                foreach (var originalNode in integers)
+                {
+                    var modifiedNode = verifyConfig.RootNodes.FirstOrDefault(n =>
+                        n.NodeType == "integer" && n.StartOffset == originalNode.StartOffset);
+
+                    if (modifiedNode != null && modifiedNode.Value.Equals(originalNode.Value))
+                    {
+                        Console.WriteLine($"✓ Integer at {originalNode.StartOffset}: expected={originalNode.Value}, actual={modifiedNode.Value}");
+                        verifiedChanges++;
+                    }
+                    else
+                    {
+                        Console.WriteLine($"✗ Integer at {originalNode.StartOffset}: expected={originalNode.Value}, actual={modifiedNode?.Value?.ToString() ?? "NOT FOUND"}");
+                    }
+                }
+
+                // Check modified strings
+                foreach (var originalNode in strings)
+                {
+                    var modifiedNode = verifyConfig.RootNodes.FirstOrDefault(n =>
+                        n.NodeType == "string" && n.StartOffset == originalNode.StartOffset);
+
+                    if (modifiedNode != null && modifiedNode.Value?.ToString() == originalNode.Value?.ToString())
+                    {
+                        string displayValue = originalNode.Value?.ToString() ?? "";
+                        if (displayValue.Length > 30)
+                            displayValue = displayValue.Substring(0, 27) + "...";
+                        Console.WriteLine($"✓ String at {originalNode.StartOffset}: '{displayValue}'");
+                        verifiedChanges++;
+                    }
+                    else
+                    {
+                        Console.WriteLine($"✗ String at {originalNode.StartOffset}: VERIFICATION FAILED");
+                    }
+                }
+
+                Console.WriteLine($"\n{verifiedChanges}/{expectedChanges} modifications verified successfully!");
+
+                if (verifiedChanges == expectedChanges)
+                {
+                    Console.WriteLine("\n✓ All in-place modifications applied and verified successfully!");
+                    Console.WriteLine($"Modified file saved to: {outputFilePath}");
+                    Console.WriteLine($"\nFile size preserved: {modifiedData.Length:N0} bytes (in-place modification)");
+                }
+                else
+                {
+                    Console.WriteLine($"\n⚠ Some modifications could not be verified! ({verifiedChanges}/{expectedChanges})");
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"\n✗ ERROR: {ex.Message}");
+                Console.WriteLine($"Stack trace:\n{ex.StackTrace}");
+            }
+        }
+
+        private static void ShowSampleNodes(ComprehensiveConfigFile config)
+        {
+            Console.WriteLine("First 5 booleans:");
+            foreach (var node in config.RootNodes.Where(n => n.NodeType == "boolean").Take(5))
+            {
+                Console.WriteLine($"  Offset {node.StartOffset}: {node.Value}");
+            }
+
+            Console.WriteLine("\nFirst 5 integers:");
+            foreach (var node in config.RootNodes.Where(n => n.NodeType == "integer").Take(5))
+            {
+                Console.WriteLine($"  Offset {node.StartOffset}: {node.Value}");
+            }
+
+            Console.WriteLine("\nFirst 5 strings:");
+            foreach (var node in config.RootNodes.Where(n => n.NodeType == "string").Take(5))
+            {
+                string value = node.Value?.ToString() ?? "null";
+                if (value.Length > 40)
+                    value = value.Substring(0, 37) + "...";
+                Console.WriteLine($"  Offset {node.StartOffset}: '{value}'");
+            }
+        }
+    }
+}

GeViSetEditor/GeViSetEditor.CLI/Commands/ParseCompleteCommand.cs

@@ -0,0 +1,112 @@
+using System;
+using System.IO;
+using System.Text.Json;
+using GeViSetEditor.Core.Models;
+using GeViSetEditor.Core.Parsers;
+
+namespace GeViSetEditor.CLI.Commands
+{
+    /// <summary>
+    /// Test complete binary parser - parses ENTIRE structure
+    /// </summary>
+    public static class ParseCompleteCommand
+    {
+        public static void Execute(string inputPath, string? outputJsonPath = null)
+        {
+            Console.WriteLine("=== Complete Binary Parser Test ===\n");
+
+            if (!File.Exists(inputPath))
+            {
+                Console.WriteLine($"ERROR: File not found: {inputPath}");
+                return;
+            }
+
+            try
+            {
+                // Read file
+                byte[] data = File.ReadAllBytes(inputPath);
+                Console.WriteLine($"Read file: {inputPath}");
+                Console.WriteLine($"File size: {data.Length:N0} bytes\n");
+
+                // Parse with complete parser
+                var parser = new CompleteBinaryParser();
+                var setFile = parser.Parse(data);
+
+                // Display results
+                Console.WriteLine("\n=== Parse Results ===");
+                Console.WriteLine($"Header: '{setFile.Header}'");
+                Console.WriteLine($"Sections: {setFile.Sections.Count}");
+                Console.WriteLine($"Total Items: {setFile.Statistics.TotalItems}");
+                Console.WriteLine($"Total Rules: {setFile.Statistics.TotalRules}");
+                Console.WriteLine($"Total Actions: {setFile.Statistics.TotalActions}");
+
+                Console.WriteLine("\n=== Section Breakdown ===");
+                foreach (var sectionType in setFile.Statistics.SectionTypes.OrderByDescending(x => x.Value))
+                {
+                    Console.WriteLine($"  {sectionType.Key}: {sectionType.Value} occurrences");
+                }
+
+                // Show first few sections in detail
+                Console.WriteLine("\n=== First 10 Sections (Detail) ===");
+                foreach (var section in setFile.Sections.Take(10))
+                {
+                    Console.WriteLine($"\nSection: '{section.Name}'");
+                    Console.WriteLine($"  Offset: {section.FileOffset} - {section.FileEndOffset} ({section.ByteSize} bytes)");
+                    Console.WriteLine($"  Items: {section.Items.Count}, Rules: {section.Rules.Count}");
+
+                    if (section.Items.Count > 0)
+                    {
+                        Console.WriteLine("  Sample items:");
+                        foreach (var item in section.Items.Take(3))
+                        {
+                            Console.WriteLine($"    {item.Key} = {item.Value} ({item.ValueType})");
+                        }
+                        if (section.Items.Count > 3)
+                        {
+                            Console.WriteLine($"    ... and {section.Items.Count - 3} more");
+                        }
+                    }
+
+                    if (section.Rules.Count > 0)
+                    {
+                        Console.WriteLine("  Sample rules:");
+                        foreach (var rule in section.Rules.Take(2))
+                        {
+                            Console.WriteLine($"    Rule #{rule.RuleId}: {rule.Actions.Count} actions");
+                            foreach (var action in rule.Actions.Take(2))
+                            {
+                                Console.WriteLine($"      - {action}");
+                            }
+                        }
+                    }
+                }
+
+                // Export to JSON if requested
+                if (!string.IsNullOrEmpty(outputJsonPath))
+                {
+                    Console.WriteLine($"\n=== Exporting to JSON ===");
+
+                    var options = new JsonSerializerOptions
+                    {
+                        WriteIndented = true,
+                        PropertyNamingPolicy = JsonNamingPolicy.CamelCase
+                    };
+
+                    string json = JsonSerializer.Serialize(setFile, options);
+                    File.WriteAllText(outputJsonPath, json);
+
+                    Console.WriteLine($"JSON written to: {outputJsonPath}");
+                    Console.WriteLine($"JSON size: {json.Length:N0} characters");
+                }
+
+                Console.WriteLine("\n✓ Parsing complete!");
+
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"\n✗ ERROR: {ex.Message}");
+                Console.WriteLine($"Stack trace:\n{ex.StackTrace}");
+            }
+        }
+    }
+}

GeViSetEditor/GeViSetEditor.CLI/Commands/TestRoundTripCommand.cs

@@ -0,0 +1,97 @@
+using System;
+using System.IO;
+using GeViSetEditor.Core.Parsers;
+using GeViSetEditor.Core.Writers;
+
+namespace GeViSetEditor.CLI.Commands
+{
+    public static class TestRoundTripCommand
+    {
+        public static void Execute(string inputPath)
+        {
+            Console.WriteLine("=== Round-Trip Conversion Test ===\n");
+
+            if (!File.Exists(inputPath))
+            {
+                Console.WriteLine($"Error: File not found: {inputPath}");
+                return;
+            }
+
+            try
+            {
+                // Step 1: Read original file
+                Console.WriteLine($"Step 1: Reading original file...");
+                byte[] originalData = File.ReadAllBytes(inputPath);
+                Console.WriteLine($"  Read {originalData.Length} bytes\n");
+
+                // Step 2: Parse with safe parser
+                Console.WriteLine($"Step 2: Parsing file...");
+                var parser = new SafeSetFileParser();
+                var setFile = parser.Parse(originalData);
+                Console.WriteLine($"  Parsed successfully");
+                Console.WriteLine($"  Found {setFile.ActionMappings.Count} action mappings\n");
+
+                // Step 3: Write back
+                Console.WriteLine($"Step 3: Writing file back...");
+                var writer = new SafeSetFileWriter();
+                byte[] outputData = writer.Write(setFile);
+                Console.WriteLine($"  Written {outputData.Length} bytes\n");
+
+                // Step 4: Compare
+                Console.WriteLine($"Step 4: Comparing original vs output...");
+                var comparison = writer.Compare(originalData, outputData);
+
+                if (comparison.IsIdentical)
+                {
+                    Console.WriteLine("\n✓✓✓ SUCCESS! Round-trip conversion is PERFECT!");
+                    Console.WriteLine("    Original and output files are byte-for-byte identical.");
+                    Console.WriteLine("    Safe to write back to GeViServer!");
+                }
+                else
+                {
+                    Console.WriteLine($"\n✗✗✗ WARNING! Files differ in {comparison.DifferentBytes} bytes");
+                    Console.WriteLine("\nFirst differences:");
+                    foreach (var diff in comparison.Differences)
+                    {
+                        Console.WriteLine($"  {diff}");
+                    }
+                    Console.WriteLine("\n!!! DO NOT write to server until this is fixed !!!");
+                }
+
+                // Step 5: Show extracted action mappings
+                Console.WriteLine($"\n" + new string('=', 70));
+                Console.WriteLine("EXTRACTED ACTION MAPPINGS");
+                Console.WriteLine(new string('=', 70));
+
+                int count = 0;
+                foreach (var mapping in setFile.ActionMappings)
+                {
+                    count++;
+                    Console.WriteLine($"\nMapping #{count} at offset {mapping.FileOffset}:");
+                    Console.WriteLine($"  Actions ({mapping.Actions.Count}):");
+
+                    int actionNum = 0;
+                    foreach (var action in mapping.Actions)
+                    {
+                        actionNum++;
+                        Console.WriteLine($"    {actionNum}. {action}");
+                        if (actionNum >= 5 && mapping.Actions.Count > 5)
+                        {
+                            Console.WriteLine($"    ... and {mapping.Actions.Count - 5} more");
+                            break;
+                        }
+                    }
+                }
+
+                Console.WriteLine($"\n" + new string('=', 70));
+                Console.WriteLine($"Total: {setFile.ActionMappings.Count} mappings");
+                Console.WriteLine(new string('=', 70));
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"\n✗✗✗ ERROR: {ex.Message}");
+                Console.WriteLine($"Stack trace: {ex.StackTrace}");
+            }
+        }
+    }
+}

GeViSetEditor/GeViSetEditor.CLI/GeViSetEditor.CLI.csproj

@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <ItemGroup>
+    <ProjectReference Include="..\GeViSetEditor.Core\GeViSetEditor.Core.csproj" />
+  </ItemGroup>
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+</Project>

GeViSetEditor/GeViSetEditor.CLI/Program.cs

@@ -0,0 +1,244 @@
+using System;
+using System.Linq;
+using GeViSetEditor.Core.Parsers;
+using GeViSetEditor.Core.Models;
+using GeViSetEditor.CLI.Commands;
+
+namespace GeViSetEditor.CLI
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            Console.WriteLine("=== GeViSet Configuration Editor ===\n");
+
+            if (args.Length == 0)
+            {
+                ShowHelp();
+                return;
+            }
+
+            string command = args[0].ToLower();
+
+            try
+            {
+                switch (command)
+                {
+                    case "view":
+                    case "parse":
+                        if (args.Length < 2)
+                        {
+                            Console.WriteLine("Usage: GeViSetEditor view <input.set>");
+                            return;
+                        }
+                        ViewSetFile(args[1]);
+                        break;
+
+                    case "export":
+                        if (args.Length < 3)
+                        {
+                            Console.WriteLine("Usage: GeViSetEditor export <input.set> <output.xlsx>");
+                            return;
+                        }
+                        ExportToExcel(args[1], args[2]);
+                        break;
+
+                    case "import":
+                        if (args.Length < 3)
+                        {
+                            Console.WriteLine("Usage: GeViSetEditor import <input.xlsx> <output.set>");
+                            return;
+                        }
+                        ImportFromExcel(args[1], args[2]);
+                        break;
+
+                    case "test-roundtrip":
+                    case "test":
+                        if (args.Length < 2)
+                        {
+                            Console.WriteLine("Usage: GeViSetEditor test-roundtrip <input.set>");
+                            return;
+                        }
+                        TestRoundTripCommand.Execute(args[1]);
+                        break;
+
+                    case "parse-complete":
+                    case "full":
+                        if (args.Length < 2)
+                        {
+                            Console.WriteLine("Usage: GeViSetEditor parse-complete <input.set> [output.json]");
+                            return;
+                        }
+                        string jsonOutput = args.Length >= 3 ? args[2] : null;
+                        ParseCompleteCommand.Execute(args[1], jsonOutput);
+                        break;
+
+                    case "to-json":
+                    case "json":
+                        if (args.Length < 3)
+                        {
+                            Console.WriteLine("Usage: GeViSetEditor to-json <input.set> <output.json>");
+                            return;
+                        }
+                        ExportJsonCommand.Execute(args[1], args[2]);
+                        break;
+
+                    case "enhanced":
+                    case "full-parse":
+                        if (args.Length < 2)
+                        {
+                            Console.WriteLine("Usage: GeViSetEditor enhanced <input.set> [output.json]");
+                            return;
+                        }
+                        string enhancedOutput = args.Length >= 3 ? args[2] : null;
+                        EnhancedParseCommand.Execute(args[1], enhancedOutput);
+                        break;
+
+                    case "analyze":
+                    case "inspect":
+                        if (args.Length < 2)
+                        {
+                            Console.WriteLine("Usage: GeViSetEditor analyze <input.set> [report.json]");
+                            return;
+                        }
+                        string reportOutput = args.Length >= 3 ? args[2] : null;
+                        AnalyzeStructureCommand.Execute(args[1], reportOutput);
+                        break;
+
+                    case "comprehensive":
+                    case "all":
+                        if (args.Length < 2)
+                        {
+                            Console.WriteLine("Usage: GeViSetEditor comprehensive <input.set> [output.json]");
+                            return;
+                        }
+                        string comprehensiveOutput = args.Length >= 3 ? args[2] : null;
+                        ComprehensiveParseCommand.Execute(args[1], comprehensiveOutput);
+                        break;
+
+                    case "modify":
+                    case "edit":
+                        if (args.Length < 2)
+                        {
+                            Console.WriteLine("Usage: GeViSetEditor modify <input.set> [output.set]");
+                            return;
+                        }
+                        string modifyOutput = args.Length >= 3 ? args[2] : null;
+                        ModifyConfigCommand.Execute(args[1], modifyOutput);
+                        break;
+
+                    default:
+                        Console.WriteLine($"Unknown command: {command}");
+                        ShowHelp();
+                        break;
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"\n❌ Error: {ex.Message}");
+                Console.WriteLine($"\nStack trace:\n{ex.StackTrace}");
+            }
+        }
+
+        static void ShowHelp()
+        {
+            Console.WriteLine("Commands:");
+            Console.WriteLine("  view <input.set>                      - View configuration and action mappings");
+            Console.WriteLine("  test-roundtrip <input.set>            - Test read/write safety (IMPORTANT!)");
+            Console.WriteLine("  comprehensive <input.set> [out.json]  - Parse ALL config data (19K+ nodes)");
+            Console.WriteLine("  modify <input.set> [output.set]       - Test edit/add/delete operations");
+            Console.WriteLine("  to-json <input.set> <output.json>     - Export action mappings to JSON");
+            Console.WriteLine("  export <input.set> <output.xlsx>      - Export to Excel for editing");
+            Console.WriteLine("  import <input.xlsx> <output.set>      - Import from Excel to .set file");
+            Console.WriteLine("\nExamples:");
+            Console.WriteLine("  GeViSetEditor test-roundtrip TestMKS.set");
+            Console.WriteLine("  GeViSetEditor enhanced TestMKS.set full_config.json");
+            Console.WriteLine("  GeViSetEditor to-json TestMKS.set mappings.json");
+            Console.WriteLine("  GeViSetEditor view TestMKS.set");
+            Console.WriteLine("  GeViSetEditor export TestMKS.set mappings.xlsx");
+        }
+
+        static void ViewSetFile(string inputPath)
+        {
+            Console.WriteLine($"Parsing: {inputPath}\n");
+
+            var parser = new SetFileParser();
+            var config = parser.Parse(inputPath);
+
+            Console.WriteLine("\n" + new string('=', 70));
+            Console.WriteLine("CONFIGURATION SUMMARY");
+            Console.WriteLine(new string('=', 70) + "\n");
+
+            int totalRules = 0;
+            int totalVariations = 0;
+
+            foreach (var section in config.Sections)
+            {
+                if (section.Rules.Count > 0)
+                {
+                    Console.WriteLine($"\n{section.Name}:");
+                    Console.WriteLine(new string('-', 50));
+
+                    foreach (var rule in section.Rules)
+                    {
+                        totalRules++;
+                        totalVariations += rule.ActionVariations.Count;
+
+                        Console.WriteLine($"\n  Rule #{rule.RuleId}:");
+
+                        // Show triggers
+                        var activeTriggers = rule.TriggerProperties.Where(kv => kv.Value).ToList();
+                        if (activeTriggers.Any())
+                        {
+                            Console.WriteLine($"    Triggers: {string.Join(", ", activeTriggers.Select(t => t.Key))}");
+                        }
+
+                        // Show main action
+                        if (!string.IsNullOrEmpty(rule.MainAction))
+                        {
+                            Console.WriteLine($"    Action: {rule.MainAction}");
+                        }
+
+                        // Show variations
+                        if (rule.ActionVariations.Count > 0)
+                        {
+                            Console.WriteLine($"    Variations ({rule.ActionVariations.Count}):");
+                            foreach (var variation in rule.ActionVariations)
+                            {
+                                Console.WriteLine($"      [{variation.VariationId}] {variation.ActionString}");
+                                if (!string.IsNullOrEmpty(variation.ActionType))
+                                {
+                                    Console.WriteLine($"          Type: {variation.ActionType}");
+                                }
+                                if (!string.IsNullOrEmpty(variation.FullCommand))
+                                {
+                                    Console.WriteLine($"          Command: {variation.FullCommand}");
+                                }
+                                if (!string.IsNullOrEmpty(variation.ServerName))
+                                {
+                                    Console.WriteLine($"          Server: {variation.ServerName}");
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            Console.WriteLine("\n" + new string('=', 70));
+            Console.WriteLine($"Total: {totalRules} rules, {totalVariations} variations");
+            Console.WriteLine(new string('=', 70));
+        }
+
+        static void ExportToExcel(string inputPath, string outputPath)
+        {
+            Console.WriteLine("Excel export not yet implemented.");
+            Console.WriteLine("Will be added in next step with EPPlus library.");
+        }
+
+        static void ImportFromExcel(string inputPath, string outputPath)
+        {
+            Console.WriteLine("Excel import not yet implemented.");
+            Console.WriteLine("Will be added after export functionality.");
+        }
+    }
+}

GeViSetEditor/GeViSetEditor.Core/GeViSetEditor.Core.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="EPPlus" Version="7.0.0" />
+  </ItemGroup>
+
+</Project>

GeViSetEditor/GeViSetEditor.Core/Models/ComprehensiveConfigFile.cs

@@ -0,0 +1,120 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.Json.Serialization;
+
+namespace GeViSetEditor.Core.Models
+{
+    /// <summary>
+    /// Complete representation of ALL configuration data in .set file
+    /// </summary>
+    public class ComprehensiveConfigFile
+    {
+        [JsonIgnore]
+        public byte[] OriginalData { get; set; }
+
+        [JsonPropertyName("fileSize")]
+        public int FileSize { get; set; }
+
+        [JsonPropertyName("header")]
+        public string Header { get; set; } = "";
+
+        [JsonPropertyName("headerNullPrefix")]
+        public bool HeaderNullPrefix { get; set; }
+
+        [JsonPropertyName("rootNodes")]
+        public List<ConfigNode> RootNodes { get; set; } = new();
+
+        [JsonPropertyName("statistics")]
+        public ComprehensiveConfigStatistics Statistics { get; set; }
+
+        /// <summary>
+        /// Get all properties (name-value pairs)
+        /// </summary>
+        [JsonIgnore]
+        public IEnumerable<ConfigNode> Properties =>
+            RootNodes.Where(n => n.NodeType == "property");
+
+        /// <summary>
+        /// Get all Rules markers with their actions
+        /// </summary>
+        [JsonIgnore]
+        public IEnumerable<ConfigNode> RulesSections =>
+            RootNodes.Where(n => n.NodeType == "marker" && n.Name == "Rules");
+
+        /// <summary>
+        /// Get property by name
+        /// </summary>
+        public IEnumerable<ConfigNode> GetProperties(string name) =>
+            Properties.Where(p => p.Name == name);
+
+        /// <summary>
+        /// Get copy of original data for writing
+        /// </summary>
+        public byte[] GetDataForWriting()
+        {
+            byte[] copy = new byte[OriginalData.Length];
+            System.Array.Copy(OriginalData, copy, OriginalData.Length);
+            return copy;
+        }
+    }
+
+    /// <summary>
+    /// A node in the configuration tree
+    /// </summary>
+    public class ConfigNode
+    {
+        [JsonPropertyName("startOffset")]
+        public int StartOffset { get; set; }
+
+        [JsonPropertyName("endOffset")]
+        public int EndOffset { get; set; }
+
+        [JsonPropertyName("nodeType")]
+        public string NodeType { get; set; } = "";
+
+        [JsonPropertyName("name")]
+        public string? Name { get; set; }
+
+        [JsonPropertyName("value")]
+        public object? Value { get; set; }
+
+        [JsonPropertyName("valueType")]
+        public string? ValueType { get; set; }
+
+        [JsonPropertyName("children")]
+        public List<ConfigNode> Children { get; set; } = new();
+
+        /// <summary>
+        /// Size in bytes
+        /// </summary>
+        [JsonIgnore]
+        public int Size => EndOffset - StartOffset;
+    }
+
+    /// <summary>
+    /// Statistics about parsed configuration (comprehensive version)
+    /// </summary>
+    public class ComprehensiveConfigStatistics
+    {
+        [JsonPropertyName("totalNodes")]
+        public int TotalNodes { get; set; }
+
+        [JsonPropertyName("propertyCount")]
+        public int PropertyCount { get; set; }
+
+        [JsonPropertyName("booleanCount")]
+        public int BooleanCount { get; set; }
+
+        [JsonPropertyName("integerCount")]
+        public int IntegerCount { get; set; }
+
+        [JsonPropertyName("stringCount")]
+        public int StringCount { get; set; }
+
+        [JsonPropertyName("markerCount")]
+        public int MarkerCount { get; set; }
+
+        [JsonPropertyName("rulesCount")]
+        public int RulesCount { get; set; }
+    }
+}

GeViSetEditor/GeViSetEditor.Core/Models/EnhancedSetFile.cs

@@ -0,0 +1,134 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.Json.Serialization;
+
+namespace GeViSetEditor.Core.Models
+{
+    /// <summary>
+    /// Enhanced representation of .set file with full configuration structure
+    /// Preserves original binary data while exposing parsed configuration
+    /// </summary>
+    public class EnhancedSetFile
+    {
+        /// <summary>
+        /// Complete original file data - preserved for round-trip
+        /// </summary>
+        [JsonIgnore]
+        public byte[] OriginalData { get; set; }
+
+        /// <summary>
+        /// File size in bytes
+        /// </summary>
+        [JsonPropertyName("fileSize")]
+        public int FileSize { get; set; }
+
+        /// <summary>
+        /// Header string (usually "GeViSoft Parameters")
+        /// </summary>
+        [JsonPropertyName("header")]
+        public string Header { get; set; } = "";
+
+        /// <summary>
+        /// Configuration items (key-value pairs)
+        /// </summary>
+        [JsonPropertyName("configItems")]
+        public List<ConfigItemEntry> ConfigItems { get; set; } = new();
+
+        /// <summary>
+        /// Action mappings (trigger -> action rules)
+        /// </summary>
+        [JsonPropertyName("actionMappings")]
+        public List<ActionMappingEntry> ActionMappings { get; set; } = new();
+
+        /// <summary>
+        /// Section names found in the file
+        /// </summary>
+        [JsonPropertyName("sectionNames")]
+        public List<SectionNameEntry> SectionNames { get; set; } = new();
+
+        /// <summary>
+        /// Statistics about the parsed configuration
+        /// </summary>
+        [JsonPropertyName("statistics")]
+        public ConfigStatistics Statistics => new ConfigStatistics
+        {
+            TotalConfigItems = ConfigItems.Count,
+            TotalActionMappings = ActionMappings.Count,
+            TotalSectionNames = SectionNames.Count,
+            TotalActions = ActionMappings.Sum(m => m.Actions.Count),
+
+            ConfigItemsByType = ConfigItems
+                .GroupBy(i => i.ValueType)
+                .ToDictionary(g => g.Key, g => g.Count()),
+
+            ActionsPerMapping = ActionMappings
+                .GroupBy(m => m.Actions.Count)
+                .OrderBy(g => g.Key)
+                .ToDictionary(g => g.Key, g => g.Count())
+        };
+
+        /// <summary>
+        /// Get a clean copy of the original data for writing
+        /// </summary>
+        public byte[] GetDataForWriting()
+        {
+            byte[] copy = new byte[OriginalData.Length];
+            System.Array.Copy(OriginalData, copy, OriginalData.Length);
+            return copy;
+        }
+    }
+
+    /// <summary>
+    /// Configuration item (key-value pair)
+    /// </summary>
+    public class ConfigItemEntry
+    {
+        [JsonPropertyName("fileOffset")]
+        public int FileOffset { get; set; }
+
+        [JsonPropertyName("key")]
+        public string Key { get; set; } = "";
+
+        [JsonPropertyName("value")]
+        public object Value { get; set; }
+
+        [JsonPropertyName("valueType")]
+        public string ValueType { get; set; } = "";
+    }
+
+    /// <summary>
+    /// Section name found in the file
+    /// </summary>
+    public class SectionNameEntry
+    {
+        [JsonPropertyName("fileOffset")]
+        public int FileOffset { get; set; }
+
+        [JsonPropertyName("name")]
+        public string Name { get; set; } = "";
+    }
+
+    /// <summary>
+    /// Statistics about parsed configuration
+    /// </summary>
+    public class ConfigStatistics
+    {
+        [JsonPropertyName("totalConfigItems")]
+        public int TotalConfigItems { get; set; }
+
+        [JsonPropertyName("totalActionMappings")]
+        public int TotalActionMappings { get; set; }
+
+        [JsonPropertyName("totalSectionNames")]
+        public int TotalSectionNames { get; set; }
+
+        [JsonPropertyName("totalActions")]
+        public int TotalActions { get; set; }
+
+        [JsonPropertyName("configItemsByType")]
+        public Dictionary<string, int> ConfigItemsByType { get; set; } = new();
+
+        [JsonPropertyName("actionsPerMapping")]
+        public Dictionary<int, int> ActionsPerMapping { get; set; } = new();
+    }
+}

GeViSetEditor/GeViSetEditor.Core/Models/GeViSetConfiguration.cs

@@ -0,0 +1,81 @@
+using System.Collections.Generic;
+
+namespace GeViSetEditor.Core.Models
+{
+    /// <summary>
+    /// Represents the complete GeViSet configuration from a .set file
+    /// </summary>
+    public class GeViSetConfiguration
+    {
+        public string Header { get; set; } = "GeViSoft Parameters";
+        public List<Section> Sections { get; set; } = new();
+        
+        /// <summary>
+        /// File format version (inferred from structure)
+        /// </summary>
+        public int FormatVersion { get; set; } = 1;
+    }
+    
+    /// <summary>
+    /// Represents a configuration section (Alarms, Clients, GeViIO, etc.)
+    /// </summary>
+    public class Section
+    {
+        public string Name { get; set; } = "";
+        public List<ConfigItem> Items { get; set; } = new();
+        public List<ActionRule> Rules { get; set; } = new();
+    }
+    
+    /// <summary>
+    /// Represents a configuration item (key-value pair)
+    /// </summary>
+    public class ConfigItem
+    {
+        public string Name { get; set; } = "";
+        public object Value { get; set; }
+        public ConfigValueType Type { get; set; }
+        
+        public override string ToString() => $"{Name} = {Value}";
+    }
+    
+    /// <summary>
+    /// Represents an action rule (trigger -> actions mapping)
+    /// </summary>
+    public class ActionRule
+    {
+        public int RuleId { get; set; }
+        public Dictionary<string, bool> TriggerProperties { get; set; } = new();
+        public string MainAction { get; set; } = "";
+        public List<ActionVariation> ActionVariations { get; set; } = new();
+        
+        public override string ToString()
+        {
+            var triggers = string.Join(", ", TriggerProperties.Where(kv => kv.Value).Select(kv => kv.Key));
+            return $"Rule #{RuleId}: [{triggers}] -> {MainAction}";
+        }
+    }
+    
+    /// <summary>
+    /// Represents platform-specific action variations (GSC, GNG, GCore)
+    /// </summary>
+    public class ActionVariation
+    {
+        public int VariationId { get; set; }
+        public string ActionString { get; set; } = "";
+        public string ActionType { get; set; } = ""; // GscAction, GCoreAction, etc.
+        public string FullCommand { get; set; } = "";
+        public string ServerType { get; set; } = ""; // GscServer, GCoreServer
+        public string ServerName { get; set; } = "";
+        public Dictionary<string, object> Metadata { get; set; } = new();
+        
+        public override string ToString() => $"{ActionType}: {ActionString}";
+    }
+    
+    public enum ConfigValueType
+    {
+        Boolean,
+        Integer,
+        String,
+        Binary
+    }
+}

GeViSetEditor/GeViSetEditor.Core/Models/SafeSetFile.cs

@@ -0,0 +1,90 @@
+using System.Collections.Generic;
+
+namespace GeViSetEditor.Core.Models
+{
+    /// <summary>
+    /// Safe representation of a .set file that preserves original binary data
+    /// Only parses action mappings, everything else stays as original bytes
+    /// </summary>
+    public class SafeSetFile
+    {
+        /// <summary>
+        /// Complete original file data - preserved for round-trip
+        /// </summary>
+        public byte[] OriginalData { get; set; }
+
+        /// <summary>
+        /// File size in bytes
+        /// </summary>
+        public int FileSize { get; set; }
+
+        /// <summary>
+        /// Header string (usually "GeViSoft Parameters")
+        /// </summary>
+        public string Header { get; set; } = "";
+
+        /// <summary>
+        /// Extracted action mappings with their file offsets
+        /// </summary>
+        public List<ActionMappingEntry> ActionMappings { get; set; } = new();
+
+        /// <summary>
+        /// Get a clean copy of the original data for writing
+        /// </summary>
+        public byte[] GetDataForWriting()
+        {
+            byte[] copy = new byte[OriginalData.Length];
+            System.Array.Copy(OriginalData, copy, OriginalData.Length);
+            return copy;
+        }
+    }
+
+    /// <summary>
+    /// Action mapping entry with its location in the file
+    /// </summary>
+    public class ActionMappingEntry
+    {
+        /// <summary>
+        /// File offset where this mapping starts
+        /// </summary>
+        public int FileOffset { get; set; }
+
+        /// <summary>
+        /// Offset of the "Rules" marker
+        /// </summary>
+        public int RulesMarkerOffset { get; set; }
+
+        /// <summary>
+        /// Offset where action data starts (after metadata)
+        /// </summary>
+        public int ActionDataStartOffset { get; set; }
+
+        /// <summary>
+        /// Offset where action data ends
+        /// </summary>
+        public int ActionDataEndOffset { get; set; }
+
+        /// <summary>
+        /// Original bytes for this entire mapping (for preservation)
+        /// </summary>
+        public byte[] OriginalBytes { get; set; }
+
+        /// <summary>
+        /// Extracted action strings
+        /// </summary>
+        public List<string> Actions { get; set; } = new();
+
+        /// <summary>
+        /// Optional: Parsed trigger conditions (if needed later)
+        /// </summary>
+        public Dictionary<string, object> TriggerConditions { get; set; } = new();
+
+        /// <summary>
+        /// Display-friendly description of this mapping
+        /// </summary>
+        public string GetDescription()
+        {
+            return $"Mapping at offset {FileOffset}: {Actions.Count} actions";
+        }
+    }
+}

GeViSetEditor/GeViSetEditor.Core/Models/SetFileComplete.cs

@@ -0,0 +1,133 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.Json.Serialization;
+
+namespace GeViSetEditor.Core.Models
+{
+    /// <summary>
+    /// Complete representation of a .set file with full structure
+    /// Supports JSON serialization and round-trip conversion
+    /// </summary>
+    public class SetFileComplete
+    {
+        [JsonPropertyName("version")]
+        public string Version { get; set; } = "1.0";
+
+        [JsonPropertyName("fileSize")]
+        public int FileSize { get; set; }
+
+        [JsonPropertyName("headerNullByte")]
+        public bool HeaderNullByte { get; set; }
+
+        [JsonPropertyName("header")]
+        public string Header { get; set; } = "";
+
+        [JsonPropertyName("sections")]
+        public List<SectionComplete> Sections { get; set; } = new();
+
+        /// <summary>
+        /// Original raw data (not serialized to JSON)
+        /// </summary>
+        [JsonIgnore]
+        public byte[] RawData { get; set; }
+
+        /// <summary>
+        /// Get statistics about the configuration
+        /// </summary>
+        [JsonIgnore]
+        public ConfigStatisticsComplete Statistics => new ConfigStatisticsComplete
+        {
+            TotalSections = Sections.Count,
+            TotalItems = Sections.Sum(s => s.Items.Count),
+            TotalRules = Sections.Sum(s => s.Rules.Count),
+            TotalActions = Sections.Sum(s => s.Rules.Sum(r => r.Actions.Count)),
+            SectionTypes = Sections.GroupBy(s => s.Name)
+                .ToDictionary(g => g.Key, g => g.Count())
+        };
+    }
+
+    /// <summary>
+    /// Complete section with all items and rules
+    /// </summary>
+    public class SectionComplete
+    {
+        [JsonPropertyName("name")]
+        public string Name { get; set; } = "";
+
+        [JsonPropertyName("fileOffset")]
+        public int FileOffset { get; set; }
+
+        [JsonPropertyName("fileEndOffset")]
+        public int FileEndOffset { get; set; }
+
+        [JsonPropertyName("items")]
+        public List<ConfigItemComplete> Items { get; set; } = new();
+
+        [JsonPropertyName("rules")]
+        public List<ActionRuleComplete> Rules { get; set; } = new();
+
+        [JsonIgnore]
+        public int ByteSize => FileEndOffset - FileOffset;
+    }
+
+    /// <summary>
+    /// Configuration item (key-value pair)
+    /// </summary>
+    public class ConfigItemComplete
+    {
+        [JsonPropertyName("key")]
+        public string Key { get; set; } = "";
+
+        [JsonPropertyName("value")]
+        public object Value { get; set; }
+
+        [JsonPropertyName("valueType")]
+        public string ValueType { get; set; } = "";
+
+        [JsonPropertyName("fileOffset")]
+        public int FileOffset { get; set; }
+    }
+
+    /// <summary>
+    /// Action rule (trigger → actions)
+    /// </summary>
+    public class ActionRuleComplete
+    {
+        [JsonPropertyName("id")]
+        public int RuleId { get; set; }
+
+        [JsonPropertyName("fileOffset")]
+        public int FileOffset { get; set; }
+
+        [JsonPropertyName("triggers")]
+        public Dictionary<string, bool> Triggers { get; set; } = new();
+
+        [JsonPropertyName("actions")]
+        public List<string> Actions { get; set; } = new();
+
+        [JsonPropertyName("metadata")]
+        public Dictionary<string, object> Metadata { get; set; } = new();
+    }
+
+    /// <summary>
+    /// Configuration statistics (Complete parser version)
+    /// </summary>
+    public class ConfigStatisticsComplete
+    {
+        [JsonPropertyName("totalSections")]
+        public int TotalSections { get; set; }
+
+        [JsonPropertyName("totalItems")]
+        public int TotalItems { get; set; }
+
+        [JsonPropertyName("totalRules")]
+        public int TotalRules { get; set; }
+
+        [JsonPropertyName("totalActions")]
+        public int TotalActions { get; set; }
+
+        [JsonPropertyName("sectionTypes")]
+        public Dictionary<string, int> SectionTypes { get; set; } = new();
+    }
+}

GeViSetEditor/GeViSetEditor.Core/Parsers/AdvancedBinaryAnalyzer.cs

@@ -0,0 +1,404 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace GeViSetEditor.Core.Parsers
+{
+    /// <summary>
+    /// Advanced binary analyzer to understand .set file structure completely
+    /// </summary>
+    public class AdvancedBinaryAnalyzer
+    {
+        private byte[] _data;
+        private int _position;
+
+        /// <summary>
+        /// Analyze binary structure and report findings
+        /// </summary>
+        public BinaryStructureReport Analyze(byte[] data)
+        {
+            _data = data;
+            _position = 0;
+
+            var report = new BinaryStructureReport
+            {
+                FileSize = data.Length
+            };
+
+            Console.WriteLine("\n=== Advanced Binary Structure Analysis ===\n");
+
+            // Read header
+            AnalyzeHeader(report);
+
+            // Find all markers
+            FindAllMarkers(report);
+
+            // Analyze data types distribution
+            AnalyzeDataTypes(report);
+
+            // Find repeated patterns
+            FindPatterns(report);
+
+            // Identify section structure
+            AnalyzeSections(report);
+
+            return report;
+        }
+
+        private void AnalyzeHeader(BinaryStructureReport report)
+        {
+            Console.WriteLine("=== Header Analysis ===");
+
+            // Skip null byte if present
+            if (_position < _data.Length && _data[_position] == 0x00)
+            {
+                report.HeaderHasNullPrefix = true;
+                _position++;
+                Console.WriteLine($"Null byte at position 0");
+            }
+
+            // Read header length
+            if (_position < _data.Length)
+            {
+                byte headerLen = _data[_position++];
+                if (_position + headerLen <= _data.Length)
+                {
+                    report.Header = Encoding.UTF8.GetString(_data, _position, headerLen);
+                    _position += headerLen;
+                    Console.WriteLine($"Header: '{report.Header}' (length: {headerLen})");
+                    Console.WriteLine($"Header ends at offset: {_position} (0x{_position:X})\n");
+                    report.HeaderEndOffset = _position;
+                }
+            }
+        }
+
+        private void FindAllMarkers(BinaryStructureReport report)
+        {
+            Console.WriteLine("=== Finding Known Markers ===");
+
+            // Known markers
+            var markers = new Dictionary<string, byte[]>
+            {
+                { "Rules", new byte[] { 0x05, 0x52, 0x75, 0x6C, 0x65, 0x73 } },
+                { "Description", new byte[] { 0x07, 0x0B, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6F, 0x6E } },
+                { "Name", new byte[] { 0x07, 0x04, 0x4E, 0x61, 0x6D, 0x65 } },
+                { "Enabled", new byte[] { 0x07, 0x07, 0x45, 0x6E, 0x61, 0x62, 0x6C, 0x65, 0x64 } }
+            };
+
+            foreach (var marker in markers)
+            {
+                var offsets = FindPattern(_data, marker.Value);
+                report.Markers[marker.Key] = offsets;
+                Console.WriteLine($"{marker.Key}: {offsets.Count} occurrences");
+            }
+
+            Console.WriteLine();
+        }
+
+        private void AnalyzeDataTypes(BinaryStructureReport report)
+        {
+            Console.WriteLine("=== Data Type Distribution ===");
+
+            int boolCount = 0, intCount = 0, stringCount = 0, actionCount = 0;
+
+            for (int i = 0; i < _data.Length; i++)
+            {
+                if (_data[i] == 0x01) boolCount++;
+                else if (_data[i] == 0x04) intCount++;
+                else if (_data[i] == 0x07) stringCount++;
+
+                // Action string pattern
+                if (i + 2 < _data.Length &&
+                    _data[i] == 0x07 && _data[i+1] == 0x01 && _data[i+2] == 0x40)
+                {
+                    actionCount++;
+                }
+            }
+
+            Console.WriteLine($"0x01 (Boolean marker): {boolCount}");
+            Console.WriteLine($"0x04 (Integer marker): {intCount}");
+            Console.WriteLine($"0x07 (String marker): {stringCount}");
+            Console.WriteLine($"Action pattern (07 01 40): {actionCount}\n");
+
+            report.DataTypeCounts["boolean"] = boolCount;
+            report.DataTypeCounts["integer"] = intCount;
+            report.DataTypeCounts["string"] = stringCount;
+            report.DataTypeCounts["action"] = actionCount;
+        }
+
+        private void FindPatterns(BinaryStructureReport report)
+        {
+            Console.WriteLine("=== Repeated Byte Patterns ===");
+
+            // Find sequences that repeat
+            var sequences = new Dictionary<string, int>();
+
+            // Check 4-byte patterns
+            for (int i = 0; i < _data.Length - 4; i++)
+            {
+                var seq = $"{_data[i]:X2} {_data[i+1]:X2} {_data[i+2]:X2} {_data[i+3]:X2}";
+                if (sequences.ContainsKey(seq))
+                    sequences[seq]++;
+                else
+                    sequences[seq] = 1;
+            }
+
+            var topPatterns = sequences
+                .Where(kv => kv.Value > 50) // More than 50 occurrences
+                .OrderByDescending(kv => kv.Value)
+                .Take(10);
+
+            foreach (var pattern in topPatterns)
+            {
+                Console.WriteLine($"{pattern.Key}: {pattern.Value} times");
+            }
+
+            Console.WriteLine();
+        }
+
+        private void AnalyzeSections(BinaryStructureReport report)
+        {
+            Console.WriteLine("=== Section Structure Analysis ===");
+
+            // Start after header
+            _position = report.HeaderEndOffset;
+
+            int sectionCount = 0;
+            while (_position < _data.Length - 100)
+            {
+                var section = TryParseSection(_position);
+                if (section != null)
+                {
+                    report.Sections.Add(section);
+                    sectionCount++;
+                    _position = section.EndOffset;
+                }
+                else
+                {
+                    _position++;
+                }
+            }
+
+            Console.WriteLine($"Identified {sectionCount} potential sections\n");
+
+            // Show first few sections
+            Console.WriteLine("=== First 10 Sections ===");
+            foreach (var section in report.Sections.Take(10))
+            {
+                Console.WriteLine($"Offset {section.StartOffset}-{section.EndOffset}: {section.Name}");
+                Console.WriteLine($"  Items: {section.Items.Count}, Size: {section.Size} bytes");
+            }
+
+            Console.WriteLine();
+        }
+
+        private SectionInfo TryParseSection(int offset)
+        {
+            // Try to identify section start
+            // Common pattern: Pascal string followed by items
+
+            if (offset + 10 > _data.Length)
+                return null;
+
+            // Look for string marker
+            if (_data[offset] != 0x07)
+                return null;
+
+            byte nameLen = _data[offset + 1];
+            if (nameLen < 3 || nameLen > 50 || offset + 2 + nameLen > _data.Length)
+                return null;
+
+            string name = Encoding.UTF8.GetString(_data, offset + 2, nameLen);
+
+            // Validate name
+            if (!name.All(c => char.IsLetterOrDigit(c) || c == '_' || c == ' '))
+                return null;
+
+            var section = new SectionInfo
+            {
+                StartOffset = offset,
+                Name = name,
+                NameLength = nameLen
+            };
+
+            int pos = offset + 2 + nameLen;
+
+            // Parse items in section until we hit another section or Rules
+            int itemCount = 0;
+            while (pos < _data.Length - 10 && itemCount < 100)
+            {
+                var item = TryParseItem(pos);
+                if (item != null)
+                {
+                    section.Items.Add(item);
+                    pos = item.EndOffset;
+                    itemCount++;
+                }
+                else
+                {
+                    // Check if we hit next section or Rules
+                    if (IsLikelyNextSection(pos))
+                        break;
+                    pos++;
+                }
+            }
+
+            section.EndOffset = pos;
+            section.Size = pos - offset;
+
+            return section.Items.Count > 0 ? section : null;
+        }
+
+        private ItemInfo TryParseItem(int offset)
+        {
+            if (offset + 5 > _data.Length)
+                return null;
+
+            // Item pattern: 07 <len> <key> <type> <value>
+            if (_data[offset] != 0x07)
+                return null;
+
+            byte keyLen = _data[offset + 1];
+            if (keyLen < 2 || keyLen > 40 || offset + 2 + keyLen + 2 > _data.Length)
+                return null;
+
+            string key = Encoding.UTF8.GetString(_data, offset + 2, keyLen);
+
+            // Validate key
+            if (!key.All(c => char.IsLetterOrDigit(c) || c == '_' || c == '-'))
+                return null;
+
+            int valueOffset = offset + 2 + keyLen;
+            byte typeMarker = _data[valueOffset];
+
+            var item = new ItemInfo
+            {
+                StartOffset = offset,
+                Key = key,
+                TypeMarker = typeMarker
+            };
+
+            // Parse value based on type
+            switch (typeMarker)
+            {
+                case 0x01: // Boolean
+                    if (valueOffset + 2 <= _data.Length)
+                    {
+                        item.Value = _data[valueOffset + 1] != 0;
+                        item.ValueType = "boolean";
+                        item.EndOffset = valueOffset + 2;
+                        return item;
+                    }
+                    break;
+
+                case 0x04: // Integer
+                    if (valueOffset + 5 <= _data.Length)
+                    {
+                        item.Value = BitConverter.ToInt32(_data, valueOffset + 1);
+                        item.ValueType = "integer";
+                        item.EndOffset = valueOffset + 5;
+                        return item;
+                    }
+                    break;
+
+                case 0x07: // String
+                    if (valueOffset + 2 <= _data.Length)
+                    {
+                        byte strLen = _data[valueOffset + 1];
+                        if (strLen > 0 && valueOffset + 2 + strLen <= _data.Length)
+                        {
+                            item.Value = Encoding.UTF8.GetString(_data, valueOffset + 2, strLen);
+                            item.ValueType = "string";
+                            item.EndOffset = valueOffset + 2 + strLen;
+                            return item;
+                        }
+                    }
+                    break;
+            }
+
+            return null;
+        }
+
+        private bool IsLikelyNextSection(int pos)
+        {
+            if (pos + 10 > _data.Length)
+                return false;
+
+            // Check for Rules marker
+            if (_data[pos] == 0x05 && pos + 6 <= _data.Length)
+            {
+                string marker = Encoding.UTF8.GetString(_data, pos + 1, 5);
+                if (marker == "Rules")
+                    return true;
+            }
+
+            // Check for section name pattern
+            if (_data[pos] == 0x07)
+            {
+                byte len = _data[pos + 1];
+                if (len >= 5 && len <= 30 && pos + 2 + len <= _data.Length)
+                {
+                    string name = Encoding.UTF8.GetString(_data, pos + 2, len);
+                    return name.All(c => char.IsLetterOrDigit(c) || c == '_');
+                }
+            }
+
+            return false;
+        }
+
+        private List<int> FindPattern(byte[] data, byte[] pattern)
+        {
+            var offsets = new List<int>();
+
+            for (int i = 0; i <= data.Length - pattern.Length; i++)
+            {
+                bool match = true;
+                for (int j = 0; j < pattern.Length; j++)
+                {
+                    if (data[i + j] != pattern[j])
+                    {
+                        match = false;
+                        break;
+                    }
+                }
+
+                if (match)
+                    offsets.Add(i);
+            }
+
+            return offsets;
+        }
+    }
+
+    public class BinaryStructureReport
+    {
+        public int FileSize { get; set; }
+        public bool HeaderHasNullPrefix { get; set; }
+        public string Header { get; set; } = "";
+        public int HeaderEndOffset { get; set; }
+        public Dictionary<string, List<int>> Markers { get; set; } = new();
+        public Dictionary<string, int> DataTypeCounts { get; set; } = new();
+        public List<SectionInfo> Sections { get; set; } = new();
+    }
+
+    public class SectionInfo
+    {
+        public int StartOffset { get; set; }
+        public int EndOffset { get; set; }
+        public int Size { get; set; }
+        public string Name { get; set; } = "";
+        public int NameLength { get; set; }
+        public List<ItemInfo> Items { get; set; } = new();
+    }
+
+    public class ItemInfo
+    {
+        public int StartOffset { get; set; }
+        public int EndOffset { get; set; }
+        public string Key { get; set; } = "";
+        public byte TypeMarker { get; set; }
+        public string ValueType { get; set; } = "";
+        public object Value { get; set; }
+    }
+}

GeViSetEditor/GeViSetEditor.Core/Parsers/BinaryConfigWriter.cs

@@ -0,0 +1,209 @@
+using System;
+using System.IO;
+using System.Text;
+using System.Collections.Generic;
+using GeViSetEditor.Core.Models;
+
+namespace GeViSetEditor.Core.Parsers
+{
+    /// <summary>
+    /// Writes ComprehensiveConfigFile back to binary .set format
+    /// Enables edit/add/delete operations on configuration
+    /// </summary>
+    public class BinaryConfigWriter
+    {
+        /// <summary>
+        /// Rebuild complete .set file from configuration nodes
+        /// </summary>
+        public byte[] Write(ComprehensiveConfigFile config)
+        {
+            using var ms = new MemoryStream();
+
+            // Write header
+            WriteHeader(ms, config);
+
+            // Write all nodes sequentially
+            foreach (var node in config.RootNodes)
+            {
+                WriteNode(ms, node);
+            }
+
+            return ms.ToArray();
+        }
+
+        private void WriteHeader(MemoryStream ms, ComprehensiveConfigFile config)
+        {
+            // Write null prefix if it was present
+            if (config.HeaderNullPrefix)
+            {
+                ms.WriteByte(0x00);
+            }
+
+            // Write header string
+            if (!string.IsNullOrEmpty(config.Header))
+            {
+                byte[] headerBytes = Encoding.UTF8.GetBytes(config.Header);
+                ms.WriteByte((byte)headerBytes.Length);
+                ms.Write(headerBytes, 0, headerBytes.Length);
+            }
+        }
+
+        private void WriteNode(MemoryStream ms, ConfigNode node)
+        {
+            switch (node.NodeType)
+            {
+                case "boolean":
+                    WriteBoolean(ms, node);
+                    break;
+
+                case "integer":
+                    WriteInteger(ms, node);
+                    break;
+
+                case "string":
+                    WriteString(ms, node);
+                    break;
+
+                case "property":
+                    WriteProperty(ms, node);
+                    break;
+
+                case "marker":
+                    WriteMarker(ms, node);
+                    break;
+
+                default:
+                    throw new InvalidOperationException($"Unknown node type: {node.NodeType}");
+            }
+        }
+
+        private void WriteBoolean(MemoryStream ms, ConfigNode node)
+        {
+            ms.WriteByte(0x01);  // Boolean marker
+
+            bool value = Convert.ToBoolean(node.Value);
+            ms.WriteByte(value ? (byte)1 : (byte)0);
+        }
+
+        private void WriteInteger(MemoryStream ms, ConfigNode node)
+        {
+            ms.WriteByte(0x04);  // Integer marker
+
+            int value = Convert.ToInt32(node.Value);
+            byte[] bytes = BitConverter.GetBytes(value);
+            ms.Write(bytes, 0, bytes.Length);
+        }
+
+        private void WriteString(MemoryStream ms, ConfigNode node)
+        {
+            ms.WriteByte(0x07);  // String marker
+
+            string value = node.Value?.ToString() ?? "";
+            byte[] bytes = Encoding.UTF8.GetBytes(value);
+
+            if (bytes.Length > 255)
+                throw new InvalidOperationException($"String too long: {bytes.Length} bytes (max 255)");
+
+            ms.WriteByte((byte)bytes.Length);
+            ms.Write(bytes, 0, bytes.Length);
+        }
+
+        private void WriteProperty(MemoryStream ms, ConfigNode node)
+        {
+            // Write property name (07 <len> <name>)
+            ms.WriteByte(0x07);
+            byte[] nameBytes = Encoding.UTF8.GetBytes(node.Name ?? "");
+
+            if (nameBytes.Length > 255)
+                throw new InvalidOperationException($"Property name too long: {nameBytes.Length} bytes (max 255)");
+
+            ms.WriteByte((byte)nameBytes.Length);
+            ms.Write(nameBytes, 0, nameBytes.Length);
+
+            // Write property value based on ValueType
+            WriteTypedValue(ms, node.Value, node.ValueType);
+        }
+
+        private void WriteMarker(MemoryStream ms, ConfigNode node)
+        {
+            // Write marker (05 <len> <name>)
+            ms.WriteByte(0x05);
+            byte[] nameBytes = Encoding.UTF8.GetBytes(node.Name ?? "");
+
+            if (nameBytes.Length > 255)
+                throw new InvalidOperationException($"Marker name too long: {nameBytes.Length} bytes (max 255)");
+
+            ms.WriteByte((byte)nameBytes.Length);
+            ms.Write(nameBytes, 0, nameBytes.Length);
+
+            // If it's a Rules marker with actions, write them
+            if (node.Name == "Rules" && node.Value is List<string> actions)
+            {
+                WriteRulesActions(ms, actions);
+            }
+        }
+
+        private void WriteRulesActions(MemoryStream ms, List<string> actions)
+        {
+            // Write action strings in the special format: 07 01 40 <len_2bytes_LE> <data>
+            foreach (var action in actions)
+            {
+                ms.WriteByte(0x07);
+                ms.WriteByte(0x01);
+                ms.WriteByte(0x40);
+
+                byte[] actionBytes = Encoding.UTF8.GetBytes(action);
+                ushort length = (ushort)actionBytes.Length;
+
+                byte[] lenBytes = BitConverter.GetBytes(length);
+                ms.Write(lenBytes, 0, 2);  // Write length as 2-byte LE
+
+                ms.Write(actionBytes, 0, actionBytes.Length);
+            }
+        }
+
+        private void WriteTypedValue(MemoryStream ms, object? value, string? valueType)
+        {
+            if (value == null)
+            {
+                // Write null as empty string
+                ms.WriteByte(0x07);
+                ms.WriteByte(0x00);
+                return;
+            }
+
+            switch (valueType)
+            {
+                case "boolean":
+                    ms.WriteByte(0x01);
+                    bool boolVal = Convert.ToBoolean(value);
+                    ms.WriteByte(boolVal ? (byte)1 : (byte)0);
+                    break;
+
+                case "integer":
+                    ms.WriteByte(0x04);
+                    int intVal = Convert.ToInt32(value);
+                    byte[] intBytes = BitConverter.GetBytes(intVal);
+                    ms.Write(intBytes, 0, intBytes.Length);
+                    break;
+
+                case "string":
+                    ms.WriteByte(0x07);
+                    string strVal = value.ToString() ?? "";
+                    byte[] strBytes = Encoding.UTF8.GetBytes(strVal);
+
+                    if (strBytes.Length > 255)
+                        throw new InvalidOperationException($"String value too long: {strBytes.Length} bytes (max 255)");
+
+                    ms.WriteByte((byte)strBytes.Length);
+                    ms.Write(strBytes, 0, strBytes.Length);
+                    break;
+
+                default:
+                    // Default to string representation
+                    WriteTypedValue(ms, value.ToString(), "string");
+                    break;
+            }
+        }
+    }
+}

GeViSetEditor/GeViSetEditor.Core/Parsers/CompleteBinaryParser.cs

@@ -0,0 +1,402 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using GeViSetEditor.Core.Models;
+
+namespace GeViSetEditor.Core.Parsers
+{
+    /// <summary>
+    /// Complete binary parser that understands the entire .set file structure
+    /// Parses ALL sections, items, and rules for full JSON serialization
+    /// </summary>
+    public class CompleteBinaryParser
+    {
+        private byte[] _data;
+        private int _position;
+        private Dictionary<int, string> _debugLog = new();
+
+        public SetFileComplete Parse(byte[] data)
+        {
+            _data = data;
+            _position = 0;
+
+            var setFile = new SetFileComplete
+            {
+                FileSize = data.Length,
+                RawData = data // Keep original for verification
+            };
+
+            Console.WriteLine($"=== Complete Binary Parser ===");
+            Console.WriteLine($"File size: {data.Length:N0} bytes\n");
+
+            try
+            {
+                // Parse header
+                ParseHeader(setFile);
+
+                // Parse all sections
+                ParseAllSections(setFile);
+
+                Console.WriteLine($"\n=== Parsing Complete ===");
+                Console.WriteLine($"Sections parsed: {setFile.Sections.Count}");
+                Console.WriteLine($"Total items: {setFile.Sections.Sum(s => s.Items.Count)}");
+                Console.WriteLine($"Total rules: {setFile.Sections.Sum(s => s.Rules.Count)}");
+
+                return setFile;
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"\nERROR at position {_position} (0x{_position:X}): {ex.Message}");
+                throw;
+            }
+        }
+
+        private void ParseHeader(SetFileComplete setFile)
+        {
+            Console.WriteLine("Parsing header...");
+
+            // Optional null byte
+            if (_position < _data.Length && _data[_position] == 0x00)
+            {
+                setFile.HeaderNullByte = true;
+                _position++;
+            }
+
+            // Header is length-prefixed string (NOT Pascal string with 0x07)
+            if (_position + 2 > _data.Length)
+                throw new Exception("File too short for header");
+
+            byte headerLen = _data[_position++];
+            if (headerLen == 0 || headerLen > 50 || _position + headerLen > _data.Length)
+                throw new Exception($"Invalid header length: {headerLen}");
+
+            setFile.Header = Encoding.UTF8.GetString(_data, _position, headerLen);
+            _position += headerLen;
+
+            Console.WriteLine($"  Header: '{setFile.Header}'");
+            Console.WriteLine($"  Position after header: {_position} (0x{_position:X})\n");
+        }
+
+        private void ParseAllSections(SetFileComplete setFile)
+        {
+            Console.WriteLine("Parsing sections...\n");
+
+            int sectionCount = 0;
+            int maxIterations = 10000; // Safety limit
+
+            while (_position < _data.Length - 10 && maxIterations-- > 0)
+            {
+                int sectionStart = _position;
+
+                var section = TryParseSection();
+                if (section != null)
+                {
+                    sectionCount++;
+                    setFile.Sections.Add(section);
+
+                    if (sectionCount <= 20 || section.Items.Count > 0 || section.Rules.Count > 0)
+                    {
+                        Console.WriteLine($"Section #{sectionCount}: '{section.Name}' " +
+                            $"(offset {sectionStart}, {section.Items.Count} items, {section.Rules.Count} rules)");
+                    }
+                }
+                else
+                {
+                    // Skip unknown byte
+                    _position++;
+                }
+            }
+
+            Console.WriteLine($"\nTotal sections parsed: {sectionCount}");
+        }
+
+        private SectionComplete TryParseSection()
+        {
+            int startPos = _position;
+
+            try
+            {
+                // Try to read section name (Pascal string: 0x07 <len> <data>)
+                string sectionName = TryReadPascalString();
+                if (string.IsNullOrEmpty(sectionName) || sectionName.Length > 100)
+                {
+                    _position = startPos;
+                    return null;
+                }
+
+                var section = new SectionComplete
+                {
+                    Name = sectionName,
+                    FileOffset = startPos
+                };
+
+                // Parse section contents
+                ParseSectionContents(section);
+
+                section.FileEndOffset = _position;
+                return section;
+            }
+            catch
+            {
+                _position = startPos;
+                return null;
+            }
+        }
+
+        private void ParseSectionContents(SectionComplete section)
+        {
+            int maxIterations = 1000;
+            bool foundRules = false;
+
+            while (_position < _data.Length - 10 && maxIterations-- > 0)
+            {
+                int itemStart = _position;
+
+                // Check for "Rules" marker (length-prefixed, no 0x07)
+                if (CheckForRulesMarker())
+                {
+                    foundRules = true;
+                    ParseRulesSubsection(section);
+                    break; // Rules typically end a section
+                }
+
+                // Try to parse a config item
+                var item = TryParseConfigItem();
+                if (item != null)
+                {
+                    section.Items.Add(item);
+                    continue;
+                }
+
+                // Check if we've hit next section
+                if (IsLikelyNextSection())
+                {
+                    break;
+                }
+
+                // Move forward
+                _position++;
+            }
+        }
+
+        private bool CheckForRulesMarker()
+        {
+            // Pattern: 05 52 75 6C 65 73 = "Rules" (length 5 + data)
+            if (_position + 6 > _data.Length)
+                return false;
+
+            return _data[_position] == 0x05 &&
+                   _data[_position + 1] == 0x52 && // 'R'
+                   _data[_position + 2] == 0x75 && // 'u'
+                   _data[_position + 3] == 0x6C && // 'l'
+                   _data[_position + 4] == 0x65 && // 'e'
+                   _data[_position + 5] == 0x73;   // 's'
+        }
+
+        private void ParseRulesSubsection(SectionComplete section)
+        {
+            // Skip "Rules" marker
+            _position += 6;
+
+            // Skip metadata bytes (counts, flags, etc.)
+            while (_position < _data.Length && _data[_position] <= 0x04)
+            {
+                _position++;
+            }
+
+            // Parse action rules
+            int ruleCount = 0;
+            int maxRules = 100;
+            int consecutiveFails = 0;
+
+            while (maxRules-- > 0 && _position < _data.Length - 20)
+            {
+                var rule = TryParseActionRule();
+                if (rule != null)
+                {
+                    rule.RuleId = ruleCount++;
+                    section.Rules.Add(rule);
+                    consecutiveFails = 0;
+                }
+                else
+                {
+                    _position++;
+                    consecutiveFails++;
+                    if (consecutiveFails > 100) break;
+                }
+            }
+        }
+
+        private ActionRuleComplete TryParseActionRule()
+        {
+            int startPos = _position;
+
+            try
+            {
+                var rule = new ActionRuleComplete
+                {
+                    FileOffset = startPos
+                };
+
+                // Try to read action string (07 01 40 <len_2bytes> <data>)
+                string actionString = TryReadActionString();
+                if (!string.IsNullOrEmpty(actionString))
+                {
+                    rule.Actions.Add(actionString);
+                    return rule;
+                }
+
+                _position = startPos;
+                return null;
+            }
+            catch
+            {
+                _position = startPos;
+                return null;
+            }
+        }
+
+        private ConfigItemComplete TryParseConfigItem()
+        {
+            int startPos = _position;
+
+            try
+            {
+                // Read key (Pascal string)
+                string key = TryReadPascalString();
+                if (string.IsNullOrEmpty(key) || key.Length > 200)
+                {
+                    _position = startPos;
+                    return null;
+                }
+
+                // Read value (typed)
+                var (value, type) = TryReadTypedValue();
+                if (value == null)
+                {
+                    _position = startPos;
+                    return null;
+                }
+
+                return new ConfigItemComplete
+                {
+                    Key = key,
+                    Value = value,
+                    ValueType = type,
+                    FileOffset = startPos
+                };
+            }
+            catch
+            {
+                _position = startPos;
+                return null;
+            }
+        }
+
+        private string TryReadPascalString()
+        {
+            if (_position + 2 > _data.Length || _data[_position] != 0x07)
+                return null;
+
+            byte length = _data[_position + 1];
+            if (length == 0 || length > 200 || _position + 2 + length > _data.Length)
+                return null;
+
+            string result = Encoding.UTF8.GetString(_data, _position + 2, length);
+            _position += 2 + length;
+            return result;
+        }
+
+        private string TryReadActionString()
+        {
+            // Pattern: 07 01 40 <len_2bytes_LE> <data>
+            if (_position + 5 > _data.Length)
+                return null;
+
+            if (_data[_position] != 0x07 ||
+                _data[_position + 1] != 0x01 ||
+                _data[_position + 2] != 0x40)
+                return null;
+
+            int length = BitConverter.ToUInt16(_data, _position + 3);
+            if (length == 0 || length > 500 || _position + 5 + length > _data.Length)
+                return null;
+
+            string result = Encoding.UTF8.GetString(_data, _position + 5, length);
+            _position += 5 + length;
+
+            // Validate it looks like an action
+            if (string.IsNullOrWhiteSpace(result) || result.Length < 3)
+                return null;
+
+            return result;
+        }
+
+        private (object value, string type) TryReadTypedValue()
+        {
+            if (_position >= _data.Length)
+                return (null, null);
+
+            byte typeMarker = _data[_position];
+
+            switch (typeMarker)
+            {
+                case 0x01: // Boolean
+                    if (_position + 2 <= _data.Length)
+                    {
+                        _position++;
+                        bool value = _data[_position++] != 0;
+                        return (value, "boolean");
+                    }
+                    break;
+
+                case 0x04: // Integer (4 bytes, little-endian)
+                    if (_position + 5 <= _data.Length)
+                    {
+                        _position++;
+                        int value = BitConverter.ToInt32(_data, _position);
+                        _position += 4;
+                        return (value, "integer");
+                    }
+                    break;
+
+                case 0x07: // String (Pascal string)
+                    string value_str = TryReadPascalString();
+                    if (value_str != null)
+                    {
+                        return (value_str, "string");
+                    }
+                    break;
+            }
+
+            return (null, null);
+        }
+
+        private bool IsLikelyNextSection()
+        {
+            // Check if next bytes look like a new section (Pascal string)
+            if (_position + 3 >= _data.Length)
+                return true;
+
+            if (_data[_position] != 0x07)
+                return false;
+
+            byte length = _data[_position + 1];
+            if (length < 3 || length > 50)
+                return false;
+
+            // Check if it's printable ASCII (likely a section name)
+            for (int i = 0; i < Math.Min(5, (int)length); i++)
+            {
+                if (_position + 2 + i >= _data.Length)
+                    return false;
+
+                byte b = _data[_position + 2 + i];
+                if (b < 32 || b > 126)
+                    return false;
+            }
+
+            return true;
+        }
+    }
+}

GeViSetEditor/GeViSetEditor.Core/Parsers/ComprehensiveConfigParser.cs

@@ -0,0 +1,333 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using GeViSetEditor.Core.Models;
+
+namespace GeViSetEditor.Core.Parsers
+{
+    /// <summary>
+    /// Comprehensive parser that extracts ALL configuration data
+    /// Based on binary analysis showing 15K booleans, 9K integers, 6K strings
+    /// </summary>
+    public class ComprehensiveConfigParser
+    {
+        private byte[] _data;
+        private int _position;
+        private int _depth;
+
+        public ComprehensiveConfigFile Parse(byte[] data)
+        {
+            _data = data;
+            _position = 0;
+            _depth = 0;
+
+            var config = new ComprehensiveConfigFile
+            {
+                OriginalData = data,
+                FileSize = data.Length
+            };
+
+            Console.WriteLine($"\n=== Comprehensive Configuration Parser ===");
+            Console.WriteLine($"File size: {data.Length:N0} bytes\n");
+
+            // Parse header
+            ParseHeader(config);
+
+            Console.WriteLine($"Starting systematic parse from offset {_position}...\n");
+
+            // Parse all data structures systematically
+            int itemsParsed = 0;
+            while (_position < _data.Length - 10)
+            {
+                var node = TryParseNextNode();
+                if (node != null)
+                {
+                    config.RootNodes.Add(node);
+                    itemsParsed++;
+
+                    if (itemsParsed % 1000 == 0)
+                        Console.WriteLine($"Parsed {itemsParsed} nodes, position: {_position}/{_data.Length}");
+                }
+                else
+                {
+                    // Skip unknown byte
+                    _position++;
+                }
+            }
+
+            Console.WriteLine($"\n=== Parse Complete ===");
+            Console.WriteLine($"Total nodes parsed: {itemsParsed}");
+            Console.WriteLine($"Position: {_position}/{_data.Length}");
+
+            // Calculate statistics
+            CalculateStatistics(config);
+
+            return config;
+        }
+
+        private void ParseHeader(ComprehensiveConfigFile config)
+        {
+            // Skip null byte
+            if (_position < _data.Length && _data[_position] == 0x00)
+            {
+                config.HeaderNullPrefix = true;
+                _position++;
+            }
+
+            // Read header
+            if (_position < _data.Length)
+            {
+                byte headerLen = _data[_position++];
+                if (_position + headerLen <= _data.Length)
+                {
+                    config.Header = Encoding.UTF8.GetString(_data, _position, headerLen);
+                    _position += headerLen;
+                    Console.WriteLine($"Header: '{config.Header}'");
+                    Console.WriteLine($"Header ends at: {_position} (0x{_position:X})\n");
+                }
+            }
+        }
+
+        private ConfigNode TryParseNextNode()
+        {
+            if (_position >= _data.Length)
+                return null;
+
+            int startOffset = _position;
+            byte marker = _data[_position];
+
+            ConfigNode node = null;
+
+            switch (marker)
+            {
+                case 0x01: // Boolean
+                    node = ParseBoolean(startOffset);
+                    break;
+
+                case 0x04: // Integer
+                    node = ParseInteger(startOffset);
+                    break;
+
+                case 0x05: // Special marker (Rules, etc.)
+                    node = ParseSpecialMarker(startOffset);
+                    break;
+
+                case 0x07: // String or Object
+                    node = ParseStringOrObject(startOffset);
+                    break;
+
+                default:
+                    // Unknown marker - might be raw data
+                    return null;
+            }
+
+            return node;
+        }
+
+        private ConfigNode ParseBoolean(int startOffset)
+        {
+            if (_position + 2 > _data.Length)
+                return null;
+
+            _position++; // Skip 0x01
+            bool value = _data[_position++] != 0;
+
+            return new ConfigNode
+            {
+                StartOffset = startOffset,
+                EndOffset = _position,
+                NodeType = "boolean",
+                Value = value
+            };
+        }
+
+        private ConfigNode ParseInteger(int startOffset)
+        {
+            if (_position + 5 > _data.Length)
+                return null;
+
+            _position++; // Skip 0x04
+            int value = BitConverter.ToInt32(_data, _position);
+            _position += 4;
+
+            return new ConfigNode
+            {
+                StartOffset = startOffset,
+                EndOffset = _position,
+                NodeType = "integer",
+                Value = value
+            };
+        }
+
+        private ConfigNode ParseSpecialMarker(int startOffset)
+        {
+            if (_position + 2 > _data.Length)
+                return null;
+
+            _position++; // Skip 0x05
+            byte nameLen = _data[_position++];
+
+            if (nameLen > 100 || _position + nameLen > _data.Length)
+            {
+                _position = startOffset;
+                return null;
+            }
+
+            string markerName = Encoding.UTF8.GetString(_data, _position, nameLen);
+            _position += nameLen;
+
+            var node = new ConfigNode
+            {
+                StartOffset = startOffset,
+                EndOffset = _position,
+                NodeType = "marker",
+                Name = markerName
+            };
+
+            // If it's "Rules", parse action mappings
+            if (markerName == "Rules")
+            {
+                ParseRulesSection(node);
+            }
+
+            return node;
+        }
+
+        private ConfigNode ParseStringOrObject(int startOffset)
+        {
+            if (_position + 2 > _data.Length)
+                return null;
+
+            _position++; // Skip 0x07
+            byte length = _data[_position++];
+
+            if (length == 0 || length > 200 || _position + length > _data.Length)
+            {
+                _position = startOffset;
+                return null;
+            }
+
+            string stringValue = Encoding.UTF8.GetString(_data, _position, length);
+            _position += length;
+
+            // Check if this string is followed by typed values (object property)
+            if (_position < _data.Length)
+            {
+                byte nextMarker = _data[_position];
+
+                if (nextMarker == 0x01 || nextMarker == 0x04 || nextMarker == 0x07)
+                {
+                    // This is a property name followed by value
+                    var node = new ConfigNode
+                    {
+                        StartOffset = startOffset,
+                        NodeType = "property",
+                        Name = stringValue
+                    };
+
+                    // Parse the value
+                    var valueNode = TryParseNextNode();
+                    if (valueNode != null)
+                    {
+                        node.Value = valueNode.Value;
+                        node.ValueType = valueNode.NodeType;
+                        node.EndOffset = _position;
+                        return node;
+                    }
+                }
+            }
+
+            // Just a standalone string
+            return new ConfigNode
+            {
+                StartOffset = startOffset,
+                EndOffset = _position,
+                NodeType = "string",
+                Value = stringValue
+            };
+        }
+
+        private void ParseRulesSection(ConfigNode rulesNode)
+        {
+            // Skip metadata bytes
+            while (_position < _data.Length && _data[_position] <= 0x04)
+            {
+                _position++;
+            }
+
+            // Parse action strings (07 01 40 pattern)
+            var actions = new List<string>();
+            int attempts = 0;
+
+            while (attempts < 200 && _position + 10 < _data.Length)
+            {
+                if (_data[_position] == 0x07 &&
+                    _data[_position + 1] == 0x01 &&
+                    _data[_position + 2] == 0x40)
+                {
+                    ushort actionLen = BitConverter.ToUInt16(_data, _position + 3);
+                    if (actionLen > 0 && actionLen < 500 && _position + 5 + actionLen <= _data.Length)
+                    {
+                        string action = Encoding.UTF8.GetString(_data, _position + 5, actionLen);
+                        actions.Add(action);
+                        _position += 5 + actionLen;
+                        attempts = 0; // Reset
+                    }
+                    else
+                    {
+                        _position++;
+                        attempts++;
+                    }
+                }
+                else
+                {
+                    _position++;
+                    attempts++;
+                }
+            }
+
+            rulesNode.Value = actions;
+            rulesNode.EndOffset = _position;
+        }
+
+        private void CalculateStatistics(ComprehensiveConfigFile config)
+        {
+            config.Statistics = new ComprehensiveConfigStatistics
+            {
+                TotalNodes = config.RootNodes.Count,
+                BooleanCount = config.RootNodes.Count(n => n.NodeType == "boolean"),
+                IntegerCount = config.RootNodes.Count(n => n.NodeType == "integer"),
+                StringCount = config.RootNodes.Count(n => n.NodeType == "string"),
+                PropertyCount = config.RootNodes.Count(n => n.NodeType == "property"),
+                MarkerCount = config.RootNodes.Count(n => n.NodeType == "marker"),
+                RulesCount = config.RootNodes.Count(n => n.NodeType == "marker" && n.Name == "Rules")
+            };
+
+            Console.WriteLine($"\n=== Statistics ===");
+            Console.WriteLine($"Total nodes: {config.Statistics.TotalNodes:N0}");
+            Console.WriteLine($"Properties: {config.Statistics.PropertyCount:N0}");
+            Console.WriteLine($"Booleans: {config.Statistics.BooleanCount:N0}");
+            Console.WriteLine($"Integers: {config.Statistics.IntegerCount:N0}");
+            Console.WriteLine($"Strings: {config.Statistics.StringCount:N0}");
+            Console.WriteLine($"Markers: {config.Statistics.MarkerCount:N0}");
+            Console.WriteLine($"Rules sections: {config.Statistics.RulesCount:N0}");
+
+            // Count property names
+            var propertyNames = config.RootNodes
+                .Where(n => n.NodeType == "property")
+                .GroupBy(n => n.Name)
+                .OrderByDescending(g => g.Count())
+                .Take(20);
+
+            if (propertyNames.Any())
+            {
+                Console.WriteLine($"\n=== Top 20 Property Names ===");
+                foreach (var group in propertyNames)
+                {
+                    Console.WriteLine($"  {group.Key}: {group.Count()} occurrences");
+                }
+            }
+        }
+    }
+}

GeViSetEditor/GeViSetEditor.Core/Parsers/EnhancedSetFileParser.cs

@@ -0,0 +1,464 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using GeViSetEditor.Core.Models;
+
+namespace GeViSetEditor.Core.Parsers
+{
+    /// <summary>
+    /// Enhanced parser that extracts full configuration structure
+    /// while preserving original binary data for round-trip conversion
+    /// </summary>
+    public class EnhancedSetFileParser
+    {
+        private byte[] _originalData;
+        private int _position;
+
+        public EnhancedSetFile Parse(byte[] data)
+        {
+            _originalData = data;
+            _position = 0;
+
+            var setFile = new EnhancedSetFile
+            {
+                OriginalData = data,
+                FileSize = data.Length
+            };
+
+            Console.WriteLine($"\n=== Enhanced Configuration Parser ===");
+            Console.WriteLine($"File size: {data.Length:N0} bytes\n");
+
+            // Read header
+            if (_position < data.Length && data[_position] == 0x00)
+                _position++;
+
+            string header = ReadPascalString();
+            setFile.Header = header ?? "GeViSoft Parameters";
+            Console.WriteLine($"Header: '{setFile.Header}'");
+
+            // Extract configuration items (key-value pairs)
+            ExtractConfigItems(setFile);
+
+            // Extract action mappings
+            ExtractActionMappings(setFile);
+
+            // Extract section names
+            ExtractSectionNames(setFile);
+
+            Console.WriteLine($"\n=== Parse Summary ===");
+            Console.WriteLine($"Configuration items: {setFile.ConfigItems.Count}");
+            Console.WriteLine($"Action mappings: {setFile.ActionMappings.Count}");
+            Console.WriteLine($"Section names: {setFile.SectionNames.Count}");
+
+            return setFile;
+        }
+
+        private void ExtractConfigItems(EnhancedSetFile setFile)
+        {
+            Console.WriteLine("\nExtracting configuration items...");
+
+            // Look for key-value patterns
+            // Common pattern: Pascal string (key) followed by typed value
+            for (int i = 0; i < _originalData.Length - 10; i++)
+            {
+                var item = TryReadConfigItem(i);
+                if (item != null && !string.IsNullOrWhiteSpace(item.Key))
+                {
+                    setFile.ConfigItems.Add(item);
+                }
+            }
+
+            Console.WriteLine($"Found {setFile.ConfigItems.Count} config items");
+        }
+
+        private ConfigItemEntry TryReadConfigItem(int offset)
+        {
+            try
+            {
+                // Skip if this looks like part of an action mapping
+                if (IsNearRulesMarker(offset, 100))
+                    return null;
+
+                // Skip if in the first 1000 bytes (header area)
+                if (offset < 1000)
+                    return null;
+
+                // Try to read Pascal string as key
+                int pos = offset;
+
+                // Look for string marker (0x07) followed by reasonable length
+                if (pos >= _originalData.Length || _originalData[pos] != 0x07)
+                    return null;
+
+                pos++;
+                if (pos >= _originalData.Length)
+                    return null;
+
+                byte keyLen = _originalData[pos];
+                if (keyLen < 3 || keyLen > 50)  // More restrictive length
+                    return null;
+
+                pos++;
+                if (pos + keyLen > _originalData.Length)
+                    return null;
+
+                string key = Encoding.UTF8.GetString(_originalData, pos, keyLen);
+
+                // Check if key looks valid (must be clean identifier)
+                if (!IsValidConfigKey(key))
+                    return null;
+
+                // Key must not contain common section names (avoid duplicates)
+                string keyLower = key.ToLower();
+                if (keyLower.Contains("rules") || keyLower.Contains("action") ||
+                    keyLower.Contains("gsc") || keyLower.Contains("gng"))
+                    return null;
+
+                pos += keyLen;
+
+                // Must be followed immediately by typed value marker
+                if (pos >= _originalData.Length)
+                    return null;
+
+                byte typeMarker = _originalData[pos];
+                if (typeMarker != 0x01 && typeMarker != 0x04 && typeMarker != 0x07)
+                    return null;
+
+                // Try to read value
+                var (value, valueType, bytesRead) = TryReadTypedValue(pos);
+                if (value == null || bytesRead == 0)
+                    return null;
+
+                return new ConfigItemEntry
+                {
+                    FileOffset = offset,
+                    Key = key,
+                    Value = value,
+                    ValueType = valueType
+                };
+            }
+            catch
+            {
+                return null;
+            }
+        }
+
+        private (object value, string type, int bytesRead) TryReadTypedValue(int pos)
+        {
+            if (pos >= _originalData.Length)
+                return (null, null, 0);
+
+            byte typeMarker = _originalData[pos];
+
+            try
+            {
+                switch (typeMarker)
+                {
+                    case 0x01: // Boolean
+                        if (pos + 2 <= _originalData.Length)
+                        {
+                            bool value = _originalData[pos + 1] != 0;
+                            return (value, "boolean", 2);
+                        }
+                        break;
+
+                    case 0x04: // Integer (4 bytes)
+                        if (pos + 5 <= _originalData.Length)
+                        {
+                            int value = BitConverter.ToInt32(_originalData, pos + 1);
+                            return (value, "integer", 5);
+                        }
+                        break;
+
+                    case 0x07: // String (Pascal string)
+                        pos++;
+                        if (pos >= _originalData.Length)
+                            break;
+
+                        byte strLen = _originalData[pos];
+                        if (strLen > 0 && strLen < 200 && pos + 1 + strLen <= _originalData.Length)
+                        {
+                            string value = Encoding.UTF8.GetString(_originalData, pos + 1, strLen);
+                            if (IsValidStringValue(value))
+                            {
+                                return (value, "string", 2 + strLen);
+                            }
+                        }
+                        break;
+                }
+            }
+            catch
+            {
+                // Ignore parse errors
+            }
+
+            return (null, null, 0);
+        }
+
+        private bool IsValidConfigKey(string key)
+        {
+            if (string.IsNullOrWhiteSpace(key))
+                return false;
+
+            // Must not be too long
+            if (key.Length > 40)
+                return false;
+
+            // No control characters except spaces
+            if (key.Any(c => char.IsControl(c)))
+                return false;
+
+            // Should contain mostly alphanumeric or underscores
+            int validChars = key.Count(c => char.IsLetterOrDigit(c) || c == '_' || c == '-');
+
+            // At least 90% valid chars (more strict)
+            if (validChars < key.Length * 0.9)
+                return false;
+
+            // Must start with a letter or underscore
+            if (!char.IsLetter(key[0]) && key[0] != '_')
+                return false;
+
+            // Common patterns that indicate it's not a config key
+            if (key.Contains("  ") || key.Contains("\t"))
+                return false;
+
+            return true;
+        }
+
+        private bool IsValidStringValue(string value)
+        {
+            if (string.IsNullOrEmpty(value))
+                return true; // Empty strings are valid
+
+            // Check for excessive control characters
+            int controlChars = value.Count(c => char.IsControl(c) && c != '\r' && c != '\n' && c != '\t');
+            return controlChars < value.Length * 0.3; // Less than 30% control chars
+        }
+
+        private bool IsNearRulesMarker(int offset, int distance)
+        {
+            // Check if there's a "Rules" marker nearby
+            byte[] rulesPattern = new byte[] { 0x05, 0x52, 0x75, 0x6C, 0x65, 0x73 };
+
+            int start = Math.Max(0, offset - distance);
+            int end = Math.Min(_originalData.Length - rulesPattern.Length, offset + distance);
+
+            for (int i = start; i < end; i++)
+            {
+                if (MatchesPattern(_originalData, i, rulesPattern))
+                    return true;
+            }
+
+            return false;
+        }
+
+        private void ExtractActionMappings(EnhancedSetFile setFile)
+        {
+            Console.WriteLine("\nExtracting action mappings...");
+
+            // Search for all "Rules" patterns (05 52 75 6C 65 73)
+            byte[] rulesPattern = new byte[] { 0x05, 0x52, 0x75, 0x6C, 0x65, 0x73 };
+
+            for (int i = 0; i < _originalData.Length - rulesPattern.Length - 100; i++)
+            {
+                if (MatchesPattern(_originalData, i, rulesPattern))
+                {
+                    var mapping = TryExtractActionMapping(i);
+                    if (mapping != null)
+                    {
+                        setFile.ActionMappings.Add(mapping);
+                    }
+                }
+            }
+
+            Console.WriteLine($"Found {setFile.ActionMappings.Count} action mappings");
+        }
+
+        private ActionMappingEntry TryExtractActionMapping(int rulesOffset)
+        {
+            try
+            {
+                var entry = new ActionMappingEntry
+                {
+                    FileOffset = rulesOffset,
+                    RulesMarkerOffset = rulesOffset
+                };
+
+                // Position after "Rules" marker
+                int pos = rulesOffset + 6; // Skip "05 Rules"
+
+                if (pos + 10 > _originalData.Length) return null;
+
+                // Skip metadata bytes (usually 0x00-0x04)
+                while (pos < _originalData.Length && _originalData[pos] <= 0x04)
+                {
+                    pos++;
+                }
+
+                int actionDataStart = pos;
+
+                // Extract action strings using pattern 07 01 40 <len_2bytes> <data>
+                var actions = new List<string>();
+                int consecutiveFailures = 0;
+                int maxAttempts = 200;
+
+                while (maxAttempts-- > 0 && pos < _originalData.Length - 10)
+                {
+                    var action = TryReadActionStringAt(pos);
+                    if (action != null)
+                    {
+                        actions.Add(action);
+                        pos += 5 + Encoding.UTF8.GetByteCount(action);
+                        consecutiveFailures = 0;
+                    }
+                    else
+                    {
+                        pos++;
+                        consecutiveFailures++;
+                        if (consecutiveFailures > 100) break;
+                    }
+                }
+
+                if (actions.Count > 0)
+                {
+                    entry.Actions = actions;
+                    entry.ActionDataStartOffset = actionDataStart;
+                    entry.ActionDataEndOffset = pos;
+
+                    // Store original bytes
+                    int length = pos - rulesOffset;
+                    entry.OriginalBytes = new byte[length];
+                    Array.Copy(_originalData, rulesOffset, entry.OriginalBytes, 0, length);
+
+                    return entry;
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Error at offset {rulesOffset}: {ex.Message}");
+            }
+
+            return null;
+        }
+
+        private string TryReadActionStringAt(int pos)
+        {
+            // Pattern: 07 01 40 <len_2bytes_LE> <data>
+            if (pos + 5 > _originalData.Length) return null;
+
+            if (_originalData[pos] != 0x07 ||
+                _originalData[pos + 1] != 0x01 ||
+                _originalData[pos + 2] != 0x40)
+                return null;
+
+            ushort length = BitConverter.ToUInt16(_originalData, pos + 3);
+            if (length == 0 || length > 500 || pos + 5 + length > _originalData.Length)
+                return null;
+
+            try
+            {
+                string result = Encoding.UTF8.GetString(_originalData, pos + 5, length);
+
+                // Validate it looks like an action string
+                if (result.Length > 3 && result.All(c => c >= 32 || c == '\t' || c == '\n' || c == '\r'))
+                {
+                    return result;
+                }
+            }
+            catch
+            {
+                // Ignore decode errors
+            }
+
+            return null;
+        }
+
+        private void ExtractSectionNames(EnhancedSetFile setFile)
+        {
+            Console.WriteLine("\nExtracting section names...");
+
+            // Look for Pascal strings that appear to be section names
+            // Characteristics: reasonable length (5-50 chars), mostly alphanumeric
+            HashSet<string> foundNames = new HashSet<string>();
+
+            for (int i = 0; i < _originalData.Length - 10; i++)
+            {
+                if (_originalData[i] == 0x07) // String marker
+                {
+                    i++;
+                    if (i >= _originalData.Length)
+                        break;
+
+                    byte len = _originalData[i];
+                    if (len >= 5 && len <= 50 && i + 1 + len <= _originalData.Length)
+                    {
+                        try
+                        {
+                            string name = Encoding.UTF8.GetString(_originalData, i + 1, len);
+
+                            // Check if it looks like a section name
+                            if (IsLikelySectionName(name) && !foundNames.Contains(name))
+                            {
+                                foundNames.Add(name);
+                                setFile.SectionNames.Add(new SectionNameEntry
+                                {
+                                    FileOffset = i - 1,
+                                    Name = name
+                                });
+                            }
+                        }
+                        catch
+                        {
+                            // Ignore decode errors
+                        }
+                    }
+                }
+            }
+
+            Console.WriteLine($"Found {setFile.SectionNames.Count} unique section names");
+        }
+
+        private bool IsLikelySectionName(string name)
+        {
+            if (string.IsNullOrWhiteSpace(name))
+                return false;
+
+            // Should be mostly letters, numbers, underscores
+            // Common section names: "Alarms", "Cameras", "GeViIO", "Description", "Name", "IpHost"
+            int validChars = name.Count(c => char.IsLetterOrDigit(c) || c == '_' || c == ' ');
+
+            // At least 80% valid characters
+            return validChars >= name.Length * 0.8;
+        }
+
+        private string ReadPascalString()
+        {
+            if (_position >= _originalData.Length)
+                return null;
+
+            byte length = _originalData[_position++];
+            if (length == 0 || _position + length > _originalData.Length)
+                return null;
+
+            string result = Encoding.UTF8.GetString(_originalData, _position, length);
+            _position += length;
+            return result;
+        }
+
+        private bool MatchesPattern(byte[] data, int offset, byte[] pattern)
+        {
+            if (offset + pattern.Length > data.Length)
+                return false;
+
+            for (int i = 0; i < pattern.Length; i++)
+            {
+                if (data[offset + i] != pattern[i])
+                    return false;
+            }
+
+            return true;
+        }
+    }
+}

GeViSetEditor/GeViSetEditor.Core/Parsers/InPlaceConfigModifier.cs

@@ -0,0 +1,150 @@
+using System;
+using System.Text;
+using GeViSetEditor.Core.Models;
+
+namespace GeViSetEditor.Core.Parsers
+{
+    /// <summary>
+    /// Modifies configuration in-place to preserve binary structure
+    /// Safer approach for edit operations
+    /// </summary>
+    public class InPlaceConfigModifier
+    {
+        /// <summary>
+        /// Modify a node's value in the original data array
+        /// Only works for fixed-size types (boolean, integer)
+        /// </summary>
+        public bool ModifyNode(byte[] data, ConfigNode node, object newValue)
+        {
+            if (node == null || data == null)
+                return false;
+
+            switch (node.NodeType)
+            {
+                case "boolean":
+                    return ModifyBoolean(data, node, newValue);
+
+                case "integer":
+                    return ModifyInteger(data, node, newValue);
+
+                case "string":
+                    // Strings are variable length - can only modify if same length
+                    return ModifyString(data, node, newValue);
+
+                default:
+                    return false;
+            }
+        }
+
+        private bool ModifyBoolean(byte[] data, ConfigNode node, object newValue)
+        {
+            try
+            {
+                // Boolean structure: 01 <value>
+                // Value is at StartOffset + 1
+                int valueOffset = node.StartOffset + 1;
+
+                if (valueOffset >= data.Length)
+                    return false;
+
+                bool boolValue = Convert.ToBoolean(newValue);
+                data[valueOffset] = boolValue ? (byte)1 : (byte)0;
+
+                // Update node value
+                node.Value = boolValue;
+                return true;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        private bool ModifyInteger(byte[] data, ConfigNode node, object newValue)
+        {
+            try
+            {
+                // Integer structure: 04 <int32_LE>
+                // Value is at StartOffset + 1
+                int valueOffset = node.StartOffset + 1;
+
+                if (valueOffset + 4 > data.Length)
+                    return false;
+
+                int intValue = Convert.ToInt32(newValue);
+                byte[] bytes = BitConverter.GetBytes(intValue);
+
+                Array.Copy(bytes, 0, data, valueOffset, 4);
+
+                // Update node value
+                node.Value = intValue;
+                return true;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        private bool ModifyString(byte[] data, ConfigNode node, object newValue)
+        {
+            try
+            {
+                // String structure: 07 <len> <data>
+                // Original length at StartOffset + 1
+                int lengthOffset = node.StartOffset + 1;
+
+                if (lengthOffset >= data.Length)
+                    return false;
+
+                byte originalLength = data[lengthOffset];
+                string newString = newValue?.ToString() ?? "";
+                byte[] newBytes = Encoding.UTF8.GetBytes(newString);
+
+                // Can only modify if new string has same length
+                if (newBytes.Length != originalLength)
+                {
+                    Console.WriteLine($"  ⚠ Cannot modify string: length mismatch (original={originalLength}, new={newBytes.Length})");
+                    return false;
+                }
+
+                // Copy new string data
+                int dataOffset = lengthOffset + 1;
+                Array.Copy(newBytes, 0, data, dataOffset, newBytes.Length);
+
+                // Update node value
+                node.Value = newString;
+                return true;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Check if a node can be modified in-place
+        /// </summary>
+        public bool CanModify(ConfigNode node, object newValue)
+        {
+            if (node == null)
+                return false;
+
+            switch (node.NodeType)
+            {
+                case "boolean":
+                case "integer":
+                    return true;
+
+                case "string":
+                    // String can only be modified if same length
+                    string currentStr = node.Value?.ToString() ?? "";
+                    string newStr = newValue?.ToString() ?? "";
+                    return Encoding.UTF8.GetByteCount(currentStr) == Encoding.UTF8.GetByteCount(newStr);
+
+                default:
+                    return false;
+            }
+        }
+    }
+}

GeViSetEditor/GeViSetEditor.Core/Parsers/SafeSetFileParser.cs

@@ -0,0 +1,189 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using GeViSetEditor.Core.Models;
+
+namespace GeViSetEditor.Core.Parsers
+{
+    /// <summary>
+    /// Safe parser that preserves original binary data for round-trip conversion
+    /// Only parses action mappings, keeps everything else as-is
+    /// </summary>
+    public class SafeSetFileParser
+    {
+        private byte[] _originalData;
+        private int _position;
+
+        public SafeSetFile Parse(byte[] data)
+        {
+            _originalData = data;
+            _position = 0;
+
+            var setFile = new SafeSetFile
+            {
+                OriginalData = data,
+                FileSize = data.Length
+            };
+
+            // Read header
+            if (_position < data.Length && data[_position] == 0x00)
+                _position++;
+
+            string header = ReadPascalString();
+            setFile.Header = header ?? "GeViSoft Parameters";
+
+            Console.WriteLine($"Parsing .set file: {data.Length} bytes, header: '{setFile.Header}'");
+
+            // Find and extract all action mappings without disturbing the rest
+            ExtractActionMappings(setFile);
+
+            return setFile;
+        }
+
+        private void ExtractActionMappings(SafeSetFile setFile)
+        {
+            // Search for all "Rules" patterns (05 52 75 6C 65 73)
+            byte[] rulesPattern = new byte[] { 0x05, 0x52, 0x75, 0x6C, 0x65, 0x73 };
+
+            for (int i = 0; i < _originalData.Length - rulesPattern.Length - 100; i++)
+            {
+                if (MatchesPattern(_originalData, i, rulesPattern))
+                {
+                    var mapping = TryExtractActionMapping(i);
+                    if (mapping != null)
+                    {
+                        setFile.ActionMappings.Add(mapping);
+                    }
+                }
+            }
+
+            Console.WriteLine($"Extracted {setFile.ActionMappings.Count} action mappings");
+        }
+
+        private ActionMappingEntry TryExtractActionMapping(int rulesOffset)
+        {
+            try
+            {
+                var entry = new ActionMappingEntry
+                {
+                    FileOffset = rulesOffset,
+                    RulesMarkerOffset = rulesOffset
+                };
+
+                // Position after "Rules" marker
+                int pos = rulesOffset + 6; // Skip "05 Rules"
+
+                // Read what appears to be count/metadata
+                if (pos + 10 > _originalData.Length) return null;
+
+                // Skip metadata bytes
+                while (pos < _originalData.Length && _originalData[pos] <= 0x04)
+                {
+                    pos++;
+                }
+
+                // Store start of action data
+                int actionDataStart = pos;
+
+                // Extract action strings using pattern 07 01 40 <len_2bytes> <data>
+                var actions = new List<string>();
+                int consecutiveFailures = 0;
+                int maxAttempts = 200;
+
+                while (maxAttempts-- > 0 && pos < _originalData.Length - 10)
+                {
+                    var action = TryReadActionStringAt(pos);
+                    if (action != null)
+                    {
+                        actions.Add(action);
+                        pos += 5 + Encoding.UTF8.GetByteCount(action); // 07 01 40 + 2-byte len + data
+                        consecutiveFailures = 0;
+                    }
+                    else
+                    {
+                        pos++;
+                        consecutiveFailures++;
+                        if (consecutiveFailures > 100) break;
+                    }
+                }
+
+                if (actions.Count > 0)
+                {
+                    entry.Actions = actions;
+                    entry.ActionDataStartOffset = actionDataStart;
+                    entry.ActionDataEndOffset = pos;
+
+                    // Store original bytes for this mapping
+                    int length = pos - rulesOffset;
+                    entry.OriginalBytes = new byte[length];
+                    Array.Copy(_originalData, rulesOffset, entry.OriginalBytes, 0, length);
+
+                    return entry;
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Error extracting mapping at offset {rulesOffset}: {ex.Message}");
+            }
+
+            return null;
+        }
+
+        private string TryReadActionStringAt(int pos)
+        {
+            // Pattern: 07 01 40 <len_2bytes> <data>
+            if (pos + 5 > _originalData.Length) return null;
+
+            if (_originalData[pos] != 0x07 ||
+                _originalData[pos + 1] != 0x01 ||
+                _originalData[pos + 2] != 0x40)
+                return null;
+
+            int length = BitConverter.ToUInt16(_originalData, pos + 3);
+            if (length == 0 || length > 500 || pos + 5 + length > _originalData.Length)
+                return null;
+
+            try
+            {
+                string result = Encoding.UTF8.GetString(_originalData, pos + 5, length);
+
+                // Validate it looks like an action string
+                if (string.IsNullOrWhiteSpace(result) || result.Length < 3)
+                    return null;
+
+                return result;
+            }
+            catch
+            {
+                return null;
+            }
+        }
+
+        private bool MatchesPattern(byte[] data, int offset, byte[] pattern)
+        {
+            if (offset + pattern.Length > data.Length)
+                return false;
+
+            for (int i = 0; i < pattern.Length; i++)
+            {
+                if (data[offset + i] != pattern[i])
+                    return false;
+            }
+            return true;
+        }
+
+        private string ReadPascalString()
+        {
+            if (_position + 2 > _originalData.Length || _originalData[_position] != 0x07)
+                return null;
+
+            byte length = _originalData[_position + 1];
+            if (_position + 2 + length > _originalData.Length || length == 0)
+                return null;
+
+            string result = Encoding.UTF8.GetString(_originalData, _position + 2, length);
+            _position += 2 + length;
+            return result;
+        }
+    }
+}

GeViSetEditor/GeViSetEditor.Core/Parsers/SetFileParser.cs

@@ -0,0 +1,559 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Linq;
+using GeViSetEditor.Core.Models;
+
+namespace GeViSetEditor.Core.Parsers
+{
+    /// <summary>
+    /// Parser for GeViSet .set configuration files (binary format)
+    /// Format: Proprietary binary with sections, rules, and action mappings
+    /// </summary>
+    public class SetFileParser
+    {
+        private byte[] _data;
+        private int _position;
+
+        public GeViSetConfiguration Parse(string filePath)
+        {
+            _data = File.ReadAllBytes(filePath);
+            _position = 0;
+
+            var config = new GeViSetConfiguration();
+
+            // Read header
+            if (_data[_position] == 0x00) _position++; // Skip initial marker
+            config.Header = ReadPascalString() ?? "GeViSoft Parameters";
+
+            Console.WriteLine($"Parsing {filePath} ({_data.Length:N0} bytes)");
+            Console.WriteLine($"Header: {config.Header}\n");
+
+            // Parse all sections until end of file
+            int sectionCount = 0;
+            while (_position < _data.Length - 20)
+            {
+                var section = TryParseSection();
+                if (section != null)
+                {
+                    config.Sections.Add(section);
+                    sectionCount++;
+                    Console.WriteLine($"Section {sectionCount}: {section.Name} ({section.Items.Count} items, {section.Rules.Count} rules) - pos: {_position}");
+                }
+                else
+                {
+                    _position++; // Skip unknown byte
+                }
+            }
+
+            Console.WriteLine($"\nTotal: {sectionCount} sections parsed");
+
+            // Second pass: Find all "Rules" markers and extract action mappings directly
+            Console.WriteLine($"\nSearching for Rules sections...");
+            ExtractRulesDirectly(config);
+
+            return config;
+        }
+
+        private void ExtractRulesDirectly(GeViSetConfiguration config)
+        {
+            // Search for pattern: 05 52 75 6C 65 73 = "05 Rules"
+            byte[] rulesPattern = new byte[] { 0x05, 0x52, 0x75, 0x6C, 0x65, 0x73 };
+
+            for (int i = 0; i < _data.Length - rulesPattern.Length; i++)
+            {
+                bool match = true;
+                for (int j = 0; j < rulesPattern.Length; j++)
+                {
+                    if (_data[i + j] != rulesPattern[j])
+                    {
+                        match = false;
+                        break;
+                    }
+                }
+
+                if (match)
+                {
+                    Console.WriteLine($"  Found Rules pattern at offset {i} (0x{i:X})");
+                    _position = i + rulesPattern.Length;
+
+                    // Create or find a section for these rules
+                    var rulesSection = config.Sections.FirstOrDefault(s => s.Name == "ActionMappings");
+                    if (rulesSection == null)
+                    {
+                        rulesSection = new Section { Name = "ActionMappings" };
+                        config.Sections.Add(rulesSection);
+                    }
+
+                    // Try to parse rules from this location
+                    ParseRulesSection(rulesSection);
+
+                    Console.WriteLine($"    Extracted {rulesSection.Rules.Count} rules");
+                }
+            }
+        }
+
+        private Section TryParseSection()
+        {
+            int startPos = _position;
+
+            // Try to read section name
+            string sectionName = ReadPascalString();
+            if (string.IsNullOrEmpty(sectionName) || sectionName.Length > 50)
+            {
+                _position = startPos;
+                return null;
+            }
+
+            var section = new Section { Name = sectionName };
+
+            // Parse section contents
+            int maxIterations = 1000; // Safety limit
+            while (_position < _data.Length - 10 && maxIterations-- > 0)
+            {
+                // Check for "Rules" subsection (can be Pascal string OR length-prefixed)
+                int savePos = _position;
+
+                // Try Pascal string first (0x07 marker)
+                string possibleRules = ReadPascalString();
+                if (possibleRules == "Rules")
+                {
+                    Console.WriteLine($"  Found Rules subsection (Pascal) at offset {savePos} in section '{sectionName}'");
+                    ParseRulesSection(section);
+                    break; // Rules typically end a section
+                }
+
+                // Rewind and try length-prefixed format (no 0x07 marker)
+                _position = savePos;
+                possibleRules = ReadLengthPrefixedString();
+                if (possibleRules == "Rules")
+                {
+                    Console.WriteLine($"  Found Rules subsection (LenPrefix) at offset {savePos} in section '{sectionName}'");
+                    ParseRulesSection(section);
+                    break; // Rules typically end a section
+                }
+
+                // Neither worked, rewind
+                _position = savePos;
+
+                // Try to read a config item
+                var item = TryReadConfigItem();
+                if (item != null)
+                {
+                    section.Items.Add(item);
+                }
+                else
+                {
+                    // Check if we've hit the next section or end
+                    if (IsLikelySectionStart())
+                        break;
+                    _position++;
+                }
+            }
+
+            return section;
+        }
+
+        private void ParseRulesSection(Section section)
+        {
+            int startRuleCount = section.Rules.Count;
+            int startPos = _position;
+
+            // Skip count/metadata bytes
+            while (_position < _data.Length && _data[_position] <= 0x04)
+            {
+                _position++;
+            }
+
+            Console.WriteLine($"      ParseRulesSection: start={startPos}, after skip={_position}, bytes: {BitConverter.ToString(_data, _position, Math.Min(20, _data.Length - _position))}");
+
+            // Parse rules - keep trying until we stop finding action strings
+            int maxRules = 100;
+            int attempts = 0;
+            int consecutiveFails = 0;
+
+            while (maxRules-- > 0 && _position < _data.Length - 20)
+            {
+                int beforePos = _position;
+                var rule = TryParseRule();
+                attempts++;
+
+                if (rule != null)
+                {
+                    section.Rules.Add(rule);
+                    Console.WriteLine($"      Found rule at pos {beforePos}, now at {_position}");
+                    consecutiveFails = 0;
+                }
+                else
+                {
+                    _position++;
+                    consecutiveFails++;
+
+                    // Stop if we've had too many consecutive failures
+                    if (consecutiveFails > 100)
+                    {
+                        Console.WriteLine($"      Too many consecutive failures at {_position}, stopping");
+                        break;
+                    }
+                }
+
+                if (attempts > 200) break; // Safety limit
+            }
+
+            Console.WriteLine($"      ParseRulesSection complete: extracted {section.Rules.Count - startRuleCount} rules");
+        }
+
+        private ActionRule TryParseRule()
+        {
+            int startPos = _position;
+
+            // Look for rule marker: 01 <id>
+            if (_position + 2 >= _data.Length || _data[_position] != 0x01)
+            {
+                _position = startPos;
+                return null;
+            }
+
+            var rule = new ActionRule
+            {
+                RuleId = _data[_position + 1]
+            };
+            _position += 2;
+
+            // Skip size bytes (05 00 00 00 or 0a 00 00 00 patterns)
+            if (_position + 4 < _data.Length && (_data[_position] == 0x05 || _data[_position] == 0x0a))
+            {
+                _position += 4;
+            }
+
+            // Read trigger properties (fields starting with .)
+            for (int i = 0; i < 30; i++) // Max 30 properties
+            {
+                if (_position >= _data.Length) break;
+
+                // Check for property field (01 <len> .<name>)
+                if (_data[_position] == 0x01 && _position + 2 < _data.Length)
+                {
+                    int len = _data[_position + 1];
+                    if (len > 0 && len < 50 && _position + 2 + len < _data.Length)
+                    {
+                        string propName = Encoding.UTF8.GetString(_data, _position + 2, len);
+                        _position += 2 + len;
+
+                        // Read boolean value
+                        if (_position < _data.Length)
+                        {
+                            bool value = _data[_position++] != 0;
+                            if (propName.StartsWith("."))
+                            {
+                                rule.TriggerProperties[propName] = value;
+                            }
+                        }
+                    }
+                    else
+                    {
+                        break;
+                    }
+                }
+                else
+                {
+                    break;
+                }
+            }
+
+            // Read main action string (07 01 40 <len_2bytes> <data>)
+            string mainAction = ReadActionString();
+            if (!string.IsNullOrEmpty(mainAction))
+            {
+                rule.MainAction = mainAction;
+            }
+
+            // Skip metadata (04 02 40... patterns)
+            SkipMetadata();
+
+            // Look for nested Rules section (action variations)
+            int checkPos = _position;
+            string nestedRules = ReadPascalString();
+            if (nestedRules == "Rules")
+            {
+                ParseActionVariations(rule);
+            }
+            else
+            {
+                // Try length-prefixed format
+                _position = checkPos;
+                nestedRules = ReadLengthPrefixedString();
+                if (nestedRules == "Rules")
+                {
+                    ParseActionVariations(rule);
+                }
+                else
+                {
+                    _position = checkPos; // Rewind if not "Rules"
+                }
+            }
+
+            // Only return rule if it has meaningful data
+            if (!string.IsNullOrEmpty(rule.MainAction) || rule.TriggerProperties.Count > 0)
+            {
+                return rule;
+            }
+
+            _position = startPos;
+            return null;
+        }
+
+        private void ParseActionVariations(ActionRule rule)
+        {
+            // Skip count bytes
+            while (_position < _data.Length && _data[_position] <= 0x04)
+            {
+                _position++;
+            }
+
+            // Parse each variation
+            int maxVariations = 30;
+            while (maxVariations-- > 0 && _position < _data.Length - 20)
+            {
+                var variation = TryParseActionVariation();
+                if (variation != null)
+                {
+                    rule.ActionVariations.Add(variation);
+                }
+                else
+                {
+                    if (IsLikelySectionStart())
+                        break;
+
+                    // Look ahead for next variation
+                    bool foundNext = false;
+                    for (int i = 1; i < 20 && _position + i < _data.Length; i++)
+                    {
+                        if (_data[_position + i] == 0x01 && _position + i + 1 < _data.Length)
+                        {
+                            _position += i;
+                            foundNext = true;
+                            break;
+                        }
+                    }
+
+                    if (!foundNext)
+                        break;
+                }
+            }
+        }
+
+        private ActionVariation TryParseActionVariation()
+        {
+            int startPos = _position;
+
+            // Look for variation marker: 01 <id>
+            if (_position + 2 >= _data.Length || _data[_position] != 0x01)
+            {
+                _position = startPos;
+                return null;
+            }
+
+            var variation = new ActionVariation
+            {
+                VariationId = _data[_position + 1]
+            };
+            _position += 2;
+
+            // Skip size (05 00 00 00)
+            if (_position + 4 < _data.Length && _data[_position] == 0x05)
+            {
+                _position += 4;
+            }
+
+            // Read action string
+            variation.ActionString = ReadActionString() ?? "";
+
+            // Skip metadata
+            SkipMetadata();
+
+            // Read action type (GscAction, GCoreAction, etc.)
+            string actionType = ReadPascalString();
+            if (actionType != null && actionType.Contains("Action"))
+            {
+                variation.ActionType = actionType;
+
+                // Read full command (another action string)
+                variation.FullCommand = ReadActionString() ?? "";
+
+                // Read server type
+                variation.ServerType = ReadPascalString() ?? "";
+
+                // Try to read server name
+                int savePos = _position;
+                string serverName = ReadPascalString();
+                if (!string.IsNullOrEmpty(serverName) && serverName.Length < 100 && !serverName.StartsWith("."))
+                {
+                    variation.ServerName = serverName;
+                }
+                else
+                {
+                    _position = savePos; // Rewind if not a valid server name
+                }
+            }
+
+            // Only return if we got meaningful data
+            if (!string.IsNullOrEmpty(variation.ActionString))
+            {
+                return variation;
+            }
+
+            _position = startPos;
+            return null;
+        }
+
+        private ConfigItem TryReadConfigItem()
+        {
+            int startPos = _position;
+
+            string name = ReadPascalString();
+            if (string.IsNullOrEmpty(name) || name.Length > 100)
+            {
+                _position = startPos;
+                return null;
+            }
+
+            // Try to read value
+            object value = ReadValue();
+            if (value == null)
+            {
+                _position = startPos;
+                return null;
+            }
+
+            return new ConfigItem
+            {
+                Name = name,
+                Value = value,
+                Type = value switch
+                {
+                    bool => ConfigValueType.Boolean,
+                    int => ConfigValueType.Integer,
+                    string => ConfigValueType.String,
+                    _ => ConfigValueType.Binary
+                }
+            };
+        }
+
+        // Helper methods for reading binary data
+
+        private string ReadPascalString()
+        {
+            if (_position + 2 > _data.Length || _data[_position] != 0x07)
+                return null;
+
+            byte length = _data[_position + 1];
+            if (_position + 2 + length > _data.Length || length == 0)
+                return null;
+
+            string result = Encoding.UTF8.GetString(_data, _position + 2, length);
+            _position += 2 + length;
+            return result;
+        }
+
+        private string ReadLengthPrefixedString()
+        {
+            // Simpler format: just <length_byte> <string_data> (no 0x07 marker)
+            if (_position + 1 > _data.Length)
+                return null;
+
+            byte length = _data[_position];
+            if (length == 0 || length > 50 || _position + 1 + length > _data.Length)
+                return null;
+
+            string result = Encoding.UTF8.GetString(_data, _position + 1, length);
+            _position += 1 + length;
+            return result;
+        }
+
+        private string ReadActionString()
+        {
+            // Action strings: 07 01 40 <len_2bytes> <data>
+            if (_position + 5 > _data.Length ||
+                _data[_position] != 0x07 ||
+                _data[_position + 1] != 0x01 ||
+                _data[_position + 2] != 0x40)
+                return null;
+
+            int length = BitConverter.ToUInt16(_data, _position + 3);
+            if (_position + 5 + length > _data.Length || length > 500)
+                return null;
+
+            string result = Encoding.UTF8.GetString(_data, _position + 5, length);
+            _position += 5 + length;
+            return result;
+        }
+
+        private object ReadValue()
+        {
+            if (_position >= _data.Length)
+                return null;
+
+            byte type = _data[_position];
+
+            switch (type)
+            {
+                case 0x01: // Boolean
+                    if (_position + 2 <= _data.Length)
+                    {
+                        _position++;
+                        return _data[_position++] != 0;
+                    }
+                    break;
+
+                case 0x04: // Integer
+                    if (_position + 5 <= _data.Length)
+                    {
+                        _position++;
+                        int value = BitConverter.ToInt32(_data, _position);
+                        _position += 4;
+                        return value;
+                    }
+                    break;
+
+                case 0x07: // String
+                    return ReadPascalString();
+            }
+
+            return null;
+        }
+
+        private void SkipMetadata()
+        {
+            // Skip common metadata patterns (04 02 40... and 04 0a...)
+            while (_position + 5 < _data.Length && _data[_position] == 0x04)
+            {
+                _position += 5;
+            }
+        }
+
+        private string PeekString(int length)
+        {
+            if (_position + length > _data.Length)
+                return "";
+            return Encoding.UTF8.GetString(_data, _position, length);
+        }
+
+        private bool IsLikelySectionStart()
+        {
+            if (_position + 10 >= _data.Length)
+                return true;
+
+            // Check for multiple nulls (section boundary)
+            int nullCount = 0;
+            for (int i = 0; i < Math.Min(10, _data.Length - _position); i++)
+            {
+                if (_data[_position + i] == 0x00)
+                    nullCount++;
+            }
+
+            return nullCount >= 4;
+        }
+    }
+}

GeViSetEditor/GeViSetEditor.Core/Writers/SafeSetFileWriter.cs

@@ -0,0 +1,173 @@
+using System;
+using System.IO;
+using System.Linq;
+using GeViSetEditor.Core.Models;
+
+namespace GeViSetEditor.Core.Writers
+{
+    /// <summary>
+    /// Safe writer that preserves binary integrity
+    /// Only modifies action mappings, keeps everything else intact
+    /// </summary>
+    public class SafeSetFileWriter
+    {
+        /// <summary>
+        /// Write SafeSetFile back to binary format
+        /// Returns byte array that can be sent to GeViServer
+        /// </summary>
+        public byte[] Write(SafeSetFile setFile)
+        {
+            if (setFile.OriginalData == null || setFile.OriginalData.Length == 0)
+            {
+                throw new InvalidOperationException("Cannot write: OriginalData is missing");
+            }
+
+            Console.WriteLine($"Writing .set file: {setFile.FileSize} bytes");
+            Console.WriteLine($"Action mappings: {setFile.ActionMappings.Count}");
+
+            // Start with exact copy of original data
+            byte[] output = setFile.GetDataForWriting();
+            Console.WriteLine($"  Output data created: {output.Length} bytes");
+
+            // Verify header is intact
+            if (VerifyHeader(output))
+            {
+                Console.WriteLine("  Header verification: PASSED");
+            }
+            else
+            {
+                Console.WriteLine("  Header verification: FAILED (proceeding anyway for round-trip test)");
+                // Don't throw - allow round-trip test to see byte comparison
+            }
+
+            // TODO: If action mappings were modified, update them here
+            // For now, we just preserve everything as-is for safe round-trip
+
+            Console.WriteLine($"Write complete: {output.Length} bytes");
+            return output;
+        }
+
+        /// <summary>
+        /// Write to file
+        /// </summary>
+        public void WriteToFile(SafeSetFile setFile, string filePath)
+        {
+            byte[] data = Write(setFile);
+
+            // Create backup if file exists
+            if (File.Exists(filePath))
+            {
+                string backupPath = filePath + ".backup";
+                File.Copy(filePath, backupPath, true);
+                Console.WriteLine($"Created backup: {backupPath}");
+            }
+
+            File.WriteAllBytes(filePath, data);
+            Console.WriteLine($"Wrote {data.Length} bytes to {filePath}");
+        }
+
+        /// <summary>
+        /// Verify the output file is valid before writing to server
+        /// </summary>
+        public bool Verify(byte[] data)
+        {
+            if (data == null || data.Length < 100)
+            {
+                Console.WriteLine("Verification failed: File too small");
+                return false;
+            }
+
+            if (!VerifyHeader(data))
+            {
+                Console.WriteLine("Verification failed: Invalid header");
+                return false;
+            }
+
+            // Additional checks
+            if (data.Length > 10 * 1024 * 1024) // 10MB max
+            {
+                Console.WriteLine("Verification failed: File too large");
+                return false;
+            }
+
+            Console.WriteLine("Verification passed");
+            return true;
+        }
+
+        private bool VerifyHeader(byte[] data)
+        {
+            // Check for "GeViSoft Parameters" header
+            string expectedHeader = "GeViSoft Parameters";
+
+            int offset = (data[0] == 0x00) ? 1 : 0;
+
+            if (offset + 2 + expectedHeader.Length > data.Length)
+                return false;
+
+            if (data[offset] != 0x07) // Pascal string marker
+                return false;
+
+            byte headerLen = data[offset + 1];
+            if (headerLen < 10 || headerLen > 50)
+                return false;
+
+            string actualHeader = System.Text.Encoding.UTF8.GetString(data, offset + 2, Math.Min(headerLen, expectedHeader.Length));
+
+            return actualHeader.StartsWith("GeViSoft");
+        }
+
+        /// <summary>
+        /// Compare two .set files for differences
+        /// Useful for testing round-trip conversion
+        /// </summary>
+        public ComparisonResult Compare(byte[] original, byte[] modified)
+        {
+            var result = new ComparisonResult
+            {
+                OriginalSize = original.Length,
+                ModifiedSize = modified.Length
+            };
+
+            if (original.Length != modified.Length)
+            {
+                result.IsIdentical = false;
+                result.Differences.Add($"Size mismatch: {original.Length} vs {modified.Length}");
+                return result;
+            }
+
+            for (int i = 0; i < original.Length; i++)
+            {
+                if (original[i] != modified[i])
+                {
+                    result.DifferentBytes++;
+                    if (result.Differences.Count < 10) // Limit to first 10 differences
+                    {
+                        result.Differences.Add($"Byte {i} (0x{i:X}): {original[i]:X2} != {modified[i]:X2}");
+                    }
+                }
+            }
+
+            result.IsIdentical = (result.DifferentBytes == 0);
+
+            if (result.IsIdentical)
+            {
+                Console.WriteLine("Files are identical!");
+            }
+            else
+            {
+                Console.WriteLine($"Files differ in {result.DifferentBytes} bytes");
+            }
+
+            return result;
+        }
+    }
+
+    public class ComparisonResult
+    {
+        public bool IsIdentical { get; set; }
+        public int OriginalSize { get; set; }
+        public int ModifiedSize { get; set; }
+        public int DifferentBytes { get; set; }
+        public List<string> Differences { get; set; } = new();
+    }
+}

GeViSetEditor/GeViSetEditor.sln

@@ -0,0 +1,48 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.0.31903.59
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GeViSetEditor.Core", "GeViSetEditor.Core\GeViSetEditor.Core.csproj", "{1D0E5C65-8C22-448B-B05F-F9FFD44DEB37}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GeViSetEditor.CLI", "GeViSetEditor.CLI\GeViSetEditor.CLI.csproj", "{3B6BCF80-F26D-4323-A08B-ACE8C093AD08}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
+		Release|Any CPU = Release|Any CPU
+		Release|x64 = Release|x64
+		Release|x86 = Release|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{1D0E5C65-8C22-448B-B05F-F9FFD44DEB37}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{1D0E5C65-8C22-448B-B05F-F9FFD44DEB37}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{1D0E5C65-8C22-448B-B05F-F9FFD44DEB37}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{1D0E5C65-8C22-448B-B05F-F9FFD44DEB37}.Debug|x64.Build.0 = Debug|Any CPU
+		{1D0E5C65-8C22-448B-B05F-F9FFD44DEB37}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{1D0E5C65-8C22-448B-B05F-F9FFD44DEB37}.Debug|x86.Build.0 = Debug|Any CPU
+		{1D0E5C65-8C22-448B-B05F-F9FFD44DEB37}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{1D0E5C65-8C22-448B-B05F-F9FFD44DEB37}.Release|Any CPU.Build.0 = Release|Any CPU
+		{1D0E5C65-8C22-448B-B05F-F9FFD44DEB37}.Release|x64.ActiveCfg = Release|Any CPU
+		{1D0E5C65-8C22-448B-B05F-F9FFD44DEB37}.Release|x64.Build.0 = Release|Any CPU
+		{1D0E5C65-8C22-448B-B05F-F9FFD44DEB37}.Release|x86.ActiveCfg = Release|Any CPU
+		{1D0E5C65-8C22-448B-B05F-F9FFD44DEB37}.Release|x86.Build.0 = Release|Any CPU
+		{3B6BCF80-F26D-4323-A08B-ACE8C093AD08}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{3B6BCF80-F26D-4323-A08B-ACE8C093AD08}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{3B6BCF80-F26D-4323-A08B-ACE8C093AD08}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{3B6BCF80-F26D-4323-A08B-ACE8C093AD08}.Debug|x64.Build.0 = Debug|Any CPU
+		{3B6BCF80-F26D-4323-A08B-ACE8C093AD08}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{3B6BCF80-F26D-4323-A08B-ACE8C093AD08}.Debug|x86.Build.0 = Debug|Any CPU
+		{3B6BCF80-F26D-4323-A08B-ACE8C093AD08}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{3B6BCF80-F26D-4323-A08B-ACE8C093AD08}.Release|Any CPU.Build.0 = Release|Any CPU
+		{3B6BCF80-F26D-4323-A08B-ACE8C093AD08}.Release|x64.ActiveCfg = Release|Any CPU
+		{3B6BCF80-F26D-4323-A08B-ACE8C093AD08}.Release|x64.Build.0 = Release|Any CPU
+		{3B6BCF80-F26D-4323-A08B-ACE8C093AD08}.Release|x86.ActiveCfg = Release|Any CPU
+		{3B6BCF80-F26D-4323-A08B-ACE8C093AD08}.Release|x86.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

GeViSetEditor/README.md

@@ -0,0 +1,40 @@
+# GeViSet Configuration Editor
+
+Tool to edit GeViSet .set configuration files via Excel.
+
+## Features
+
+- **Parse** `.set` files (binary format)
+- **Export** action mappings to Excel (.xlsx)
+- **Edit** mappings in Excel (user-friendly)
+- **Import** Excel back to `.set` format
+
+## Usage
+
+```bash
+# Export .set to Excel
+GeViSetEditor.exe export input.set output.xlsx
+
+# Import Excel to .set  
+GeViSetEditor.exe import input.xlsx output.set
+
+# View mappings
+GeViSetEditor.exe view input.set
+```
+
+## Project Structure
+
+- `GeViSetEditor.Core` - Parser/writer library
+- `GeViSetEditor.CLI` - Command-line tool
+
+## Format Discovered
+
+Binary format with:
+- Header: "GeViSoft Parameters"
+- Sections: Alarms, Clients, GeViIO, etc.
+- Rules: Trigger properties → Actions
+- Action variations: Platform-specific (GSC, GNG, GCore)
+
+## Next Steps
+
+Run with TestMKS.set to extract all action mappings to Excel for editing.