@pmate/chat-sdk 0.12.0-next.85 → 0.12.0-next.87

package/lib/chatError.d.ts

@@ -2,6 +2,14 @@ export type ChatErrorCode = "unavailable" | "access-denied" | "authentication-re
 /** Stable recovery categories. The original failure remains available as cause. */
 export declare class ChatError extends Error {
     readonly code: ChatErrorCode;
+    readonly diagnostic?: {
+        source: string;
+        stage?: string;
+        database?: string;
+        tables?: string;
+        mode?: string;
+        attempt?: number;
+    };
     readonly retryable: boolean;
     readonly status?: number;
     /** Present only when access was denied for one conversation, not the Team. */
@@ -10,5 +18,6 @@ export declare class ChatError extends Error {
         cause?: unknown;
         status?: number;
         threadId?: string;
+        diagnostic?: ChatError["diagnostic"];
     });
 }

package/lib/chatError.js

@@ -1,6 +1,7 @@
 /** Stable recovery categories. The original failure remains available as cause. */
 export class ChatError extends Error {
     code;
+    diagnostic;
     retryable;
     status;
     /** Present only when access was denied for one conversation, not the Team. */
@@ -11,6 +12,7 @@ export class ChatError extends Error {
         this.name = "ChatError";
         this.status = options.status;
         this.threadId = options.threadId;
+        this.diagnostic = options.diagnostic;
         this.retryable = ["unavailable", "storage-unavailable", "busy"].includes(code);
     }
 }

package/lib/runtime/chatError.js

