🐛(frontend) keep the loading skeleton until an empty doc has synced

A doc never opened on this device has an empty local copy, and the
socket opening is not the content arriving either. Rendering on either
showed the empty-doc placeholder for a moment, which reads as a doc whose
content was deleted.

Signed-off-by: Dor Zairi <dorzairidev@gmail.com>

Author: MashdorDev

CHANGELOG.md

@@ -14,6 +14,7 @@ and this project adheres to
 
 - 🐛(backend) bypass throttling on access/me action from yhub
 - 🐛(frontend) switch language when the current one is untranslated #2790
+- 🐛(frontend) keep the loading skeleton until an empty doc has synced #2817
 
 ## [v6.0.0] - 2026-10-05
 

src/frontend/apps/impress/src/features/docs/doc-management/stores/__tests__/useProviderStore.test.tsx

@@ -1,4 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import * as Y from 'yjs';
 
 import { useProviderStore } from '../useProviderStore';
 
@@ -377,13 +378,54 @@ describe('useProviderStore', () => {
   it('renders as soon as the local copy is loaded, without waiting for a connection', () => {
     expect(useProviderStore.getState().isReady).toBe(false);
 
+    // the document the store built, which the local copy loads into
+    const doc = IndexeddbPersistenceMock.mock.calls[0][1] as Y.Doc;
+    doc
+      .getXmlFragment('document-store')
+      .insert(0, [new Y.XmlElement('blockGroup')]);
     persistence.emit('synced');
 
     expect(useProviderStore.getState().isReady).toBe(true);
     // nothing was connected: this is the offline path
     expect(useProviderStore.getState().isConnected).toBe(false);
   });
 
+  it('keeps loading when the local copy is empty, until the content is synced', () => {
+    // a device that never opened this doc: rendering now would show the empty-doc placeholder
+    persistence.emit('synced');
+    provider.emit('status', { status: 'connected' });
+
+    expect(useProviderStore.getState().isReady).toBe(false);
+
+    provider.synced = true;
+    provider.emit('sync', true);
+
+    expect(useProviderStore.getState().isReady).toBe(true);
+  });
+
+  it('keeps loading when the socket fails on an empty copy, until the http fallback syncs', () => {
+    // a network that blocks websocket upgrades, on a device that never opened this doc
+    persistence.emit('synced');
+    closeWith(1006);
+
+    expect(useProviderStore.getState().isReady).toBe(false);
+
+    httpProvider.synced = true;
+    httpProvider.emit('sync', true);
+
+    expect(useProviderStore.getState().isReady).toBe(true);
+  });
+
+  it('renders when the socket fails on a copy that has content', () => {
+    const doc = IndexeddbPersistenceMock.mock.calls[0][1] as Y.Doc;
+    doc
+      .getXmlFragment('document-store')
+      .insert(0, [new Y.XmlElement('blockGroup')]);
+    closeWith(1006);
+
+    expect(useProviderStore.getState().isReady).toBe(true);
+  });
+
   it('remembers the document, so the sweep leaves its copy alone', () => {
     expect(rememberLocalDocMock).toHaveBeenCalledWith('doc-id');
   });

src/frontend/apps/impress/src/features/docs/doc-management/stores/useProviderStore.tsx

@@ -123,6 +123,13 @@ const createPersistence = (storeId: string, doc: Y.Doc) => {
   }
 };
 
+/**
+ * An empty document is not worth rendering yet: on a device that never opened the doc it would
+ * show the empty-doc placeholder until the server's content lands, which reads as a deleted doc.
+ */
+const hasContent = (doc: Y.Doc) =>
+  doc.getXmlFragment('document-store').length > 0;
+
 export const useProviderStore = create<UseCollaborationStore>((set, get) => ({
   ...defaultValues,
   createProvider: (wsUrl, storeId, initialDoc, { readOnly = false } = {}) => {
@@ -146,9 +153,14 @@ export const useProviderStore = create<UseCollaborationStore>((set, get) => ({
 
       /**
        * The editor waits on `isReady` (see `DocEditor`), and local content is enough to render:
-       * whatever the connection then brings merges into what is already on screen.
+       * whatever the connection then brings merges into what is already on screen. An empty local
+       * copy is not (see `hasContent`): it waits for the sync.
        */
-      persistence.on('synced', () => set({ isReady: true }));
+      persistence.on('synced', () => {
+        if (hasContent(doc)) {
+          set({ isReady: true });
+        }
+      });
     }
 
     const provider = new WebsocketProvider(wsUrl, storeId, doc, {
@@ -213,8 +225,9 @@ export const useProviderStore = create<UseCollaborationStore>((set, get) => ({
       // for sockets that failed to open).
       if (status === 'connected') {
         clearTimeout(lostConnectionTimeout);
-        // An open socket means we are authenticated (auth happens at upgrade)
-        set({ isConnected: true, isReady: true });
+        // An open socket means we are authenticated (auth happens at upgrade). Not ready yet:
+        // the content arrives with the `sync` that follows.
+        set({ isConnected: true });
       }
     });
 
@@ -240,11 +253,16 @@ export const useProviderStore = create<UseCollaborationStore>((set, get) => ({
 
       const { isConnected: wasConnected, isReady: wasReady } = get();
 
+      // A closed socket is not the content arriving either: while the local copy is empty, the
+      // `sync` of the http fallback (started by this very close) is what makes the doc ready.
+      // Offline there is nothing to wait for, `useCollaboration` marks it ready.
+      const isReady = wasReady || hasContent(doc);
+
       // This also fires on every failed reconnect attempt - forever, on a network that never
       // lets the socket open. Skip the `set()` once these are already at this value, or a
       // same-value write still hands every no-selector subscriber a new object to re-render on.
-      if (wasConnected || !wasReady) {
-        set({ isConnected: false, isReady: true });
+      if (wasConnected || isReady !== wasReady) {
+        set({ isConnected: false, isReady });
       }
 
       // Only a connection that had actually opened can have been *lost* in a way that means