From 7cfe94dd809896f26d4fe3d2b941118c9e57a308 Mon Sep 17 00:00:00 2001
From: Jeff Hobson <jeffrey296@gmail.com>
Date: Wed, 9 Mar 2022 13:12:12 -0500
Subject: [PATCH 1/5] Accept incoming messages as JSON strings (BREAKING)

Require incoming messages to be serialized JSON strings. This is part 1
of a 2-part change to convert to JSON messaging.
---
 LiveSplit.Server.csproj          |  4 +++
 UI/Components/ServerComponent.cs | 55 ++++++++++++++++++++------------
 packages.config                  |  4 +++
 3 files changed, 42 insertions(+), 21 deletions(-)
 create mode 100644 packages.config

diff --git a/LiveSplit.Server.csproj b/LiveSplit.Server.csproj
index 91eecf1..53c5558 100644
--- a/LiveSplit.Server.csproj
+++ b/LiveSplit.Server.csproj
@@ -43,6 +43,9 @@
     <Prefer32Bit>false</Prefer32Bit>
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="Newtonsoft.Json, Version=13.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+      <HintPath>packages\Newtonsoft.Json.13.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
+    </Reference>
     <Reference Include="Noesis.Javascript">
       <HintPath>..\..\Libs\Noesis.Javascript v0.7 - Binaries\Noesis.Javascript.dll</HintPath>
     </Reference>
@@ -89,6 +92,7 @@
       <Name>UpdateManager</Name>
       <Private>False</Private>
     </ProjectReference>
+    <None Include="packages.config" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/UI/Components/ServerComponent.cs b/UI/Components/ServerComponent.cs
index 0c1a32c..d9a1b89 100644
--- a/UI/Components/ServerComponent.cs
+++ b/UI/Components/ServerComponent.cs
@@ -1,6 +1,7 @@
 using LiveSplit.Model;
 using LiveSplit.Options;
 using LiveSplit.TimeFormatters;
+using Newtonsoft.Json;
 using System;
 using System.Collections.Generic;
 using System.Drawing;
@@ -39,6 +40,15 @@ public class ServerComponent : IComponent
 
         public IDictionary<string, Action> ContextMenuControls { get; protected set; }
 
