@ai-matrx/messaging 0.11.1 → 0.11.3

package/CHANGELOG.md

@@ -1,5 +1,50 @@
 # Changelog — `@ai-matrx/messaging`
 
+## 0.11.3 — 2026-09-12
+
+### Fixed
+
+- **"listConversations: deadlock detected" on the inbox's first load.** An independent
+  reviewer opening `/chat` on 2026-09-12 got that banner from the messaging surface; a reload
+  worked. The read writes nothing — `get_dm_conversations_with_details` is `STABLE` on the live
+  database and so is `get_dm_unread_count`. A pure read still joins a deadlock cycle whenever a
+  concurrent DDL session (migrations apply against live traffic here all day; four applied in the
+  ten minutes around the sighting) wants `AccessExclusiveLock` on a table the read already holds
+  `AccessShareLock` on, and Postgres kills whichever party's `deadlock_timeout` expires first —
+  often the reader. Reproduced on a throwaway Postgres 17: a two-statement read-only transaction
+  against one `lock table … access exclusive` + `alter table` session dies `40P01` with
+  `waits for AccessShareLock … blocked by …` — the same DETAIL shape the platform logged for
+  `chat.conversation` the same day.
+  `normalizeMessagingError` now classifies `40P01`, `40001` and `55P03` as a new `contention`
+  code, and the repository's one retry became two: the cancelled call is re-issued up to three
+  times with a short jittered backoff (the victim is rolled back in full, so re-running is safe —
+  for writes too), and **every heal announces itself** through the new `onDiagnostic` option,
+  which the React provider wires to the host's diagnostics as a warning. Only an exhausted retry
+  budget reaches a person, and it no longer speaks Postgres at them. `core/repository.test.ts`
+  pins all four behaviours, including that a `42501` is never retried as contention.
+
+### Consumer action (C28)
+
+None required. A host that builds a repository directly may pass `onDiagnostic` to see the heals;
+`<MessagingProvider>` already does.
+
+## 0.11.2 — 2026-09-11
+
+### Fixed
+
+- **The AI answer was squeezed to a sliver.** `.mx-msg__ai-output` capped itself at `30dvh`
+  with `overflow-y: auto`, but declared no `flex-shrink: 0` inside `.mx-msg__thread`'s flex
+  column — whose scroll region is `flex: 1 1 auto` with a content-sized basis. In the first
+  live "Catch me up" run in matrx-frontend (2026-09-11) the answer rendered as a 45px box holding
+  270px of text and no visible scrollbar: a complete answer the reader could not see. The same
+  hole was open on `.mx-msg__ai-bar`. Both now declare `flex: 0 0 auto`, and
+  `src/react/thread-rows.test.ts` pins every fixed row of the thread column (header, AI bar, AI
+  output, composer) so the next fixed row cannot re-open the class.
+
+### Consumer action (C28)
+
+None. Upgrade to receive the stylesheet fix; no API changed.
+
 ## 0.11.1
 
 Automatic changed-only republish (docs/metadata drift since the last tag — see

package/dist/index.cjs

@@ -229,14 +229,15 @@ var MessagingError = class extends Error {
     this.remedy = remedy;
     if (cause !== void 0) this.cause = cause;
   }
-  /** True when retrying after the host re-establishes a session is the fix. */
+  /** True when re-running the same call is the fix. */
   get isRetryable() {
-    return this.code === "session-unavailable" || this.code === "transport";
+    return this.code === "session-unavailable" || this.code === "contention" || this.code === "transport";
   }
 };
 var FORBIDDEN_CODES = /* @__PURE__ */ new Set(["42501", "PGRST301", "PGRST302"]);
 var NOT_FOUND_CODES = /* @__PURE__ */ new Set(["PGRST116", "PGRST205"]);
 var CONFLICT_CODES = /* @__PURE__ */ new Set(["23505"]);
+var CONTENTION_CODES = /* @__PURE__ */ new Set(["40P01", "40001", "55P03"]);
 var SESSION_MARKERS = [
   "auth session missing",
   "jwt expired",
@@ -258,6 +259,14 @@ function normalizeMessagingError(error, operation) {
       error
     );
   }
+  if (code !== void 0 && CONTENTION_CODES.has(code)) {
+    return new MessagingError(
+      "contention",
+      `${operation}: the database resolved a lock collision by cancelling this call (${code}: ${message})`,
+      "Nothing of this call committed, so it is safe to re-run \u2014 the package re-runs it a bounded number of times and announces each heal. Seeing it repeatedly means real contention on the messaging tables (usually DDL applied against live traffic); look at what else held a lock at that moment, never at the caller.",
+      error
+    );
+  }
   if (code !== void 0 && FORBIDDEN_CODES.has(code)) {
     return new MessagingError(
       "forbidden",
@@ -285,7 +294,7 @@ function normalizeMessagingError(error, operation) {
   return new MessagingError(
     "transport",
     `${operation}: ${message}`,
-    "Transient transport failure. The package retries reads; a write is surfaced to the outbox so the typed message is never lost.",
+    "Transient transport failure. A typed message is surfaced to the outbox so it is never lost; a read is the caller's to re-issue (only `contention` and `session-unavailable` are re-run inside the package).",
     error
   );
 }
@@ -1681,6 +1690,12 @@ function requireOrg(organizationId, operation) {
   }
   return organizationId;
 }
+var CONTENTION_ATTEMPTS = 3;
+var CONTENTION_BACKOFF_MS = [60, 180];
+function sleep(ms) {
+  const jittered = ms + Math.random() * ms * 0.5;
+  return new Promise((resolve) => setTimeout(resolve, jittered));
+}
 function createMessagingRepository(options) {
   const { identity } = options;
   const org = requireOrg(identity.organizationId, "createMessagingRepository");
@@ -1692,18 +1707,31 @@ function createMessagingRepository(options) {
   const db = () => client.schema(MESSAGING_SCHEMA);
   const rpcDb = () => client.schema(MESSAGING_RPC_SCHEMA);
   async function withSessionRetry(operation, run) {
-    try {
-      return await run();
-    } catch (error) {
-      const normalized = normalizeMessagingError(error, operation);
-      if (normalized.code !== "session-unavailable" || options.resolveSession === void 0) {
-        throw normalized;
-      }
-      await options.resolveSession();
+    let sessionRetried = false;
+    for (let attempt = 1; ; attempt += 1) {
       try {
-        return await run();
-      } catch (retryError) {
-        throw normalizeMessagingError(retryError, operation);
+        const value = await run();
+        if (attempt > 1) {
+          options.onDiagnostic?.(
+            `${operation}: healed on attempt ${attempt} after a database lock collision (rolled back, safe to re-run).`
+          );
+        }
+        return value;
+      } catch (error) {
+        const normalized = normalizeMessagingError(error, operation);
+        if (normalized.code === "session-unavailable" && options.resolveSession !== void 0 && !sessionRetried) {
+          sessionRetried = true;
+          await options.resolveSession();
+          continue;
+        }
+        if (normalized.code === "contention" && attempt < CONTENTION_ATTEMPTS) {
+          options.onDiagnostic?.(
+            `${operation}: attempt ${attempt}/${CONTENTION_ATTEMPTS} hit a database lock collision (${normalized.message}) \u2014 re-running in ${CONTENTION_BACKOFF_MS[attempt - 1] ?? 0}ms.`
+          );
+          await sleep(CONTENTION_BACKOFF_MS[attempt - 1] ?? 0);
+          continue;
+        }
+        throw normalized;
       }
     }
   }