@palbase/web 1.1.0 → 1.2.0

package/dist/internal.d.cts

@@ -1,7 +1,7 @@
-import { u as PalbeConfig, J as PalbeRuntime } from './analytics-facade-CAKBIH_U.cjs';
-export { K as buildRuntime } from './analytics-facade-CAKBIH_U.cjs';
+import { u as PalbeConfig, J as PalbeRuntime } from './analytics-facade-Ct3A1zop.cjs';
+export { K as buildRuntime } from './analytics-facade-Ct3A1zop.cjs';
 import { B as BackendError } from './errors-fDoNdTrJ.cjs';
-export { P as PB, c as createBoundClient } from './pb-DioxNuEV.cjs';
+export { P as PB, c as createBoundClient } from './pb-BlIfgBG-.cjs';
 import 'livekit-client';
 import './storage-BPaeSG8K.cjs';
 import './pooled-flags-Bwq4usn0.js';

package/dist/internal.d.ts

@@ -1,7 +1,7 @@
-import { u as PalbeConfig, J as PalbeRuntime } from './analytics-facade-DLH-KivI.js';
-export { K as buildRuntime } from './analytics-facade-DLH-KivI.js';
+import { u as PalbeConfig, J as PalbeRuntime } from './analytics-facade-C93tr7dA.js';
+export { K as buildRuntime } from './analytics-facade-C93tr7dA.js';
 import { B as BackendError } from './errors-fDoNdTrJ.js';
-export { P as PB, c as createBoundClient } from './pb-HegMSSk-.js';
+export { P as PB, c as createBoundClient } from './pb-BtYdWClg.js';
 import 'livekit-client';
 import './storage-BPaeSG8K.js';
 import './pooled-flags-Bwq4usn0.js';

package/dist/internal.js

@@ -6,7 +6,7 @@ import {
   createBoundClient,
   getRuntime,
   onConfigured
-} from "./chunk-XVLR3HGD.js";
+} from "./chunk-OZLVL7G2.js";
 export {
   __configure,
   __registerNamespaces,

package/dist/next/client.cjs

@@ -2552,6 +2552,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,
@@ -2566,18 +2578,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 };
@@ -2829,6 +2855,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);
@@ -2890,6 +2966,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). */
@@ -2908,6 +3039,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;
@@ -3014,7 +3147,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);
     }
@@ -3039,6 +3172,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;
@@ -3054,7 +3203,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, {
@@ -3070,6 +3222,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;
@@ -3212,7 +3393,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();
@@ -3259,7 +3443,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 {
@@ -3418,7 +3648,9 @@ 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 stored = {
           id: `${group.rfcGroupId}#${row.server_seq}`,
           direction: "incoming",
@@ -3433,7 +3665,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);
@@ -3449,7 +3693,9 @@ var MessageDeliverySource = class {
           serverSeq: row.server_seq,
           receivedAt: /* @__PURE__ */ new Date(),
           clientMsgId,
-          replyRef: replyTo
+          replyRef: replyTo,
+          envelopeType: decoded.type ?? "text",
+          reaction: isReaction ? decoded.reaction : null
         });
         return true;
       }
@@ -5439,7 +5685,6 @@ var MessagingCoordinator = class {
         await r.groups.addMember(group, userId);
       }
     }
-    r.registry.register(group);
     void r.catalog.upsert({
       displayId: group.displayId,
       rfcGroupId: group.rfcGroupId,
@@ -5454,46 +5699,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();
@@ -5570,6 +5783,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 {
@@ -6303,7 +6574,7 @@ function defaultSessionStorage(key) {
 }
 
 // src/version.ts
-var VERSION = "1.1.0";
+var VERSION = "1.2.0";
 
 // src/runtime.ts
 function buildRuntime(config) {