@@ -11,7 +11,7 @@ export function asChatError(error) {
                 : /BACKPRESSURE|TOO_LARGE/.test(message) ? "busy"
                     : status === 400 || /INVALID_|CONVERSATION_MISMATCH|CONVERSATION_UNKNOWN|NOT_OWNED/.test(message) ? "invalid-input"
                         : /QuotaExceeded|DatabaseClosed|UnknownError|AbortError/.test(value?.name ?? "") || /STORAGE_|DATABASE_|CACHE_WRITE/.test(message) ? "storage-unavailable" : "unavailable";
-    return new ChatError(code, message, { cause: error, status, threadId: value?.threadId });
+    return new ChatError(code, message, { cause: error, status, threadId: value?.threadId, diagnostic: value?.diagnostic });
 }
 /** Keep a conversation denial distinct from loss of Team authority. */
 export function threadChatError(error, threadId) {

package/lib/runtime/chatSession.js

@@ -156,8 +156,16 @@ export class ChatSession {
                     this.groups?.hint({ id: groupThreadId(scope.appId, message.to, scope.teamId), kind: "group", targetId: message.to, teamId: scope.teamId }, Number.isSafeInteger(body.payload.versionNumber) ? body.payload.versionNumber : undefined);
                 }
                 const decoded = options.decode(message);
+                // A peer can react before history returns our own ACKed source message.
+                // Discussion windows store controls against canonical target IDs; retain
+                // the known sent local target in the same atomic receive batch so the
+                // reaction is visible without waiting for another network history read.
+                const control = message.body?.content;
+                const targetId = control?.reaction?.messageId ?? control?.recall?.messageId;
+                const outgoing = decoded && targetId ? this.sender.snapshot(decoded.threadId).find(record => record.hash === targetId && record.status === 'sent' && record.message.from === scope.profileId) : undefined;
+                const localTarget = outgoing && options.decode(outgoing.message);
                 if (decoded)
-                    void this.messages.receive(decoded.threadId, [decoded]).then(async () => {
+                    void this.messages.receive(decoded.threadId, localTarget ? [localTarget, decoded] : [decoded]).then(async () => {
                         if (!this.closed && this.readingStarted)
                             this.reading.refresh();
                         if (message.from === scope.profileId)

package/lib/runtime/indexedDbRecovery.d.ts

@@ -1,4 +1,6 @@
 import type { Dexie } from "dexie";
 /** WebKit can invalidate an IDB connection while the application is suspended.
  * Only replay a whole rejected transaction; never replay individual requests or clear data. */
-export declare function recoverableTransactions(db: Dexie, isClosed: () => boolean): Dexie["transaction"];
+export declare function recoverableTransactions(db: Dexie, isClosed: () => boolean, options?: {
+    retryAbort?: boolean;
+}): Dexie["transaction"];

package/lib/runtime/indexedDbRecovery.js

@@ -1,16 +1,31 @@
 /** WebKit can invalidate an IDB connection while the application is suspended.
  * Only replay a whole rejected transaction; never replay individual requests or clear data. */
-export function recoverableTransactions(db, isClosed) {
-    const transaction = (...args) => db.transaction.apply(db, args);
+export function recoverableTransactions(db, isClosed, options = {}) {
+    const transaction = async (args, attempt) => {
+        try {
+            return await db.transaction.apply(db, args);
+        }
+        catch (cause) {
+            const original = cause;
+            const error = new Error(original.message, { cause });
+            error.name = original.name;
+            Object.assign(error, { status: original.status, threadId: original.threadId, inner: original.inner, diagnostic: { source: "storage", database: db.name, tables: args.slice(1, -1).flat().map((table) => table.name ?? String(table)).join(","), mode: String(args[0]), attempt } });
+            throw error;
+        }
+    };
     let recovery;
     return (async (...args) => {
         try {
-            return await transaction(...args);
+            return await transaction(args, 1);
         }
         catch (error) {
             const failure = error;
-            if (isClosed() || !(failure.name === "UnknownError" || failure.inner?.name === "UnknownError") || !/without an in-progress transaction/i.test(failure.message ?? ""))
+            const aborted = options.retryAbort && (failure.name === "AbortError" || failure.inner?.name === "AbortError");
+            if (isClosed() || !aborted && (!(failure.name === "UnknownError" || failure.inner?.name === "UnknownError") || !/without an in-progress transaction/i.test(failure.message ?? "")))
                 throw error;
+            // An aborted transaction has already rolled back; replay without closing other live transactions.
+            if (aborted)
+                return transaction(args, 2);
             if (!recovery) {
                 db.close({ disableAutoOpen: false });
                 const opening = db.open();
@@ -21,7 +36,7 @@ export function recoverableTransactions(db, isClosed) {
             await recovery;
             if (isClosed())
                 throw error;
-            return transaction(...args);
+            return transaction(args, 2);
         }
     });
 }

package/lib/runtime/readCounts.d.ts

@@ -44,6 +44,7 @@ export declare class ReadCountsClient {
     private requestedRevision;
     private force;
     constructor(options: ReadCountsOptions);
+    private report;
     private denyCache;
     private post;
     private subscription;

package/lib/runtime/readCounts.js

@@ -1,3 +1,4 @@
+import { asChatError, ChatError } from "./chatError.js";
 import { isOffline, isOfflineNetworkFailure } from "./connectivity.js";
 import { IndexedDbResponseCache, isResponseCacheAuthorityError, assertResponseCacheAccess } from "./responseCache.js";
 import { messageScopeKey } from "./messageStore.js";
@@ -38,14 +39,18 @@ export class ReadCountsClient {
         if (options.scope) {
             if (options.scope.appId !== options.appId || options.scope.profileId !== options.profileId)
                 throw new Error("READ_COUNTS_SCOPE_MISMATCH");
-            this.cache = new IndexedDbResponseCache(messageScopeKey(options.scope), { access: options.access });
+            this.cache = new IndexedDbResponseCache(messageScopeKey(options.scope), { access: options.access, retryAbort: true });
         }
     }
+    report(error, stage) {
+        const failure = asChatError(error);
+        this.options.onError?.(new ChatError(failure.code, failure.message, { cause: error, status: failure.status, threadId: failure.threadId, diagnostic: { ...failure.diagnostic, source: "read-counts", stage } }));
+    }
     denyCache() {
         this.revoked = true;
         this.accessVersion++;
         this.lastResult = undefined;
-        void this.cache?.invalidate().catch(error => this.options.onError?.(error));
+        void this.cache?.invalidate().catch(error => this.report(error, "cache.invalidate"));
     }
     async post(path, body, signal) {
         const scopeVersion = this.options.access ? await assertResponseCacheAccess(this.options.access) : undefined;
@@ -102,7 +107,7 @@ export class ReadCountsClient {
                 this.heartbeat = undefined;
             }
             if (!isOfflineNetworkFailure(error))
-                this.options.onError?.(error);
+                this.report(error, "subscription.renew");
         }).finally(() => { if (this.subscriptionPending === pending)
             this.subscriptionPending = undefined; });
         this.subscriptionPending = pending;
@@ -137,7 +142,7 @@ export class ReadCountsClient {
         this.subscribed = false;
         this.subscriptionDenied = false;
         if (old)
-            void this.subscription(old, true).catch(error => this.options.onError?.(error));
+            void this.subscription(old, true).catch(error => this.report(error, "subscription.release"));
         if (!threadId)
             return;
         this.renew();
@@ -190,7 +195,7 @@ export class ReadCountsClient {
         const key = JSON.stringify(["counts", threadId, [...ids].sort()]);
         try {
             const stored = this.cache ? await this.cache.read(key).catch(error => { if (isResponseCacheAuthorityError(error))
-                throw error; this.options.onError?.(error); return undefined; }) : undefined;
+                throw error; this.report(error, "cache.read"); return undefined; }) : undefined;
             if (generation !== this.generation || this.closed || accessVersion !== this.accessVersion)
                 return;
             const cached = this.revoked || (stored?.cached && stored.cached.value.revision < this.revision) ? undefined : stored?.cached;
@@ -214,7 +219,7 @@ export class ReadCountsClient {
             this.revoked = false;
             if (stored)
                 await this.cache?.write(key, value, stored.epoch).catch(error => { if (isResponseCacheAuthorityError(error))
-                    throw error; this.options.onError?.(error); });
+                    throw error; this.report(error, "cache.write"); });
             if (generation !== this.generation || this.closed || accessVersion !== this.accessVersion)
                 return;
             this.revision = value.revision;
@@ -237,7 +242,7 @@ export class ReadCountsClient {
                     clearInterval(this.heartbeat);
                     this.heartbeat = undefined;
                 }
-                this.options.onError?.(error);
+                this.report(error, "counts.request");
                 if (!isResponseCacheAuthorityError(error) && (!/READ_COUNTS_HTTP_4\d\d|INVALID_READ_COUNTS/.test(String(error)) || /READ_COUNTS_HTTP_(409|429)/.test(String(error))) && this.retries < 3) {
                     retryDelay = 1000 * 2 ** this.retries++;
                     this.dirty = true;
@@ -265,6 +270,6 @@ export class ReadCountsClient {
         if (old)
             void this.subscription(old, true).catch(() => { });
         this.thread = undefined;
-        return this.closing = this.cache?.close().catch(error => this.options.onError?.(error)) ?? Promise.resolve();
+        return this.closing = this.cache?.close().catch(error => this.report(error, "cache.close")) ?? Promise.resolve();
     }
 }

package/lib/runtime/responseCache.d.ts

@@ -5,6 +5,7 @@ export type ResponseCacheAccess = () => Promise<{
 export declare function isResponseCacheAuthorityError(error: unknown): boolean;
 export declare function assertResponseCacheAccess(access?: ResponseCacheAccess, expectedVersion?: number): Promise<number | undefined>;
 export type ResponseCacheOptions<T> = {
+    retryAbort?: boolean;
     indexedDB?: IDBFactory;
     name?: string;
     access?: ResponseCacheAccess;

package/lib/runtime/responseCache.js

@@ -36,7 +36,7 @@ export class IndexedDbResponseCache {
             if (!Number.isSafeInteger(value) || value < 1 || value > max)
                 throw new Error("INVALID_RESPONSE_CACHE_LIMIT");
         this.db = new Dexie(options.name ?? "pmate-chat-response-windows", { indexedDB: options.indexedDB ?? globalThis.indexedDB, IDBKeyRange: globalThis.IDBKeyRange });
-        this.transact = recoverableTransactions(this.db, () => this.closed);
+        this.transact = recoverableTransactions(this.db, () => this.closed, { retryAbort: options.retryAbort });
         this.db.version(1).stores({ windows: "[scope+key],scope", epochs: "scope" });
         this.rows = this.db.table("windows");
         this.epochs = this.db.table("epochs");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmate/chat-sdk",
-  "version": "0.12.0-next.85",
+  "version": "0.12.0-next.87",
   "description": "Local-first chat SDK, message subscriptions, reading state, and shared chat UI primitives",
   "type": "module",
   "main": "./lib/index.js",