@palbase/web 1.1.1 → 1.2.1

package/dist/{chunk-EMQGOKW6.js → chunk-KJXRY4S3.js}

@@ -2730,6 +2730,18 @@ async function listDevices(rt, userId) {
 }
 
 // src/messaging/group-messaging.ts
+function encodeReaction(args) {
+  return encodeUtf8(
+    JSON.stringify({
+      v: 1,
+      type: "reaction",
+      client_msg_id: args.clientMsgId,
+      target_client_msg_id: args.targetClientMsgId,
+      emoji: args.emoji,
+      op: args.op
+    })
+  );
+}
 function encodeEnvelope(args) {
   const env = {
     v: 1,
@@ -2744,18 +2756,32 @@ function decodeEnvelope(bytes) {
   const s = decodeUtf8(bytes);
   try {
     const o = JSON.parse(s);
+    if (typeof o === "object" && o !== null && o.type === "reaction") {
+      return {
+        type: "reaction",
+        text: null,
+        clientMsgId: o.client_msg_id ?? "",
+        replyTo: null,
+        reaction: {
+          targetClientMsgId: o.target_client_msg_id ?? "",
+          emoji: o.emoji ?? "",
+          op: o.op ?? "add"
+        }
+      };
+    }
     if (typeof o === "object" && o !== null && o.type === "text" && typeof o.v === "number") {
       return {
+        type: "text",
         text: o.text ?? null,
         clientMsgId: o.client_msg_id ?? "",
         replyTo: o.reply_to ?? null
       };
     }
     if (typeof o === "object" && o !== null && o.type === "text") {
-      return { text: o.text ?? null, clientMsgId: "", replyTo: null };
+      return { type: "text", text: o.text ?? null, clientMsgId: "", replyTo: null };
     }
     if (typeof o === "object" && o !== null && o.type === "media")
-      return { text: null, clientMsgId: "", replyTo: null };
+      return { type: "media", text: null, clientMsgId: "", replyTo: null };
   } catch {
   }
   return { text: s, clientMsgId: "", replyTo: null };
@@ -3007,6 +3033,56 @@ var GroupMessaging = class {
     }
     return { receipt: { serverSeq: wire.server_seq, epoch: wire.epoch }, clientMsgId };
   }
+  /** Send a reaction (add/remove of an emoji on a target message). Encrypts a
+   * `type:'reaction'` envelope at the current epoch and sends through the SAME
+   * MLS application path as `sendText` (the server stays blind — a reaction is
+   * just another application message). Persists the outgoing reaction row so it
+   * re-folds onto its target after a reload (the own-send half of the reload
+   * parity). NEVER rebases (epoch-bound like any application message). */
+  async sendReaction(group, args) {
+    const plaintext = encodeReaction({
+      clientMsgId: args.clientMsgId,
+      targetClientMsgId: args.targetClientMsgId,
+      emoji: args.emoji,
+      op: args.op
+    });
+    const ct = await this.engine.encryptApplication(fromBase64(group.rfcGroupId), plaintext);
+    const body = {
+      ciphertext_b64: toBase64(ct),
+      client_idem_key: randomId()
+    };
+    const wire = await palbeRequest(
+      this.rt,
+      "POST",
+      MessagingPaths.groupMessages(group.displayId),
+      { body }
+    );
+    const stored = {
+      id: `${group.rfcGroupId}#${wire.server_seq}`,
+      direction: "outgoing",
+      text: null,
+      senderDeviceId: this.selfDeviceId,
+      epoch: wire.epoch,
+      serverSeq: wire.server_seq,
+      at: Date.now(),
+      clientMsgId: args.clientMsgId,
+      replyTo: null,
+      envelopeType: "reaction",
+      reaction: {
+        targetClientMsgId: args.targetClientMsgId,
+        emoji: args.emoji,
+        op: args.op
+      }
+    };
+    try {
+      await this.messageStore.append(group.rfcGroupId, stored);
+    } catch {
+    }
+    return {
+      receipt: { serverSeq: wire.server_seq, epoch: wire.epoch },
+      clientMsgId: args.clientMsgId
+    };
+  }
   // ── The rebase loop ──
   async commitWithRebase(rfcGroupId, build) {
     const gidBytes = fromBase64(rfcGroupId);
@@ -3068,6 +3144,61 @@ var GroupMessaging = class {
   }
 };
 
+// src/messaging/reaction-fold.ts
+function orderLte(aEpoch, aSeq, bEpoch, bSeq) {
+  if (aEpoch !== bEpoch) return aEpoch < bEpoch;
+  return aSeq <= bSeq;
+}
+var ReactionFold = class {
+  // Map<targetClientMsgId, Map<actorUserId, UserState>>
+  states = /* @__PURE__ */ new Map();
+  // Dedup set: eventClientMsgId values already applied.
+  seenEvents = /* @__PURE__ */ new Set();
+  ingest(e) {
+    if (this.seenEvents.has(e.eventClientMsgId)) return;
+    this.seenEvents.add(e.eventClientMsgId);
+    let byUser = this.states.get(e.targetClientMsgId);
+    if (byUser === void 0) {
+      byUser = /* @__PURE__ */ new Map();
+      this.states.set(e.targetClientMsgId, byUser);
+    }
+    const prev = byUser.get(e.actorUserId);
+    if (prev !== void 0) {
+      if (orderLte(e.epoch, e.serverSeq, prev.orderEpoch, prev.orderSeq)) return;
+    }
+    byUser.set(e.actorUserId, {
+      orderEpoch: e.epoch,
+      orderSeq: e.serverSeq,
+      emoji: e.op === "add" ? e.emoji : null
+    });
+  }
+  /**
+   * Returns a tally of `{ emoji → sorted userIds[] }` for the given target
+   * message. Users whose last event was a `remove` (emoji === null) are
+   * excluded. userId arrays are sorted for deterministic output (render
+   * stability + golden tests).
+   */
+  tally(targetClientMsgId) {
+    const byUser = this.states.get(targetClientMsgId);
+    if (byUser === void 0) return {};
+    const out = /* @__PURE__ */ new Map();
+    for (const [userId, st] of byUser) {
+      if (st.emoji === null) continue;
+      let users = out.get(st.emoji);
+      if (users === void 0) {
+        users = [];
+        out.set(st.emoji, users);
+      }
+      users.push(userId);
+    }
+    const result = {};
+    for (const [emoji, users] of out) {
+      result[emoji] = users.sort();
+    }
+    return result;
+  }
+};
+
 // src/messaging/chat.ts
 var Chat = class {
   /** Stable, URL/log-safe id (the grp_ display id once active; a reserved local id while draft). */
@@ -3086,6 +3217,8 @@ var Chat = class {
   seenKeys = /* @__PURE__ */ new Set();
   /** Index: clientMsgId → { text, senderUserId } for resolveReply lookups. */
   byClientMsgId = /* @__PURE__ */ new Map();
+  /** The single authoritative reaction fold for this chat (live + own-send + history). */
+  reactionFold = new ReactionFold();
   loadedEarliestSeq = null;
   historyLoaded = false;
   wired = false;
@@ -3192,7 +3325,7 @@ var Chat = class {
       const key = this.internalKey(m.serverSeq);
       if (this.seenKeys.has(key)) continue;
       this.seenKeys.add(key);
-      this.messageList.push(m);
+      this.messageList.push(this.applyReactionTally(m));
       changed = true;
       this.loadedEarliestSeq = Math.min(this.loadedEarliestSeq ?? m.serverSeq, m.serverSeq);
     }
@@ -3217,6 +3350,22 @@ var Chat = class {
       senderUser = await this.backend.userIdForDevice(this._group, incoming.senderDeviceId);
     }
     const direction = senderUser !== null && senderUser === this.backend.selfUserId ? "outgoing" : "incoming";
+    if (incoming.envelopeType === "reaction" && incoming.reaction) {
+      const actorUserId = direction === "outgoing" ? this.backend.selfUserId : senderUser;
+      if (actorUserId !== null) {
+        this.reactionFold.ingest({
+          targetClientMsgId: incoming.reaction.targetClientMsgId,
+          actorUserId,
+          emoji: incoming.reaction.emoji,
+          op: incoming.reaction.op,
+          epoch: incoming.epoch,
+          serverSeq: incoming.serverSeq,
+          eventClientMsgId: incoming.clientMsgId
+        });
+        this.recomputeReactions(incoming.reaction.targetClientMsgId);
+      }
+      return;
+    }
     const incomingClientMsgId = incoming.clientMsgId;
     const incomingReplyRef = incoming.replyRef;
     let resolvedReplyTo = null;
@@ -3232,7 +3381,10 @@ var Chat = class {
       serverSeq: incoming.serverSeq,
       sentAt: incoming.receivedAt,
       clientMsgId: incomingClientMsgId,
-      replyTo: resolvedReplyTo
+      replyTo: resolvedReplyTo,
+      // Attach any tally already folded for this message (a reaction that arrived
+      // BEFORE its target — the dangling case — renders the moment the target lands).
+      reactions: incomingClientMsgId ? this.reactionFold.tally(incomingClientMsgId) : {}
     };
     if (incomingClientMsgId && incoming.text !== null) {
       this.byClientMsgId.set(incomingClientMsgId, {
@@ -3248,6 +3400,35 @@ var Chat = class {
     );
     this.emit();
   }
+  /**
+   * Rebuild the target message's `reactions` from the authoritative fold and
+   * re-emit. No-op when the target isn't present yet (its tally is attached the
+   * moment it lands, via the append/merge paths) or when the tally is unchanged.
+   */
+  recomputeReactions(targetClientMsgId) {
+    if (!targetClientMsgId) return;
+    const tally = this.reactionFold.tally(targetClientMsgId);
+    let changed = false;
+    this.messageList = this.messageList.map((m) => {
+      if (m.clientMsgId !== targetClientMsgId) return m;
+      if (sameReactions(m.reactions, tally)) return m;
+      changed = true;
+      return { ...m, reactions: tally };
+    });
+    if (changed) this.emit();
+  }
+  /**
+   * Overlay the authoritative fold's tally onto a message as it is appended/merged.
+   * The Chat fold WINS when it has a non-empty tally; otherwise the tally already
+   * attached upstream (the coordinator's page-local history fold) is preserved.
+   */
+  applyReactionTally(m) {
+    if (!m.clientMsgId) return m;
+    const tally = this.reactionFold.tally(m.clientMsgId);
+    if (Object.keys(tally).length === 0) return m;
+    if (sameReactions(m.reactions, tally)) return m;
+    return { ...m, reactions: tally };
+  }
   /** @internal — called by the backend's conv subscription. */
   applyConv(event, payload) {
     const userId = typeof payload.user_id === "string" ? payload.user_id : null;
@@ -3390,7 +3571,10 @@ var Chat = class {
       serverSeq: receipt.serverSeq,
       sentAt: /* @__PURE__ */ new Date(),
       clientMsgId,
-      replyTo: resolvedReplyTo
+      replyTo: resolvedReplyTo,
+      // Attach any tally already folded for this own-sent message (rare, but keeps
+      // the dangling-target invariant uniform across every append path).
+      reactions: clientMsgId ? this.reactionFold.tally(clientMsgId) : {}
     });
     this.messageList.sort((a, b) => a.serverSeq - b.serverSeq);
     this.emit();
@@ -3437,7 +3621,53 @@ var Chat = class {
     this.readWatermark = Math.max(this.readWatermark, message.serverSeq);
     this.emit();
   }
+  // ── Reactions ──
+  /** Add an emoji reaction to a message. No-op if the message isn't reactable
+   * (empty clientMsgId — a legacy/system row). The reaction folds locally with
+   * the server receipt's `(epoch, serverSeq)` so the target's tally updates
+   * instantly; the durable echo on the next pump is a fold no-op (dedup on the
+   * SAME wire clientMsgId). Never appends a bubble. */
+  async react(message, emoji) {
+    await this.sendReaction(message, emoji, "add");
+  }
+  /** Remove this user's emoji reaction from a message (op:'remove'). */
+  async unreact(message, emoji) {
+    await this.sendReaction(message, emoji, "remove");
+  }
+  async sendReaction(message, emoji, op) {
+    if (!message.clientMsgId) return;
+    const group = await this.materializeIfNeeded();
+    const clientMsgId = mintClientMsgId();
+    const { receipt } = await this.backend.sendReaction(group, {
+      clientMsgId,
+      targetClientMsgId: message.clientMsgId,
+      emoji,
+      op
+    });
+    this.reactionFold.ingest({
+      targetClientMsgId: message.clientMsgId,
+      actorUserId: this.backend.selfUserId,
+      emoji,
+      op,
+      epoch: receipt.epoch,
+      serverSeq: receipt.serverSeq,
+      eventClientMsgId: clientMsgId
+    });
+    this.recomputeReactions(message.clientMsgId);
+  }
 };
+function sameReactions(a, b) {
+  const ak = Object.keys(a);
+  const bk = Object.keys(b);
+  if (ak.length !== bk.length) return false;
+  for (const k of ak) {
+    const av = a[k];
+    const bv = b[k];
+    if (!bv || av === void 0 || av.length !== bv.length) return false;
+    for (let i = 0; i < av.length; i++) if (av[i] !== bv[i]) return false;
+  }
+  return true;
+}
 
 // src/messaging/delivery-source.ts
 var MessageHub = class {
@@ -3467,6 +3697,11 @@ var MessageHub = class {
     };
   }
 };
+function decodeSenderDeviceId(sender) {
+  if (sender.length === 0) return null;
+  const id = decodeUtf8(sender);
+  return id.length > 0 ? id : null;
+}
 var MessageDeliverySource = class {
   constructor(rt, engine, hub, registry, messageStore, deviceId, selfUserId) {
     this.rt = rt;
@@ -3596,12 +3831,15 @@ var MessageDeliverySource = class {
     try {
       const received = await this.engine.processIncoming(fromBase64(group.rfcGroupId), blob);
       if (received.type === "application") {
-        const { text, clientMsgId, replyTo } = decodeEnvelope(received.data);
+        const decoded = decodeEnvelope(received.data);
+        const { text, clientMsgId, replyTo } = decoded;
+        const isReaction = decoded.type === "reaction" && decoded.reaction != null;
+        const senderDeviceId = row.sender_device_id ?? decodeSenderDeviceId(received.sender);
         const stored = {
           id: `${group.rfcGroupId}#${row.server_seq}`,
           direction: "incoming",
           text,
-          senderDeviceId: row.sender_device_id ?? null,
+          senderDeviceId,
           epoch: row.epoch,
           serverSeq: row.server_seq,
           at: Date.now(),
@@ -3611,7 +3849,19 @@ var MessageDeliverySource = class {
             previewBody: replyTo.preview?.body ?? null,
             previewAuthorUserId: replyTo.preview?.author_user_id ?? null,
             previewKind: replyTo.preview?.kind ?? "text"
-          } : null
+          } : null,
+          // Thread the reaction discriminator + fields through the persisted row so
+          // a reaction folded LIVE re-folds onto its target after a reload (the
+          // reload-parity boundary — mirrors iOS T3). Omitted for non-reactions →
+          // old rows hydrate as `'text'`/no-reaction (backward-compat).
+          ...isReaction && decoded.reaction ? {
+            envelopeType: "reaction",
+            reaction: {
+              targetClientMsgId: decoded.reaction.targetClientMsgId,
+              emoji: decoded.reaction.emoji,
+              op: decoded.reaction.op
+            }
+          } : {}
         };
         try {
           await this.messageStore.append(group.rfcGroupId, stored);
@@ -3622,12 +3872,14 @@ var MessageDeliverySource = class {
           kind: "application",
           group,
           text,
-          senderDeviceId: row.sender_device_id ?? null,
+          senderDeviceId,
           epoch: row.epoch,
           serverSeq: row.server_seq,
           receivedAt: /* @__PURE__ */ new Date(),
           clientMsgId,
-          replyRef: replyTo
+          replyRef: replyTo,
+          envelopeType: decoded.type ?? "text",
+          reaction: isReaction ? decoded.reaction : null
         });
         return true;
       }
@@ -5630,46 +5882,14 @@ var MessagingCoordinator = class {
     const r = await this.resolve();
     return r.groups.sendText(group, text, replyTo);
   }
+  async sendReaction(group, args) {
+    const r = await this.resolve();
+    return r.groups.sendReaction(group, args);
+  }
   async history(group, limit, before) {
     const r = await this.resolve();
     const rows = await r.messageStore.history(group.rfcGroupId, limit, before);
-    const lookup = /* @__PURE__ */ new Map();
-    for (const s of rows) {
-      const cid = s.clientMsgId ?? "";
-      if (cid && s.text !== null) {
-        const senderUserId = s.direction === "outgoing" ? this.selfUserId : "";
-        lookup.set(cid, { text: s.text, senderUserId });
-      }
-    }
-    return rows.map((s) => this.toChatMessage(group, s, (id) => lookup.get(id) ?? null));
-  }
-  toChatMessage(group, s, lookup) {
-    const clientMsgId = s.clientMsgId ?? "";
-    let replyTo = null;
-    if (s.replyTo && lookup) {
-      const ref = {
-        v: 1,
-        client_msg_id: s.replyTo.clientMsgId,
-        preview: {
-          kind: s.replyTo.previewKind,
-          author_user_id: s.replyTo.previewAuthorUserId ?? "",
-          body: s.replyTo.previewBody ?? void 0,
-          body_truncated: false
-        }
-      };
-      replyTo = resolveReply(ref, lookup);
-    }
-    return {
-      id: `${group.displayId}#${s.serverSeq}`,
-      kind: s.text != null ? "text" : "system",
-      direction: s.direction,
-      senderUserId: s.direction === "outgoing" ? this.selfUserId : null,
-      text: s.text,
-      serverSeq: s.serverSeq,
-      sentAt: new Date(s.at),
-      clientMsgId,
-      replyTo
-    };
+    return projectHistory(group.displayId, rows, this.selfUserId);
   }
   async members(group) {
     const r = await this.resolve();
@@ -5746,6 +5966,64 @@ var MessagingCoordinator = class {
     return res.devices.map((d) => d.device_id);
   }
 };
+function projectHistory(displayId, rows, selfUserId, resolveActor) {
+  const fold = new ReactionFold();
+  for (const s of rows) {
+    if (s.envelopeType !== "reaction" || !s.reaction) continue;
+    const actor = s.direction === "outgoing" ? selfUserId : resolveActor?.(s.senderDeviceId ?? null) ?? null;
+    if (actor === null) continue;
+    fold.ingest({
+      targetClientMsgId: s.reaction.targetClientMsgId,
+      actorUserId: actor,
+      emoji: s.reaction.emoji,
+      op: s.reaction.op,
+      epoch: s.epoch,
+      serverSeq: s.serverSeq,
+      eventClientMsgId: s.clientMsgId ?? `${s.id}`
+    });
+  }
+  const lookup = /* @__PURE__ */ new Map();
+  for (const s of rows) {
+    if (s.envelopeType === "reaction") continue;
+    const cid = s.clientMsgId ?? "";
+    if (cid && s.text !== null) {
+      const senderUserId = s.direction === "outgoing" ? selfUserId : "";
+      lookup.set(cid, { text: s.text, senderUserId });
+    }
+  }
+  const out = [];
+  for (const s of rows) {
+    if (s.envelopeType === "reaction") continue;
+    const clientMsgId = s.clientMsgId ?? "";
+    let replyTo = null;
+    if (s.replyTo) {
+      const ref = {
+        v: 1,
+        client_msg_id: s.replyTo.clientMsgId,
+        preview: {
+          kind: s.replyTo.previewKind,
+          author_user_id: s.replyTo.previewAuthorUserId ?? "",
+          body: s.replyTo.previewBody ?? void 0,
+          body_truncated: false
+        }
+      };
+      replyTo = resolveReply(ref, (id) => lookup.get(id) ?? null);
+    }
+    out.push({
+      id: `${displayId}#${s.serverSeq}`,
+      kind: s.text != null ? "text" : "system",
+      direction: s.direction,
+      senderUserId: s.direction === "outgoing" ? selfUserId : null,
+      text: s.text,
+      serverSeq: s.serverSeq,
+      sentAt: new Date(s.at),
+      clientMsgId,
+      replyTo,
+      reactions: clientMsgId ? fold.tally(clientMsgId) : {}
+    });
+  }
+  return out;
+}
 
 // src/messaging/facade.ts
 var PalbeMessaging = class {
@@ -6479,7 +6757,7 @@ function defaultSessionStorage(key) {
 }
 
 // src/version.ts
-var VERSION = "1.1.1";
+var VERSION = "1.2.1";
 
 // src/runtime.ts
 function buildRuntime(config) {
@@ -6839,4 +7117,4 @@ export {
   pb,
   createBoundClient
 };
-//# sourceMappingURL=chunk-EMQGOKW6.js.map
+//# sourceMappingURL=chunk-KJXRY4S3.js.map