@cjhyy/code-shell-chat 0.8.12 → 0.8.20

package/dist/delivery-queue.d.ts

@@ -47,12 +47,16 @@ export declare class DeliveryQueue {
     private readonly deliver;
     private readonly onError;
     private readonly pending;
+    /** Enqueues that reserved capacity while attachments are materialized outside the mutation lock. */
+    private readonly preparing;
     private readonly completed;
     private readonly inFlight;
     private readonly targetInFlight;
     private mutation;
     private retryTimer?;
     private persistRetryTimer?;
+    /** Terminal records whose spool may be deleted after a successful state retry. */
+    private readonly persistRetryCleanups;
     private stopped;
     constructor(config: DeliveryQueueConfig, deliver: (adapterId: string, message: ChannelMessage) => Promise<void>, onError: (error: unknown, message: ChannelMessage) => void);
     start(): Promise<void>;

package/dist/delivery-queue.js

@@ -34,12 +34,16 @@ export class DeliveryQueue {
     deliver;
     onError;
     pending = [];
+    /** Enqueues that reserved capacity while attachments are materialized outside the mutation lock. */
+    preparing = new Map();
     completed = new Map();
     inFlight = new Set();
     targetInFlight = new Map();
     mutation = Promise.resolve();
     retryTimer;
     persistRetryTimer;
+    /** Terminal records whose spool may be deleted after a successful state retry. */
+    persistRetryCleanups = new Map();
     stopped = true;
     constructor(config, deliver, onError) {
         this.config = config;
@@ -76,65 +80,78 @@ export class DeliveryQueue {
         if (this.stopped)
             throw new Error("Chat Gateway inbox is stopped");
         const dedupeKey = deliveryDedupeKey(message);
-        let result = "queued";
-        await this.withMutation(async () => {
+        const id = randomUUID();
+        const reserved = await this.withMutation(async () => {
+            if (this.stopped)
+                throw new Error("Chat Gateway inbox is stopped");
             this.pruneCompleted();
             if (dedupeKey &&
                 (this.completed.has(dedupeKey) ||
-                    this.pending.some((entry) => entry.dedupeKey === dedupeKey))) {
-                result = "duplicate";
-                return;
+                    this.pending.some((entry) => entry.dedupeKey === dedupeKey) ||
+                    [...this.preparing.values()].some((candidate) => candidate === dedupeKey))) {
+                return false;
             }
-            if (this.pending.length >= this.config.maxPending) {
+            if (this.pending.length + this.preparing.size >= this.config.maxPending) {
                 throw new DeliveryBackpressureError(this.config.maxPending);
             }
-            const id = randomUUID();
-            // Attachments used to make a record non-persistent outright, because
-            // `load()` cannot be serialized — so the message lived in memory only while
-            // the adapter had already acked it. Spool the bytes instead: the record
-            // then persists like any other, carrying file paths in place of closures.
-            const spooled = await this.spoolAttachments(id, message);
-            let record;
-            try {
-                const persistent = Boolean(this.config.path && (!message.attachments?.length || spooled !== undefined));
-                const safeMessage = persistent ? serializableMessage(message, spooled) : message;
-                record = {
-                    id,
-                    ...(dedupeKey ? { dedupeKey } : {}),
-                    adapterId,
-                    message: safeMessage,
-                    attempts: 0,
-                    nextAttemptAt: Date.now(),
-                    persistent,
-                    ...(spooled ? { spooled } : {}),
-                };
-                this.pending.push(record);
-                if (persistent)
-                    await this.persist();
-            }
-            catch (error) {
-                if (record) {
-                    const index = this.pending.findIndex((candidate) => candidate.id === record?.id);
-                    if (index >= 0)
-                        this.pending.splice(index, 1);
-                    await this.discardSpool(record);
-                }
-                else if (spooled) {
-                    await this.discardSpool({
+            this.preparing.set(id, dedupeKey);
+            return true;
+        });
+        if (!reserved)
+            return "duplicate";
+        // attachment.load() may perform an unbounded network read. The reservation
+        // above preserves dedupe/backpressure, while doing the I/O here prevents one
+        // slow attachment from blocking every enqueue and terminal state write.
+        const spooled = await this.spoolAttachments(id, message);
+        let record;
+        try {
+            await this.withMutation(async () => {
+                try {
+                    if (this.stopped)
+                        throw new Error("Chat Gateway inbox is stopped");
+                    const persistent = Boolean(this.config.path && (!message.attachments?.length || spooled !== undefined));
+                    const safeMessage = persistent ? serializableMessage(message, spooled) : message;
+                    record = {
                         id,
+                        ...(dedupeKey ? { dedupeKey } : {}),
                         adapterId,
-                        message,
+                        message: safeMessage,
                         attempts: 0,
-                        nextAttemptAt: 0,
-                        persistent: false,
-                        spooled,
-                    });
+                        nextAttemptAt: Date.now(),
+                        persistent,
+                        ...(spooled ? { spooled } : {}),
+                    };
+                    this.pending.push(record);
+                    if (persistent)
+                        await this.persist();
                 }
-                throw error;
-            }
-        });
+                catch (error) {
+                    if (record) {
+                        const index = this.pending.findIndex((candidate) => candidate.id === record?.id);
+                        if (index >= 0)
+                            this.pending.splice(index, 1);
+                    }
+                    throw error;
+                }
+                finally {
+                    this.preparing.delete(id);
+                }
+            });
+        }
+        catch (error) {
+            await this.discardSpool(record ?? {
+                id,
+                adapterId,
+                message,
+                attempts: 0,
+                nextAttemptAt: 0,
+                persistent: false,
+                ...(spooled ? { spooled } : {}),
+            });
+            throw error;
+        }
         this.pump();
-        return result;
+        return "queued";
     }
     pump() {
         if (this.stopped)
@@ -215,6 +232,8 @@ export class DeliveryQueue {
         this.pump();
     }
     schedulePersistRetry(message, cleanup) {
+        if (cleanup)
+            this.persistRetryCleanups.set(cleanup.id, { entry: cleanup, message });
         if (this.stopped || !this.config.path || this.persistRetryTimer)
             return;
         const delay = Math.max(10, Math.min(this.config.retryBaseMs, this.config.retryMaxMs));
@@ -224,11 +243,14 @@ export class DeliveryQueue {
                 return;
             void this.withMutation(async () => {
                 await this.persist();
-                if (cleanup)
-                    await this.discardSpool(cleanup);
+                for (const [id, pendingCleanup] of this.persistRetryCleanups) {
+                    await this.discardSpool(pendingCleanup.entry);
+                    this.persistRetryCleanups.delete(id);
+                }
             }).catch((error) => {
-                this.onError(error, message);
-                this.schedulePersistRetry(message, cleanup);
+                const relatedMessage = this.persistRetryCleanups.values().next().value?.message ?? message;
+                this.onError(error, relatedMessage);
+                this.schedulePersistRetry(relatedMessage);
             });
         }, delay);
         this.persistRetryTimer.unref?.();
@@ -527,7 +549,8 @@ function validStoredEntry(entry, maxAttachmentBytes) {
         value.message.attachments) {
         return false;
     }
-    if (value.dedupeKey !== undefined && (typeof value.dedupeKey !== "string" || value.dedupeKey.length > 16_384)) {
+    if (value.dedupeKey !== undefined &&
+        (typeof value.dedupeKey !== "string" || value.dedupeKey.length > 16_384)) {
         return false;
     }
     if (value.spooled === undefined)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cjhyy/code-shell-chat",
-  "version": "0.8.12",
+  "version": "0.8.20",
   "description": "A standalone, transport-agnostic multi-channel chat gateway for Node.js and Bun.",
   "type": "module",
   "main": "./dist/index.js",