@pmate/chat-sdk 0.12.0-next.55 → 0.12.0-next.56

package/lib/runtime/durableSender.d.ts

@@ -46,6 +46,11 @@ export declare class DurableChatSender {
     private uploads;
     private reconciliations;
     private firstDelivery;
+    private ioQueue;
+    private ioTimer?;
+    private ioRunning?;
+    private ioCount;
+    private ioBytes;
     private acceptanceQueue;
     private acceptanceTimer?;
     private acceptanceRunning?;
@@ -104,6 +109,10 @@ export declare class DurableChatSender {
     private localView;
     private prepareVoice;
     private save;
+    private queueIO;
+    private scheduleIO;
+    private failIO;
+    private drainIO;
     /** 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>;

package/lib/runtime/durableSender.js

@@ -16,6 +16,11 @@ export class DurableChatSender {
     uploads = new Set();
     reconciliations = new Set();
     firstDelivery = new Set();
+    ioQueue = [];
+    ioTimer;
+    ioRunning;
+    ioCount = 0;
+    ioBytes = 0;
     acceptanceQueue = [];
     acceptanceTimer;
     acceptanceRunning;
@@ -194,6 +199,7 @@ export class DurableChatSender {
     /** Stop disclosure immediately; durable invalidation is coordinated separately. */
     withdraw() {
         this.withdrawn = true;
+        this.failIO(new Error("OUTBOX_ACCESS_REVOKED"));
         this.failAcceptances(new Error("OUTBOX_ACCESS_REVOKED"));
         this.failConfirmations(new Error("OUTBOX_ACCESS_REVOKED"));
         this.uploads.forEach(controller => controller.abort());
@@ -257,7 +263,15 @@ export class DurableChatSender {
             return Promise.reject(new Error("OUTBOX_ACCESS_REVOKED"));
         if (input.voiceBlob && (!(input.voiceBlob instanceof Blob) || input.voiceBlob.size === 0 || input.voiceBlob.size > 16 * 1024 * 1024))
             return Promise.reject(new Error("INVALID_VOICE_ATTACHMENT"));
-        const bytes = input.voiceBlob?.size ?? 0;
+        let bytes;
+        try {
+            bytes = JSON.stringify([input.to, input.body, input.recipients, this.identity]).length * 3 + 1024 + (input.voiceBlob?.size ?? 0);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        if (bytes > 20 * 1024 * 1024)
+            return Promise.reject(new Error("OUTBOX_RECORD_TOO_LARGE"));
         if (this.acceptanceCount >= 4096 || this.acceptanceBytes + bytes > 64 * 1024 * 1024)
             return Promise.reject(new Error("OUTBOX_ACCEPTANCE_BACKPRESSURE"));
         this.acceptanceCount++;
@@ -278,7 +292,7 @@ export class DurableChatSender {
             }
             const record = { ...(input.voiceBlob ? { voiceData: { bytes: await input.voiceBlob.arrayBuffer(), type: input.voiceBlob.type } } : {}), scope: this.scope, threadId, hash: message.hash, message, status: "sending", accessVersion: this.version };
             const durable = await new Promise((resolve, reject) => {
-                this.acceptanceQueue.push({ record, resolve, reject });
+                this.acceptanceQueue.push({ record, bytes, resolve, reject });
                 this.scheduleAcceptances();
             });
             return durable.message;
@@ -301,8 +315,8 @@ export class DurableChatSender {
         const task = (async () => {
             let bytes = 0, count = 0;
             for (const item of this.acceptanceQueue) {
-                const size = item.record.voiceData?.bytes.byteLength ?? 0;
-                if (count >= 128 || (count > 0 && bytes + size > 16 * 1024 * 1024))
+                const size = item.bytes;
+                if (count >= 128 || (count > 0 && bytes + size > 20 * 1024 * 1024))
                     break;
                 bytes += size;
                 count++;
@@ -373,7 +387,7 @@ export class DurableChatSender {
     }
     async transmit(hash) {
         await this.ready;
-        let record = await this.withEpoch("r", async () => this.outbox.get([this.scope, hash]));
+        let record = await this.queueIO(hash);
         if (!record || this.closed || this.withdrawn)
             throw new Error("OUTGOING_MESSAGE_UNAVAILABLE");
         if (record.status === "sent" || record.confirmed) {
@@ -411,14 +425,7 @@ export class DurableChatSender {
             transmitting = true;
             const message = await this.client.sendPrepared(record.message);
             const sent = { ...record, message, status: "sent" };
-            const committed = await this.save(sent);
-            if (!this.closed && !this.withdrawn) {
-                if (committed?.confirmed || !committed)
-                    this.values.delete(hash);
-                else
-                    this.values.set(hash, committed);
-                this.emit();
-            }
+            await this.save(sent);
             return message;
         }
         catch (error) {
@@ -438,16 +445,8 @@ export class DurableChatSender {
             if (!this.closed && !this.withdrawn && !(this.closing && statefulGroup(record.message))) {
                 const failed = { ...record, status: "failed" };
                 const committed = await this.save(failed);
-                if (committed?.confirmed || committed?.status === "sent") {
-                    this.values.delete(hash);
-                    this.emit();
+                if (committed?.confirmed || committed?.status === "sent")
                     return committed.message;
-                }
-                if (committed)
-                    this.values.set(hash, committed);
-                else
-                    this.values.delete(hash);
-                this.emit();
             }
             throw error;
         }
@@ -511,7 +510,7 @@ export class DurableChatSender {
             await this.checkAccess();
             if (this.closing)
                 throw new Error("CHAT_SENDER_CLOSED");
-            const latest = await this.withEpoch("r", () => this.outbox.get([this.scope, record.hash]));
+            const latest = await this.queueIO(record.hash);
             if (!latest)
                 throw new Error("OUTGOING_MESSAGE_UNAVAILABLE");
             if (!hasVoice(latest) || latest.confirmed || latest.status === "sent")
@@ -536,18 +535,9 @@ export class DurableChatSender {
             if (this.closing)
                 throw new Error("CHAT_SENDER_CLOSED");
             const { voiceBlob: _blob, voiceData: _data, ...uploaded } = latest;
-            const committed = await this.withEpoch("rw", async () => {
-                const current = await this.outbox.get([this.scope, record.hash]);
-                if (!current || current.confirmed || current.status === "sent" || !hasVoice(current))
-                    return current;
-                const next = { ...uploaded, message: withVoiceUrl(latest.message, url) };
-                await this.outbox.put(next);
-                return next;
-            });
+            const committed = await this.queueIO(record.hash, { ...uploaded, message: withVoiceUrl(latest.message, url) }, true);
             if (!committed)
                 throw new Error("OUTGOING_MESSAGE_UNAVAILABLE");
-            this.values.set(record.hash, committed);
-            this.emit();
             return committed;
         }
         finally {
@@ -555,17 +545,88 @@ export class DurableChatSender {
             release();
         }
     }
-    async save(record) {
-        return this.withEpoch("rw", async () => {
-            const previous = await this.outbox.get([this.scope, record.hash]);
-            if (!previous || previous.confirmed || previous.status === "sent")
-                return previous;
-            // A second document may already have durably replaced the Blob with its URL.
-            if (hasVoice(record) && !hasVoice(previous))
-                return previous;
-            await this.outbox.put(record);
-            return record;
-        });
+    save(record) { return this.queueIO(record.hash, record); }
+    queueIO(hash, record, uploaded = false) {
+        if (this.closed || this.withdrawn)
+            return Promise.reject(new Error("OUTBOX_ACCESS_REVOKED"));
+        const value = record ?? this.values.get(hash);
+        const bytes = value ? JSON.stringify(value.message).length * 3 + (value.voiceData?.bytes.byteLength ?? value.voiceBlob?.size ?? 0) : 0;
+        if (bytes > 20 * 1024 * 1024)
+            return Promise.reject(new Error("OUTBOX_RECORD_TOO_LARGE"));
+        if (this.ioCount >= 4096 || this.ioBytes + bytes > 64 * 1024 * 1024)
+            return Promise.reject(new Error("OUTBOX_IO_BACKPRESSURE"));
+        this.ioCount++;
+        this.ioBytes += bytes;
+        return new Promise((resolve, reject) => {
+            this.ioQueue.push({ hash, record, uploaded, bytes, resolve, reject });
+            this.scheduleIO();
+        }).finally(() => { this.ioCount--; this.ioBytes -= bytes; });
+    }
+    scheduleIO() {
+        if (this.ioTimer || this.ioRunning || !this.ioQueue.length)
+            return;
+        this.ioTimer = setTimeout(() => { this.ioTimer = undefined; void this.drainIO(); }, 16);
+    }
+    failIO(error) {
+        clearTimeout(this.ioTimer);
+        this.ioTimer = undefined;
+        for (const item of this.ioQueue.splice(0))
+            item.reject(error);
+    }
+    drainIO() {
+        const task = (async () => {
+            let count = 0, bytes = 0;
+            for (const item of this.ioQueue) {
+                if (count >= 128 || (count > 0 && bytes + item.bytes > 20 * 1024 * 1024))
+                    break;
+                count++;
+                bytes += item.bytes;
+            }
+            const batch = this.ioQueue.splice(0, count);
+            try {
+                const records = await this.withEpoch(batch.some(item => item.record) ? "rw" : "r", async () => {
+                    const hashes = [...new Set(batch.map(item => item.hash))];
+                    const rows = await this.outbox.bulkGet(hashes.map(hash => [this.scope, hash]));
+                    const current = new Map(hashes.map((hash, index) => [hash, rows[index]]));
+                    const writes = new Map(), result = [];
+                    for (const item of batch) {
+                        const previous = current.get(item.hash);
+                        // Preserve another document's confirmation, sent status or uploaded URL.
+                        if (item.record && previous && !previous.confirmed && previous.status !== "sent" && !(hasVoice(item.record) && !hasVoice(previous)) && !(item.uploaded && !hasVoice(previous))) {
+                            current.set(item.hash, item.record);
+                            writes.set(item.hash, item.record);
+                        }
+                        result.push(current.get(item.hash));
+                    }
+                    if (writes.size)
+                        await this.outbox.bulkPut([...writes.values()]);
+                    return result;
+                });
+                await this.checkAccess();
+                let changed = false;
+                batch.forEach((item, index) => {
+                    if (!item.record)
+                        return;
+                    const record = records[index], old = this.values.get(item.hash);
+                    if (!record || record.confirmed) {
+                        changed = this.values.delete(item.hash) || changed;
+                        this.releaseUrl(item.hash);
+                    }
+                    else if (!old || old.status !== record.status || old.accessVersion !== record.accessVersion || JSON.stringify(old.message) !== JSON.stringify(record.message) || hasVoice(old) !== hasVoice(record)) {
+                        this.values.set(item.hash, record);
+                        changed = true;
+                    }
+                });
+                if (changed)
+                    this.emit();
+                batch.forEach((item, index) => item.resolve(records[index]));
+            }
+            catch (error) {
+                batch.forEach(item => item.reject(error));
+            }
+        })().finally(() => { this.ioRunning = undefined; this.scheduleIO(); });
+        this.ioRunning = task;
+        return task;
     }
     /** Confirm only after the authoritative message has been durably merged.
      * A tombstone prevents another tab's late failure from recreating the outbox. */

package/package.json

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