@openmarket/rooms-client 0.6.0 → 0.7.0

package/src/agent/topic-inbox.ts

@@ -26,6 +26,20 @@ import type {
 /** The reserved bucket key for untopicked (linear) messages. */
 export const UNTOPICKED_BUCKET = "";
 
+/** Effective attention for a bucket: an elapsed timed mute reads as the
+ *  base attention ('default'). The store expires timed mutes lazily (no
+ *  deadline-triggered frame), so a hydrated inbox would otherwise stay
+ *  muted past the deadline until the next hydration. A null or absent
+ *  deadline keeps the stored attention (permanent mute). */
+export function resolveTopicAttention(
+  state: Pick<RoomTopicBucketState, "attention" | "muteUntil">,
+  nowMs: number = Date.now(),
+): RoomTopicAttention {
+  if (state.attention !== "mute" || state.muteUntil == null) return state.attention;
+  const deadline = Date.parse(state.muteUntil);
+  return Number.isFinite(deadline) && deadline <= nowMs ? "default" : "mute";
+}
+
 export interface TopicInboxItem {
   /** Bucket key: a topicId, or UNTOPICKED_BUCKET for the linear lane. */
   key: string;
@@ -141,7 +155,7 @@ export class RoomTopicInbox {
   }
 
   attentionFor(topicId: string): RoomTopicAttention {
-    return this.bucketFor(topicId).attention;
+    return resolveTopicAttention(this.bucketFor(topicId));
   }
 
   /** A registry mutation arrived (TOPIC_UPDATED, or a verb result echo). */
@@ -196,6 +210,10 @@ export class RoomTopicInbox {
       this.buckets.set(topicId, bucket);
     }
     bucket.attention = attention;
+    // The mirror knows only the new attention: a stale deadline from a
+    // previous timed mute must not expire it. The next hydration restores
+    // any server-side deadline.
+    delete bucket.muteUntil;
   }
 
   /**
@@ -224,7 +242,7 @@ export class RoomTopicInbox {
   channelUnread(): number {
     let total = 0;
     for (const bucket of this.buckets.values()) {
-      if (bucket.attention === "mute") continue;
+      if (resolveTopicAttention(bucket) === "mute") continue;
       total += bucket.unreadCount;
     }
     return total;
@@ -241,7 +259,7 @@ export class RoomTopicInbox {
   inboxItems(): TopicInboxItem[] {
     const items: TopicInboxItem[] = [];
     const untopicked = this.bucketFor(UNTOPICKED_BUCKET);
-    if (untopicked.unreadCount > 0 && untopicked.attention !== "mute") {
+    if (untopicked.unreadCount > 0 && resolveTopicAttention(untopicked) !== "mute") {
       items.push({
         key: UNTOPICKED_BUCKET,
         topic: undefined,
@@ -254,11 +272,11 @@ export class RoomTopicInbox {
     for (const topic of this.topics.values()) {
       if (topic.mergedInto) continue;
       const state = this.bucketFor(topic.topicId);
-      if (state.attention === "mute") continue;
+      if (resolveTopicAttention(state) === "mute") continue;
       let aliasUnread = 0;
       for (const alias of this.aliasesOf(topic.topicId)) {
         const aliasState = this.bucketFor(alias);
-        if (aliasState.attention === "mute") continue;
+        if (resolveTopicAttention(aliasState) === "mute") continue;
         aliasUnread += aliasState.unreadCount;
       }
       if (state.unreadCount + aliasUnread === 0) continue;

package/src/shared/rooms-protocol.ts

@@ -250,6 +250,19 @@ export interface RoomLedgerEntry {
   since?: string | number | null | undefined;
   reactions?: Array<{ emoji: string; count: number }> | undefined;
   editedAt?: string | number | Date | undefined;
+  /** Database-serialized edit counter: positive integer, strictly
+   *  increasing per event row, incremented on every successful text or
+   *  caption edit; absent means never edited. Orders caption edits where
+   *  wall-clock editedAt stamps can tie or skew across store replicas.
+   *  Missing on stores older than edit revisions. */
+  editRevision?: number | undefined;
+  /** Database-serialized card-mutation counter: positive integer,
+   *  strictly increasing per event row, bumped on every unfurl card
+   *  mutation (attach, edit-drop, purge); absent means cards were never
+   *  mutated. Consumers apply card patches only at or above their known
+   *  revision, making stale post-removal unfurl frames inert. Missing on
+   *  stores older than unfurl revisions. */
+  unfurlsRevision?: number | undefined;
   deletedAt?: string | number | Date | undefined;
   deletedBy?: string | undefined;
   replyCount?: number | undefined;
@@ -258,6 +271,12 @@ export interface RoomLedgerEntry {
   pinnedBy?: string | null | undefined;
   pinnedAt?: string | number | Date | null | undefined;
   attachments?: RoomAttachment[] | undefined;
+  /** Counts-only poll summary when this message carries a poll. Additive:
+   *  non-poll entries omit it, and live updates ride ENTRY_UPDATED. */
+  poll?: RoomPollSummary | null | undefined;
+  /** Server-rendered link unfurl cards. Additive: entries without links
+   *  (and servers older than the unfurl worker) omit it. */
+  unfurls?: RoomUnfurl[] | undefined;
   roomRole?: RoomRole | null | undefined;
   metadata?: (Record<string, unknown> & Partial<RoomForwardMetadata> & Partial<RoomWebhookMetadata>) | undefined;
 }
@@ -313,6 +332,49 @@ export interface RoomAttachment {
  */
 export type RoomAttachmentInput = RoomAttachment & { key: string };
 
+export interface RoomPollOption {
+  id: string;
+  text: string;
+  /** Vote count for this option. Counts only, never voter identities
+   *  (voters are fetched on demand, exactly like reactors). */
+  count: number;
+}
+
+/**
+ * Counts-only poll summary denormalized onto the carrying message (a poll
+ * IS a message). Vote/close/edit updates ride the existing ENTRY_UPDATED
+ * frame with the refreshed summary; the server's side collections stay the
+ * authoritative copy.
+ */
+export interface RoomPollSummary {
+  question: string;
+  options: RoomPollOption[];
+  multi: boolean;
+  /** ISO date when the poll auto-closes; null or absent means open-ended. */
+  closesAt?: string | null | undefined;
+  closed: boolean;
+  /** Store-serialized poll ordering revision, strictly increasing per
+   *  poll: consumers reject frames below their known revision so
+   *  bus-reordered vote/close updates cannot regress tallies. Present
+   *  where the relay forwards it; missing on older relays. */
+  revision?: number | undefined;
+}
+
+/**
+ * Server-rendered link unfurl card on an entry. `url` is the canonical
+ * URL; `thumbnailKey` is the re-hosted copy in the attachments bucket,
+ * signed through the member-scoped attachment path. The origin's image URL
+ * never crosses the wire. Cards appear via ENTRY_UPDATED when the unfurl
+ * worker lands.
+ */
+export interface RoomUnfurl {
+  url: string;
+  title?: string | undefined;
+  description?: string | undefined;
+  siteName?: string | undefined;
+  thumbnailKey?: string | undefined;
+}
+
 /**
  * A registry-backed topic inside a channel. The id is permanent: rename
  * changes `name` only, and links (`om://topic/<topicId>`) keep resolving.
@@ -383,6 +445,21 @@ export interface RoomReadStatePayload {
    *  Present when the store surfaces it and on ROOM_SET_ATTENTION acks
    *  (which reply READ_STATE scoped to the one room, readState empty). */
   attention?: Record<string, RoomTopicAttention> | undefined;
+  /** Per-room timed-mute expiry (ISO date), keyed like attention. Rides
+   *  beside a 'mute' attention entry when the mute carries an expiry; null
+   *  marks an explicitly cleared or permanent mute. A lapsed expiry never
+   *  appears: the server resolves it at read time and the attention value
+   *  reads as its base ('default'). Missing on servers older than
+   *  mute-with-duration. */
+  muteUntil?: Record<string, string | null> | undefined;
+  /** Per-room attention commit revision, keyed like attention: a
+   *  database-serialized, strictly increasing counter per (user, room),
+   *  present only for rooms whose attention has ever been committed.
+   *  ORDERING CONTRACT: a consumer that has synced revision R for a room
+   *  must ignore snapshot attention entries whose revision is <= R (a
+   *  snapshot read before a newer commit can arrive after that commit's
+   *  sync frame). Missing on stores older than attention revisions. */
+  attentionRevision?: Record<string, number> | undefined;
   /** Unread mention counts by room, server-computed from the notify
    *  worker's ROOM_MENTION rows so badges survive reload and clear through
    *  the ack path. Unlike readState/attention the map is SPARSE AND
@@ -995,6 +1072,14 @@ export interface RoomTopicBucketState {
   unreadCount: number;
   cursor: number;
   attention: RoomTopicAttention;
+  /** Standing timed-mute deadline (ISO date; null = permanent mute).
+   *  Present only on the room-wide '' bucket and only while its attention
+   *  is an active 'mute'; never on topic buckets. Same semantics as the
+   *  read-state muteUntil: the store expires timed mutes lazily, so
+   *  consumers resolve an elapsed deadline back to the base attention
+   *  ('default') at read time (see resolveTopicAttention). Missing on
+   *  servers older than mute-with-duration. */
+  muteUntil?: string | null | undefined;
 }
 
 export interface RoomTopicResultPayload {