Switch from `time` to `metadata`, store batch ID

CHANGELOG

    e.g. IrcClient { server("irc.example.com", 6667) }
  * Add behaviour options
    * requestModesOnJoin - automatically sends a MODE request when joining a channel
+ * Events now have a `metadata` property instead of a `time` (and time is available in metadata)
+   * IrcEvent.time is now deprecated but will remain until after v1.0.0.
+   * Metadata now contains the event's batch ID, if any.
  * (Internal) Introduced event mutators
    * Event mutators are now responsible for handling changing events in response to state
      e.g. ChannelFanOutMutator creates Channel* events for global quits/nick changes/etc

build.gradle.kts

     kotlin("jvm") version "1.3.21"
     id("com.jfrog.bintray") version "1.8.4"
     id("org.jetbrains.dokka") version "0.9.17"
-    id("name.remal.check-updates") version "1.0.112"
+    id("name.remal.check-updates") version "1.0.113"
 }
 
 jacoco {

src/main/kotlin/com/dmdirc/ktirc/IrcClientImpl.kt

  */
 // TODO: How should alternative nicknames work?
 // TODO: Should IRC Client take a pool of servers and rotate through, or make the caller do that?
-// TODO: Should there be a default profile?
 internal class IrcClientImpl(private val config: IrcClientConfig) : IrcClient, CoroutineScope {
 
     private val log by logger()
         with(socketFactory(this, config.server.host, config.server.port, config.server.useTls)) {
             socket = this
 
-            emitEvent(ServerConnecting(currentTimeProvider()))
+            emitEvent(ServerConnecting(EventMetadata(currentTimeProvider())))
 
             launch {
                 try {
                     connect()
-                    emitEvent(ServerConnected(currentTimeProvider()))
+                    emitEvent(ServerConnected(EventMetadata(currentTimeProvider())))
                     sendCapabilityList()
                     sendPasswordIfPresent()
                     sendNickChange(config.profile.nickname)
                     sendUser(config.profile.username, config.profile.realName)
                     messageHandler.processMessages(this@IrcClientImpl, receiveChannel.map { parser.parse(it) })
                 } catch (ex : Exception) {
-                    emitEvent(ServerConnectionError(currentTimeProvider(), ex.toConnectionError(), ex.localizedMessage))
+                    emitEvent(ServerConnectionError(EventMetadata(currentTimeProvider()), ex.toConnectionError(), ex.localizedMessage))
                 }
 
                 reset()
-                emitEvent(ServerDisconnected(currentTimeProvider()))
+                emitEvent(ServerDisconnected(EventMetadata(currentTimeProvider())))
             }
         }
     }

src/main/kotlin/com/dmdirc/ktirc/events/Events.kt

 import com.dmdirc.ktirc.model.User
 import java.time.LocalDateTime
 
+/**
+ * Metadata associated with an event.
+ *
+ * @param time The best-guess time at which the event occurred.
+ * @param batchId The ID of the batch this event is part of, if any.
+ */
+data class EventMetadata(val time: LocalDateTime, val batchId: String? = null)
+
 /** Base class for all events. */
-sealed class IrcEvent(val time: LocalDateTime)
+sealed class IrcEvent(val metadata: EventMetadata) {
+
+    /** The time at which the event occurred. */
+    @Deprecated("Only for backwards compatibility; to be removed post-1.0.0", replaceWith = ReplaceWith("metadata.time"))
+    val time: LocalDateTime
+        get() = metadata.time
+
+}
 
 /** Raised when a connection to the server is being established. */
-class ServerConnecting(time: LocalDateTime) : IrcEvent(time)
+class ServerConnecting(metadata: EventMetadata) : IrcEvent(metadata)
 
 /** Raised when the connection to the server has been established. The server will not be ready for use yet. */
-class ServerConnected(time: LocalDateTime) : IrcEvent(time)
+class ServerConnected(metadata: EventMetadata) : IrcEvent(metadata)
 
 /** Raised when the connection to the server has ended. */
-class ServerDisconnected(time: LocalDateTime) : IrcEvent(time)
+class ServerDisconnected(metadata: EventMetadata) : IrcEvent(metadata)
 
 /** Raised when an error occurred trying to connect. */
-class ServerConnectionError(time: LocalDateTime, val error: ConnectionError, val details: String?) : IrcEvent(time)
+class ServerConnectionError(metadata: EventMetadata, val error: ConnectionError, val details: String?) : IrcEvent(metadata)
 
 /** Raised when the server is ready for use. */
-class ServerReady(time: LocalDateTime) : IrcEvent(time)
+class ServerReady(metadata: EventMetadata) : IrcEvent(metadata)
 
 /** Raised when the server initially welcomes us to the IRC network. */
-class ServerWelcome(time: LocalDateTime, val server: String, val localNick: String) : IrcEvent(time)
+class ServerWelcome(metadata: EventMetadata, val server: String, val localNick: String) : IrcEvent(metadata)
 
 /** Raised when the features supported by the server have changed. This may occur numerous times. */
-class ServerFeaturesUpdated(time: LocalDateTime, val serverFeatures: ServerFeatureMap) : IrcEvent(time)
+class ServerFeaturesUpdated(metadata: EventMetadata, val serverFeatures: ServerFeatureMap) : IrcEvent(metadata)
 
 /** Raised whenever a PING is received from the server. */
-class PingReceived(time: LocalDateTime, val nonce: ByteArray) : IrcEvent(time)
+class PingReceived(metadata: EventMetadata, val nonce: ByteArray) : IrcEvent(metadata)
 
 /** Raised when a user joins a channel. */
-class ChannelJoined(time: LocalDateTime, val user: User, val channel: String) : IrcEvent(time)
+class ChannelJoined(metadata: EventMetadata, val user: User, val channel: String) : IrcEvent(metadata)
 
 /** Raised when a user leaves a channel. */
-class ChannelParted(time: LocalDateTime, val user: User, val channel: String, val reason: String = "") : IrcEvent(time)
+class ChannelParted(metadata: EventMetadata, val user: User, val channel: String, val reason: String = "") : IrcEvent(metadata)
 
 /** Raised when a [victim] is kicked from a channel. */
-class ChannelUserKicked(time: LocalDateTime, val user: User, val channel: String, val victim: String, val reason: String = "") : IrcEvent(time)
+class ChannelUserKicked(metadata: EventMetadata, val user: User, val channel: String, val victim: String, val reason: String = "") : IrcEvent(metadata)
 
 /** Raised when a user quits, and is in a channel. */
-class ChannelQuit(time: LocalDateTime, val user: User, val channel: String, val reason: String = "") : IrcEvent(time)
+class ChannelQuit(metadata: EventMetadata, val user: User, val channel: String, val reason: String = "") : IrcEvent(metadata)
 
 /** Raised when a user changes nickname, and is in a channel. */
-class ChannelNickChanged(time: LocalDateTime, val user: User, val channel: String, val newNick: String) : IrcEvent(time)
+class ChannelNickChanged(metadata: EventMetadata, val user: User, val channel: String, val newNick: String) : IrcEvent(metadata)
 
 /** Raised when a batch of the channel's member list has been received. More batches may follow. */
-class ChannelNamesReceived(time: LocalDateTime, val channel: String, val names: List<String>) : IrcEvent(time)
+class ChannelNamesReceived(metadata: EventMetadata, val channel: String, val names: List<String>) : IrcEvent(metadata)
 
 /** Raised when the entirety of the channel's member list has been received. */
-class ChannelNamesFinished(time: LocalDateTime, val channel: String) : IrcEvent(time)
+class ChannelNamesFinished(metadata: EventMetadata, val channel: String) : IrcEvent(metadata)
 
 /** Raised when a channel topic is discovered (not changed). Usually followed by [ChannelTopicMetadataDiscovered] if the [topic] is non-null. */
-class ChannelTopicDiscovered(time: LocalDateTime, val channel: String, val topic: String?) : IrcEvent(time)
+class ChannelTopicDiscovered(metadata: EventMetadata, val channel: String, val topic: String?) : IrcEvent(metadata)
 
 /** Raised when a channel topic's metadata is discovered. */
-class ChannelTopicMetadataDiscovered(time: LocalDateTime, val channel: String, val user: User, val setTime: LocalDateTime) : IrcEvent(time)
+class ChannelTopicMetadataDiscovered(metadata: EventMetadata, val channel: String, val user: User, val setTime: LocalDateTime) : IrcEvent(metadata)
 
 /**
  * Raised when a channel's topic is changed.
  *
  * If the topic has been unset (cleared), [topic] will be `null`
  */
-class ChannelTopicChanged(time: LocalDateTime, val user: User, val channel: String, val topic: String?) : IrcEvent(time)
+class ChannelTopicChanged(metadata: EventMetadata, val user: User, val channel: String, val topic: String?) : IrcEvent(metadata)
 
 /** Raised when a message is received. */
-class MessageReceived(time: LocalDateTime, val user: User, val target: String, val message: String, val messageId: String? = null) : IrcEvent(time)
+class MessageReceived(metadata: EventMetadata, val user: User, val target: String, val message: String, val messageId: String? = null) : IrcEvent(metadata)
 
 /**
  * Raised when a notice is received.
  *
  * The [user] may in fact be a server, or have a nickname of `*` while connecting.
  */
-class NoticeReceived(time: LocalDateTime, val user: User, val target: String, val message: String) : IrcEvent(time)
+class NoticeReceived(metadata: EventMetadata, val user: User, val target: String, val message: String) : IrcEvent(metadata)
 
 /** Raised when an action is received. */
-class ActionReceived(time: LocalDateTime, val user: User, val target: String, val action: String, val messageId: String? = null) : IrcEvent(time)
+class ActionReceived(metadata: EventMetadata, val user: User, val target: String, val action: String, val messageId: String? = null) : IrcEvent(metadata)
 
 /** Raised when a CTCP is received. */
-class CtcpReceived(time: LocalDateTime, val user: User, val target: String, val type: String, val content: String) : IrcEvent(time)
+class CtcpReceived(metadata: EventMetadata, val user: User, val target: String, val type: String, val content: String) : IrcEvent(metadata)
 
 /** Raised when a CTCP reply is received. */
-class CtcpReplyReceived(time: LocalDateTime, val user: User, val target: String, val type: String, val content: String) : IrcEvent(time)
+class CtcpReplyReceived(metadata: EventMetadata, val user: User, val target: String, val type: String, val content: String) : IrcEvent(metadata)
 
 /** Raised when a user quits. */
-class UserQuit(time: LocalDateTime, val user: User, val reason: String = "") : IrcEvent(time)
+class UserQuit(metadata: EventMetadata, val user: User, val reason: String = "") : IrcEvent(metadata)
 
 /** Raised when a user changes nickname. */
-class UserNickChanged(time: LocalDateTime, val user: User, val newNick: String) : IrcEvent(time)
+class UserNickChanged(metadata: EventMetadata, val user: User, val newNick: String) : IrcEvent(metadata)
 
 /**
  * Raised when a user's account changes (i.e., they auth'd or deauth'd with services).
  *
  * This event is only raised if the server supports the `account-notify` capability.
  */
-class UserAccountChanged(time: LocalDateTime, val user: User, val newAccount: String?) : IrcEvent(time)
+class UserAccountChanged(metadata: EventMetadata, val user: User, val newAccount: String?) : IrcEvent(metadata)
 
 /** Raised when available server capabilities are received. More batches may follow. */
-class ServerCapabilitiesReceived(time: LocalDateTime, val capabilities: Map<Capability, String>) : IrcEvent(time)
+class ServerCapabilitiesReceived(metadata: EventMetadata, val capabilities: Map<Capability, String>) : IrcEvent(metadata)
 
 /** Raised when our requested capabilities are acknowledged. More batches may follow. */
-class ServerCapabilitiesAcknowledged(time: LocalDateTime, val capabilities: Map<Capability, String>) : IrcEvent(time)
+class ServerCapabilitiesAcknowledged(metadata: EventMetadata, val capabilities: Map<Capability, String>) : IrcEvent(metadata)
 
 /** Raised when the server has finished sending us capabilities. */
-class ServerCapabilitiesFinished(time: LocalDateTime) : IrcEvent(time)
+class ServerCapabilitiesFinished(metadata: EventMetadata) : IrcEvent(metadata)
 
 /** Raised when a line of the Message Of the Day has been received. */
-class MotdLineReceived(time: LocalDateTime, val line: String, val first: Boolean = false) : IrcEvent(time)
+class MotdLineReceived(metadata: EventMetadata, val line: String, val first: Boolean = false) : IrcEvent(metadata)
 
 /** Raised when a Message Of the Day has completed. */
-class MotdFinished(time: LocalDateTime, val missing: Boolean = false) : IrcEvent(time)
+class MotdFinished(metadata: EventMetadata, val missing: Boolean = false) : IrcEvent(metadata)
 
 /**
  * Raised when a mode change occurs.
  * and the given modes are thus exhaustive. Otherwise, the modes are a sequence of changes to apply to the existing
  * state.
  */
-class ModeChanged(time: LocalDateTime, val target: String, val modes: String, val arguments: Array<String>, val discovered: Boolean = false) : IrcEvent(time)
+class ModeChanged(metadata: EventMetadata, val target: String, val modes: String, val arguments: Array<String>, val discovered: Boolean = false) : IrcEvent(metadata)
 
 /** Raised when an AUTHENTICATION message is received. [argument] is `null` if the server sent an empty reply ("+") */
-class AuthenticationMessage(time: LocalDateTime, val argument: String?) : IrcEvent(time)
+class AuthenticationMessage(metadata: EventMetadata, val argument: String?) : IrcEvent(metadata)
 
 /** Raised when a SASL attempt finishes, successfully or otherwise. */
-class SaslFinished(time: LocalDateTime, var success: Boolean) : IrcEvent(time)
+class SaslFinished(metadata: EventMetadata, var success: Boolean) : IrcEvent(metadata)
 
 /** Raised when the server says our SASL mechanism isn't available, but gives us a list of others. */
-class SaslMechanismNotAvailableError(time: LocalDateTime, var mechanisms: Collection<String>) : IrcEvent(time)
+class SaslMechanismNotAvailableError(metadata: EventMetadata, var mechanisms: Collection<String>) : IrcEvent(metadata)
+
+/** Indicates a batch of messages has begun. */
+class BatchStarted(metadata: EventMetadata, val referenceId: String, val batchType: String, val params: Array<String>) : IrcEvent(metadata)
+
+/** Indicates a batch of messages has finished. */
+class BatchFinished(metadata: EventMetadata, val referenceId: String) : IrcEvent(metadata)

src/main/kotlin/com/dmdirc/ktirc/events/handlers/ChannelStateHandler.kt

 
     private fun handleTopicChanged(client: IrcClient, event: ChannelTopicChanged) {
         client.channelState[event.channel]?.let {
-            it.topic = ChannelTopic(event.topic, event.user, event.time)
+            it.topic = ChannelTopic(event.topic, event.user, event.metadata.time)
         }
     }
 

src/main/kotlin/com/dmdirc/ktirc/events/mutators/ChannelFanOutMutator.kt

     private suspend fun SequenceScope<IrcEvent>.handleQuit(client: IrcClient, event: UserQuit) {
         client.channelState.forEach {
             if (it.users.contains(event.user.nickname)) {
-                yield(ChannelQuit(event.time, event.user, it.name, event.reason))
+                yield(ChannelQuit(event.metadata, event.user, it.name, event.reason))
             }
         }
     }
         client.channelState.forEach {
             it.users[event.user.nickname]?.let { chanUser ->
                 chanUser.nickname = event.newNick
-                yield(ChannelNickChanged(event.time, event.user, it.name, event.newNick))
+                yield(ChannelNickChanged(event.metadata, event.user, it.name, event.newNick))
             }
         }
     }

