@fabriktor/fx 0.0.110 → 0.0.111

package/dist/src/chat/send-queue.d.ts

@@ -46,6 +46,7 @@ export type ChatSendQueueOptions = {
     lock: ChatSendLock;
     upload: (entry: QueuedChat, signal: AbortSignal) => Promise<boolean>;
     changed?: (chat?: Chat) => void;
+    online?: () => boolean;
 };
 export declare class ChatSendQueue {
     private readonly opts;
@@ -97,4 +98,6 @@ export declare class ChatSendQueue {
     private publish;
 }
 export declare function chatSendNeedsRetry(entry: QueuedChat): boolean;
+export declare function chatSendCanRetry(entry: QueuedChat): boolean;
+export declare function chatSendCanRestore(entry: QueuedChat): boolean;
 export declare function chatSendCanRemove(entry: QueuedChat): boolean;

package/dist/src/chat/send-queue.js

@@ -16,8 +16,9 @@ export const ChatSendStatus = {
     Uploading: "uploading",
     UploadInterrupted: "upload_interrupted",
 };
-// Persistent creation FIFO per account and room. Creation never advances beyond
-// an uncertain head: it recovers automatically with its original request key.
+// Persistent creation FIFO per account and room. A creation is attempted once:
+// the backend rejects reused keys rather than replaying the original response.
+// Unconfirmed entries remain visible but never block later messages.
 // Retrieval, attachments, other rooms and other users are independent.
 export class ChatSendQueue {
     opts;
@@ -156,6 +157,11 @@ export class ChatSendQueue {
         }
         this.remember(chat);
         this.publish();
+        for (const entry of this.entries) {
+            if (!entry.chat && entry.server_id === chat.id) {
+                this.startConfirmation(entry, this.owner, this.controller.signal);
+            }
+        }
     }
     async refresh() {
         if (!this.enabled) {
@@ -184,12 +190,13 @@ export class ChatSendQueue {
             if (stored.length === 0 && this.pendingSaves.size === 0)
                 this.wakeup.cancel();
             for (const room of new Set(stored
-                .filter((entry) => !entry.chat && !entry.server_id)
+                .filter(chatSendCanCreate)
                 .map((entry) => entry.input.chat_room_id))) {
                 this.work(room, owner, signal);
             }
             for (const entry of stored) {
-                if (chatSendCanConfirm(entry)) {
+                if (chatSendCanConfirm(entry) ||
+                    (!entry.chat && entry.server_id && this.confirmed.has(entry.server_id))) {
                     this.startConfirmation(entry, owner, signal);
                 }
                 if (entry.chat && entry.status === ChatSendStatus.Uploading) {
@@ -207,7 +214,7 @@ export class ChatSendQueue {
     }
     async retry(id) {
         const entry = this.entries.find((value) => value.id === id);
-        if (!entry || !this.enabled) {
+        if (!entry || !this.enabled || !chatSendCanRetry(entry)) {
             return;
         }
         if (entry.sequence === undefined) {
@@ -233,7 +240,7 @@ export class ChatSendQueue {
                 return;
             }
             const current = (await this.opts.store.list(owner)).find((value) => value.id === id);
-            if (!current || !chatSendNeedsRetry(current)) {
+            if (!current || !chatSendCanRetry(current)) {
                 return;
             }
             if (current.chat) {
@@ -308,7 +315,7 @@ export class ChatSendQueue {
             owner_id: owner,
             scope: `chat-send:${room}`,
             signal,
-            select: (entry) => entry.input.chat_room_id === room && !entry.chat && !entry.server_id,
+            select: (entry) => entry.input.chat_room_id === room && chatSendCanCreate(entry),
             on_error: (err) => {
                 if (this.current(owner, signal)) {
                     this.error = err;
@@ -325,13 +332,23 @@ export class ChatSendQueue {
                 if (!this.current(owner, signal) || this.cancellations.has(entry.id)) {
                     return false;
                 }
-                // A persisted Sending marker is an interrupted request once we own
-                // the room lock. Reuse its key; never skip an unknown creation outcome.
+                // The room lock excludes a sender in another tab. A leftover attempt
+                // (including legacy automatic retries) has an unknown outcome, not
+                // permission to POST again with an already consumed key.
                 let current = this.pendingCreates.get(entry.id) ?? entry;
-                if (this.waitForRetry(current))
+                if (current.attempted && !current.server_id) {
+                    await this.save({
+                        ...current,
+                        status: ChatSendStatus.Failed,
+                        retry: undefined,
+                    });
+                    return true;
+                }
+                if (this.opts.online?.() === false)
                     return false;
                 const request = new AbortController();
                 const requestSignal = AbortSignal.any([signal, request.signal]);
+                let requestStarted = false;
                 this.sends.set(entry.id, request);
                 try {
                     if (!current.server_id) {
@@ -344,6 +361,7 @@ export class ChatSendQueue {
                         if (!this.current(owner, signal))
                             return false;
                         requestSignal.throwIfAborted();
+                        requestStarted = true;
                         const out = await this.opts.chat.insertOneChat({
                             in: current.input,
                             signal: requestSignal,
@@ -369,15 +387,12 @@ export class ChatSendQueue {
                     }
                     this.startConfirmation(current, owner, signal);
                 }
-                catch (err) {
+                catch {
                     current = {
                         ...current,
-                        status: requestSignal.aborted
-                            ? ChatSendStatus.Interrupted
-                            : ChatSendStatus.Failed,
-                        retry: requestSignal.aborted
-                            ? undefined
-                            : nextQueueRetry(current.retry),
+                        attempted: current.attempted && (requestStarted || !!current.server_id),
+                        status: ChatSendStatus.Failed,
+                        retry: undefined,
                     };
                     if (current.server_id)
                         this.pendingCreates.set(current.id, current);
@@ -387,14 +402,13 @@ export class ChatSendQueue {
                     }
                     catch (storageError) {
                         this.error = storageError;
-                    }
-                    if (this.current(owner, signal) && !request.signal.aborted) {
-                        this.error = err;
                         this.publish();
-                        if (current.retry)
-                            this.scheduleRecovery(current.retry.after);
+                        this.recoverStorage();
+                        return false;
                     }
-                    return false;
+                    // The failed entry is durable and excluded from the creation lane.
+                    // Continue with the next message without a timer or another POST.
+                    return this.current(owner, signal);
                 }
                 finally {
                     this.sends.delete(entry.id);
@@ -406,7 +420,9 @@ export class ChatSendQueue {
     // Retrieval is independent of the room's creation lock. Its per-message
     // lock coordinates retries/recovery across tabs without holding later POSTs.
     startConfirmation(entry, owner, signal) {
-        if (this.confirmations.has(entry.id) || this.waitForRetry(entry)) {
+        const known = entry.server_id && this.confirmed.get(entry.server_id);
+        if (this.confirmations.has(entry.id) ||
+            (!known && this.opts.online?.() === false)) {
             return;
         }
         this.confirmations.add(entry.id);
@@ -417,17 +433,23 @@ export class ChatSendQueue {
             }
             const stored = (await this.opts.store.list(owner)).find((value) => value.id === entry.id);
             if (!stored ||
-                !chatSendCanConfirm(stored) ||
-                this.waitForRetry(stored)) {
+                !stored.server_id ||
+                stored.chat ||
+                (!chatSendCanConfirm(stored) && !this.confirmed.has(stored.server_id))) {
                 return;
             }
             let current = stored;
             try {
-                const out = await this.opts.chat.findOneChat({
-                    id: current.server_id,
-                    signal,
-                });
-                const chat = out.value;
+                const chat = this.confirmed.get(current.server_id) ??
+                    (await this.opts.chat
+                        .findOneChat({ id: current.server_id, signal })
+                        .catch((err) => {
+                        // A room event can arrive while this read is in flight.
+                        const confirmed = this.confirmed.get(current.server_id);
+                        if (confirmed)
+                            return { value: confirmed };
+                        throw err;
+                    })).value;
                 if (!chat ||
                     chat.id !== current.server_id ||
                     chat.owner_id !== owner ||
@@ -457,26 +479,16 @@ export class ChatSendQueue {
                     this.opts.changed?.(chat);
                 }
             }
-            catch (err) {
-                const retry = signal.aborted
-                    ? undefined
-                    : nextQueueRetry(current.retry);
-                if (retry && !current.chat && this.current(owner, signal)) {
-                    this.scheduleRecovery(retry.after);
-                }
+            catch {
                 await this.save({
                     ...current,
-                    retry,
+                    retry: undefined,
                     status: current.chat
                         ? ChatSendStatus.UploadInterrupted
                         : signal.aborted
                             ? ChatSendStatus.Interrupted
                             : ChatSendStatus.Failed,
                 });
-                if (this.current(owner, signal)) {
-                    this.error = err;
-                    this.publish();
-                }
             }
         })
             .catch((err) => {
@@ -681,14 +693,30 @@ function chatSendCanConfirm(entry) {
         (entry.status === ChatSendStatus.Confirming ||
             entry.status === ChatSendStatus.Sending ||
             entry.status === ChatSendStatus.Queued ||
-            entry.status === ChatSendStatus.Interrupted ||
-            entry.status === ChatSendStatus.Failed));
+            entry.status === ChatSendStatus.Interrupted));
 }
 export function chatSendNeedsRetry(entry) {
     return (entry.status === ChatSendStatus.Failed ||
         entry.status === ChatSendStatus.Interrupted ||
         entry.status === ChatSendStatus.UploadInterrupted);
 }
+// Local persistence and reads by a known server ID are safe to retry. An
+// attempted creation without an ID cannot be repeated or silently re-keyed.
+export function chatSendCanRetry(entry) {
+    return (chatSendNeedsRetry(entry) &&
+        (!entry.attempted || !!entry.server_id || !!entry.chat));
+}
+export function chatSendCanRestore(entry) {
+    return (chatSendNeedsRetry(entry) &&
+        entry.attempted &&
+        !entry.server_id &&
+        !entry.chat);
+}
+function chatSendCanCreate(entry) {
+    return (!entry.chat &&
+        !entry.server_id &&
+        (entry.status !== ChatSendStatus.Failed || !!entry.retry));
+}
 export function chatSendCanRemove(entry) {
     if (!entry.chat && entry.server_id) {
         return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fabriktor/fx",
-  "version": "0.0.110",
+  "version": "0.0.111",
   "description": "![Fabriktor Logo](./img/fabriktor-character.gif)",
   "type": "module",
   "exports": {