collabmd 0.1.38 → 0.1.40

package/src/client/excalidraw-editor.js

@@ -10,7 +10,9 @@ import {
 import '@excalidraw/excalidraw/index.css';
 
 import {
+  buildRenderableCollaboratorsMap,
   findCollaboratorByPeerId,
+  getCollaboratorsRenderSignature,
   mergeAwarenessUserPatch,
   resolveLocalAwarenessUser,
 } from './domain/excalidraw-collaboration.js';
@@ -24,6 +26,9 @@ import {
   parseSceneJson,
   sceneToInitialData,
 } from './domain/excalidraw-scene.js';
+import {
+  buildReconciledExcalidrawSceneUpdate,
+} from './domain/excalidraw-scene-reconcile.js';
 import {
   normalizeDocumentMode,
 } from './domain/excalidraw-document-switch.js';
@@ -60,10 +65,12 @@ let pendingHostFollowPeerId = null;
 let suppressViewportBroadcast = false;
 let pendingViewportSuppressionReleases = 0;
 let lastAppliedFollowViewportSignature = '';
+let lastRenderedCollaboratorsSignature = '';
 let apiStateCleanupCallbacks = [];
 let collaboratorRenderFrame = 0;
 let queuedCollaborators = null;
 let initialViewportFitPending = true;
+let previewViewportFitTimerId = 0;
 let roomClient = null;
 let roomClientGeneration = 0;
 let reactRoot = null;
@@ -79,6 +86,10 @@ function getDocumentViewState(mode = currentDocument.mode) {
   };
 }
 