src/main/kotlin/com/dmdirc/ktirc/events/mutators/ServerReadyMutator.kt

         if (client.serverState.receivedWelcome
                 && client.serverState.status == ServerStatus.Negotiating
                 && event::class !in excludedEvents) {
-            yield(ServerReady(event.time))
+            yield(ServerReady(event.metadata))
         }
         yield(event)
     }.toList()

src/main/kotlin/com/dmdirc/ktirc/messages/AccountProcessor.kt

     override val commands = arrayOf("ACCOUNT")
 
     override fun process(message: IrcMessage) = message.sourceUser?.let { user ->
-        listOf(UserAccountChanged(message.time, user, message.accountName))
+        listOf(UserAccountChanged(message.metadata, user, message.accountName))
     } ?: emptyList()
 
     private val IrcMessage.accountName

src/main/kotlin/com/dmdirc/ktirc/messages/AuthenticationProcessor.kt

     override val commands = arrayOf("AUTHENTICATE", RPL_SASLSUCCESS, ERR_SASLFAIL, RPL_SASLMECHS)
 
     override fun process(message: IrcMessage) = when(message.command) {
-        "AUTHENTICATE" -> listOf(AuthenticationMessage(message.time, message.authenticateArgument))
-        RPL_SASLSUCCESS -> listOf(SaslFinished(message.time, true))
-        ERR_SASLFAIL -> listOf(SaslFinished(message.time, false))
-        RPL_SASLMECHS -> listOf(SaslMechanismNotAvailableError(message.time, message.mechanisms))
+        "AUTHENTICATE" -> listOf(AuthenticationMessage(message.metadata, message.authenticateArgument))
+        RPL_SASLSUCCESS -> listOf(SaslFinished(message.metadata, true))
+        ERR_SASLFAIL -> listOf(SaslFinished(message.metadata, false))
+        RPL_SASLMECHS -> listOf(SaslMechanismNotAvailableError(message.metadata, message.mechanisms))
         else -> emptyList()
     }
 

src/main/kotlin/com/dmdirc/ktirc/messages/BatchProcessor.kt

+package com.dmdirc.ktirc.messages
+
+import com.dmdirc.ktirc.events.IrcEvent
+import com.dmdirc.ktirc.model.IrcMessage
+
+internal class BatchProcessor : MessageProcessor {
+
+    override val commands = arrayOf("BATCH")
+
+    override fun process(message: IrcMessage): List<IrcEvent> {
+        TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
+    }
+
+}

src/main/kotlin/com/dmdirc/ktirc/messages/CapabilityProcessor.kt

 package com.dmdirc.ktirc.messages
 
+import com.dmdirc.ktirc.events.EventMetadata
 import com.dmdirc.ktirc.events.ServerCapabilitiesAcknowledged
 import com.dmdirc.ktirc.events.ServerCapabilitiesFinished
 import com.dmdirc.ktirc.events.ServerCapabilitiesReceived
 import com.dmdirc.ktirc.model.IrcMessage
 import com.dmdirc.ktirc.model.capabilities
 import com.dmdirc.ktirc.util.logger
