@fabriktor/fx 0.0.102 → 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,11 @@ 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;
@@ -73,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,25 @@ 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();
@@ -44,6 +47,7 @@ export class ChatSendQueue {
         return {
             entries: this.entries,
             confirmed: [...this.confirmed.values()],
+            confirmed_sequences: Object.fromEntries(this.confirmedSequences),
             error: this.error,
         };
     }
@@ -61,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;
@@ -157,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);
                 }
@@ -197,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;
             }
@@ -209,7 +219,12 @@ 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();
@@ -270,7 +285,7 @@ export class ChatSendQueue {
             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;
@@ -286,12 +301,9 @@ export class ChatSendQueue {
                 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;
@@ -310,53 +322,24 @@ export class ChatSendQueue {
                     if (!this.current(owner, signal)) {
                         return false;
                     }
-                    if (!current.server_id) {
-                        requestSignal.throwIfAborted();
-                        const out = await this.opts.chat.insertOneChat({
-                            in: current.input,
-                            signal: requestSignal,
-                            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 {
@@ -383,6 +366,86 @@ 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)) {
+            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;
@@ -503,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}`;
     }
@@ -525,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);
@@ -538,6 +608,14 @@ 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 ||

package/package.json

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