@openmarket/rooms-client 0.1.0 → 0.2.1

package/dist/agent/armed-mode.d.ts

@@ -89,18 +89,35 @@ export interface ArmedRoomState {
 }
 /** A fresh armed state for a newly armed room. */
 export declare function makeArmedRoomState(roomId: string, lastSeq?: number): ArmedRoomState;
+/**
+ * A fresh armed state that CARRIES the cost/rate counters from a prior armed
+ * session of the same room. Disarm/rearm must not zero the cooldown, hourly
+ * window, or session budget: otherwise toggling /disarm + /arm bypasses every
+ * cost guard. Error and chain counters DO reset (rearming is an explicit
+ * operator action; a fresh process still starts with nothing retained).
+ */
+export declare function rearmedRoomState(roomId: string, retired: ArmedRoomState | null, lastSeq?: number): ArmedRoomState;
+/** Seqs of the user's own posts in a window of entries; the reply-trigger
+ *  check tests `inReplyTo` against this set. Pure. */
+export declare function ownSeqsOf(entries: ReadonlyArray<RoomLedgerEntry>, ownUserId: string): Set<number>;
 /**
  * Whether a single incoming entry is a qualifying TRIGGER: a NEW human POST in
- * the room that @mentions the user's own handle. Agent posts, system entries,
- * the user's own posts, and non-mentions never trigger. Pure.
+ * the room that @mentions the user's own handle, OR (when `ownSeqs` is given)
+ * directly replies to one of the user's own messages. Reply semantics match a
+ * mention (replying pings the author), so armed mode treats both as addressed
+ * to the user. Agent posts, system entries, the user's own posts, and
+ * non-mentions never trigger. Pure.
  */
-export declare function isTriggeringEntry(entry: RoomLedgerEntry, ownHandle: string, ownUserId: string): boolean;
+export declare function isTriggeringEntry(entry: RoomLedgerEntry, ownHandle: string, ownUserId: string, ownSeqs?: ReadonlySet<number>): boolean;
 /**
  * The newest qualifying trigger among entries strictly newer than
  * `afterSeq`, or null if none. Used by the loop to decide whether the latest
- * batch of room messages contains a reason to act. Pure.
+ * batch of room messages contains a reason to act. Reply triggers resolve
+ * against the user's own seqs within `entries` unless a wider `ownSeqs`
+ * window is supplied (the live single-entry path passes the room cache).
+ * Pure.
  */
-export declare function findTrigger(entries: ReadonlyArray<RoomLedgerEntry>, ownHandle: string, ownUserId: string, afterSeq: number): RoomLedgerEntry | null;
+export declare function findTrigger(entries: ReadonlyArray<RoomLedgerEntry>, ownHandle: string, ownUserId: string, afterSeq: number, ownSeqs?: ReadonlySet<number>): RoomLedgerEntry | null;
 /** Autonomous posts inside the rolling hourly window as of `now`. */
 export declare function postsInWindow(state: ArmedRoomState, now?: number): number;
 /** Remaining cooldown (ms) before the next autonomous post is allowed; 0 when

package/dist/agent/armed-mode.js

@@ -83,12 +83,41 @@ export function makeArmedRoomState(roomId, lastSeq = 0) {
         lastEvaluatedSeq: lastSeq,
     };
 }
+/**
+ * A fresh armed state that CARRIES the cost/rate counters from a prior armed
+ * session of the same room. Disarm/rearm must not zero the cooldown, hourly
+ * window, or session budget: otherwise toggling /disarm + /arm bypasses every
+ * cost guard. Error and chain counters DO reset (rearming is an explicit
+ * operator action; a fresh process still starts with nothing retained).
+ */
+export function rearmedRoomState(roomId, retired, lastSeq = 0) {
+    const state = makeArmedRoomState(roomId, lastSeq);
+    if (!retired || retired.roomId !== roomId)
+        return state;
+    state.postTimes = [...retired.postTimes];
+    state.postsThisSession = retired.postsThisSession;
+    state.tokensThisSession = retired.tokensThisSession;
+    return state;
+}
+/** Seqs of the user's own posts in a window of entries; the reply-trigger
+ *  check tests `inReplyTo` against this set. Pure. */
+export function ownSeqsOf(entries, ownUserId) {
+    const seqs = new Set();
+    for (const entry of entries) {
+        if (entry.userId === ownUserId)
+            seqs.add(entry.seq);
+    }
+    return seqs;
+}
 /**
  * Whether a single incoming entry is a qualifying TRIGGER: a NEW human POST in
- * the room that @mentions the user's own handle. Agent posts, system entries,
- * the user's own posts, and non-mentions never trigger. Pure.
+ * the room that @mentions the user's own handle, OR (when `ownSeqs` is given)
+ * directly replies to one of the user's own messages. Reply semantics match a
+ * mention (replying pings the author), so armed mode treats both as addressed
+ * to the user. Agent posts, system entries, the user's own posts, and
+ * non-mentions never trigger. Pure.
  */
