fix(frontend): rich mode uses sendable.version as clientVersion and skips this.version on 409

static/collab-client.js

···
 export class CollabClient {
     constructor(rkey, initialVersion, applyRemoteSteps) {
         this.rkey = rkey;
-        this.version = initialVersion;
+        this.version = initialVersion; // authoritative for source mode; advisory for rich mode
         this.applyRemoteSteps = applyRemoteSteps;
         this._inflight = false;
-        this._queue = [];           // used by source mode (text-patch steps)
-        this._pmGetSendable = null; // set by rich mode; returns {steps, clientID} or null
+        this._queue = [];           // source mode only
+        this._pmGetSendable = null; // rich mode: () => sendableSteps(pmView.state) | null
     }
 
     // Source mode: queue explicit step objects and flush.
···
         this._flush();
     }
 
-    // Rich mode: register a callback that returns sendable PM steps on demand.
-    // The callback should call sendableSteps(pmView.state) and return the result,
-    // or null if nothing to send.
+    // Rich mode: register the sendable-steps provider.
     setPMSendable(fn) {
         this._pmGetSendable = fn;
+        this._queue = []; // clear any stale source-mode queue
     }
 
-    // Signal that a PM transaction occurred; try to flush if not already in-flight.
+    // Rich mode: call after every PM transaction to trigger a flush attempt.
     notifyPMChange() {
         this._flush();
     }
···
         if (this._inflight) return;
 
         let toSend;
-        let isRichMode = false;
+        let clientVersion;
+        const isRichMode = !!this._pmGetSendable;
 
-        if (this._pmGetSendable) {
-            // Rich mode: ask prosemirror-collab what needs sending.
+        if (isRichMode) {
             const sendable = this._pmGetSendable();
             if (!sendable || sendable.steps.length === 0) return;
+            // Use version from the collab plugin state — always authoritative.
+            clientVersion = sendable.version;
             toSend = sendable.steps.map(s => ({type: 'pm-step', json: JSON.stringify(s.toJSON())}));
-            isRichMode = true;
         } else {
-            // Source mode: drain the queue.
             if (this._queue.length === 0) return;
+            clientVersion = this.version;
             toSend = this._queue.slice();
         }
 
···
                 method: 'POST',
                 headers: {'Content-Type': 'application/json'},
                 body: JSON.stringify({
-                    clientVersion: this.version,
+                    clientVersion,
                     steps: toSend.map(s => JSON.stringify(s)),
                     clientID: this._clientID || '',
                 }),
···
                 if (!isRichMode) {
                     this._queue = this._queue.slice(toSend.length);
                 }
-                // Rich mode: prosemirror-collab tracks confirmation via receiveTransaction;
-                // no queue to drain here.
+                // Rich mode: the collab plugin tracks confirmation internally;
+                // this.version is updated here as a fallback for WebSocket-less paths.
             } else if (resp.status === 409) {
-                const {version, steps: missedJSON} = await resp.json();
+                const {steps: missedJSON} = await resp.json();
                 const missed = missedJSON.map(s => JSON.parse(s));
+                // Apply missed steps — for rich mode this calls receiveTransaction
+                // which rebases our unconfirmed steps and updates the collab plugin state.
+                // Do NOT update this.version here; the collab plugin owns that for rich mode.
                 this.applyRemoteSteps(missed);
-                this.version = version;
+                // Retry after a short delay so the PM state settles.
+                setTimeout(() => this._flush(), 30);
+                return; // skip the finally retry below
             } else {
                 console.error('CollabClient: unexpected status', resp.status);
             }
···
             console.error('CollabClient: fetch error', e);
         } finally {
             this._inflight = false;
-            // Retry if there's more to send.
-            const hasMore = this._pmGetSendable
+            const hasMore = isRichMode
                 ? (this._pmGetSendable()?.steps.length > 0)
                 : this._queue.length > 0;
             if (hasMore) {
···
     handleWSMessage(msg, myClientID) {
         if (msg.type !== 'steps') return;
         if (msg.clientID === myClientID) {
+            // Our steps confirmed via WebSocket broadcast — update advisory version.
             this.version = msg.version;
             return;
         }