-import java.time.LocalDateTime
 
 internal class CapabilityProcessor : MessageProcessor {
 
     override val commands = arrayOf("CAP")
 
     override fun process(message: IrcMessage) = when (message.subCommand) {
-        "LS" -> handleList(message.time, message.subCommandArguments)
-        "ACK" -> listOf(ServerCapabilitiesAcknowledged(message.time, message.params.capabilities))
+        "LS" -> handleList(message.metadata, message.subCommandArguments)
+        "ACK" -> listOf(ServerCapabilitiesAcknowledged(message.metadata, message.params.capabilities))
         else -> emptyList()
     }
 
-    private fun handleList(time: LocalDateTime, lsParams: List<ByteArray>) = sequence {
-        yield(ServerCapabilitiesReceived(time, lsParams.capabilities))
+    private fun handleList(metadata: EventMetadata, lsParams: List<ByteArray>) = sequence {
+        yield(ServerCapabilitiesReceived(metadata, lsParams.capabilities))
         if (lsParams.size < 2 || String(lsParams[0]) != "*") {
-            yield(ServerCapabilitiesFinished(time))
+            yield(ServerCapabilitiesFinished(metadata))
         }
     }.toList()
 

src/main/kotlin/com/dmdirc/ktirc/messages/ISupportProcessor.kt

 
     override val commands = arrayOf(RPL_ISUPPORT)
 
-    override fun process(message: IrcMessage) = listOf(ServerFeaturesUpdated(message.time, ServerFeatureMap().apply {
+    override fun process(message: IrcMessage) = listOf(ServerFeaturesUpdated(message.metadata, ServerFeatureMap().apply {
         // Ignore the first (nickname) and last ("are supported by this server") params
         for (i in 1 until message.params.size - 1) {
             parseParam(message.params[i])

src/main/kotlin/com/dmdirc/ktirc/messages/JoinProcessor.kt

 
     override fun process(message: IrcMessage) = message.sourceUser?.let { user ->
         user.addExtendedJoinFields(message.params)
-        listOf(ChannelJoined(message.time, user, String(message.params[0])))
+        listOf(ChannelJoined(message.metadata, user, String(message.params[0])))
     } ?: emptyList()
 
     private fun User.addExtendedJoinFields(params: List<ByteArray>) {

src/main/kotlin/com/dmdirc/ktirc/messages/KickProcessor.kt

     override val commands = arrayOf("KICK")
 
     override fun process(message: IrcMessage) = message.sourceUser?.let { user ->
-        listOf(ChannelUserKicked(message.time, user, message.channel, message.victim, message.reason))
+        listOf(ChannelUserKicked(message.metadata, user, message.channel, message.victim, message.reason))
     } ?: emptyList()
 
     private val IrcMessage.channel

src/main/kotlin/com/dmdirc/ktirc/messages/ModeProcessor.kt

         val isDiscovery = message.command == RPL_CHANNELMODEIS || message.command == RPL_UMODEIS
         val paramOffset = if (message.command == RPL_CHANNELMODEIS) 1 else 0
         return listOf(ModeChanged(
-                message.time,
+                message.metadata,
                 target = String(message.params[paramOffset]),
                 modes = String(message.params[paramOffset + 1]),
                 arguments = message.params.takeLast(message.params.size - paramOffset - 2).map { String(it) }.toTypedArray(),

src/main/kotlin/com/dmdirc/ktirc/messages/MotdProcessor.kt

 
     override fun process(message: IrcMessage) = sequence {
         when (message.command) {
-            RPL_MOTDSTART -> yield(MotdLineReceived(message.time, String(message.params[1]), true))
-            RPL_MOTD -> yield(MotdLineReceived(message.time, String(message.params[1])))
-            ERR_NOMOTD -> yield(MotdFinished(message.time, missing = true))
-            RPL_ENDOFMOTD -> yield(MotdFinished(message.time))
+            RPL_MOTDSTART -> yield(MotdLineReceived(message.metadata, String(message.params[1]), true))
+            RPL_MOTD -> yield(MotdLineReceived(message.metadata, String(message.params[1])))
+            ERR_NOMOTD -> yield(MotdFinished(message.metadata, missing = true))
+            RPL_ENDOFMOTD -> yield(MotdFinished(message.metadata))
         }
     }.toList()
 

src/main/kotlin/com/dmdirc/ktirc/messages/NamesProcessor.kt

     override val commands = arrayOf("353", "366")
 
     override fun process(message: IrcMessage) = when (message.command) {
-        "353" -> listOf(ChannelNamesReceived(message.time, String(message.params[2]), String(message.params[3]).split(' ')))
-        "366" -> listOf(ChannelNamesFinished(message.time, String(message.params[1])))
+        "353" -> listOf(ChannelNamesReceived(message.metadata, String(message.params[2]), String(message.params[3]).split(' ')))
+        "366" -> listOf(ChannelNamesFinished(message.metadata, String(message.params[1])))
         else -> emptyList()
     }
 

src/main/kotlin/com/dmdirc/ktirc/messages/NickProcessor.kt

     override val commands = arrayOf("NICK")
 
     override fun process(message: IrcMessage) =
-            message.sourceUser?.let { listOf(UserNickChanged(message.time, it, String(message.params[0]))) }
+            message.sourceUser?.let { listOf(UserNickChanged(message.metadata, it, String(message.params[0]))) }
                     ?: emptyList()
 
 }

src/main/kotlin/com/dmdirc/ktirc/messages/NoticeProcessor.kt

 
     override fun process(message: IrcMessage) = when {
             message.isCtcp() -> handleCtcp(message,  message.sourceUser)
-            else -> listOf(NoticeReceived(message.time,  message.sourceUser ?: User("*"), String(message.params[0]), String(message.params[1])))
+            else -> listOf(NoticeReceived(message.metadata,  message.sourceUser ?: User("*"), String(message.params[0]), String(message.params[1])))
         }
 
     private fun handleCtcp(message: IrcMessage, user: User?): List<IrcEvent> {
         val content = String(message.params[1]).substring(1 until message.params[1].size - 1)
         val parts = content.split(' ', limit=2)
         val body = if (parts.size == 2) parts[1] else ""
-        return listOf(CtcpReplyReceived(message.time, user, String(message.params[0]), parts[0], body))
+        return listOf(CtcpReplyReceived(message.metadata, user, String(message.params[0]), parts[0], body))
     }
 
     private fun IrcMessage.isCtcp() = params[1].size > 2 && params[1][0] == CTCP_BYTE && params[1][params[1].size - 1] == CTCP_BYTE

src/main/kotlin/com/dmdirc/ktirc/messages/PartProcessor.kt

     override val commands = arrayOf("PART")
 
     override fun process(message: IrcMessage) = message.sourceUser?.let { user ->
-        listOf(ChannelParted(message.time, user, message.channel, message.reason))
+        listOf(ChannelParted(message.metadata, user, message.channel, message.reason))
     } ?: emptyList()
 
     private val IrcMessage.channel

src/main/kotlin/com/dmdirc/ktirc/messages/PingProcessor.kt

 
     override val commands = arrayOf("PING")
 
-    override fun process(message: IrcMessage) = listOf(PingReceived(message.time, message.params[0]))
+    override fun process(message: IrcMessage) = listOf(PingReceived(message.metadata, message.params[0]))
 
 }

src/main/kotlin/com/dmdirc/ktirc/messages/PrivmsgProcessor.kt

     override fun process(message: IrcMessage) = message.sourceUser?.let { user ->
         listOf(when {
             message.isCtcp() -> handleCtcp(message, user)
-            else -> MessageReceived(message.time, user, String(message.params[0]), String(message.params[1]), message.messageId)
+            else -> MessageReceived(message.metadata, user, String(message.params[0]), String(message.params[1]), message.messageId)
         })
     } ?: emptyList()
 
         val parts = content.split(' ', limit=2)
         val body = if (parts.size == 2) parts[1] else ""
         return when (parts[0].toUpperCase()) {
-            "ACTION" -> ActionReceived(message.time, user, String(message.params[0]), body, message.messageId)
-            else -> CtcpReceived(message.time, user, String(message.params[0]), parts[0], body)
+            "ACTION" -> ActionReceived(message.metadata, user, String(message.params[0]), body, message.messageId)
+            else -> CtcpReceived(message.metadata, user, String(message.params[0]), parts[0], body)
         }
     }
 

src/main/kotlin/com/dmdirc/ktirc/messages/QuitProcessor.kt

     override val commands = arrayOf("QUIT")
 
     override fun process(message: IrcMessage) = message.sourceUser?.let { user ->
-        listOf(UserQuit(message.time, user, message.reason))
+        listOf(UserQuit(message.metadata, user, message.reason))
     } ?: emptyList()
 
     private val IrcMessage.reason

src/main/kotlin/com/dmdirc/ktirc/messages/TopicProcessor.kt

 
     override fun process(message: IrcMessage) = sequence {
         when (message.command) {
-            RPL_TOPIC -> yield(ChannelTopicDiscovered(message.time, message.channel, String(message.params[2])))
-            RPL_NOTOPIC -> yield(ChannelTopicDiscovered(message.time, message.channel, null))
+            RPL_TOPIC -> yield(ChannelTopicDiscovered(message.metadata, message.channel, String(message.params[2])))
+            RPL_NOTOPIC -> yield(ChannelTopicDiscovered(message.metadata, message.channel, null))
             RPL_TOPICWHOTIME -> yield(ChannelTopicMetadataDiscovered(
-                    message.time, message.channel, message.params[2].asUser(), message.topicSetTime))
-            "TOPIC" -> message.sourceUser?.let { yield(ChannelTopicChanged(message.time, it, String(message.params[0]), String(message.params[1]))) }
+                    message.metadata, message.channel, message.params[2].asUser(), message.topicSetTime))
+            "TOPIC" -> message.sourceUser?.let { yield(ChannelTopicChanged(message.metadata, it, String(message.params[0]), String(message.params[1]))) }
         }
     }.toList()
 

src/main/kotlin/com/dmdirc/ktirc/messages/WelcomeProcessor.kt

 
     override val commands = arrayOf(RPL_WELCOME)
 
-    override fun process(message: IrcMessage) = listOf(ServerWelcome(message.time, message.serverName(), String(message.params[0])))
+    override fun process(message: IrcMessage) = listOf(ServerWelcome(message.metadata, message.serverName(), String(message.params[0])))
 
     private fun IrcMessage.serverName() = prefix?.let { String(it) } ?: ""
 

src/main/kotlin/com/dmdirc/ktirc/model/CapabilitiesState.kt

     /** Messages sent by the client are echo'd back on successful delivery. */
     object EchoMessages : Capability("echo-message")
 
+    /** Messages can be sent in batches, and potentially handled differently by the client. */
+    object Batch : Capability("batch")
+
     // Capabilities that notify us of changes to other clients:
     /** Receive a notification when a user's account changes. */
     object AccountChangeMessages : Capability("account-notify")

src/main/kotlin/com/dmdirc/ktirc/model/IrcMessage.kt

 package com.dmdirc.ktirc.model
 
+import com.dmdirc.ktirc.events.EventMetadata
 import com.dmdirc.ktirc.util.currentTimeProvider
 import com.dmdirc.ktirc.util.currentTimeZoneProvider
 import java.time.Instant
 /**
  * Represents an IRC protocol message.
  */
-class IrcMessage(val tags: Map<MessageTag, String>, val prefix: ByteArray?, val command: String, val params: List<ByteArray>) {
+internal class IrcMessage(val tags: Map<MessageTag, String>, val prefix: ByteArray?, val command: String, val params: List<ByteArray>) {
 
     /** The time at which the message was sent, or our best guess at it. */
-    val time: LocalDateTime = if (MessageTag.ServerTime in tags) {
-        LocalDateTime.ofInstant(Instant.parse(tags[MessageTag.ServerTime]), currentTimeZoneProvider())
-    } else {
-        currentTimeProvider()
-    }
+    val metadata = EventMetadata(time, batchId)
 
     /** The user that generated the message, if any. */
     val sourceUser by lazy {
         }
     }
 
+    private val time
+        get() = if (MessageTag.ServerTime in tags) {
+            LocalDateTime.ofInstant(Instant.parse(tags[MessageTag.ServerTime]), currentTimeZoneProvider())
+        } else {
+            currentTimeProvider()
+        }
+
+    private val batchId
+        get() = tags[MessageTag.Batch]
+
 }
 
 /**
  * Supported tags that may be applied to messages.
  */
+@Suppress("unused")
 sealed class MessageTag(val name: String) {
     /** Specifies the account name of the user, if the `account-tag` capability is negotiated. */
     object AccountName : MessageTag("account")
+
+    /** Specifies the ID that a batch message belongs to. */
+    object Batch : MessageTag("batch")
+
     /** Specifies the time the server received the message, if the `server-time` capability is negotiated. */
     object ServerTime : MessageTag("time")
+
     /** A unique ID for the message, used to reply, react, edit, delete, etc. */
     object MessageId : MessageTag("draft/msgid")
+
     /** Used to identify a message ID that was replied to, to enable threaded conversations. */
     object Reply : MessageTag("+draft/reply")
+
     /** Used to specify a slack-like reaction to another message. */
     object React : MessageTag("+draft/react")
 }

src/test/kotlin/com/dmdirc/ktirc/IrcClientImplTest.kt

         verify(mockEventHandler, timeout(500).atLeast(2)).invoke(captor.capture())
 
         assertTrue(captor.firstValue is ServerConnecting)
-        assertEquals(TestConstants.time, captor.firstValue.time)
+        assertEquals(TestConstants.time, captor.firstValue.metadata.time)
 
         assertTrue(captor.secondValue is ServerConnected)
-        assertEquals(TestConstants.time, captor.secondValue.time)
+        assertEquals(TestConstants.time, captor.secondValue.metadata.time)
     }
 
     @Test

src/test/kotlin/com/dmdirc/ktirc/events/EventUtilsTest.kt

 
     @Test
     fun `ChannelNamesReceived#toModesAndUsers parses nicknames and mode prefixes`() {
-        val event = ChannelNamesReceived(TestConstants.time, "#thegibson", listOf(
+        val event = ChannelNamesReceived(EventMetadata(TestConstants.time), "#thegibson", listOf(
                 "@+acidBurn", "@zeroCool", "thePlague"
         ))
 
 
     @Test
     fun `ChannelNamesReceived#toModesAndUsers parses extended joins with prefixes`() {
-        val event = ChannelNamesReceived(TestConstants.time, "#thegibson", listOf(
+        val event = ChannelNamesReceived(EventMetadata(TestConstants.time), "#thegibson", listOf(
                 "@+acidBurn!libby@root.localhost", "zeroCool!dade@root.localhost"
         ))
 
     @Test
     fun `reply sends response to user when message is private`() {
         serverState.localNickname = "zeroCool"
-        val message = MessageReceived(TestConstants.time, User("acidBurn"), "Zerocool", "Hack the planet!")
+        val message = MessageReceived(EventMetadata(TestConstants.time), User("acidBurn"), "Zerocool", "Hack the planet!")
 
         ircClient.reply(message, "OK")
         verify(ircClient).send("PRIVMSG acidBurn :OK")
 
     @Test
     fun `reply sends unprefixed response to user when message is in a channel`() {
-        val message = MessageReceived(TestConstants.time, User("acidBurn"), "#TheGibson", "Hack the planet!")
+        val message = MessageReceived(EventMetadata(TestConstants.time), User("acidBurn"), "#TheGibson", "Hack the planet!")
 
         ircClient.reply(message, "OK")
         verify(ircClient).send("PRIVMSG #TheGibson :OK")
 
     @Test
     fun `reply sends prefixed response to user when message is in a channel`() {
-        val message = MessageReceived(TestConstants.time, User("acidBurn"), "#TheGibson", "Hack the planet!")
+        val message = MessageReceived(EventMetadata(TestConstants.time), User("acidBurn"), "#TheGibson", "Hack the planet!")
 
         ircClient.reply(message, "OK", prefixWithNickname = true)
         verify(ircClient).send("PRIVMSG #TheGibson :acidBurn: OK")
     @Test
     fun `reply sends response with message ID to user when message is private`() {
         serverState.localNickname = "zeroCool"
-        val message = MessageReceived(TestConstants.time, User("acidBurn"), "Zerocool", "Hack the planet!", "abc123")
+        val message = MessageReceived(EventMetadata(TestConstants.time), User("acidBurn"), "Zerocool", "Hack the planet!", "abc123")
 
         ircClient.reply(message, "OK")
         verify(ircClient).send("@+draft/reply=abc123 PRIVMSG acidBurn :OK")
 
     @Test
     fun `reply sends unprefixed response with message ID to user when message is in a channel`() {
-        val message = MessageReceived(TestConstants.time, User("acidBurn"), "#TheGibson", "Hack the planet!", "abc123")
+        val message = MessageReceived(EventMetadata(TestConstants.time), User("acidBurn"), "#TheGibson", "Hack the planet!", "abc123")
 
         ircClient.reply(message, "OK")
         verify(ircClient).send("@+draft/reply=abc123 PRIVMSG #TheGibson :OK")
 
     @Test
     fun `reply sends prefixed response with message ID to user when message is in a channel`() {
-        val message = MessageReceived(TestConstants.time, User("acidBurn"), "#TheGibson", "Hack the planet!", "abc123")
+        val message = MessageReceived(EventMetadata(TestConstants.time), User("acidBurn"), "#TheGibson", "Hack the planet!", "abc123")
 
         ircClient.reply(message, "OK", prefixWithNickname = true)
         verify(ircClient).send("@+draft/reply=abc123 PRIVMSG #TheGibson :acidBurn: OK")
     @Test
     fun `react sends response to user when message is private`() {
         serverState.localNickname = "zeroCool"
-        val message = MessageReceived(TestConstants.time, User("acidBurn"), "Zerocool", "Hack the planet!", "msgId")
+        val message = MessageReceived(EventMetadata(TestConstants.time), User("acidBurn"), "Zerocool", "Hack the planet!", "msgId")
 
         ircClient.react(message, ":P")
         verify(ircClient).send("@+draft/react=:P;+draft/reply=msgId TAGMSG acidBurn")
 
     @Test
     fun `react sends unprefixed response to user when message is in a channel`() {
-        val message = MessageReceived(TestConstants.time, User("acidBurn"), "#TheGibson", "Hack the planet!", "msgId")
+        val message = MessageReceived(EventMetadata(TestConstants.time), User("acidBurn"), "#TheGibson", "Hack the planet!", "msgId")
 
         ircClient.react(message, ":P")
         verify(ircClient).send("@+draft/react=:P;+draft/reply=msgId TAGMSG #TheGibson")

src/test/kotlin/com/dmdirc/ktirc/events/handlers/CapabilitiesHandlerTest.kt

 
     @Test
     fun `adds new capabilities to the state`() {
-        handler.processEvent(ircClient, ServerCapabilitiesReceived(TestConstants.time, hashMapOf(
+        handler.processEvent(ircClient, ServerCapabilitiesReceived(EventMetadata(TestConstants.time), hashMapOf(
                 Capability.EchoMessages to "",
                 Capability.HostsInNamesReply to "123"
         )))
     fun `updates negotiation state when capabilities finished`() {
         serverState.capabilities.advertisedCapabilities[Capability.EchoMessages] = ""
 
-        handler.processEvent(ircClient, ServerCapabilitiesFinished(TestConstants.time))
+        handler.processEvent(ircClient, ServerCapabilitiesFinished(EventMetadata(TestConstants.time)))
 
         assertEquals(CapabilitiesNegotiationState.AWAITING_ACK, serverState.capabilities.negotiationState)
     }
         serverState.capabilities.advertisedCapabilities[Capability.EchoMessages] = ""
         serverState.capabilities.advertisedCapabilities[Capability.AccountChangeMessages] = ""
 
-        handler.processEvent(ircClient, ServerCapabilitiesFinished(TestConstants.time))
+        handler.processEvent(ircClient, ServerCapabilitiesFinished(EventMetadata(TestConstants.time)))
 
         verify(ircClient).send(argThat { equals("CAP REQ :echo-message account-notify") || equals("CAP REQ :account-notify echo-message") })
     }
 
     @Test
     fun `sends END when blank capabilities received`() {
-        handler.processEvent(ircClient, ServerCapabilitiesFinished(TestConstants.time))
+        handler.processEvent(ircClient, ServerCapabilitiesFinished(EventMetadata(TestConstants.time)))
 
         verify(ircClient).send("CAP END")
     }
 
     @Test
     fun `updates negotiation when blank capabilities received`() {
-        handler.processEvent(ircClient, ServerCapabilitiesFinished(TestConstants.time))
+        handler.processEvent(ircClient, ServerCapabilitiesFinished(EventMetadata(TestConstants.time)))
 
         assertEquals(CapabilitiesNegotiationState.FINISHED, serverState.capabilities.negotiationState)
     }
 
     @Test
     fun `sends END when capabilities acknowledged and no enabled mechanisms`() {
-        handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(TestConstants.time, hashMapOf(
+        handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(EventMetadata(TestConstants.time), hashMapOf(
                 Capability.EchoMessages to "",
                 Capability.HostsInNamesReply to ""
         )))
     @Test
     fun `sends END when capabilities acknowledged and no sasl state`() {
         serverState.sasl.mechanisms.addAll(listOf(saslMech1, saslMech2, saslMech3))
-        handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(TestConstants.time, hashMapOf(
+        handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(EventMetadata(TestConstants.time), hashMapOf(
                 Capability.EchoMessages to "",
                 Capability.HostsInNamesReply to ""
         )))
     fun `sends END when capabilities acknowledged and no shared mechanism`() {
         serverState.sasl.mechanisms.addAll(listOf(saslMech1, saslMech2, saslMech3))
         serverState.capabilities.advertisedCapabilities[Capability.SaslAuthentication] = "fake1,fake2"
-        handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(TestConstants.time, hashMapOf(
+        handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(EventMetadata(TestConstants.time), hashMapOf(
                 Capability.SaslAuthentication to "",
                 Capability.HostsInNamesReply to ""
         )))
     fun `sets current SASL mechanism when capabilities acknowledged with shared mechanism`() {
         serverState.sasl.mechanisms.addAll(listOf(saslMech1, saslMech2, saslMech3))
         serverState.capabilities.advertisedCapabilities[Capability.SaslAuthentication] = "mech1,fake2"
-        handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(TestConstants.time, hashMapOf(
+        handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(EventMetadata(TestConstants.time), hashMapOf(
                 Capability.SaslAuthentication to "",
                 Capability.HostsInNamesReply to ""
         )))
     fun `sets current SASL mechanism when capabilities acknowledged with no declared mechanisms`() {
         serverState.sasl.mechanisms.addAll(listOf(saslMech1, saslMech2, saslMech3))
         serverState.capabilities.advertisedCapabilities[Capability.SaslAuthentication] = ""
-        handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(TestConstants.time, hashMapOf(
+        handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(EventMetadata(TestConstants.time), hashMapOf(
                 Capability.SaslAuthentication to "",
                 Capability.HostsInNamesReply to ""
         )))
     fun `sends authenticate when capabilities acknowledged with shared mechanism`() {
         serverState.sasl.mechanisms.addAll(listOf(saslMech1, saslMech2, saslMech3))
         serverState.capabilities.advertisedCapabilities[Capability.SaslAuthentication] = "mech1,fake2"
-        handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(TestConstants.time, hashMapOf(
+        handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(EventMetadata(TestConstants.time), hashMapOf(
                 Capability.SaslAuthentication to "",
                 Capability.HostsInNamesReply to ""
         )))
     fun `sends authenticate when capabilities acknowledged with no declared mechanisms`() {
         serverState.sasl.mechanisms.addAll(listOf(saslMech1, saslMech2, saslMech3))
         serverState.capabilities.advertisedCapabilities[Capability.SaslAuthentication] = ""
-        handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(TestConstants.time, hashMapOf(
+        handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(EventMetadata(TestConstants.time), hashMapOf(
                 Capability.SaslAuthentication to "",
                 Capability.HostsInNamesReply to ""
         )))
     fun `updates negotiation state when capabilities acknowledged with shared mechanism`() {
         serverState.sasl.mechanisms.addAll(listOf(saslMech1, saslMech2, saslMech3))
         serverState.capabilities.advertisedCapabilities[Capability.SaslAuthentication] = "mech1,fake2"
-        handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(TestConstants.time, hashMapOf(
+        handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(EventMetadata(TestConstants.time), hashMapOf(
                 Capability.SaslAuthentication to "",
                 Capability.HostsInNamesReply to ""
         )))
 
     @Test
     fun `updates negotiation state when capabilities acknowledged`() {
-        handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(TestConstants.time, hashMapOf(
+        handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(EventMetadata(TestConstants.time), hashMapOf(
                 Capability.EchoMessages to "",
                 Capability.HostsInNamesReply to "123"
         )))
 
     @Test
     fun `stores enabled caps when capabilities acknowledged`() {
-        handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(TestConstants.time, hashMapOf(
+        handler.processEvent(ircClient, ServerCapabilitiesAcknowledged(EventMetadata(TestConstants.time), hashMapOf(
                 Capability.EchoMessages to "",
                 Capability.HostsInNamesReply to "123"
         )))
     @Test
     fun `aborts authentication attempt if not expecting one`() {
         serverState.sasl.currentMechanism = null
-        handler.processEvent(ircClient, AuthenticationMessage(TestConstants.time, "+"))
+        handler.processEvent(ircClient, AuthenticationMessage(EventMetadata(TestConstants.time), "+"))
 
         verify(ircClient).send("AUTHENTICATE *")
     }
         serverState.sasl.currentMechanism = saslMech1
 
         val argument = "ABC"
-        handler.processEvent(ircClient, AuthenticationMessage(TestConstants.time, argument))
+        handler.processEvent(ircClient, AuthenticationMessage(EventMetadata(TestConstants.time), argument))
 
         verify(saslMech1).handleAuthenticationEvent(ircClient, argument.fromBase64())
     }
         serverState.sasl.currentMechanism = saslMech1
 
         val argument = "A".repeat(400)
-        handler.processEvent(ircClient, AuthenticationMessage(TestConstants.time, argument))
+        handler.processEvent(ircClient, AuthenticationMessage(EventMetadata(TestConstants.time), argument))
 
         assertEquals(argument, serverState.sasl.saslBuffer)
         verify(saslMech1, never()).handleAuthenticationEvent(any(), any())
         serverState.sasl.currentMechanism = saslMech1
 
         serverState.sasl.saslBuffer = "A".repeat(400)
-        handler.processEvent(ircClient, AuthenticationMessage(TestConstants.time, "B".repeat(400)))
+        handler.processEvent(ircClient, AuthenticationMessage(EventMetadata(TestConstants.time), "B".repeat(400)))
 
         assertEquals("A".repeat(400) + "B".repeat(400), serverState.sasl.saslBuffer)
         verify(saslMech1, never()).handleAuthenticationEvent(any(), any())
         serverState.sasl.saslBuffer = "A".repeat(400)
 
         val argument = "ABCD"
-        handler.processEvent(ircClient, AuthenticationMessage(TestConstants.time, argument))
+        handler.processEvent(ircClient, AuthenticationMessage(EventMetadata(TestConstants.time), argument))
 
         val captor = argumentCaptor<ByteArray>()
         verify(saslMech1).handleAuthenticationEvent(same(ircClient), captor.capture())
 
         serverState.sasl.saslBuffer = "A".repeat(400)
 
-        handler.processEvent(ircClient, AuthenticationMessage(TestConstants.time, null))
+        handler.processEvent(ircClient, AuthenticationMessage(EventMetadata(TestConstants.time), null))
 
         val captor = argumentCaptor<ByteArray>()
         verify(saslMech1).handleAuthenticationEvent(same(ircClient), captor.capture())
 
     @Test
     fun `sends END when SASL auth finished`() {
-        handler.processEvent(ircClient, SaslFinished(TestConstants.time, true))
+        handler.processEvent(ircClient, SaslFinished(EventMetadata(TestConstants.time), true))
 
         verify(ircClient).send("CAP END")
     }
 
     @Test
     fun `sets negotiation state when SASL auth finished`() {
-        handler.processEvent(ircClient, SaslFinished(TestConstants.time, true))
+        handler.processEvent(ircClient, SaslFinished(EventMetadata(TestConstants.time), true))
 
         assertEquals(CapabilitiesNegotiationState.FINISHED, serverState.capabilities.negotiationState)
     }
             mechanismState = "root@thegibson"
         }
 
-        handler.processEvent(ircClient, SaslFinished(TestConstants.time, true))
+        handler.processEvent(ircClient, SaslFinished(EventMetadata(TestConstants.time), true))
 
         with (serverState.sasl) {
             assertNull(currentMechanism)
     @Test
     fun `sends a new authenticate request when sasl mechanism rejected and new one is acceptable`() {
         serverState.sasl.mechanisms.addAll(listOf(saslMech1, saslMech2, saslMech3))
-        handler.processEvent(ircClient, SaslMechanismNotAvailableError(TestConstants.time, listOf("mech1", "fake2")))
+        handler.processEvent(ircClient, SaslMechanismNotAvailableError(EventMetadata(TestConstants.time), listOf("mech1", "fake2")))
 
         verify(ircClient).send("AUTHENTICATE mech1")
     }
     @Test
     fun `sends cap end when sasl mechanism rejected and no new one is acceptable`() {
         serverState.sasl.mechanisms.addAll(listOf(saslMech1, saslMech2, saslMech3))
-        handler.processEvent(ircClient, SaslMechanismNotAvailableError(TestConstants.time, listOf("fake1", "fake2")))
+        handler.processEvent(ircClient, SaslMechanismNotAvailableError(EventMetadata(TestConstants.time), listOf("fake1", "fake2")))
 
         verify(ircClient).send("CAP END")
     }
     @Test
     fun `sets negotiation state when sasl mechanism rejected and no new one is acceptable`() {
         serverState.sasl.mechanisms.addAll(listOf(saslMech1, saslMech2, saslMech3))
-        handler.processEvent(ircClient, SaslMechanismNotAvailableError(TestConstants.time, listOf("fake1", "fake2")))
+        handler.processEvent(ircClient, SaslMechanismNotAvailableError(EventMetadata(TestConstants.time), listOf("fake1", "fake2")))
 
         assertEquals(CapabilitiesNegotiationState.FINISHED, serverState.capabilities.negotiationState)
     }

src/test/kotlin/com/dmdirc/ktirc/events/handlers/ChannelStateHandlerTest.kt

 
     @Test
     fun `creates new state object for local joins`() {
-        handler.processEvent(ircClient, ChannelJoined(TestConstants.time, User("acidburn", "libby", "root.localhost"), "#thegibson"))
+        handler.processEvent(ircClient, ChannelJoined(EventMetadata(TestConstants.time), User("acidburn", "libby", "root.localhost"), "#thegibson"))
         assertTrue("#thegibson" in channelStateMap)
     }
 
     @Test
     fun `does not create new state object for remote joins`() {
-        handler.processEvent(ircClient, ChannelJoined(TestConstants.time, User("zerocool", "dade", "root.localhost"), "#thegibson"))
+        handler.processEvent(ircClient, ChannelJoined(EventMetadata(TestConstants.time), User("zerocool", "dade", "root.localhost"), "#thegibson"))
         assertFalse("#thegibson" in channelStateMap)
     }
 
     fun `adds joiners to channel state`() {
         channelStateMap += ChannelState("#thegibson") { CaseMapping.Rfc }
 
-        handler.processEvent(ircClient, ChannelJoined(TestConstants.time, User("zerocool", "dade", "root.localhost"), "#thegibson"))
+        handler.processEvent(ircClient, ChannelJoined(EventMetadata(TestConstants.time), User("zerocool", "dade", "root.localhost"), "#thegibson"))
 
         assertTrue("zerocool" in channelStateMap["#thegibson"]?.users!!)
     }
         channel.users += ChannelUser("thePlague")
         channelStateMap += channel
 
-        handler.processEvent(ircClient, ChannelNamesReceived(TestConstants.time, "#thegibson", listOf("zeroCool")))
+        handler.processEvent(ircClient, ChannelNamesReceived(EventMetadata(TestConstants.time), "#thegibson", listOf("zeroCool")))
 
         assertEquals(1, channel.users.count())
         assertNotNull(channel.users["zeroCool"])
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
         channelStateMap += channel
 
-        handler.processEvent(ircClient, ChannelNamesReceived(TestConstants.time, "#thegibson", listOf("zeroCool")))
-        handler.processEvent(ircClient, ChannelNamesReceived(TestConstants.time, "#thegibson", listOf("acidBurn")))
-        handler.processEvent(ircClient, ChannelNamesReceived(TestConstants.time, "#thegibson", listOf("thePlague")))
+        handler.processEvent(ircClient, ChannelNamesReceived(EventMetadata(TestConstants.time), "#thegibson", listOf("zeroCool")))
+        handler.processEvent(ircClient, ChannelNamesReceived(EventMetadata(TestConstants.time), "#thegibson", listOf("acidBurn")))
+        handler.processEvent(ircClient, ChannelNamesReceived(EventMetadata(TestConstants.time), "#thegibson", listOf("thePlague")))
 
         assertEquals(3, channel.users.count())
         assertNotNull(channel.users["zeroCool"])
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
         channelStateMap += channel
 
-        handler.processEvent(ircClient, ChannelNamesReceived(TestConstants.time, "#thegibson", listOf("zeroCool")))
-        handler.processEvent(ircClient, ChannelNamesFinished(TestConstants.time, "#thegibson"))
-        handler.processEvent(ircClient, ChannelNamesReceived(TestConstants.time, "#thegibson", listOf("acidBurn")))
-        handler.processEvent(ircClient, ChannelNamesReceived(TestConstants.time, "#thegibson", listOf("thePlague")))
+        handler.processEvent(ircClient, ChannelNamesReceived(EventMetadata(TestConstants.time), "#thegibson", listOf("zeroCool")))
+        handler.processEvent(ircClient, ChannelNamesFinished(EventMetadata(TestConstants.time), "#thegibson"))
+        handler.processEvent(ircClient, ChannelNamesReceived(EventMetadata(TestConstants.time), "#thegibson", listOf("acidBurn")))
+        handler.processEvent(ircClient, ChannelNamesReceived(EventMetadata(TestConstants.time), "#thegibson", listOf("thePlague")))
 
         assertEquals(2, channel.users.count())
         assertNotNull(channel.users["acidBurn"])
         channelStateMap += channel
         serverState.features[ServerFeature.ModePrefixes] = ModePrefixMapping("ov", "@+")
 
-        handler.processEvent(ircClient, ChannelNamesReceived(TestConstants.time, "#thegibson", listOf("@zeroCool", "@+acidBurn", "+thePlague", "cerealKiller")))
-        handler.processEvent(ircClient, ChannelNamesFinished(TestConstants.time, "#thegibson"))
+        handler.processEvent(ircClient, ChannelNamesReceived(EventMetadata(TestConstants.time), "#thegibson", listOf("@zeroCool", "@+acidBurn", "+thePlague", "cerealKiller")))
+        handler.processEvent(ircClient, ChannelNamesFinished(EventMetadata(TestConstants.time), "#thegibson"))
 
         assertEquals(4, channel.users.count())
         assertEquals("o", channel.users["zeroCool"]?.modes)
         channelStateMap += channel
         serverState.features[ServerFeature.ModePrefixes] = ModePrefixMapping("ov", "@+")
 
-        handler.processEvent(ircClient, ChannelNamesReceived(TestConstants.time, "#thegibson", listOf("@zeroCool!dade@root.localhost", "+acidBurn!libby@root.localhost")))
-        handler.processEvent(ircClient, ChannelNamesFinished(TestConstants.time, "#thegibson"))
+        handler.processEvent(ircClient, ChannelNamesReceived(EventMetadata(TestConstants.time), "#thegibson", listOf("@zeroCool!dade@root.localhost", "+acidBurn!libby@root.localhost")))
+        handler.processEvent(ircClient, ChannelNamesFinished(EventMetadata(TestConstants.time), "#thegibson"))
 
         assertEquals(2, channel.users.count())
         assertEquals("o", channel.users["zeroCool"]?.modes)
         channelStateMap += channel
         serverState.features[ServerFeature.ModePrefixes] = ModePrefixMapping("ov", "@+")
 
-        handler.processEvent(ircClient, ChannelNamesReceived(TestConstants.time, "#thegibson", listOf("@zeroCool!dade@root.localhost", "+acidBurn!libby@root.localhost")))
+        handler.processEvent(ircClient, ChannelNamesReceived(EventMetadata(TestConstants.time), "#thegibson", listOf("@zeroCool!dade@root.localhost", "+acidBurn!libby@root.localhost")))
 
         assertTrue(channel.receivingUserList)
 
-        handler.processEvent(ircClient, ChannelNamesFinished(TestConstants.time, "#thegibson"))
+        handler.processEvent(ircClient, ChannelNamesFinished(EventMetadata(TestConstants.time), "#thegibson"))
 
         assertFalse(channel.receivingUserList)
     }
         serverState.features[ServerFeature.ModePrefixes] = ModePrefixMapping("ov", "@+")
         behaviour.requestModesOnJoin = true
 
-        handler.processEvent(ircClient, ChannelNamesFinished(TestConstants.time, "#thegibson"))
+        handler.processEvent(ircClient, ChannelNamesFinished(EventMetadata(TestConstants.time), "#thegibson"))
 
         verify(ircClient).send("MODE :#thegibson")
     }
         behaviour.requestModesOnJoin = true
         channel.modesDiscovered = true
 
-        handler.processEvent(ircClient, ChannelNamesFinished(TestConstants.time, "#thegibson"))
+        handler.processEvent(ircClient, ChannelNamesFinished(EventMetadata(TestConstants.time), "#thegibson"))
 
         verify(ircClient, never()).send("MODE :#thegibson")
     }
         serverState.features[ServerFeature.ModePrefixes] = ModePrefixMapping("ov", "@+")
         behaviour.requestModesOnJoin = false
 
-        handler.processEvent(ircClient, ChannelNamesFinished(TestConstants.time, "#thegibson"))
+        handler.processEvent(ircClient, ChannelNamesFinished(EventMetadata(TestConstants.time), "#thegibson"))
 
         verify(ircClient, never()).send("MODE :#thegibson")
     }
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
         channelStateMap += channel
 
-        handler.processEvent(ircClient, ChannelParted(TestConstants.time, User("acidburn", "libby", "root.localhost"), "#thegibson"))
+        handler.processEvent(ircClient, ChannelParted(EventMetadata(TestConstants.time), User("acidburn", "libby", "root.localhost"), "#thegibson"))
 
         assertFalse("#thegibson" in channelStateMap)
     }
         channel.users += ChannelUser("ZeroCool")
         channelStateMap += channel
 
-        handler.processEvent(ircClient, ChannelParted(TestConstants.time, User("zerocool", "dade", "root.localhost"), "#thegibson"))
+        handler.processEvent(ircClient, ChannelParted(EventMetadata(TestConstants.time), User("zerocool", "dade", "root.localhost"), "#thegibson"))
 
         assertFalse("zerocool" in channel.users)
     }
         val channel = ChannelState("#thegibson") { CaseMapping.Rfc }
         channelStateMap += channel
 
-        handler.processEvent(ircClient, ChannelUserKicked(TestConstants.time, User("zerocool", "dade", "root.localhost"), "#thegibson", "acidburn", "Bye!"))
+        handler.processEvent(ircClient, ChannelUserKicked(EventMetadata(TestConstants.time), User("zerocool", "dade", "root.localhost"), "#thegibson", "acidburn", "Bye!"))
 
         assertFalse("#thegibson" in channelStateMap)
     }
         channel.users += ChannelUser("ZeroCool")
         channelStateMap += channel
 
-        handler.processEvent(ircClient, ChannelUserKicked(TestConstants.time, User("acidburn", "libby", "root.localhost"), "#thegibson", "zerocool", "Bye!"))
+        handler.processEvent(ircClient, ChannelUserKicked(EventMetadata(TestConstants.time), User("acidburn", "libby", "root.localhost"), "#thegibson", "zerocool", "Bye!"))
 
         assertFalse("zerocool" in channel.users)
     }
             channelStateMap += this
         }
 
-        handler.processEvent(ircClient, ChannelQuit(TestConstants.time, User("zerocool", "dade", "root.localhost"), "#thegibson"))
-        handler.processEvent(ircClient, ChannelQuit(TestConstants.time, User("zerocool", "dade", "root.localhost"), "#dumpsterdiving"))
+        handler.processEvent(ircClient, ChannelQuit(EventMetadata(TestConstants.time), User("zerocool", "dade", "root.localhost"), "#thegibson"))
+        handler.processEvent(ircClient, ChannelQuit(EventMetadata(TestConstants.time), User("zerocool", "dade", "root.localhost"), "#dumpsterdiving"))
 
         assertFalse("zerocool" in channelStateMap["#thegibson"]!!.users)
         assertFalse("zerocool" in channelStateMap["#dumpsterdiving"]!!.users)
         channel.users += ChannelUser("acidBurn")
         channelStateMap += channel
 
-        handler.processEvent(ircClient, ChannelNickChanged(TestConstants.time, User("acidburn", "libby", "root.localhost"), "#thegibson", "acidB"))
-        handler.processEvent(ircClient, ChannelNickChanged(TestConstants.time, User("acidburn", "libby", "root.localhost"), "#dumpsterdiving", "acidB"))
+        handler.processEvent(ircClient, ChannelNickChanged(EventMetadata(TestConstants.time), User("acidburn", "libby", "root.localhost"), "#thegibson", "acidB"))
+        handler.processEvent(ircClient, ChannelNickChanged(EventMetadata(TestConstants.time), User("acidburn", "libby", "root.localhost"), "#dumpsterdiving", "acidB"))
 
         assertFalse("acidBurn" in channel.users)
         assertTrue("acidB" in channel.users)
         channelStateMap += channel
         serverState.features[ServerFeature.ChannelModes] = arrayOf("ab", "cd", "ef", "gh")
 
-        handler.processEvent(ircClient, ModeChanged(TestConstants.time, "#thegibson", "+", emptyArray(), true))
+        handler.processEvent(ircClient, ModeChanged(EventMetadata(TestConstants.time), "#thegibson", "+", emptyArray(), true))
 
         assertTrue(channel.modesDiscovered)
     }
         channelStateMap += channel
         serverState.features[ServerFeature.ChannelModes] = arrayOf("ab", "cd", "ef", "gh")
 
-        handler.processEvent(ircClient, ModeChanged(TestConstants.time, "#thegibson", "+ceg", arrayOf("CCC", "EEE"), true))
+        handler.processEvent(ircClient, ModeChanged(EventMetadata(TestConstants.time), "#thegibson", "+ceg", arrayOf("CCC", "EEE"), true))
 
         assertEquals("CCC", channel.modes['c'])
         assertEquals("EEE", channel.modes['e'])
         channelStateMap += channel
         serverState.features[ServerFeature.ChannelModes] = arrayOf("ab", "cd", "ef", "gh")
 
-        handler.processEvent(ircClient, ModeChanged(TestConstants.time, "#thegibson", "-c+d-eh+fg", arrayOf("CCC", "DDD", "FFF"), true))
+        handler.processEvent(ircClient, ModeChanged(EventMetadata(TestConstants.time), "#thegibson", "-c+d-eh+fg", arrayOf("CCC", "DDD", "FFF"), true))
 
         assertNull(channel.modes['c'])
         assertEquals("DDD", channel.modes['d'])
             channelStateMap += this
         }
 
-        handler.processEvent(ircClient, ModeChanged(TestConstants.time, "#thegibson", "+o", arrayOf("zeroCool")))
+        handler.processEvent(ircClient, ModeChanged(EventMetadata(TestConstants.time), "#thegibson", "+o", arrayOf("zeroCool")))
 
         assertEquals("o", channelStateMap["#thegibson"]?.users?.get("zeroCool")?.modes)
     }
             channelStateMap += this
         }
 
-        handler.processEvent(ircClient, ModeChanged(TestConstants.time, "#thegibson", "+v", arrayOf("zeroCool")))
+        handler.processEvent(ircClient, ModeChanged(EventMetadata(TestConstants.time), "#thegibson", "+v", arrayOf("zeroCool")))
 
         assertEquals("ov", channelStateMap["#thegibson"]?.users?.get("zeroCool")?.modes)
     }
             channelStateMap += this
         }
 
-        handler.processEvent(ircClient, ModeChanged(TestConstants.time, "#thegibson", "+o", arrayOf("zeroCool")))
+        handler.processEvent(ircClient, ModeChanged(EventMetadata(TestConstants.time), "#thegibson", "+o", arrayOf("zeroCool")))
 
         assertEquals("ov", channelStateMap["#thegibson"]?.users?.get("zeroCool")?.modes)
     }
             channelStateMap += this
         }
 
-        handler.processEvent(ircClient, ModeChanged(TestConstants.time, "#thegibson", "+vo", arrayOf("zeroCool", "zeroCool")))
+        handler.processEvent(ircClient, ModeChanged(EventMetadata(TestConstants.time), "#thegibson", "+vo", arrayOf("zeroCool", "zeroCool")))
 
         assertEquals("ov", channelStateMap["#thegibson"]?.users?.get("zeroCool")?.modes)
     }
             channelStateMap += this
         }
 
-        handler.processEvent(ircClient, ModeChanged(TestConstants.time, "#thegibson", "-vo", arrayOf("zeroCool", "zeroCool")))
+        handler.processEvent(ircClient, ModeChanged(EventMetadata(TestConstants.time), "#thegibson", "-vo", arrayOf("zeroCool", "zeroCool")))
 
         assertEquals("", channelStateMap["#thegibson"]?.users?.get("zeroCool")?.modes)
     }
         }
         serverState.features[ServerFeature.ChannelModes] = arrayOf("ab", "cd", "ef", "gh")
 
-        handler.processEvent(ircClient, ModeChanged(TestConstants.time, "#thegibson", "oa-v+b", arrayOf("zeroCool", "aaa", "zeroCool", "bbb")))
+        handler.processEvent(ircClient, ModeChanged(EventMetadata(TestConstants.time), "#thegibson", "oa-v+b", arrayOf("zeroCool", "aaa", "zeroCool", "bbb")))
 
         assertEquals("o", channelStateMap["#thegibson"]?.users?.get("zeroCool")?.modes)
         assertEquals("aaa", channelStateMap["#thegibson"]?.modes?.get('a'))
         val state = ChannelState("#thegibson") { CaseMapping.Rfc }
         channelStateMap += state
 
-        handler.processEvent(ircClient, ChannelTopicDiscovered(TestConstants.time, "#thegibson", "Hack the planet!"))
-        handler.processEvent(ircClient, ChannelTopicMetadataDiscovered(TestConstants.time, "#thegibson", User("acidBurn"), TestConstants.otherTime))
+        handler.processEvent(ircClient, ChannelTopicDiscovered(EventMetadata(TestConstants.time), "#thegibson", "Hack the planet!"))
+        handler.processEvent(ircClient, ChannelTopicMetadataDiscovered(EventMetadata(TestConstants.time), "#thegibson", User("acidBurn"), TestConstants.otherTime))
 
         assertTrue(state.topicDiscovered)
         assertEquals(ChannelTopic("Hack the planet!", User("acidBurn"), TestConstants.otherTime), state.topic)
         val state = ChannelState("#thegibson") { CaseMapping.Rfc }
         channelStateMap += state
 
-        handler.processEvent(ircClient, ChannelTopicDiscovered(TestConstants.time, "#thegibson", null))
+        handler.processEvent(ircClient, ChannelTopicDiscovered(EventMetadata(TestConstants.time), "#thegibson", null))
 
         assertTrue(state.topicDiscovered)
         assertEquals(ChannelTopic(), state.topic)
         state.topicDiscovered = true
         channelStateMap += state
 
-        handler.processEvent(ircClient, ChannelTopicDiscovered(TestConstants.time, "#thegibson", "Hack the planet"))
-        handler.processEvent(ircClient, ChannelTopicMetadataDiscovered(TestConstants.time, "#thegibson", User("zeroCool"), TestConstants.time))
+        handler.processEvent(ircClient, ChannelTopicDiscovered(EventMetadata(TestConstants.time), "#thegibson", "Hack the planet"))
+        handler.processEvent(ircClient, ChannelTopicMetadataDiscovered(EventMetadata(TestConstants.time), "#thegibson", User("zeroCool"), TestConstants.time))
 
         assertTrue(state.topicDiscovered)
         assertEquals(ChannelTopic("Hack the planet!", User("acidBurn"), TestConstants.otherTime), state.topic)
         val state = ChannelState("#thegibson") { CaseMapping.Rfc }
         channelStateMap += state
 
-        handler.processEvent(ircClient, ChannelTopicChanged(TestConstants.time, User("acidBurn"), "#thegibson", "Hack the planet!"))
+        handler.processEvent(ircClient, ChannelTopicChanged(EventMetadata(TestConstants.time), User("acidBurn"), "#thegibson", "Hack the planet!"))
 
         assertEquals(ChannelTopic("Hack the planet!", User("acidBurn"), TestConstants.time), state.topic)
     }
         val state = ChannelState("#thegibson") { CaseMapping.Rfc }
         channelStateMap += state
 
-        handler.processEvent(ircClient, ChannelTopicChanged(TestConstants.time, User("acidBurn"), "#thegibson", null))
+        handler.processEvent(ircClient, ChannelTopicChanged(EventMetadata(TestConstants.time), User("acidBurn"), "#thegibson", null))
 
         assertEquals(ChannelTopic(null, User("acidBurn"), TestConstants.time), state.topic)
     }
         val state = ChannelState("#thegibson") { CaseMapping.Rfc }
         channelStateMap += state
 
-        handler.processEvent(ircClient, ChannelTopicChanged(TestConstants.time, User("acidBurn"), "#dumpsterdiving", "Hack the planet!"))
+        handler.processEvent(ircClient, ChannelTopicChanged(EventMetadata(TestConstants.time), User("acidBurn"), "#dumpsterdiving", "Hack the planet!"))
 
         assertEquals(ChannelTopic(), state.topic)
     }

src/test/kotlin/com/dmdirc/ktirc/events/handlers/PingHandlerTest.kt

 
 import com.dmdirc.ktirc.IrcClient
 import com.dmdirc.ktirc.TestConstants
+import com.dmdirc.ktirc.events.EventMetadata
 import com.dmdirc.ktirc.events.PingReceived
 import com.nhaarman.mockitokotlin2.mock
 import com.nhaarman.mockitokotlin2.verify
 
     @Test
     fun `PingHandler responses to pings with a pong`() = runBlocking {
-        handler.processEvent(ircClient, PingReceived(TestConstants.time, "the_plague".toByteArray()))
+        handler.processEvent(ircClient, PingReceived(EventMetadata(TestConstants.time), "the_plague".toByteArray()))
         verify(ircClient).send("PONG :the_plague")
     }
 

src/test/kotlin/com/dmdirc/ktirc/events/handlers/ServerStateHandlerTest.kt

 
     @Test
     fun `sets local nickname on welcome event`() {
-        handler.processEvent(ircClient, ServerWelcome(TestConstants.time, "the.gibson", "acidBurn"))
+        handler.processEvent(ircClient, ServerWelcome(EventMetadata(TestConstants.time), "the.gibson", "acidBurn"))
         assertEquals("acidBurn", serverState.localNickname)
     }
 
     @Test
     fun `sets server name on welcome event`() {
-        handler.processEvent(ircClient, ServerWelcome(TestConstants.time, "the.gibson", "acidBurn"))
+        handler.processEvent(ircClient, ServerWelcome(EventMetadata(TestConstants.time), "the.gibson", "acidBurn"))
         assertEquals("the.gibson", serverState.serverName)
     }
 
     @Test
     fun `sets receivedWelcome on welcome event`() {
-        handler.processEvent(ircClient, ServerWelcome(TestConstants.time, "the.gibson", "acidBurn"))
+        handler.processEvent(ircClient, ServerWelcome(EventMetadata(TestConstants.time), "the.gibson", "acidBurn"))
         assertTrue(serverState.receivedWelcome)
     }
 
     @Test
     fun `sets state to connecting on event`() {
-        handler.processEvent(ircClient, ServerConnecting(TestConstants.time))
+        handler.processEvent(ircClient, ServerConnecting(EventMetadata(TestConstants.time)))
         assertEquals(ServerStatus.Connecting, serverState.status)
     }
 
     @Test
     fun `sets state to disconnected on event`() {
         serverState.status = ServerStatus.Ready
-        handler.processEvent(ircClient, ServerDisconnected(TestConstants.time))
+        handler.processEvent(ircClient, ServerDisconnected(EventMetadata(TestConstants.time)))
         assertEquals(ServerStatus.Disconnected, serverState.status)
     }
 
     @Test
     fun `sets state to negotiating on connected`() {
-        handler.processEvent(ircClient, ServerConnected(TestConstants.time))
+        handler.processEvent(ircClient, ServerConnected(EventMetadata(TestConstants.time)))
         assertEquals(ServerStatus.Negotiating, serverState.status)
     }
 
     @Test
     fun `sets state to ready on ServerReady`() {
-        handler.processEvent(ircClient, ServerReady(TestConstants.time))
+        handler.processEvent(ircClient, ServerReady(EventMetadata(TestConstants.time)))
         assertEquals(ServerStatus.Ready, serverState.status)
     }
 
         features[ServerFeature.ChannelModes] = arrayOf("abc", "def")
         features[ServerFeature.WhoxSupport] = true
 
-        handler.processEvent(ircClient, ServerFeaturesUpdated(TestConstants.time, features))
+        handler.processEvent(ircClient, ServerFeaturesUpdated(EventMetadata(TestConstants.time), features))
 
         assertArrayEquals(arrayOf("abc", "def"), serverState.features[ServerFeature.ChannelModes])
         assertEquals(true, serverState.features[ServerFeature.WhoxSupport])

src/test/kotlin/com/dmdirc/ktirc/events/handlers/UserStateHandlerTest.kt

     fun `adds channel to user on join`() {
         userState += User("acidBurn")
 
-        handler.processEvent(ircClient, ChannelJoined(TestConstants.time, User("acidBurn", "libby", "root.localhost"), "#thegibson"))
+        handler.processEvent(ircClient, ChannelJoined(EventMetadata(TestConstants.time), User("acidBurn", "libby", "root.localhost"), "#thegibson"))
 
         assertEquals(listOf("#thegibson"), userState["acidBurn"]?.channels?.toList())
     }
     fun `updates user info on join`() {
         userState += User("acidBurn")
 
-        handler.processEvent(ircClient, ChannelJoined(TestConstants.time, User("acidBurn", "libby", "root.localhost"), "#thegibson"))
+        handler.processEvent(ircClient, ChannelJoined(EventMetadata(TestConstants.time), User("acidBurn", "libby", "root.localhost"), "#thegibson"))
 
         val details = userState["acidBurn"]?.details!!
         assertEquals("libby", details.ident)
         userState.addToChannel(User("acidBurn"), "#thegibson")
         userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
 
-        handler.processEvent(ircClient, ChannelParted(TestConstants.time, User("acidBurn", "libby", "root.localhost"), "#dumpsterdiving"))
+        handler.processEvent(ircClient, ChannelParted(EventMetadata(TestConstants.time), User("acidBurn", "libby", "root.localhost"), "#dumpsterdiving"))
 
         assertEquals(listOf("#thegibson"), userState["acidBurn"]?.channels?.toList())
     }
         userState += User("acidBurn")
         userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
 
-        handler.processEvent(ircClient, ChannelParted(TestConstants.time, User("acidBurn", "libby", "root.localhost"), "#dumpsterdiving"))
+        handler.processEvent(ircClient, ChannelParted(EventMetadata(TestConstants.time), User("acidBurn", "libby", "root.localhost"), "#dumpsterdiving"))
 
         assertNull(userState["acidBurn"])
     }
         userState.addToChannel(User("zeroCool"), "#dumpsterdiving")
         userState.addToChannel(User("zeroCool"), "#thegibson")
 
-        handler.processEvent(ircClient, ChannelParted(TestConstants.time, User("zeroCool", "dade", "root.localhost"), "#dumpsterdiving"))
+        handler.processEvent(ircClient, ChannelParted(EventMetadata(TestConstants.time), User("zeroCool", "dade", "root.localhost"), "#dumpsterdiving"))
 
         assertEquals(listOf("#thegibson"), userState["acidBurn"]?.channels?.toList())
         assertEquals(listOf("#thegibson"), userState["zeroCool"]?.channels?.toList())
         userState += User("acidBurn")
         userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
 
-        handler.processEvent(ircClient, ChannelParted(TestConstants.time, User("zeroCool", "dade", "root.localhost"), "#dumpsterdiving"))
+        handler.processEvent(ircClient, ChannelParted(EventMetadata(TestConstants.time), User("zeroCool", "dade", "root.localhost"), "#dumpsterdiving"))
 
         assertNull(userState["acidBurn"])
     }
         userState += User("zeroCool")
         userState.addToChannel(User("zeroCool"), "#dumpsterdiving")
 
-        handler.processEvent(ircClient, ChannelParted(TestConstants.time, User("zeroCool", "dade", "root.localhost"), "#dumpsterdiving"))
+        handler.processEvent(ircClient, ChannelParted(EventMetadata(TestConstants.time), User("zeroCool", "dade", "root.localhost"), "#dumpsterdiving"))
 
         assertNotNull(userState["zeroCool"])
     }
         userState.addToChannel(User("acidBurn"), "#thegibson")
         userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
 
-        handler.processEvent(ircClient, ChannelUserKicked(TestConstants.time, User("thePlague"), "#dumpsterdiving", "acidBurn"))
+        handler.processEvent(ircClient, ChannelUserKicked(EventMetadata(TestConstants.time), User("thePlague"), "#dumpsterdiving", "acidBurn"))
 
         assertEquals(listOf("#thegibson"), userState["acidBurn"]?.channels?.toList())
     }
         userState += User("acidBurn")
         userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
 
-        handler.processEvent(ircClient, ChannelUserKicked(TestConstants.time, User("thePlague"), "#dumpsterdiving", "acidBurn"))
+        handler.processEvent(ircClient, ChannelUserKicked(EventMetadata(TestConstants.time), User("thePlague"), "#dumpsterdiving", "acidBurn"))
 
         assertNull(userState["acidBurn"])
     }
         userState.addToChannel(User("zeroCool"), "#dumpsterdiving")
         userState.addToChannel(User("zeroCool"), "#thegibson")
 
-        handler.processEvent(ircClient, ChannelUserKicked(TestConstants.time, User("thePlague"), "#dumpsterdiving", "zeroCool"))
+        handler.processEvent(ircClient, ChannelUserKicked(EventMetadata(TestConstants.time), User("thePlague"), "#dumpsterdiving", "zeroCool"))
 
         assertEquals(listOf("#thegibson"), userState["acidBurn"]?.channels?.toList())
         assertEquals(listOf("#thegibson"), userState["zeroCool"]?.channels?.toList())
         userState += User("acidBurn")
         userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
 
-        handler.processEvent(ircClient, ChannelUserKicked(TestConstants.time, User("thePlague"), "#dumpsterdiving", "zeroCool"))
+        handler.processEvent(ircClient, ChannelUserKicked(EventMetadata(TestConstants.time), User("thePlague"), "#dumpsterdiving", "zeroCool"))
 
         assertNull(userState["acidBurn"])
     }
         userState += User("zeroCool")
         userState.addToChannel(User("zeroCool"), "#dumpsterdiving")
 
-        handler.processEvent(ircClient, ChannelUserKicked(TestConstants.time, User("thePlague"), "#dumpsterdiving", "zeroCool"))
+        handler.processEvent(ircClient, ChannelUserKicked(EventMetadata(TestConstants.time), User("thePlague"), "#dumpsterdiving", "zeroCool"))
 
         assertNotNull(userState["zeroCool"])
     }
         userState += User("acidBurn")
         userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
 
-        handler.processEvent(ircClient, UserQuit(TestConstants.time, User("acidBurn", "libby", "root.localhost")))
+        handler.processEvent(ircClient, UserQuit(EventMetadata(TestConstants.time), User("acidBurn", "libby", "root.localhost")))
 
         assertNull(userState["acidBurn"])
     }
         userState += User("acidBurn")
         userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
 
-        handler.processEvent(ircClient, ChannelNamesReceived(TestConstants.time, "#thegibson", listOf("@acidBurn")))
+        handler.processEvent(ircClient, ChannelNamesReceived(EventMetadata(TestConstants.time), "#thegibson", listOf("@acidBurn")))
 
         assertEquals(listOf("#dumpsterdiving", "#thegibson"), userState["acidBurn"]?.channels?.toList())
     }
         userState += User("acidBurn")
         userState.addToChannel(User("acidBurn"), "#dumpsterdiving")
 
-        handler.processEvent(ircClient, ChannelNamesReceived(TestConstants.time, "#thegibson", listOf("@acidBurn!libby@root.localhost")))
+        handler.processEvent(ircClient, ChannelNamesReceived(EventMetadata(TestConstants.time), "#thegibson", listOf("@acidBurn!libby@root.localhost")))
 
         val details = userState["acidBurn"]?.details!!
         assertEquals("libby", details.ident)
     fun `updates user info on account change`() {
         userState += User("acidBurn")
 
-        handler.processEvent(ircClient, UserAccountChanged(TestConstants.time, User("acidBurn", "libby", "root.localhost"), "acidBurn"))
+        handler.processEvent(ircClient, UserAccountChanged(EventMetadata(TestConstants.time), User("acidBurn", "libby", "root.localhost"), "acidBurn"))
 
         val details = userState["acidBurn"]?.details!!
         assertEquals("acidBurn", details.account)
         val user = User("acidBurn", "libby", "root.localhost")
         whenever(ircClient.isLocalUser(user)).doReturn(true)
 
-        handler.processEvent(ircClient, UserNickChanged(TestConstants.time, user, "acid~"))
+        handler.processEvent(ircClient, UserNickChanged(EventMetadata(TestConstants.time), user, "acid~"))
 
         assertEquals("acid~", serverState.localNickname)
     }
         val user = User("acidBurn", "libby", "root.localhost")
         userState += User("AcidBurn")
 
-        handler.processEvent(ircClient, UserNickChanged(TestConstants.time, user, "acid~"))
+        handler.processEvent(ircClient, UserNickChanged(EventMetadata(TestConstants.time), user, "acid~"))
 
         assertNotNull(userState["acid~"])
         assertNull(userState["AcidBurn"])

src/test/kotlin/com/dmdirc/ktirc/events/mutators/ChannelFanOutMutatorTest.kt

 import com.dmdirc.ktirc.BehaviourConfig
 import com.dmdirc.ktirc.IrcClient
 import com.dmdirc.ktirc.TestConstants
-import com.dmdirc.ktirc.events.ChannelNickChanged
-import com.dmdirc.ktirc.events.ChannelQuit
-import com.dmdirc.ktirc.events.UserNickChanged
-import com.dmdirc.ktirc.events.UserQuit
+import com.dmdirc.ktirc.events.*
 import com.dmdirc.ktirc.io.CaseMapping
 import com.dmdirc.ktirc.model.*
 import com.nhaarman.mockitokotlin2.doReturn
             channelStateMap += this
         }
 
-        val quitEvent = UserQuit(TestConstants.time, User("zerocool", "dade", "root.localhost"), "Hack the planet!")
+        val quitEvent = UserQuit(EventMetadata(TestConstants.time), User("zerocool", "dade", "root.localhost"), "Hack the planet!")
         val events = mutator.mutateEvent(ircClient, quitEvent)
 
         val names = mutableListOf<String>()
         Assertions.assertSame(quitEvent, events[0])
         events.subList(1, events.size).forEach { event ->
             (event as ChannelQuit).let {
-                Assertions.assertEquals(TestConstants.time, it.time)
+                Assertions.assertEquals(TestConstants.time, it.metadata.time)
                 Assertions.assertEquals("zerocool", it.user.nickname)
                 Assertions.assertEquals("Hack the planet!", it.reason)
                 names.add(it.channel)
             channelStateMap += this
         }
 
-        val nickEvent = UserNickChanged(TestConstants.time, User("zerocool", "dade", "root.localhost"), "zer0c00l")
+        val nickEvent = UserNickChanged(EventMetadata(TestConstants.time), User("zerocool", "dade", "root.localhost"), "zer0c00l")
         val events = mutator.mutateEvent(ircClient, nickEvent)
 
         val names = mutableListOf<String>()
         Assertions.assertSame(nickEvent, events[0])
         events.subList(1, events.size).forEach { event ->
             (event as ChannelNickChanged).let {
-                Assertions.assertEquals(TestConstants.time, it.time)
+                Assertions.assertEquals(TestConstants.time, it.metadata.time)
                 Assertions.assertEquals("zerocool", it.user.nickname)
                 Assertions.assertEquals("zer0c00l", it.newNick)
                 names.add(it.channel)

src/test/kotlin/com/dmdirc/ktirc/events/mutators/ServerReadyMutatorTest.kt

         ircClient.serverState.status = ServerStatus.Negotiating
 
         listOf(
-                ServerWelcome(TestConstants.time, "the.gibson", "acidBurn"),
-                PingReceived(TestConstants.time, "1234".toByteArray()),
-                ServerCapabilitiesReceived(TestConstants.time, emptyMap()),
-                ServerCapabilitiesAcknowledged(TestConstants.time, emptyMap()),
-                ServerCapabilitiesFinished(TestConstants.time)
+                ServerWelcome(EventMetadata(TestConstants.time), "the.gibson", "acidBurn"),
+                PingReceived(EventMetadata(TestConstants.time), "1234".toByteArray()),
+                ServerCapabilitiesReceived(EventMetadata(TestConstants.time), emptyMap()),
+                ServerCapabilitiesAcknowledged(EventMetadata(TestConstants.time), emptyMap()),
+                ServerCapabilitiesFinished(EventMetadata(TestConstants.time))
         ).forEach {
             assertEquals(1, mutator.mutateEvent(ircClient, it).size)
         }
 
-        val event = MessageReceived(TestConstants.time, User("zeroCool"), "acidBurn", "Welcome!")
+        val event = MessageReceived(EventMetadata(TestConstants.time), User("zeroCool"), "acidBurn", "Welcome!")
         val events = mutator.mutateEvent(ircClient, event)
         assertEquals(2, events.size)
         assertSame(event, events[1])

src/test/kotlin/com/dmdirc/ktirc/io/MessageHandlerTest.kt

 
 import com.dmdirc.ktirc.IrcClient
 import com.dmdirc.ktirc.TestConstants
+import com.dmdirc.ktirc.events.EventMetadata
 import com.dmdirc.ktirc.events.ServerConnected
 import com.dmdirc.ktirc.events.ServerReady
 import com.dmdirc.ktirc.events.ServerWelcome
         val eventHandler2 = mock<EventHandler>()
         val handler = MessageHandler(listOf(joinProcessor, nickProcessor), emptyList(), mutableListOf(eventHandler1, eventHandler2))
         val joinMessage = IrcMessage(emptyMap(), null, "JOIN", emptyList())
-        whenever(joinProcessor.process(any())).thenReturn(listOf(ServerConnected(TestConstants.time), ServerWelcome(TestConstants.time, "the.gibson", "acidBurn")))
+        whenever(joinProcessor.process(any())).thenReturn(listOf(ServerConnected(EventMetadata(TestConstants.time)), ServerWelcome(EventMetadata(TestConstants.time), "the.gibson", "acidBurn")))
 
         with(Channel<IrcMessage>(1)) {
             send(joinMessage)
         val eventHandler1 = mock<EventHandler>()
         val eventHandler2 = mock<EventHandler>()
         val handler = MessageHandler(emptyList(), emptyList(), mutableListOf(eventHandler1, eventHandler2))
-        handler.emitEvent(ircClient, ServerWelcome(TestConstants.time, "the.gibson", "acidBurn"))
+        handler.emitEvent(ircClient, ServerWelcome(EventMetadata(TestConstants.time), "the.gibson", "acidBurn"))
 
         verify(eventHandler1).processEvent(same(ircClient), isA<ServerWelcome>())
         verify(eventHandler2).processEvent(same(ircClient), isA<ServerWelcome>())
     @Test
     fun `mutates events in order`() {
         val eventMutator1 = mock<EventMutator> {
-            on { mutateEvent(any(), isA<ServerWelcome>()) } doReturn listOf(ServerReady(TestConstants.time))
+            on { mutateEvent(any(), isA<ServerWelcome>()) } doReturn listOf(ServerReady(EventMetadata(TestConstants.time)))
         }
         val eventMutator2 = mock<EventMutator> {
-            on { mutateEvent(any(), isA<ServerReady>()) } doReturn listOf(ServerConnected(TestConstants.time))
+            on { mutateEvent(any(), isA<ServerReady>()) } doReturn listOf(ServerConnected(EventMetadata(TestConstants.time)))
         }
         val eventHandler = mock<EventHandler>()
 
         val handler = MessageHandler(emptyList(), listOf(eventMutator1, eventMutator2), mutableListOf(eventHandler))
-        handler.emitEvent(ircClient, ServerWelcome(TestConstants.time, "the.gibson", "acidBurn"))
+        handler.emitEvent(ircClient, ServerWelcome(EventMetadata(TestConstants.time), "the.gibson", "acidBurn"))
 
         verify(eventMutator1).mutateEvent(same(ircClient), isA<ServerWelcome>())
         verify(eventMutator2).mutateEvent(same(ircClient), isA<ServerReady>())
     fun `allows mutators to fan out events`() {
         val eventMutator1 = mock<EventMutator> {
             on { mutateEvent(any(), isA<ServerWelcome>()) } doReturn listOf(
-                    ServerReady(TestConstants.time),
-                    ServerConnected(TestConstants.time)
+                    ServerReady(EventMetadata(TestConstants.time)),
+                    ServerConnected(EventMetadata(TestConstants.time))
             )
         }
         val eventMutator2 = mock<EventMutator> {
-            on { mutateEvent(any(), isA<ServerReady>()) } doReturn listOf(ServerReady(TestConstants.time))
-            on { mutateEvent(any(), isA<ServerConnected>()) } doReturn listOf(ServerConnected(TestConstants.time))
+            on { mutateEvent(any(), isA<ServerReady>()) } doReturn listOf(ServerReady(EventMetadata(TestConstants.time)))
+            on { mutateEvent(any(), isA<ServerConnected>()) } doReturn listOf(ServerConnected(EventMetadata(TestConstants.time)))
         }
         val eventHandler = mock<EventHandler>()
 
         val handler = MessageHandler(emptyList(), listOf(eventMutator1, eventMutator2), mutableListOf(eventHandler))
-        handler.emitEvent(ircClient, ServerWelcome(TestConstants.time, "the.gibson", "acidBurn"))
+        handler.emitEvent(ircClient, ServerWelcome(EventMetadata(TestConstants.time), "the.gibson", "acidBurn"))
 
         with (inOrder(eventMutator2, eventHandler)) {
             verify(eventMutator2).mutateEvent(same(ircClient), isA<ServerReady>())
         val eventHandler = mock<EventHandler>()
 
         val handler = MessageHandler(emptyList(), listOf(eventMutator1, eventMutator2), mutableListOf(eventHandler))
-        handler.emitEvent(ircClient, ServerWelcome(TestConstants.time, "the.gibson", "acidBurn"))
+        handler.emitEvent(ircClient, ServerWelcome(EventMetadata(TestConstants.time), "the.gibson", "acidBurn"))
 
         verify(eventMutator2, never()).mutateEvent(any(), any())
         verify(eventHandler, never()).processEvent(any(), any())

src/test/kotlin/com/dmdirc/ktirc/messages/AccountProcessorTest.kt

                 IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "ACCOUNT", params("acidBurn")))
         assertEquals(1, events.size)
 
-        assertEquals(TestConstants.time, events[0].time)
+        assertEquals(TestConstants.time, events[0].metadata.time)
         assertEquals(User("acidburn", "libby", "root.localhost"), events[0].user)
         assertEquals("acidBurn", events[0].newAccount)
     }
                 IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "ACCOUNT", params("*")))
         assertEquals(1, events.size)
 
-        assertEquals(TestConstants.time, events[0].time)
+        assertEquals(TestConstants.time, events[0].metadata.time)
         assertEquals(User("acidburn", "libby", "root.localhost"), events[0].user)
         assertEquals(null, events[0].newAccount)
     }

src/test/kotlin/com/dmdirc/ktirc/messages/AuthenticationProcessorTest.kt

 
         assertEquals(1, events.size)
         val event = events[0] as AuthenticationMessage
-        assertEquals(TestConstants.time, event.time)
+        assertEquals(TestConstants.time, event.metadata.time)
         assertNull(event.argument)
     }
 
 
         assertEquals(1, events.size)
         val event = events[0] as AuthenticationMessage
-        assertEquals(TestConstants.time, event.time)
+        assertEquals(TestConstants.time, event.metadata.time)
         assertNull(event.argument)
     }
 
 
         assertEquals(1, events.size)
         val event = events[0] as AuthenticationMessage
-        assertEquals(TestConstants.time, event.time)
+        assertEquals(TestConstants.time, event.metadata.time)
         assertEquals("HackThePlanet", event.argument)
     }
 
 
         assertEquals(1, events.size)
         val event = events[0] as SaslFinished
-        assertEquals(TestConstants.time, event.time)
+        assertEquals(TestConstants.time, event.metadata.time)
         assertTrue(event.success)
     }
 
 
         assertEquals(1, events.size)
         val event = events[0] as SaslFinished
-        assertEquals(TestConstants.time, event.time)
+        assertEquals(TestConstants.time, event.metadata.time)
         assertFalse(event.success)
     }
 
 
         assertEquals(1, events.size)
         val event = events[0] as SaslMechanismNotAvailableError
-        assertEquals(TestConstants.time, event.time)
+        assertEquals(TestConstants.time, event.metadata.time)
         assertEquals(listOf("PLAIN", "EXTERNAL", "MAGIC"), event.mechanisms)
     }
 
 
         assertEquals(1, events.size)
         val event = events[0] as SaslMechanismNotAvailableError
-        assertEquals(TestConstants.time, event.time)
+        assertEquals(TestConstants.time, event.metadata.time)
         assertTrue(event.mechanisms.isEmpty())
     }
 

src/test/kotlin/com/dmdirc/ktirc/messages/JoinProcessorTest.kt

                 IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "JOIN", params("#crashandburn")))
         assertEquals(1, events.size)
 
-        assertEquals(TestConstants.time, events[0].time)
+        assertEquals(TestConstants.time, events[0].metadata.time)
         assertEquals(User("acidburn", "libby", "root.localhost"), events[0].user)
         assertEquals("#crashandburn", events[0].channel)
     }
                 IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "JOIN", params("#crashandburn", "acidBurn", "Libby")))
         assertEquals(1, events.size)
 
