@ai-matrx/messaging 0.12.5 → 0.13.1

package/CHANGELOG.md

@@ -1,5 +1,48 @@
 # Changelog — `@ai-matrx/messaging`
 
+## 0.13.1
+
+### Fixed
+
+- **Opening an unavailable conversation no longer loops.** 0.13.0 cleared a
+  conversation's read failure at the START of every `openConversation`, so a
+  second holder (the page and its thread pane both calling `useConversation`)
+  flipped `unavailable` back to false while its read was in flight. A host that
+  swaps the thread for an access surface on that flag remounted the thread,
+  which re-opened, which cleared it again — "Maximum update depth exceeded" on
+  matrx-frontend `/messages/<id>`. The failure is now replaced only by the next
+  answer.
+
+### Consumer action
+
+- None — adopt the release.
+
+## 0.13.0
+
+### Added
+
+- **A conversation that cannot be read now says so.** Opening a conversation the
+  caller may not read (a refused message read) used to leave the thread absent
+  forever — an endless spinner — and a zero-row read of a conversation that does
+  not exist or is hidden by RLS rendered "No messages yet". The engine now
+  records a per-conversation read failure in the store
+  (`snapshot.conversationReadFailures`, type `ConversationReadFailure`); on a
+  zero-row read it asks the conversation row itself (`getConversation(id)`)
+  before calling the thread empty, and opens no realtime channel for a
+  conversation the user cannot read.
+- `useConversation(id)` gains `error: MessagingError | null` and
+  `unavailable: boolean` (additive). `isLoading` is now false once the read has
+  failed. `<ConversationView>` renders "Conversation unavailable" /
+  "Couldn't load this conversation" instead of the spinner or the empty state.
+
+### Consumer action
+
+- Hosts with an access surface: when `useConversation(id).unavailable` is true,
+  render it instead of the thread. `error.cause` is the raw database error
+  (`42501`, `PGRST116`) for hosts that classify access failures themselves
+  (matrx-frontend: `<AccessGate token="dm_conversation" id error={error.cause} />`).
+- No action otherwise — existing fields are unchanged.
+
 ## 0.12.5
 
 Automatic changed-only republish (docs/metadata drift since the last tag — see

package/dist/index.cjs

@@ -1044,6 +1044,7 @@ function createMessagingStore() {
   let archivedCount = null;
   let threads = /* @__PURE__ */ new Map();
   let activeConversationId = null;
+  let conversationReadFailures = /* @__PURE__ */ new Map();
   const listeners = /* @__PURE__ */ new Set();
   let cached = null;
   function snapshot() {
@@ -1056,7 +1057,8 @@ function createMessagingStore() {
       activeConversationId,
       totalUnreadConversations: conversations.filter((item) => item.unreadCount > 0).length,
       archiveFilter,
-      archivedCount
+      archivedCount,
+      conversationReadFailures
     };
     return cached;
   }
@@ -1140,6 +1142,14 @@ function createMessagingStore() {
       conversations = normalizeConversations(conversations);
       emit();
     },
+    setConversationReadFailure(id, failure) {
+      if (failure === null && !conversationReadFailures.has(id)) return;
+      const next = new Map(conversationReadFailures);
+      if (failure === null) next.delete(id);
+      else next.set(id, failure);
+      conversationReadFailures = next;
+      emit();
+    },
     setThread(id, messages, args = {}) {
       writeThread({
         conversationId: id,
@@ -1447,9 +1457,24 @@ function createMessagingEngine(options) {
       store.setActiveConversation(id);
       try {
         const page = await repository.listMessages(id, { limit: messagePageSize });
+        if (page.items.length === 0) {
+          await repository.getConversation(id);
+        }
+        store.setConversationReadFailure(id, null);
         store.setThread(id, page.items, { hasMoreOlder: page.hasMore });
       } catch (error) {
-        reportError(error, "openConversation");
+        const normalized = normalizeMessagingError(error, "openConversation");
+        const unavailable = normalized.code === "not-found" || normalized.code === "forbidden";
+        store.setConversationReadFailure(id, { error: normalized, unavailable });
+        if (unavailable) {
+          report({
+            level: "warn",
+            message: normalized.message,
+            remedy: normalized.remedy
+          });
+          return;
+        }
+        reportError(normalized, "openConversation");
       }
       if (openChannels.has(id) || disposed) return;
       const handle = manager.open({