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

package/lib/runtime/durableSender.d.ts

@@ -46,6 +46,11 @@ export declare class DurableChatSender {
     private uploads;
     private reconciliations;
     private firstDelivery;
+    private acceptanceQueue;
+    private acceptanceTimer?;
+    private acceptanceRunning?;
+    private acceptanceCount;
+    private acceptanceBytes;
     private uploadTail;
     private uploadWaiting;
     private confirmationQueue;
@@ -88,6 +93,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;

package/lib/runtime/durableSender.js

@@ -16,6 +16,11 @@ export class DurableChatSender {
     uploads = new Set();
     reconciliations = new Set();
     firstDelivery = new Set();
+    acceptanceQueue = [];
+    acceptanceTimer;
+    acceptanceRunning;
+    acceptanceCount = 0;
+    acceptanceBytes = 0;
     uploadTail = Promise.resolve();
     uploadWaiting = 0;
     confirmationQueue = [];
@@ -189,6 +194,7 @@ export class DurableChatSender {
     /** Stop disclosure immediately; durable invalidation is coordinated separately. */
     withdraw() {
         this.withdrawn = true;
+        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 +255,13 @@ 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"));
+        const bytes = input.voiceBlob?.size ?? 0;
+        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 +273,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, 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.record.voiceData?.bytes.byteLength ?? 0;
+                if (count >= 128 || (count > 0 && bytes + size > 16 * 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)

package/package.json

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