fix(events): bound LID mention resolution with a timeout and avoid mention-text collisions

A hanging lid->pn resolver no longer swallows the message: resolution is
capped at 3s and the message emits with the raw LID on timeout or failure.
Inline @Number rewrites now apply longest-first to avoid substring clashes.

Author: zeative

src/events/decoders/messages.ts

@@ -531,14 +531,14 @@ const mapMentions = (jids: string[], ctx: DecodeContext): string[] =>
 
 const userPart = (jid: string): string => (jid.split('@')[0] ?? '').split(':')[0] ?? ''
 
-const syncMentionText =(text: string, map: Map<string, string> | undefined): string => {
+const syncMentionText = (text: string, map: Map<string, string> | undefined): string => {
   if (map == null || map.size === 0 || text.length === 0) return text
+  const pairs = [...map]
+    .map(([lid, pn]) => [userPart(lid), userPart(pn)] as const)
+    .filter(([from, to]) => from.length > 0 && to.length > 0 && from !== to)
+    .sort((a, b) => b[0].length - a[0].length)
   let out = text
-  for (const [lid, pn] of map) {
-    const from = userPart(lid)
-    const to = userPart(pn)
-    if (from.length > 0 && to.length > 0 && from !== to) out = out.split(`@${from}`).join(`@${to}`)
-  }
+  for (const [from, to] of pairs) out = out.split(`@${from}`).join(`@${to}`)
   return out
 }
 

src/events/pipeline.ts

@@ -91,6 +91,17 @@ type ClientEmitter = TypedEventEmitter<ClientEventMap>
 
 const asArray = <T>(value: unknown): T[] => (Array.isArray(value) ? (value as T[]) : [])
 
+const MENTION_RESOLVE_TIMEOUT_MS = 3000
+
+const raceTimeout = <T>(p: Promise<T>, ms: number): Promise<T | null> =>
+  new Promise<T | null>((resolve) => {
+    const timer = setTimeout(() => resolve(null), ms)
+    p.then(
+      (v) => { clearTimeout(timer); resolve(v) },
+      () => { clearTimeout(timer); resolve(null) },
+    )
+  })
+
 const connectionReachout = (update: unknown): RawReachoutTimelock | null => {
   if (update == null || typeof update !== 'object') return null
   const lock = (update as { reachoutTimeLock?: unknown }).reachoutTimeLock
@@ -171,7 +182,7 @@ export function attachInboundPipeline(
     await Promise.all(
       lids.map(async (lid) => {
         try {
-          const pn = await resolve(lid)
+          const pn = await raceTimeout(Promise.resolve(resolve(lid)), MENTION_RESOLVE_TIMEOUT_MS)
           if (pn != null && pn.length > 0) map.set(lid, pn)
         } catch (err) {
           ctx.logger?.warn(err, 'inbound pipeline: lid->pn resolve threw')
@@ -203,9 +214,14 @@ export function attachInboundPipeline(
         runMessage(msg, decodeCtx)
         continue
       }
-      void buildMentionMap(msg).then((mentionMap) =>
-        runMessage(msg, mentionMap != null ? { ...decodeCtx, mentionMap } : decodeCtx),
-      )
+      void buildMentionMap(msg)
+        .then((mentionMap) =>
+          runMessage(msg, mentionMap != null ? { ...decodeCtx, mentionMap } : decodeCtx),
+        )
+        .catch((err) => {
+          ctx.logger?.warn(err, 'inbound pipeline: deferred mention emit failed')
+          runMessage(msg, decodeCtx)
+        })
     }
   })
 

tests/events/pipeline.test.ts

@@ -124,6 +124,35 @@ describe('attachInboundPipeline — messages.upsert', () => {
     expect(ctx.text).toBe('hey @628999')
   })
 
+  it('still emits the message when the LID resolver hangs (timeout fallback)', async () => {
+    vi.useFakeTimers()
+    try {
+      const client = new TypedEventEmitter<ClientEventMap>()
+      const socket = makeInboundSocket({ user: { id: SELF } })
+      attachInboundPipeline(
+        client,
+        socket as unknown as Parameters<typeof attachInboundPipeline>[1],
+        { selfJid: SELF, resolveLidToPn: () => new Promise<string | null>(() => {}) },
+      )
+      const seen = vi.fn()
+      client.on('text', seen)
+      socket.triggerMessagesUpsert({
+        messages: [
+          textMsg('hi @66554863583429', {
+            message: { extendedTextMessage: { text: 'hi @66554863583429', contextInfo: { mentionedJid: ['66554863583429@lid'] } } },
+          }),
+        ],
+        type: 'notify',
+      })
+      expect(seen).not.toHaveBeenCalled()
+      await vi.advanceTimersByTimeAsync(3001)
+      expect(seen).toHaveBeenCalledTimes(1)
+      expect(seen.mock.calls[0]?.[0].mentions).toEqual(['66554863583429@lid'])
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
   it('keeps unmapped LID mentions (best-effort) and stays sync without a resolver', () => {
     const { client, socket } = setup()
     const seen = vi.fn()