fix(frontend): confirm own PM steps via receiveTransaction after successful POST to advance collab plugin version

static/collab-client.js

···
 export class CollabClient {
     constructor(rkey, initialVersion, applyRemoteSteps) {
         this.rkey = rkey;
-        this.version = initialVersion; // authoritative for source mode; advisory for rich mode
+        this.version = initialVersion; // authoritative for source mode
         this.applyRemoteSteps = applyRemoteSteps;
         this._inflight = false;
         this._queue = [];           // source mode only
-        this._pmGetSendable = null; // rich mode: () => sendableSteps(pmView.state) | null
+        this._pmGetSendable = null; // rich mode: () => sendableSteps(state) | null
+        this._pmConfirm = null;     // rich mode: (steps, clientIDs) => void — confirms sent steps
     }
 
     // Source mode: queue explicit step objects and flush.
···
         this._flush();
     }
 
-    // Rich mode: register the sendable-steps provider.
-    setPMSendable(fn) {
-        this._pmGetSendable = fn;
-        this._queue = []; // clear any stale source-mode queue
+    // Rich mode: register the sendable-steps provider and confirmation callback.
+    // getSendable: () => { steps, version } | null  (calls sendableSteps(pmState))
+    // confirm:     (steps, clientIDs) => void        (calls receiveTransaction on own steps)
+    setPMHandlers(getSendable, confirm) {
+        this._pmGetSendable = getSendable;
+        this._pmConfirm = confirm;
+        this._queue = [];
     }
 
-    // Rich mode: call after every PM transaction to trigger a flush attempt.
+    // Rich mode: call after every PM transaction.
     notifyPMChange() {
         this._flush();
     }
···
     async _flush() {
         if (this._inflight) return;
 
-        let toSend;
-        let clientVersion;
         const isRichMode = !!this._pmGetSendable;
+        let toSend, clientVersion, sentSteps;
 
         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())}));
+            sentSteps = sendable.steps; // keep reference to confirm on success
+            toSend = sentSteps.map(s => ({type: 'pm-step', json: JSON.stringify(s.toJSON())}));
         } else {
             if (this._queue.length === 0) return;
             clientVersion = this.version;
···
             if (resp.ok) {
                 const {version} = await resp.json();
                 this.version = version;
-                if (!isRichMode) {
+                if (isRichMode) {
+                    // Confirm our own steps in the collab plugin so it advances its
+                    // version counter and clears the unconfirmed buffer.
+                    if (this._pmConfirm && sentSteps) {
+                        this._pmConfirm(sentSteps, sentSteps.map(() => this._clientID || ''));
+                    }
+                } else {
                     this._queue = this._queue.slice(toSend.length);
                 }
-                // 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 {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.
+                // Apply missed steps — for rich mode this calls receiveTransaction which
+                // rebases unconfirmed steps and advances the collab plugin version.
                 this.applyRemoteSteps(missed);
-                // Retry after a short delay so the PM state settles.
                 setTimeout(() => this._flush(), 30);
-                return; // skip the finally retry below
+                return; // skip finally retry
             } else {
                 console.error('CollabClient: unexpected status', resp.status);
             }
···
     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;
+            // Our own steps echoed back — version already advanced by POST success path.
             return;
         }
         const steps = msg.steps.map(s => JSON.parse(s));

templates/document_edit.html

···
             })
             .create();
 
-        // Register the PM sendable-steps provider so CollabClient reads directly
-        // from prosemirror-collab's unconfirmed buffer rather than a separate queue.
-        collabClient.setPMSendable(() => {
-            const pmView = milkdownEditor.action(c => c.get(editorViewCtx));
-            return sendableSteps(pmView.state);
-        });
+        // Register PM handlers so CollabClient reads sendableSteps and confirms
+        // its own steps via receiveTransaction (advancing the collab plugin version).
+        collabClient.setPMHandlers(
+            () => {
+                const pmView = milkdownEditor.action(c => c.get(editorViewCtx));
+                return sendableSteps(pmView.state);
+            },
+            (steps, clientIDs) => {
+                const pmView = milkdownEditor.action(c => c.get(editorViewCtx));
+                applyingRemote = true;
+                try {
+                    const tr = receiveTransaction(pmView.state, steps, clientIDs);
+                    pmView.dispatch(tr);
+                } finally {
+                    applyingRemote = false;
+                }
+            }
+        );
 
         return milkdownEditor;
     }
···
             const doc = cmView.state.doc;
             cmView.dispatch({ changes: { from: 0, to: doc.length, insert: md } });
             updatePreview(md);
-            collabClient.setPMSendable(null);  // detach from stale Milkdown instance
+            collabClient.setPMHandlers(null, null);  // detach from stale Milkdown instance
         } else {
             // source → rich: extract markdown from CodeMirror, recreate Milkdown
             const md = cmView.state.doc.toString();
-            await createMilkdownEditor(md);    // setPMSendable called inside
+            await createMilkdownEditor(md);    // setPMHandlers called inside
         }
 
         currentMode = nextMode;