@palbase/web 1.2.0 → 1.3.0

package/dist/index.cjs

@@ -1607,6 +1607,88 @@ var PalbeFlags = class {
   }
 };
 
+// src/messaging/edit-fold.ts
+function orderLt(aEpoch, aSeq, bEpoch, bSeq) {
+  if (aEpoch !== bEpoch) return aEpoch < bEpoch;
+  return aSeq < bSeq;
+}
+function orderEq(aEpoch, aSeq, bEpoch, bSeq) {
+  return aEpoch === bEpoch && aSeq === bSeq;
+}
+var EditFold = class {
+  // target → winning edit state
+  states = /* @__PURE__ */ new Map();
+  // dedup of real wire events that reached (and were resolvable enough to evaluate at) the fold
+  seenEvents = /* @__PURE__ */ new Set();
+  // events parked because target/author or sender was unresolved at ingest time
+  held = [];
+  // targets that have had ≥1 valid edit applied (write-once)
+  editedTargets = /* @__PURE__ */ new Set();
+  /**
+   * Ingest one edit. `authorOfTarget` resolves the target message's AUTHOR userId
+   * (null = target unknown/dangling → HOLD).
+   */
+  ingest(e, authorOfTarget) {
+    const author = authorOfTarget(e.targetClientMsgId);
+    if (author === null) {
+      this.holdIfNew(e);
+      return;
+    }
+    if (e.editorUserId === null) {
+      this.holdIfNew(e);
+      return;
+    }
+    if (e.editorUserId !== author) return;
+    if (this.seenEvents.has(e.eventClientMsgId)) return;
+    this.seenEvents.add(e.eventClientMsgId);
+    const prev = this.states.get(e.targetClientMsgId);
+    if (prev !== void 0) {
+      if (orderLt(e.epoch, e.serverSeq, prev.orderEpoch, prev.orderSeq)) return;
+      if (orderEq(e.epoch, e.serverSeq, prev.orderEpoch, prev.orderSeq) && e.eventClientMsgId <= prev.lastEventId) {
+        return;
+      }
+    }
+    this.states.set(e.targetClientMsgId, {
+      orderEpoch: e.epoch,
+      orderSeq: e.serverSeq,
+      lastEventId: e.eventClientMsgId,
+      text: e.newText
+    });
+    this.editedTargets.add(e.targetClientMsgId);
+  }
+  /**
+   * Park an event for later re-attempt, deduping held re-deliveries by
+   * eventClientMsgId so a repeatedly-delivered unresolvable edit is held exactly
+   * once (and never double-applies when it finally resolves on reevaluate).
+   */
+  holdIfNew(e) {
+    if (this.held.some((h) => h.eventClientMsgId === e.eventClientMsgId)) return;
+    this.held.push(e);
+  }
+  /** The winning edit text for a target, or null if no valid edit has applied. */
+  text(targetClientMsgId) {
+    return this.states.get(targetClientMsgId)?.text ?? null;
+  }
+  /** Write-once: true once any valid edit applied to the target. */
+  isEdited(targetClientMsgId) {
+    return this.editedTargets.has(targetClientMsgId);
+  }
+  /**
+   * 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
+   * event with the fresh `authorOfTarget` — events that still don't resolve are
+   * simply re-held; events that now resolve fold via the normal LWW path.
+   * Idempotent: re-ingest is deduped by `seenEvents` (applied events) and by
+   * `holdIfNew` (still-held events), so reevaluating repeatedly can neither
+   * double-apply nor lose an edit.
+   */
+  reevaluateHeld(authorOfTarget) {
+    const pending = this.held;
+    this.held = [];
+    for (const e of pending) this.ingest(e, authorOfTarget);
+  }
+};
+
 // src/messaging/util.ts
 function toBase64(bytes) {
   if (typeof Buffer !== "undefined") {
@@ -1746,6 +1828,17 @@ async function listDevices(rt, userId) {
 }
 
 // src/messaging/group-messaging.ts
+function encodeEdit(args) {
+  return encodeUtf8(
+    JSON.stringify({
+      v: 1,
+      type: "edit",
+      client_msg_id: args.clientMsgId,
+      target_client_msg_id: args.targetClientMsgId,
+      new_text: args.newText
+    })
+  );
+}
 function encodeReaction(args) {
   return encodeUtf8(
     JSON.stringify({
@@ -1785,6 +1878,18 @@ function decodeEnvelope(bytes) {
         }
       };
     }
+    if (typeof o === "object" && o !== null && o.type === "edit") {
+      return {
+        type: "edit",
+        text: null,
+        clientMsgId: o.client_msg_id ?? "",
+        replyTo: null,
+        edit: {
+          targetClientMsgId: o.target_client_msg_id ?? "",
+          newText: o.new_text ?? ""
+        }
+      };
+    }
     if (typeof o === "object" && o !== null && o.type === "text" && typeof o.v === "number") {
       return {
         type: "text",
@@ -2099,6 +2204,54 @@ var GroupMessaging = class {
       clientMsgId: args.clientMsgId
     };
   }
+  /** Send an edit (edit-by-supersession on a target message). Encrypts a
+   * `type:'edit'` envelope at the current epoch and sends through the SAME MLS
+   * application path as `sendText` (the server stays blind — an edit is just
+   * another application message). Persists the outgoing edit row so it re-folds
+   * onto its target's text after a reload (the own-send half of the reload
+   * parity). NEVER rebases (epoch-bound like any application message). */
+  async sendEdit(group, args) {
+    const plaintext = encodeEdit({
+      clientMsgId: args.clientMsgId,
+      targetClientMsgId: args.targetClientMsgId,
+      newText: args.newText
+    });
+    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: "edit",
+      edit: {
+        targetClientMsgId: args.targetClientMsgId,
+        newText: args.newText
+      }
+    };
+    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);
@@ -2235,6 +2388,14 @@ var Chat = class {
   byClientMsgId = /* @__PURE__ */ new Map();
   /** The single authoritative reaction fold for this chat (live + own-send + history). */
   reactionFold = new ReactionFold();
+  /** The single authoritative edit fold for this chat (live + own-send + history). */
+  editFold = new EditFold();
+  /** 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();
+  /** Per-target AUTHOR userId — the EditFold author-gate input (filled at bubble
+   * projection time from senderUserId; '' = resolved-but-unknown peer). */
+  authorByClientMsgId = /* @__PURE__ */ new Map();
   loadedEarliestSeq = null;
   historyLoaded = false;
   wired = false;
@@ -2335,13 +2496,17 @@ var Chat = class {
           senderUserId: m.senderUserId ?? ""
         });
       }
+      if (m.clientMsgId) {
+        this.seedEditBase(m.clientMsgId, m.text, m.senderUserId ?? "");
+      }
     }
+    this.editFold.reevaluateHeld(this.authorOfTarget);
     for (const m of incoming) {
       if (m.serverSeq <= 0) continue;
       const key = this.internalKey(m.serverSeq);
       if (this.seenKeys.has(key)) continue;
       this.seenKeys.add(key);
-      this.messageList.push(this.applyReactionTally(m));
+      this.messageList.push(this.applyEditOverlay(this.applyReactionTally(m)));
       changed = true;
       this.loadedEarliestSeq = Math.min(this.loadedEarliestSeq ?? m.serverSeq, m.serverSeq);
     }
@@ -2382,6 +2547,22 @@ var Chat = class {
       }
       return;
     }
+    if (incoming.envelopeType === "edit" && incoming.edit) {
+      const editorUserId = direction === "outgoing" ? this.backend.selfUserId : senderUser;
+      this.editFold.ingest(
+        {
+          targetClientMsgId: incoming.edit.targetClientMsgId,
+          editorUserId,
+          newText: incoming.edit.newText,
+          epoch: incoming.epoch,
+          serverSeq: incoming.serverSeq,
+          eventClientMsgId: incoming.clientMsgId
+        },
+        this.authorOfTarget
+      );
+      this.recomputeEdit(incoming.edit.targetClientMsgId);
+      return;
+    }
     const incomingClientMsgId = incoming.clientMsgId;
     const incomingReplyRef = incoming.replyRef;
     let resolvedReplyTo = null;
@@ -2400,7 +2581,9 @@ var Chat = class {
       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) : {}
+      reactions: incomingClientMsgId ? this.reactionFold.tally(incomingClientMsgId) : {},
+      // Default false; applyEditOverlay below folds any edit that arrived first.
+      edited: false
     };
     if (incomingClientMsgId && incoming.text !== null) {
       this.byClientMsgId.set(incomingClientMsgId, {
@@ -2408,7 +2591,11 @@ var Chat = class {
         senderUserId: senderUser ?? ""
       });
     }
-    this.messageList.push(msg);
+    if (incomingClientMsgId) {
+      this.seedEditBase(incomingClientMsgId, incoming.text, senderUser);
+      this.editFold.reevaluateHeld(this.authorOfTarget);
+    }
+    this.messageList.push(this.applyEditOverlay(msg));
     this.messageList.sort((a, b) => a.serverSeq - b.serverSeq);
     this.loadedEarliestSeq = Math.min(
       this.loadedEarliestSeq ?? incoming.serverSeq,
@@ -2416,6 +2603,19 @@ var Chat = class {
     );
     this.emit();
   }
+  /** The EditFold author-gate input: the target message's resolved author userId
+   * (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;
+  /** 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. */
+  seedEditBase(clientMsgId, text, author) {
+    if (!this.originalTextByClientMsgId.has(clientMsgId)) {
+      this.originalTextByClientMsgId.set(clientMsgId, text);
+    }
+    if (author !== null) this.authorByClientMsgId.set(clientMsgId, author);
+  }
   /**
    * 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
@@ -2445,6 +2645,46 @@ var Chat = class {
     if (sameReactions(m.reactions, tally)) return m;
     return { ...m, reactions: tally };
   }
+  /**
+   * Rebuild the target message's rendered `text` + `edited` flag from the
+   * authoritative edit fold and re-emit, PRESERVING `.reactions` and `.replyTo`
+   * (the reaction-polish lesson — never clobber). text = `editFold.text(cid) ??
+   * base`; base is the seeded original so a forged/ignored edit leaves it intact.
+   * No-op when the target isn't present yet (the fold already recorded it; the
+   * overlay applies the moment the target lands) or when unchanged.
+   */
+  recomputeEdit(targetClientMsgId) {
+    if (!targetClientMsgId) return;
+    const editText = this.editFold.text(targetClientMsgId);
+    const foldEdited = this.editFold.isEdited(targetClientMsgId);
+    let changed = false;
+    this.messageList = this.messageList.map((m) => {
+      if (m.clientMsgId !== targetClientMsgId) return m;
+      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;
+      changed = true;
+      return { ...m, text, edited };
+    });
+    if (changed) this.emit();
+  }
+  /**
+   * Overlay the authoritative edit fold's winning text + flag onto a message as it
+   * is appended/merged. The fold WINS when it has an edit for this target;
+   * otherwise the upstream `text`/`edited` (e.g. the coordinator's page-local
+   * history fold) is preserved. PRESERVES reactions + replyTo.
+   */
+  applyEditOverlay(m) {
+    if (!m.clientMsgId) return m;
+    const editText = this.editFold.text(m.clientMsgId);
+    const foldEdited = this.editFold.isEdited(m.clientMsgId);
+    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 };
+  }
   /** @internal — called by the backend's conv subscription. */
   applyConv(event, payload) {
     const userId = typeof payload.user_id === "string" ? payload.user_id : null;
@@ -2499,6 +2739,8 @@ var Chat = class {
       this.memberCache = m;
       this.emit();
     }
+    this.editFold.reevaluateHeld(this.authorOfTarget);
+    for (const cid of this.originalTextByClientMsgId.keys()) this.recomputeEdit(cid);
   }
   seedMembersFromGroup(group) {
     const seed = [
@@ -2577,6 +2819,7 @@ var Chat = class {
     this.seenKeys.add(key);
     if (clientMsgId) {
       this.byClientMsgId.set(clientMsgId, { text, senderUserId: this.backend.selfUserId });
+      this.seedEditBase(clientMsgId, text, this.backend.selfUserId);
     }
     this.messageList.push({
       id: this.publicId(receipt.serverSeq),
@@ -2590,7 +2833,9 @@ var Chat = class {
       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) : {}
+      reactions: clientMsgId ? this.reactionFold.tally(clientMsgId) : {},
+      // Own-sent edits fold via edit() after the fact; new sends start unedited.
+      edited: false
     });
     this.messageList.sort((a, b) => a.serverSeq - b.serverSeq);
     this.emit();
@@ -2671,6 +2916,37 @@ var Chat = class {
     });
     this.recomputeReactions(message.clientMsgId);
   }
+  // ── Edit ──
+  /** Edit an own text message (edit-by-supersession). No-op if the message isn't
+   * editable (empty clientMsgId, or not a `text` kind). The edit folds locally
+   * with the server receipt's `(epoch, serverSeq)` so the target's text updates
+   * 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) {
+    if (!message.clientMsgId || message.kind !== "text") return;
+    const group = await this.materializeIfNeeded();
+    const clientMsgId = mintClientMsgId();
+    const { receipt } = await this.backend.sendEdit(group, {
+      clientMsgId,
+      targetClientMsgId: message.clientMsgId,
+      newText
+    });
+    this.seedEditBase(message.clientMsgId, message.text, this.backend.selfUserId);
+    this.editFold.ingest(
+      {
+        targetClientMsgId: message.clientMsgId,
+        editorUserId: this.backend.selfUserId,
+        newText,
+        epoch: receipt.epoch,
+        serverSeq: receipt.serverSeq,
+        eventClientMsgId: clientMsgId
+      },
+      this.authorOfTarget
+    );
+    this.recomputeEdit(message.clientMsgId);
+  }
 };
 function sameReactions(a, b) {
   const ak = Object.keys(a);
@@ -2713,6 +2989,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;
@@ -2845,11 +3126,13 @@ var MessageDeliverySource = class {
         const decoded = decodeEnvelope(received.data);
         const { text, clientMsgId, replyTo } = decoded;
         const isReaction = decoded.type === "reaction" && decoded.reaction != null;
+        const isEdit = decoded.type === "edit" && decoded.edit != 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(),
@@ -2871,6 +3154,17 @@ var MessageDeliverySource = class {
               emoji: decoded.reaction.emoji,
               op: decoded.reaction.op
             }
+          } : {},
+          // 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).
+          ...isEdit && decoded.edit ? {
+            envelopeType: "edit",
+            edit: {
+              targetClientMsgId: decoded.edit.targetClientMsgId,
+              newText: decoded.edit.newText
+            }
           } : {}
         };
         try {
@@ -2882,14 +3176,15 @@ 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,
           envelopeType: decoded.type ?? "text",
-          reaction: isReaction ? decoded.reaction : null
+          reaction: isReaction ? decoded.reaction : null,
+          edit: isEdit ? decoded.edit : null
         });
         return true;
       }
@@ -4897,6 +5192,10 @@ var MessagingCoordinator = class {
     const r = await this.resolve();
     return r.groups.sendReaction(group, args);
   }
+  async sendEdit(group, args) {
+    const r = await this.resolve();
+    return r.groups.sendEdit(group, args);
+  }
   async history(group, limit, before) {
     const r = await this.resolve();
     const rows = await r.messageStore.history(group.rfcGroupId, limit, before);
@@ -4993,6 +5292,32 @@ function projectHistory(displayId, rows, selfUserId, resolveActor) {
       eventClientMsgId: s.clientMsgId ?? `${s.id}`
     });
   }
+  const editFold = new EditFold();
+  const authorByClientMsgId = /* @__PURE__ */ new Map();
+  for (const s of rows) {
+    if (s.envelopeType === "reaction" || s.envelopeType === "edit") continue;
+    const cid = s.clientMsgId ?? "";
+    if (!cid) continue;
+    const author = s.direction === "outgoing" ? selfUserId : resolveActor?.(s.senderDeviceId ?? null);
+    if (author != null) authorByClientMsgId.set(cid, author);
+  }
+  const authorOfTarget = (cid) => authorByClientMsgId.get(cid) ?? null;
+  for (const s of rows) {
+    if (s.envelopeType !== "edit" || !s.edit) continue;
+    const editor = s.direction === "outgoing" ? selfUserId : resolveActor?.(s.senderDeviceId ?? null) ?? null;
+    editFold.ingest(
+      {
+        targetClientMsgId: s.edit.targetClientMsgId,
+        editorUserId: editor,
+        newText: s.edit.newText,
+        epoch: s.epoch,
+        serverSeq: s.serverSeq,
+        eventClientMsgId: s.clientMsgId ?? `${s.id}`
+      },
+      authorOfTarget
+    );
+  }
+  editFold.reevaluateHeld(authorOfTarget);
   const lookup = /* @__PURE__ */ new Map();
   for (const s of rows) {
     if (s.envelopeType === "reaction") continue;
@@ -5004,7 +5329,7 @@ function projectHistory(displayId, rows, selfUserId, resolveActor) {
   }
   const out = [];
   for (const s of rows) {
-    if (s.envelopeType === "reaction") continue;
+    if (s.envelopeType === "reaction" || s.envelopeType === "edit") continue;
     const clientMsgId = s.clientMsgId ?? "";
     let replyTo = null;
     if (s.replyTo) {
@@ -5020,17 +5345,20 @@ function projectHistory(displayId, rows, selfUserId, resolveActor) {
       };
       replyTo = resolveReply(ref, (id) => lookup.get(id) ?? null);
     }
+    const editText = clientMsgId ? editFold.text(clientMsgId) : null;
+    const edited = clientMsgId ? editFold.isEdited(clientMsgId) : false;
     out.push({
       id: `${displayId}#${s.serverSeq}`,
       kind: s.text != null ? "text" : "system",
       direction: s.direction,
       senderUserId: s.direction === "outgoing" ? selfUserId : null,
-      text: s.text,
+      text: editText ?? s.text,
       serverSeq: s.serverSeq,
       sentAt: new Date(s.at),
       clientMsgId,
       replyTo,
-      reactions: clientMsgId ? fold.tally(clientMsgId) : {}
+      reactions: clientMsgId ? fold.tally(clientMsgId) : {},
+      edited
     });
   }
   return out;
@@ -5887,7 +6215,7 @@ function localStorageSessionStorage(key = DEFAULT_KEY) {
 }
 
 // src/version.ts
-var VERSION = "1.2.0";
+var VERSION = "1.3.0";
 
 // src/internal.ts
 function getRuntime() {