@palbase/web 1.4.0 → 1.5.0

package/dist/next/client.js

@@ -7,7 +7,7 @@ import {
   __configure,
   endpointRefFromApiKey,
   getRuntime
-} from "../chunk-3EVGYJ5F.js";
+} from "../chunk-MBA2NAKS.js";
 
 // src/next/client.ts
 var SESSION_MAX_AGE_S = 2592e3;

package/dist/next/index.cjs

@@ -2736,7 +2736,8 @@ var EditFold = class {
       orderEpoch: e.epoch,
       orderSeq: e.serverSeq,
       lastEventId: e.eventClientMsgId,
-      text: e.newText
+      text: e.newText,
+      bodyRanges: e.bodyRanges ?? null
     });
     this.editedTargets.add(e.targetClientMsgId);
   }
@@ -2757,6 +2758,15 @@ var EditFold = class {
   isEdited(targetClientMsgId) {
     return this.editedTargets.has(targetClientMsgId);
   }
+  /**
+   * The WINNING edit's replacement mention ranges for a target (raw, un-normalized),
+   * or null when no valid edit applied or the winning edit carried none. The Chat
+   * normalizes these against the edited text to compute the edited message's mentions
+   * (mentions T6). LWW-consistent: always the same edit that `text(...)` returns.
+   */
+  bodyRanges(targetClientMsgId) {
+    return this.states.get(targetClientMsgId)?.bodyRanges ?? null;
+  }
   /**
    * Re-run HELD edits when the roster/target newly resolves (call on member/roster
    * change and when a target message arrives). Clears `held` and re-ingests each
@@ -2930,7 +2940,14 @@ function encodeEdit(args) {
       type: "edit",
       client_msg_id: args.clientMsgId,
       target_client_msg_id: args.targetClientMsgId,
-      new_text: args.newText
+      new_text: args.newText,
+      ...args.bodyRanges && args.bodyRanges.length > 0 ? {
+        body_ranges: args.bodyRanges.map((r) => ({
+          start: r.start,
+          length: r.length,
+          mentioned_user_id: r.mentionedUserId
+        }))
+      } : {}
     })
   );
 }
@@ -2952,7 +2969,14 @@ function encodeEnvelope(args) {
     type: "text",
     client_msg_id: args.clientMsgId,
     text: args.text,
-    ...args.replyTo ? { reply_to: args.replyTo } : {}
+    ...args.replyTo ? { reply_to: args.replyTo } : {},
+    ...args.bodyRanges && args.bodyRanges.length > 0 ? {
+      body_ranges: args.bodyRanges.map((r) => ({
+        start: r.start,
+        length: r.length,
+        mentioned_user_id: r.mentionedUserId
+      }))
+    } : {}
   };
   return encodeUtf8(JSON.stringify(env));
 }
@@ -2986,6 +3010,7 @@ function decodeEnvelope(bytes) {
       };
     }
     if (typeof o === "object" && o !== null && o.type === "edit") {
+      const editRanges = decodeBodyRanges(o.body_ranges);
       return {
         type: "edit",
         text: null,
@@ -2994,15 +3019,18 @@ function decodeEnvelope(bytes) {
         edit: {
           targetClientMsgId: o.target_client_msg_id ?? "",
           newText: o.new_text ?? ""
-        }
+        },
+        ...editRanges ? { bodyRanges: editRanges } : {}
       };
     }
     if (typeof o === "object" && o !== null && o.type === "text" && typeof o.v === "number") {
+      const textRanges = decodeBodyRanges(o.body_ranges);
       return {
         type: "text",
         text: o.text ?? null,
         clientMsgId: o.client_msg_id ?? "",
-        replyTo: o.reply_to ?? null
+        replyTo: o.reply_to ?? null,
+        ...textRanges ? { bodyRanges: textRanges } : {}
       };
     }
     if (typeof o === "object" && o !== null && o.type === "text") {
@@ -3014,6 +3042,14 @@ function decodeEnvelope(bytes) {
   }
   return { text: s, clientMsgId: "", replyTo: null };
 }
+function decodeBodyRanges(raw) {
+  if (!raw || raw.length === 0) return void 0;
+  return raw.map((r) => ({
+    start: r.start,
+    length: r.length,
+    mentionedUserId: r.mentioned_user_id
+  }));
+}
 function resolveReply(ref, lookup) {
   const parent = lookup(ref.client_msg_id);
   if (parent !== null) {
@@ -3225,9 +3261,9 @@ var GroupMessaging = class {
   /** Send a text message. Encrypt at the current epoch, POST, return the receipt +
    * the client-minted `clientMsgId` (needed by the Chat layer for reply indexing).
    * NEVER rebases (a 422 stale_application surfaces to the caller). */
-  async sendText(group, text, replyTo) {
+  async sendText(group, text, replyTo, bodyRanges) {
     const clientMsgId = mintClientMsgId();
-    const plaintext = encodeEnvelope({ text, clientMsgId, replyTo });
+    const plaintext = encodeEnvelope({ text, clientMsgId, replyTo, bodyRanges });
     const ct = await this.engine.encryptApplication(fromBase64(group.rfcGroupId), plaintext);
     const body = {
       ciphertext_b64: toBase64(ct),
@@ -3253,7 +3289,10 @@ var GroupMessaging = class {
         previewBody: replyTo.preview?.body ?? null,
         previewAuthorUserId: replyTo.preview?.author_user_id ?? null,
         previewKind: replyTo.preview?.kind ?? "text"
-      } : null
+      } : null,
+      // Persist the OUTGOING bubble's mention ranges so an own-sent mention re-resolves
+      // onto its bubble after a reload (own-send reload parity — the T4-reviewer Minor).
+      ...bodyRanges && bodyRanges.length > 0 ? { bodyRanges } : {}
     };
     try {
       await this.messageStore.append(group.rfcGroupId, stored);
@@ -3321,7 +3360,8 @@ var GroupMessaging = class {
     const plaintext = encodeEdit({
       clientMsgId: args.clientMsgId,
       targetClientMsgId: args.targetClientMsgId,
-      newText: args.newText
+      newText: args.newText,
+      bodyRanges: args.bodyRanges
     });
     const ct = await this.engine.encryptApplication(fromBase64(group.rfcGroupId), plaintext);
     const body = {
@@ -3347,7 +3387,10 @@ var GroupMessaging = class {
       envelopeType: "edit",
       edit: {
         targetClientMsgId: args.targetClientMsgId,
-        newText: args.newText
+        newText: args.newText,
+        // Persist the edit's REPLACEMENT ranges so the edited message's mentions
+        // re-resolve from this edit after a reload (own-send reload parity — T6).
+        ...args.bodyRanges && args.bodyRanges.length > 0 ? { bodyRanges: args.bodyRanges } : {}
       }
     };
     try {
@@ -3469,6 +3512,41 @@ var GroupMessaging = class {
   }
 };
 
+// src/messaging/mention-ranges.ts
+function normalizeMentionRangesUtf16(ranges, text) {
+  const n = text.length;
+  function splitsSurrogatePair(index) {
+    if (index <= 0 || index >= n) return false;
+    const before = text.charCodeAt(index - 1);
+    const at = text.charCodeAt(index);
+    const beforeIsHigh = before >= 55296 && before <= 56319;
+    const atIsLow = at >= 56320 && at <= 57343;
+    return beforeIsHigh && atIsLow;
+  }
+  const survivors = [];
+  for (let idx = 0; idx < ranges.length; idx++) {
+    const r = ranges[idx];
+    if (r === void 0) continue;
+    if (r.start < 0 || r.length <= 0 || r.start + r.length > n) continue;
+    if (splitsSurrogatePair(r.start) || splitsSurrogatePair(r.start + r.length)) continue;
+    survivors.push({ idx, range: r });
+  }
+  survivors.sort((lhs, rhs) => {
+    if (lhs.range.start !== rhs.range.start) return lhs.range.start - rhs.range.start;
+    if (lhs.range.length !== rhs.range.length) return rhs.range.length - lhs.range.length;
+    return lhs.idx - rhs.idx;
+  });
+  const kept = [];
+  let prevEnd = Number.NEGATIVE_INFINITY;
+  for (const s of survivors) {
+    if (s.range.start >= prevEnd) {
+      kept.push(s.range);
+      prevEnd = s.range.start + s.range.length;
+    }
+  }
+  return kept;
+}
+
 // src/messaging/reaction-fold.ts
 function orderLte(aEpoch, aSeq, bEpoch, bSeq) {
   if (aEpoch !== bEpoch) return aEpoch < bEpoch;
@@ -3556,6 +3634,13 @@ var Chat = class {
   /** True once the persisted suppression set has been loaded (so the omit applies
    * even on the cold-launch hydrate path before a fresh deleteForMe). */
   suppressedLoaded = false;
+  /** Self-elevation dedup keys (`<selfUserId>|<clientMsgId or seq:n>`). Once a
+   * mention of me from another sender fires `onMentionElevation`, its key lands here
+   * + is persisted, so a re-delivery / cold-launch re-hydrate never re-fires. */
+  elevated = /* @__PURE__ */ new Set();
+  /** True once the persisted elevation set has been loaded (so a re-delivered mention
+   * on the cold-launch hydrate path dedups against the persisted decision). */
+  elevatedLoaded = false;
   /** Per-target BASE (original) text, so the rendered text is `edit ?? original`.
    * Seeded once per target (write-once base) so a 2nd own edit can't corrupt it. */
   originalTextByClientMsgId = /* @__PURE__ */ new Map();
@@ -3567,6 +3652,14 @@ var Chat = class {
   wired = false;
   liveUnsub = null;
   listeners = /* @__PURE__ */ new Set();
+  /**
+   * Fires ONCE per `(selfUserId, clientMsgId)` when an INCOMING message mentions THIS
+   * user from ANOTHER sender (not an edit). The dedup survives re-delivery + reload
+   * via the persisted elevation set, so this never double-fires for one mention. The
+   * app wires it to a buzz/badge (e.g. an in-app banner). Best-effort cooperative —
+   * the SDK guarantees the DECISION, not the buzz. Mirrors iOS `Chat.onMentionElevation`.
+   */
+  onMentionElevation;
   /** @internal — obtain via pb.messaging.directChat / groupChat / chat(id). */
   constructor(args) {
     this.backend = args.backend;
@@ -3644,7 +3737,8 @@ var Chat = class {
           reactions: {},
           replyTo: null,
           edited: false,
-          isDeleted: true
+          isDeleted: true,
+          mentions: []
         });
         continue;
       }
@@ -3680,6 +3774,7 @@ var Chat = class {
     this.wired = true;
     this.liveUnsub = this.backend.subscribeLive(this._group, this);
     void this.loadSuppressed();
+    void this.loadElevated();
     void this.hydrateHistory();
     void this.refreshMembers();
   }
@@ -3701,6 +3796,17 @@ var Chat = class {
     } catch {
     }
   }
+  /** Hydrate the persisted self-elevation dedup keys (once). No re-emit: the set only
+   * gates the elevation DECISION, it does not change what renders. */
+  async loadElevated() {
+    if (this.elevatedLoaded || !this._group) return;
+    this.elevatedLoaded = true;
+    try {
+      const keys = await this.backend.loadElevated(this._group);
+      for (const k of keys) this.elevated.add(k);
+    } catch {
+    }
+  }
   async hydrateHistory() {
     if (this.historyLoaded || !this._group) return;
     this.historyLoaded = true;
@@ -3730,7 +3836,9 @@ var Chat = class {
       if (m.clientMsgId && !m.isDeleted) {
         this.deleteFold.reevaluatePending(m.clientMsgId, m.senderUserId);
       }
-      this.messageList.push(this.applyEditOverlay(this.applyReactionTally(m)));
+      this.messageList.push(
+        this.applyEditOverlay(this.applyReactionTally(this.resolveMentionNames(m)))
+      );
       changed = true;
       this.loadedEarliestSeq = Math.min(this.loadedEarliestSeq ?? m.serverSeq, m.serverSeq);
     }
@@ -3780,7 +3888,10 @@ var Chat = class {
           newText: incoming.edit.newText,
           epoch: incoming.epoch,
           serverSeq: incoming.serverSeq,
-          eventClientMsgId: incoming.clientMsgId
+          eventClientMsgId: incoming.clientMsgId,
+          // Mentions T6: carry the edit's REPLACEMENT ranges so the edited message's
+          // mentions reflect them (recomputed against the new text on recomputeEdit).
+          bodyRanges: incoming.bodyRanges
         },
         this.authorOfTarget
       );
@@ -3808,6 +3919,7 @@ var Chat = class {
     if (incomingReplyRef) {
       resolvedReplyTo = resolveReply(incomingReplyRef, (id) => this.byClientMsgId.get(id) ?? null);
     }
+    const mentions = this.resolveMentions(incoming.text, incoming.bodyRanges);
     const msg = {
       id: this.publicId(incoming.serverSeq),
       kind: this.kindOf(incoming),
@@ -3824,8 +3936,10 @@ var Chat = class {
       // Default false; applyEditOverlay below folds any edit that arrived first.
       edited: false,
       // Default false; surfaced() applies the tombstone scrub if a delete folded.
-      isDeleted: false
+      isDeleted: false,
+      mentions
     };
+    this.elevateIfMentioned(msg, mentions, senderUser, incoming.envelopeType);
     if (incomingClientMsgId && incoming.text !== null) {
       this.byClientMsgId.set(incomingClientMsgId, {
         text: incoming.text,
@@ -3849,6 +3963,75 @@ var Chat = class {
    * (null = target unknown/dangling → the fold HOLDs). Captured as a bound arrow
    * so it can be passed to the pure EditFold. */
   authorOfTarget = (targetClientMsgId) => this.authorByClientMsgId.get(targetClientMsgId) ?? null;
+  // ── Mentions (mentions T6) ──
+  /** Resolve a message's decode-time mention spans: NORMALIZE the raw `body_ranges`
+   * against `text` (the pinned `normalizeMentionRangesUtf16` cross-SDK contract) then
+   * resolve each surviving range's `mentionedUserId` to a roster display name. An id
+   * not in the roster resolves to `null` (the renderer falls back to the `text` slice).
+   * Pure over (text, bodyRanges, memberCache); never throws. Mirrors iOS T3. */
+  resolveMentions(text, bodyRanges) {
+    if (text === null || !bodyRanges || bodyRanges.length === 0) return [];
+    const normalized = normalizeMentionRangesUtf16(bodyRanges, text);
+    if (normalized.length === 0) return [];
+    return normalized.map((r) => ({
+      start: r.start,
+      length: r.length,
+      mentionedUserId: r.mentionedUserId,
+      displayName: this.displayNameOf(r.mentionedUserId)
+    }));
+  }
+  /** Re-resolve the roster display name on already-NORMALIZED spans (the history
+   * projection produces them with null names — resolution is LIVE, not snapshotted).
+   * A member rename then reflects on old messages. Returns the message unchanged when
+   * it has no mentions (the common case) or no name changed. Mirrors iOS T3. */
+  resolveMentionNames(m) {
+    if (!m.mentions || m.mentions.length === 0) {
+      return m.mentions ? m : { ...m, mentions: [] };
+    }
+    let changed = false;
+    const reresolved = m.mentions.map((span) => {
+      const name = this.displayNameOf(span.mentionedUserId);
+      if (name === span.displayName) return span;
+      changed = true;
+      return { ...span, displayName: name };
+    });
+    if (!changed) return m;
+    return { ...m, mentions: reresolved };
+  }
+  /** The WINNING edit's resolved mentions for a target (normalize its replacement
+   * ranges against the new text + roster names), or `[]` if no winning edit / no
+   * ranges. The edited message's mentions reflect the EDIT's ranges (mirrors iOS T3). */
+  editMentions(targetClientMsgId, newText) {
+    const ranges = this.editFold.bodyRanges(targetClientMsgId);
+    if (!ranges) return [];
+    return this.resolveMentions(newText, ranges);
+  }
+  /** Resolve a userId → its roster display name (null if not a known member). */
+  displayNameOf(userId) {
+    return this.memberCache.find((mm) => mm.userId === userId)?.displayName ?? null;
+  }
+  /** Compute the SELF-ELEVATION decision for a freshly-ingested INCOMING bubble and,
+   * when it fires, record the dedup key (persisted) + invoke `onMentionElevation`.
+   * Gate (mirrors iOS T3): a surviving mention targets THIS user AND the sender is not
+   * me AND it's NOT an edit AND the `(selfUserId, clientMsgId|seq)` key isn't already
+   * elevated. Dedup-once: the in-memory set gates the session, the persisted set
+   * survives reload. An EDIT never reaches here (it folds, not a bubble) — the
+   * `envelopeType !== 'edit'` guard is belt-and-braces. */
+  elevateIfMentioned(message, mentions, senderUserId, envelopeType) {
+    const me = this.backend.selfUserId;
+    if (envelopeType === "edit") return;
+    if (senderUserId === me) return;
+    if (!mentions.some((mm) => mm.mentionedUserId === me)) return;
+    const idPart = message.clientMsgId ? message.clientMsgId : `seq:${message.serverSeq}`;
+    const key = `${me}|${idPart}`;
+    if (this.elevated.has(key)) return;
+    this.elevated.add(key);
+    if (this._group) {
+      void this.backend.saveElevated(this._group, [...this.elevated]).catch(() => {
+      });
+    }
+    this.onMentionElevation?.(message);
+  }
   /** Seed the per-target base text + author for the edit fold. Base is write-once
    * (a later own/peer edit must not overwrite the original we render against). The
    * author is (re)recorded whenever a non-empty resolution is available. */
@@ -3905,9 +4088,10 @@ var Chat = class {
       const base = this.originalTextByClientMsgId.has(targetClientMsgId) ? this.originalTextByClientMsgId.get(targetClientMsgId) ?? null : m.text;
       const text = editText ?? base;
       const edited = foldEdited || m.edited;
-      if (m.text === text && m.edited === edited) return m;
+      const mentions = editText !== null ? this.editMentions(targetClientMsgId, text) : m.mentions;
+      if (m.text === text && m.edited === edited && sameMentions(m.mentions, mentions)) return m;
       changed = true;
-      return { ...m, text, edited };
+      return { ...m, text, edited, mentions };
     });
     if (changed) this.emit();
   }
@@ -3924,8 +4108,9 @@ var Chat = class {
     if (editText === null && !foldEdited) return m;
     const text = editText ?? m.text;
     const edited = foldEdited || m.edited;
-    if (m.text === text && m.edited === edited) return m;
-    return { ...m, text, edited };
+    const mentions = editText !== null ? this.editMentions(m.clientMsgId, text) : m.mentions;
+    if (m.text === text && m.edited === edited && sameMentions(m.mentions, mentions)) return m;
+    return { ...m, text, edited, mentions };
   }
   /** @internal — called by the backend's conv subscription. */
   applyConv(event, payload) {
@@ -3983,6 +4168,18 @@ var Chat = class {
     }
     this.editFold.reevaluateHeld(this.authorOfTarget);
     for (const cid of this.originalTextByClientMsgId.keys()) this.recomputeEdit(cid);
+    this.reresolveAllMentionNames();
+  }
+  /** Re-resolve roster display names across the whole transcript (called on a roster
+   * change). Re-emits only if any name actually changed. */
+  reresolveAllMentionNames() {
+    let changed = false;
+    this.messageList = this.messageList.map((m) => {
+      const reresolved = this.resolveMentionNames(m);
+      if (reresolved !== m) changed = true;
+      return reresolved;
+    });
+    if (changed) this.emit();
   }
   seedMembersFromGroup(group) {
     const seed = [
@@ -4050,11 +4247,12 @@ var Chat = class {
       };
       resolvedReplyTo = resolveReply(replyRef, (id) => this.byClientMsgId.get(id) ?? null);
     }
-    const { receipt, clientMsgId } = await this.backend.sendText(group, text, replyRef);
-    this.appendOwnSend(text, receipt, clientMsgId, resolvedReplyTo);
+    const bodyRanges = opts?.mentions ?? null;
+    const { receipt, clientMsgId } = await this.backend.sendText(group, text, replyRef, bodyRanges);
+    this.appendOwnSend(text, receipt, clientMsgId, resolvedReplyTo, bodyRanges);
     return receipt;
   }
-  appendOwnSend(text, receipt, clientMsgId, resolvedReplyTo) {
+  appendOwnSend(text, receipt, clientMsgId, resolvedReplyTo, bodyRanges) {
     if (receipt.serverSeq <= 0) return;
     const key = this.internalKey(receipt.serverSeq);
     if (this.seenKeys.has(key)) return;
@@ -4079,7 +4277,10 @@ var Chat = class {
       // Own-sent edits fold via edit() after the fact; new sends start unedited.
       edited: false,
       // Own-sent deletes fold via deleteForEveryone() after the fact; start live.
-      isDeleted: false
+      isDeleted: false,
+      // Mentions T6: resolve the own-sent bubble's mentions for its own render (the
+      // sender never gets a wire echo of its own message — this is the only local copy).
+      mentions: this.resolveMentions(text, bodyRanges)
     });
     this.messageList.sort((a, b) => a.serverSeq - b.serverSeq);
     this.emit();
@@ -4167,15 +4368,18 @@ var Chat = class {
    * instantly; the durable echo on the next pump is a fold no-op (dedup on the
    * SAME wire clientMsgId). Never appends a bubble; PRESERVES the target's
    * reactions + reply context. Only the original author's edits count — for an own
-   * message self IS the author, so the author-gate passes. */
-  async edit(message, newText) {
+   * message self IS the author, so the author-gate passes. `opts.mentions` carries the
+   * edit's REPLACEMENT mention ranges → the edited message's mentions reflect them. */
+  async edit(message, newText, opts) {
     if (!message.clientMsgId || message.kind !== "text") return;
     const group = await this.materializeIfNeeded();
     const clientMsgId = mintClientMsgId();
+    const bodyRanges = opts?.mentions ?? null;
     const { receipt } = await this.backend.sendEdit(group, {
       clientMsgId,
       targetClientMsgId: message.clientMsgId,
-      newText
+      newText,
+      bodyRanges
     });
     this.seedEditBase(message.clientMsgId, message.text, this.backend.selfUserId);
     this.editFold.ingest(
@@ -4185,7 +4389,8 @@ var Chat = class {
         newText,
         epoch: receipt.epoch,
         serverSeq: receipt.serverSeq,
-        eventClientMsgId: clientMsgId
+        eventClientMsgId: clientMsgId,
+        bodyRanges
       },
       this.authorOfTarget
     );
@@ -4238,6 +4443,18 @@ var Chat = class {
     }
   }
 };
+function sameMentions(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    const x = a[i];
+    const y = b[i];
+    if (!x || !y) return false;
+    if (x.start !== y.start || x.length !== y.length || x.mentionedUserId !== y.mentionedUserId || x.displayName !== y.displayName) {
+      return false;
+    }
+  }
+  return true;
+}
 function sameReactions(a, b) {
   const ak = Object.keys(a);
   const bk = Object.keys(b);
@@ -4449,14 +4666,21 @@ var MessageDeliverySource = class {
           // Thread the edit discriminator + new text through the persisted row so an
           // edit folded LIVE re-folds onto its target after a reload (the reload-parity
           // boundary — mirrors iOS T3). Omitted for non-edits → old rows hydrate as
-          // `'text'`/no-edit (backward-compat).
+          // `'text'`/no-edit (backward-compat). The edit's replacement body_ranges ride
+          // along so the edited message's mentions re-resolve on cold launch (T6).
           ...isEdit && decoded.edit ? {
             envelopeType: "edit",
             edit: {
               targetClientMsgId: decoded.edit.targetClientMsgId,
-              newText: decoded.edit.newText
+              newText: decoded.edit.newText,
+              ...decoded.bodyRanges ? { bodyRanges: decoded.bodyRanges } : {}
             }
           } : {},
+          // Thread the TEXT bubble's mention ranges (raw) through the persisted row so a
+          // mention surfaced LIVE re-resolves onto its bubble after a reload (the
+          // reload-parity boundary for mentions — T6, mirrors iOS T3). Only on a text
+          // bubble (not a reaction/edit/delete row); omitted when absent (backward-compat).
+          ...!isReaction && !isEdit && !isDelete && decoded.bodyRanges ? { bodyRanges: decoded.bodyRanges } : {},
           // Thread the delete discriminator + target through the persisted row so a
           // delete-for-everyone tombstone folded LIVE re-folds onto its target after
           // a reload (the reload-parity boundary — the iOS-review CRITICAL lesson;
@@ -4488,7 +4712,10 @@ var MessageDeliverySource = class {
           envelopeType: decoded.type ?? "text",
           reaction: isReaction ? decoded.reaction : null,
           edit: isEdit ? decoded.edit : null,
-          delete: isDelete ? decoded.delete : null
+          delete: isDelete ? decoded.delete : null,
+          // The raw mention ranges (text bubble or the edit's replacement ranges); the
+          // Chat normalizes + resolves names → ChatMessage.mentions (T6).
+          bodyRanges: decoded.bodyRanges ?? null
         });
         return true;
       }
@@ -4643,6 +4870,36 @@ var GroupCatalog = class {
   }
 };
 
+// src/messaging/mention-elevation.ts
+var MentionElevationStore = class {
+  constructor(kv) {
+    this.kv = kv;
+  }
+  kv;
+  key(rfcGroupId) {
+    return `elev:${rfcGroupId}`;
+  }
+  /** Load the persisted elevation keys for a chat (empty array if none). */
+  async load(rfcGroupId) {
+    const raw = await this.kv.get(this.key(rfcGroupId));
+    if (!raw) return [];
+    try {
+      const parsed = JSON.parse(decodeUtf8(raw));
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
+    }
+  }
+  /** Persist the full elevation key set for a chat (deterministic, deduped order). */
+  async save(rfcGroupId, keys) {
+    const sorted = [...new Set(keys)].sort();
+    await this.kv.set(this.key(rfcGroupId), encodeUtf8(JSON.stringify(sorted)));
+  }
+  async wipe() {
+    for (const k of await this.kv.keys("elev:")) await this.kv.delete(k);
+  }
+};
+
 // src/messaging/wasm/pkg/palbe_mls_bg.js
 var palbe_mls_bg_exports = {};
 __export(palbe_mls_bg_exports, {
@@ -6350,6 +6607,7 @@ var MessagingCoordinator = class {
     this.groupStore = new GroupStateStorage(this.kv);
     this.kpStore = new KeyPackageStorage(this.kv);
     this.suppressionStore = new SuppressionStore(this.kv);
+    this.elevationStore = new MentionElevationStore(this.kv);
     this.registry.attachChatList(
       (chats) => {
         this.chatList = chats;
@@ -6365,6 +6623,7 @@ var MessagingCoordinator = class {
   groupStore;
   kpStore;
   suppressionStore;
+  elevationStore;
   registry = new GroupRegistry();
   resolved = null;
   resolvePromise = null;
@@ -6520,9 +6779,9 @@ var MessagingCoordinator = class {
     });
     return group;
   }
-  async sendText(group, text, replyTo) {
+  async sendText(group, text, replyTo, bodyRanges) {
     const r = await this.resolve();
-    return r.groups.sendText(group, text, replyTo);
+    return r.groups.sendText(group, text, replyTo, bodyRanges);
   }
   async sendReaction(group, args) {
     const r = await this.resolve();
@@ -6544,6 +6803,14 @@ var MessagingCoordinator = class {
   saveSuppressed(group, keys) {
     return this.suppressionStore.save(group.rfcGroupId, keys);
   }
+  /** Load this chat's persisted self-elevation dedup keys (durable-only). */
+  loadElevated(group) {
+    return this.elevationStore.load(group.rfcGroupId);
+  }
+  /** Persist this chat's self-elevation dedup keys (durable-only, no wire). */
+  saveElevated(group, keys) {
+    return this.elevationStore.save(group.rfcGroupId, keys);
+  }
   async history(group, limit, before) {
     const r = await this.resolve();
     const rows = await r.messageStore.history(group.rfcGroupId, limit, before);
@@ -6662,7 +6929,10 @@ function projectHistory(displayId, rows, selfUserId, resolveActor) {
         newText: s.edit.newText,
         epoch: s.epoch,
         serverSeq: s.serverSeq,
-        eventClientMsgId: s.clientMsgId ?? `${s.id}`
+        eventClientMsgId: s.clientMsgId ?? `${s.id}`,
+        // Mentions T6: the edit's replacement ranges ride the fold so the WINNING
+        // edit's ranges drive the edited message's mentions on cold launch.
+        bodyRanges: s.edit.bodyRanges ?? null
       },
       authorOfTarget
     );
@@ -6712,7 +6982,9 @@ function projectHistory(displayId, rows, selfUserId, resolveActor) {
         replyTo: null,
         reactions: {},
         edited: false,
-        isDeleted: true
+        isDeleted: true,
+        // Mentions T6: delete DOMINATES mentions too — a tombstoned message has none.
+        mentions: []
       });
       continue;
     }
@@ -6732,23 +7004,36 @@ function projectHistory(displayId, rows, selfUserId, resolveActor) {
     }
     const editText = clientMsgId ? editFold.text(clientMsgId) : null;
     const edited = clientMsgId ? editFold.isEdited(clientMsgId) : false;
+    const text = editText ?? s.text;
+    const rawRanges = editText !== null ? editFold.bodyRanges(clientMsgId) : s.bodyRanges;
+    const mentions = normalizeMentionsNullNames(rawRanges, text);
     out.push({
       id: `${displayId}#${s.serverSeq}`,
       kind: s.text != null ? "text" : "system",
       direction: s.direction,
       senderUserId: s.direction === "outgoing" ? selfUserId : null,
-      text: editText ?? s.text,
+      text,
       serverSeq: s.serverSeq,
       sentAt: new Date(s.at),
       clientMsgId,
       replyTo,
       reactions: clientMsgId ? fold.tally(clientMsgId) : {},
       edited,
-      isDeleted: false
+      isDeleted: false,
+      mentions
     });
   }
   return out;
 }
+function normalizeMentionsNullNames(raw, text) {
+  if (text === null || !raw || raw.length === 0) return [];
+  return normalizeMentionRangesUtf16(raw, text).map((r) => ({
+    start: r.start,
+    length: r.length,
+    mentionedUserId: r.mentionedUserId,
+    displayName: null
+  }));
+}
 
 // src/messaging/facade.ts
 var PalbeMessaging = class {
@@ -7482,7 +7767,7 @@ function defaultSessionStorage(key) {
 }
 
 // src/version.ts
-var VERSION = "1.4.0";
+var VERSION = "1.5.0";
 
 // src/runtime.ts
 function buildRuntime(config) {