feat(events): add staticId, longer uppercase ids, mention LID->PN resolution, robust timestamps

uniqueId is now a 16-char uppercase hex; add staticId (stable hash of
roomId+senderId). Resolve @lid mentions to PN via the lid mapping, normalize
device suffixes, and rewrite inline @numbers in text to match. Parse
messageTimestamp from number/string/Long/{low,high} so stored quoted messages
keep their real time.

Author: zeative

src/client/client.ts

@@ -710,6 +710,7 @@ export class Client extends TypedEventEmitter<ClientEventMap> {
         groupMetadata: (groupId) => this.group.metadata(groupId).catch(() => null),
         receiverName: () => Promise.resolve(this.resolveMe().name ?? null),
         resolveQuoted: (id, remoteJid) => this.lookupQuoted(id, remoteJid),
+        resolveLidToPn: (lid) => this.lidToPn(lid),
         sendReply: async (target, content, opts, quoted) =>
           await this.send(target).text(content, opts).reply(quoted),
         react: (key, emoji) => this.react(key, emoji),
@@ -736,6 +737,17 @@ export class Client extends TypedEventEmitter<ClientEventMap> {
     }
   }
 
+  private async lidToPn(lid: string): Promise<string | null> {
+    try {
+      const repo = (this._socket as { signalRepository?: { lidMapping?: { getPNForLID?: (l: string) => Promise<string | null> } } } | undefined)?.signalRepository
+      const mapping = repo?.lidMapping
+      if (mapping == null || typeof mapping.getPNForLID !== 'function') return null
+      return await mapping.getPNForLID(lid)
+    } catch {
+      return null
+    }
+  }
+
   private async lookupQuoted(id: string, remoteJid: string): Promise<WAMessage | null> {
     for (const fromMe of [false, true]) {
       try {

src/events/context.ts

@@ -143,6 +143,7 @@ export type ContextMedia =
 
 export interface MessageContext {
   uniqueId: string
+  staticId: string
   channelId: string
   chatId: string
   chatType: ChatType
@@ -228,14 +229,37 @@ export const extractLinks = (text: string): string[] => {
   return matches.map((url) => url.replace(/[.,;:!?]+$/, ''))
 }
 
-export const computeUniqueId = (key: WAMessageKey): string => {
-  const input = `${key.remoteJid ?? ''}|${key.id ?? ''}|${key.fromMe === true ? '1' : '0'}`
-  let hash = 0x811c9dc5
+const fnv1a = (input: string, seed = 0x811c9dc5): number => {
+  let hash = seed >>> 0
   for (let i = 0; i < input.length; i++) {
     hash ^= input.charCodeAt(i)
-    hash = (Math.imul(hash, 0x01000193) >>> 0)
+    hash = Math.imul(hash, 0x01000193) >>> 0
   }
-  return hash.toString(16).padStart(8, '0')
+  return hash >>> 0
+}
+
+const hashHex = (input: string): string =>
+  (fnv1a(input).toString(16).padStart(8, '0') + fnv1a(input, 0x9dc5811c).toString(16).padStart(8, '0')).toUpperCase()
+
+export const computeUniqueId = (key: WAMessageKey): string =>
+  hashHex(`${key.remoteJid ?? ''}|${key.id ?? ''}|${key.fromMe === true ? '1' : '0'}`)
+
+export const computeStaticId = (roomId: string | null, senderId: string): string =>
+  hashHex(`${roomId ?? ''}|${senderId}`)
+
+export const epochSecondsToMs = (value: unknown): number => {
+  let secs: number | null = null
+  if (typeof value === 'number') secs = value
+  else if (typeof value === 'bigint') secs = Number(value)
+  else if (typeof value === 'string') {
+    const n = Number.parseInt(value, 10)
+    secs = Number.isFinite(n) ? n : null
+  } else if (value != null && typeof value === 'object') {
+    const o = value as { toNumber?: () => number; low?: number; high?: number }
+    if (typeof o.toNumber === 'function') secs = o.toNumber()
+    else if (typeof o.low === 'number') secs = (typeof o.high === 'number' ? o.high : 0) * 4294967296 + (o.low >>> 0)
+  }
+  return secs != null && Number.isFinite(secs) && secs > 0 ? secs * 1000 : 0
 }
 
 export const senderDeviceOf = (jid: string): SenderDevice => {
@@ -293,25 +317,26 @@ export const makeCitation = (
 export const buildMessageContext = (input: BuildContextInput): MessageContext => {
   const remoteJid = typeof input.key.remoteJid === 'string' ? input.key.remoteJid : null
   const isGroup = remoteJid !== null && isGroupJid(remoteJid)
+  const senderId = input.sender.pn ?? input.sender.jid
+  const roomId = isGroup
+    ? (remoteJid ? jidNormalizedUser(remoteJid) : null)
+    : input.key.fromMe === true && remoteJid
+      ? jidNormalizedUser(remoteJid)
+      : senderId
 
   const ctx: MessageContext = {
     uniqueId: computeUniqueId(input.key),
+    staticId: computeStaticId(roomId, senderId),
     channelId: input.channelId,
     chatId: input.key.id ?? '',
     chatType: input.chatType,
     receiverId: input.receiverId ? jidNormalizedUser(input.receiverId) : input.receiverId,
-    roomId: isGroup
-      ? (remoteJid ? jidNormalizedUser(remoteJid) : null)
-      : input.key.fromMe === true && remoteJid
-        ? jidNormalizedUser(remoteJid)
-        : (input.sender.pn ?? input.sender.jid),
-    senderId: input.sender.pn ?? input.sender.jid,
+    roomId,
+    senderId,
     senderLid: input.sender.lid ?? null,
     senderName: input.sender.pushName ?? null,
     senderDevice: senderDeviceOf(input.sender.jid),
-    timestamp: typeof input.message.messageTimestamp === 'number'
-      ? input.message.messageTimestamp * 1000
-      : 0,
+    timestamp: epochSecondsToMs(input.message.messageTimestamp),
     text: input.text,
     mentions: input.mentions,
     links: extractLinks(input.text),

src/events/decoders/messages.ts

@@ -24,6 +24,7 @@ export interface DecodeContext {
   selfJid: string
   selfLid?: string
   selfName?: string
+  mentionMap?: Map<string, string>
   logger?: DownloadLogger
   channelId?: string
   receiverId?: string
@@ -514,6 +515,33 @@ const decodeQuotedContext = async (
   }
 }
 
+export const rawMentionsOf = (msg: WAMessage): string[] =>
+  extractMentions(contextInfoOf(msg)).mentionedJids
+
+const normalizeJid = (jid: string): string => {
+  try {
+    return jidNormalizedUser(jid)
+  } catch {
+    return jid
+  }
+}
+
+const mapMentions = (jids: string[], ctx: DecodeContext): string[] =>
+  jids.map((j) => normalizeJid(ctx.mentionMap?.get(j) ?? j))
+
+const userPart = (jid: string): string => (jid.split('@')[0] ?? '').split(':')[0] ?? ''
+
+const syncMentionText =(text: string, map: Map<string, string> | undefined): string => {
+  if (map == null || map.size === 0 || text.length === 0) return text
+  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}`)
+  }
+  return out
+}
+
 const buildContext = (
   msg: WAMessage,
   ctx: DecodeContext,
@@ -567,15 +595,16 @@ const buildContext = (
     return ctx.react(key, emoji)
   }
 
-  const { mentionedJids } = extractMentions(contextInfo)
+  const mentionedJids = mapMentions(extractMentions(contextInfo).mentionedJids, ctx)
+  const syncedText = syncMentionText(text, ctx.mentionMap)
 
   const baseInput = {
     message: msg,
     key,
     channelId,
     receiverId,
     selfJid: ctx.selfJid,
-    text,
+    text: syncedText,
     chatType,
     sender,
     mentions: mentionedJids,
@@ -689,9 +718,12 @@ export const decodeMention = (msg: WAMessage, ctx: DecodeContext): MentionContex
   const key = msg.key
   if (key == null) return null
   const contextInfo = contextInfoOf(msg)
-  const { mentionedJids } = extractMentions(contextInfo)
-  if (mentionedJids.length === 0) return null
-  const hasSelf = mentionedJids.some((jid) => normalizedEquals(jid, ctx.selfJid))
+  const rawMentions = extractMentions(contextInfo).mentionedJids
+  if (rawMentions.length === 0) return null
+  const mentionedJids = mapMentions(rawMentions, ctx)
+  const hasSelf =
+    mentionedJids.some((jid) => normalizedEquals(jid, ctx.selfJid)) ||
+    (ctx.selfLid != null && rawMentions.some((jid) => normalizedEquals(jid, ctx.selfLid as string)))
   if (!hasSelf) return null
   const content = asRecord(msg.message)
   if (content == null) return null

src/events/pipeline.ts

@@ -42,8 +42,10 @@ import {
   decodeSticker,
   decodeText,
   decodeVideo,
+  rawMentionsOf,
   type DecodeContext,
 } from './decoders/messages.js'
+import { isLidJid } from './decoders/_shared.js'
 import {
   decodeDelete,
   decodeEdit,
@@ -70,6 +72,7 @@ export interface InboundPipelineContext {
   groupMetadata?: (groupId: string) => Promise<{ subject?: string } | null>
   receiverName?: () => Promise<string | null>
   resolveQuoted?: (id: string, remoteJid: string) => Promise<WAMessage | null>
+  resolveLidToPn?: (lid: string) => Promise<string | null>
   sendReply?: (target: string, content: string, opts: TextOptions | undefined, quoted: WAMessage) => Promise<WAMessageKey>
   react?: (key: WAMessageKey, emoji: string) => Promise<WAMessageKey>
   ignoreMe?: boolean
@@ -145,20 +148,39 @@ export function attachInboundPipeline(
     cleanups.push(() => socket.ev.off(event, wrapped))
   }
 
-  const runMessage = (msg: WAMessage): void => {
-    tryEmit(() => decodeMessage(msg, decodeCtx), (p) => client.emit('message', p))
-    tryEmit(() => decodeText(msg, decodeCtx), (p) => client.emit('text', p))
-    tryEmit(() => decodeImage(msg, decodeCtx), (p) => client.emit('image', p))
-    tryEmit(() => decodeVideo(msg, decodeCtx), (p) => client.emit('video', p))
-    tryEmit(() => decodeAudio(msg, decodeCtx), (p) => client.emit('audio', p))
-    tryEmit(() => decodeDocument(msg, decodeCtx), (p) => client.emit('document', p))
-    tryEmit(() => decodeSticker(msg, decodeCtx), (p) => client.emit('sticker', p))
-    tryEmit(() => decodeMention(msg, decodeCtx), (p) => client.emit('mention', p))
-    tryEmit(() => decodeMentionAll(msg, decodeCtx), (p) => client.emit('mention-all', p))
+  const runMessage = (msg: WAMessage, msgCtx: DecodeContext): void => {
+    tryEmit(() => decodeMessage(msg, msgCtx), (p) => client.emit('message', p))
+    tryEmit(() => decodeText(msg, msgCtx), (p) => client.emit('text', p))
+    tryEmit(() => decodeImage(msg, msgCtx), (p) => client.emit('image', p))
+    tryEmit(() => decodeVideo(msg, msgCtx), (p) => client.emit('video', p))
+    tryEmit(() => decodeAudio(msg, msgCtx), (p) => client.emit('audio', p))
+    tryEmit(() => decodeDocument(msg, msgCtx), (p) => client.emit('document', p))
+    tryEmit(() => decodeSticker(msg, msgCtx), (p) => client.emit('sticker', p))
+    tryEmit(() => decodeMention(msg, msgCtx), (p) => client.emit('mention', p))
+    tryEmit(() => decodeMentionAll(msg, msgCtx), (p) => client.emit('mention-all', p))
     tryEmit(() => decodeButtonClick(msg, interactiveCtx), (p) => client.emit('button-click', p))
     tryEmit(() => decodeListSelect(msg, interactiveCtx), (p) => client.emit('list-select', p))
   }
 
+  const buildMentionMap = async (msg: WAMessage): Promise<Map<string, string> | undefined> => {
+    const resolve = ctx.resolveLidToPn
+    if (resolve == null) return undefined
+    const lids = [...new Set(rawMentionsOf(msg).filter(isLidJid))]
+    if (lids.length === 0) return undefined
+    const map = new Map<string, string>()
+    await Promise.all(
+      lids.map(async (lid) => {
+        try {
+          const pn = await resolve(lid)
+          if (pn != null && pn.length > 0) map.set(lid, pn)
+        } catch (err) {
+          ctx.logger?.warn(err, 'inbound pipeline: lid->pn resolve threw')
+        }
+      }),
+    )
+    return map.size > 0 ? map : undefined
+  }
+
   const tryEmit = <T>(decode: () => T | null, emit: (payload: T) => void): void => {
     let payload: T | null
     try {
@@ -175,7 +197,15 @@ export function attachInboundPipeline(
     const upsert = dropSpoofedSelfOnly(raw as UpsertPayload)
     for (const msg of upsert.messages) {
       if (ctx.ignoreMe === true && msg.key?.fromMe === true) continue
-      runMessage(msg)
+      const needsResolve =
+        ctx.resolveLidToPn != null && rawMentionsOf(msg).some(isLidJid)
+      if (!needsResolve) {
+        runMessage(msg, decodeCtx)
+        continue
+      }
+      void buildMentionMap(msg).then((mentionMap) =>
+        runMessage(msg, mentionMap != null ? { ...decodeCtx, mentionMap } : decodeCtx),
+      )
     }
   })
 

tests/events/context.test.ts

@@ -8,6 +8,8 @@ vi.mock('baileys', async (importOriginal) => {
 const {
   extractLinks,
   computeUniqueId,
+  computeStaticId,
+  epochSecondsToMs,
   isQuestionOf,
   isPrefixOf,
   isTagMeOf,
@@ -63,14 +65,54 @@ describe('computeUniqueId', () => {
 
   it('returns a non-empty hex string', () => {
     const id = computeUniqueId({ remoteJid: 'r', id: 'i', fromMe: false })
-    expect(id).toMatch(/^[0-9a-f]+$/)
+    expect(id).toMatch(/^[0-9A-F]+$/)
     expect(id.length).toBeGreaterThan(0)
   })
 
   it('handles undefined key fields gracefully', () => {
     const id = computeUniqueId({ remoteJid: undefined, id: undefined, fromMe: undefined })
     expect(typeof id).toBe('string')
   })
+
+  it('emits a 16-char hex id', () => {
+    expect(computeUniqueId({ remoteJid: 'r', id: 'i', fromMe: false })).toMatch(/^[0-9A-F]{16}$/)
+  })
+})
+
+describe('computeStaticId', () => {
+  it('is stable for the same room+sender pair regardless of message', () => {
+    const a = computeStaticId('628room@s.whatsapp.net', '628me@s.whatsapp.net')
+    const b = computeStaticId('628room@s.whatsapp.net', '628me@s.whatsapp.net')
+    expect(a).toBe(b)
+    expect(a).toMatch(/^[0-9A-F]{16}$/)
+  })
+
+  it('differs when room or sender differs', () => {
+    const base = computeStaticId('room@g.us', 'a@s.whatsapp.net')
+    expect(base).not.toBe(computeStaticId('room@g.us', 'b@s.whatsapp.net'))
+    expect(base).not.toBe(computeStaticId('other@g.us', 'a@s.whatsapp.net'))
+  })
+})
+
+describe('epochSecondsToMs', () => {
+  const SECS = 1782132231
+  it('converts a number (seconds) to ms', () => {
+    expect(epochSecondsToMs(SECS)).toBe(SECS * 1000)
+  })
+  it('parses string seconds', () => {
+    expect(epochSecondsToMs(String(SECS))).toBe(SECS * 1000)
+  })
+  it('handles Long-like with toNumber', () => {
+    expect(epochSecondsToMs({ toNumber: () => SECS })).toBe(SECS * 1000)
+  })
+  it('handles serialized Long {low, high}', () => {
+    expect(epochSecondsToMs({ low: SECS, high: 0 })).toBe(SECS * 1000)
+  })
+  it('returns 0 for missing/invalid', () => {
+    expect(epochSecondsToMs(undefined)).toBe(0)
+    expect(epochSecondsToMs(0)).toBe(0)
+    expect(epochSecondsToMs('nope')).toBe(0)
+  })
 })
 
 describe('isQuestionOf', () => {

tests/events/pipeline.test.ts

@@ -95,6 +95,51 @@ describe('attachInboundPipeline — messages.upsert', () => {
     expect(seen).not.toHaveBeenCalled()
   })
 
+  it('resolves LID mentions to PN via resolveLidToPn', async () => {
+    const client = new TypedEventEmitter<ClientEventMap>()
+    const socket = makeInboundSocket({ user: { id: SELF } })
+    attachInboundPipeline(
+      client,
+      socket as unknown as Parameters<typeof attachInboundPipeline>[1],
+      {
+        selfJid: SELF,
+        resolveLidToPn: async (lid) =>
+          lid === '66554863583429@lid' ? '628999:0@s.whatsapp.net' : null,
+      },
+    )
+    const seen = vi.fn()
+    client.on('text', seen)
+    socket.triggerMessagesUpsert({
+      messages: [
+        textMsg('hey @66554863583429', {
+          message: { extendedTextMessage: { text: 'hey @66554863583429', contextInfo: { mentionedJid: ['66554863583429@lid'] } } },
+        }),
+      ],
+      type: 'notify',
+    })
+    await new Promise((r) => setTimeout(r, 0))
+    expect(seen).toHaveBeenCalledTimes(1)
+    const ctx = seen.mock.calls[0]?.[0]
+    expect(ctx.mentions).toEqual(['628999@s.whatsapp.net'])
+    expect(ctx.text).toBe('hey @628999')
+  })
+
+  it('keeps unmapped LID mentions (best-effort) and stays sync without a resolver', () => {
+    const { client, socket } = setup()
+    const seen = vi.fn()
+    client.on('text', seen)
+    socket.triggerMessagesUpsert({
+      messages: [
+        textMsg('@x', {
+          message: { extendedTextMessage: { text: '@x', contextInfo: { mentionedJid: ['66554863583429@lid'] } } },
+        }),
+      ],
+      type: 'notify',
+    })
+    expect(seen).toHaveBeenCalledTimes(1)
+    expect(seen.mock.calls[0]?.[0].mentions).toEqual(['66554863583429@lid'])
+  })
+
   it('emits both text and mention when self mentioned (multi-decoder)', () => {
     const { client, socket } = setup()
     const text = vi.fn()