+        private class Message
+        {
+            public string Command { get; set; }
+
+            public Dictionary<string, object> Data { get; set; }
+
+            public string Nonce { get; set; }
+        }
+
         public ServerComponent(LiveSplitState state)
         {
             Settings = new Settings();
@@ -173,9 +183,8 @@ private void ProcessMessage(String message, Connection clientConnection)
             string response = null;
             try
             {
-                var args = message.Split(new [] { ' ' }, 2);
-                var command = args[0];
-                switch (command)
+                Message request = JsonConvert.DeserializeObject<Message>(message);
+                switch (request.Command)
                 {
                     case "startorsplit":
                     {
@@ -232,13 +241,13 @@ private void ProcessMessage(String message, Connection clientConnection)
                     }
                     case "setgametime":
                     {
-                        var time = parseTime(args[1]);
+                        var time = parseTime((string)request.Data["time"]);
                         State.SetGameTime(time);
                         break;
                     }
                     case "setloadingtimes":
                     {
-                        var time = parseTime(args[1]);
+                        var time = parseTime((string)request.Data["time"]);
                         State.LoadingTimes = time ?? TimeSpan.Zero;
                         break;
                     }
@@ -261,7 +270,8 @@ private void ProcessMessage(String message, Connection clientConnection)
                     }
                     case "getdelta":
                     {
-                        var comparison = args.Length > 1 ? args[1] : State.CurrentComparison;
+                        var data = (string)request.Data?["comparison"];
+                        var comparison = !string.IsNullOrEmpty(data) ? data : State.CurrentComparison;
                         TimeSpan? delta = null;
                         if (State.CurrentPhase == TimerPhase.Running || State.CurrentPhase == TimerPhase.Paused)
                             delta = LiveSplitStateHelper.GetLastDelta(State, State.CurrentSplitIndex, comparison, State.CurrentTimingMethod);
@@ -322,7 +332,8 @@ private void ProcessMessage(String message, Connection clientConnection)
                     {
                         if (State.CurrentSplit != null)
                         {
-                            var comparison = args.Length > 1 ? args[1] : State.CurrentComparison;
+                            var data = (string)request.Data?["comparison"];
+                            var comparison = !string.IsNullOrEmpty(data) ? data : State.CurrentComparison;
                             var time = State.CurrentSplit.Comparisons[comparison][State.CurrentTimingMethod];
                             response = SplitTimeFormatter.Format(time);
                         }
@@ -356,7 +367,8 @@ private void ProcessMessage(String message, Connection clientConnection)
                     case "getfinaltime":
                     case "getfinalsplittime":
                     {
-                        var comparison = args.Length > 1 ? args[1] : State.CurrentComparison;
+                        var data = (string)request.Data?["comparison"];
+                        var comparison = !string.IsNullOrEmpty(data) ? data : State.CurrentComparison;
                         var time = (State.CurrentPhase == TimerPhase.Ended)
                             ? State.CurrentTime[State.CurrentTimingMethod]
                             : State.Run.Last().Comparisons[comparison][State.CurrentTimingMethod];
@@ -367,10 +379,12 @@ private void ProcessMessage(String message, Connection clientConnection)
                     case "getpredictedtime":
                     {
                         string comparison;
-                        if (command == "getbestpossibletime")
+                        if (request.Command == "getbestpossibletime")
                             comparison = LiveSplit.Model.Comparisons.BestSegmentsComparisonGenerator.ComparisonName;
-                        else
-                            comparison = args.Length > 1 ? args[1] : State.CurrentComparison;
+                        else {
+                            var data = (string)request.Data?["comparison"];
+                            comparison = !string.IsNullOrEmpty(data) ? data : State.CurrentComparison;
+                        }
                         var prediction = PredictTime(State, comparison);
                         response = SplitTimeFormatter.Format(prediction);
                         break;
@@ -383,30 +397,29 @@ private void ProcessMessage(String message, Connection clientConnection)
                     }
                     case "setcomparison":
                     {
-                        State.CurrentComparison = args[1];
+                        State.CurrentComparison = (string)request.Data["comparison"];
                         break;
                     }
                     case "switchto":
                     {
-                        State.CurrentTimingMethod = args[1] == "gametime" ? TimingMethod.GameTime : TimingMethod.RealTime;
+                        State.CurrentTimingMethod = (string)request.Data["timingMethod"] == "gametime" ? TimingMethod.GameTime : TimingMethod.RealTime;
                         break;
                     }
                     case "setsplitname":
                     case "setcurrentsplitname":
                     {
-                        var index = State.CurrentSplitIndex;
-                        var title = args[1];
+                        int index = State.CurrentSplitIndex;
+                        string name = (string)request.Data["name"];
 
-                        if (command == "setsplitname")
+                        if (request.Command == "setsplitname")
                         {
-                            var options = args[1].Split(new [] { ' ' }, 2);
-                            index = Convert.ToInt32(options[0]);
-                            title = options[1];
+                            index = (int)request.Data["index"];
+                            name = (string)request.Data["name"];
                         }
 
                         if (index >= 0 && index < State.Run.Count)
                         {
-                            State.Run[index].Name = title;
+                            State.Run[index].Name = name;
                             State.Run.HasChanged = true;
                         }
 
@@ -414,7 +427,7 @@ private void ProcessMessage(String message, Connection clientConnection)
                     }
                     default:
                     {
-                        throw new Exception($"Unrecognized command: \"{command}\"");
+                        throw new Exception($"Unrecognized command: \"{request.Command}\"");
                     }
                 }
             }
diff --git a/packages.config b/packages.config
new file mode 100644
index 0000000..ce3dc38
--- /dev/null
+++ b/packages.config
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="Newtonsoft.Json" version="13.0.1" targetFramework="net461" />
+</packages>
\ No newline at end of file

From e03a651ebc91adc1129aa3165b3c479e02af9be1 Mon Sep 17 00:00:00 2001
From: Jeff Hobson <jeffrey296@gmail.com>
Date: Thu, 10 Mar 2022 14:30:41 -0500
Subject: [PATCH 2/5] Send messages as JSON strings for all commands

All commands now respond with a message consisting of a JSON string
---
 UI/Components/ServerComponent.cs | 86 ++++++++++++++------------------
 1 file changed, 38 insertions(+), 48 deletions(-)

diff --git a/UI/Components/ServerComponent.cs b/UI/Components/ServerComponent.cs
index d9a1b89..d71a1bb 100644
--- a/UI/Components/ServerComponent.cs
+++ b/UI/Components/ServerComponent.cs
@@ -2,6 +2,7 @@
 using LiveSplit.Options;
 using LiveSplit.TimeFormatters;
 using Newtonsoft.Json;
+using Newtonsoft.Json.Serialization;
 using System;
 using System.Collections.Generic;
 using System.Drawing;
@@ -44,6 +45,8 @@ private class Message
         {
             public string Command { get; set; }
 
+            public string Status { get; set; }
+
             public Dictionary<string, object> Data { get; set; }
 
             public string Nonce { get; set; }
@@ -180,10 +183,13 @@ void connection_MessageReceived(object sender, MessageEventArgs e)
 
         private void ProcessMessage(String message, Connection clientConnection)
         {
-            string response = null;
+            Message response = new Message{ Status = "success", Data = new Dictionary<string, object>() };
             try
             {
                 Message request = JsonConvert.DeserializeObject<Message>(message);
+                response.Command = request.Command;
+                response.Nonce = request.Nonce;
+
                 switch (request.Command)
                 {
                     case "startorsplit":
@@ -279,38 +285,25 @@ private void ProcessMessage(String message, Connection clientConnection)
                             delta = State.Run.Last().SplitTime[State.CurrentTimingMethod] - State.Run.Last().Comparisons[comparison][State.CurrentTimingMethod];
 
                         // Defaults to "-" when delta is null, such as when State.CurrentPhase == TimerPhase.NotRunning
-                        response = DeltaFormatter.Format(delta);
+                        response.Data.Add("delta", DeltaFormatter.Format(delta));
                         break;
                     }
                     case "getsplitindex":
                     {
                         var splitindex = State.CurrentSplitIndex;
-                        response = splitindex.ToString();
+                        response.Data.Add("splitIndex", splitindex.ToString());
                         break;
                     }
                     case "getcurrentsplitname":
                     {
-                        if (State.CurrentSplit != null)
-                        {
-                            response = State.CurrentSplit.Name;
-                        }
-                        else
-                        {
-                            response = "-";
-                        }
+                        response.Data.Add("currentSplitName", State.CurrentSplit?.Name);
                         break;
                     }
                     case "getlastsplitname":
                     case "getprevioussplitname":
                     {
-                        if (State.CurrentSplitIndex > 0)
-                        {
-                            response = State.Run[State.CurrentSplitIndex - 1].Name;
-                        }
-                        else
-                        {
-                            response = "-";
-                        }
+                        response.Data.Add("previousSplitName",
+                            State.CurrentSplitIndex > 0 ? State.Run[State.CurrentSplitIndex - 1].Name : null);
                         break;
                     }
                     case "getlastsplittime":
@@ -319,11 +312,11 @@ private void ProcessMessage(String message, Connection clientConnection)
                         if (State.CurrentSplitIndex > 0)
                         {
                             var time = State.Run[State.CurrentSplitIndex - 1].SplitTime[State.CurrentTimingMethod];
-                            response = SplitTimeFormatter.Format(time);
+                            response.Data.Add("previousSplitTime", SplitTimeFormatter.Format(time));
                         }
                         else
                         {
-                            response = "-";
+                            response.Data.Add("previousSplitTime", null);
                         }
                         break;
                     }
@@ -335,33 +328,29 @@ private void ProcessMessage(String message, Connection clientConnection)
                             var data = (string)request.Data?["comparison"];
                             var comparison = !string.IsNullOrEmpty(data) ? data : State.CurrentComparison;
                             var time = State.CurrentSplit.Comparisons[comparison][State.CurrentTimingMethod];
-                            response = SplitTimeFormatter.Format(time);
+                            response.Data.Add("currentSplitTime", SplitTimeFormatter.Format(time));
                         }
                         else
                         {
-                            response = "-";
+                            response.Data.Add("currentSplitTime", null);
                         }
                         break;
                     }
                     case "getcurrentrealtime":
                     {
-                        response = SplitTimeFormatter.Format(State.CurrentTime.RealTime);
+                        response.Data.Add("currentRealTime", SplitTimeFormatter.Format(State.CurrentTime.RealTime));
                         break;
                     }
                     case "getcurrentgametime":
                     {
-                        var timingMethod = TimingMethod.GameTime;
-                        if (!State.IsGameTimeInitialized)
-                            timingMethod = TimingMethod.RealTime;
-                        response = SplitTimeFormatter.Format(State.CurrentTime[timingMethod]);
+                        var timingMethod = State.IsGameTimeInitialized ? TimingMethod.GameTime : TimingMethod.RealTime;
+                        response.Data.Add("currentGameTime", SplitTimeFormatter.Format(State.CurrentTime[timingMethod]));
                         break;
                     }
                     case "getcurrenttime":
                     {
-                        var timingMethod = State.CurrentTimingMethod;
-                        if (timingMethod == TimingMethod.GameTime && !State.IsGameTimeInitialized)
-                            timingMethod = TimingMethod.RealTime;
-                        response = SplitTimeFormatter.Format(State.CurrentTime[timingMethod]);
+                        var timingMethod = State.IsGameTimeInitialized ? State.CurrentTimingMethod : TimingMethod.RealTime;
+                        response.Data.Add("currentTime", SplitTimeFormatter.Format(State.CurrentTime[timingMethod]));
                         break;
                     }
                     case "getfinaltime":
@@ -372,27 +361,33 @@ private void ProcessMessage(String message, Connection clientConnection)
                         var time = (State.CurrentPhase == TimerPhase.Ended)
                             ? State.CurrentTime[State.CurrentTimingMethod]
                             : State.Run.Last().Comparisons[comparison][State.CurrentTimingMethod];
-                        response = SplitTimeFormatter.Format(time);
+                        response.Data.Add("finalTime", SplitTimeFormatter.Format(time));
                         break;
                     }
                     case "getbestpossibletime":
                     case "getpredictedtime":
                     {
                         string comparison;
+                        string responseKey = "predictedTime";
                         if (request.Command == "getbestpossibletime")
+                        {
+                            responseKey = "bestPossibleTime";
                             comparison = LiveSplit.Model.Comparisons.BestSegmentsComparisonGenerator.ComparisonName;
-                        else {
+                        }
+                        else
+                        {
                             var data = (string)request.Data?["comparison"];
                             comparison = !string.IsNullOrEmpty(data) ? data : State.CurrentComparison;
                         }
+
                         var prediction = PredictTime(State, comparison);
-                        response = SplitTimeFormatter.Format(prediction);
+                        response.Data.Add(responseKey, SplitTimeFormatter.Format(prediction));
                         break;
                     }
                     case "gettimerphase":
                     case "getcurrenttimerphase":
                     {
-                        response = State.CurrentPhase.ToString();
+                        response.Data.Add("timerPhase", State.CurrentPhase.ToString());
                         break;
                     }
                     case "setcomparison":
@@ -408,15 +403,9 @@ private void ProcessMessage(String message, Connection clientConnection)
                     case "setsplitname":
                     case "setcurrentsplitname":
                     {
-                        int index = State.CurrentSplitIndex;
+                        int index = request.Command == "setsplitname" ? (int)request.Data["index"] : State.CurrentSplitIndex;
                         string name = (string)request.Data["name"];
 
-                        if (request.Command == "setsplitname")
-                        {
-                            index = (int)request.Data["index"];
-                            name = (string)request.Data["name"];
-                        }
-
                         if (index >= 0 && index < State.Run.Count)
                         {
                             State.Run[index].Name = name;
@@ -433,14 +422,15 @@ private void ProcessMessage(String message, Connection clientConnection)
             }
             catch (Exception ex)
             {
-                response = "[Error]: " + ex.GetType() + ": " + ex.Message;
+                response.Status = "error";
+                response.Data.Add("error", $"{ex.GetType()}: {ex.Message}");
                 Log.Error(ex);
             }
 
-            if (!string.IsNullOrEmpty(response))
-            {
-                clientConnection.SendMessage(response);
-            }
+            clientConnection.SendMessage(
+                JsonConvert.SerializeObject(
+                    response,
+                    new JsonSerializerSettings{ ContractResolver = new CamelCasePropertyNamesContractResolver() }));
         }
 
         private void connection_Disconnected(object sender, EventArgs e)

From 20e44c323b892645fb9e084c98faa8144c6b5edc Mon Sep 17 00:00:00 2001
From: Jeff Hobson <jeffrey296@gmail.com>
Date: Thu, 10 Mar 2022 14:32:10 -0500
Subject: [PATCH 3/5] Update documentation to new JSON standard

Also adds 4 previously-undocumented commands to list
---
 README.md | 73 ++++++++++++++++++++++++++++++++++++++++---------------
 1 file changed, 53 insertions(+), 20 deletions(-)

diff --git a/README.md b/README.md
index c9ce06c..fcd8622 100644
--- a/README.md
+++ b/README.md
@@ -48,11 +48,41 @@ Made something cool? Consider getting it added to this list.
 
 ## Commands
 
-Commands are case sensitive and end with a carriage return and a line feed (\r\n). You can provide parameters by using a space after the command and sending the parameters afterwards (`<command><space><parameters><\r\n>`).
-
-A command can respond with a message. The message ends with a carriage return and a line feed, just like a command.
+Commands are JSON strings that end with a carriage return and a line feed (\r\n).
+```json
+{ "command": "starttimer" }
+```
+Additional data can be passed to commands that accept them (such as `getdelta`) in the form of a `data` object.
+```json
+{
+    "command": "getdelta",
+    "data": {
+        "comparison": "Best Segments"
+    }
+}
+```
+Remember that the JSON object **must** be serialized to a string before it is sent to LiveSplit.Server.
+
+All commands respond with a message. The message is a JSON string and ends with a carriage return and a line feed, just like a command. The message will, at minimum, contain two properties: `"command"` and `"status"`. The command property simply reiterates what command was attempted. The `"status"` property will have a value of either `"success"` or `"error"` to indicate the success or failure of the operation, respectively.
+Example response for a request of `{ "command": "starttimer" }`:
+```json
+{
+    "command": "starttimer",
+    "status": "success"
+}
+```
+If the requested command expects some kind of information, it will be included in a `data` object with a property name similar to the command name.
+```json
+{
+    "command": "getbestpossibletime",
+    "status": "success",
+    "data": {
+        "bestPossibleTime": "45:02.85"
+    }
+}
+```
 
-Here's the list of commands:
+The following commands perform actions and do not return any additional data:
 
 - starttimer
 - startorsplit
@@ -63,34 +93,37 @@ Here's the list of commands:
 - resume
 - reset
 - initgametime
-- setgametime TIME
-- setloadingtimes TIME
 - pausegametime
 - unpausegametime
-- setcomparison COMPARISON
+- setgametime (expects `time` property)
+- setloadingtimes (expects `time` property)
+- setcomparison (expects `comparison` property)
+- setsplitname (expects `index` and `name` properties)
+- setcurrentsplitname (expects `name` property)
+- switchto (expects `timingMethod` property with value of either "gametime" or "realtime")
+- alwayspausegametime
 
 The following commands respond with a time:
 
-- getdelta
-- getdelta COMPARISON
-- getlastsplittime
-- getcomparisonsplittime
+- getdelta (optional `comparison` property) - time is prefixed with "+" or "-"
+- getprevioussplittime / getlastsplittime
+- getcurrentsplittime / getcomparisonsplittime (optional `comparison` property)
 - getcurrenttime
-- getfinaltime
-- getfinaltime COMPARISON
-- getpredictedtime COMPARISON
+- getfinaltime / getfinalsplittime (optional `comparison` property)
+- getpredictedtime (optional `comparison` property)
 - getbestpossibletime
 
-Other commands:
+The following commands respond with other types of information:
 
 - getsplitindex
 - getcurrentsplitname
-- getprevioussplitname
-- getcurrenttimerphase
+- getprevioussplitname / getlastsplitname
+- gettimerphase / getcurrenttimerphase
 
 Commands are defined at `ProcessMessage` in "ServerComponent.cs".
 
-When using Game Time, it's important that you call "initgametime" once. Once "initgametime" is used, an additional comparison will appear and you can switch to it via the context menu (Compare Against > Game Time). This special comparison will show everything based on the Game Time (every component now shows Game Time based information).
+### Game Time
+When using Game Time, it's important that you call "initgametime" once. Once "initgametime" is used, an additional comparison will appear and you can switch to it via the context menu (Compare Against > Game Time). This special comparison will show everything based on the Game Time (every component now shows Game Time based information). If you do not initialize game time, all commands that respond with a time will use Real Time for the timing method, even if you specify Game Time.
 
 ## Example Clients
 
@@ -101,7 +134,7 @@ import socket
 
 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 s.connect(("localhost", 16834))
-s.send(b"starttimer\r\n")
+s.send(b"{\"command\":\"starttimer\"}\r\n")
 ```
 
 ### Java 7+
@@ -115,7 +148,7 @@ public class MainTest {
     public static void main(String[] args) throws IOException {
         Socket socket = new Socket("localhost", 16834);
         PrintWriter writer = new PrintWriter(socket.getOutputStream());
-        writer.write("starttimer\r\n");
+        writer.write("{\"command\":\"starttimer\"}\r\n");
         writer.flush();
         socket.close();
     }

From dd99ad9f151633c53cb42e31f7ccdb5eafdef9b6 Mon Sep 17 00:00:00 2001
From: Jeff Hobson <jeffrey296@gmail.com>
Date: Fri, 11 Mar 2022 14:42:02 -0500
Subject: [PATCH 4/5] Add explanation of nonces to README

---
 .gitignore |  1 +
 README.md  | 23 +++++++++++++++++++++++
 2 files changed, 24 insertions(+)

diff --git a/.gitignore b/.gitignore
index 3d3dd1a..ea2ea78 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,6 +5,7 @@
 *.suo
 *.user
 *.sln.docstates
+.vs/
 
 # Build results
 [Dd]ebug/
diff --git a/README.md b/README.md
index fcd8622..ee57394 100644
--- a/README.md
+++ b/README.md
@@ -125,6 +125,29 @@ Commands are defined at `ProcessMessage` in "ServerComponent.cs".
 ### Game Time
 When using Game Time, it's important that you call "initgametime" once. Once "initgametime" is used, an additional comparison will appear and you can switch to it via the context menu (Compare Against > Game Time). This special comparison will show everything based on the Game Time (every component now shows Game Time based information). If you do not initialize game time, all commands that respond with a time will use Real Time for the timing method, even if you specify Game Time.
 
+## Matching responses to commands
+Message responses are not guaranteed to be sent in the same order incoming commands are received. This means that if your application is waiting for a response to its request, it could receive the response for a *different* request instead, if the two requests were made close enough to each other. In order to guarantee a response corresponds to a given request, clients should generate a [nonce](https://en.wikipedia.org/wiki/Cryptographic_nonce) and send it with their command request. LiveSplit.Server will include the nonce in the response so that your code may check that it matches before performing any additional actions. This also has the added benefit of preventing another application from sending messages over the same port that could trigger actions in your application.
+
+Example request with nonce:
+```json
+{
+    "command": "getdelta",
+    "nonce": "ac49057d-be60-44e5-a05a-882b9eb31e81",
+}
+```
+Response:
+```json
+{
+    "command": "getdelta",
+    "status": "success",
+    "nonce": "ac49057d-be60-44e5-a05a-882b9eb31e81",
+    "data": {
+        "delta": "-1:30.12"
+    }
+}
+```
+Note that while it is common for nonces to be of a standardized format, such as UUID in the example above, there are no requirements around their structure or uniqueness; any string will be accepted by LiveSplit.Server. It is up to whatever client you use to guarantee their uniqueness. The nonce field is completely optional, though strongly recommended in any case that sends commands even somewhat frequently.
+
 ## Example Clients
 
 ### Python

From 297f5971c0eb1cab2cf73e004802b638b63f27e2 Mon Sep 17 00:00:00 2001
From: Jeff Hobson <jeffrey296@gmail.com>
Date: Fri, 11 Mar 2022 14:43:48 -0500
Subject: [PATCH 5/5] Fix: typo in README

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index ee57394..fe52ace 100644
--- a/README.md
+++ b/README.md
@@ -9,7 +9,7 @@ Consider using the latest development build of LiveSplit available at [http://li
 Alternatively:
 
 - Download the Server component from [https://github.com/LiveSplit/LiveSplit.Server/releases](https://github.com/LiveSplit/LiveSplit.Server/releases)
-- Locate your LiveSplit instillation directory
+- Locate your LiveSplit installation directory
 - Place the contents of the downloaded zip into the "LiveSplit\Components" directory
 
 ## Setup