-        assertEquals(TestConstants.time, events[0].time)
+        assertEquals(TestConstants.time, events[0].metadata.time)
         assertEquals(User("acidburn", "libby", "root.localhost", account = "acidBurn", realName = "Libby"), events[0].user)
         assertEquals("#crashandburn", events[0].channel)
     }
                 IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "JOIN", params("#crashandburn", "*", "Libby")))
         assertEquals(1, events.size)
 
-        assertEquals(TestConstants.time, events[0].time)
+        assertEquals(TestConstants.time, events[0].metadata.time)
         assertEquals(User("acidburn", "libby", "root.localhost", realName = "Libby"), events[0].user)
         assertEquals("#crashandburn", events[0].channel)
     }

src/test/kotlin/com/dmdirc/ktirc/messages/KickProcessorTest.kt

                 IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "KICK", params("#crashandburn", "zeroCool")))
         assertEquals(1, events.size)
 
-        assertEquals(TestConstants.time, events[0].time)
+        assertEquals(TestConstants.time, events[0].metadata.time)
         assertEquals(User("acidburn", "libby", "root.localhost"), events[0].user)
         assertEquals("#crashandburn", events[0].channel)
         assertEquals("zeroCool", events[0].victim)
                 IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "KICK", params("#crashandburn", "zeroCool", "Hack the planet!")))
         assertEquals(1, events.size)
 
