diff --git a/playwright/e2e/synchronize-content/untouched.spec.ts b/playwright/e2e/synchronize-content/untouched.spec.ts
new file mode 100644
index 00000000000..989e6030a72
--- /dev/null
+++ b/playwright/e2e/synchronize-content/untouched.spec.ts
@@ -0,0 +1,28 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { expect, mergeTests } from '@playwright/test'
+import { test as editorTest } from '../../support/fixtures/editor.ts'
+import { test as uploadFileTest } from '../../support/fixtures/upload-file.ts'
+
+const test = mergeTests(editorTest, uploadFileTest)
+
+test.use({ fileContent: '## Hello world\n' })
+
+test('does not save an untouched file', async ({ close, editor, open, page }) => {
+ const saves: string[] = []
+ page.on('request', (request) => {
+ if (/\/session\/.*\/save/.test(request.url())) {
+ saves.push(request.url())
+ }
+ })
+ const push = page.waitForResponse(/\/session\/.*\/push/)
+ await open()
+ await expect(editor.getHeading({ name: 'Hello world' })).toBeVisible()
+ await push
+ await expect(editor.saveIndicator).not.toHaveAccessibleName(/Unsaved changes/)
+ await close()
+ expect(saves).toEqual([])
+})
diff --git a/src/components/CollaborativeEditor.vue b/src/components/CollaborativeEditor.vue
index 7937d5cdff5..f92f4db0467 100644
--- a/src/components/CollaborativeEditor.vue
+++ b/src/components/CollaborativeEditor.vue
@@ -651,8 +651,13 @@ export default defineComponent({
content,
isRichEditor: this.isRichEditor,
})
+ // Every client generates the same initial state from the file content.
+ // Mark it as received from the server so it is neither pushed nor saved.
+ // The first local change pushes it along, as the provider sends
+ // everything the server does not have yet.
setInitialYjsState(this.ydoc, content, {
isRichEditor: this.isRichEditor,
+ origin: this.syncProvider,
})
}
})
diff --git a/src/composables/useSaveService.ts b/src/composables/useSaveService.ts
index 6106ae46984..61d6cd9e2f8 100644
--- a/src/composables/useSaveService.ts
+++ b/src/composables/useSaveService.ts
@@ -42,7 +42,8 @@ export function provideSaveService(
*/
function getSaveData(): SaveData {
return {
- version: syncService.version,
+ // No steps were received yet on a document without stored state
+ version: Math.max(syncService.version, 0),
autosaveContent: serialize(),
documentState: getDocumentState(ydoc),
}
@@ -51,6 +52,7 @@ export function provideSaveService(
const saveService = new SaveService({
connection,
getSaveData,
+ pushChanges: () => syncService.sendRemainingSteps(),
})
const autosaveOnUpdate = ({ transaction }: { transaction: Transaction }) => {
@@ -99,13 +101,28 @@ export function provideSaveService(
*/
function updateVersionWithChanges(event: { version: number }) {
versionWithChanges.value = Math.max(event.version, versionWithChanges.value)
+ // Retried pushes are not preceded by an editor update that triggers the autosave
+ if ((document.value?.lastSavedVersion ?? 0) < event.version && !saveService.autosave.isPending) {
+ saveService.autosave()
+ }
}
syncService.bus.on('changesPushed', updateVersionWithChanges)
onUnmounted(() => {
syncService.bus.off('changesPushed', updateVersionWithChanges)
})
- const dirty = computed(() => (document.value?.lastSavedVersion ?? 0) < versionWithChanges.value)
+ const hasPendingChanges = ref(false)
+ // Track if local changes are waiting to be pushed
+ function updatePendingChanges(event: { pending: boolean }) {
+ hasPendingChanges.value = event.pending
+ }
+ syncService.bus.on('pendingChanges', updatePendingChanges)
+ onUnmounted(() => {
+ syncService.bus.off('pendingChanges', updatePendingChanges)
+ })
+
+ const dirty = computed(() => hasPendingChanges.value
+ || (document.value?.lastSavedVersion ?? 0) < versionWithChanges.value)
watch(dirty, setDirty)
provide(saveServiceKey, saveService)
diff --git a/src/helpers/setInitialYjsState.ts b/src/helpers/setInitialYjsState.ts
index c9304a5bae8..67272300779 100644
--- a/src/helpers/setInitialYjsState.ts
+++ b/src/helpers/setInitialYjsState.ts
@@ -17,11 +17,12 @@ import markdownit from '../markdownit/index.ts'
* @param content desired content of the final document
* @param options options
* @param options.isRichEditor use a rich editor for the content
+ * @param options.origin origin of the update, e.g. the sync provider
*/
export function setInitialYjsState(
ydoc: Doc,
content: string,
- { isRichEditor }: { isRichEditor: boolean },
+ { isRichEditor, origin }: { isRichEditor: boolean, origin?: unknown },
) {
const html = isRichEditor
? markdownit.render(content) + '
'
@@ -54,5 +55,5 @@ export function setInitialYjsState(
}
const baseUpdate = encodeStateAsUpdate(getBaseDoc(node))
- applyUpdate(ydoc, baseUpdate)
+ applyUpdate(ydoc, baseUpdate, origin)
}
diff --git a/src/services/Outbox.ts b/src/services/Outbox.ts
index f08917faf2a..3bab6151a62 100644
--- a/src/services/Outbox.ts
+++ b/src/services/Outbox.ts
@@ -17,6 +17,15 @@ export default class Outbox {
#syncQuery = ''
#recoveryAttemptCounter = 0
#isRecoveringSync = false
+ #onChange
+
+ /**
+ * @param options options
+ * @param options.onChange called when `hasUpdate` changes
+ */
+ constructor({ onChange = () => { } }: { onChange?: (hasUpdate: boolean) => void } = {}) {
+ this.#onChange = onChange
+ }
storeStep(step: Uint8Array) {
const encoded = encodeArrayBuffer(step)
@@ -29,7 +38,7 @@ export default class Outbox {
return
}
if (encoded < 'AQ') {
- this.#syncUpdate = encoded
+ this.#setSyncUpdate(encoded)
return
}
this.#awarenessUpdate = encoded
@@ -58,6 +67,14 @@ export default class Outbox {
return !!this.#syncUpdate
}
+ #setSyncUpdate(update: string) {
+ const hadUpdate = this.hasUpdate
+ this.#syncUpdate = update
+ if (this.hasUpdate !== hadUpdate) {
+ this.#onChange(this.hasUpdate)
+ }
+ }
+
/*
* Clear data that has just been sent.
*
@@ -66,7 +83,7 @@ export default class Outbox {
*/
clearSentData({ steps, awareness }: Sendable) {
if (steps.includes(this.#syncUpdate)) {
- this.#syncUpdate = ''
+ this.#setSyncUpdate('')
}
if (steps.includes(this.#syncQuery)) {
this.#syncQuery = ''
diff --git a/src/services/SaveService.ts b/src/services/SaveService.ts
index 95a87d922e5..08c17cde574 100644
--- a/src/services/SaveService.ts
+++ b/src/services/SaveService.ts
@@ -37,18 +37,22 @@ class SaveService {
lastSaveAttempt = 0
pendingAutosave = 0
getSaveData
+ pushChanges
autosave
clear
constructor({
connection,
getSaveData,
+ pushChanges = async () => {},
}: {
connection: ShallowRef
getSaveData: () => SaveData
+ pushChanges?: () => Promise
}) {
this.connection = connection
this.getSaveData = getSaveData
+ this.pushChanges = pushChanges
this.autosave = debounce(this._autosave.bind(this), AUTOSAVE_DEBOUNCE * 1000)
this.clear = this.clearAutosave.bind(this)
}
@@ -67,6 +71,8 @@ class SaveService {
logger.warn('Could not save due to missing connection')
return
}
+ // Save the version that includes the local changes
+ await this.pushChanges()
const data = this.getSaveData()
try {
this.lastSaveAttempt = Date.now()
diff --git a/src/services/SyncService.ts b/src/services/SyncService.ts
index 7cb75f45728..90d79288c0c 100644
--- a/src/services/SyncService.ts
+++ b/src/services/SyncService.ts
@@ -63,6 +63,9 @@ export declare type EventTypes = {
/* local yjs changes have been pushed to the server */
changesPushed: { version: number }
+ /* local yjs changes are waiting to be pushed to the server */
+ pendingChanges: { pending: boolean }
+
/* error */
error: { type: ErrorType, data?: object }
@@ -85,7 +88,10 @@ class SyncService {
pushError = 0
backend?: PollingBackend
#sendIntervalId?: NodeJS.Timeout
- #outbox = new Outbox()
+ #outbox = new Outbox({
+ onChange: (hasUpdate) => this.bus.emit('pendingChanges', { pending: hasUpdate }),
+ })
+
bus = mitt()
#openConnection: () => Promise
#lastStepPush = Date.now()
diff --git a/src/tests/composables/useSaveService.spec.ts b/src/tests/composables/useSaveService.spec.ts
new file mode 100644
index 00000000000..65c6e48cb95
--- /dev/null
+++ b/src/tests/composables/useSaveService.spec.ts
@@ -0,0 +1,105 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { Editor } from '@tiptap/core'
+import type { SaveService } from '../../services/SaveService.ts'
+import type { EventTypes, SyncService } from '../../services/SyncService.ts'
+import type { Connection } from '../../types/Connection.ts'
+import type { Document } from '../../types/Document.ts'
+
+import { mount } from '@vue/test-utils'
+import mitt from 'mitt'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { defineComponent, nextTick, shallowRef } from 'vue'
+import { Doc } from 'yjs'
+import * as saveApi from '../../apis/save.ts'
+import { provideSaveService } from '../../composables/useSaveService.ts'
+
+vi.mock('../../apis/save.ts')
+
+const connection = shallowRef({
+ documentId: '123',
+ sessionId: 345,
+ sessionToken: 'sessionToken',
+ filePath: './',
+ baseVersionEtag: 'etag',
+})
+
+/**
+ * Mount a component providing the save service with a stubbed sync service.
+ *
+ * @param options options
+ * @param options.version version on the stupped sync service
+ */
+function setup({ version = 2 } = {}) {
+ const syncService = {
+ bus: mitt(),
+ version,
+ sendRemainingSteps: vi.fn(async () => {}),
+ }
+ const editor = { on: vi.fn(), off: vi.fn() }
+ const setDirty = vi.fn<(val: boolean) => Promise>(async () => {})
+ let saveService: SaveService | undefined
+ mount(defineComponent({
+ template: '',
+ setup() {
+ ({ saveService } = provideSaveService(
+ connection,
+ editor as unknown as Editor,
+ syncService as unknown as SyncService,
+ () => 'content',
+ new Doc(),
+ setDirty as unknown as (val: boolean) => Promise,
+ ))
+ },
+ }))
+ const document = { lastSavedVersion: 1, lastSavedVersionTime: 0 } as Document
+ syncService.bus.emit('change', { document, sessions: [] })
+ return { syncService, setDirty, saveService: saveService! }
+}
+
+describe('provideSaveService', () => {
+ beforeEach(() => {
+ vi.useFakeTimers()
+ vi.mocked(saveApi.save).mockResolvedValue({
+ data: { document: { lastSavedVersion: 2, lastSavedVersionTime: 0 } },
+ } as Awaited>)
+ })
+
+ afterEach(() => {
+ vi.useRealTimers()
+ vi.clearAllMocks()
+ })
+
+ it('is dirty while local changes are pending', async () => {
+ const { syncService, setDirty } = setup()
+ syncService.bus.emit('pendingChanges', { pending: true })
+ await nextTick()
+ expect(setDirty.mock.lastCall?.[0]).toBe(true)
+ syncService.bus.emit('pendingChanges', { pending: false })
+ await nextTick()
+ expect(setDirty.mock.lastCall?.[0]).toBe(false)
+ })
+
+ it('autosaves changes pushed without an editor update', async () => {
+ const { syncService } = setup()
+ syncService.bus.emit('changesPushed', { version: 2 })
+ await vi.advanceTimersByTimeAsync(1000)
+ expect(saveApi.save).toHaveBeenCalledWith(connection.value, expect.objectContaining({ version: 2 }))
+ })
+
+ it('does not autosave pushed changes that are already saved', async () => {
+ const { syncService } = setup()
+ syncService.bus.emit('changesPushed', { version: 1 })
+ await vi.advanceTimersByTimeAsync(1000)
+ expect(saveApi.save).not.toHaveBeenCalled()
+ })
+
+ it('saves version 0 before any steps were received', async () => {
+ const { saveService } = setup({ version: -1 })
+ await saveService.save()
+ expect(saveApi.save).toHaveBeenCalledWith(connection.value, expect.objectContaining({ version: 0 }))
+ })
+})
diff --git a/src/tests/helpers/setInitialYjsState.spec.ts b/src/tests/helpers/setInitialYjsState.spec.ts
new file mode 100644
index 00000000000..dc731d29bce
--- /dev/null
+++ b/src/tests/helpers/setInitialYjsState.spec.ts
@@ -0,0 +1,73 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { SyncService } from '../../services/SyncService.ts'
+
+import * as decoding from 'lib0/decoding'
+import mitt from 'mitt'
+import { describe, expect, it, vi } from 'vitest'
+import { applyUpdate, Doc, XmlText } from 'yjs'
+import { setInitialYjsState } from '../../helpers/setInitialYjsState.ts'
+import initWebSocketPolyfill from '../../services/WebSocketPolyfill.ts'
+import { WebsocketProvider } from '../../services/y-websocket.js'
+
+const content = '# Hello world\n\nold line :)\n'
+
+/**
+ * Create a provider connected to a sync service that records the sent steps.
+ */
+async function setupProvider() {
+ const ydoc = new Doc()
+ const syncService = {
+ bus: mitt(),
+ open: vi.fn(async () => {}),
+ hasActiveConnection: () => true,
+ sendStep: vi.fn(),
+ }
+ const WebSocketPolyfill = initWebSocketPolyfill(syncService as unknown as SyncService)
+ const provider = new WebsocketProvider('ws://localhost:1234', 'file:123', ydoc, {
+ WebSocketPolyfill: WebSocketPolyfill as unknown as typeof WebSocket,
+ disableBc: true,
+ })
+ await vi.waitUntil(() => provider.wsconnected)
+ const sentUpdates = () => syncService.sendStep.mock.calls
+ .map(([step]) => decoding.createDecoder(step))
+ // sync message containing a sync step 2 or update
+ .filter((decoder) => decoding.readVarUint(decoder) === 0 && decoding.readVarUint(decoder) > 0)
+ .map((decoder) => decoding.readVarUint8Array(decoder))
+ return { ydoc, provider, sentUpdates }
+}
+
+describe('setInitialYjsState', () => {
+ it('applies the content with the given origin', () => {
+ const ydoc = new Doc()
+ const origin = {}
+ const onUpdate = vi.fn()
+ ydoc.on('update', onUpdate)
+ setInitialYjsState(ydoc, content, { isRichEditor: true, origin })
+ expect(onUpdate).toHaveBeenCalledOnce()
+ expect(onUpdate.mock.calls[0][1]).toBe(origin)
+ expect(ydoc.getXmlFragment('default').toString()).toContain('old line :)')
+ })
+
+ it('is not sent with the sync provider as origin', async () => {
+ const { ydoc, provider, sentUpdates } = await setupProvider()
+ setInitialYjsState(ydoc, content, { isRichEditor: true, origin: provider })
+ expect(sentUpdates()).toHaveLength(0)
+ provider.destroy()
+ })
+
+ it('is sent along with the first local change', async () => {
+ const { ydoc, provider, sentUpdates } = await setupProvider()
+ setInitialYjsState(ydoc, content, { isRichEditor: true, origin: provider })
+ ydoc.getXmlFragment('default').insert(0, [new XmlText('edit')])
+ expect(sentUpdates()).toHaveLength(1)
+ const remote = new Doc()
+ applyUpdate(remote, sentUpdates()[0])
+ expect(remote.getXmlFragment('default').toString())
+ .toBe(ydoc.getXmlFragment('default').toString())
+ provider.destroy()
+ })
+})
diff --git a/src/tests/services/Outbox.spec.ts b/src/tests/services/Outbox.spec.ts
new file mode 100644
index 00000000000..c5a654ee960
--- /dev/null
+++ b/src/tests/services/Outbox.spec.ts
@@ -0,0 +1,48 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { describe, expect, it, vi } from 'vitest'
+import Outbox from '../../services/Outbox.ts'
+
+// sync messages with yjs updates
+const update = new Uint8Array([0, 2, 2, 0, 0])
+const otherUpdate = new Uint8Array([0, 2, 2, 0, 1])
+// sync step 1 message
+const query = new Uint8Array([0, 0, 1, 0])
+// awareness message
+const awareness = new Uint8Array([1, 0])
+
+describe('Outbox', () => {
+ it('notifies when it gets an update and when the update was sent', () => {
+ const onChange = vi.fn()
+ const outbox = new Outbox({ onChange })
+ outbox.storeStep(update)
+ outbox.storeStep(otherUpdate)
+ expect(onChange).toHaveBeenCalledExactlyOnceWith(true)
+ outbox.clearSentData(outbox.getDataToSend())
+ expect(onChange).toHaveBeenLastCalledWith(false)
+ expect(onChange).toHaveBeenCalledTimes(2)
+ })
+
+ it('does not notify for sync queries and awareness', () => {
+ const onChange = vi.fn()
+ const outbox = new Outbox({ onChange })
+ outbox.storeStep(query)
+ outbox.storeStep(awareness)
+ outbox.clearSentData(outbox.getDataToSend())
+ expect(onChange).not.toHaveBeenCalled()
+ })
+
+ it('keeps the update that arrived while sending', () => {
+ const onChange = vi.fn()
+ const outbox = new Outbox({ onChange })
+ outbox.storeStep(update)
+ const sendable = outbox.getDataToSend()
+ outbox.storeStep(otherUpdate)
+ outbox.clearSentData(sendable)
+ expect(onChange).toHaveBeenCalledExactlyOnceWith(true)
+ expect(outbox.hasUpdate).toBe(true)
+ })
+})
diff --git a/src/tests/services/SaveService.spec.ts b/src/tests/services/SaveService.spec.ts
index 6f77eb0b9ba..e3d56bacbf0 100644
--- a/src/tests/services/SaveService.spec.ts
+++ b/src/tests/services/SaveService.spec.ts
@@ -44,4 +44,23 @@ describe('SaveService', () => {
data: { outsideChange: 'outside content' },
})
})
+
+ it('pushes changes before saving', async () => {
+ vi.mocked(saveApi.save).mockResolvedValue({
+ data: { document: { lastSavedVersion: 2 } },
+ } as Awaited>)
+ let version = 1
+ const pushChanges = vi.fn(async () => {
+ version = 2
+ })
+ const saveService = new SaveService({
+ connection,
+ getSaveData: () => ({ ...getSaveData(), version }),
+ pushChanges,
+ })
+
+ expect(await saveService.save()).toBe(true)
+ expect(pushChanges).toHaveBeenCalledOnce()
+ expect(saveApi.save).toHaveBeenCalledWith(connection.value, expect.objectContaining({ version: 2 }))
+ })
})
diff --git a/src/tests/services/SyncService.spec.ts b/src/tests/services/SyncService.spec.ts
index 4b5a07f67c2..dc630ce9860 100644
--- a/src/tests/services/SyncService.spec.ts
+++ b/src/tests/services/SyncService.spec.ts
@@ -4,11 +4,14 @@
*/
import { describe, expect, it, vi } from 'vitest'
+import { shallowRef } from 'vue'
import * as connect from '../../apis/connect.ts'
+import * as sync from '../../apis/sync.ts'
import { provideConnection } from '../../composables/useConnection.js'
import { SyncService } from '../../services/SyncService.js'
vi.mock('../../apis/connect')
+vi.mock('../../apis/sync')
const connection = {
documentId: '123',
@@ -64,4 +67,30 @@ describe('Sync service', () => {
expect(openHandler).toHaveBeenCalledWith(expect.objectContaining({ session: initialData.session }))
expect(openData.value?.canAttachFiles).toBe(true)
})
+
+ describe('pending changes', () => {
+ // sync message with an empty yjs update
+ const update = new Uint8Array([0, 2, 2, 0, 0])
+
+ it('are pending until pushed', async () => {
+ const service = new SyncService({ connection: shallowRef(connection), openConnection: vi.fn() })
+ const onPendingChanges = vi.fn()
+ service.bus.on('pendingChanges', onPendingChanges)
+ vi.mocked(sync.push).mockResolvedValue({ data: { steps: [], documentState: '', version: 1 } })
+ service.sendStep(update)
+ expect(onPendingChanges).toHaveBeenCalledExactlyOnceWith({ pending: true })
+ await service.sendStepsNow()
+ expect(onPendingChanges).toHaveBeenLastCalledWith({ pending: false })
+ })
+
+ it('remain pending if the push fails', async () => {
+ const service = new SyncService({ connection: shallowRef(connection), openConnection: vi.fn() })
+ const onPendingChanges = vi.fn()
+ service.bus.on('pendingChanges', onPendingChanges)
+ vi.mocked(sync.push).mockRejectedValue({ code: 'ECONNABORTED' })
+ service.sendStep(update)
+ await expect(service.sendStepsNow()).rejects.toThrow()
+ expect(onPendingChanges).toHaveBeenCalledExactlyOnceWith({ pending: true })
+ })
+ })
})