diff --git a/Calamity/Client/Client.hs b/Calamity/Client/Client.hs
--- a/Calamity/Client/Client.hs
+++ b/Calamity/Client/Client.hs
@@ -5,6 +5,7 @@
     react,
     runBotIO,
     runBotIO',
+    runBotIO'',
     stopBot,
     sendPresence,
     events,
@@ -95,7 +96,7 @@
 -- | Create a bot, run your setup action, and then loop until the bot closes.
 runBotIO ::
     forall r a.
-    (P.Members '[P.Embed IO, P.Final IO, CacheEff, MetricEff, LogEff] r, Typeable (SetupEff r)) =>
+    (P.Members '[P.Embed IO, P.Final IO, CacheEff, MetricEff, LogEff] r) =>
     Token ->
     -- | The intents the bot should use
     Intents ->
@@ -106,15 +107,15 @@
 resetDi :: BotC r => P.Sem r a -> P.Sem r a
 resetDi m = do
     initialDi <- P.asks (^. #initialDi)
-    Di.local (flip fromMaybe initialDi) m
+    Di.local (`fromMaybe` initialDi) m
 
 {- | Create a bot, run your setup action, and then loop until the bot closes.
 
- This version allows you to specify the initial status, and intents.
+ This version allows you to specify the initial status
 -}
 runBotIO' ::
     forall r a.
-    (P.Members '[P.Embed IO, P.Final IO, CacheEff, MetricEff, LogEff] r, Typeable (SetupEff r)) =>
+    (P.Members '[P.Embed IO, P.Final IO, CacheEff, MetricEff, LogEff] r) =>
     Token ->
     -- | The intents the bot should use
     Intents ->
@@ -136,6 +137,44 @@
                 Di.push "calamity-stop" finishUp
                 pure Nothing
 
+{- | Create a bot, run your setup action, and then loop until the bot closes.
+
+ This version only handles the @'P.Reader' 'Client'@ effect, allowing you to
+ handle the @'P.AtomicState' 'EventHandlers'@ yourself.
+-}
+runBotIO'' ::
+    forall r a.
+    (P.Members
+      '[ LogEff
+       , MetricEff
+       , CacheEff
+       , P.Reader Client
+       , P.AtomicState EventHandlers
+       , P.Embed IO
+       , P.Final IO
+       , P.Async
+       ]
+ r) =>
+    Token ->
+    -- | The intents the bot should use
+    Intents ->
+    -- | The initial status to send to the gateway
+    Maybe StatusUpdateData ->
+    P.Sem (P.Reader Client ': r) a ->
+    P.Sem r (Maybe StartupError)
+runBotIO'' token intents status setup = do
+    initialDi <- Di.fetch
+    client <- P.embed $ newClient token initialDi
+    P.runReader client . Di.push "calamity" $ do
+        void $ Di.push "calamity-setup" setup
+        r <- shardBot status intents
+        case r of
+            Left e -> pure (Just e)
+            Right _ -> do
+                Di.push "calamity-loop" clientLoop
+                Di.push "calamity-stop" finishUp
+                pure Nothing
+
 {- | Register an event handler, returning an action that removes the event handler from the bot.
 
  Refer to 'EventType' for what events you can register, and 'EHType' for the
@@ -217,7 +256,7 @@
     inc <- P.asks (^. #eventsIn)
     P.embed $ dupChan inc
 
-{- | Wait until an event satisfying a condition happens, then returns it's
+{- | Wait until an event satisfying a condition happens, then returns its
  parameters.
 
  The check function for this command is pure unlike 'waitUntilM'
@@ -260,7 +299,7 @@
         when (f args) $ do
             P.embed $ putMVar result args
 
-{- | Wait until an event satisfying a condition happens, then returns it's
+{- | Wait until an event satisfying a condition happens, then returns its
  parameters
 
  This is what it would look like with @s ~ \''MessageCreateEvt'@:
@@ -326,7 +365,7 @@
     debug "bot has stopped"
 
 {- | main loop of the client, handles fetching the next event, processing the
- event and invoking it's handler functions
+ event and invoking its handler functions
 -}
 clientLoop :: BotC r => P.Sem r ()
 clientLoop = do
@@ -382,38 +421,38 @@
     P.Sem (P.Fail ': r) [IO ()]
 handleEvent' eh evt@(Ready rd@ReadyData{}) = do
     updateCache evt
-    pure $ map ($ rd) (getEventHandlers @ 'ReadyEvt eh)
+    pure $ map ($ rd) (getEventHandlers @'ReadyEvt eh)
 handleEvent' _ Resumed = pure []
 handleEvent' eh evt@(ChannelCreate (DMChannel' chan)) = do
     updateCache evt
     Just newChan <- DMChannel' <<$>> getDM (getID chan)
-    pure $ map ($ newChan) (getEventHandlers @ 'ChannelCreateEvt eh)
+    pure $ map ($ newChan) (getEventHandlers @'ChannelCreateEvt eh)
 handleEvent' eh evt@(ChannelCreate (GuildChannel' chan)) = do
     updateCache evt
     Just guild <- getGuild (getID chan)
     Just newChan <- pure $ GuildChannel' <$> guild ^. #channels . at (getID chan)
-    pure $ map ($ newChan) (getEventHandlers @ 'ChannelCreateEvt eh)
+    pure $ map ($ newChan) (getEventHandlers @'ChannelCreateEvt eh)
 handleEvent' eh evt@(ChannelUpdate (DMChannel' chan)) = do
     Just oldChan <- DMChannel' <<$>> getDM (getID chan)
     updateCache evt
     Just newChan <- DMChannel' <<$>> getDM (getID chan)
-    pure $ map ($ (oldChan, newChan)) (getEventHandlers @ 'ChannelUpdateEvt eh)
+    pure $ map ($ (oldChan, newChan)) (getEventHandlers @'ChannelUpdateEvt eh)
 handleEvent' eh evt@(ChannelUpdate (GuildChannel' chan)) = do
     Just oldGuild <- getGuild (getID chan)
     Just oldChan <- pure $ GuildChannel' <$> oldGuild ^. #channels . at (getID chan)
     updateCache evt
     Just newGuild <- getGuild (getID chan)
     Just newChan <- pure $ GuildChannel' <$> newGuild ^. #channels . at (getID chan)
-    pure $ map ($ (oldChan, newChan)) (getEventHandlers @ 'ChannelUpdateEvt eh)
+    pure $ map ($ (oldChan, newChan)) (getEventHandlers @'ChannelUpdateEvt eh)
 handleEvent' eh evt@(ChannelDelete (GuildChannel' chan)) = do
     Just oldGuild <- getGuild (getID chan)
     Just oldChan <- pure $ GuildChannel' <$> oldGuild ^. #channels . at (getID chan)
     updateCache evt
-    pure $ map ($ oldChan) (getEventHandlers @ 'ChannelDeleteEvt eh)
+    pure $ map ($ oldChan) (getEventHandlers @'ChannelDeleteEvt eh)
 handleEvent' eh evt@(ChannelDelete (DMChannel' chan)) = do
     Just oldChan <- DMChannel' <<$>> getDM (getID chan)
     updateCache evt
-    pure $ map ($ oldChan) (getEventHandlers @ 'ChannelDeleteEvt eh)
+    pure $ map ($ oldChan) (getEventHandlers @'ChannelDeleteEvt eh)
 
 -- handleEvent' eh evt@(ChannelPinsUpdate ChannelPinsUpdateData { channelID, lastPinTimestamp }) = do
 --   chan <- (GuildChannel' <$> os ^? #channels . at (coerceSnowflake channelID) . _Just)
@@ -427,12 +466,12 @@
     pure $
         map
             ($ (guild, (if isNew then GuildCreateNew else GuildCreateAvailable)))
-            (getEventHandlers @ 'GuildCreateEvt eh)
+            (getEventHandlers @'GuildCreateEvt eh)
 handleEvent' eh evt@(GuildUpdate guild) = do
     Just oldGuild <- getGuild (getID guild)
     updateCache evt
     Just newGuild <- getGuild (getID guild)
-    pure $ map ($ (oldGuild, newGuild)) (getEventHandlers @ 'GuildUpdateEvt eh)
+    pure $ map ($ (oldGuild, newGuild)) (getEventHandlers @'GuildUpdateEvt eh)
 
 -- NOTE: Guild will be deleted in the new cache if unavailable was false
 handleEvent' eh evt@(GuildDelete UnavailableGuild{id, unavailable}) = do
@@ -441,96 +480,96 @@
     pure $
         map
             ($ (oldGuild, (if unavailable then GuildDeleteUnavailable else GuildDeleteRemoved)))
-            (getEventHandlers @ 'GuildDeleteEvt eh)
+            (getEventHandlers @'GuildDeleteEvt eh)
 handleEvent' eh evt@(GuildBanAdd BanData{guildID, user}) = do
     Just guild <- getGuild guildID
     updateCache evt
-    pure $ map ($ (guild, user)) (getEventHandlers @ 'GuildBanAddEvt eh)
+    pure $ map ($ (guild, user)) (getEventHandlers @'GuildBanAddEvt eh)
 handleEvent' eh evt@(GuildBanRemove BanData{guildID, user}) = do
     Just guild <- getGuild guildID
     updateCache evt
-    pure $ map ($ (guild, user)) (getEventHandlers @ 'GuildBanRemoveEvt eh)
+    pure $ map ($ (guild, user)) (getEventHandlers @'GuildBanRemoveEvt eh)
 
 -- NOTE: we fire this event using the guild data with old emojis
 handleEvent' eh evt@(GuildEmojisUpdate GuildEmojisUpdateData{guildID, emojis}) = do
     Just guild <- getGuild guildID
     updateCache evt
-    pure $ map ($ (guild, emojis)) (getEventHandlers @ 'GuildEmojisUpdateEvt eh)
+    pure $ map ($ (guild, emojis)) (getEventHandlers @'GuildEmojisUpdateEvt eh)
 handleEvent' eh evt@(GuildIntegrationsUpdate GuildIntegrationsUpdateData{guildID}) = do
     updateCache evt
     Just guild <- getGuild guildID
-    pure $ map ($ guild) (getEventHandlers @ 'GuildIntegrationsUpdateEvt eh)
+    pure $ map ($ guild) (getEventHandlers @'GuildIntegrationsUpdateEvt eh)
 handleEvent' eh evt@(GuildMemberAdd member) = do
     updateCache evt
     Just guild <- getGuild (getID member)
     Just member <- pure $ guild ^. #members . at (getID member)
-    pure $ map ($ member) (getEventHandlers @ 'GuildMemberAddEvt eh)
+    pure $ map ($ member) (getEventHandlers @'GuildMemberAddEvt eh)
 handleEvent' eh evt@(GuildMemberRemove GuildMemberRemoveData{user, guildID}) = do
     Just guild <- getGuild guildID
     Just member <- pure $ guild ^. #members . at (getID user)
     updateCache evt
-    pure $ map ($ member) (getEventHandlers @ 'GuildMemberRemoveEvt eh)
+    pure $ map ($ member) (getEventHandlers @'GuildMemberRemoveEvt eh)
 handleEvent' eh evt@(GuildMemberUpdate GuildMemberUpdateData{user, guildID}) = do
     Just oldGuild <- getGuild guildID
     Just oldMember <- pure $ oldGuild ^. #members . at (getID user)
     updateCache evt
     Just newGuild <- getGuild guildID
     Just newMember <- pure $ newGuild ^. #members . at (getID user)
-    pure $ map ($ (oldMember, newMember)) (getEventHandlers @ 'GuildMemberUpdateEvt eh)
+    pure $ map ($ (oldMember, newMember)) (getEventHandlers @'GuildMemberUpdateEvt eh)
 handleEvent' eh evt@(GuildMembersChunk GuildMembersChunkData{members, guildID}) = do
     updateCache evt
     Just guild <- getGuild guildID
     let memberIDs = map (getID @Member) members
     let members' = catMaybes $ map (\mid -> guild ^. #members . at mid) memberIDs
-    pure $ map ($ (guild, members')) (getEventHandlers @ 'GuildMembersChunkEvt eh)
+    pure $ map ($ (guild, members')) (getEventHandlers @'GuildMembersChunkEvt eh)
 handleEvent' eh evt@(GuildRoleCreate GuildRoleData{guildID, role}) = do
     updateCache evt
     Just guild <- getGuild guildID
     Just role' <- pure $ guild ^. #roles . at (getID role)
-    pure $ map ($ (guild, role')) (getEventHandlers @ 'GuildRoleCreateEvt eh)
+    pure $ map ($ (guild, role')) (getEventHandlers @'GuildRoleCreateEvt eh)
 handleEvent' eh evt@(GuildRoleUpdate GuildRoleData{guildID, role}) = do
     Just oldGuild <- getGuild guildID
     Just oldRole <- pure $ oldGuild ^. #roles . at (getID role)
     updateCache evt
     Just newGuild <- getGuild guildID
     Just newRole <- pure $ newGuild ^. #roles . at (getID role)
-    pure $ map ($ (newGuild, oldRole, newRole)) (getEventHandlers @ 'GuildRoleUpdateEvt eh)
+    pure $ map ($ (newGuild, oldRole, newRole)) (getEventHandlers @'GuildRoleUpdateEvt eh)
 handleEvent' eh evt@(GuildRoleDelete GuildRoleDeleteData{guildID, roleID}) = do
     Just guild <- getGuild guildID
     Just role <- pure $ guild ^. #roles . at roleID
     updateCache evt
-    pure $ map ($ (guild, role)) (getEventHandlers @ 'GuildRoleDeleteEvt eh)
+    pure $ map ($ (guild, role)) (getEventHandlers @'GuildRoleDeleteEvt eh)
 handleEvent' eh (InviteCreate d) = do
-    pure $ map ($ d) (getEventHandlers @ 'InviteCreateEvt eh)
+    pure $ map ($ d) (getEventHandlers @'InviteCreateEvt eh)
 handleEvent' eh (InviteDelete d) = do
-    pure $ map ($ d) (getEventHandlers @ 'InviteDeleteEvt eh)
+    pure $ map ($ d) (getEventHandlers @'InviteDeleteEvt eh)
 handleEvent' eh evt@(MessageCreate msg _) = do
     updateCache evt
-    pure $ map ($ msg) (getEventHandlers @ 'MessageCreateEvt eh)
+    pure $ map ($ msg) (getEventHandlers @'MessageCreateEvt eh)
 handleEvent' eh evt@(MessageUpdate msg) = do
     oldMsg <- getMessage (getID msg)
     updateCache evt
     newMsg <- getMessage (getID msg)
-    let rawActions = map ($ msg) (getEventHandlers @ 'RawMessageUpdateEvt eh)
+    let rawActions = map ($ msg) (getEventHandlers @'RawMessageUpdateEvt eh)
     let actions = case (oldMsg, newMsg) of
             (Just oldMsg', Just newMsg') ->
-                map ($ (oldMsg', newMsg')) (getEventHandlers @ 'MessageUpdateEvt eh)
+                map ($ (oldMsg', newMsg')) (getEventHandlers @'MessageUpdateEvt eh)
             _ -> []
     pure $ rawActions <> actions
 handleEvent' eh evt@(MessageDelete MessageDeleteData{id}) = do
     oldMsg <- getMessage id
     updateCache evt
-    let rawActions = map ($ id) (getEventHandlers @ 'RawMessageDeleteEvt eh)
+    let rawActions = map ($ id) (getEventHandlers @'RawMessageDeleteEvt eh)
     let actions = case oldMsg of
             Just oldMsg' ->
-                map ($ oldMsg') (getEventHandlers @ 'MessageDeleteEvt eh)
+                map ($ oldMsg') (getEventHandlers @'MessageDeleteEvt eh)
             _ -> []
     pure $ rawActions <> actions
 handleEvent' eh evt@(MessageDeleteBulk MessageDeleteBulkData{ids}) = do
     messages <- catMaybes <$> traverse getMessage ids
     updateCache evt
-    let rawActions = map ($ ids) (getEventHandlers @ 'RawMessageDeleteBulkEvt eh)
-    let actions = map ($ messages) (getEventHandlers @ 'MessageDeleteBulkEvt eh)
+    let rawActions = map ($ ids) (getEventHandlers @'RawMessageDeleteBulkEvt eh)
+    let actions = map ($ messages) (getEventHandlers @'MessageDeleteBulkEvt eh)
     pure $ rawActions <> actions
 handleEvent' eh evt@(MessageReactionAdd reaction) = do
     updateCache evt
@@ -543,10 +582,10 @@
         Nothing -> do
             chan <- getDM (coerceSnowflake $ getID @Channel reaction)
             pure (DMChannel' <$> chan)
-    let rawActions = map ($ reaction) (getEventHandlers @ 'RawMessageReactionAddEvt eh)
+    let rawActions = map ($ reaction) (getEventHandlers @'RawMessageReactionAddEvt eh)
     let actions = case (msg, user, chan) of
             (Just msg', Just user', Just chan') ->
-                map ($ (msg', user', chan', reaction ^. #emoji)) (getEventHandlers @ 'MessageReactionAddEvt eh)
+                map ($ (msg', user', chan', reaction ^. #emoji)) (getEventHandlers @'MessageReactionAddEvt eh)
             _ -> []
     pure $ rawActions <> actions
 handleEvent' eh evt@(MessageReactionRemove reaction) = do
@@ -560,19 +599,19 @@
         Nothing -> do
             chan <- getDM (coerceSnowflake $ getID @Channel reaction)
             pure (DMChannel' <$> chan)
-    let rawActions = map ($ reaction) (getEventHandlers @ 'RawMessageReactionRemoveEvt eh)
+    let rawActions = map ($ reaction) (getEventHandlers @'RawMessageReactionRemoveEvt eh)
     let actions = case (msg, user, chan) of
             (Just msg', Just user', Just chan') ->
-                map ($ (msg', user', chan', reaction ^. #emoji)) (getEventHandlers @ 'MessageReactionRemoveEvt eh)
+                map ($ (msg', user', chan', reaction ^. #emoji)) (getEventHandlers @'MessageReactionRemoveEvt eh)
             _ -> []
     pure $ rawActions <> actions
 handleEvent' eh evt@(MessageReactionRemoveAll MessageReactionRemoveAllData{messageID}) = do
     msg <- getMessage messageID
     updateCache evt
-    let rawActions = map ($ messageID) (getEventHandlers @ 'RawMessageReactionRemoveAllEvt eh)
+    let rawActions = map ($ messageID) (getEventHandlers @'RawMessageReactionRemoveAllEvt eh)
     let actions = case msg of
             Just msg' ->
-                map ($ msg') (getEventHandlers @ 'MessageReactionRemoveAllEvt eh)
+                map ($ msg') (getEventHandlers @'MessageReactionRemoveAllEvt eh)
             _ -> []
     pure $ rawActions <> actions
 handleEvent' eh evt@(PresenceUpdate PresenceUpdateData{userID, presence = Presence{guildID}}) = do
@@ -585,30 +624,30 @@
         newUser :: User = upcast newMember
         userUpdates =
             if oldUser /= newUser
-                then map ($ (oldUser, newUser)) (getEventHandlers @ 'UserUpdateEvt eh)
+                then map ($ (oldUser, newUser)) (getEventHandlers @'UserUpdateEvt eh)
                 else mempty
-    pure $ userUpdates <> map ($ (oldMember, newMember)) (getEventHandlers @ 'GuildMemberUpdateEvt eh)
+    pure $ userUpdates <> map ($ (oldMember, newMember)) (getEventHandlers @'GuildMemberUpdateEvt eh)
 handleEvent' eh (TypingStart TypingStartData{channelID, guildID, userID, timestamp = UnixTimestamp timestamp}) =
     case guildID of
         Just gid -> do
             Just guild <- getGuild gid
             Just chan <- pure $ GuildChannel' <$> guild ^. #channels . at (coerceSnowflake channelID)
-            pure $ map ($ (chan, userID, timestamp)) (getEventHandlers @ 'TypingStartEvt eh)
+            pure $ map ($ (chan, userID, timestamp)) (getEventHandlers @'TypingStartEvt eh)
         Nothing -> do
             Just chan <- DMChannel' <<$>> getDM (coerceSnowflake channelID)
-            pure $ map ($ (chan, userID, timestamp)) (getEventHandlers @ 'TypingStartEvt eh)
+            pure $ map ($ (chan, userID, timestamp)) (getEventHandlers @'TypingStartEvt eh)
 handleEvent' eh evt@(UserUpdate _) = do
     Just oldUser <- getBotUser
     updateCache evt
     Just newUser <- getBotUser
-    pure $ map ($ (oldUser, newUser)) (getEventHandlers @ 'UserUpdateEvt eh)
+    pure $ map ($ (oldUser, newUser)) (getEventHandlers @'UserUpdateEvt eh)
 handleEvent' eh evt@(VoiceStateUpdate newVoiceState@V.VoiceState{guildID = Just guildID}) = do
     oldVoiceState <- ((find ((== V.sessionID newVoiceState) . V.sessionID) . voiceStates) =<<) <$> getGuild guildID
     updateCache evt
-    pure $ map ($ (oldVoiceState, newVoiceState)) (getEventHandlers @ 'VoiceStateUpdateEvt eh)
+    pure $ map ($ (oldVoiceState, newVoiceState)) (getEventHandlers @'VoiceStateUpdateEvt eh)
 handleEvent' eh evt@(InteractionCreate interaction) = do
     updateCache evt
-    pure $ map ($ interaction) (getEventHandlers @ 'InteractionEvt eh)
+    pure $ map ($ interaction) (getEventHandlers @'InteractionEvt eh)
 handleEvent' _ e = fail $ "Unhandled event: " <> show e
 
 updateCache :: P.Members '[CacheEff, P.Fail] r => DispatchData -> P.Sem r ()
diff --git a/Calamity/Client/Types.hs b/Calamity/Client/Types.hs
--- a/Calamity/Client/Types.hs
+++ b/Calamity/Client/Types.hs
@@ -80,7 +80,6 @@
        , P.Async
        ]
       r
-  , Typeable r
   )
 
 -- | A concrete effect stack used inside the bot
diff --git a/Calamity/Commands/Dsl.hs b/Calamity/Commands/Dsl.hs
--- a/Calamity/Commands/Dsl.hs
+++ b/Calamity/Commands/Dsl.hs
@@ -60,12 +60,12 @@
    'Calamity.Commands.Dsl.command' \@'[] "test" \\ctx -> 'pure' ()
  @
 
- In the above block, any command declared inside 'hide' will have it's
+ In the above block, any command declared inside 'hide' will have its
  \'hidden\' flag set and will not be shown by the default help command:
  'Calamity.Commands.Help.helpCommand'
 
  The 'Calamity.Commands.Help.helpCommand' function can be used to create a
- help command for the commands DSL action it is used in, read it's doc page
+ help command for the commands DSL action it is used in, read its doc page
  for more information on how it functions.
 
  The 'Calamity.Commands.Utils.addCommands' function creates the command
@@ -256,7 +256,7 @@
 {- | Construct a group and place any commands registered in the given action
  into the new group.
 
- This also resets the @help@ function back to it's original value, use
+ This also resets the @help@ function back to its original value, use
  'group'' if you don't want that (i.e. your help function is context aware).
 -}
 group ::
@@ -273,7 +273,7 @@
  The parent group, visibility, checks, and command help are drawn from the
  reader context.
 
- This also resets the @help@ function back to it's original value, use
+ This also resets the @help@ function back to its original value, use
  'group'' if you don't want that (i.e. your help function is context aware).
 -}
 groupA ::
@@ -292,7 +292,7 @@
  The parent group, visibility, checks, and command help are drawn from the
  reader context.
 
- Unlike 'help' this doesn't reset the @help@ function back to it's original
+ Unlike 'help' this doesn't reset the @help@ function back to its original
  value.
 -}
 group' ::
@@ -309,7 +309,7 @@
  The parent group, visibility, checks, and command help are drawn from the
  reader context.
 
- Unlike 'help' this doesn't reset the @help@ function back to it's original
+ Unlike 'help' this doesn't reset the @help@ function back to its original
  value.
 -}
 groupA' ::
diff --git a/Calamity/Gateway/Types.hs b/Calamity/Gateway/Types.hs
--- a/Calamity/Gateway/Types.hs
+++ b/Calamity/Gateway/Types.hs
@@ -23,6 +23,7 @@
 import           Calamity.Types.Model.Guild.Guild
 import           Calamity.Types.Model.Voice
 import           Calamity.Types.Model.Presence.Activity
+import           Calamity.Types.Model.User (StatusType)
 import           Calamity.Types.Snowflake
 
 import           Control.Concurrent.Async
@@ -219,7 +220,7 @@
 data StatusUpdateData = StatusUpdateData
   { since  :: Maybe Integer
   , game   :: Maybe Activity
-  , status :: Text
+  , status :: StatusType
   , afk    :: Bool
   }
   deriving ( Show, Generic )
diff --git a/Calamity/Types/Upgradeable.hs b/Calamity/Types/Upgradeable.hs
--- a/Calamity/Types/Upgradeable.hs
+++ b/Calamity/Types/Upgradeable.hs
@@ -24,7 +24,7 @@
 -- | A typeclass that represents snowflakes that can be upgraded to their
 -- complete data, either through the cache or HTTP.
 class Upgradeable a ids | a -> ids, ids -> a where
-  -- | Upgrade a snowflake to it's complete data.
+  -- | Upgrade a snowflake to its complete data.
   --
   -- If it existed in the cache then it is returned from there, otherwise we
   -- fetch from HTTP and update the cache on success.
diff --git a/Calamity/Utils/Message.hs b/Calamity/Utils/Message.hs
--- a/Calamity/Utils/Message.hs
+++ b/Calamity/Utils/Message.hs
@@ -114,21 +114,21 @@
 codeline :: L.Text -> L.Text
 codeline content = "``" <> escapeCodelines content <> "``"
 
-{- | Formats some text into it's bolded form
+{- | Formats some text into its bolded form
 
  Any existing bolded text is escaped
 -}
 bold :: L.Text -> L.Text
 bold content = "**" <> escapeBold content <> "**"
 
-{- | Formats some text into it's striked form
+{- | Formats some text into its striked form
 
  Any existing striked text is escaped
 -}
 strike :: L.Text -> L.Text
 strike content = "~~" <> escapeStrike content <> "~~"
 
-{- | Formats some text into it's underlined form
+{- | Formats some text into its underlined form
 
  Any existing underlined text is escaped
 -}
@@ -143,7 +143,7 @@
 quoteAll :: L.Text -> L.Text
 quoteAll = (">> " <>)
 
-{- | Formats some text into it's spoilered form
+{- | Formats some text into its spoilered form
 
  Any existing spoilers are escaped
 -}
diff --git a/ChangeLog.md b/ChangeLog.md
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -1,5 +1,13 @@
 # Changelog for Calamity
 
+## 0.1.30.4
+
++ The `status` field of `StatusUpdateData` has been changed from `Text` to
+  `StatusType`.
++ Removed the redundant `Typeable` constraint from `BotC` and `runBotIO`, etc.
++ Added the `runBotIO''` function which gives more control over the internal
+  state effects.
+
 ## 0.1.30.3
 
 + Added models for interactions and components 
diff --git a/calamity.cabal b/calamity.cabal
--- a/calamity.cabal
+++ b/calamity.cabal
@@ -5,7 +5,7 @@
 -- see: https://github.com/sol/hpack
 
 name:           calamity
-version:        0.1.30.3
+version:        0.1.30.4
 synopsis:       A library for writing discord bots in haskell
 description:    Please see the README on GitHub at <https://github.com/simmsb/calamity#readme>
 category:       Network, Web