@pmate/chat-sdk 0.12.0-next.50 → 0.12.0-next.52

package/lib/runtime/chatSession.d.ts

@@ -115,6 +115,7 @@ export declare class ChatSession<T extends StoredMessage> {
         all?: boolean;
         refresh?: boolean;
     }): Promise<MessageSnapshot<T>>;
+    private confirmMessages;
     private rememberHistoryEdge;
     private readEarlier;
     private readAll;

package/lib/runtime/chatSession.js

@@ -104,7 +104,8 @@ export class ChatSession {
                     void this.messages.receive(decoded.threadId, [decoded]).then(async () => {
                         if (!this.closed && this.readingStarted)
                             this.reading.refresh();
-                        await this.sender.confirm([message.hash]);
+                        if (message.from === scope.profileId)
+                            await this.sender.confirm([message.hash]);
                     }).catch(error => { if (String(error).includes("MESSAGE_PROJECTION_CHANGED"))
                         this.messages.invalidate(decoded.threadId);
                     else if (!this.closed)
@@ -254,7 +255,7 @@ export class ChatSession {
         }
         const page = await (options.before ? this.messages.earlier(threadId, options.before, options.limit) : this.messages.read(threadId, options.limit));
         this.assertOpen();
-        await this.sender.confirm(page.messages.map(message => message.id));
+        await this.confirmMessages(page.messages);
         if (this.initializing && !this.readingStarted && page.complete)
             await this.startReading();
         this.assertOpen();
@@ -263,6 +264,16 @@ export class ChatSession {
             this.rememberHistoryEdge(threadId, page);
         return page;
     }
+    async confirmMessages(messages) {
+        await this.sender.initialize();
+        // Only this profile can create its outgoing wire hashes. Keep the legacy
+        // fallback when a generic host has not supplied an author on stored rows.
+        const hashes = messages.filter(message => {
+            const from = message.from;
+            return typeof from !== "string" || !from || from === this.options.messages.scope.profileId;
+        }).map(message => message.id);
+        return hashes.length ? this.sender.confirm(hashes) : Promise.resolve();
+    }
     rememberHistoryEdge(threadId, page) {
         const first = page.messages[0];
         this.historyEdges.set(threadId, { before: first ? { timestamp: first.timestamp, id: first.id } : undefined, version: page.resetVersion, hasEarlier: page.hasEarlier });
@@ -281,7 +292,7 @@ export class ChatSession {
             if (!edge.before)
                 throw new Error("MESSAGE_SYNC_NO_PROGRESS");
             const page = await this.messages.earlier(threadId, edge.before, 100, true);
-            await this.sender.confirm(page.messages.map(message => message.id));
+            await this.confirmMessages(page.messages);
             this.assertOpen();
             this.rememberHistoryEdge(threadId, page);
             return page;

package/lib/runtime/durableSender.d.ts

@@ -45,6 +45,10 @@ export declare class DurableChatSender {
     private uploads;
     private uploadTail;
     private uploadWaiting;
+    private confirmationQueue;
+    private confirmationTimer?;
+    private confirmationRunning?;
+    private confirmationSize;
     private version;
     private withdrawn;
     private revoking?;
@@ -91,6 +95,11 @@ export declare class DurableChatSender {
     /** Confirm only after the authoritative message has been durably merged.
      * A tombstone prevents another tab's late failure from recreating the outbox. */
     confirm(hashes: string[]): Promise<void>;
+    private scheduleConfirmations;
+    private drainConfirmations;
+    private failConfirmations;
+    private flushConfirmations;
+    private confirmNow;
     private resume;
     close(): Promise<void>;
 }

package/lib/runtime/durableSender.js

@@ -14,6 +14,10 @@ export class DurableChatSender {
     uploads = new Set();
     uploadTail = Promise.resolve();
     uploadWaiting = 0;
+    confirmationQueue = [];
+    confirmationTimer;
+    confirmationRunning;
+    confirmationSize = 0;
     version = 0;
     withdrawn = false;
     revoking;
@@ -181,6 +185,7 @@ export class DurableChatSender {
     /** Stop disclosure immediately; durable invalidation is coordinated separately. */
     withdraw() {
         this.withdrawn = true;
+        this.failConfirmations(new Error("OUTBOX_ACCESS_REVOKED"));
         this.uploads.forEach(controller => controller.abort());
         this.releaseUrls();
         this.values.clear();
@@ -419,10 +424,67 @@ export class DurableChatSender {
     }
     /** Confirm only after the authoritative message has been durably merged.
      * A tombstone prevents another tab's late failure from recreating the outbox. */
-    async confirm(hashes) {
+    confirm(hashes) {
         hashes = [...new Set(hashes)];
         if (!hashes.length)
+            return Promise.resolve();
+        if (this.closed || this.closing || this.withdrawn)
+            return Promise.reject(new Error("OUTBOX_ACCESS_REVOKED"));
+        if (this.confirmationSize + hashes.length > 4096)
+            return Promise.reject(new Error("OUTBOX_CONFIRM_BACKPRESSURE"));
+        const pending = new Promise((resolve, reject) => this.confirmationQueue.push({ hashes, resolve, reject }));
+        this.confirmationSize += hashes.length;
+        this.scheduleConfirmations();
+        return pending;
+    }
+    scheduleConfirmations() {
+        if (this.confirmationTimer !== undefined || this.confirmationRunning || !this.confirmationQueue.length)
             return;
+        this.confirmationTimer = setTimeout(() => { this.confirmationTimer = undefined; void this.drainConfirmations(); }, 16);
+    }
+    drainConfirmations() {
+        if (this.confirmationRunning)
+            return this.confirmationRunning;
+        const batch = this.confirmationQueue.splice(0);
+        if (!batch.length)
+            return Promise.resolve();
+        const size = batch.reduce((sum, item) => sum + item.hashes.length, 0);
+        return this.confirmationRunning = (async () => {
+            let failed = false, error;
+            try {
+                await this.confirmNow([...new Set(batch.flatMap(item => item.hashes))]);
+            }
+            catch (reason) {
+                failed = true;
+                error = reason;
+            }
+            this.confirmationSize -= size;
+            for (const item of batch)
+                if (failed)
+                    item.reject(error);
+                else
+                    item.resolve();
+        })().finally(() => {
+            this.confirmationRunning = undefined;
+            this.scheduleConfirmations();
+        });
+    }
+    failConfirmations(error) {
+        clearTimeout(this.confirmationTimer);
+        this.confirmationTimer = undefined;
+        for (const item of this.confirmationQueue.splice(0)) {
+            this.confirmationSize -= item.hashes.length;
+            item.reject(error);
+        }
+    }
+    async flushConfirmations() {
+        while (this.confirmationRunning || this.confirmationQueue.length) {
+            clearTimeout(this.confirmationTimer);
+            this.confirmationTimer = undefined;
+            await (this.confirmationRunning ?? this.drainConfirmations());
+        }
+    }
+    async confirmNow(hashes) {
         await this.ready;
         let changed = false;
         try {
@@ -477,10 +539,12 @@ export class DurableChatSender {
         this.channel = undefined;
         try {
             await this.ready;
+            await this.flushConfirmations();
             await Promise.allSettled([...this.accepted, ...this.running.values(), ...(this.revoking ? [this.revoking] : [])]);
         }
         finally {
             this.closed = true;
+            this.failConfirmations(new Error("CHAT_SENDER_CLOSED"));
             this.releaseUrls();
             this.values.clear();
             this.snapshots.clear();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmate/chat-sdk",
-  "version": "0.12.0-next.50",
+  "version": "0.12.0-next.52",
   "description": "Cross-platform PMate chat input components, voice input primitives, and ASR helpers",
   "type": "module",
   "main": "./lib/index.js",