-        assertEquals(TestConstants.time, events[0].time)
+        assertEquals(TestConstants.time, events[0].metadata.time)
         assertEquals(User("acidburn", "libby", "root.localhost"), events[0].user)
         assertEquals("#crashandburn", events[0].channel)
         assertEquals("zeroCool", events[0].victim)

src/test/kotlin/com/dmdirc/ktirc/messages/ModeProcessorTest.kt

                 IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "221", params("acidBurn", "+hax")))
         assertEquals(1, events.size)
 
-        assertEquals(TestConstants.time, events[0].time)
+        assertEquals(TestConstants.time, events[0].metadata.time)
         assertEquals("acidBurn", events[0].target)
         assertEquals("+hax", events[0].modes)
         assertEquals(0, events[0].arguments.size)
                 IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "221", params("acidBurn", "+hax", "123", "467")))
         assertEquals(1, events.size)
 
-        assertEquals(TestConstants.time, events[0].time)
+        assertEquals(TestConstants.time, events[0].metadata.time)
         assertEquals("acidBurn", events[0].target)
         assertEquals("+hax", events[0].modes)
         assertEquals(2, events[0].arguments.size)
                 IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "MODE", params("acidBurn", "+hax")))
         assertEquals(1, events.size)
 
-        assertEquals(TestConstants.time, events[0].time)
+        assertEquals(TestConstants.time, events[0].metadata.time)
         assertEquals("acidBurn", events[0].target)
         assertEquals("+hax", events[0].modes)
         assertEquals(0, events[0].arguments.size)
                 IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "MODE", params("acidBurn", "+hax", "123", "467")))
         assertEquals(1, events.size)
 
