@fabriktor/fx 0.0.101 → 0.0.103

package/dist/src/chat/optimistic.js

@@ -55,9 +55,22 @@ export function projectQueuedChats(chats, snapshot, ownerID, roomID) {
     }
     const result = [...confirmed.values()].sort((a, b) => Date.parse(a.created_at) - Date.parse(b.created_at) ||
         a.id.localeCompare(b.id));
+    const sequences = new Map(entries
+        .filter((entry) => entry.server_id && entry.sequence !== undefined)
+        .map((entry) => [entry.server_id, entry.sequence]));
     for (const entry of entries) {
-        if (!entry.chat) {
-            result.push(entry.optimistic);
+        // A room event may arrive before this entry's independent confirmation
+        // read. Match the server ID so identical messages remain distinct.
+        if (!entry.chat && (!entry.server_id || !confirmed.has(entry.server_id))) {
+            // Out-of-order reads must not move a later outgoing bubble ahead of an
+            // earlier pending one. Canonical messages keep their server ordering.
+            const before = result.findIndex((chat) => {
+                const sequence = sequences.get(chat.id) ?? snapshot.confirmed_sequences?.[chat.id];
+                return (sequence !== undefined &&
+                    entry.sequence !== undefined &&
+                    sequence > entry.sequence);
+            });
+            result.splice(before < 0 ? result.length : before, 0, entry.optimistic);
         }
     }
     return result.length === chats.length &&
@@ -68,6 +81,7 @@ export function projectQueuedChats(chats, snapshot, ownerID, roomID) {
 export function activeQueuedChat(snapshot, ownerID, roomID) {
     return (snapshot.entries.find((entry) => entry.owner_id === ownerID &&
         entry.input.chat_room_id === roomID &&
+        !entry.server_id &&
         entry.status === ChatSendStatus.Sending)?.optimistic ?? null);
 }
 export function queuedChatsByID(snapshot) {

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

@@ -5,6 +5,7 @@ export declare const ChatSendStatus: {
     readonly Saving: "saving";
     readonly Queued: "queued";
     readonly Sending: "sending";
+    readonly Confirming: "confirming";
     readonly Failed: "failed";
     readonly Interrupted: "interrupted";
     readonly Uploading: "uploading";
@@ -35,6 +36,7 @@ export type ChatSendLock = QueueLock;
 export type ChatSendSnapshot = {
     entries: readonly QueuedChat[];
     confirmed: readonly Chat[];
+    confirmed_sequences?: Readonly<Record<string, number>>;
     error?: unknown;
 };
 export type ChatSendQueueOptions = {
@@ -50,9 +52,13 @@ export declare class ChatSendQueue {
     private controller;
     private entries;
     private confirmed;
+    private confirmedSequences;
     private listeners;
     private readonly queue;
     private uploads;
+    private confirmations;
+    private sends;
+    private cancellations;
     private writes;
     private pendingSaves;
     private error?;
@@ -71,9 +77,11 @@ export declare class ChatSendQueue {
     retry(id: string): Promise<void>;
     remove(id: string): Promise<void>;
     private work;
+    private startConfirmation;
     private startUpload;
     private recoverUpload;
     private uploadLock;
+    private confirmationLock;
     private roomLock;
     private current;
     private save;

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

@@ -10,22 +10,27 @@ export const ChatSendStatus = {
     Saving: "saving",
     Queued: "queued",
     Sending: "sending",
+    Confirming: "confirming",
     Failed: "failed",
     Interrupted: "interrupted",
     Uploading: "uploading",
     UploadInterrupted: "upload_interrupted",
 };
-// Persistent FIFO per account and room. The transport never advances beyond a
-// failed/uncertain head. Other rooms and other users remain independent.
+// Persistent creation FIFO per account and room. Creation never advances beyond
+// a failed/uncertain head. Retrieval, other rooms and other users are independent.
 export class ChatSendQueue {
     opts;
     owner = "";
     controller = new AbortController();
     entries = [];
     confirmed = new Map();
+    confirmedSequences = new Map();
     listeners = new Set();
     queue;
     uploads = new Set();
+    confirmations = new Set();
+    sends = new Map();
+    cancellations = new Set();
     writes = Promise.resolve();
     pendingSaves = new Map();
     error;
@@ -42,6 +47,7 @@ export class ChatSendQueue {
         return {
             entries: this.entries,
             confirmed: [...this.confirmed.values()],
+            confirmed_sequences: Object.fromEntries(this.confirmedSequences),
             error: this.error,
         };
     }
@@ -59,6 +65,7 @@ export class ChatSendQueue {
         if (this.owner !== ownerID) {
             this.entries = [...this.pendingSaves.values()].filter((entry) => entry.owner_id === ownerID);
             this.confirmed.clear();
+            this.confirmedSequences.clear();
             this.error = undefined;
         }
         this.owner = ownerID;
@@ -155,17 +162,20 @@ export class ChatSendQueue {
             ];
             for (const entry of stored) {
                 if (entry.chat) {
-                    this.remember(entry.chat);
+                    this.remember(entry.chat, entry.sequence);
                 }
             }
             this.error = undefined;
             this.publish();
             for (const room of new Set(stored
-                .filter((entry) => !entry.chat)
+                .filter((entry) => !entry.chat && !entry.server_id)
                 .map((entry) => entry.input.chat_room_id))) {
                 this.work(room, owner, signal);
             }
             for (const entry of stored) {
+                if (chatSendCanConfirm(entry)) {
+                    this.startConfirmation(entry, owner, signal);
+                }
                 if (entry.chat && entry.status === ChatSendStatus.Uploading) {
                     this.recoverUpload(entry, owner, signal);
                 }
@@ -195,7 +205,9 @@ export class ChatSendQueue {
             return;
         }
         const signal = this.controller.signal, owner = this.owner;
-        await this.opts.lock(this.roomLock(entry), signal, async () => {
+        await this.opts.lock(entry.server_id && !entry.chat
+            ? this.confirmationLock(entry)
+            : this.roomLock(entry), signal, async () => {
             if (!this.current(owner, signal)) {
                 return;
             }
@@ -207,51 +219,73 @@ export class ChatSendQueue {
                 this.startUpload(current, owner, signal, true);
             }
             else {
-                await this.save({ ...current, status: ChatSendStatus.Queued });
+                await this.save({
+                    ...current,
+                    status: current.server_id
+                        ? ChatSendStatus.Confirming
+                        : ChatSendStatus.Queued,
+                });
             }
         });
         await this.refresh();
     }
     async remove(id) {
-        const entry = this.entries.find((value) => value.id === id);
+        const owner = this.owner, signal = this.controller.signal;
+        let entry = this.entries.find((value) => value.id === id);
         if (!entry ||
-            !this.enabled ||
-            entry.status === ChatSendStatus.Saving ||
-            entry.status === ChatSendStatus.Sending ||
-            entry.status === ChatSendStatus.Uploading) {
-            return;
-        }
-        if (entry.sequence === undefined) {
-            this.pendingSaves.delete(id);
-            this.entries = this.entries.filter((value) => value.id !== id);
-            this.publish();
-            this.persist();
+            !this.current(owner, signal) ||
+            !chatSendCanRemove(entry) ||
+            this.cancellations.has(id)) {
             return;
         }
-        const signal = this.controller.signal, owner = this.owner;
-        const removeStored = async () => {
-            if (!this.current(owner, signal))
+        this.cancellations.add(id);
+        try {
+            // Finish a pending local save before removing its durable record. The
+            // cancellation flag prevents this tab from starting that message meanwhile.
+            if (entry.status === ChatSendStatus.Saving) {
+                await this.writes;
+                entry = this.entries.find((value) => value.id === id);
+            }
+            if (!entry || !this.current(owner, signal) || !chatSendCanRemove(entry)) {
                 return;
-            const stored = (await this.opts.store.list(owner)).find((value) => value.id === id);
-            if (stored && !chatSendCanRemove(stored))
+            }
+            // Cancel only this request. A server response that already arrived wins;
+            // the shared room lock still protects removal from another tab's sender.
+            this.sends.get(id)?.abort();
+            if (entry.sequence === undefined) {
+                this.pendingSaves.delete(id);
+                this.entries = this.entries.filter((value) => value.id !== id);
+                this.publish();
+                this.persist();
                 return;
-            await this.opts.store.remove(id);
-            this.entries = this.entries.filter((value) => value.id !== id);
-            this.publish();
-            this.opts.changed?.();
-        };
-        // Upload retries use their own lock so a slow multipart never holds the
-        // message lane. Discard must coordinate with that same lock.
-        await this.opts.lock(entry.chat ? this.uploadLock(entry) : this.roomLock(entry), signal, removeStored);
-        this.persist();
-        await this.refresh();
+            }
+            const removeStored = async () => {
+                if (!this.current(owner, signal))
+                    return;
+                const stored = (await this.opts.store.list(owner)).find((value) => value.id === id);
+                if (stored && !chatSendCanRemove(stored))
+                    return;
+                await this.opts.store.remove(id);
+                this.entries = this.entries.filter((value) => value.id !== id);
+                this.publish();
+                this.opts.changed?.();
+            };
+            // Upload retries use their own lock so a slow multipart never holds the
+            // message lane. Discard must coordinate with that same lock.
+            await this.opts.lock(entry.chat ? this.uploadLock(entry) : this.roomLock(entry), signal, removeStored);
+        }
+        finally {
+            this.cancellations.delete(id);
+            this.persist();
+            await this.refresh();
+        }
     }
     work(room, owner, signal) {
         this.queue.process({
             owner_id: owner,
             scope: `chat-send:${room}`,
             signal,
-            select: (entry) => entry.input.chat_room_id === room && !entry.chat,
+            select: (entry) => entry.input.chat_room_id === room && !entry.chat && !entry.server_id,
             on_error: (err) => {
                 if (this.current(owner, signal)) {
                     this.error = err;
@@ -264,20 +298,20 @@ export class ChatSendQueue {
                 }
             },
             run: async (entry) => {
-                if (!this.current(owner, signal)) {
+                if (!this.current(owner, signal) || this.cancellations.has(entry.id)) {
                     return false;
                 }
-                if (entry.status === ChatSendStatus.Sending ||
-                    (entry.status === ChatSendStatus.Interrupted && entry.server_id)) {
-                    if (!entry.server_id) {
-                        await this.save({ ...entry, status: ChatSendStatus.Interrupted });
-                        return false;
-                    }
+                if (entry.status === ChatSendStatus.Sending) {
+                    await this.save({ ...entry, status: ChatSendStatus.Interrupted });
+                    return false;
                 }
                 else if (entry.status !== ChatSendStatus.Queued) {
                     return false;
                 }
                 let current = entry;
+                const request = new AbortController();
+                const requestSignal = AbortSignal.any([signal, request.signal]);
+                this.sends.set(entry.id, request);
                 try {
                     current = {
                         ...entry,
@@ -288,58 +322,30 @@ export class ChatSendQueue {
                     if (!this.current(owner, signal)) {
                         return false;
                     }
-                    if (!current.server_id) {
-                        const out = await this.opts.chat.insertOneChat({
-                            in: current.input,
-                            signal,
-                            idempotency_key: current.id,
-                        });
-                        current = {
-                            ...current,
-                            server_id: requiredOperationID(out, "Created chat response did not contain an ID."),
-                        };
-                        // Retain the returned ID even if the page/account changed meanwhile.
-                        await this.save(current);
-                    }
-                    if (!this.current(owner, signal)) {
-                        return false;
-                    }
-                    const out = await this.opts.chat.findOneChat({
-                        id: current.server_id,
-                        signal,
+                    requestSignal.throwIfAborted();
+                    const out = await this.opts.chat.insertOneChat({
+                        in: current.input,
+                        signal: requestSignal,
+                        idempotency_key: current.id,
                     });
-                    const chat = out.value;
-                    if (!chat ||
-                        chat.id !== current.server_id ||
-                        chat.owner_id !== owner ||
-                        chat.chat_room_id !== room) {
-                        throw new Error("Chat confirmation could not be resolved.");
-                    }
+                    current = {
+                        ...current,
+                        status: ChatSendStatus.Confirming,
+                        server_id: requiredOperationID(out, "Created chat response did not contain an ID."),
+                    };
+                    // Persist successful creation before advancing the room's FIFO. A
+                    // later retrieval failure must never cause this POST to be repeated.
+                    await this.save(current);
                     if (!this.current(owner, signal)) {
                         return false;
                     }
-                    this.remember(chat);
-                    if (current.attachments.files.length) {
-                        current = {
-                            ...current,
-                            chat,
-                            status: ChatSendStatus.UploadInterrupted,
-                        };
-                        await this.save(current);
-                        this.startUpload(current, owner, signal);
-                    }
-                    else {
-                        await this.opts.store.remove(current.id);
-                        this.entries = this.entries.filter((value) => value.id !== current.id);
-                        this.publish();
-                        this.opts.changed?.(chat);
-                    }
+                    this.startConfirmation(current, owner, signal);
                 }
                 catch (err) {
                     try {
                         await this.save({
                             ...current,
-                            status: signal.aborted
+                            status: requestSignal.aborted
                                 ? ChatSendStatus.Interrupted
                                 : ChatSendStatus.Failed,
                         });
@@ -347,16 +353,99 @@ export class ChatSendQueue {
                     catch (storageError) {
                         this.error = storageError;
                     }
-                    if (this.current(owner, signal)) {
+                    if (this.current(owner, signal) && !request.signal.aborted) {
                         this.error = err;
                         this.publish();
                     }
                     return false;
                 }
+                finally {
+                    this.sends.delete(entry.id);
+                }
                 return true;
             },
         });
     }
+    // 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)) {
+            return;
+        }
+        this.confirmations.add(entry.id);
+        void this.opts
+            .lock(this.confirmationLock(entry), signal, async () => {
+            if (!this.current(owner, signal)) {
+                return;
+            }
+            const stored = (await this.opts.store.list(owner)).find((value) => value.id === entry.id);
+            if (!stored || !chatSendCanConfirm(stored)) {
+                return;
+            }
+            let current = stored;
+            try {
+                const out = await this.opts.chat.findOneChat({
+                    id: current.server_id,
+                    signal,
+                });
+                const chat = out.value;
+                if (!chat ||
+                    chat.id !== current.server_id ||
+                    chat.owner_id !== owner ||
+                    chat.chat_room_id !== current.input.chat_room_id) {
+                    throw new Error("Chat confirmation could not be resolved.");
+                }
+                if (!this.current(owner, signal)) {
+                    return;
+                }
+                this.remember(chat, current.sequence);
+                if (current.attachments.files.length &&
+                    chat.has_objects &&
+                    !chat.objects_uploaded) {
+                    current = {
+                        ...current,
+                        chat,
+                        status: ChatSendStatus.UploadInterrupted,
+                    };
+                    await this.save(current);
+                    this.startUpload(current, owner, signal);
+                }
+                else {
+                    await this.opts.store.remove(current.id);
+                    this.entries = this.entries.filter((value) => value.id !== current.id);
+                    this.publish();
+                    this.opts.changed?.(chat);
+                }
+            }
+            catch (err) {
+                await this.save({
+                    ...current,
+                    status: current.chat
+                        ? ChatSendStatus.UploadInterrupted
+                        : signal.aborted
+                            ? ChatSendStatus.Interrupted
+                            : ChatSendStatus.Failed,
+                });
+                if (this.current(owner, signal)) {
+                    this.error = err;
+                    this.publish();
+                }
+            }
+        })
+            .catch((err) => {
+            if (this.current(owner, signal)) {
+                this.error = err;
+                this.publish();
+            }
+        })
+            .finally(() => {
+            this.confirmations.delete(entry.id);
+            // A pause/resume can occur before the aborted worker releases its lock.
+            if (this.enabled && signal.aborted) {
+                void this.refresh();
+            }
+        });
+    }
     startUpload(entry, owner, signal, reconcile = false) {
         if (this.uploads.has(entry.id)) {
             return;
@@ -477,6 +566,9 @@ export class ChatSendQueue {
     uploadLock(entry) {
         return `chat-upload:${entry.owner_id}:${entry.id}`;
     }
+    confirmationLock(entry) {
+        return `chat-confirm:${entry.owner_id}:${entry.id}`;
+    }
     roomLock(entry) {
         return `${entry.owner_id}:chat-send:${entry.input.chat_room_id}`;
     }
@@ -499,7 +591,11 @@ export class ChatSendQueue {
                 : this.entries.map((value) => (value.id === entry.id ? entry : value));
         this.publish();
     }
-    remember(chat) {
+    remember(chat, sequence = this.entries.find((entry) => entry.server_id === chat.id)
+        ?.sequence) {
+        if (sequence !== undefined) {
+            this.confirmedSequences.set(chat.id, sequence);
+        }
         const old = this.confirmed.get(chat.id);
         if (!old || old.updated_at <= chat.updated_at) {
             this.confirmed.set(chat.id, chat);
@@ -512,11 +608,25 @@ export class ChatSendQueue {
         }
     }
 }
+function chatSendCanConfirm(entry) {
+    return (!!entry.server_id &&
+        !entry.chat &&
+        (entry.status === ChatSendStatus.Confirming ||
+            entry.status === ChatSendStatus.Sending ||
+            entry.status === ChatSendStatus.Queued ||
+            entry.status === ChatSendStatus.Interrupted));
+}
 export function chatSendNeedsRetry(entry) {
     return (entry.status === ChatSendStatus.Failed ||
         entry.status === ChatSendStatus.Interrupted ||
         entry.status === ChatSendStatus.UploadInterrupted);
 }
 export function chatSendCanRemove(entry) {
-    return entry.status === ChatSendStatus.Queued || chatSendNeedsRetry(entry);
+    if (!entry.chat && entry.server_id) {
+        return false;
+    }
+    return (entry.status === ChatSendStatus.Saving ||
+        entry.status === ChatSendStatus.Queued ||
+        entry.status === ChatSendStatus.Sending ||
+        chatSendNeedsRetry(entry));
 }

package/package.json

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