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

package/lib/runtime/durableSender.d.ts

@@ -46,6 +46,16 @@ 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?;
+    private acceptanceCount;
+    private acceptanceBytes;
     private uploadTail;
     private uploadWaiting;
     private confirmationQueue;
@@ -88,6 +98,9 @@ export declare class DurableChatSender {
     /** Compatibility API: resolves only after transport delivery. */
     send(threadId: string, input: SendMessageInput): Promise<ChatRuntimeMessage>;
     private persistOutgoing;
+    private scheduleAcceptances;
+    private failAcceptances;
+    private drainAcceptances;
     retry(hash: string): Promise<ChatRuntimeMessage>;
     private transmit;
     private reconcile;
@@ -96,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,16 @@ export class DurableChatSender {
     uploads = new Set();
     reconciliations = new Set();
     firstDelivery = new Set();
+    ioQueue = [];
+    ioTimer;
+    ioRunning;
+    ioCount = 0;
+    ioBytes = 0;
+    acceptanceQueue = [];
+    acceptanceTimer;
+    acceptanceRunning;
+    acceptanceCount = 0;
+    acceptanceBytes = 0;
     uploadTail = Promise.resolve();
     uploadWaiting = 0;
     confirmationQueue = [];
@@ -189,6 +199,8 @@ 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());
         this.reconciliations.forEach(controller => controller.abort());
@@ -249,6 +261,21 @@ export class DurableChatSender {
     persistOutgoing(threadId, input) {
         if (this.closed || this.closing || this.withdrawn)
             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"));
+        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++;
+        this.acceptanceBytes += bytes;
         const pending = (async () => {
             await this.ready;
             await this.checkAccess();
@@ -260,41 +287,93 @@ export class DurableChatSender {
                 message.hash = commandId(this.scope, this.version, threadId, message);
             if (input.voiceBlob) {
                 const body = message.body;
-                if (!(input.voiceBlob instanceof Blob) || input.voiceBlob.size === 0 || input.voiceBlob.size > 16 * 1024 * 1024 || body.kind !== "message" || !validVoice(body.content.voice))
+                if (body.kind !== "message" || !validVoice(body.content.voice))
                     throw new Error("INVALID_VOICE_ATTACHMENT");
             }
             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 this.withEpoch("rw", async () => {
-                if (command) {
-                    const previous = await this.outbox.get([this.scope, message.hash]);
-                    if (previous && (previous.accessVersion ?? 0) === this.version) {
-                        if (previous.message.from !== this.identity.profileId || previous.message.hash !== message.hash || commandId(this.scope, this.version, threadId, previous.message) !== message.hash)
-                            throw new Error("OUTGOING_COMMAND_CONFLICT");
-                        return previous;
+            const durable = await new Promise((resolve, reject) => {
+                this.acceptanceQueue.push({ record, bytes, resolve, reject });
+                this.scheduleAcceptances();
+            });
+            return durable.message;
+        })().finally(() => { this.accepted.delete(pending); this.acceptanceCount--; this.acceptanceBytes -= bytes; });
+        this.accepted.add(pending);
+        return pending;
+    }
+    scheduleAcceptances() {
+        if (this.acceptanceTimer || this.acceptanceRunning || !this.acceptanceQueue.length)
+            return;
+        this.acceptanceTimer = setTimeout(() => { this.acceptanceTimer = undefined; void this.drainAcceptances(); }, 16);
+    }
+    failAcceptances(error) {
+        clearTimeout(this.acceptanceTimer);
+        this.acceptanceTimer = undefined;
+        for (const item of this.acceptanceQueue.splice(0))
+            item.reject(error);
+    }
+    drainAcceptances() {
+        const task = (async () => {
+            let bytes = 0, count = 0;
+            for (const item of this.acceptanceQueue) {
+                const size = item.bytes;
+                if (count >= 128 || (count > 0 && bytes + size > 20 * 1024 * 1024))
+                    break;
+                bytes += size;
+                count++;
+            }
+            const batch = this.acceptanceQueue.splice(0, count);
+            try {
+                const result = await this.withEpoch("rw", async () => {
+                    const commands = batch.filter(item => statefulGroup(item.record.message));
+                    const previous = await this.outbox.bulkGet(commands.map(item => [this.scope, item.record.hash]));
+                    const known = new Map(previous.filter((row) => Boolean(row && (row.accessVersion ?? 0) === this.version)).map(row => [row.hash, row]));
+                    const writes = [], records = [];
+                    for (const { record } of batch) {
+                        const command = statefulGroup(record.message), old = command ? known.get(record.hash) : undefined;
+                        if (old) {
+                            if (old.message.from !== this.identity.profileId || old.message.hash !== record.hash || commandId(this.scope, this.version, record.threadId, old.message) !== record.hash)
+                                throw new Error("OUTGOING_COMMAND_CONFLICT");
+                            records.push(old);
+                        }
+                        else {
+                            writes.push(record);
+                            records.push(record);
+                            if (command)
+                                known.set(record.hash, record);
+                        }
+                    }
+                    if (writes.length)
+                        await this.outbox.bulkPut(writes);
+                    return { writes, records };
+                });
+                await this.checkAccess();
+                for (const record of result.writes)
+                    if (statefulGroup(record.message))
+                        this.firstDelivery.add(record.hash);
+                let changed = false;
+                for (const record of result.records) {
+                    if (record.confirmed) {
+                        this.firstDelivery.delete(record.hash);
+                        changed = this.values.delete(record.hash) || changed;
+                    }
+                    else {
+                        const current = this.values.get(record.hash);
+                        if (!current || current.status !== record.status || current.accessVersion !== record.accessVersion) {
+                            this.values.set(record.hash, record);
+                            changed = true;
+                        }
                     }
                 }
-                await this.outbox.put(record);
-                return record;
-            });
-            await this.checkAccess();
-            if (command && durable === record)
-                this.firstDelivery.add(record.hash);
-            if (durable.confirmed) {
-                this.firstDelivery.delete(durable.hash);
-                if (this.values.delete(durable.hash))
+                if (changed)
                     this.emit();
+                batch.forEach((item, index) => item.resolve(result.records[index]));
             }
-            else {
-                const current = this.values.get(durable.hash);
-                if (!current || current.status !== durable.status || current.accessVersion !== durable.accessVersion) {
-                    this.values.set(durable.hash, durable);
-                    this.emit();
-                }
+            catch (error) {
+                batch.forEach(item => item.reject(error));
             }
-            return durable.message;
-        })().finally(() => this.accepted.delete(pending));
-        this.accepted.add(pending);
-        return pending;
+        })().finally(() => { this.acceptanceRunning = undefined; this.scheduleAcceptances(); });
+        this.acceptanceRunning = task;
+        return task;
     }
     retry(hash) {
         if (this.closed || this.closing || this.withdrawn)
@@ -308,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) {
@@ -346,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) {
@@ -373,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;
         }
@@ -446,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")
@@ -471,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 {
@@ -490,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.54",
+  "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",