-        assertEquals(TestConstants.time, events[0].time)
+        assertEquals(TestConstants.time, events[0].metadata.time)
         assertEquals("acidBurn", events[0].target)
         assertEquals("+hax", events[0].modes)
         assertEquals(2, events[0].arguments.size)
                 IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "324", params("acidBurn", "#thegibson", "+hax")))
         assertEquals(1, events.size)
 
-        assertEquals(TestConstants.time, events[0].time)
+        assertEquals(TestConstants.time, events[0].metadata.time)
         assertEquals("#thegibson", events[0].target)
         assertEquals("+hax", events[0].modes)
         assertEquals(0, events[0].arguments.size)
                 IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "324", params("acidBurn", "#thegibson", "+hax", "123", "467")))
         assertEquals(1, events.size)
 
-        assertEquals(TestConstants.time, events[0].time)
+        assertEquals(TestConstants.time, events[0].metadata.time)
         assertEquals("#thegibson", events[0].target)
         assertEquals("+hax", events[0].modes)
         assertEquals(2, events[0].arguments.size)
                 IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "MODE", params("#thegibson", "+hax")))
         assertEquals(1, events.size)
 
-        assertEquals(TestConstants.time, events[0].time)
+        assertEquals(TestConstants.time, events[0].metadata.time)
         assertEquals("#thegibson", events[0].target)
         assertEquals("+hax", events[0].modes)
         assertEquals(0, events[0].arguments.size)
                 IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "MODE", params("#thegibson", "+hax", "123", "467")))
         assertEquals(1, events.size)
 
