connector: implement user cache

* Fixes the totally broken UserInfo resolution in guilds.
* Adds support for USER_UPDATE from the gateway.

Design considerations behind the user cache:

* Explicitly handle deleted user IDs by short circuiting the lookup
  logic and returning a singleton.
* The cache map is protected during HTTP requests to the Discord API.
* The nonexistence of a user is cached. This is to prevent excessive
  requests (a user can't suddenly begin existing at a given ID).

The user cache is upserted on READY, incoming messages, backfill, etc.

pkg/connector/usercache.go

@@ -0,0 +1,161 @@
+// mautrix-discord - A Matrix-Discord puppeting bridge.
+// Copyright (C) 2026 Tulir Asokan
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+package connector
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"sync"
+
+	"github.com/bwmarrin/discordgo"
+	"github.com/rs/zerolog"
+	"go.mau.fi/mautrix-discord/pkg/discordid"
+)
+
+// NOTE: Not simply using `exsync.Map` because we want the lock to be held
+// during HTTP requests.
+
+type UserCache struct {
+	session *discordgo.Session
+	cache   map[string]*discordgo.User
+	lock    sync.Mutex
+}
+
+func NewUserCache(session *discordgo.Session) *UserCache {
+	return &UserCache{
+		session: session,
+		cache:   make(map[string]*discordgo.User),
+	}
+}
+
+func (uc *UserCache) HandleReady(ready *discordgo.Ready) {
+	if ready == nil {
+		return
+	}
+
+	uc.lock.Lock()
+	defer uc.lock.Unlock()
+
+	for _, user := range ready.Users {
+		uc.cache[user.ID] = user
+	}
+}
+
+func (uc *UserCache) HandleMessage(msg *discordgo.Message) {
+	if msg == nil {
+		return
+	}
+
+	// For now just forward to HandleMessages until a need for a specialized
+	// path makes itself known.
+	uc.HandleMessages([]*discordgo.Message{msg})
+}
+
+// HandleMessages updates the user cache with message authors from a slice of
+// discordgo.Message.
+func (uc *UserCache) HandleMessages(msgs []*discordgo.Message) {
+	if len(msgs) == 0 {
+		return
+	}
+
+	collectedUsers := map[string]*discordgo.User{}
+	for _, msg := range msgs {
+		collectedUsers[msg.Author.ID] = msg.Author
+
+		referenced := msg.ReferencedMessage
+		if referenced != nil && referenced.Author != nil {
+			collectedUsers[referenced.Author.ID] = referenced.Author
+		}
+
+		for _, mentioned := range msg.Mentions {
+			collectedUsers[mentioned.ID] = mentioned
+		}
+
+		// Message snapshots lack `author` entirely and seemingly have an empty
+		// `mentions` array, even when the original message actually mentions
+		// someone.
+	}
+
+	uc.lock.Lock()
+	defer uc.lock.Unlock()
+
+	for _, user := range collectedUsers {
+		uc.cache[user.ID] = user
+	}
+}
+
+func (uc *UserCache) HandleUserUpdate(update *discordgo.UserUpdate) {
+	if update == nil || update.User == nil {
+		return
+	}
+
+	uc.lock.Lock()
+	defer uc.lock.Unlock()
+
+	uc.cache[update.ID] = update.User
+}
+
+// Resolve looks up a user in the cache, requesting the user from the Discord
+// HTTP API if not present.
+//
+// If the user cannot be found, then its nonexistence is cached. This is to
+// avoid excessive requests when e.g. backfilling messages from a user that has
+// since been deleted since connecting. If some other error occurs, the cache
+// isn't touched and nil is returned.
+//
+// Otherwise, the cache is updated as you'd expect.
+func (uc *UserCache) Resolve(ctx context.Context, userID string) *discordgo.User {
+	if userID == discordid.DeletedGuildUserID {
+		return &discordid.DeletedGuildUser
+	}
+
+	// Hopefully this isn't too contentious?
+	uc.lock.Lock()
+	defer uc.lock.Unlock()
+
+	cachedUser, present := uc.cache[userID]
+	if cachedUser != nil {
+		return cachedUser
+	} else if present {
+		// If a `nil` is present in the map, then we already know that the user
+		// doesn't exist.
+		return nil
+	}
+
+	log := zerolog.Ctx(ctx).With().
+		Str("action", "resolve user").
+		Str("user_id", userID).Logger()
+
+	log.Trace().Msg("Fetching user")
+	user, err := uc.session.User(userID)
+
+	var restError *discordgo.RESTError
+	if errors.As(err, &restError) && restError.Response.StatusCode == http.StatusNotFound {
+		log.Info().Msg("Tried to resolve a user that doesn't exist, caching nonexistence")
+		uc.cache[userID] = nil
+
+		return nil
+	} else if err != nil {
+		log.Err(err).Msg("Failed to resolve user")
+		return nil
+	}
+
+	uc.cache[userID] = user
+
+	return user
+}