-export function isTriggeringEntry(entry, ownHandle, ownUserId) {
+export function isTriggeringEntry(entry, ownHandle, ownUserId, ownSeqs) {
     if (entry.type !== RoomLedgerEntryType.POST)
         return false;
     if (entry.isAgent)
@@ -102,6 +131,10 @@ export function isTriggeringEntry(entry, ownHandle, ownUserId) {
         return false;
     if (me.length > 0 && fromHandle === me)
         return false;
+    // A direct reply to one of our messages is addressed to us. The set only
+    // spans the cached window, so replies to long-scrolled-out posts stay inert.
+    if (entry.inReplyTo !== undefined && ownSeqs?.has(entry.inReplyTo))
+        return true;
     // Must EXPLICITLY @mention the user's own handle. A bare-substring match (the
     // old mentionsAgent) fired on ordinary words for short handles like "may" /
     // "btc"; armed posting has no human review, so it triggers ONLY on an `@handle`
@@ -111,14 +144,17 @@ export function isTriggeringEntry(entry, ownHandle, ownUserId) {
 /**
  * The newest qualifying trigger among entries strictly newer than
  * `afterSeq`, or null if none. Used by the loop to decide whether the latest
- * batch of room messages contains a reason to act. Pure.
+ * batch of room messages contains a reason to act. Reply triggers resolve
+ * against the user's own seqs within `entries` unless a wider `ownSeqs`
+ * window is supplied (the live single-entry path passes the room cache).
+ * Pure.
  */
-export function findTrigger(entries, ownHandle, ownUserId, afterSeq) {
+export function findTrigger(entries, ownHandle, ownUserId, afterSeq, ownSeqs = ownSeqsOf(entries, ownUserId)) {
     let found = null;
     for (const entry of entries) {
         if (entry.seq <= afterSeq)
             continue;
-        if (isTriggeringEntry(entry, ownHandle, ownUserId))
+        if (isTriggeringEntry(entry, ownHandle, ownUserId, ownSeqs))
             found = entry;
     }
     return found;

package/dist/client.d.ts

@@ -208,6 +208,10 @@ export interface RoomDmSendRequest {
     conversationId?: string;
     content: string;
     clientMsgId?: string;
+    /** A private DM-attachment key (dm-attachments/…) or a legacy public image
+     *  URL. Stored on the message's imageUrl; the client signs keys on render.
+     *  Additive — omitted for text-only sends. */
+    imageUrl?: string;
 }
 export interface RoomThreadRequest {
     room: string;
@@ -251,6 +255,28 @@ export declare function requestRoomFriends(client: RoomWsClient): Promise<RoomFr
 export declare function openRoomDmOnClient(client: RoomWsClient, request: RoomDmOpenRequest, timeoutMs?: number): Promise<RoomDmOpenedPayload>;
 export declare function requestRoomDmHistoryOnClient(client: RoomWsClient, request: RoomDmHistoryRequest, timeoutMs?: number): Promise<RoomDmHistoryResultPayload>;
 export declare function sendRoomDmOnClient(client: RoomWsClient, request: RoomDmSendRequest, timeoutMs?: number): Promise<RoomDmMessagePayload>;
+/** Edit one of my DM messages. Fire-and-forget over the WS; the relay fans out
+ *  DM_MESSAGE_EDITED to both participants. */
+export declare function editRoomDmOnClient(client: RoomWsClient, request: {
+    conversationId?: string;
+    username?: string;
+    messageId: string;
+    content: string;
+}): void;
+/** Soft-delete one of my DM messages. The relay fans out DM_MESSAGE_DELETED. */
+export declare function deleteRoomDmOnClient(client: RoomWsClient, request: {
+    conversationId?: string;
+    username?: string;
+    messageId: string;
+}): void;
+/** Toggle a reaction on a DM message. The relay fans out DM_REACTION_UPDATED. */
+export declare function reactRoomDmOnClient(client: RoomWsClient, request: {
+    conversationId?: string;
+    username?: string;
+    messageId: string;
+    emoji: string;
+    op: "add" | "remove";
+}): void;
 export declare function peekRoom(config: RoomClientConfig, options: RoomPeekOptions): Promise<RoomBackfillPayload>;
 export declare function sayRoom(config: RoomClientConfig, options: RoomSayOptions): Promise<RoomSayResult>;
 export declare function joinRoom(config: RoomClientConfig, options: RoomJoinOptions): Promise<RoomJoinedSession>;

package/dist/client.js

@@ -465,6 +465,7 @@ export async function sendRoomDmOnClient(client, request, timeoutMs) {
             clientMsgId,
             ...(request.username ? { username: request.username } : {}),
             ...(request.conversationId ? { conversationId: request.conversationId } : {}),
+            ...(request.imageUrl ? { imageUrl: request.imageUrl } : {}),
         },
         timestamp: Date.now(),
     });
@@ -473,6 +474,46 @@ export async function sendRoomDmOnClient(client, request, timeoutMs) {
         msg.payload.message.clientMsgId === clientMsgId, timeoutMs, requestId);
     return sent.payload;
 }
+/** Edit one of my DM messages. Fire-and-forget over the WS; the relay fans out
+ *  DM_MESSAGE_EDITED to both participants. */
+export function editRoomDmOnClient(client, request) {
+    client.send({
+        type: RoomClientMessageType.DM_EDIT,
+        payload: {
+            messageId: request.messageId,
+            content: request.content,
+            ...(request.conversationId ? { conversationId: request.conversationId } : {}),
+            ...(request.username ? { username: request.username } : {}),
+        },
+        timestamp: Date.now(),
+    });
+}
+/** Soft-delete one of my DM messages. The relay fans out DM_MESSAGE_DELETED. */
+export function deleteRoomDmOnClient(client, request) {
+    client.send({
+        type: RoomClientMessageType.DM_DELETE,
+        payload: {
+            messageId: request.messageId,
+            ...(request.conversationId ? { conversationId: request.conversationId } : {}),
+            ...(request.username ? { username: request.username } : {}),
+        },
+        timestamp: Date.now(),
+    });
+}
+/** Toggle a reaction on a DM message. The relay fans out DM_REACTION_UPDATED. */
+export function reactRoomDmOnClient(client, request) {
+    client.send({
+        type: RoomClientMessageType.DM_REACT,
+        payload: {
+            messageId: request.messageId,
+            emoji: request.emoji,
+            op: request.op,
+            ...(request.conversationId ? { conversationId: request.conversationId } : {}),
+            ...(request.username ? { username: request.username } : {}),
+        },
+        timestamp: Date.now(),
+    });
+}
 export async function peekRoom(config, options) {
     if (!config.webSocketCtor) {
         try {

package/dist/shared/rooms-protocol.d.ts

@@ -38,6 +38,9 @@ export declare const RoomClientMessageType: {
     readonly DM_HISTORY: "DM_HISTORY";
     readonly DM_SEND: "DM_SEND";
     readonly DM_READ: "DM_READ";
+    readonly DM_EDIT: "DM_EDIT";
+    readonly DM_DELETE: "DM_DELETE";
+    readonly DM_REACT: "DM_REACT";
     readonly TOPIC_CREATE: "TOPIC_CREATE";
     readonly TOPIC_RENAME: "TOPIC_RENAME";
     readonly TOPIC_MOVE: "TOPIC_MOVE";
@@ -87,6 +90,9 @@ export declare const RoomServerMessageType: {
     readonly DM_HISTORY: "DM_HISTORY";
     readonly DM_MESSAGE: "DM_MESSAGE";
     readonly DM_INBOX_UPDATED: "DM_INBOX_UPDATED";
+    readonly DM_MESSAGE_EDITED: "DM_MESSAGE_EDITED";
+    readonly DM_MESSAGE_DELETED: "DM_MESSAGE_DELETED";
+    readonly DM_REACTION_UPDATED: "DM_REACTION_UPDATED";
     readonly TOPIC: "TOPIC";
     readonly TOPICS: "TOPICS";
     readonly TOPIC_UPDATED: "TOPIC_UPDATED";
@@ -438,6 +444,11 @@ export interface RoomDmMessage {
     /** Sealed DM: content is '' and the opaque envelope rides here. */
     secret?: RoomLedgerSecretPayload | null | undefined;
     metadata?: Record<string, unknown> | undefined;
+    /** Legacy public chat-image URL (renders as-is, no signing). */
+    imageUrl?: string | null | undefined;
+    /** Private, signed, scanned DM attachments (dm-attachments/ keyspace).
+     *  Additive: old messages carry none and render unchanged. */
+    attachments?: RoomAttachment[] | undefined;
 }
 export interface RoomDmOpenPayload {
     requestId?: string;
@@ -459,6 +470,58 @@ export interface RoomDmSendPayload {
     conversationId?: string;
     content: string;
     clientMsgId?: string;
+    /** DM-attachment key or legacy public image URL; stored on the message's
+     *  imageUrl. Additive — text-only sends omit it. */
+    imageUrl?: string;
+}
+/** Client → server: edit one of my DM messages (sealed messages are rejected). */
+export interface RoomDmEditPayload {
+    requestId?: string;
+    conversationId?: string;
+    username?: string;
+    messageId: string;
+    content: string;
+}
+/** Client → server: soft-delete one of my DM messages (tombstone in place). */
+export interface RoomDmDeletePayload {
+    requestId?: string;
+    conversationId?: string;
+    username?: string;
+    messageId: string;
+}
+/** Server → both participants: a DM message was edited. */
+export interface RoomDmMessageEditedPayload {
+    conversationId: string;
+    messageId: string;
+    content: string;
+    editedAt: string | number;
+    participant: RoomDmParticipant;
+}
+/** Server → both participants: a DM message was soft-deleted (tombstone). */
+export interface RoomDmMessageDeletedPayload {
+    conversationId: string;
+    messageId: string;
+    deletedAt: string | number;
+    participant: RoomDmParticipant;
+}
+/** Client → server: toggle a reaction on a DM message. */
+export interface RoomDmReactPayload {
+    requestId?: string;
+    conversationId?: string;
+    username?: string;
+    messageId: string;
+    emoji: string;
+    op: "add" | "remove";
+}
+/** Server → both participants: a DM message's aggregated reactions changed. */
+export interface RoomDmReactionUpdatedPayload {
+    conversationId: string;
+    messageId: string;
+    reactions: Array<{
+        emoji: string;
+        users: string[];
+    }>;
+    participant: RoomDmParticipant;
 }
 export interface RoomDmReadPayload {
     requestId?: string;
@@ -975,6 +1038,18 @@ export type RoomClientMessage = {
     type: typeof RoomClientMessageType.DM_READ;
     payload: RoomDmReadPayload;
     timestamp?: number;
+} | {
+    type: typeof RoomClientMessageType.DM_EDIT;
+    payload: RoomDmEditPayload;
+    timestamp?: number;
+} | {
+    type: typeof RoomClientMessageType.DM_DELETE;
+    payload: RoomDmDeletePayload;
+    timestamp?: number;
+} | {
+    type: typeof RoomClientMessageType.DM_REACT;
+    payload: RoomDmReactPayload;
+    timestamp?: number;
 } | {
     type: typeof RoomClientMessageType.TOPIC_CREATE;
     payload: RoomTopicCreatePayload;
@@ -1165,6 +1240,18 @@ export type RoomServerMessage = {
     type: typeof RoomServerMessageType.DM_INBOX_UPDATED;
     payload: RoomDmInboxUpdatedPayload;
     timestamp: number;
+} | {
+    type: typeof RoomServerMessageType.DM_MESSAGE_EDITED;
+    payload: RoomDmMessageEditedPayload;
+    timestamp: number;
+} | {
+    type: typeof RoomServerMessageType.DM_MESSAGE_DELETED;
+    payload: RoomDmMessageDeletedPayload;
+    timestamp: number;
+} | {
+    type: typeof RoomServerMessageType.DM_REACTION_UPDATED;
+    payload: RoomDmReactionUpdatedPayload;
+    timestamp: number;
 } | {
     type: typeof RoomServerMessageType.TOPIC;
     payload: RoomTopicResultPayload;

package/dist/shared/rooms-protocol.js

@@ -38,6 +38,9 @@ export const RoomClientMessageType = {
     DM_HISTORY: "DM_HISTORY",
     DM_SEND: "DM_SEND",
     DM_READ: "DM_READ",
+    DM_EDIT: "DM_EDIT",
+    DM_DELETE: "DM_DELETE",
+    DM_REACT: "DM_REACT",
     TOPIC_CREATE: "TOPIC_CREATE",
     TOPIC_RENAME: "TOPIC_RENAME",
     TOPIC_MOVE: "TOPIC_MOVE",
@@ -86,6 +89,9 @@ export const RoomServerMessageType = {
     DM_HISTORY: "DM_HISTORY",
     DM_MESSAGE: "DM_MESSAGE",
     DM_INBOX_UPDATED: "DM_INBOX_UPDATED",
+    DM_MESSAGE_EDITED: "DM_MESSAGE_EDITED",
+    DM_MESSAGE_DELETED: "DM_MESSAGE_DELETED",
+    DM_REACTION_UPDATED: "DM_REACTION_UPDATED",
     TOPIC: "TOPIC",
     TOPICS: "TOPICS",
     TOPIC_UPDATED: "TOPIC_UPDATED",

package/dist/social-client.d.ts

@@ -175,6 +175,12 @@ export interface RoomSpaceMember {
     /** Named identity roles (RoomSpaceRole.roleId). */
     roleIds?: string[];
     joinedAt?: string;
+    /** The member's handle/username, resolved server-side from their room
+     *  memberships. Absent when the store couldn't resolve a real name (never
+     *  the raw userId). */
+    handle?: string;
+    /** Per-space display name; null or absent means the account username. */
+    nickname?: string | null;
 }
 export declare function getUserPrefs(config: RoomSocialConfig): Promise<Record<string, unknown>>;
 /** Whole-blob replace (16KB cap server-side; last writer wins). */
@@ -321,6 +327,8 @@ export declare function removeSpaceMember(config: RoomSocialConfig, spaceId: str
     removed?: boolean;
 }>;
 export declare function changeSpaceMemberRole(config: RoomSocialConfig, spaceId: string, targetUserId: string, role: "admin" | "member"): Promise<RoomSpaceMember>;
+/** Set (string) or clear (null) a member's per-space nickname; the store validates and enforces uniqueness. */
+export declare function setSpaceMemberNickname(config: RoomSocialConfig, spaceId: string, targetUserId: string, nickname: string | null): Promise<RoomSpaceMember>;
 export declare function createRoomSpace(config: RoomSocialConfig, input: {
     name: string;
     access?: "open" | "invite";

package/dist/social-client.js

@@ -501,6 +501,11 @@ export async function changeSpaceMemberRole(config, spaceId, targetUserId, role)
     const result = await socialRequest(config, `/spaces/${encodeURIComponent(spaceId)}/members/${encodeURIComponent(targetUserId)}/role`, { method: "PATCH", body: { role } });
     return result.member;
 }
+/** Set (string) or clear (null) a member's per-space nickname; the store validates and enforces uniqueness. */
+export async function setSpaceMemberNickname(config, spaceId, targetUserId, nickname) {
+    const result = await socialRequest(config, `/spaces/${encodeURIComponent(spaceId)}/members/${encodeURIComponent(targetUserId)}/nickname`, { method: "PATCH", body: { nickname } });
+    return result.member;
+}
 export async function createRoomSpace(config, input) {
     const result = await socialRequest(config, "/spaces", {
         method: "POST",

package/dist/social-types.d.ts

@@ -112,6 +112,14 @@ export interface RoomDmMessage {
     /** Sealed DM: content is '' and the opaque envelope rides here. */
     secret?: RoomLedgerSecretPayload | null;
     metadata?: Record<string, unknown>;
+    /** DM image: a private dm-attachments/ key (signed on render) or a legacy
+     *  public URL. Additive — old messages carry none. */
+    imageUrl?: string | null;
+    /** Aggregated reactions (per-emoji userId lists). Additive. */
+    reactions?: Array<{
+        emoji: string;
+        users: string[];
+    }>;
 }
 export interface RoomDmHistory {
     conversationId: string;

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.5.0";
-export declare const RUNNER_VERSION = "0.5.0";
+export declare const VERSION = "0.5.1";
+export declare const RUNNER_VERSION = "0.5.1";

package/dist/version.js

@@ -1,2 +1,2 @@
-export const VERSION = "0.5.0";
-export const RUNNER_VERSION = "0.5.0";
+export const VERSION = "0.5.1";
+export const RUNNER_VERSION = "0.5.1";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openmarket/rooms-client",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "OM Rooms protocol client: wire types, WebSocket + REST clients, and chat view-models. Browser-safe (no node:/bun: imports).",
   "type": "module",
   "license": "Apache-2.0",

package/src/agent/armed-mode.ts

@@ -126,15 +126,49 @@ export function makeArmedRoomState(roomId: string, lastSeq = 0): ArmedRoomState
   };
 }
 
+/**
+ * A fresh armed state that CARRIES the cost/rate counters from a prior armed
+ * session of the same room. Disarm/rearm must not zero the cooldown, hourly
+ * window, or session budget: otherwise toggling /disarm + /arm bypasses every
+ * cost guard. Error and chain counters DO reset (rearming is an explicit
+ * operator action; a fresh process still starts with nothing retained).
+ */
+export function rearmedRoomState(
+  roomId: string,
+  retired: ArmedRoomState | null,
+  lastSeq = 0,
+): ArmedRoomState {
+  const state = makeArmedRoomState(roomId, lastSeq);
+  if (!retired || retired.roomId !== roomId) return state;
+  state.postTimes = [...retired.postTimes];
+  state.postsThisSession = retired.postsThisSession;
+  state.tokensThisSession = retired.tokensThisSession;
+  return state;
+}
+
+/** Seqs of the user's own posts in a window of entries; the reply-trigger
+ *  check tests `inReplyTo` against this set. Pure. */
+export function ownSeqsOf(entries: ReadonlyArray<RoomLedgerEntry>, ownUserId: string): Set<number> {
+  const seqs = new Set<number>();
+  for (const entry of entries) {
+    if (entry.userId === ownUserId) seqs.add(entry.seq);
+  }
+  return seqs;
+}
+
 /**
  * Whether a single incoming entry is a qualifying TRIGGER: a NEW human POST in
- * the room that @mentions the user's own handle. Agent posts, system entries,
- * the user's own posts, and non-mentions never trigger. Pure.
+ * the room that @mentions the user's own handle, OR (when `ownSeqs` is given)
+ * directly replies to one of the user's own messages. Reply semantics match a
+ * mention (replying pings the author), so armed mode treats both as addressed
+ * to the user. Agent posts, system entries, the user's own posts, and
+ * non-mentions never trigger. Pure.
  */
 export function isTriggeringEntry(
   entry: RoomLedgerEntry,
   ownHandle: string,
   ownUserId: string,
+  ownSeqs?: ReadonlySet<number>,
 ): boolean {
   if (entry.type !== RoomLedgerEntryType.POST) return false;
   if (entry.isAgent) return false;
@@ -144,6 +178,9 @@ export function isTriggeringEntry(
   const me = normalizeHandle(ownHandle).toLowerCase();
   if (entry.userId === ownUserId) return false;
   if (me.length > 0 && fromHandle === me) return false;
+  // A direct reply to one of our messages is addressed to us. The set only
+  // spans the cached window, so replies to long-scrolled-out posts stay inert.
+  if (entry.inReplyTo !== undefined && ownSeqs?.has(entry.inReplyTo)) return true;
   // Must EXPLICITLY @mention the user's own handle. A bare-substring match (the
   // old mentionsAgent) fired on ordinary words for short handles like "may" /
   // "btc"; armed posting has no human review, so it triggers ONLY on an `@handle`
@@ -154,18 +191,22 @@ export function isTriggeringEntry(
 /**
  * The newest qualifying trigger among entries strictly newer than
  * `afterSeq`, or null if none. Used by the loop to decide whether the latest
- * batch of room messages contains a reason to act. Pure.
+ * batch of room messages contains a reason to act. Reply triggers resolve
+ * against the user's own seqs within `entries` unless a wider `ownSeqs`
+ * window is supplied (the live single-entry path passes the room cache).
+ * Pure.
  */
 export function findTrigger(
   entries: ReadonlyArray<RoomLedgerEntry>,
   ownHandle: string,
   ownUserId: string,
   afterSeq: number,
+  ownSeqs: ReadonlySet<number> = ownSeqsOf(entries, ownUserId),
 ): RoomLedgerEntry | null {
   let found: RoomLedgerEntry | null = null;
   for (const entry of entries) {
     if (entry.seq <= afterSeq) continue;
-    if (isTriggeringEntry(entry, ownHandle, ownUserId)) found = entry;
+    if (isTriggeringEntry(entry, ownHandle, ownUserId, ownSeqs)) found = entry;
   }
   return found;
 }

package/src/client.ts

@@ -284,6 +284,10 @@ export interface RoomDmSendRequest {
   conversationId?: string;
   content: string;
   clientMsgId?: string;
+  /** A private DM-attachment key (dm-attachments/…) or a legacy public image
+   *  URL. Stored on the message's imageUrl; the client signs keys on render.
+   *  Additive — omitted for text-only sends. */
+  imageUrl?: string;
 }
 
 export interface RoomThreadRequest {
@@ -931,6 +935,7 @@ export async function sendRoomDmOnClient(
       clientMsgId,
       ...(request.username ? { username: request.username } : {}),
       ...(request.conversationId ? { conversationId: request.conversationId } : {}),
+      ...(request.imageUrl ? { imageUrl: request.imageUrl } : {}),
     },
     timestamp: Date.now(),
   });
@@ -946,6 +951,64 @@ export async function sendRoomDmOnClient(
   return sent.payload;
 }
 
+/** Edit one of my DM messages. Fire-and-forget over the WS; the relay fans out
+ *  DM_MESSAGE_EDITED to both participants. */
+export function editRoomDmOnClient(
+  client: RoomWsClient,
+  request: { conversationId?: string; username?: string; messageId: string; content: string },
+): void {
+  client.send({
+    type: RoomClientMessageType.DM_EDIT,
+    payload: {
+      messageId: request.messageId,
+      content: request.content,
+      ...(request.conversationId ? { conversationId: request.conversationId } : {}),
+      ...(request.username ? { username: request.username } : {}),
+    },
+    timestamp: Date.now(),
+  });
+}
+
+/** Soft-delete one of my DM messages. The relay fans out DM_MESSAGE_DELETED. */
+export function deleteRoomDmOnClient(
+  client: RoomWsClient,
+  request: { conversationId?: string; username?: string; messageId: string },
+): void {
+  client.send({
+    type: RoomClientMessageType.DM_DELETE,
+    payload: {
+      messageId: request.messageId,
+      ...(request.conversationId ? { conversationId: request.conversationId } : {}),
+      ...(request.username ? { username: request.username } : {}),
+    },
+    timestamp: Date.now(),
+  });
+}
+
+/** Toggle a reaction on a DM message. The relay fans out DM_REACTION_UPDATED. */
+export function reactRoomDmOnClient(
+  client: RoomWsClient,
+  request: {
+    conversationId?: string;
+    username?: string;
+    messageId: string;
+    emoji: string;
+    op: "add" | "remove";
+  },
+): void {
+  client.send({
+    type: RoomClientMessageType.DM_REACT,
+    payload: {
+      messageId: request.messageId,
+      emoji: request.emoji,
+      op: request.op,
+      ...(request.conversationId ? { conversationId: request.conversationId } : {}),
+      ...(request.username ? { username: request.username } : {}),
+    },
+    timestamp: Date.now(),
+  });
+}
+
 export async function peekRoom(
   config: RoomClientConfig,
   options: RoomPeekOptions,

package/src/shared/rooms-protocol.ts

@@ -38,6 +38,9 @@ export const RoomClientMessageType = {
   DM_HISTORY: "DM_HISTORY",
   DM_SEND: "DM_SEND",
   DM_READ: "DM_READ",
+  DM_EDIT: "DM_EDIT",
+  DM_DELETE: "DM_DELETE",
+  DM_REACT: "DM_REACT",
   TOPIC_CREATE: "TOPIC_CREATE",
   TOPIC_RENAME: "TOPIC_RENAME",
   TOPIC_MOVE: "TOPIC_MOVE",
@@ -90,6 +93,9 @@ export const RoomServerMessageType = {
   DM_HISTORY: "DM_HISTORY",
   DM_MESSAGE: "DM_MESSAGE",
   DM_INBOX_UPDATED: "DM_INBOX_UPDATED",
+  DM_MESSAGE_EDITED: "DM_MESSAGE_EDITED",
+  DM_MESSAGE_DELETED: "DM_MESSAGE_DELETED",
+  DM_REACTION_UPDATED: "DM_REACTION_UPDATED",
   TOPIC: "TOPIC",
   TOPICS: "TOPICS",
   TOPIC_UPDATED: "TOPIC_UPDATED",
@@ -527,6 +533,11 @@ export interface RoomDmMessage {
   /** Sealed DM: content is '' and the opaque envelope rides here. */
   secret?: RoomLedgerSecretPayload | null | undefined;
   metadata?: Record<string, unknown> | undefined;
+  /** Legacy public chat-image URL (renders as-is, no signing). */
+  imageUrl?: string | null | undefined;
+  /** Private, signed, scanned DM attachments (dm-attachments/ keyspace).
+   *  Additive: old messages carry none and render unchanged. */
+  attachments?: RoomAttachment[] | undefined;
 }
 
 export interface RoomDmOpenPayload {
@@ -551,6 +562,61 @@ export interface RoomDmSendPayload {
   conversationId?: string;
   content: string;
   clientMsgId?: string;
+  /** DM-attachment key or legacy public image URL; stored on the message's
+   *  imageUrl. Additive — text-only sends omit it. */
+  imageUrl?: string;
+}
+
+/** Client → server: edit one of my DM messages (sealed messages are rejected). */
+export interface RoomDmEditPayload {
+  requestId?: string;
+  conversationId?: string;
+  username?: string;
+  messageId: string;
+  content: string;
+}
+
+/** Client → server: soft-delete one of my DM messages (tombstone in place). */
+export interface RoomDmDeletePayload {
+  requestId?: string;
+  conversationId?: string;
+  username?: string;
+  messageId: string;
+}
+
+/** Server → both participants: a DM message was edited. */
+export interface RoomDmMessageEditedPayload {
+  conversationId: string;
+  messageId: string;
+  content: string;
+  editedAt: string | number;
+  participant: RoomDmParticipant;
+}
+
+/** Server → both participants: a DM message was soft-deleted (tombstone). */
+export interface RoomDmMessageDeletedPayload {
+  conversationId: string;
+  messageId: string;
+  deletedAt: string | number;
+  participant: RoomDmParticipant;
+}
+
+/** Client → server: toggle a reaction on a DM message. */
+export interface RoomDmReactPayload {
+  requestId?: string;
+  conversationId?: string;
+  username?: string;
+  messageId: string;
+  emoji: string;
+  op: "add" | "remove";
+}
+
+/** Server → both participants: a DM message's aggregated reactions changed. */
+export interface RoomDmReactionUpdatedPayload {
+  conversationId: string;
+  messageId: string;
+  reactions: Array<{ emoji: string; users: string[] }>;
+  participant: RoomDmParticipant;
 }
 
 export interface RoomDmReadPayload {
@@ -1085,6 +1151,21 @@ export type RoomClientMessage =
       payload: RoomDmReadPayload;
       timestamp?: number;
     }
+  | {
+      type: typeof RoomClientMessageType.DM_EDIT;
+      payload: RoomDmEditPayload;
+      timestamp?: number;
+    }
+  | {
+      type: typeof RoomClientMessageType.DM_DELETE;
+      payload: RoomDmDeletePayload;
+      timestamp?: number;
+    }
+  | {
+      type: typeof RoomClientMessageType.DM_REACT;
+      payload: RoomDmReactPayload;
+      timestamp?: number;
+    }
   | {
       type: typeof RoomClientMessageType.TOPIC_CREATE;
       payload: RoomTopicCreatePayload;
@@ -1317,6 +1398,21 @@ export type RoomServerMessage =
       payload: RoomDmInboxUpdatedPayload;
       timestamp: number;
     }
+  | {
+      type: typeof RoomServerMessageType.DM_MESSAGE_EDITED;
+      payload: RoomDmMessageEditedPayload;
+      timestamp: number;
+    }
+  | {
+      type: typeof RoomServerMessageType.DM_MESSAGE_DELETED;
+      payload: RoomDmMessageDeletedPayload;
+      timestamp: number;
+    }
+  | {
+      type: typeof RoomServerMessageType.DM_REACTION_UPDATED;
+      payload: RoomDmReactionUpdatedPayload;
+      timestamp: number;
+    }
   | {
       type: typeof RoomServerMessageType.TOPIC;
       payload: RoomTopicResultPayload;

package/src/social-client.ts

@@ -658,6 +658,12 @@ export interface RoomSpaceMember {
   /** Named identity roles (RoomSpaceRole.roleId). */
   roleIds?: string[];
   joinedAt?: string;
+  /** The member's handle/username, resolved server-side from their room
+   *  memberships. Absent when the store couldn't resolve a real name (never
+   *  the raw userId). */
+  handle?: string;
+  /** Per-space display name; null or absent means the account username. */
+  nickname?: string | null;
 }
 
 export async function getUserPrefs(config: RoomSocialConfig): Promise<Record<string, unknown>> {
@@ -1048,6 +1054,21 @@ export async function changeSpaceMemberRole(
   return result.member;
 }
 
+/** Set (string) or clear (null) a member's per-space nickname; the store validates and enforces uniqueness. */
+export async function setSpaceMemberNickname(
+  config: RoomSocialConfig,
+  spaceId: string,
+  targetUserId: string,
+  nickname: string | null,
+): Promise<RoomSpaceMember> {
+  const result = await socialRequest<{ member: RoomSpaceMember }>(
+    config,
+    `/spaces/${encodeURIComponent(spaceId)}/members/${encodeURIComponent(targetUserId)}/nickname`,
+    { method: "PATCH", body: { nickname } },
+  );
+  return result.member;
+}
+
 export async function createRoomSpace(
   config: RoomSocialConfig,
   input: { name: string; access?: "open" | "invite" },

package/src/social-types.ts

@@ -126,6 +126,11 @@ export interface RoomDmMessage {
   /** Sealed DM: content is '' and the opaque envelope rides here. */
   secret?: RoomLedgerSecretPayload | null;
   metadata?: Record<string, unknown>;
+  /** DM image: a private dm-attachments/ key (signed on render) or a legacy
+   *  public URL. Additive — old messages carry none. */
+  imageUrl?: string | null;
+  /** Aggregated reactions (per-emoji userId lists). Additive. */
+  reactions?: Array<{ emoji: string; users: string[] }>;
 }
 
 export interface RoomDmHistory {

package/src/version.ts

@@ -1,2 +1,2 @@
-export const VERSION = "0.5.0";
-export const RUNNER_VERSION = "0.5.0";
+export const VERSION = "0.5.1";
+export const RUNNER_VERSION = "0.5.1";