-        assertEquals(TestConstants.time, events[0].time)
+        assertEquals(TestConstants.time, events[0].metadata.time)
         assertEquals("#thegibson", events[0].target)
         assertEquals("+hax", events[0].modes)
         assertEquals(2, events[0].arguments.size)

src/test/kotlin/com/dmdirc/ktirc/messages/MotdProcessorTest.kt

         assertEquals(1, events.size)
 
         val event = events[0] as MotdFinished
-        assertEquals(TestConstants.time, events[0].time)
+        assertEquals(TestConstants.time, events[0].metadata.time)
         assertTrue(event.missing)
     }
 
         assertEquals(1, events.size)
 
         val event = events[0] as MotdFinished
-        assertEquals(TestConstants.time, events[0].time)
+        assertEquals(TestConstants.time, events[0].metadata.time)
         assertFalse(event.missing)
     }
 
         assertEquals(1, events.size)
 
         val event = events[0] as MotdLineReceived
-        assertEquals(TestConstants.time, event.time)
+        assertEquals(TestConstants.time, event.metadata.time)
         assertEquals("- the.gibson MOTD -", event.line)
         assertTrue(event.first)
     }
         assertEquals(1, events.size)
 
         val event = events[0] as MotdLineReceived
-        assertEquals(TestConstants.time, event.time)
+        assertEquals(TestConstants.time, event.metadata.time)
         assertEquals("Hack the planet!", event.line)
         assertFalse(event.first)
     }