+function applyDocumentMode(mode = currentDocument.mode) {
+  document.body.dataset.documentMode = normalizeDocumentMode(mode);
+}
+
 function createRoomClient(filePath) {
   const generation = ++roomClientGeneration;
   const client = new ExcalidrawRoomClient({
@@ -295,16 +306,21 @@ if (isTestMode) {
 
 function applyCollaborators(collaborators) {
   activeCollaborators = collaborators instanceof Map ? collaborators : new Map();
+  const renderableCollaborators = buildRenderableCollaboratorsMap(activeCollaborators);
+  const renderSignature = getCollaboratorsRenderSignature(renderableCollaborators);
 
   if (!excalidrawAPI) {
     pendingCollaborators = activeCollaborators;
     return;
   }
 
-  excalidrawAPI.updateScene({
-    collaborators: activeCollaborators,
-    captureUpdate: CaptureUpdateAction.NEVER,
-  });
+  if (renderSignature !== lastRenderedCollaboratorsSignature) {
+    lastRenderedCollaboratorsSignature = renderSignature;
+    excalidrawAPI.updateScene({
+      collaborators: renderableCollaborators,
+      captureUpdate: CaptureUpdateAction.NEVER,
+    });
+  }
 
   if (pendingHostFollowPeerId) {
     applyHostFollowRequest(pendingHostFollowPeerId);
@@ -328,10 +344,29 @@ function queueCollaboratorsRender(collaborators) {
   });
 }
 
-function applySceneFromJson(rawJson) {
+function isEditingTextElement() {
+  return Boolean(excalidrawAPI?.getAppState?.()?.editingTextElement);
+}
+
+function flushPendingRemoteScene() {
+  if (!pendingRemoteSceneJson || !excalidrawAPI || !collabReady || isEditingTextElement()) {
+    return false;
+  }
+
+  const sceneJson = pendingRemoteSceneJson;
+  pendingRemoteSceneJson = '';
+  applySceneFromJson(sceneJson, {
+    force: true,
+  });
+  return true;
+}
+
+function applySceneFromJson(rawJson, {
+  force = false,
+} = {}) {
   const scene = parseSceneJson(rawJson);
   const normalizedJson = JSON.stringify(scene);
-  if (normalizedJson === appliedSceneJson && !pendingRemoteSceneJson) {
+  if (!force && normalizedJson === appliedSceneJson && !pendingRemoteSceneJson) {
     return;
   }
 
@@ -342,9 +377,12 @@ function applySceneFromJson(rawJson) {
     return;
   }
 
-  updateApiScene(scene, {
-    replaceElements: true,
-  });
+  if (!force && isEditingTextElement()) {
+    pendingRemoteSceneJson = normalizedJson;
+    return;
+  }
+
+  updateApiScene(scene);
 }
 
 function releaseOnChangeSuppressionAfterPaint({ trackedSharedSnapshot = false } = {}) {
@@ -376,30 +414,21 @@ function releaseViewportBroadcastSuppressionAfterPaint() {
 
 function buildApiSceneUpdate(scene, {
   appStateOverrides = {},
-  replaceElements = false,
 } = {}) {
   const currentAppState = excalidrawAPI.getAppState();
-  const currentElements = replaceElements
-    ? []
-    : (excalidrawAPI.getSceneElementsIncludingDeleted?.() || excalidrawAPI.getSceneElements());
-  const restoredElements = restoreElements(scene?.elements || [], currentElements, {
-    repairBindings: true,
-  });
-  const restoredAppState = restoreAppState(scene?.appState || {}, currentAppState);
-  const reconciledElements = replaceElements
-    ? restoredElements
-    : reconcileElements(currentElements, restoredElements, currentAppState);
+  const currentElements = excalidrawAPI.getSceneElementsIncludingDeleted?.() || excalidrawAPI.getSceneElements();
 
-  return {
-    appState: {
-      theme: currentTheme,
-      viewBackgroundColor: restoredAppState.viewBackgroundColor ?? '#ffffff',
-      gridSize: restoredAppState.gridSize ?? null,
-      ...getDocumentViewState(),
-      ...appStateOverrides,
-    },
-    elements: reconciledElements,
-  };
+  return buildReconciledExcalidrawSceneUpdate({
+    appStateOverrides,
+    currentAppState,
+    currentElements,
+    documentViewState: getDocumentViewState(),
+    reconcileElementsFn: reconcileElements,
+    restoreAppStateFn: restoreAppState,
+    restoreElementsFn: restoreElements,
+    scene,
+    theme: currentTheme,
+  });
 }
 
 function logFileConflictOnce(conflictingFileIds = []) {
@@ -437,12 +466,10 @@ function requestEditorRemount(scene) {
 function applySceneToMountedApi(scene, {
   appStateOverrides = {},
   captureUpdate = CaptureUpdateAction.NEVER,
-  replaceElements = false,
   trackedSharedSnapshot = false,
 } = {}) {
   const nextSceneUpdate = buildApiSceneUpdate(scene, {
     appStateOverrides,
-    replaceElements,
   });
   let applyResult = null;
 
@@ -484,13 +511,11 @@ function applySceneToMountedApi(scene, {
 function updateApiScene(scene, {
   appStateOverrides = {},
   captureUpdate = CaptureUpdateAction.NEVER,
-  replaceElements = false,
   trackedSharedSnapshot = true,
 } = {}) {
   applySceneToMountedApi(scene, {
     appStateOverrides,
     captureUpdate,
-    replaceElements,
     trackedSharedSnapshot,
   });
 }
@@ -520,6 +545,10 @@ function onRoomTextUpdate() {
   applySceneFromJson(roomClient?.getLastSceneJson?.() || '');
 }
 
+function getLiveSceneElementsForSync(fallbackElements = []) {
+  return excalidrawAPI?.getSceneElementsIncludingDeleted?.() || fallbackElements;
+}
+
 function postToParent(type, payload = {}) {
   window.parent.postMessage({ source: 'excalidraw-editor', type, ...payload }, parentOrigin);
 }
@@ -541,8 +570,17 @@ function getSceneElementsForPreviewFit() {
   );
 }
 
-function scheduleInitialViewportFit() {
-  if (!initialViewportFitPending || !excalidrawAPI) {
+function scheduleViewportFit({
+  delayMs = 0,
+  forcePreview = false,
+  consumeInitialFit = false,
+} = {}) {
+  const normalizedMode = normalizeDocumentMode(currentDocument.mode);
+  if (!excalidrawAPI || (forcePreview && normalizedMode !== 'preview')) {
+    return;
+  }
+
+  if (!forcePreview && !initialViewportFitPending) {
     return;
   }
 
@@ -550,22 +588,55 @@ function scheduleInitialViewportFit() {
   if (elements.length === 0) {
     return;
   }
-  initialViewportFitPending = false;
+  if (consumeInitialFit) {
+    initialViewportFitPending = false;
+  }
 
-  requestAnimationFrame(() => {
-    requestAnimationFrame(() => {
-      if (!excalidrawAPI) {
-        return;
-      }
+  if (previewViewportFitTimerId) {
+    window.clearTimeout(previewViewportFitTimerId);
+  }
 
-      excalidrawAPI.scrollToContent(elements, {
-        animate: false,
-        fitToViewport: true,
-        maxZoom: 2,
-        viewportZoomFactor: normalizeDocumentMode(currentDocument.mode) === 'preview' ? 0.92 : 0.88,
+  previewViewportFitTimerId = window.setTimeout(() => {
+    previewViewportFitTimerId = 0;
+    requestAnimationFrame(() => {
+      requestAnimationFrame(() => {
+        if (!excalidrawAPI) {
+          return;
+        }
+
+        const latestElements = getSceneElementsForPreviewFit();
+        if (latestElements.length === 0) {
+          return;
+        }
+
+        if (forcePreview) {
+          suppressViewportBroadcast = true;
+        }
+
+        excalidrawAPI.scrollToContent(latestElements, {
+          animate: false,
+          fitToViewport: true,
+          maxZoom: 2,
+          viewportZoomFactor: normalizedMode === 'preview' ? 0.92 : 0.88,
+        });
+
+        if (forcePreview) {
+          releaseViewportBroadcastSuppressionAfterPaint();
+        }
       });
     });
-  });
+  }, delayMs);
+}
+
+function scheduleInitialViewportFit() {
+  scheduleViewportFit({ consumeInitialFit: true });
+}
+
+function schedulePreviewViewportFit() {
+  scheduleViewportFit({ forcePreview: true, delayMs: 80 });
+  window.setTimeout(() => {
+    scheduleViewportFit({ forcePreview: true });
+  }, 240);
 }
 
 function syncLocalViewportToRoom() {
@@ -674,6 +745,7 @@ function resetRealtimeRoomState() {
   suppressViewportBroadcast = false;
   pendingViewportSuppressionReleases = 0;
   lastAppliedFollowViewportSignature = '';
+  lastRenderedCollaboratorsSignature = '';
   if (collaboratorRenderFrame) {
     cancelAnimationFrame(collaboratorRenderFrame);
   }
@@ -776,6 +848,11 @@ window.addEventListener('message', (event) => {
     return;
   }
 
+  if (message.type === 'fit-preview-viewport') {
+    schedulePreviewViewportFit();
+    return;
+  }
+
   if (message.type === 'prepare-disconnect') {
     void (async () => {
       await prepareRealtimeRoomDisconnect();
@@ -799,17 +876,8 @@ function scheduleSyncToRoom(elements, appState, files) {
     return;
   }
 
-  const nextSceneJson = JSON.stringify(normalizeScene({
-    elements,
-    appState,
-    files,
-  }));
-  if (nextSceneJson === appliedSceneJson) {
-    return;
-  }
-
-  appliedSceneJson = nextSceneJson;
-  roomClient.scheduleSceneSync(elements, appState, files);
+  const liveElements = getLiveSceneElementsForSync(elements);
+  roomClient.scheduleSceneSync(liveElements, appState, files);
 }
 
 function initializeEditor(api) {
@@ -828,14 +896,27 @@ function initializeEditor(api) {
 
     setFollowedSocket(null, { force: true });
   }));
+  apiStateCleanupCallbacks.push(api.onStateChange('editingTextElement', (editingTextElement) => {
+    if (!editingTextElement) {
+      requestAnimationFrame(() => {
+        requestAnimationFrame(() => {
+          flushPendingRemoteScene();
+        });
+      });
+    }
+  }));
 
   const sceneJson = pendingRemoteSceneJson || roomClient?.getLastSceneJson?.() || '';
+  const initialScene = parseSceneJson(sceneJson);
   pendingRemoteSceneJson = '';
-  updateApiScene(parseSceneJson(sceneJson));
+  appliedSceneJson = JSON.stringify(initialScene);
+  updateApiScene(initialScene);
 
   if (pendingCollaborators) {
+    const renderableCollaborators = buildRenderableCollaboratorsMap(pendingCollaborators);
+    lastRenderedCollaboratorsSignature = getCollaboratorsRenderSignature(renderableCollaborators);
     excalidrawAPI.updateScene({
-      collaborators: pendingCollaborators,
+      collaborators: renderableCollaborators,
       captureUpdate: CaptureUpdateAction.NEVER,
     });
     pendingCollaborators = null;
@@ -863,6 +944,7 @@ async function init() {
 
   try {
     applySurfaceTheme(currentTheme);
+    applyDocumentMode();
     await ensureClientAuthenticated();
     const initialScene = await connectDocumentClient(currentDocument.filePath);
     if (!initialScene) {

package/src/client/infrastructure/editor-session.js

@@ -218,6 +218,10 @@ export class EditorSession {
     return this.viewAdapter.scrollToLine(lineNumber, viewportRatio);
   }
 
+  revealSearchMatch(match) {
+    return this.viewAdapter.revealSearchMatch(match);
+  }
+
   getUserCursor(clientId) {
     return this.collaborationClient.getUserCursor(
       clientId,

package/src/client/infrastructure/editor-view-adapter.js

@@ -38,14 +38,15 @@ import {
 } from '@codemirror/view';
 import { yCollab } from 'y-codemirror.next';
 
-import { isBaseFilePath, isPlantUmlFilePath } from '../../domain/file-kind.js';
+import { isBaseFilePath, isMermaidFilePath, isPlantUmlFilePath } from '../../domain/file-kind.js';
 import { normalizeCommentQuote } from '../../domain/comment-threads.js';
 import { createMarkdownToolbarEdit } from '../domain/markdown-formatting.js';
+import { mermaidLanguage, mermaidLanguageDescription } from '../domain/mermaid-language.js';
 import { wikiLinkCompletions } from '../domain/wiki-link-completions.js';
 import { plantUmlLanguage, plantUmlLanguageDescription } from '../domain/plantuml-language.js';
 import { handleImagePasteEvent } from './editor-paste-utils.js';
 
-const markdownCodeLanguages = [...languages, plantUmlLanguageDescription];
+const markdownCodeLanguages = [...languages, mermaidLanguageDescription, plantUmlLanguageDescription];
 const pairedMatchingBracketMark = Decoration.mark({ class: 'cm-matchingBracket cm-matchingBracket-paired' });
 const nonmatchingBracketMark = Decoration.mark({ class: 'cm-nonmatchingBracket' });
 const remoteUpdateMark = Decoration.mark({ class: 'cm-remoteUpdateFlash' });
@@ -299,6 +300,10 @@ function createEditorTheme(theme) {
 }
 
 export function createLanguageExtension(filePath) {
+  if (isMermaidFilePath(filePath)) {
+    return mermaidLanguage;
+  }
+
   if (isPlantUmlFilePath(filePath)) {
     return plantUmlLanguage;
   }
@@ -846,6 +851,36 @@ export class EditorViewAdapter {
     return true;
   }
 
+  revealSearchMatch({ column = 1, length = 0, line = 1 } = {}) {
+    const state = this.editorView?.state;
+    if (!state || !this.editorView) {
+      return false;
+    }
+
+    const targetLineNumber = Math.min(
+      Math.max(Math.round(Number(line) || 1), 1),
+      state.doc.lines,
+    );
+    const targetLine = state.doc.line(targetLineNumber);
+    const columnOffset = Math.min(
+      Math.max(Math.round(Number(column) || 1) - 1, 0),
+      targetLine.length,
+    );
+    const from = targetLine.from + columnOffset;
+    const to = Math.min(
+      from + Math.max(Math.round(Number(length) || 0), 0),
+      targetLine.to,
+    );
+
+    this.editorView.dispatch({
+      scrollIntoView: true,
+      selection: EditorSelection.range(from, Math.max(to, from)),
+    });
+    this.editorView.focus();
+    this.scrollToLine(targetLineNumber, 0.2);
+    return true;
+  }
+
   scrollToPosition(position, alignment = 'center') {
     const state = this.editorView?.state;
     const scroller = this.editorView?.scrollDOM;

package/src/client/infrastructure/excalidraw-room-client.js

@@ -30,6 +30,48 @@ const DEFAULT_EMPTY_SCENE_GUARD_MS = 250;
 const DEFAULT_SAVE_THROTTLE_MS = 48;
 const DEFAULT_SYNC_TIMEOUT_MS = 4000;
 
+function stableJson(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map((entry) => stableJson(entry)).join(',')}]`;
+  }
+
+  if (value && typeof value === 'object') {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`).join(',')}}`;
+  }
+
+  return JSON.stringify(value);
+}
+
+function normalizeElementVersion(value) {
+  const version = Number(value);
+  return Number.isFinite(version) ? version : 0;
+}
+
+function normalizeElementVersionNonce(value) {
+  const versionNonce = Number(value);
+  return Number.isFinite(versionNonce) ? versionNonce : 0;
+}
+
+function shouldSyncElementToRoom(localElement, roomElement) {
+  if (!localElement?.id) {
+    return false;
+  }
+
+  if (!roomElement) {
+    return true;
+  }
+
+  const localVersion = normalizeElementVersion(localElement.version);
+  const roomVersion = normalizeElementVersion(roomElement.version);
+  if (localVersion !== roomVersion) {
+    return localVersion > roomVersion;
+  }
+
+  const localVersionNonce = normalizeElementVersionNonce(localElement.versionNonce);
+  const roomVersionNonce = normalizeElementVersionNonce(roomElement.versionNonce);
+  return localVersionNonce < roomVersionNonce;
+}
+
 export class ExcalidrawRoomClient {
   constructor({
     cancelAnimationFrameFn = (frameId) => cancelAnimationFrame(frameId),
@@ -74,6 +116,7 @@ export class ExcalidrawRoomClient {
     this.handleProviderSync = null;
     this.lastSceneJson = '';
     this.sceneSyncTimer = null;
+    this.sceneSyncDueAt = 0;
     this.lastSceneSyncAt = 0;
     this.pendingSceneSyncPayload = null;
     this.pointerAwarenessFrame = 0;
@@ -86,6 +129,7 @@ export class ExcalidrawRoomClient {
     this.canWriteToRoom = false;
     this.waitingForAuthoritativeSync = false;
     this.applyingSharedSnapshotDepth = 0;
+    this.suppressStructuredSceneUpdateDepth = 0;
 
     this.handleAwarenessChange = () => {
       this.onCollaboratorsChange(buildCollaboratorsMap(this.awareness));
@@ -96,6 +140,10 @@ export class ExcalidrawRoomClient {
         return;
       }
 
+      if (this.suppressStructuredSceneUpdateDepth > 0) {
+        return;
+      }
+
       const remoteJson = this.getStructuredSceneJson();
       if (!remoteJson || remoteJson === this.lastSceneJson) {
         return;
@@ -386,6 +434,40 @@ export class ExcalidrawRoomClient {
     return nextAppState;
   }
 
+  buildLiveSceneDelta({
+    appState,
+    baseSceneJson,
+    elements,
+    files,
+  } = {}) {
+    const roomSceneJson = this.getStructuredSceneJson() || this.lastSceneJson || baseSceneJson;
+    const roomScene = parseSceneJson(roomSceneJson);
+    const nextAppState = this.mergeLocallyChangedAppState(appState, baseSceneJson);
+    const roomElementsById = new Map(roomScene.elements.map((element) => [element.id, element]));
+    const changedElements = (Array.isArray(elements) ? elements : []).filter((element) => (
+      shouldSyncElementToRoom(element, roomElementsById.get(element?.id))
+    ));
+    const nextFiles = files && typeof files === 'object' ? files : {};
+    const changedFiles = Object.fromEntries(
+      Object.entries(nextFiles).filter(([fileId, file]) => (
+        stableJson(file) !== stableJson(roomScene.files?.[fileId])
+      )),
+    );
+    const appStateChanged = (
+      nextAppState.gridSize !== roomScene.appState?.gridSize
+      || nextAppState.viewBackgroundColor !== roomScene.appState?.viewBackgroundColor
+    );
+
+    return {
+      hasChanges: changedElements.length > 0 || Object.keys(changedFiles).length > 0 || appStateChanged,
+      scene: buildLiveCollaborationScene(
+        changedElements,
+        nextAppState,
+        changedFiles,
+      ),
+    };
+  }
+
   scheduleSceneSync(elements, appState, files) {
     this.pendingSceneSyncPayload = {
       appState,
@@ -401,14 +483,20 @@ export class ExcalidrawRoomClient {
   }
 
   scheduleSceneSyncFlush() {
-    if (this.sceneSyncTimer !== null) {
+    const elapsed = this.now() - this.lastSceneSyncAt;
+    const delay = Math.max(0, this.saveThrottleMs - elapsed);
+    const dueAt = this.now() + delay;
+    if (this.sceneSyncTimer !== null && this.sceneSyncDueAt <= dueAt) {
       return;
     }
 
-    const elapsed = this.now() - this.lastSceneSyncAt;
-    const delay = Math.max(0, this.saveThrottleMs - elapsed);
+    if (this.sceneSyncTimer !== null) {
+      this.clearTimeoutFn(this.sceneSyncTimer);
+    }
+    this.sceneSyncDueAt = dueAt;
     this.sceneSyncTimer = this.setTimeoutFn(() => {
       this.sceneSyncTimer = null;
+      this.sceneSyncDueAt = 0;
       this.flushSceneSync();
     }, delay);
   }
@@ -426,30 +514,45 @@ export class ExcalidrawRoomClient {
     } = this.pendingSceneSyncPayload;
     this.pendingSceneSyncPayload = null;
 
-    const sceneData = buildLiveCollaborationScene(
-      elements,
-      this.mergeLocallyChangedAppState(appState, baseSceneJson),
-      files,
-    );
-    const json = JSON.stringify(sceneData);
-    if (this.shouldDelayEmptySceneCommit(json)) {
-      this.pendingSceneSyncPayload = {
-        appState,
-        baseSceneJson,
+    if (Array.isArray(elements) && elements.length === 0) {
+      const emptyCandidate = buildLiveCollaborationScene(
         elements,
+        this.mergeLocallyChangedAppState(appState, baseSceneJson),
         files,
-      };
-      this.scheduleDelayedEmptySceneCommit();
-      return;
+      );
+      if (this.shouldDelayEmptySceneCommit(JSON.stringify(emptyCandidate))) {
+        this.pendingSceneSyncPayload = {
+          appState,
+          baseSceneJson,
+          elements,
+          files,
+        };
+        this.scheduleDelayedEmptySceneCommit();
+        return;
+      }
     }
 
-    if (json !== this.lastSceneJson) {
-      this.lastSceneSyncAt = this.now();
-      this.commitSceneJson(json, {
-        origin: 'excalidraw-local-change',
-      });
+    const {
+      hasChanges,
+      scene: sceneData,
+    } = this.buildLiveSceneDelta({
+      appState,
+      baseSceneJson,
+      elements,
+      files,
+    });
+
+    if (!hasChanges) {
+      this.pendingEmptySceneCandidate = null;
+      return;
     }
 
+    const json = JSON.stringify(sceneData);
+    this.lastSceneSyncAt = this.now();
+    this.commitSceneJson(json, {
+      origin: 'excalidraw-local-change',
+    });
+
     this.pendingEmptySceneCandidate = null;
 
     if (this.pendingSceneSyncPayload) {
@@ -510,8 +613,10 @@ export class ExcalidrawRoomClient {
     const firstSeenAt = this.pendingEmptySceneCandidate?.firstSeenAt ?? this.now();
     const elapsed = this.now() - firstSeenAt;
     const delay = Math.max(0, this.emptySceneGuardMs - elapsed);
+    this.sceneSyncDueAt = this.now() + delay;
     this.sceneSyncTimer = this.setTimeoutFn(() => {
       this.sceneSyncTimer = null;
+      this.sceneSyncDueAt = 0;
       this.flushSceneSync();
     }, delay);
   }
@@ -634,19 +739,25 @@ export class ExcalidrawRoomClient {
       return false;
     }
 
-    this.lastSceneJson = normalizedJson;
-
-    this.ydoc.transact(() => {
-      applySceneDiffToExcalidrawRoom(this.ydoc, parseSceneJson(normalizedJson));
-    }, origin);
+    let didChange = false;
+    this.suppressStructuredSceneUpdateDepth += 1;
+    try {
+      this.ydoc.transact(() => {
+        didChange = applySceneDiffToExcalidrawRoom(this.ydoc, parseSceneJson(normalizedJson));
+      }, origin);
+    } finally {
+      this.suppressStructuredSceneUpdateDepth = Math.max(0, this.suppressStructuredSceneUpdateDepth - 1);
+    }
 
-    return true;
+    this.lastSceneJson = JSON.stringify(parseSceneJson(this.getStructuredSceneJson() || normalizedJson));
+    return didChange;
   }
 
   disconnect() {
     this.flushSceneSync();
     this.clearTimeoutFn(this.sceneSyncTimer);
     this.sceneSyncTimer = null;
+    this.sceneSyncDueAt = 0;
     this.pendingSceneSyncPayload = null;
 
     if (this.pointerAwarenessFrame) {
@@ -692,5 +803,6 @@ export class ExcalidrawRoomClient {
     this.canWriteToRoom = false;
     this.waitingForAuthoritativeSync = false;
     this.applyingSharedSnapshotDepth = 0;
+    this.suppressStructuredSceneUpdateDepth = 0;
   }
 }