src/test/kotlin/com/dmdirc/ktirc/messages/NoticeProcessorTest.kt

         assertEquals(1, events.size)
 
         val event = events[0] as NoticeReceived
-        assertEquals(TestConstants.time, event.time)
+        assertEquals(TestConstants.time, event.metadata.time)
         assertEquals(User("acidburn", "libby", "root.localhost"), event.user)
         assertEquals("#crashandburn", event.target)
         assertEquals("hack the planet!", event.message)
         assertEquals(1, events.size)
 
         val event = events[0] as NoticeReceived
-        assertEquals(TestConstants.time, event.time)
+        assertEquals(TestConstants.time, event.metadata.time)
         assertEquals(User("*"), event.user)
         assertEquals("#crashandburn", event.target)
         assertEquals("hack the planet!", event.message)
         assertEquals(1, events.size)
 
         val event = events[0] as CtcpReplyReceived
-        assertEquals(TestConstants.time, event.time)
+        assertEquals(TestConstants.time, event.metadata.time)
         assertEquals(User("acidburn", "libby", "root.localhost"), event.user)
         assertEquals("#crashandburn", event.target)
         assertEquals("PING", event.type)
         assertEquals(1, events.size)
 
         val event = events[0] as CtcpReplyReceived
-        assertEquals(TestConstants.time, event.time)
+        assertEquals(TestConstants.time, event.metadata.time)
         assertEquals(User("acidburn", "libby", "root.localhost"), event.user)
         assertEquals("#crashandburn", event.target)
         assertEquals("PING", event.type)

src/test/kotlin/com/dmdirc/ktirc/messages/PartProcessorTest.kt

                 IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "PART", params("#crashandburn")))
         assertEquals(1, events.size)
 
-        assertEquals(TestConstants.time, events[0].time)
+        assertEquals(TestConstants.time, events[0].metadata.time)
         assertEquals(User("acidburn", "libby", "root.localhost"), events[0].user)
         assertEquals("#crashandburn", events[0].channel)
         assertEquals("", events[0].reason)
                 IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "PART", params("#crashandburn", "Hack the planet!")))
         assertEquals(1, events.size)
 
-        assertEquals(TestConstants.time, events[0].time)
+        assertEquals(TestConstants.time, events[0].metadata.time)
         assertEquals(User("acidburn", "libby", "root.localhost"), events[0].user)
         assertEquals("#crashandburn", events[0].channel)
         assertEquals("Hack the planet!", events[0].reason)

src/test/kotlin/com/dmdirc/ktirc/messages/PrivmsgProcessorTest.kt

         assertEquals(1, events.size)
 
         val event = events[0] as MessageReceived
-        assertEquals(TestConstants.time, event.time)
+        assertEquals(TestConstants.time, event.metadata.time)
         assertEquals(User("acidburn", "libby", "root.localhost"), event.user)
         assertEquals("#crashandburn", event.target)
         assertEquals("hack the planet!", event.message)
         assertEquals(1, events.size)
 
         val event = events[0] as MessageReceived
-        assertEquals(TestConstants.time, event.time)
+        assertEquals(TestConstants.time, event.metadata.time)
         assertEquals(User("acidburn", "libby", "root.localhost"), event.user)
         assertEquals("#crashandburn", event.target)
         assertEquals("hack the planet!", event.message)
         assertEquals(1, events.size)
 
         val event = events[0] as ActionReceived
-        assertEquals(TestConstants.time, event.time)
+        assertEquals(TestConstants.time, event.metadata.time)
         assertEquals(User("acidburn", "libby", "root.localhost"), event.user)
         assertEquals("#crashandburn", event.target)
         assertEquals("hacks the planet", event.action)
         assertEquals(1, events.size)
 
         val event = events[0] as ActionReceived
-        assertEquals(TestConstants.time, event.time)
+        assertEquals(TestConstants.time, event.metadata.time)
         assertEquals(User("acidburn", "libby", "root.localhost"), event.user)
         assertEquals("#crashandburn", event.target)
         assertEquals("hacks the planet", event.action)
         assertEquals(1, events.size)
 
         val event = events[0] as ActionReceived
-        assertEquals(TestConstants.time, event.time)
+        assertEquals(TestConstants.time, event.metadata.time)
         assertEquals(User("acidburn", "libby", "root.localhost"), event.user)
         assertEquals("#crashandburn", event.target)
         assertEquals("", event.action)
         assertEquals(1, events.size)
 
         val event = events[0] as ActionReceived
-        assertEquals(TestConstants.time, event.time)
+        assertEquals(TestConstants.time, event.metadata.time)
         assertEquals(User("acidburn", "libby", "root.localhost"), event.user)
         assertEquals("#crashandburn", event.target)
         assertEquals("hacks the planet", event.action)
         assertEquals(1, events.size)
 
         val event = events[0] as CtcpReceived
-        assertEquals(TestConstants.time, event.time)
+        assertEquals(TestConstants.time, event.metadata.time)
         assertEquals(User("acidburn", "libby", "root.localhost"), event.user)
         assertEquals("#crashandburn", event.target)
         assertEquals("PING", event.type)
         assertEquals(1, events.size)
 
         val event = events[0] as CtcpReceived
-        assertEquals(TestConstants.time, event.time)
+        assertEquals(TestConstants.time, event.metadata.time)
         assertEquals(User("acidburn", "libby", "root.localhost"), event.user)
         assertEquals("#crashandburn", event.target)
         assertEquals("PING", event.type)

src/test/kotlin/com/dmdirc/ktirc/messages/QuitProcessorTest.kt

                 IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "QUIT", emptyList()))
         assertEquals(1, events.size)
 
-        assertEquals(TestConstants.time, events[0].time)
+        assertEquals(TestConstants.time, events[0].metadata.time)
         assertEquals(User("acidburn", "libby", "root.localhost"), events[0].user)
         assertEquals("", events[0].reason)
     }
                 IrcMessage(emptyMap(), "acidburn!libby@root.localhost".toByteArray(), "QUIT", params("Hack the planet!")))
         assertEquals(1, events.size)
 
-        assertEquals(TestConstants.time, events[0].time)
+        assertEquals(TestConstants.time, events[0].metadata.time)
         assertEquals(User("acidburn", "libby", "root.localhost"), events[0].user)
         assertEquals("Hack the planet!", events[0].reason)
     }

src/test/kotlin/com/dmdirc/ktirc/messages/TopicProcessorTest.kt

         assertEquals(1, events.size)
 
         val event = events[0] as ChannelTopicDiscovered
-        assertEquals(TestConstants.time, event.time)
+        assertEquals(TestConstants.time, event.metadata.time)
         assertEquals("#thegibson", event.channel)
         assertEquals("Hack the planet!", event.topic)
     }
         assertEquals(1, events.size)
 
         val event = events[0] as ChannelTopicDiscovered
-        assertEquals(TestConstants.time, event.time)
+        assertEquals(TestConstants.time, event.metadata.time)
         assertEquals("#thegibson", event.channel)
         assertNull(event.topic)
     }
         assertEquals(1, events.size)
 
         val event = events[0] as ChannelTopicMetadataDiscovered
-        assertEquals(TestConstants.time, event.time)
+        assertEquals(TestConstants.time, event.metadata.time)
         assertEquals("#thegibson", event.channel)
         assertEquals("zeroCool", event.user.nickname)
         assertEquals(TestConstants.otherTime, event.setTime)
         assertEquals(1, events.size)
 
         val event = events[0] as ChannelTopicChanged
-        assertEquals(TestConstants.time, event.time)
+        assertEquals(TestConstants.time, event.metadata.time)
         assertEquals(User("acidBurn", "acidB", "the.gibson"), event.user)
         assertEquals("#thegibson", event.channel)
         assertEquals("Hack the planet!", event.topic)

src/test/kotlin/com/dmdirc/ktirc/messages/WelcomeProcessorTest.kt

         val events = processor.process(IrcMessage(emptyMap(), "thegibson.com".toByteArray(), "001", params(
                 "acidBurn", "Welcome to the Internet Relay Network, acidBurn!burn@hacktheplanet.com")))
         assertEquals(1, events.size)
-        assertEquals(TestConstants.time, events[0].time)
+        assertEquals(TestConstants.time, events[0].metadata.time)
         assertEquals("acidBurn", events[0].localNick)
         assertEquals("thegibson.com", events[0].server)
     }

src/test/kotlin/com/dmdirc/ktirc/model/IrcMessageTest.kt

     fun `Gets UTC time from ServerTime tag if present`() {
         currentTimeZoneProvider = { ZoneId.of("Z") }
         val message = IrcMessage(hashMapOf(MessageTag.ServerTime to "1995-09-15T09:00:00.0000Z"), null, "", emptyList())
-        assertEquals(LocalDateTime.parse("1995-09-15T09:00:00"), message.time)
+        assertEquals(LocalDateTime.parse("1995-09-15T09:00:00"), message.metadata.time)
     }
 
     @Test
     fun `Converts time in ServerTime tag to local timezone`() {
         currentTimeZoneProvider = { ZoneId.of("America/New_York") }
         val message = IrcMessage(hashMapOf(MessageTag.ServerTime to "1995-09-15T09:00:00.0000Z"), null, "", emptyList())
-        assertEquals(LocalDateTime.parse("1995-09-15T05:00:00"), message.time)
+        assertEquals(LocalDateTime.parse("1995-09-15T05:00:00"), message.metadata.time)
     }
 
     @Test
     fun `Uses current local time if no tag present`() {
         currentTimeProvider = { TestConstants.time }
         val message = IrcMessage(emptyMap(), null, "", emptyList())
-        assertEquals(LocalDateTime.parse("1995-09-15T09:00:00"), message.time)
+        assertEquals(LocalDateTime.parse("1995-09-15T09:00:00"), message.metadata.time)
+    }
+
+    @Test
+    fun `populates batch field if present`() {
+        currentTimeProvider = { TestConstants.time }
+        val message = IrcMessage(hashMapOf(MessageTag.Batch to "abc123"), null, "", emptyList())
+        assertEquals("abc123", message.metadata.batchId)
     }
 
     @Test