+
+
+
+ {{ sideLabels[side] }}
+
+
+ -
+
-
+
+ +
+-
+
- + + +
+
+ {{ announcement }} +
+ +
+
+ + {{ n('text', '%n change', '%n changes', activeEdits.length) }} +
+ +
+ {{
+ n(
+ 'text',
+ '%n formatting change hidden',
+ '%n formatting changes hidden',
+ formatCount,
+ )
+ }}
+
+ {{ t('text', 'Show') }}
+
+
+
+
+
+ {{
+ t(
+ 'text',
+ 'All rendered changes are formatting-only and hidden by the current filter.',
+ )
+ }}
+
+
+
+ {{ t('text', 'Open Markdown source') }}
+
+
+ + {{ + t('text', 'No rendered differences — Markdown syntax differs.') + }} +
++ {{ t('text', 'No differences.') }} +
+
+
+
+
+
+
+
+
+
+ + {{ + t( + 'text', + 'Source compares literal Markdown, so its change groups can differ from rendered changes.', + ) + }} +
++ {{ + t( + 'text', + 'Line endings changed: {before} → {after}', + model.lineEndingChange, + ) + }} +
+ +
+
+
+
+
+
+ + {{ sideLabels[side] }} +
+
+
+
+
+
+
+
+
+
+ {{
+ gapRows(slot.gap)
+ ? t('text', 'Hide unchanged lines')
+ : t('text', 'Show {count} unchanged lines', {
+ count: slot.gap.count,
+ })
+ }}
+
+
+ {{ t('text', 'Show more unchanged lines') }}
+
+
+
+
+ + {{ + t( + 'text', + 'Additional unchanged lines are hidden to keep the comparison responsive.', + ) + }} +
++ +
+{{ t('text', 'Complete Markdown source is shown because a detailed comparison is unavailable.') }}
++ {{ t('text', 'Source preview was truncated to the display limit.') }} +
+
+
+
+
+
+
+ {{ t('text', 'Before') }}
+{{ before.text }}{{ t('text', 'After') }}
+{{ after.text }}\n${escapeHtml(content)}`
+}
+
/**
*
* @param editor to apply methods to
@@ -29,12 +35,9 @@ export function useEditorMethods(editor: Editor) {
) => void = (content, { addToHistory = true } = {}) => {
const hasMarkdownContent
= editor.extensionManager.extensions.includes(Markdown)
- const html = hasMarkdownContent
- ? markdownit.render(content) + ''
- : `\n${escapeHtml(content)}`
editor
.chain()
- .setContent(html, { emitUpdate: addToHistory })
+ .setContent(renderEditorContent(content, hasMarkdownContent), { emitUpdate: addToHistory })
.command(({ tr }) => {
tr.setMeta('addToHistory', addToHistory)
return true
diff --git a/src/createMarkdownContentComparison.ts b/src/createMarkdownContentComparison.ts
new file mode 100644
index 00000000000..c525e532cd9
--- /dev/null
+++ b/src/createMarkdownContentComparison.ts
@@ -0,0 +1,123 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { createApp } from 'vue'
+import MarkdownSourceFallback from './components/MarkdownSourceFallback.vue'
+import { OPEN_LINK_HANDLER } from './composables/useOpenLinkHandler.ts'
+import { openLink } from './helpers/links.js'
+
+export interface MarkdownContentComparisonOptions {
+ el: HTMLElement
+ beforeContent: string
+ afterContent: string
+ fileId?: number
+ filePath?: string
+ shareToken?: string
+ noLazyImages?: boolean
+ openLinkHandler?: (href: string) => void
+ onLoaded?: () => void | Promise\s*$/
-const DETAILS_AND_SUMMARY_START_REGEX
- = /(?<=^
\s*).*(?=<\/summary>\s*$)/
+const DETAILS_START_REGEX = /^
).*(?=<\/summary>\s*$)/
+const DETAILS_START_REGEX = /^\s+open(?:=(?:""|''|open))?)?>\s*$/
+const DETAILS_AND_SUMMARY_START_REGEX = /^\s+open(?:=(?:""|''|open))?)?>\s*(?.*)<\/summary>\s*$/
const DETAILS_END_REGEX = /^<\/details>\s*$/
const SUMMARY_REGEX = /(?<=^).*(?=<\/summary>\s*$)/
@@ -32,16 +31,22 @@ function parseDetails(
let detailsFound = false
let detailsSummary = null
+ let openDetails: boolean
let startLineCount = 2
- const m = state.src.slice(start, max).match(DETAILS_AND_SUMMARY_START_REGEX)
- if (m) {
+ const openingLine = state.src.slice(start, max)
+ const combined = openingLine.match(DETAILS_AND_SUMMARY_START_REGEX)
+ if (combined) {
// Details block start and summary in same line
- detailsSummary = m[0].trim()
+ detailsSummary = combined.groups!.summary!.trim()
+ openDetails = Boolean(combined.groups!.open)
startLineCount = 1
- } else if (!state.src.slice(start, max).match(DETAILS_START_REGEX)) {
- // Details block start in separate line
- return false
+ } else {
+ const opening = openingLine.match(DETAILS_START_REGEX)
+ if (!opening) {
+ return false
+ }
+ openDetails = Boolean(opening.groups!.open)
}
// Since start is found, we can report success here in validation mode
@@ -105,6 +110,9 @@ function parseDetails(
token.block = true
token.info = detailsSummary
token.map = [startLine, nextLine]
+ if (openDetails) {
+ token.attrSet('open', '')
+ }
token = state.push('details_summary', 'summary', 1)
token.block = false
diff --git a/src/nodes/Details.js b/src/nodes/Details.js
index 7b5f9073f8a..01b814f245c 100644
--- a/src/nodes/Details.js
+++ b/src/nodes/Details.js
@@ -67,6 +67,11 @@ const Details = Node.create({
openDetails: {
default: false,
},
+ open: {
+ default: false,
+ parseHTML: (element) => element.hasAttribute('open'),
+ renderHTML: ({ open }) => open ? { open: '' } : {},
+ },
}
},
@@ -91,7 +96,7 @@ const Details = Node.create({
},
toMarkdown: (state, node) => {
- state.write('\n')
+ state.write(node.attrs.open ? '\n' : '\n')
state.renderContent(node)
state.closeBlock(node)
state.ensureNewLine()
diff --git a/src/nodes/DetailsView.vue b/src/nodes/DetailsView.vue
index 65677b0db96..2ec5c094d4e 100644
--- a/src/nodes/DetailsView.vue
+++ b/src/nodes/DetailsView.vue
@@ -5,13 +5,17 @@
-
+
diff --git a/src/nodes/Image.ts b/src/nodes/Image.ts
index 405dc92a694..389be2d9947 100644
--- a/src/nodes/Image.ts
+++ b/src/nodes/Image.ts
@@ -17,6 +17,7 @@ const imageFileDropPluginKey = new PluginKey('imageFileDrop')
const imageExtractAttachmentsKey = new PluginKey('imageExtractAttachments')
interface ImageOptions extends TiptapImageOptions {
+ emitAttachmentEvents: boolean
noLazyImages: boolean
}
@@ -53,6 +54,7 @@ const Image = TiptapImage.extend({
addOptions() {
return {
...this.parent?.() as ImageOptions,
+ emitAttachmentEvents: true,
noLazyImages: false,
}
},
@@ -120,31 +122,33 @@ const Image = TiptapImage.extend({
},
},
}),
- new Plugin({
- key: imageExtractAttachmentsKey,
- state: {
- init(_, { doc }) {
- const attachmentSrcs = extractAttachmentSrcs(doc)
- emit('text:editor:attachments:updated', { attachmentSrcs })
- return { attachmentSrcs }
- },
- apply(tr, value, _oldState, newState) {
- if (!tr.docChanged) {
- return value
- }
- const attachmentSrcs = extractAttachmentSrcs(newState.doc)
- if (
- JSON.stringify(attachmentSrcs)
- === JSON.stringify(value?.attachmentSrcs)
- ) {
- return value
- }
-
- emit('text:editor:attachments:updated', { attachmentSrcs })
- return { attachmentSrcs }
- },
- },
- }),
+ ...(this.options.emitAttachmentEvents
+ ? [new Plugin({
+ key: imageExtractAttachmentsKey,
+ state: {
+ init(_, { doc }) {
+ const attachmentSrcs = extractAttachmentSrcs(doc)
+ emit('text:editor:attachments:updated', { attachmentSrcs })
+ return { attachmentSrcs }
+ },
+ apply(tr, value, _oldState, newState) {
+ if (!tr.docChanged) {
+ return value
+ }
+ const attachmentSrcs = extractAttachmentSrcs(newState.doc)
+ if (
+ JSON.stringify(attachmentSrcs)
+ === JSON.stringify(value?.attachmentSrcs)
+ ) {
+ return value
+ }
+
+ emit('text:editor:attachments:updated', { attachmentSrcs })
+ return { attachmentSrcs }
+ },
+ },
+ })]
+ : []),
]
},
diff --git a/src/nodes/ImageView.vue b/src/nodes/ImageView.vue
index eb2c7576c4d..cec809cbc51 100644
--- a/src/nodes/ImageView.vue
+++ b/src/nodes/ImageView.vue
@@ -24,8 +24,10 @@
v-if="isMediaAttachment"
contenteditable="false"
class="media">
-
![]()
{{ alt }}
{{ attachmentSize }}
-
+
-
+
+
@@ -593,7 +599,11 @@ export default {
.media-wrapper {
display: flex;
- // Overwrite some global rules for a elments
+ padding: 0;
+ border: 0;
+ background: transparent;
+ font: inherit;
+ cursor: pointer;
text-decoration: none;
color: var(--color-main-text);
diff --git a/src/services/AttachmentResolver.js b/src/services/AttachmentResolver.js
index 6d1f2fa0a98..bc915c98156 100644
--- a/src/services/AttachmentResolver.js
+++ b/src/services/AttachmentResolver.js
@@ -22,7 +22,6 @@ export default class AttachmentResolver {
this.#shareToken = shareToken
this.#currentDirectory = currentDirectory
this.#documentId = fileId ?? session.documentId
- this.#initAttachmentListPromise = this.#updateAttachmentList()
}
async #updateAttachmentList() {
@@ -52,7 +51,7 @@ export default class AttachmentResolver {
if (src.match(directoryRegexp)) {
const imageFileName = decodeURIComponent(src.replace(directoryRegexp, '').split('?')[0])
- // Wait until attachment list got fetched (initialized by constructor)
+ this.#initAttachmentListPromise ??= this.#updateAttachmentList()
await this.#initAttachmentListPromise
attachment = this.#findAttachment(imageFileName)
diff --git a/src/tests/comparison/ComparisonChangeList.spec.ts b/src/tests/comparison/ComparisonChangeList.spec.ts
new file mode 100644
index 00000000000..246e4914c97
--- /dev/null
+++ b/src/tests/comparison/ComparisonChangeList.spec.ts
@@ -0,0 +1,173 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { ComparisonDescriptor, ComparisonEdit } from '../../comparison/markdownComparisonTypes.ts'
+
+import * as l10n from '@nextcloud/l10n'
+import { mount } from '@vue/test-utils'
+import { schema } from 'prosemirror-schema-basic'
+import { describe, expect, it, vi } from 'vitest'
+import ComparisonChangeList from '../../components/ComparisonChangeList.vue'
+
+function descriptor(id: string, text: string, facets: ComparisonDescriptor['facets'] = ['text']): ComparisonDescriptor {
+ return {
+ id,
+ operation: 'replace',
+ detail: 'inline',
+ facets,
+ before: { from: 0, to: 1 },
+ after: { from: 0, to: 1 },
+ context: { before: null, after: null },
+ preview: { before: { kind: 'text', text }, after: { kind: 'text', text } },
+ signals: [],
+ }
+}
+
+const document = schema.node('doc', null, [schema.node('paragraph', null, schema.text('Body'))])
+
+describe('ComparisonChangeList', () => {
+ it('AUD-14 renders only the bounded page containing a high-cardinality current edit', () => {
+ const edits = Array.from({ length: 10_000 }, (_value, index): ComparisonEdit => {
+ const primary = descriptor(`member-${index}`, `preview-${index}`)
+ return { id: `edit-${index}`, kind: 'content', primary, descriptors: [primary] }
+ })
+ const wrapper = mount(ComparisonChangeList, {
+ props: { edits, currentId: 'edit-9999', beforeDocument: document, afterDocument: document },
+ })
+ const rows = wrapper.findAll('[data-comparison-select]')
+
+ expect(rows).toHaveLength(80)
+ expect(rows[0]!.attributes('data-comparison-select')).toBe('edit-9920')
+ expect(rows.at(-1)!.attributes('data-comparison-select')).toBe('edit-9999')
+ expect(wrapper.find('[data-comparison-select="edit-9999"]').attributes('aria-current')).toBe('true')
+ })
+
+ it('preserves the current change label when paging away from its row', async () => {
+ const edits = Array.from({ length: 160 }, (_value, index): ComparisonEdit => {
+ const primary = descriptor(`member-${index}`, `preview-${index}`)
+ return { id: `edit-${index}`, kind: 'content', primary, descriptors: [primary] }
+ })
+ const wrapper = mount(ComparisonChangeList, {
+ props: { edits, currentId: 'edit-159', beforeDocument: document, afterDocument: document },
+ })
+ const initialLabel = wrapper.emitted('currentLabel')!.at(-1)![0]
+
+ await wrapper.findAll('.text-comparison__change-pages button')[0]!.trigger('click')
+
+ expect(wrapper.findAll('[data-comparison-select]')[0]!.attributes('data-comparison-select')).toBe('edit-0')
+ expect(wrapper.find('[aria-current="true"]').exists()).toBe(false)
+ expect(wrapper.emitted('currentLabel')!.at(-1)![0]).toBe(initialLabel)
+ expect(initialLabel).not.toBe('')
+ })
+
+ it('AUD-14 unmounts records in collapsed sections', async () => {
+ const primary = descriptor('member', 'preview')
+ const edit: ComparisonEdit = { id: 'edit', kind: 'content', primary, descriptors: [primary] }
+ const wrapper = mount(ComparisonChangeList, {
+ props: { edits: [edit], beforeDocument: document, afterDocument: document },
+ })
+
+ await wrapper.get('.text-comparison__section-toggle').trigger('click')
+
+ expect(wrapper.findAll('[data-comparison-select]')).toHaveLength(0)
+ })
+
+ it('translates only the selected lookup entry for each record', () => {
+ const translate = vi.spyOn(l10n, 't')
+ const primary: ComparisonDescriptor = {
+ ...descriptor('member', 'preview', ['attribute']),
+ signals: [{ type: 'attribute', attribute: 'link', change: 'changed' }],
+ }
+ const edit: ComparisonEdit = { id: 'edit', kind: 'content', primary, descriptors: [primary] }
+
+ mount(ComparisonChangeList, {
+ props: { edits: [edit], beforeDocument: document, afterDocument: document },
+ })
+
+ const messages = translate.mock.calls.map(([, message]) => message)
+ expect(messages).toContain('Link changed')
+ expect(messages).not.toContain('Heading level changed')
+ translate.mockRestore()
+ })
+
+ it('V01 renders one row per first-class edit using explicit primary and all member descriptors', async () => {
+ const first = descriptor('member-first', 'wrong', ['formatting'])
+ const primary = descriptor('member-primary', 'primary')
+ const edit: ComparisonEdit = { id: 'edit-row', kind: 'content', primary, descriptors: [first, primary] }
+ const wrapper = mount(ComparisonChangeList, {
+ props: { edits: [edit], currentId: 'edit-row', beforeDocument: document, afterDocument: document },
+ })
+ const rows = wrapper.findAll('[data-comparison-select]')
+ expect(rows).toHaveLength(1)
+ expect(rows[0]!.attributes('data-comparison-select')).toBe('edit-row')
+ expect(rows[0]!.find('.text-comparison__change-item-content').exists()).toBe(true)
+ expect(rows[0]!.text()).toContain('primary')
+ expect(rows[0]!.text()).toContain('2 edits')
+ await rows[0]!.trigger('click')
+ expect(wrapper.emitted('select')).toEqual([['edit-row']])
+ })
+
+ it('renders explicit before and after previews for a replacement', () => {
+ const primary: ComparisonDescriptor = {
+ ...descriptor('member', 'unused'),
+ preview: {
+ before: { kind: 'text', text: 'before text' },
+ after: { kind: 'text', text: 'after text' },
+ },
+ }
+ const edit: ComparisonEdit = { id: 'edit', kind: 'content', primary, descriptors: [primary] }
+ const wrapper = mount(ComparisonChangeList, {
+ props: { edits: [edit], beforeDocument: document, afterDocument: document },
+ })
+
+ expect(wrapper.get('del.text-comparison__preview-before').text()).toBe('before text')
+ expect(wrapper.get('ins.text-comparison__preview-after').text()).toBe('after text')
+ })
+
+ it('labels a coarse composite change by its structural scope instead of an incidental task attribute', () => {
+ const primary: ComparisonDescriptor = {
+ ...descriptor('member', 'nested content', ['text', 'attribute', 'structure']),
+ coarseReason: 'ambiguous-attribution',
+ signals: [
+ { type: 'attribute', attribute: 'task-state', change: 'changed' },
+ { type: 'node' },
+ ],
+ }
+ const edit: ComparisonEdit = { id: 'edit', kind: 'content', primary, descriptors: [primary] }
+ const wrapper = mount(ComparisonChangeList, {
+ props: { edits: [edit], beforeDocument: document, afterDocument: document },
+ })
+
+ expect(wrapper.get('[data-comparison-select]').text()).toContain('Structure changed')
+ expect(wrapper.get('[data-comparison-select]').text()).not.toContain('Task state changed')
+ })
+
+ it.each([
+ ['insert', 'inline', 'Paragraph changed', 'Paragraph added'],
+ ['delete', 'inline', 'Paragraph changed', 'Paragraph removed'],
+ ['insert', 'block', 'Paragraph added', 'Paragraph changed'],
+ ['delete', 'block', 'Paragraph removed', 'Paragraph changed'],
+ ] as const)('labels a %s %s operation at the correct altitude', (operation, detail, expected, rejected) => {
+ const primary: ComparisonDescriptor = {
+ ...descriptor('member', 's'),
+ operation,
+ detail,
+ context: {
+ before: { code: 'paragraph', path: [], from: 0, to: 1 },
+ after: { code: 'paragraph', path: [], from: 0, to: 1 },
+ },
+ preview: operation === 'insert'
+ ? { before: null, after: { kind: 'text', text: 's' } }
+ : { before: { kind: 'text', text: 's' }, after: null },
+ }
+ const edit: ComparisonEdit = { id: 'edit', kind: 'content', primary, descriptors: [primary] }
+ const wrapper = mount(ComparisonChangeList, {
+ props: { edits: [edit], beforeDocument: document, afterDocument: document },
+ })
+
+ expect(wrapper.get('[data-comparison-select]').text()).toContain(expected)
+ expect(wrapper.get('[data-comparison-select]').text()).not.toContain(rejected)
+ })
+})
diff --git a/src/tests/comparison/MarkdownSourceComponent.spec.ts b/src/tests/comparison/MarkdownSourceComponent.spec.ts
new file mode 100644
index 00000000000..f095354e1e1
--- /dev/null
+++ b/src/tests/comparison/MarkdownSourceComponent.spec.ts
@@ -0,0 +1,187 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { mount } from '@vue/test-utils'
+import { describe, expect, it, vi } from 'vitest'
+import MarkdownSourceComparison from '../../components/MarkdownSourceComparison.vue'
+import { SOURCE_DIFF_LIMITS } from '../../comparison/markdownSourceComparison.ts'
+import {
+ COMPLETE_SOURCE_DISPLAY_LIMITS,
+ displayBoundedMarkdownSource,
+ displayMarkdownSource,
+} from '../../comparison/markdownSourceDisplay.ts'
+
+describe('Markdown source component', () => {
+ const multilineSource = (length: number) => {
+ const line = `${'x'.repeat(COMPLETE_SOURCE_DISPLAY_LIMITS.maximumVisibleCharactersPerLine - 1)}\n`
+ return line.repeat(Math.floor(length / line.length)) + 'x'.repeat(length % line.length)
+ }
+
+ it.each([
+ COMPLETE_SOURCE_DISPLAY_LIMITS.maximumVisibleCharactersPerSide - 1,
+ COMPLETE_SOURCE_DISPLAY_LIMITS.maximumVisibleCharactersPerSide,
+ ])('AUD-08 preserves complete source at the %i-character display boundary', (length) => {
+ const source = multilineSource(length)
+ expect(displayBoundedMarkdownSource(source)).toEqual({ text: source, truncated: false })
+ })
+
+ it('keeps supplementary characters well formed at the input boundary', () => {
+ const limit = COMPLETE_SOURCE_DISPLAY_LIMITS.maximumInputCharactersPerSide
+ const exact = `${multilineSource(limit - 2)}😀`
+ const crossingPrefix = multilineSource(limit - 1)
+ const crossing = `${crossingPrefix}😀`
+
+ expect(displayBoundedMarkdownSource(exact)).toEqual({ text: exact, truncated: false })
+ const result = displayBoundedMarkdownSource(crossing)
+ expect(result.text).toBe(crossingPrefix)
+ expect(result.text.length).toBeLessThanOrEqual(COMPLETE_SOURCE_DISPLAY_LIMITS.maximumVisibleCharactersPerSide)
+ expect(result.text.isWellFormed()).toBe(true)
+ expect(result.truncated).toBe(true)
+ })
+
+ it('keeps supplementary characters and visible controls intact at the output boundary', () => {
+ expect(displayMarkdownSource('abc😀', 5)).toBe('abc😀')
+ expect(displayMarkdownSource('abc😀', 4)).toBe('abc')
+ expect(displayMarkdownSource('\tremaining', 5)).toBe('⟦TAB⟧')
+ })
+
+ it.each([
+ ['high', '\uD83D', '⟦U+D83D⟧'],
+ ['low', '\uDE00', '⟦U+DE00⟧'],
+ ])('renders a lone %s surrogate as an exact reversible token', (_name, source, expected) => {
+ const result = displayBoundedMarkdownSource(source)
+
+ expect(result).toEqual({ text: expected, truncated: false })
+ expect(result.text).not.toContain('\uFFFD')
+ expect(result.text.isWellFormed()).toBe(true)
+ })
+
+ it('reports expansion truncation instead of silently omitting a supplementary character', () => {
+ const result = displayBoundedMarkdownSource(`${'\t'.repeat(200_000)}😀`)
+
+ expect(result.truncated).toBe(true)
+ expect(result.text).toHaveLength(COMPLETE_SOURCE_DISPLAY_LIMITS.maximumVisibleCharactersPerLine)
+ expect(result.text).not.toContain('\uFFFD')
+ expect(result.text.isWellFormed()).toBe(true)
+ expect(result.text.length).toBeLessThanOrEqual(COMPLETE_SOURCE_DISPLAY_LIMITS.maximumVisibleCharactersPerLine)
+ })
+
+ it('shows complete fallback immediately, then enhanced literal hunks', async () => {
+ const wrapper = mount(MarkdownSourceComparison, {
+ props: { beforeContent: 'old\t \n', afterContent: 'new\u200B\n', layoutMode: 'paired' },
+ })
+ expect(wrapper.find('[data-comparison-source-fallback]').exists()).toBe(true)
+ await vi.waitFor(() => expect(wrapper.find('[data-source-hunk]').exists()).toBe(true))
+ expect(wrapper.text()).toContain('old')
+ expect(wrapper.text()).toContain('new⟦ZWSP⟧')
+ })
+
+ it('AUD-05 exposes side, operation, whitespace, EOL, and missing-newline semantics', async () => {
+ const wrapper = mount(MarkdownSourceComparison, {
+ props: {
+ beforeContent: `old${String.fromCharCode(9)}\r\ntrail `,
+ afterContent: 'new\ntrail\n',
+ layoutMode: 'paired',
+ },
+ })
+ await vi.waitFor(() => expect(wrapper.find('[data-source-hunk]').exists()).toBe(true))
+
+ expect(wrapper.find('[data-source-side="before"]').text()).toBe('Before')
+ expect(wrapper.find('[data-source-side="after"]').text()).toBe('After')
+ expect(wrapper.find('[data-source-operation="removed"]').attributes('aria-label')).toContain('Removed line')
+ expect(wrapper.find('[data-source-operation="added"]').attributes('aria-label')).toContain('Added line')
+ expect(wrapper.find('[data-source-operation="removed"] [data-source-cue]').text()).toBe('−')
+ expect(wrapper.find('[data-source-operation="added"] [data-source-cue]').text()).toBe('+')
+ for (const token of ['TAB', 'CRLF', 'LF', '2 TRAILING SPACES', 'No newline at end of file']) {
+ expect(wrapper.text()).toContain(token)
+ }
+ })
+
+ it('omits per-line badges when paired line endings match', async () => {
+ const wrapper = mount(MarkdownSourceComparison, {
+ props: {
+ beforeContent: 'old\nunchanged\n',
+ afterContent: 'new\nunchanged\n',
+ layoutMode: 'paired',
+ },
+ })
+ await vi.waitFor(() => expect(wrapper.find('[data-source-hunk]').exists()).toBe(true))
+
+ expect(wrapper.findAll('[data-source-eol]')).toHaveLength(0)
+ })
+
+ it('AUD-13 renders the audited bidi and control set as visible inert source tokens', async () => {
+ const controls = '\u061C\u00AD\u200E\u200F\u0085\u2028\u2029'
+ const wrapper = mount(MarkdownSourceComparison, {
+ props: { beforeContent: controls, afterContent: '', layoutMode: 'paired' },
+ })
+ await vi.waitFor(() => expect(wrapper.find('[data-source-hunk]').exists()).toBe(true))
+
+ for (const token of ['ALM', 'SHY', 'LRM', 'RLM', 'NEL', 'LS', 'PS']) {
+ expect(wrapper.text()).toContain(token)
+ }
+ for (const control of controls) {
+ expect(wrapper.text()).not.toContain(control)
+ }
+ })
+
+ it('AUD-08 expands a large unchanged gap incrementally with observable source ranges', async () => {
+ const prefix = Array.from({ length: 3_000 }, (_value, index) => `prefix-${index}`)
+ const suffix = Array.from({ length: 3_000 }, (_value, index) => `suffix-${index}`)
+ const beforeContent = [...prefix, 'old literal', ...suffix].join('\n')
+ const afterContent = [...prefix, 'new literal', ...suffix].join('\n')
+ const wrapper = mount(MarkdownSourceComparison, {
+ props: { beforeContent, afterContent, layoutMode: 'paired' },
+ })
+ await vi.waitFor(() => expect(wrapper.findAll('.text-source-comparison__gap button')).toHaveLength(2))
+
+ await wrapper.findAll('[data-source-gap-toggle]')[0]!.trigger('click')
+
+ expect(wrapper.findAll('.text-source-comparison__row')).toHaveLength(SOURCE_DIFF_LIMITS.maximumGapPageRows + 7)
+ expect(wrapper.text()).toContain('prefix-0')
+ expect(wrapper.text()).toContain(`prefix-${SOURCE_DIFF_LIMITS.maximumGapPageRows - 1}`)
+ expect(wrapper.text()).not.toContain(`prefix-${SOURCE_DIFF_LIMITS.maximumGapPageRows}`)
+
+ await wrapper.find('[data-source-gap-more]').trigger('click')
+
+ expect(wrapper.findAll('.text-source-comparison__row')).toHaveLength(SOURCE_DIFF_LIMITS.maximumGapPageRows * 2 + 7)
+ expect(wrapper.text()).toContain(`prefix-${SOURCE_DIFF_LIMITS.maximumGapPageRows}`)
+ })
+
+ it('AUD-08 never expands gaps beyond the shared displayed-row ceiling', async () => {
+ const prefix = Array.from({ length: 3_000 }, (_value, index) => `prefix-${index}`)
+ const suffix = Array.from({ length: 3_000 }, (_value, index) => `suffix-${index}`)
+ const beforeContent = [...prefix, 'old literal', ...suffix].join('\n')
+ const afterContent = [...prefix, 'new literal', ...suffix].join('\n')
+ const wrapper = mount(MarkdownSourceComparison, {
+ props: { beforeContent, afterContent, layoutMode: 'paired' },
+ })
+ await vi.waitFor(() => expect(wrapper.findAll('[data-source-gap-toggle]')).toHaveLength(2))
+
+ for (const toggle of wrapper.findAll('[data-source-gap-toggle]')) {
+ await toggle.trigger('click')
+ while (wrapper.find('[data-source-gap-more]').exists()) {
+ await wrapper.find('[data-source-gap-more]').trigger('click')
+ }
+ }
+
+ expect(wrapper.findAll('.text-source-comparison__row')).toHaveLength(SOURCE_DIFF_LIMITS.maximumDisplayedRows)
+ expect(wrapper.text()).toContain('prefix-0')
+ expect(wrapper.text()).toContain('suffix-3')
+ expect(wrapper.text()).not.toContain('suffix-2999')
+ expect(wrapper.find('[data-source-gap-limited]').exists()).toBe(true)
+ }, 15_000)
+
+ it('V11 preserves bounded complete fallback when source enhancement is limited', async () => {
+ const beforeContent = 'x'.repeat(SOURCE_DIFF_LIMITS.maximumCharacters + 1)
+ const wrapper = mount(MarkdownSourceComparison, {
+ props: { beforeContent, afterContent: 'after', layoutMode: 'single' },
+ })
+ await vi.waitFor(() => expect(wrapper.find('[data-source-limited]').exists()).toBe(true))
+ expect(wrapper.find('[data-comparison-source-fallback]').exists()).toBe(true)
+ expect(wrapper.find('pre code').text()).toHaveLength(COMPLETE_SOURCE_DISPLAY_LIMITS.maximumVisibleCharactersPerLine)
+ expect(wrapper.findAll('[role="status"]').map((status) => status.text()).join(' ')).toContain('truncated')
+ })
+})
diff --git a/src/tests/comparison/MarkdownSourceFallback.spec.ts b/src/tests/comparison/MarkdownSourceFallback.spec.ts
new file mode 100644
index 00000000000..0791c0d5efc
--- /dev/null
+++ b/src/tests/comparison/MarkdownSourceFallback.spec.ts
@@ -0,0 +1,30 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { mount } from '@vue/test-utils'
+import { describe, expect, it, vi } from 'vitest'
+import MarkdownSourceFallback from '../../components/MarkdownSourceFallback.vue'
+
+vi.mock('../../comparison/markdownSourceComparison.ts', () => {
+ throw new Error('enhanced Source is unavailable')
+})
+
+describe('complete Markdown source fallback', () => {
+ it('always renders both complete snapshots as inert literal text with visible controls', () => {
+ const wrapper = mount(MarkdownSourceFallback, {
+ props: {
+ beforeContent: '\nzero\u200Bwidth',
+ afterContent: '
\nlast',
+ },
+ })
+ const sources = wrapper.findAll('pre code')
+ expect(sources).toHaveLength(2)
+ expect(sources[0]!.text()).toContain('')
+ expect(sources[0]!.text()).toContain('⟦ZWSP⟧')
+ expect(sources[1]!.text()).toContain('')
+ expect(wrapper.find('script').exists()).toBe(false)
+ expect(wrapper.find('img').exists()).toBe(false)
+ })
+})
diff --git a/src/tests/comparison/a15HistoryDifferential.spec.ts b/src/tests/comparison/a15HistoryDifferential.spec.ts
new file mode 100644
index 00000000000..15e84bdb803
--- /dev/null
+++ b/src/tests/comparison/a15HistoryDifferential.spec.ts
@@ -0,0 +1,183 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { Node as ProseMirrorNode } from '@tiptap/pm/model'
+
+import { describe, expect, it } from 'vitest'
+import { createComparisonEditor } from '../../comparison/createComparisonEditor.ts'
+import { createHierarchicalMarkdownComparisonModel } from '../../comparison/hierarchicalMarkdownComparisonModel.ts'
+
+interface EditorLike {
+ state: { doc: ProseMirrorNode }
+ destroy: () => void
+}
+
+interface ExpectedReplacement {
+ operation: string
+ detail: string
+ before: string
+ after: string
+}
+
+interface RegressionCase {
+ name: string
+ before: string
+ after: string
+ expected: readonly ExpectedReplacement[]
+}
+
+const regressionCorpus: readonly RegressionCase[] = [
+ {
+ name: 'keeps an exact trailing block outside earlier replacements',
+ before: `# Wiki App
+
+Old build instructions.
+
+Shared footer.
+`,
+ after: `# Collective Wiki
+
+New installation instructions.
+
+Shared footer.
+`,
+ expected: [
+ { operation: 'insert', detail: 'inline', before: '', after: 'Collective ' },
+ { operation: 'delete', detail: 'inline', before: ' App', after: '' },
+ { operation: 'replace', detail: 'inline', before: 'Old build', after: 'New installation' },
+ ],
+ },
+ {
+ name: 'keeps a weighted multi-block gap precise',
+ before: `## Development Background: Ownership
+
+Individual users own files. Collective pages should be owned by the collective.
+
+## Stable anchor
+
+This block is unchanged.
+`,
+ after: `## Development background: Ownership
+
+Collective data is owned by the collective instead.
+
+## Stable anchor
+
+This block is unchanged.
+`,
+ expected: [
+ { operation: 'replace', detail: 'inline', before: 'B', after: 'b' },
+ { operation: 'delete', detail: 'inline', before: 'Individual users own files. ', after: '' },
+ { operation: 'replace', detail: 'inline', before: 'pages should be ', after: 'data is ' },
+ { operation: 'insert', detail: 'inline', before: '', after: ' instead' },
+ ],
+ },
+ {
+ name: 'reports code text and language replacements directly',
+ before: `\`\`\`
+const value = 1
+\`\`\`
+`,
+ after: `\`\`\`js
+const value = 1 // comment
+\`\`\`
+`,
+ expected: [
+ { operation: 'replace', detail: 'block', before: 'const value = 1', after: 'const value = 1 // comment' },
+ { operation: 'insert', detail: 'inline', before: '', after: ' // comment' },
+ ],
+ },
+ {
+ name: 'reports a removed list item as a node deletion',
+ before: `- Remove me
+- Keep me
+`,
+ after: `- Keep me
+`,
+ expected: [
+ { operation: 'delete', detail: 'block', before: 'Remove me', after: '' },
+ ],
+ },
+ {
+ name: 'does not expose parser-only Markdown syntax as a change signal',
+ before: `GNU AGPL v3 or later
+`,
+ after: `Files: *
+Copyright: Azul
+License: AGPL v3 or later
+`,
+ expected: [
+ {
+ operation: 'replace',
+ detail: 'inline',
+ before: 'GNU',
+ after: 'Files: *\nCopyright: Azul azul@example.com\nLicense:',
+ },
+ ],
+ },
+]
+
+function replacementOutput(beforeContent: string, afterContent: string) {
+ const beforeEditor = createComparisonEditor(beforeContent) as EditorLike
+ const afterEditor = createComparisonEditor(afterContent) as EditorLike
+ try {
+ const before = beforeEditor.state.doc
+ const after = afterEditor.state.doc
+ return createHierarchicalMarkdownComparisonModel(before, after).edits
+ .flatMap(({ descriptors }) => descriptors)
+ .map((descriptor) => ({
+ operation: descriptor.operation,
+ detail: descriptor.detail,
+ facets: descriptor.facets,
+ before: before.textBetween(descriptor.before.from, descriptor.before.to, '\n', '\ufffc'),
+ after: after.textBetween(descriptor.after.from, descriptor.after.to, '\n', '\ufffc'),
+ context: descriptor.context,
+ signals: descriptor.signals,
+ coarseReason: descriptor.coarseReason ?? null,
+ }))
+ } finally {
+ beforeEditor.destroy()
+ afterEditor.destroy()
+ }
+}
+
+function replacementProjection(replacements: ReturnType): ExpectedReplacement[] {
+ return replacements.map(({ operation, detail, before, after }) => ({ operation, detail, before, after }))
+}
+
+function corpusCase(name: string) {
+ return regressionCorpus.find((candidate) => candidate.name === name)!
+}
+
+describe('A15 repository-history regression corpus', () => {
+ it.each(regressionCorpus)('$name', ({ before, after, expected }) => {
+ const replacements = replacementOutput(before, after)
+
+ expect(replacementProjection(replacements)).toEqual(expected)
+ expect(replacements.every(({ coarseReason }) => coarseReason === null)).toBe(true)
+ })
+
+ it('keeps replacement descriptor signals observable', () => {
+ const code = corpusCase('reports code text and language replacements directly')
+ const codeReplacements = replacementOutput(code.before, code.after)
+ expect(codeReplacements[0]).toMatchObject({
+ facets: ['attribute'],
+ signals: [{ type: 'attribute', attribute: 'code-language', change: 'changed' }],
+ })
+
+ const deletion = corpusCase('reports a removed list item as a node deletion')
+ expect(replacementOutput(deletion.before, deletion.after)[0]).toMatchObject({
+ facets: ['text', 'structure'],
+ context: { before: { code: 'list-item' }, after: null },
+ signals: [{ type: 'node' }],
+ })
+
+ const syntax = corpusCase('does not expose parser-only Markdown syntax as a change signal')
+ expect(replacementOutput(syntax.before, syntax.after)[0]).toMatchObject({
+ facets: ['text', 'attribute', 'unknown'],
+ signals: [{ type: 'attribute', attribute: 'link', change: 'added' }],
+ })
+ })
+})
diff --git a/src/tests/comparison/comparisonAlignment.spec.ts b/src/tests/comparison/comparisonAlignment.spec.ts
new file mode 100644
index 00000000000..3783e9d7087
--- /dev/null
+++ b/src/tests/comparison/comparisonAlignment.spec.ts
@@ -0,0 +1,343 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { describe, expect, it } from 'vitest'
+import {
+ alignComparisonAxis,
+ createComparisonWorkLedger,
+ DEFAULT_COMPARISON_CELL_LEDGER,
+ DEFAULT_COMPARISON_TOKEN_LEDGER,
+ forcedIncreasingPairs,
+} from '../../comparison/comparisonAlignment.ts'
+
+function options(work = createComparisonWorkLedger()) {
+ return {
+ work,
+ fingerprint: (value: string) => value,
+ profile: (value: string) => [...value],
+ compatible: () => true,
+ }
+}
+
+interface EvidencedItem {
+ id: number
+ side: 'before' | 'after'
+}
+
+function evidencedOptions(work = createComparisonWorkLedger()) {
+ return {
+ work,
+ fingerprint: ({ id, side }: EvidencedItem) => `${side}:${id}`,
+ profile: ({ id, side }: EvidencedItem) => [`item:${id}`, side],
+ compatible: () => true,
+ }
+}
+
+function evidencedAxis(size: number, side: EvidencedItem['side']): EvidencedItem[] {
+ return Array.from({ length: size }, (_value, id) => ({ id, side }))
+}
+
+const FINAL_CELL_LEDGER = DEFAULT_COMPARISON_CELL_LEDGER
+const FINAL_TOKEN_LEDGER = DEFAULT_COMPARISON_TOKEN_LEDGER
+const FINAL_SQUARE_SIZE = Math.floor(Math.sqrt(FINAL_CELL_LEDGER))
+
+function permutations(values: readonly number[]): number[][] {
+ if (values.length < 2) {
+ return [Array.from(values)]
+ }
+ return values.flatMap((value, index) => permutations(values.toSpliced(index, 1))
+ .map((suffix) => [value, ...suffix]))
+}
+
+function exhaustiveForcedPairs(values: readonly number[]) {
+ let maximum = 0
+ const optimal: number[][] = []
+ for (let mask = 0; mask < 2 ** values.length; mask++) {
+ const indices = values.flatMap((_value, index) => mask & (1 << index) ? [index] : [])
+ if (!indices.every((index, offset) => offset === 0 || values[indices[offset - 1]!]! < values[index]!)) {
+ continue
+ }
+ if (indices.length > maximum) {
+ maximum = indices.length
+ optimal.length = 0
+ }
+ if (indices.length === maximum) {
+ optimal.push(indices)
+ }
+ }
+ return optimal[0]!.filter((index) => optimal.every((candidate) => candidate.includes(index)))
+ .map((before) => ({ before, after: values[before]! }))
+}
+
+describe('comparison alignment', () => {
+ it('uses the authoritative comparison-wide shipping ledgers', () => {
+ expect(createComparisonWorkLedger()).toEqual({
+ remainingCells: 40_000,
+ remainingTokenComparisons: 84_000_000,
+ })
+ })
+
+ it('pairs a whole equal axis without weighted work', () => {
+ const work = createComparisonWorkLedger()
+
+ expect(alignComparisonAxis(['alpha', 'beta'], ['alpha', 'beta'], options(work))).toEqual([
+ { before: 0, after: 0 },
+ { before: 1, after: 1 },
+ ])
+ expect(work).toEqual({
+ remainingCells: DEFAULT_COMPARISON_CELL_LEDGER,
+ remainingTokenComparisons: DEFAULT_COMPARISON_TOKEN_LEDGER,
+ })
+ })
+
+ it('A03 uses ordered unique fingerprints as exact anchors', () => {
+ const work = createComparisonWorkLedger()
+
+ expect(alignComparisonAxis(['alpha', 'omega'], ['new', 'alpha', 'omega'], options(work))).toEqual([
+ { before: null, after: 0 },
+ { before: 0, after: 1 },
+ { before: 1, after: 2 },
+ ])
+ expect(work.remainingCells).toBe(40_000)
+ })
+
+ it('matches exhaustive forced-LIS anchors for crossing candidates', () => {
+ for (let size = 1; size <= 6; size++) {
+ for (const values of permutations(Array.from({ length: size }, (_value, index) => index))) {
+ const pairs = values.map((after, before) => ({ before, after }))
+ expect(forcedIncreasingPairs(pairs), values.join(','))
+ .toEqual(exhaustiveForcedPairs(values))
+ }
+ }
+ })
+
+ it('aligns around the forced subset of crossing exact candidates', () => {
+ expect(alignComparisonAxis(['alpha', 'beta', 'gamma'], ['beta', 'gamma', 'alpha'], options())).toEqual([
+ { before: 0, after: null },
+ { before: 1, after: 0 },
+ { before: 2, after: 1 },
+ { before: null, after: 2 },
+ ])
+ })
+
+ it('retains the first exact duplicate when one is inserted', () => {
+ expect(alignComparisonAxis(['same'], ['same', 'same'], options())).toEqual([
+ { before: 0, after: 0 },
+ { before: null, after: 1 },
+ ])
+ })
+
+ it('retains the first exact duplicate when one is deleted', () => {
+ expect(alignComparisonAxis(['same', 'same'], ['same'], options())).toEqual([
+ { before: 0, after: 0 },
+ { before: 1, after: null },
+ ])
+ })
+
+ it('A09 pairs one compatible changed item without weighted work', () => {
+ const work = createComparisonWorkLedger()
+
+ expect(alignComparisonAxis(['before'], ['after'], options(work))).toEqual([
+ { before: 0, after: 0 },
+ ])
+ expect(work.remainingCells).toBe(DEFAULT_COMPARISON_CELL_LEDGER)
+ expect(work.remainingTokenComparisons).toBe(DEFAULT_COMPARISON_TOKEN_LEDGER)
+ })
+
+ it('leaves one incompatible changed item unmatched', () => {
+ const incompatible = {
+ ...options(),
+ compatible: () => false,
+ }
+
+ expect(alignComparisonAxis(['list'], ['quote'], incompatible)).toEqual([
+ { before: 0, after: null },
+ { before: null, after: 0 },
+ ])
+ })
+
+ it('A10 coarsens a multi-item rewrite with ambiguous exact attribution', () => {
+ expect(alignComparisonAxis(['aa', 'bb', 'cc'], ['xx', 'yy'], options())).toEqual([{
+ before: { from: 0, to: 3 },
+ after: { from: 0, to: 2 },
+ coarseReason: 'ambiguous-attribution',
+ }])
+ })
+
+ it.each([
+ Math.floor(FINAL_SQUARE_SIZE / 2),
+ FINAL_SQUARE_SIZE - 1,
+ ])('A11 keeps a final-ledger-derived unique-evidence %i square gap precise', (size) => {
+ const result = alignComparisonAxis(
+ evidencedAxis(size, 'before'),
+ evidencedAxis(size, 'after'),
+ evidencedOptions(),
+ )
+
+ expect(result).toHaveLength(size)
+ expect(result.every((step, index) => step.before === index && step.after === index)).toBe(true)
+ })
+
+ it('A12 keeps the largest default-ledger square gap precise', () => {
+ const work = createComparisonWorkLedger()
+ const size = FINAL_SQUARE_SIZE
+ const result = alignComparisonAxis(
+ evidencedAxis(size, 'before'),
+ evidencedAxis(size, 'after'),
+ evidencedOptions(work),
+ )
+
+ expect(result).toHaveLength(size)
+ expect(work.remainingCells).toBe(0)
+ expect(work.remainingTokenComparisons).toBe(FINAL_TOKEN_LEDGER - 4 * size ** 2)
+ })
+
+ it('A13 refuses the first generated cell and token overflows atomically', () => {
+ const cellWork = createComparisonWorkLedger()
+ const size = FINAL_SQUARE_SIZE
+ expect(alignComparisonAxis(
+ evidencedAxis(size + 1, 'before'),
+ evidencedAxis(size, 'after'),
+ evidencedOptions(cellWork),
+ )).toEqual([{
+ before: { from: 0, to: size + 1 },
+ after: { from: 0, to: size },
+ coarseReason: 'comparison-limit',
+ }])
+ expect(cellWork).toEqual(createComparisonWorkLedger())
+
+ const tokenWork = createComparisonWorkLedger()
+ const longProfile = Array.from({ length: Math.floor(FINAL_TOKEN_LEDGER / (2 * size * size)) + 1 }, () => 'x')
+ expect(alignComparisonAxis(
+ evidencedAxis(size, 'before'),
+ evidencedAxis(size, 'after'),
+ {
+ ...evidencedOptions(tokenWork),
+ profile: () => longProfile,
+ },
+ )).toEqual([{
+ before: { from: 0, to: size },
+ after: { from: 0, to: size },
+ coarseReason: 'comparison-limit',
+ }])
+ expect(tokenWork).toEqual(createComparisonWorkLedger())
+ })
+
+ it('A14 allocates final-ledger cell work by axis order without debiting a refused gap', () => {
+ interface Item {
+ fingerprint: string
+ profile: readonly string[]
+ }
+ const gap = (size: number, name: string, side: 'before' | 'after'): Item[] => (
+ Array.from({ length: size }, (_value, id) => ({
+ fingerprint: `${name}:${side}:${id}`,
+ profile: [`${name}:${id}`, side],
+ }))
+ )
+ const anchor = (name: string): Item => ({ fingerprint: name, profile: [name] })
+ const firstSize = Math.floor(FINAL_SQUARE_SIZE / 2)
+ const refusedSize = FINAL_SQUARE_SIZE
+ const lastSize = Math.max(2, Math.floor(firstSize / 10))
+ const before = [
+ ...gap(firstSize, 'first', 'before'),
+ anchor('anchor-1'),
+ ...gap(refusedSize, 'refused', 'before'),
+ anchor('anchor-2'),
+ ...gap(lastSize, 'last', 'before'),
+ ]
+ const after = [
+ ...gap(firstSize, 'first', 'after'),
+ anchor('anchor-1'),
+ ...gap(refusedSize, 'refused', 'after'),
+ anchor('anchor-2'),
+ ...gap(lastSize, 'last', 'after'),
+ ]
+ const work = createComparisonWorkLedger()
+ const result = alignComparisonAxis(before, after, {
+ work,
+ fingerprint: (item) => item.fingerprint,
+ profile: (item) => item.profile,
+ compatible: () => true,
+ })
+ const refusedStart = firstSize + 1
+
+ expect(result).toContainEqual({
+ before: { from: refusedStart, to: refusedStart + refusedSize },
+ after: { from: refusedStart, to: refusedStart + refusedSize },
+ coarseReason: 'comparison-limit',
+ })
+ expect(result.at(-1)).toEqual({ before: before.length - 1, after: after.length - 1 })
+ expect(work.remainingCells).toBe(FINAL_CELL_LEDGER - firstSize ** 2 - lastSize ** 2)
+ })
+
+ it('A14 retains token and tie debits while preserving work after a refused token gap', () => {
+ interface Item {
+ fingerprint: string
+ profile: readonly string[]
+ }
+ const gapSize = Math.floor(FINAL_SQUARE_SIZE / 2)
+ const firstAfterSize = gapSize - 1
+ const lastSize = Math.max(2, Math.floor(gapSize / 10))
+ const firstProduct = gapSize * firstAfterSize
+ const firstProfileLength = Math.floor(FINAL_TOKEN_LEDGER / (4 * firstProduct))
+ const firstProfile = Array.from({ length: firstProfileLength }, () => 'same')
+ const tieCharge = 2 * firstProduct * firstProfileLength
+ const refusedProfileLength = Math.floor((FINAL_TOKEN_LEDGER - tieCharge) / (2 * gapSize ** 2)) + 1
+ const refusedProfile = Array.from({ length: refusedProfileLength }, () => 'refused')
+ const gap = (size: number, name: string, side: 'before' | 'after', profile?: readonly string[]): Item[] => (
+ Array.from({ length: size }, (_value, id) => ({
+ fingerprint: `${name}:${side}:${id}`,
+ profile: profile ?? [`${name}:${id}`, side],
+ }))
+ )
+ const anchor = (name: string): Item => ({ fingerprint: name, profile: [name] })
+ const before = [
+ ...gap(gapSize, 'tie', 'before', firstProfile),
+ anchor('anchor-1'),
+ ...gap(gapSize, 'refused', 'before', refusedProfile),
+ anchor('anchor-2'),
+ ...gap(lastSize, 'last', 'before'),
+ ]
+ const after = [
+ ...gap(firstAfterSize, 'tie', 'after', firstProfile),
+ anchor('anchor-1'),
+ ...gap(gapSize, 'refused', 'after', refusedProfile),
+ anchor('anchor-2'),
+ ...gap(lastSize, 'last', 'after'),
+ ]
+ const work = createComparisonWorkLedger()
+ const result = alignComparisonAxis(before, after, {
+ work,
+ fingerprint: (item) => item.fingerprint,
+ profile: (item) => item.profile,
+ compatible: () => true,
+ })
+ const lastCharge = 4 * lastSize ** 2
+
+ expect(result[0]).toMatchObject({ coarseReason: 'ambiguous-attribution' })
+ expect(result).toContainEqual({
+ before: { from: gapSize + 1, to: 2 * gapSize + 1 },
+ after: { from: firstAfterSize + 1, to: firstAfterSize + gapSize + 1 },
+ coarseReason: 'comparison-limit',
+ })
+ expect(result.at(-1)).toEqual({ before: before.length - 1, after: after.length - 1 })
+ expect(work).toEqual({
+ remainingCells: FINAL_CELL_LEDGER - firstProduct - lastSize ** 2,
+ remainingTokenComparisons: FINAL_TOKEN_LEDGER - tieCharge - lastCharge,
+ })
+ })
+
+ it('P05 admits a skewed one-by-many gap by its exact cell charge', () => {
+ const work = createComparisonWorkLedger()
+ const result = alignComparisonAxis(
+ evidencedAxis(1, 'before'),
+ evidencedAxis(20_000, 'after'),
+ evidencedOptions(work),
+ )
+
+ expect(result).not.toContainEqual(expect.objectContaining({ coarseReason: 'comparison-limit' }))
+ expect(work.remainingCells).toBe(20_000)
+ })
+})
diff --git a/src/tests/comparison/comparisonAlignmentOracle.spec.ts b/src/tests/comparison/comparisonAlignmentOracle.spec.ts
new file mode 100644
index 00000000000..888fa76d654
--- /dev/null
+++ b/src/tests/comparison/comparisonAlignmentOracle.spec.ts
@@ -0,0 +1,167 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { ComparisonAlignmentStep, ComparisonWorkLedger } from '../../comparison/comparisonAlignment.ts'
+
+import { describe, expect, it } from 'vitest'
+import {
+ DEFAULT_COMPARISON_CELL_LEDGER,
+ DEFAULT_COMPARISON_TOKEN_LEDGER,
+ solveWeightedGap,
+} from '../../comparison/comparisonAlignment.ts'
+
+interface OracleItem {
+ fingerprint: string
+ profile: readonly string[]
+}
+
+interface Rational {
+ numerator: bigint
+ denominator: bigint
+}
+
+interface OracleMatch {
+ before: number
+ after: number
+}
+
+function compareRational(a: Rational, b: Rational) {
+ const difference = a.numerator * b.denominator - b.numerator * a.denominator
+ return difference < 0n ? -1 : difference > 0n ? 1 : 0
+}
+
+function addRational(a: Rational, b: Rational): Rational {
+ return {
+ numerator: a.numerator * b.denominator + b.numerator * a.denominator,
+ denominator: a.denominator * b.denominator,
+ }
+}
+
+function oraclePairScore(before: OracleItem, after: OracleItem): Rational {
+ if (before.fingerprint === after.fingerprint) {
+ return { numerator: 3n, denominator: 1n }
+ }
+ let prefix = 0
+ while (prefix < before.profile.length
+ && prefix < after.profile.length
+ && before.profile[prefix] === after.profile[prefix]) {
+ prefix++
+ }
+ let suffix = 0
+ const maximumSuffix = Math.min(before.profile.length, after.profile.length) - prefix
+ while (suffix < maximumSuffix
+ && before.profile[before.profile.length - suffix - 1] === after.profile[after.profile.length - suffix - 1]) {
+ suffix++
+ }
+ const denominator = BigInt(Math.max(before.profile.length, after.profile.length, 1))
+ return { numerator: denominator + BigInt(prefix + suffix), denominator }
+}
+
+function enumerateMatchings(
+ beforeCount: number,
+ afterCount: number,
+ beforeStart = 0,
+ afterStart = 0,
+): OracleMatch[][] {
+ const matchings: OracleMatch[][] = [[]]
+ for (let before = beforeStart; before < beforeCount; before++) {
+ for (let after = afterStart; after < afterCount; after++) {
+ for (const suffix of enumerateMatchings(beforeCount, afterCount, before + 1, after + 1)) {
+ matchings.push([{ before, after }, ...suffix])
+ }
+ }
+ }
+ return matchings
+}
+
+function oracleAlignment(before: readonly OracleItem[], after: readonly OracleItem[]) {
+ let bestScore: Rational = { numerator: -1n, denominator: 1n }
+ let best: OracleMatch[][] = []
+ for (const matching of enumerateMatchings(before.length, after.length)) {
+ const score = matching.reduce(
+ (total, pair) => addRational(total, oraclePairScore(before[pair.before]!, after[pair.after]!)),
+ { numerator: 0n, denominator: 1n },
+ )
+ const order = compareRational(score, bestScore)
+ if (order > 0) {
+ bestScore = score
+ best = [matching]
+ } else if (order === 0) {
+ best.push(matching)
+ }
+ }
+ const signatures = new Map(best.map((matching) => [
+ matching.map(({ before: a, after: b }) => `${a}:${b}`).join(','),
+ matching,
+ ]))
+ if (signatures.size > 1) {
+ return { coarseReason: 'ambiguous-attribution' as const }
+ }
+ return { steps: alignmentSteps(before.length, after.length, [...signatures.values()][0]!) }
+}
+
+function alignmentSteps(beforeCount: number, afterCount: number, matches: readonly OracleMatch[]) {
+ const steps: ComparisonAlignmentStep[] = []
+ let before = 0
+ let after = 0
+ for (const match of matches) {
+ while (before < match.before) {
+ steps.push({ before: before++, after: null })
+ }
+ while (after < match.after) {
+ steps.push({ before: null, after: after++ })
+ }
+ steps.push({ before: before++, after: after++ })
+ }
+ while (before < beforeCount) {
+ steps.push({ before: before++, after: null })
+ }
+ while (after < afterCount) {
+ steps.push({ before: null, after: after++ })
+ }
+ return steps
+}
+
+function axes(items: readonly OracleItem[], maximumLength: number): OracleItem[][] {
+ const result: OracleItem[][] = [[]]
+ for (let length = 1; length <= maximumLength; length++) {
+ for (const prefix of result.filter((axis) => axis.length === length - 1)) {
+ for (const item of items) {
+ result.push([...prefix, item])
+ }
+ }
+ }
+ return result
+}
+
+function freshWork(): ComparisonWorkLedger {
+ return {
+ remainingCells: DEFAULT_COMPARISON_CELL_LEDGER,
+ remainingTokenComparisons: DEFAULT_COMPARISON_TOKEN_LEDGER,
+ }
+}
+
+describe('comparison alignment exact oracles', () => {
+ it('matches an independent exact-rational and signature oracle exhaustively', () => {
+ const items: OracleItem[] = [
+ { fingerprint: 'a', profile: ['shared', 'a'] },
+ { fingerprint: 'b', profile: ['shared', 'b'] },
+ { fingerprint: 'c', profile: ['c'] },
+ ]
+ const candidates = axes(items, 3)
+ for (const before of candidates) {
+ for (const after of candidates) {
+ const actual = solveWeightedGap(before, after, {
+ work: freshWork(),
+ fingerprint: (item) => item.fingerprint,
+ profile: (item) => item.profile,
+ compatible: () => true,
+ })
+ expect(actual, `${before.map(({ fingerprint }) => fingerprint)} -> ${after.map(({ fingerprint }) => fingerprint)}`)
+ .toEqual(oracleAlignment(before, after))
+ }
+ }
+ })
+})
diff --git a/src/tests/comparison/comparisonDecorations.spec.ts b/src/tests/comparison/comparisonDecorations.spec.ts
new file mode 100644
index 00000000000..62b217b4f70
--- /dev/null
+++ b/src/tests/comparison/comparisonDecorations.spec.ts
@@ -0,0 +1,90 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { ComparisonDescriptor } from '../../comparison/markdownComparisonTypes.ts'
+
+import { EditorState } from '@tiptap/pm/state'
+import { schema } from 'prosemirror-schema-basic'
+import { describe, expect, it } from 'vitest'
+import { createComparisonDocumentIndex } from '../../comparison/comparisonDocumentIndex.ts'
+import { createComparisonEditor } from '../../comparison/createComparisonEditor.ts'
+import {
+ ComparisonProjectionError,
+ createComparisonDecorationPlugin,
+ prepareComparisonDecorations,
+} from '../../comparison/markdownComparison.ts'
+
+function descriptor(id: string, before: { from: number, to: number }, after = before): ComparisonDescriptor {
+ return {
+ id,
+ operation: 'replace',
+ detail: 'inline',
+ facets: ['text'],
+ before,
+ after,
+ context: { before: null, after: null },
+ preview: { before: null, after: null },
+ signals: [],
+ }
+}
+
+const doc = schema.node('doc', null, [schema.node('paragraph', null, schema.text('hello'))])
+
+describe('comparison decorations', () => {
+ it('does not infer a current descriptor without edit-owned selection', () => {
+ const change = descriptor('text', { from: 1, to: 4 })
+ const { key, plugin } = createComparisonDecorationPlugin([change], 'before', 'Changed')
+ const state = EditorState.create({ doc, plugins: [plugin] })
+ expect(key.getState(state)).toMatchObject({ activeIds: ['text'], currentIds: [] })
+ })
+
+ it('V04 projects non-empty ranges without creating any marker for a zero-length side', () => {
+ expect(prepareComparisonDecorations(doc, [descriptor('empty', { from: 2, to: 2 })], 'before')).toEqual([])
+ const projected = prepareComparisonDecorations(doc, [descriptor('text', { from: 1, to: 4 })], 'before')
+ expect(projected).toEqual([expect.objectContaining({ from: 1, to: 4, type: 'inline' })])
+ })
+
+ it('fails the complete projection when a non-empty range cannot be represented', () => {
+ const invalid = descriptor('invalid', { from: 99, to: 100 })
+ expect(() => prepareComparisonDecorations(doc, [invalid], 'before')).toThrow(ComparisonProjectionError)
+ })
+
+ it('AUD-04 decorates the enclosing list for a coarse nested-list range', () => {
+ const editor = createComparisonEditor('- outer\n - first\n - second')
+ try {
+ const index = createComparisonDocumentIndex(editor.state.doc)
+ const outerList = index.children[0]!
+ const nestedList = outerList.children[0]!.children[1]!
+ const firstItem = nestedList.children[0]!
+ const lastItem = nestedList.children.at(-1)!
+ const change = descriptor('nested-list', { from: firstItem.from, to: lastItem.to })
+ change.detail = 'block'
+ change.context.before = {
+ code: 'list-item',
+ path: firstItem.path,
+ from: firstItem.from,
+ to: firstItem.to,
+ }
+
+ expect(prepareComparisonDecorations(editor.state.doc, [change], 'before')).toEqual([
+ expect.objectContaining({ from: nestedList.from, to: nestedList.to, type: 'node' }),
+ ])
+ } finally {
+ editor.destroy()
+ }
+ })
+
+ it('invalidates prepared immutable decorations after a document transaction', () => {
+ const change = descriptor('text', { from: 1, to: 4 })
+ const { key, plugin } = createComparisonDecorationPlugin([change], 'before', 'Changed', {
+ activeIds: ['text'],
+ currentIds: ['text'],
+ })
+ const state = EditorState.create({ doc, plugins: [plugin] })
+ expect(key.getState(state)?.prepared).toHaveLength(1)
+ const changed = state.apply(state.tr.insertText('!', 1))
+ expect(key.getState(changed)).toMatchObject({ activeIds: [], currentIds: [], prepared: [] })
+ })
+})
diff --git a/src/tests/comparison/comparisonDocumentLocation.spec.ts b/src/tests/comparison/comparisonDocumentLocation.spec.ts
new file mode 100644
index 00000000000..42afa139dd6
--- /dev/null
+++ b/src/tests/comparison/comparisonDocumentLocation.spec.ts
@@ -0,0 +1,52 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { describe, expect, it, vi } from 'vitest'
+import { locateComparisonTarget } from '../../comparison/comparisonNavigation.ts'
+
+function scrollerIn(pane: HTMLElement) {
+ const scroller = document.createElement('div')
+ pane.append(scroller)
+ Object.defineProperties(scroller, {
+ clientHeight: { value: 300 },
+ scrollHeight: { value: 1200 },
+ scrollLeft: { value: 20 },
+ scrollTop: { value: 50 },
+ })
+ vi.spyOn(scroller, 'getBoundingClientRect').mockReturnValue({ height: 300, top: 100 } as DOMRect)
+ Object.defineProperty(scroller, 'scrollTo', { value: vi.fn() })
+ return scroller
+}
+
+describe('comparison document location', () => {
+ it('prefers the decorated DOM target', () => {
+ const pane = document.createElement('article')
+ const scroller = scrollerIn(pane)
+ const target = document.createElement('span')
+ target.dataset.comparisonChange = 'descriptor-1'
+ scroller.append(target)
+ vi.spyOn(target, 'getBoundingClientRect').mockReturnValue({ height: 20, top: 700 } as DOMRect)
+ const fallback = vi.fn(() => ({ top: 900, height: 1 }))
+ expect(locateComparisonTarget(pane, scroller, 'descriptor-1', 'smooth', fallback)).toBe(true)
+ expect(fallback).not.toHaveBeenCalled()
+ })
+
+ it('V04 centers a supplied position rectangle for a marker-free zero-length side', () => {
+ const pane = document.createElement('article')
+ const scroller = scrollerIn(pane)
+ const fallback = vi.fn(() => ({ top: 700, height: 1 }))
+ expect(locateComparisonTarget(pane, scroller, 'missing', 'auto', fallback)).toBe(true)
+ expect(scroller.scrollTo).toHaveBeenCalledWith({ behavior: 'auto', left: 20, top: 500.5 })
+ expect(pane.querySelector('[data-comparison-change="missing"]')).toBeNull()
+ })
+
+ it('fails closed for invalid or hidden panes', () => {
+ const pane = document.createElement('article')
+ const scroller = scrollerIn(pane)
+ pane.hidden = true
+ expect(locateComparisonTarget(pane, scroller, 'missing', 'auto', () => ({ top: 1, height: 1 }))).toBe(false)
+ expect(locateComparisonTarget(null, scroller, 'missing', 'auto')).toBe(false)
+ })
+})
diff --git a/src/tests/comparison/comparisonEditorLifecycle.spec.ts b/src/tests/comparison/comparisonEditorLifecycle.spec.ts
new file mode 100644
index 00000000000..ead3a8dbfbb
--- /dev/null
+++ b/src/tests/comparison/comparisonEditorLifecycle.spec.ts
@@ -0,0 +1,28 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { PluginKey, Plugin as ProseMirrorPlugin } from '@tiptap/pm/state'
+import { mount } from '@vue/test-utils'
+import { describe, expect, it, vi } from 'vitest'
+import ComparisonEditorContent from '../../components/ComparisonEditorContent.vue'
+import { createComparisonEditor } from '../../comparison/createComparisonEditor.ts'
+
+describe('comparison editor lifecycle boundary', () => {
+ it('mounts the detached editor with its comparison plugin and node views', async () => {
+ const editor = createComparisonEditor('::: info\nBefore\n:::')
+ const plugin = new ProseMirrorPlugin({ key: new PluginKey('comparison') })
+ const wrapper = mount(ComparisonEditorContent, { props: { editor, plugins: [plugin] } })
+ try {
+ await vi.waitFor(() => expect(wrapper.emitted('ready')).toHaveLength(1))
+ const content = wrapper.get('.text-comparison__content')
+ expect(editor.view.dom.parentElement).toBe(content.element)
+ expect(content.find('[data-node-view-wrapper][data-text-el="callout"]').exists()).toBe(true)
+ expect(plugin.spec.key?.get(editor.state)).toBeDefined()
+ } finally {
+ wrapper.unmount()
+ editor.destroy()
+ }
+ })
+})
diff --git a/src/tests/comparison/comparisonNavigation.spec.ts b/src/tests/comparison/comparisonNavigation.spec.ts
new file mode 100644
index 00000000000..f627fa4c048
--- /dev/null
+++ b/src/tests/comparison/comparisonNavigation.spec.ts
@@ -0,0 +1,61 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { ComparisonDescriptor, ComparisonEdit } from '../../comparison/markdownComparisonTypes.ts'
+
+import { describe, expect, it } from 'vitest'
+import {
+ currentIdAfterFilter,
+ currentOrdinal,
+ isPureFormatting,
+ moveCurrentId,
+} from '../../comparison/comparisonNavigation.ts'
+
+function descriptor(id: string, facets: ComparisonDescriptor['facets'], operation: ComparisonDescriptor['operation'] = 'replace'): ComparisonDescriptor {
+ return {
+ id,
+ operation,
+ detail: 'inline',
+ facets,
+ before: { from: 0, to: 1 },
+ after: { from: 0, to: 1 },
+ context: { before: null, after: null },
+ preview: { before: null, after: null },
+ signals: [],
+ }
+}
+
+function edit(id: string, descriptors: ComparisonDescriptor[]): ComparisonEdit {
+ return { id, kind: 'content', primary: descriptors.at(-1)!, descriptors }
+}
+
+describe('edit-first comparison navigation', () => {
+ const edits = [
+ edit('e0', [descriptor('d0', ['text'])]),
+ edit('e1', [descriptor('d1', ['formatting'])]),
+ edit('e2', [descriptor('d2a', ['formatting']), descriptor('d2b', ['text', 'formatting'])]),
+ edit('e3', [descriptor('d3', ['attribute'])]),
+ ]
+
+ it('requires every member to be formatting-only', () => {
+ expect(isPureFormatting(edits[1]!)).toBe(true)
+ expect(isPureFormatting(edits[2]!)).toBe(false)
+ })
+
+ it('V02 preserves the current edit or moves next then previous after filtering', () => {
+ expect(currentIdAfterFilter(edits, ['e0', 'e2', 'e3'], 'e2')).toBe('e2')
+ expect(currentIdAfterFilter(edits, ['e0', 'e2', 'e3'], 'e1')).toBe('e2')
+ expect(currentIdAfterFilter(edits, ['e0'], 'e1')).toBe('e0')
+ expect(currentIdAfterFilter(edits, [], 'e1')).toBeNull()
+ })
+
+ it('V01 wraps navigation and reports one ordinal per first-class edit', () => {
+ const active = ['e0', 'e2', 'e3']
+ expect(moveCurrentId(active, 'e0', -1)).toBe('e3')
+ expect(moveCurrentId(active, 'e3', 1)).toBe('e0')
+ expect(currentOrdinal(active, 'e2')).toBe(2)
+ expect(currentOrdinal([], null)).toBe(0)
+ })
+})
diff --git a/src/tests/comparison/comparisonPerformance.spec.ts b/src/tests/comparison/comparisonPerformance.spec.ts
new file mode 100644
index 00000000000..4cbdade1289
--- /dev/null
+++ b/src/tests/comparison/comparisonPerformance.spec.ts
@@ -0,0 +1,171 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { Node } from '@tiptap/pm/model'
+
+import { describe, expect, it } from 'vitest'
+import {
+ alignComparisonAxis,
+ createComparisonWorkLedger,
+ DEFAULT_COMPARISON_TOKEN_LEDGER,
+} from '../../comparison/comparisonAlignment.ts'
+import { createHierarchicalMarkdownComparisonModel } from '../../comparison/hierarchicalMarkdownComparisonModel.ts'
+import { prepareComparisonDecorations } from '../../comparison/markdownComparison.ts'
+import { createComparisonTestEditor } from './comparisonTestEditor.ts'
+
+interface Item {
+ key: string
+ profile: readonly string[]
+}
+
+function items(count: number, side: string): Item[] {
+ return Array.from({ length: count }, (_value, index) => ({
+ key: `${side}:${index}`,
+ profile: [`item:${index}`, side],
+ }))
+}
+
+function options(work = createComparisonWorkLedger()) {
+ return {
+ work,
+ fingerprint: ({ key }: Item) => key,
+ profile: ({ profile }: Item) => profile,
+ compatible: () => true,
+ }
+}
+
+describe('bounded comparison performance fixtures', () => {
+ it('AUD-14 projects near-limit one-sided descriptors within a bounded candidate budget', () => {
+ const editor = createComparisonTestEditor('placeholder')
+ try {
+ const headings = Array.from({ length: 6490 }, (_value, index) => (
+ editor.schema.nodes.heading!.create({ level: 1 }, editor.schema.text(`Section ${index}`))
+ ))
+ const populated = editor.schema.nodes.doc!.create(null, headings)
+ const empty = editor.schema.nodes.doc!.create()
+ const model = createHierarchicalMarkdownComparisonModel(populated, empty)
+ const descriptors = model.edits.flatMap(({ descriptors: members }) => members)
+
+ const prepared = prepareComparisonDecorations(populated, descriptors, 'before')
+
+ expect(prepared).toHaveLength(headings.length)
+ } finally {
+ editor.destroy()
+ }
+ })
+
+ it('P01 compares a near-6500-line exact-anchor document with negligible weighted work', () => {
+ const editor = createComparisonTestEditor('placeholder')
+ try {
+ const headings = Array.from({ length: 6490 }, (_value, index) => (
+ editor.schema.nodes.heading!.create({ level: 1 }, editor.schema.text(`Section ${index}`))
+ ))
+ const before = editor.schema.nodes.doc!.create(null, headings)
+ const changedHeading = editor.schema.nodes.heading!.create(
+ { level: 1 },
+ editor.schema.text('Section 3245 edited'),
+ )
+ const after = editor.schema.nodes.doc!.create(null, headings.with(3245, changedHeading))
+
+ const model = createHierarchicalMarkdownComparisonModel(before, after)
+
+ expect(model.edits).toHaveLength(1)
+
+ const work = createComparisonWorkLedger()
+ const axis = Array.from({ length: 6490 }, (_value, index) => ({
+ key: `anchor:${index}`,
+ profile: [`anchor:${index}`],
+ }))
+ const changed = axis.with(3245, { key: 'changed:3245', profile: ['changed:3245'] })
+ alignComparisonAxis(axis, changed, options(work))
+ expect(work).toEqual(createComparisonWorkLedger())
+ } finally {
+ editor.destroy()
+ }
+ })
+
+ it.each(['insert', 'delete'] as const)('places a near-6500-line one-sided %s axis in linear time', (operation) => {
+ const editor = createComparisonTestEditor('placeholder')
+ try {
+ const headings = Array.from({ length: 6490 }, (_value, index) => (
+ editor.schema.nodes.heading!.create({ level: 1 }, editor.schema.text(`Section ${index}`))
+ ))
+ const empty = editor.schema.nodes.doc!.create()
+ const populated = editor.schema.nodes.doc!.create(null, headings)
+ const model = operation === 'insert'
+ ? createHierarchicalMarkdownComparisonModel(empty, populated)
+ : createHierarchicalMarkdownComparisonModel(populated, empty)
+
+ expect(model.edits).toHaveLength(headings.length)
+ expect(model.edits.every(({ primary }) => primary.operation === operation)).toBe(true)
+ } finally {
+ editor.destroy()
+ }
+ })
+
+ it('P04 shares the final token ledger across nested production nodes', () => {
+ const editor = createComparisonTestEditor('placeholder')
+ try {
+ const firstBeforeCount = 100
+ const firstAfterCount = firstBeforeCount - 1
+ const firstProduct = firstBeforeCount * firstAfterCount
+ const firstLength = Math.floor(DEFAULT_COMPARISON_TOKEN_LEDGER / (4 * firstProduct))
+ const firstCharge = 2 * firstProduct * firstLength
+ const secondCount = 100
+ const secondLength = Math.floor((DEFAULT_COMPARISON_TOKEN_LEDGER - firstCharge) / (2 * secondCount ** 2)) + 1
+ const paragraphs = (count: number, character: string, length: number) => Array.from(
+ { length: count },
+ () => editor.schema.nodes.paragraph!.create(null, editor.schema.text(character.repeat(length))),
+ )
+ const quote = (children: readonly Node[]) => (
+ editor.schema.nodes.blockquote!.create(null, children)
+ )
+ const anchor = editor.schema.nodes.paragraph!.create(null, editor.schema.text('exact nested boundary anchor'))
+ const before = editor.schema.nodes.doc!.create(null, [
+ quote(paragraphs(firstBeforeCount, 'a', firstLength)),
+ anchor,
+ quote(paragraphs(secondCount, 'c', secondLength)),
+ ])
+ const after = editor.schema.nodes.doc!.create(null, [
+ quote(paragraphs(firstAfterCount, 'b', firstLength)),
+ anchor,
+ quote(paragraphs(secondCount, 'd', secondLength)),
+ ])
+ const model = createHierarchicalMarkdownComparisonModel(before, after)
+
+ expect(2 * secondCount ** 2 * (secondLength - 1)).toBeLessThanOrEqual(DEFAULT_COMPARISON_TOKEN_LEDGER - firstCharge)
+ expect(2 * secondCount ** 2 * secondLength).toBeGreaterThan(DEFAULT_COMPARISON_TOKEN_LEDGER - firstCharge)
+ expect(model.edits.map(({ primary }) => primary.coarseReason)).toEqual([
+ 'ambiguous-attribution',
+ 'comparison-limit',
+ ])
+ } finally {
+ editor.destroy()
+ }
+ })
+
+ it('P03 bounds many aggregate maximal gaps with one comparison-wide ledger', () => {
+ const gapCount = 5
+ const gapSize = 200
+ const before: Item[] = []
+ const after: Item[] = []
+ for (let gap = 0; gap < gapCount; gap++) {
+ before.push(...items(gapSize, `before-${gap}`))
+ after.push(...items(gapSize, `after-${gap}`))
+ if (gap < gapCount - 1) {
+ const anchor = { key: `anchor-${gap}`, profile: [`anchor-${gap}`] }
+ before.push(anchor)
+ after.push(anchor)
+ }
+ }
+ const work = createComparisonWorkLedger()
+
+ const result = alignComparisonAxis(before, after, options(work))
+ const limited = result.filter((region) => 'coarseReason' in region && region.coarseReason === 'comparison-limit')
+
+ expect(work.remainingCells).toBe(0)
+ expect(limited).toHaveLength(gapCount - 1)
+ })
+})
diff --git a/src/tests/comparison/comparisonPresentation.spec.ts b/src/tests/comparison/comparisonPresentation.spec.ts
new file mode 100644
index 00000000000..92be57d563f
--- /dev/null
+++ b/src/tests/comparison/comparisonPresentation.spec.ts
@@ -0,0 +1,28 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { ComparisonAttributeCode, ComparisonSignal } from '../../comparison/markdownComparisonTypes.ts'
+
+import { describe, expect, it } from 'vitest'
+import { selectComparisonSignal } from '../../comparison/comparisonPresentation.ts'
+
+const bold: ComparisonSignal = { type: 'mark', mark: 'bold', change: 'added' }
+const attribute = (code: ComparisonAttributeCode): ComparisonSignal => ({ type: 'attribute', attribute: code, change: 'changed' })
+
+describe('AUD-10 comparison presentation', () => {
+ it('selects the same strongest attribute regardless of descriptor storage order', () => {
+ const signals = [bold, attribute('image-alt'), attribute('image-target')]
+ expect(selectComparisonSignal(signals)).toEqual(attribute('image-target'))
+ expect(selectComparisonSignal([...signals].reverse())).toEqual(attribute('image-target'))
+ })
+
+ it('prioritizes every specific attribute and node structure over generic formatting', () => {
+ for (const code of ['link', 'task-state', 'heading-level', 'table-span', 'unknown-attribute'] as const) {
+ expect(selectComparisonSignal([bold, attribute(code)])).toEqual(attribute(code))
+ }
+ const node: ComparisonSignal = { type: 'node' }
+ expect(selectComparisonSignal([bold, node])).toEqual(node)
+ })
+})
diff --git a/src/tests/comparison/comparisonSections.spec.ts b/src/tests/comparison/comparisonSections.spec.ts
new file mode 100644
index 00000000000..2dd787ba6f4
--- /dev/null
+++ b/src/tests/comparison/comparisonSections.spec.ts
@@ -0,0 +1,76 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { Node } from '@tiptap/pm/model'
+import type { ComparisonDescriptor, ComparisonEdit } from '../../comparison/markdownComparisonTypes.ts'
+
+import { schema } from 'prosemirror-schema-basic'
+import { describe, expect, it } from 'vitest'
+import { buildComparisonSections, headingLocations, nearestHeading } from '../../comparison/comparisonSections.ts'
+
+function doc(...blocks: Array<[type: 'heading' | 'paragraph', text: string]>): Node {
+ return schema.node('doc', null, blocks.map(([type, text]) => schema.node(type, type === 'heading' ? { level: 1 } : null, text ? schema.text(text) : undefined)))
+}
+
+function descriptor(id: string, operation: ComparisonDescriptor['operation'], before: number, after: number): ComparisonDescriptor {
+ return {
+ id,
+ operation,
+ detail: 'inline',
+ facets: ['text'],
+ before: { from: before, to: before + 1 },
+ after: { from: after, to: after + 1 },
+ context: {
+ before: { code: 'paragraph', path: [1], from: before, to: before + 1 },
+ after: { code: 'paragraph', path: [1], from: after, to: after + 1 },
+ },
+ preview: { before: null, after: null },
+ signals: [],
+ }
+}
+
+function edit(id: string, primary: ComparisonDescriptor, members: ComparisonDescriptor[] = [primary]): ComparisonEdit {
+ return { id, kind: 'content', primary, descriptors: members }
+}
+
+describe('edit-first comparison sections', () => {
+ it('finds ordered headings and resolves the nearest preceding heading', () => {
+ const document = doc(['paragraph', 'Intro'], ['heading', 'One'], ['paragraph', 'Body'], ['heading', 'Two'])
+ const headings = headingLocations(document)
+ expect(headings.map(({ text }) => text)).toEqual(['One', 'Two'])
+ expect(nearestHeading(headings, 0)).toBe('')
+ expect(nearestHeading(headings, headings[1]!.from)).toBe('Two')
+ })
+
+ it('builds one row source per edit', () => {
+ const before = doc(['heading', 'Alpha'], ['paragraph', 'Before'])
+ const after = doc(['heading', 'Alpha'], ['paragraph', 'After'])
+ const headingEnd = after.child(0).nodeSize
+ const primary = descriptor('d-primary', 'replace', headingEnd, headingEnd)
+ const formatting = { ...descriptor('d-format', 'replace', headingEnd, headingEnd), facets: ['formatting'] as const }
+ const sections = buildComparisonSections([edit('edit-1', primary, [formatting, primary])], before, after)
+
+ expect(sections).toEqual([expect.objectContaining({
+ id: 'edit-1',
+ title: 'Alpha',
+ edits: [expect.objectContaining({ id: 'edit-1', primary })],
+ })])
+ })
+
+ it('uses Before context for deletions and the After title for a correlated rename', () => {
+ const before = doc(['heading', 'Old'], ['paragraph', 'Before'])
+ const after = doc(['heading', 'New'], ['paragraph', 'After'])
+ const beforeBody = before.child(0).nodeSize
+ const afterBody = after.child(0).nodeSize
+ const rename = descriptor('rename', 'replace', 0, 0)
+ rename.context.before = { code: 'heading', path: [0], from: 0, to: beforeBody }
+ rename.context.after = { code: 'heading', path: [0], from: 0, to: afterBody }
+ const deletion = descriptor('delete', 'delete', beforeBody, afterBody)
+ const sections = buildComparisonSections([edit('rename-edit', rename), edit('delete-edit', deletion)], before, after)
+
+ expect(sections.map(({ title }) => title)).toEqual(['New'])
+ expect(sections[0]!.edits.map(({ id }) => id)).toEqual(['rename-edit', 'delete-edit'])
+ })
+})
diff --git a/src/tests/comparison/comparisonTestEditor.ts b/src/tests/comparison/comparisonTestEditor.ts
new file mode 100644
index 00000000000..103a67e7973
--- /dev/null
+++ b/src/tests/comparison/comparisonTestEditor.ts
@@ -0,0 +1,19 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { createComparisonEditor } from '../../comparison/createComparisonEditor.ts'
+
+export function createComparisonTestEditor(content: string) {
+ return createComparisonEditor(content, { noLazyImages: true })
+}
+
+export function comparisonTestDocument(content: string) {
+ const editor = createComparisonEditor(content, { noLazyImages: true })
+ try {
+ return editor.state.doc
+ } finally {
+ editor.destroy()
+ }
+}
diff --git a/src/tests/comparison/createComparisonEditor.spec.ts b/src/tests/comparison/createComparisonEditor.spec.ts
new file mode 100644
index 00000000000..cda29bf339d
--- /dev/null
+++ b/src/tests/comparison/createComparisonEditor.spec.ts
@@ -0,0 +1,28 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { describe, expect, it } from 'vitest'
+import { createComparisonEditor } from '../../comparison/createComparisonEditor.ts'
+
+describe('comparison editor', () => {
+ it('creates a complete immutable detached Text editor with directional paragraphs', () => {
+ const editor = createComparisonEditor('English\n\nالعربية')
+ try {
+ expect(editor.options.element).toBeInstanceOf(HTMLElement)
+ expect((editor.options.element as HTMLElement).isConnected).toBe(false)
+ expect(editor.isEditable).toBe(false)
+ expect(editor.state.doc.textContent).toBe('Englishالعربية')
+ const directions: Array = []
+ editor.state.doc.descendants((node) => {
+ if (node.type.name === 'paragraph') {
+ directions.push(node.attrs.dir as string | null)
+ }
+ })
+ expect(directions.slice(0, 2)).toEqual(['ltr', 'rtl'])
+ } finally {
+ editor.destroy()
+ }
+ })
+})
diff --git a/src/tests/comparison/createMarkdownContentComparison.spec.ts b/src/tests/comparison/createMarkdownContentComparison.spec.ts
new file mode 100644
index 00000000000..53c3fd57479
--- /dev/null
+++ b/src/tests/comparison/createMarkdownContentComparison.spec.ts
@@ -0,0 +1,281 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { Editor } from '@tiptap/vue-3'
+import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from 'vitest'
+import { nextTick } from 'vue'
+import * as markdownComparison from '../../comparison/markdownComparison.ts'
+import { createMarkdownContentComparison } from '../../createMarkdownContentComparison.ts'
+
+const originalScrollTo = HTMLElement.prototype.scrollTo
+
+beforeAll(async () => {
+ HTMLElement.prototype.scrollTo = vi.fn()
+ await Promise.all([
+ import('../../components/MarkdownContentComparison.vue'),
+ import('../../components/MarkdownSourceFallback.vue'),
+ ])
+})
+
+afterAll(() => {
+ if (originalScrollTo) {
+ HTMLElement.prototype.scrollTo = originalScrollTo
+ } else {
+ delete (HTMLElement.prototype as Partial).scrollTo
+ }
+})
+
+afterEach(() => vi.restoreAllMocks())
+
+describe('Markdown comparison factory fallback and lifecycle', () => {
+ it('V09 reports syntax-only Markdown as no semantic edit and opens Source', async () => {
+ const el = document.createElement('div')
+ const instance = await createMarkdownContentComparison({
+ beforeContent: '*same rendered text*',
+ afterContent: '_same rendered text_',
+ el,
+ })
+
+ expect(el.querySelectorAll('[data-comparison-change]')).toHaveLength(0)
+ expect(el.querySelector('[role="status"]')?.textContent).toContain('No rendered differences')
+ const openSource = el.querySelector('[data-comparison-empty-action]')
+ expect(openSource).not.toBeNull()
+ openSource!.click()
+ await nextTick()
+ expect([...el.querySelectorAll('[role="tab"]')]
+ .find(({ textContent }) => textContent?.trim() === 'Markdown source')
+ ?.getAttribute('aria-selected')).toBe('true')
+ instance.destroy()
+ })
+
+ it('F05 remounts complete Source when rendered editor initialization fails', async () => {
+ vi.spyOn(Editor.prototype, 'mount').mockImplementation(() => {
+ throw new Error('forced mount failure')
+ })
+ const el = document.createElement('div')
+ const instance = await createMarkdownContentComparison({ beforeContent: 'before', afterContent: 'after', el })
+ expect(el.querySelector('[data-comparison-source-fallback]')).not.toBeNull()
+ expect(el.querySelectorAll('.ProseMirror')).toHaveLength(0)
+ expect(el.textContent).toContain('before')
+ expect(el.textContent).toContain('after')
+ instance.destroy()
+ instance.destroy()
+ expect(el.childElementCount).toBe(0)
+ })
+
+ it('F06 remounts complete Source without partial Documents when projection fails', async () => {
+ const originalSetAttribute = Element.prototype.setAttribute
+ vi.spyOn(Element.prototype, 'setAttribute').mockImplementation(function(this: Element, name, value) {
+ if (name === 'data-comparison-change') {
+ throw new Error('forced projection failure')
+ }
+ return originalSetAttribute.call(this, name, value)
+ })
+ const beforeContent = 'Complete projection before'
+ const afterContent = 'Complete projection after'
+ const el = document.createElement('div')
+ const instance = await createMarkdownContentComparison({ beforeContent, afterContent, el })
+ const fullDocuments = [...el.querySelectorAll('[role="tab"]')]
+ .find(({ textContent }) => textContent?.trim() === 'Full documents')
+
+ fullDocuments!.click()
+ await vi.waitFor(() => {
+ expect(el.querySelector('[data-comparison-source-fallback]')).not.toBeNull()
+ })
+ expect(el.querySelectorAll('.text-comparison__documents .ProseMirror')).toHaveLength(0)
+ expect(el.textContent).toContain(beforeContent)
+ expect(el.textContent).toContain(afterContent)
+ instance.destroy()
+ })
+
+ it('V12 can reopen the same pair after idempotent destroy without leaking root DOM', async () => {
+ const el = document.createElement('div')
+ for (let index = 0; index < 2; index++) {
+ const instance = await createMarkdownContentComparison({ beforeContent: 'Before', afterContent: 'After', el })
+ expect(el.querySelectorAll('.text-comparison-root')).toHaveLength(1)
+ instance.destroy()
+ instance.destroy()
+ expect(el.childElementCount).toBe(0)
+ }
+ })
+
+ it('keeps both document editors alive while switching views', async () => {
+ const el = document.createElement('div')
+ const instance = await createMarkdownContentComparison({ beforeContent: 'Before', afterContent: 'After', el })
+ expect(el.querySelectorAll('.ProseMirror')).toHaveLength(0)
+ expect(el.querySelectorAll('[data-comparison-source-fallback]')).toHaveLength(0)
+ const selectTab = async (label: string) => {
+ const tab = [...el.querySelectorAll('[role="tab"]')]
+ .find(({ textContent }) => textContent?.trim() === label)
+ expect(tab).toBeDefined()
+ tab!.click()
+ await nextTick()
+ }
+
+ await selectTab('Full documents')
+ expect(el.querySelectorAll('.ProseMirror')).toHaveLength(2)
+ await selectTab('Changes')
+ await selectTab('Full documents')
+
+ expect(el.querySelector('.text-comparison > [data-comparison-source-fallback]')).toBeNull()
+ expect(el.querySelectorAll('.ProseMirror')).toHaveLength(2)
+ instance.destroy()
+ })
+
+ it('omits duplicate heading anchors from the two comparison documents', async () => {
+ const el = document.createElement('div')
+ const instance = await createMarkdownContentComparison({
+ beforeContent: '# Shared heading\n\nBefore',
+ afterContent: '# Shared heading\n\nAfter',
+ el,
+ })
+ const documents = [...el.querySelectorAll('[role="tab"]')]
+ .find(({ textContent }) => textContent?.trim() === 'Full documents')
+
+ documents!.click()
+ await nextTick()
+
+ await vi.waitFor(() => expect(el.querySelectorAll('.ProseMirror')).toHaveLength(2))
+ await new Promise((resolve) => setTimeout(resolve, 0))
+ expect(el.querySelectorAll('.text-comparison__documents .heading-anchor[id]')).toHaveLength(0)
+ instance.destroy()
+ })
+
+ it('AUD-02 publishes the current selection when Documents mounts lazily', async () => {
+ const originalScrollTo = HTMLElement.prototype.scrollTo
+ const scrollTo = vi.fn()
+ HTMLElement.prototype.scrollTo = scrollTo
+ const el = document.createElement('div')
+ const instance = await createMarkdownContentComparison({
+ beforeContent: 'Old first.\n\nOld second.',
+ afterContent: 'New first.\n\nNew second.',
+ el,
+ })
+ const secondEdit = el.querySelectorAll('[data-comparison-select]')[1]
+
+ secondEdit!.click()
+ await vi.waitFor(() => {
+ expect(el.querySelectorAll('[data-comparison-change="change-1"][aria-current="true"]')).toHaveLength(2)
+ })
+ await vi.waitFor(() => expect(scrollTo).toHaveBeenCalled())
+ instance.destroy()
+ if (originalScrollTo) {
+ HTMLElement.prototype.scrollTo = originalScrollTo
+ } else {
+ delete (HTMLElement.prototype as Partial).scrollTo
+ }
+ })
+
+ it('AUD-11 locates the current edit on the newly visible side after a single-to-paired resize', async () => {
+ const originalResizeObserver = globalThis.ResizeObserver
+ const originalScrollTo = HTMLElement.prototype.scrollTo
+ const scrollTo = vi.fn()
+ let resizeTo!: (width: number) => void
+ HTMLElement.prototype.scrollTo = scrollTo
+ globalThis.ResizeObserver = class {
+ constructor(private readonly callback: ResizeObserverCallback) {}
+
+ observe(target: Element) {
+ resizeTo = (width) => this.callback([{ target, contentRect: { width } } as ResizeObserverEntry], this)
+ resizeTo(600)
+ }
+
+ disconnect() {}
+
+ unobserve() {}
+ } as typeof ResizeObserver
+ const el = document.createElement('div')
+ const instance = await createMarkdownContentComparison({
+ beforeContent: 'Old first.\n\nOld second.',
+ afterContent: 'New first.\n\nNew second.',
+ el,
+ })
+ try {
+ el.querySelectorAll('[data-comparison-select]')[1]!.click()
+ await vi.waitFor(() => expect(el.querySelector('.text-comparison--single')).not.toBeNull())
+ const afterScroller = el.querySelector('.text-comparison__document--after .text-comparison__document-scroller')!
+ await vi.waitFor(() => expect(scrollTo).toHaveBeenCalled())
+ expect(scrollTo.mock.contexts).not.toContain(afterScroller)
+
+ resizeTo(900)
+ await vi.waitFor(() => expect(el.querySelector('.text-comparison--paired')).not.toBeNull())
+
+ expect(scrollTo.mock.contexts).toContain(afterScroller)
+ } finally {
+ instance.destroy()
+ globalThis.ResizeObserver = originalResizeObserver
+ if (originalScrollTo) {
+ HTMLElement.prototype.scrollTo = originalScrollTo
+ } else {
+ delete (HTMLElement.prototype as Partial).scrollTo
+ }
+ }
+ })
+
+ it('keeps the working comparison when the loaded callback throws', async () => {
+ const el = document.createElement('div')
+ const creation = createMarkdownContentComparison({
+ beforeContent: 'Before',
+ afterContent: 'After',
+ el,
+ onLoaded: () => { throw new Error('callback failure') },
+ })
+ const instance = await Promise.race([
+ creation,
+ new Promise((resolve) => setTimeout(() => resolve(null), 1000)),
+ ])
+ expect(instance).not.toBeNull()
+ expect(el.querySelector('.text-comparison')).not.toBeNull()
+ expect(el.querySelector('[data-comparison-source-fallback]')).toBeNull()
+ instance?.destroy()
+ })
+
+ it('AUD-21 awaits a rejected loaded callback and keeps the working comparison', async () => {
+ const el = document.createElement('div')
+ let rejectLoaded!: (error: Error) => void
+ const onLoaded = vi.fn(() => new Promise((_resolve, reject) => {
+ rejectLoaded = reject
+ }))
+ const creation = createMarkdownContentComparison({
+ beforeContent: 'Before',
+ afterContent: 'After',
+ el,
+ onLoaded,
+ })
+ let creationSettled = false
+ void creation.then(() => {
+ creationSettled = true
+ })
+ await new Promise((resolve) => setTimeout(resolve, 0))
+
+ expect(onLoaded).toHaveBeenCalledOnce()
+ expect(creationSettled).toBe(false)
+ rejectLoaded(new Error('async callback failure'))
+ const instance = await creation
+
+ expect(el.querySelector('.text-comparison')).not.toBeNull()
+ expect(el.querySelector('[data-comparison-source-fallback]')).toBeNull()
+ instance.destroy()
+ })
+
+ it('F07 routes a descriptor model limit to complete Source', async () => {
+ vi.spyOn(markdownComparison, 'createMarkdownComparisonModel').mockImplementation(() => {
+ throw new markdownComparison.ComparisonModelLimitError()
+ })
+ const beforeContent = '# Complete before snapshot\n\nBefore body\n'
+ const afterContent = '# Complete after snapshot\n\nAfter body\n'
+ const el = document.createElement('div')
+
+ const instance = await createMarkdownContentComparison({ beforeContent, afterContent, el })
+
+ expect(el.querySelector('[data-comparison-source-fallback]')).not.toBeNull()
+ expect(el.querySelectorAll('.ProseMirror')).toHaveLength(0)
+ expect(el.textContent).toContain('Detailed rendered comparison unavailable')
+ expect(el.textContent).not.toContain('No rendered changes')
+ expect(el.textContent).toContain(beforeContent)
+ expect(el.textContent).toContain(afterContent)
+ instance.destroy()
+ })
+})
diff --git a/src/tests/comparison/hierarchicalMarkdownComparison.spec.ts b/src/tests/comparison/hierarchicalMarkdownComparison.spec.ts
new file mode 100644
index 00000000000..88ac12c2f13
--- /dev/null
+++ b/src/tests/comparison/hierarchicalMarkdownComparison.spec.ts
@@ -0,0 +1,363 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { Node } from '@tiptap/pm/model'
+import type { ComparisonEdit, ComparisonSide } from '../../comparison/markdownComparisonTypes.ts'
+
+import { Schema } from '@tiptap/pm/model'
+import { schema as basicSchema } from 'prosemirror-schema-basic'
+import { describe, expect, it } from 'vitest'
+import {
+ ComparisonModelLimitError,
+ createHierarchicalMarkdownComparisonModel,
+ MAX_INLINE_ENVELOPE_SIZE,
+ MAX_RENDERED_COMPARISON_DESCRIPTORS,
+} from '../../comparison/hierarchicalMarkdownComparisonModel.ts'
+import { comparisonTestDocument, createComparisonTestEditor } from './comparisonTestEditor.ts'
+
+function compare(beforeContent: string, afterContent: string) {
+ const before = comparisonTestDocument(beforeContent)
+ const after = comparisonTestDocument(afterContent)
+ return {
+ before,
+ after,
+ model: createHierarchicalMarkdownComparisonModel(before, after),
+ }
+}
+
+function meaningfulSize(doc: Node) {
+ return doc.content.size - (doc.lastChild?.content.size === 0 ? doc.lastChild.nodeSize : 0)
+}
+
+function editText(doc: { textBetween: (from: number, to: number, separator: string) => string }) {
+ return (edit: ComparisonEdit, side: ComparisonSide) => (
+ doc.textBetween(edit.primary[side].from, edit.primary[side].to, '\n')
+ )
+}
+
+describe('hierarchical markdown comparison', () => {
+ it('A01 emits no edit for two equal documents', () => {
+ const { model } = compare('# Title\n\nBody text.\n', '# Title\n\nBody text.\n')
+
+ expect(model.edits).toEqual([])
+ })
+
+ it('A02 normalizes separate schema instances without position or content drift', () => {
+ const beforeEditor = createComparisonTestEditor('# Title\n\nOriginal body.\n')
+ const afterEditor = createComparisonTestEditor('# Title\n\nUpdated body.\n')
+ try {
+ const before = beforeEditor.state.doc
+ const after = afterEditor.state.doc
+ expect(before.type.schema).not.toBe(after.type.schema)
+
+ const model = createHierarchicalMarkdownComparisonModel(before, after)
+
+ expect(model.edits).toHaveLength(1)
+ const [edit] = model.edits
+ expect(before.textBetween(edit!.primary.before.from, edit!.primary.before.to)).toBe('Original')
+ expect(after.textBetween(edit!.primary.after.from, edit!.primary.after.to)).toBe('Updated')
+ } finally {
+ beforeEditor.destroy()
+ afterEditor.destroy()
+ }
+ })
+
+ it('AUD-19 rejects cross-schema normalization that drops node attributes', () => {
+ const paragraph = basicSchema.spec.nodes.get('paragraph')!
+ const beforeSchema = new Schema({
+ nodes: basicSchema.spec.nodes.update('paragraph', { ...paragraph, attrs: { audit: { default: null } } }),
+ marks: basicSchema.spec.marks,
+ })
+ const afterSchema = new Schema({ nodes: basicSchema.spec.nodes, marks: basicSchema.spec.marks })
+ const before = beforeSchema.node('doc', null, [beforeSchema.node('paragraph', { audit: 'must-survive' }, beforeSchema.text('same'))])
+ const after = afterSchema.node('doc', null, [afterSchema.node('paragraph', null, afterSchema.text('same'))])
+
+ expect(() => createHierarchicalMarkdownComparisonModel(before, after)).toThrow(/schema normalization lost semantics/)
+ })
+
+ it('A05 retains the first repeated paragraph and inserts the second copy', () => {
+ const { after, model } = compare('Anchor\n\nSame\n', 'Anchor\n\nSame\n\nSame\n')
+ const text = editText(after)
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]!.primary.operation).toBe('insert')
+ expect(text(model.edits[0]!, 'after')).toBe('Same')
+ expect(model.edits[0]!.primary.after).toEqual({
+ from: after.child(0).nodeSize + after.child(1).nodeSize,
+ to: meaningfulSize(after),
+ })
+ })
+
+ it('A06 retains the first repeated paragraph and deletes the second copy', () => {
+ const { before, model } = compare('Anchor\n\nSame\n\nSame\n', 'Anchor\n\nSame\n')
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]!.primary.operation).toBe('delete')
+ expect(model.edits[0]!.primary.before).toEqual({
+ from: before.child(0).nodeSize + before.child(1).nodeSize,
+ to: meaningfulSize(before),
+ })
+ })
+
+ it.each([
+ ['insertion', '# Existing\n', '## Added\n\n# Existing\n', 'insert'],
+ ['deletion', '## Removed\n\n# Existing\n', '# Existing\n', 'delete'],
+ ] as const)('AUD-12 reports a heading %s as added or removed without adjacent heading attributes', (_name, beforeContent, afterContent, operation) => {
+ const { model } = compare(beforeContent, afterContent)
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]!.primary.operation).toBe(operation)
+ expect(model.edits[0]!.primary.signals).not.toContainEqual(expect.objectContaining({
+ type: 'attribute',
+ attribute: 'heading-level',
+ }))
+ })
+
+ it('A07 reports a paragraph turning into a heading as one semantic replacement', () => {
+ const { model } = compare('Shared title\n', '# Shared title\n')
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({
+ kind: 'content',
+ primary: {
+ detail: 'block',
+ operation: 'replace',
+ context: { before: { code: 'paragraph' }, after: { code: 'heading' } },
+ },
+ })
+ expect(model.edits[0]!.primary.facets).toContain('structure')
+ expect(model.edits[0]!.primary.signals).toContainEqual({
+ type: 'attribute',
+ attribute: 'heading-level',
+ change: 'added',
+ })
+ })
+
+ it('A08 does not pair incompatible non-text containers', () => {
+ const { model } = compare('- Shared item\n', '> Shared item\n')
+
+ expect(model.edits).toHaveLength(2)
+ expect(model.edits.map(({ primary }) => primary.operation).toSorted()).toEqual(['delete', 'insert'])
+ })
+
+ it.each([
+ ['section headings', '# Setup\n\n# Usage\n\n# Notes\n', '# Install\n\n# Config\n'],
+ ['shopping items', 'Buy milk\n\nBuy eggs\n\nBuy rice\n', 'Get bread\n\nGet jam\n'],
+ ])('A10 coarsens a no-affix %s rewrite', (_name, beforeContent, afterContent) => {
+ const { before, after, model } = compare(beforeContent, afterContent)
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]!.primary).toMatchObject({
+ coarseReason: 'ambiguous-attribution',
+ detail: 'block',
+ operation: 'replace',
+ before: { from: 0, to: meaningfulSize(before) },
+ after: { from: 0, to: meaningfulSize(after) },
+ })
+ })
+
+ it('reports one reordered block as one move edit', () => {
+ const { model } = compare(
+ 'Unique alpha\n\nUnique beta\n\nUnique gamma\n',
+ 'Unique beta\n\nUnique gamma\n\nUnique alpha\n',
+ )
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]!.primary).toMatchObject({
+ operation: 'move',
+ detail: 'block',
+ facets: ['structure'],
+ })
+ })
+
+ it('pairs uniquely compatible changed containers instead of coarsening their shared gap', () => {
+ const before = [
+ '# Operational notes',
+ '',
+ '> Draft maintenance window starts at 20:00.',
+ '',
+ '::: info',
+ 'The canary is limited to one region.',
+ ':::',
+ '',
+ '',
+ 'Draft runbook
',
+ '',
+ 'Rollback after two failed health checks.',
+ '',
+ '',
+ '',
+ ].join('\n')
+ const after = [
+ '# Operational notes',
+ '',
+ '> Approved maintenance window starts at 21:00.',
+ '',
+ '::: warn',
+ 'The canary is limited to two regions.',
+ ':::',
+ '',
+ '',
+ 'Approved runbook
',
+ '',
+ 'Rollback after one failed health check.',
+ '',
+ '',
+ '',
+ ].join('\n')
+ const { model } = compare(before, after)
+ const attributes = model.edits.flatMap(({ descriptors }) => descriptors)
+ .flatMap(({ signals }) => signals)
+ .filter((signal) => signal.type === 'attribute')
+ .map(({ attribute }) => attribute)
+ const primaryAttributes = model.edits
+ .flatMap(({ primary }) => primary.signals)
+ .filter((signal) => signal.type === 'attribute')
+ .map(({ attribute }) => attribute)
+
+ expect(model.edits.length).toBeGreaterThan(3)
+ expect(model.edits.every(({ primary }) => primary.coarseReason === undefined)).toBe(true)
+ expect(attributes).toContain('callout-type')
+ expect(attributes).toContain('details-state')
+ expect(primaryAttributes.filter((attribute) => attribute === 'callout-type')).toHaveLength(1)
+ expect(primaryAttributes.filter((attribute) => attribute === 'details-state')).toHaveLength(1)
+ })
+
+ it('does not label code content edits as language changes', () => {
+ const { model } = compare(
+ '```javascript\nconst stage = "draft"\n```\n',
+ '```typescript\nconst stage = "ready"\n```\n',
+ )
+ const languageEdits = model.edits.filter(({ primary }) => primary.signals.some((signal) => (
+ signal.type === 'attribute' && signal.attribute === 'code-language'
+ )))
+
+ expect(languageEdits).toHaveLength(1)
+ expect(model.edits.some(({ primary }) => (
+ primary.preview.before?.kind === 'text'
+ && primary.preview.before.text === 'draft'
+ && primary.signals.every((signal) => signal.type !== 'attribute' || signal.attribute !== 'code-language')
+ ))).toBe(true)
+ })
+
+ it('expands front-matter previews to complete changed lines', () => {
+ const { model } = compare([
+ '---',
+ 'release: atlas-2.4',
+ 'status: draft',
+ 'owner: Maya Chen',
+ 'tags: [payments, canary]',
+ 'legacy: true',
+ '---',
+ '',
+ '# Release record',
+ ].join('\n'), [
+ '---',
+ 'release: atlas-2.4.1',
+ 'status: approved',
+ 'owner: Noor Rahman',
+ 'tags: [payments, canary, customer-visible]',
+ 'approved-at: 2026-08-30T21:00:00+07:00',
+ '---',
+ '',
+ '# Release record',
+ ].join('\n'))
+ const previews = model.edits
+ .filter(({ primary }) => primary.context.before?.code === 'front-matter')
+ .map(({ primary }) => [primary.preview.before, primary.preview.after])
+ .flat()
+ .map((preview) => preview?.kind === 'text' ? preview.text : '')
+
+ expect(previews).toHaveLength(4)
+ expect(previews[0]).toMatch(/^release: atlas-2\.4\b/)
+ expect(previews[1]).toMatch(/^release: atlas-2\.4\.1\b/)
+ expect(previews[2]).toMatch(/^tags: \[payments, canary\]/)
+ expect(previews[3]).toMatch(/^tags: \[payments, canary, customer-visible\]/)
+ })
+
+ it('moves exact repeated section content with its unique heading anchor', () => {
+ const repeated = 'Health check passed.\n\nDeploy the stable build.'
+ const before = [
+ '# Repeated deployment notes',
+ `## Region A\n\n${repeated}`,
+ `## Region B\n\n${repeated}`,
+ `## Retired region\n\n${repeated}`,
+ `## Region C\n\n${repeated}`,
+ ].join('\n\n')
+ const after = [
+ '# Repeated deployment notes',
+ `## Region C\n\n${repeated}`,
+ `## Region A\n\n${repeated}`,
+ '## New region\n\nHealth check passed.\n\nDeploy the canary build.',
+ `## Region B\n\n${repeated}`,
+ ].join('\n\n')
+ const { before: beforeDoc, after: afterDoc, model } = compare(before, after)
+ const moved = model.edits.find(({ primary }) => primary.operation === 'move')!
+ const repeatedCopies = model.edits.filter(({ primary }) => primary.operation !== 'move')
+ .map((edit) => ({
+ operation: edit.primary.operation,
+ before: beforeDoc.textBetween(edit.primary.before.from, edit.primary.before.to, '\n'),
+ after: afterDoc.textBetween(edit.primary.after.from, edit.primary.after.to, '\n'),
+ }))
+
+ expect(model.edits).toHaveLength(7)
+ expect(beforeDoc.textBetween(moved.primary.before.from, moved.primary.before.to, '\n'))
+ .toBe('Region C\nHealth check passed.\nDeploy the stable build.')
+ expect(afterDoc.textBetween(moved.primary.after.from, moved.primary.after.to, '\n'))
+ .toBe('Region C\nHealth check passed.\nDeploy the stable build.')
+ expect(repeatedCopies.filter(({ before }) => before === 'Health check passed.')).toHaveLength(1)
+ expect(repeatedCopies.filter(({ after }) => after === 'Health check passed.')).toHaveLength(1)
+ })
+
+ it('F08 keeps a large inline envelope as one rendered block change', () => {
+ const shared = 'z'.repeat(MAX_INLINE_ENVELOPE_SIZE)
+ const { before, after, model } = compare(`start ${shared}\n`, `${shared} finish\n`)
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]!.primary).toMatchObject({
+ detail: 'block',
+ before: { from: 0, to: meaningfulSize(before) },
+ after: { from: 0, to: meaningfulSize(after) },
+ })
+ })
+
+ it('accepts 10000 descriptors and rejects 10001 at the production default', () => {
+ const editor = createComparisonTestEditor('placeholder')
+ try {
+ const document = (count: number, side: 'before' | 'after') => {
+ const nodes = Array.from({ length: count }, (_value, index) => [
+ editor.schema.nodes.paragraph!.create(null, editor.schema.text(`${side} ${index}`)),
+ editor.schema.nodes.heading!.create({ level: 2 }, editor.schema.text(`Exact anchor ${index}`)),
+ ]).flat()
+ return editor.schema.nodes.doc!.create(null, nodes)
+ }
+ const before = document(MAX_RENDERED_COMPARISON_DESCRIPTORS + 1, 'before')
+ const atLimit = createHierarchicalMarkdownComparisonModel(
+ editor.schema.nodes.doc!.create(null, before.content.content.slice(0, -2)),
+ document(MAX_RENDERED_COMPARISON_DESCRIPTORS, 'after'),
+ )
+
+ expect(MAX_RENDERED_COMPARISON_DESCRIPTORS).toBe(10_000)
+ expect(atLimit.edits).toHaveLength(MAX_RENDERED_COMPARISON_DESCRIPTORS)
+ expect(() => createHierarchicalMarkdownComparisonModel(
+ before,
+ document(MAX_RENDERED_COMPARISON_DESCRIPTORS + 1, 'after'),
+ )).toThrow(ComparisonModelLimitError)
+ } finally {
+ editor.destroy()
+ }
+ })
+
+ it('freezes the model and keeps the primary inside its own descriptors', () => {
+ const { model } = compare('one\n\ntwo\n', 'one edited\n\ntwo edited\n')
+
+ expect(Object.isFrozen(model)).toBe(true)
+ expect(Object.isFrozen(model.edits)).toBe(true)
+ expect(model.edits.every((edit) => edit.descriptors.includes(edit.primary))).toBe(true)
+ expect(new Set(model.edits.map(({ id }) => id))).toHaveLength(model.edits.length)
+ expect(new Set(model.edits.flatMap(({ descriptors }) => descriptors.map(({ id }) => id))))
+ .toHaveLength(model.edits.flatMap(({ descriptors }) => descriptors).length)
+ })
+})
diff --git a/src/tests/comparison/markdownSourceComparison.spec.ts b/src/tests/comparison/markdownSourceComparison.spec.ts
new file mode 100644
index 00000000000..3af9ec62b96
--- /dev/null
+++ b/src/tests/comparison/markdownSourceComparison.spec.ts
@@ -0,0 +1,214 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { SourceDiffHunk, SourceDiffLine } from '../../comparison/markdownSourceComparison.ts'
+
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { createMarkdownSourceComparison, materializeSourceDiffGap, SOURCE_DIFF_LIMITS } from '../../comparison/markdownSourceComparison.ts'
+import { compareMarkdownSourceLines } from '../../comparison/markdownSourceComparisonProtocol.ts'
+
+afterEach(() => vi.unstubAllGlobals())
+
+describe('literal Markdown source comparison', () => {
+ const lines = (hunks: readonly SourceDiffHunk[], side: 'before' | 'after') => hunks
+ .flatMap(({ rows }) => rows.flatMap((row) => row[side] ? [row[side]] : []))
+
+ it('V10 normalizes EOL only for matching while retaining literal line facts', async () => {
+ const model = await createMarkdownSourceComparison('tab\tvalue \r\nzero\u200Bwidth\nlast', 'tab value \nzero width\nlast\n')
+ expect(model.status).toBe('ready')
+ if (model.status !== 'ready') {
+ return
+ }
+ const before = lines(model.hunks, 'before')
+ const after = lines(model.hunks, 'after')
+ expect(before[0]).toMatchObject({ text: 'tab\tvalue ', eol: 'crlf' })
+ expect(before.some(({ text }) => text.includes('\u200b'))).toBe(true)
+ expect(before.at(-1)?.eol).toBe('none')
+ expect(after.at(-1)?.eol).toBe('lf')
+ })
+
+ it('AUD-14 materializes stable paired row records with the source model', async () => {
+ const model = await createMarkdownSourceComparison('old\nsame\n', 'new\nsame\n')
+ expect(model.status).toBe('ready')
+ if (model.status !== 'ready') {
+ return
+ }
+ const hunk = model.hunks[0]!
+
+ expect(hunk.rows.map(({ before, after }) => [before?.text, after?.text])).toEqual([['old', 'new'], ['same', 'same']])
+ expect(hunk.rows).toBe(hunk.rows)
+ })
+
+ it('AUD-08 represents large collapsed gaps without retained line clones', async () => {
+ const source = Array.from({ length: 10_000 }, (_value, index) => `line ${index}`).join('\n')
+ const model = await createMarkdownSourceComparison(source, source)
+ expect(model.status).toBe('ready')
+ if (model.status !== 'ready') {
+ return
+ }
+
+ expect(model.gaps).toEqual([{
+ id: 'source-gap-0',
+ slot: 0,
+ beforeFrom: 0,
+ beforeTo: 10_000,
+ afterFrom: 0,
+ afterTo: 10_000,
+ count: 10_000,
+ }])
+ })
+
+ it('AUD-08 materializes large gaps in bounded observable pages', async () => {
+ const source = Array.from({ length: 10_000 }, (_value, index) => `line ${index}`).join('\n')
+ const model = await createMarkdownSourceComparison(source, source)
+ expect(model.status).toBe('ready')
+ if (model.status !== 'ready') {
+ return
+ }
+ const gap = model.gaps[0]!
+
+ const firstPage = materializeSourceDiffGap(source, source, gap, Number.POSITIVE_INFINITY)
+ const secondPage = materializeSourceDiffGap(source, source, gap, SOURCE_DIFF_LIMITS.maximumGapPageRows, SOURCE_DIFF_LIMITS.maximumGapPageRows)
+
+ expect(firstPage).toHaveLength(SOURCE_DIFF_LIMITS.maximumGapPageRows)
+ expect(firstPage[0]?.before).toMatchObject({ number: 1, text: 'line 0' })
+ expect(firstPage.at(-1)?.after).toMatchObject({ number: SOURCE_DIFF_LIMITS.maximumGapPageRows, text: `line ${SOURCE_DIFF_LIMITS.maximumGapPageRows - 1}` })
+ expect(secondPage).toHaveLength(SOURCE_DIFF_LIMITS.maximumGapPageRows)
+ expect(secondPage[0]?.before).toMatchObject({ number: SOURCE_DIFF_LIMITS.maximumGapPageRows + 1, text: `line ${SOURCE_DIFF_LIMITS.maximumGapPageRows}` })
+ expect(secondPage.at(-1)?.after).toMatchObject({ number: SOURCE_DIFF_LIMITS.maximumGapPageRows * 2, text: `line ${SOURCE_DIFF_LIMITS.maximumGapPageRows * 2 - 1}` })
+ })
+
+ it('falls back when visible controls exceed the source display limit', async () => {
+ const source = `${'\t'.repeat(200_000)}😀`
+
+ await expect(createMarkdownSourceComparison(source, source)).resolves.toEqual({
+ status: 'limited',
+ reason: 'size',
+ })
+ })
+
+ it('retains complete literal lines when only line endings differ', async () => {
+ const beforeSource = 'same\r\nbytes\r\n'
+ const afterSource = 'same\nbytes\n'
+ const model = await createMarkdownSourceComparison(beforeSource, afterSource)
+ expect(model.status).toBe('ready')
+ if (model.status !== 'ready') {
+ return
+ }
+ expect(model.hunks).toEqual([])
+ expect(model.gaps).toHaveLength(1)
+ const rows = materializeSourceDiffGap(beforeSource, afterSource, model.gaps[0]!)
+ expect(rows.map(({ before }: { before?: SourceDiffLine }) => ({ text: before?.text, eol: before?.eol }))).toEqual([
+ { text: 'same', eol: 'crlf' },
+ { text: 'bytes', eol: 'crlf' },
+ ])
+ expect(rows.map(({ after }: { after?: SourceDiffLine }) => ({ text: after?.text, eol: after?.eol }))).toEqual([
+ { text: 'same', eol: 'lf' },
+ { text: 'bytes', eol: 'lf' },
+ ])
+ })
+
+ it('keeps syntax-only and HTML-like changes as literal text', async () => {
+ const model = await createMarkdownSourceComparison('# Heading\n', '# Heading #\n![]()
')
+ expect(model.status).toBe('ready')
+ if (model.status !== 'ready') {
+ return
+ }
+ expect(lines(model.hunks, 'before').map(({ text }) => text)).toContain('')
+ expect(lines(model.hunks, 'after').map(({ text }) => text)).toContain('![]()
')
+ })
+
+ it('reports limits and aborts without losing the caller fallback contract', async () => {
+ await expect(createMarkdownSourceComparison('x'.repeat(SOURCE_DIFF_LIMITS.maximumCharacters + 1), ''))
+ .resolves.toEqual({ status: 'limited', reason: 'size' })
+ const controller = new AbortController()
+ controller.abort()
+ await expect(createMarkdownSourceComparison('before', 'after', controller.signal)).rejects.toMatchObject({ name: 'AbortError' })
+ })
+
+ it('V11 terminates an in-flight worker when the caller aborts', async () => {
+ const terminate = vi.fn()
+ vi.stubGlobal('Worker', class {
+ addEventListener() {}
+ removeEventListener() {}
+ postMessage() {}
+ terminate() { terminate() }
+ })
+ const controller = new AbortController()
+ const comparison = createMarkdownSourceComparison('before', 'after', controller.signal)
+ controller.abort()
+ await expect(comparison).rejects.toMatchObject({ name: 'AbortError' })
+ expect(terminate).toHaveBeenCalledOnce()
+ })
+
+ it('terminates the worker when posting the comparison request throws', async () => {
+ const failure = new Error('post failure')
+ const terminate = vi.fn()
+ vi.stubGlobal('Worker', class {
+ addEventListener() {}
+ removeEventListener() {}
+ postMessage() {
+ throw failure
+ }
+
+ terminate() { terminate() }
+ })
+
+ await expect(createMarkdownSourceComparison('before', 'after')).rejects.toBe(failure)
+ expect(terminate).toHaveBeenCalledOnce()
+ })
+
+ it('rejects message decoding errors once and ignores a late success', async () => {
+ const workers: Array<{ onmessage?: EventListener, onmessageerror?: EventListener }> = []
+ const terminate = vi.fn()
+ vi.stubGlobal('Worker', class {
+ onmessage?: EventListener
+ onmessageerror?: EventListener
+ constructor() {
+ workers.push(this)
+ }
+
+ postMessage() {}
+
+ terminate() { terminate() }
+ })
+ const comparison = createMarkdownSourceComparison('before', 'after')
+
+ expect(workers[0]!.onmessageerror).toBeTypeOf('function')
+ workers[0]!.onmessageerror!(new MessageEvent('messageerror'))
+ workers[0]!.onmessage!(new MessageEvent('message', { data: { status: 'ready', changes: [] } }))
+
+ await expect(comparison).rejects.toThrow('Source comparison worker failed')
+ expect(terminate).toHaveBeenCalledOnce()
+ })
+
+ it('rejects malformed worker responses after cleanup', async () => {
+ const workers: Array<{ onmessage?: EventListener }> = []
+ const terminate = vi.fn()
+ vi.stubGlobal('Worker', class {
+ onmessage?: EventListener
+ constructor() {
+ workers.push(this)
+ }
+
+ postMessage() {}
+
+ terminate() { terminate() }
+ })
+ const comparison = createMarkdownSourceComparison('before', 'after')
+
+ workers[0]!.onmessage!(new MessageEvent('message', { data: null }))
+
+ await expect(comparison).rejects.toThrow('Source comparison worker failed')
+ expect(terminate).toHaveBeenCalledOnce()
+ })
+
+ it('uses the same bounded line protocol for main-thread and worker paths', () => {
+ expect(compareMarkdownSourceLines({ before: 'old\n', after: 'new\n', maximumEditLength: 10, timeoutMilliseconds: 1000 }))
+ .toMatchObject({ status: 'ready' })
+ expect(compareMarkdownSourceLines({ before: 'old\n', after: 'new\n', maximumEditLength: 0, timeoutMilliseconds: 1000 }))
+ .toEqual({ status: 'limited' })
+ })
+})
diff --git a/src/tests/comparison/markdownSourceComparisonWorker.spec.ts b/src/tests/comparison/markdownSourceComparisonWorker.spec.ts
new file mode 100644
index 00000000000..031caf28ae2
--- /dev/null
+++ b/src/tests/comparison/markdownSourceComparisonWorker.spec.ts
@@ -0,0 +1,30 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { SourceComparisonWorkerRequest } from '../../comparison/markdownSourceComparisonProtocol.ts'
+
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+afterEach(() => {
+ vi.resetModules()
+ vi.unstubAllGlobals()
+})
+
+describe('Markdown source comparison worker', () => {
+ it('delegates ready and limited messages to the shared protocol', async () => {
+ let listener: ((event: MessageEvent) => void) | undefined
+ const postMessage = vi.fn()
+ vi.stubGlobal('addEventListener', vi.fn((_type, callback) => {
+ listener = callback
+ }))
+ vi.stubGlobal('postMessage', postMessage)
+ await import('../../comparison/markdownSourceComparison.worker.ts')
+ expect(listener).toBeTypeOf('function')
+ listener?.(new MessageEvent('message', { data: { before: 'old\n', after: 'new\n', maximumEditLength: 10, timeoutMilliseconds: 1000 } }))
+ expect(postMessage).toHaveBeenLastCalledWith(expect.objectContaining({ status: 'ready' }))
+ listener?.(new MessageEvent('message', { data: { before: 'old\n', after: 'new\n', maximumEditLength: 0, timeoutMilliseconds: 1000 } }))
+ expect(postMessage).toHaveBeenLastCalledWith({ status: 'limited' })
+ })
+})
diff --git a/src/tests/comparison/renderedComparisonLimit.spec.ts b/src/tests/comparison/renderedComparisonLimit.spec.ts
new file mode 100644
index 00000000000..276e71aaaed
--- /dev/null
+++ b/src/tests/comparison/renderedComparisonLimit.spec.ts
@@ -0,0 +1,23 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { describe, expect, it } from 'vitest'
+import { exceedsRenderedComparisonLimit, RENDERED_COMPARISON_LIMITS } from '../../comparison/markdownComparison.ts'
+
+describe('rendered comparison preflight', () => {
+ it('accepts each exact geometry ceiling and rejects the first excess', () => {
+ const chars = RENDERED_COMPARISON_LIMITS.maximumCharactersPerSnapshot
+ const lineChars = RENDERED_COMPARISON_LIMITS.maximumCharactersPerLine
+ const line = `${'a'.repeat(lineChars - 1)}\n`
+ const source = (length: number) => line.repeat(Math.floor(length / line.length)) + 'a'.repeat(length % line.length)
+ expect(exceedsRenderedComparisonLimit(source(chars), 'after')).toBe(false)
+ expect(exceedsRenderedComparisonLimit(source(chars + 1), 'after')).toBe(true)
+ expect(exceedsRenderedComparisonLimit('a'.repeat(lineChars), 'after')).toBe(false)
+ expect(exceedsRenderedComparisonLimit('a'.repeat(lineChars + 1), 'after')).toBe(true)
+ const lines = RENDERED_COMPARISON_LIMITS.maximumLinesPerSnapshot
+ expect(exceedsRenderedComparisonLimit('x\n'.repeat(lines - 1), 'after')).toBe(false)
+ expect(exceedsRenderedComparisonLimit('x\r'.repeat(lines), 'after')).toBe(true)
+ })
+})
diff --git a/src/tests/comparison/tableGridComparison.spec.ts b/src/tests/comparison/tableGridComparison.spec.ts
new file mode 100644
index 00000000000..6d14c301559
--- /dev/null
+++ b/src/tests/comparison/tableGridComparison.spec.ts
@@ -0,0 +1,655 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { Schema } from '@tiptap/pm/model'
+import type { ComparisonEdit, ComparisonSide } from '../../comparison/markdownComparisonTypes.ts'
+
+import { Node as ProseMirrorNode } from '@tiptap/pm/model'
+import { describe, expect, it, vi } from 'vitest'
+import {
+ alignComparisonColumns,
+ DEFAULT_COMPARISON_TOKEN_LEDGER,
+} from '../../comparison/comparisonAlignment.ts'
+import { createHierarchicalMarkdownComparisonModel } from '../../comparison/hierarchicalMarkdownComparisonModel.ts'
+import { comparisonTestDocument, createComparisonTestEditor } from './comparisonTestEditor.ts'
+
+function markdownTable(header: readonly string[], rows: readonly (readonly string[])[]) {
+ return [
+ `| ${header.join(' | ')} |`,
+ `|${header.map(() => '---').join('|')}|`,
+ ...rows.map((row) => `| ${row.join(' | ')} |`),
+ ].join('\n')
+}
+
+function compare(before: string, after: string) {
+ return createHierarchicalMarkdownComparisonModel(
+ comparisonTestDocument(before),
+ comparisonTestDocument(after),
+ )
+}
+
+interface TableSpec {
+ header: readonly { text: string, colspan?: number, rowspan?: number }[]
+ rows: readonly (readonly { text: string, colspan?: number, rowspan?: number }[])[]
+}
+
+function tableNode(schema: Schema, spec: TableSpec) {
+ const text = (value: string) => value ? schema.text(value) : undefined
+ const cell = (name: 'tableHeader' | 'tableCell', value: TableSpec['header'][number]) => schema.nodes[name]!.create(
+ { colspan: value.colspan ?? 1, rowspan: value.rowspan ?? 1 },
+ name === 'tableHeader' ? text(value.text) : schema.nodes.paragraph!.create(null, text(value.text)),
+ )
+ const header = schema.nodes.tableHeadRow!.create(null, spec.header.map((value) => cell('tableHeader', value)))
+ const rows = spec.rows.map((row) => schema.nodes.tableRow!.create(null, row.map((value) => cell('tableCell', value))))
+ return schema.nodes.table!.create(null, [header, ...rows])
+}
+
+function tableDocument(schema: Schema, spec: TableSpec) {
+ return schema.nodes.doc!.create(null, tableNode(schema, spec))
+}
+
+function compareTableSpecs(before: TableSpec, after: TableSpec) {
+ const editor = createComparisonTestEditor('placeholder')
+ try {
+ return createHierarchicalMarkdownComparisonModel(
+ tableDocument(editor.schema, before),
+ tableDocument(editor.schema, after),
+ )
+ } finally {
+ editor.destroy()
+ }
+}
+
+function malformedTableDocument(
+ schema: Schema,
+ children: readonly ('caption' | 'header' | 'body' | 'header-with-body-cell' | 'body-with-header-cell')[],
+) {
+ const text = (value: string) => schema.text(value)
+ const headerCell = () => schema.nodes.tableHeader!.create(null, text('header'))
+ const bodyCell = () => schema.nodes.tableCell!.create(null, schema.nodes.paragraph!.create(null, text('body')))
+ const nodes = children.map((kind) => {
+ if (kind === 'caption') {
+ return schema.nodes.tableCaption!.create(null, text('caption'))
+ }
+ if (kind === 'header') {
+ return schema.nodes.tableHeadRow!.create(null, headerCell())
+ }
+ if (kind === 'body') {
+ return schema.nodes.tableRow!.create(null, bodyCell())
+ }
+ if (kind === 'header-with-body-cell') {
+ return schema.nodes.tableHeadRow!.create(null, bodyCell())
+ }
+ return schema.nodes.tableRow!.create(null, headerCell())
+ })
+ return schema.nodes.doc!.create(null, schema.nodes.table!.create(null, nodes))
+}
+
+function expectColumnEdit(
+ edit: ComparisonEdit,
+ operation: 'delete' | 'insert',
+ column: number,
+ rows: number,
+) {
+ const side: ComparisonSide = operation === 'delete' ? 'before' : 'after'
+ expect(edit.kind).toBe('table-column')
+ expect(edit.primary.operation).toBe(operation)
+ expect(edit.descriptors).toHaveLength(rows)
+ expect(edit.descriptors.every((descriptor) => descriptor.operation === operation)).toBe(true)
+ expect(edit.descriptors.map((descriptor) => descriptor.context[side]?.path.at(-1)))
+ .toEqual(Array.from({ length: rows }, () => column))
+ expect(edit.descriptors).toContain(edit.primary)
+}
+
+describe('sparse table comparison', () => {
+ it('AUD-14 does not materialize table profiles before matrix budget admission', () => {
+ const editor = createComparisonTestEditor('placeholder')
+ const columns = 201
+ const before = tableDocument(editor.schema, {
+ header: Array.from({ length: columns }, (_value, index) => ({ text: `before-${index}` })),
+ rows: [],
+ })
+ const after = tableDocument(editor.schema, {
+ header: Array.from({ length: columns }, (_value, index) => ({ text: `after-${index}` })),
+ rows: [],
+ })
+ const textContent = vi.spyOn(ProseMirrorNode.prototype, 'textContent', 'get')
+ try {
+ const model = createHierarchicalMarkdownComparisonModel(before, after)
+
+ expect(model.edits[0]!.primary.coarseReason).toBe('comparison-limit')
+ const tableCellReads = textContent.mock.contexts.filter((node) => (
+ (node as ProseMirrorNode).type.name === 'tableHeader'
+ )).length
+ expect(tableCellReads).toBeLessThanOrEqual(columns * 2 * 5)
+ } finally {
+ textContent.mockRestore()
+ editor.destroy()
+ }
+ })
+
+ it.each([
+ ['first', 0],
+ ['middle', 1],
+ ['last', 2],
+ ] as const)('T01 attributes the %s duplicate-body column deletion', (_name, column) => {
+ const widerHeader = ['A', 'B', 'C']
+ const narrowerHeader = widerHeader.filter((_value, index) => index !== column)
+ const wider = markdownTable(widerHeader, Array.from({ length: 2 }, () => ['x', 'x', 'x']))
+ const narrower = markdownTable(narrowerHeader, Array.from({ length: 2 }, () => ['x', 'x']))
+
+ const deletion = compare(wider, narrower)
+ expect(deletion.edits).toHaveLength(1)
+ expectColumnEdit(deletion.edits[0]!, 'delete', column, 3)
+ })
+
+ it.each([
+ ['first', 0],
+ ['middle', 1],
+ ['last', 2],
+ ] as const)('T02 attributes the %s duplicate-body column insertion', (_name, column) => {
+ const widerHeader = ['A', 'B', 'C']
+ const narrowerHeader = widerHeader.filter((_value, index) => index !== column)
+ const wider = markdownTable(widerHeader, Array.from({ length: 2 }, () => ['x', 'x', 'x']))
+ const narrower = markdownTable(narrowerHeader, Array.from({ length: 2 }, () => ['x', 'x']))
+
+ const insertion = compare(narrower, wider)
+ expect(insertion.edits).toHaveLength(1)
+ expectColumnEdit(insertion.edits[0]!, 'insert', column, 3)
+ })
+
+ it('T03 distinguishes duplicate headers with an exact body row', () => {
+ const model = compare(
+ markdownTable(['X', 'X', 'X'], [['a', 'b', 'c'], ['x', 'x', 'x']]),
+ markdownTable(['X', 'X'], [['a', 'b'], ['x', 'x']]),
+ )
+
+ expect(model.edits).toHaveLength(1)
+ expectColumnEdit(model.edits[0]!, 'delete', 2, 3)
+ })
+
+ it('T04 pairs equal duplicate-vector multiplicity by rank beside a unique deletion', () => {
+ const model = compare(
+ markdownTable(['A', 'X', 'X', 'C'], [['x', 'x', 'x', 'x']]),
+ markdownTable(['A', 'X', 'X'], [['x', 'x', 'x']]),
+ )
+
+ expect(model.edits).toHaveLength(1)
+ expectColumnEdit(model.edits[0]!, 'delete', 3, 2)
+ })
+
+ it('T05 keeps unequal identical-column multiplicity coarse', () => {
+ const model = compare(
+ markdownTable(['X', 'X', 'X'], [['', '', ''], ['x', 'x', 'x']]),
+ markdownTable(['X', 'X'], [['', ''], ['x', 'x']]),
+ )
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({
+ kind: 'content',
+ primary: {
+ operation: 'replace',
+ coarseReason: 'ambiguous-attribution',
+ context: { before: { code: 'table' }, after: { code: 'table' } },
+ },
+ })
+ })
+
+ it('T06 keeps a crossing exact column reorder coarse', () => {
+ const model = compare(
+ markdownTable(['A', 'B', 'C'], [['a', 'b', 'c']]),
+ markdownTable(['C', 'B', 'A'], [['c', 'b', 'a']]),
+ )
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({
+ kind: 'content',
+ primary: {
+ operation: 'replace',
+ coarseReason: 'table-evidence-conflict',
+ context: { before: { code: 'table' }, after: { code: 'table' } },
+ },
+ })
+ })
+
+ it('T07 keeps one edited retained column precise at cell altitude', () => {
+ const model = compare(
+ markdownTable(['A', 'B', 'C'], [['1', '2', '3']]),
+ markdownTable(['A', 'X', 'C'], [['1', 'changed', '3']]),
+ )
+ const descriptors = model.edits.flatMap(({ descriptors }) => descriptors)
+
+ expect(model.edits).toHaveLength(2)
+ expect(model.edits.every(({ kind }) => kind === 'content')).toBe(true)
+ expect(descriptors).toHaveLength(2)
+ expect(descriptors.map(({ context }) => context.before?.path)).toEqual([
+ [0, 0, 1],
+ [0, 1, 1],
+ ])
+ expect(descriptors.map(({ before, after }) => ({ before, after }))).toEqual([
+ { before: { from: 6, to: 7 }, after: { from: 6, to: 7 } },
+ { before: { from: 20, to: 21 }, after: { from: 20, to: 27 } },
+ ])
+ expect(descriptors.every(({ context }) => (
+ context.before?.code === 'table-cell' && context.after?.code === 'table-cell'
+ ))).toBe(true)
+ })
+
+ it('T08 keeps two adjacent edited columns precise when the optimum is unique', () => {
+ const model = compare(
+ markdownTable(['A', 'B old', 'C old', 'D'], [['1', 'before b', 'before c', '4']]),
+ markdownTable(['A', 'B new', 'C new', 'D'], [['1', 'after b', 'after c', '4']]),
+ )
+ const descriptors = model.edits.flatMap(({ descriptors }) => descriptors)
+
+ expect(descriptors).toHaveLength(4)
+ expect(model.edits.every(({ kind }) => kind === 'content')).toBe(true)
+ expect(descriptors.every(({ coarseReason }) => coarseReason === undefined)).toBe(true)
+ expect(descriptors.every(({ context }) => (
+ context.before?.code === 'table-cell' && context.after?.code === 'table-cell'
+ ))).toBe(true)
+ })
+
+ it('groups one column alignment change across its physical cells without duplicating content edits', () => {
+ const model = compare([
+ '# Evidence matrix',
+ '',
+ '| Signal | Evidence | State |',
+ '| :--- | :---: | ---: |',
+ '| API \\| worker | **Draft** [runbook](https://example.org/draft) | 10% |',
+ '| Screenshot |  | Pending |',
+ ].join('\n'), [
+ '# Evidence matrix',
+ '',
+ '| Signal | Evidence | State |',
+ '| ---: | :--- | :---: |',
+ '| API \\| worker | **Approved** [runbook](https://example.org/approved) | 25% |',
+ '| Screenshot |  | Complete |',
+ ].join('\n'))
+ const alignmentEdits = model.edits.filter(({ primary }) => primary.signals.some((signal) => (
+ signal.type === 'attribute' && signal.attribute === 'table-alignment'
+ )))
+ expect(model.edits).toHaveLength(7)
+ expect(alignmentEdits).toHaveLength(3)
+ expect(alignmentEdits.map(({ descriptors }) => descriptors.length)).toEqual([3, 3, 3])
+ expect(alignmentEdits.every(({ descriptors }) => descriptors.every(({ signals }) => signals.some((signal) => (
+ signal.type === 'attribute' && signal.attribute === 'table-alignment'
+ ))))).toBe(true)
+ })
+
+ it('T09 combines an edited retained column with one adjacent column deletion', () => {
+ const model = compare(
+ markdownTable(['A', 'B old', 'C'], [['1', 'before', '3']]),
+ markdownTable(['A', 'B new'], [['1', 'after']]),
+ )
+ const columnEdits = model.edits.filter(({ kind }) => kind === 'table-column')
+ const cellEdits = model.edits.filter(({ kind }) => kind === 'content')
+
+ expect(columnEdits).toHaveLength(1)
+ expectColumnEdit(columnEdits[0]!, 'delete', 2, 2)
+ expect(cellEdits).toHaveLength(2)
+ expect(cellEdits.flatMap(({ descriptors }) => descriptors).every(({ context }) => (
+ context.before?.code === 'table-cell' && context.after?.code === 'table-cell'
+ ))).toBe(true)
+ })
+
+ it('T10 keeps a row insertion at row altitude beside a column deletion', () => {
+ const model = compare(
+ markdownTable(['A', 'B', 'C'], [['one', 'x', 'x'], ['two', 'x', 'x']]),
+ markdownTable(['A', 'B'], [['one', 'x'], ['inserted row', 'unique'], ['two', 'x']]),
+ )
+ const columnEdits = model.edits.filter(({ kind }) => kind === 'table-column')
+ const rowInsertions = model.edits.filter(({ primary }) => (
+ primary.operation === 'insert' && primary.context.after?.code === 'table-row'
+ ))
+
+ expect(columnEdits).toHaveLength(1)
+ expectColumnEdit(columnEdits[0]!, 'delete', 2, 3)
+ expect(rowInsertions).toHaveLength(1)
+ })
+
+ it('T10 keeps a row deletion at row altitude beside a column insertion', () => {
+ const model = compare(
+ markdownTable(['A', 'B'], [['one', 'x'], ['deleted row', 'unique'], ['two', 'x']]),
+ markdownTable(['A', 'B', 'C'], [['one', 'x', 'x'], ['two', 'x', 'x']]),
+ )
+ const columnEdits = model.edits.filter(({ kind }) => kind === 'table-column')
+ const rowDeletions = model.edits.filter(({ primary }) => (
+ primary.operation === 'delete' && primary.context.before?.code === 'table-row'
+ ))
+
+ expect(columnEdits).toHaveLength(1)
+ expectColumnEdit(columnEdits[0]!, 'insert', 2, 3)
+ expect(rowDeletions).toHaveLength(1)
+ })
+
+ it('T11 keeps a ragged typo precise at physical-cell altitude', () => {
+ const model = compare(
+ markdownTable(['A', 'B', 'C'], [['one', 'before']]),
+ markdownTable(['A', 'B', 'C'], [['one', 'after']]),
+ )
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({
+ kind: 'content',
+ primary: {
+ operation: 'replace',
+ context: { before: { code: 'table-cell' }, after: { code: 'table-cell' } },
+ },
+ })
+ })
+
+ it.each([
+ ['fills', 'insert', ['one'], ['one', 'two']],
+ ['removes', 'delete', ['one', 'two'], ['one']],
+ ] as const)('T12 %s a ragged absent-present slot as one local cell change', (_name, operation, beforeRow, afterRow) => {
+ const model = compare(
+ markdownTable(['A', 'B'], [beforeRow]),
+ markdownTable(['A', 'B'], [afterRow]),
+ )
+ const side: ComparisonSide = operation === 'delete' ? 'before' : 'after'
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({ kind: 'content', primary: { operation } })
+ expect(model.edits[0]!.primary.context[side]?.code).toBe('table-cell')
+ })
+
+ it('T13 groups only present physical cells from a deleted ragged column', () => {
+ const wider = markdownTable(['A', 'B', 'C'], [
+ ['x', 'x'],
+ ['x', 'x', 'distinct C'],
+ ])
+ const narrower = markdownTable(['A', 'B'], [
+ ['x', 'x'],
+ ['x', 'x'],
+ ])
+ const model = compare(wider, narrower)
+
+ expect(model.edits).toHaveLength(1)
+ expectColumnEdit(model.edits[0]!, 'delete', 2, 2)
+ })
+
+ it.each(['deletion', 'insertion'] as const)('T14 fails a ragged middle identity conflict transactionally on %s', (direction) => {
+ const wider = markdownTable(['A', 'B', 'C'], [
+ ['x', 'x', 'x'],
+ ['x', 'x'],
+ ])
+ const narrower = markdownTable(['A', 'C'], [
+ ['x', 'x'],
+ ['x'],
+ ])
+ const model = direction === 'deletion'
+ ? compare(wider, narrower)
+ : compare(narrower, wider)
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({
+ kind: 'content',
+ primary: {
+ operation: 'replace',
+ coarseReason: 'table-evidence-conflict',
+ context: { before: { code: 'table' }, after: { code: 'table' } },
+ },
+ })
+ expect(model.edits[0]!.descriptors).toHaveLength(1)
+ })
+
+ it.each(['deletion', 'insertion'] as const)('AUD-01 fails closed when a ragged width change creates cross-row exact identity on %s', (direction) => {
+ for (const width of [2, 3, 4]) {
+ const wider = markdownTable(
+ Array.from({ length: width + 1 }, () => 'N'),
+ [
+ Array.from({ length: width }, () => 'x'),
+ Array.from({ length: width + 1 }, () => 'x'),
+ ],
+ )
+ const narrower = markdownTable(
+ Array.from({ length: width }, () => 'N'),
+ [
+ Array.from({ length: width - 1 }, () => 'x'),
+ Array.from({ length: width }, () => 'x'),
+ ],
+ )
+ const model = direction === 'deletion'
+ ? compare(wider, narrower)
+ : compare(narrower, wider)
+ const rowOperations = model.edits.filter(({ primary }) => (
+ primary.context.before?.code === 'table-row' || primary.context.after?.code === 'table-row'
+ ))
+
+ expect(rowOperations).toHaveLength(0)
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({
+ kind: 'content',
+ primary: {
+ operation: 'replace',
+ coarseReason: 'table-evidence-conflict',
+ context: { before: { code: 'table' }, after: { code: 'table' } },
+ },
+ })
+ expect(model.edits[0]!.descriptors).toHaveLength(1)
+ }
+ })
+
+ it.each(['deletion', 'insertion'] as const)('AUD-01 reconciles the complete row basis when row count and width change on %s', (direction) => {
+ const wider = markdownTable(['N', 'N', 'N'], [
+ ['x', 'x'],
+ ['x', 'x', 'x'],
+ ])
+ const narrower = markdownTable(['N', 'N'], [
+ ['inserted', 'unique'],
+ ['x'],
+ ['x', 'x'],
+ ])
+ const model = direction === 'deletion'
+ ? compare(wider, narrower)
+ : compare(narrower, wider)
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({
+ kind: 'content',
+ primary: {
+ operation: 'replace',
+ coarseReason: 'table-evidence-conflict',
+ context: { before: { code: 'table' }, after: { code: 'table' } },
+ },
+ })
+ expect(model.edits[0]!.descriptors).toHaveLength(1)
+ })
+
+ it.each(['deletion', 'insertion'] as const)('AUD-01 keeps a genuine ragged row replacement beside a column %s', (direction) => {
+ const wider = markdownTable(['A', 'B', 'C'], [
+ ['retained', 'x'],
+ ['deleted', 'y', 'z'],
+ ])
+ const narrower = markdownTable(['A', 'B'], [
+ ['inserted', 'q'],
+ ['retained', 'x'],
+ ])
+ const model = direction === 'deletion'
+ ? compare(wider, narrower)
+ : compare(narrower, wider)
+ const columnEdits = model.edits.filter(({ kind }) => kind === 'table-column')
+ const rowOperations = model.edits.filter(({ primary }) => (
+ primary.context.before?.code === 'table-row' || primary.context.after?.code === 'table-row'
+ ))
+
+ expect(columnEdits).toHaveLength(1)
+ expectColumnEdit(columnEdits[0]!, direction === 'deletion' ? 'delete' : 'insert', 2, 1)
+ expect(rowOperations.map(({ primary }) => primary.operation).toSorted()).toEqual(['delete', 'insert'])
+ expect(model.edits.every(({ primary }) => primary.coarseReason === undefined)).toBe(true)
+ })
+
+ it.each([
+ ['deletes', 'delete', 3, 2],
+ ['inserts', 'insert', 3, 4],
+ ] as const)('T15 %s the outer repeated row after retaining the first exact copies', (_name, operation, beforeCount, afterCount) => {
+ const rows = (count: number) => Array.from({ length: count }, () => ['Same', 'x'])
+ const model = compare(
+ markdownTable(['H1', 'H2'], rows(beforeCount)),
+ markdownTable(['H1', 'H2'], rows(afterCount)),
+ )
+ const side: ComparisonSide = operation === 'delete' ? 'before' : 'after'
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({ kind: 'content', primary: { operation } })
+ expect(model.edits[0]!.primary.context[side]?.code).toBe('table-row')
+ expect(model.edits[0]!.primary.context[side]?.path.at(-1)).toBe(operation === 'delete' ? 3 : 4)
+ })
+
+ it.each([
+ ['span', { header: [{ text: 'changed', colspan: 2 }], rows: [] }],
+ ['row span', { header: [{ text: 'changed', rowspan: 2 }], rows: [[{ text: 'body' }]] }],
+ ['malformed empty row', { header: [{ text: 'changed' }], rows: [[]] }],
+ ['more than 512 rows', {
+ header: [{ text: 'changed' }],
+ rows: Array.from({ length: 512 }, (_value, index) => [{ text: `row ${index}` }]),
+ }],
+ ['more than 10000 physical cells', {
+ header: Array.from({ length: 100 }, (_value, index) => ({ text: index === 0 ? 'changed' : `head ${index}` })),
+ rows: Array.from({ length: 100 }, (_value, row) => (
+ Array.from({ length: 100 }, (_cell, column) => ({ text: `cell ${row}:${column}` }))
+ )),
+ }],
+ ] as const)('T16 emits one unsupported-table edit for %s geometry', (_name, invalid) => {
+ const valid = { header: [{ text: 'valid' }], rows: [] }
+ const model = compareTableSpecs(valid, invalid)
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({
+ kind: 'content',
+ primary: {
+ operation: 'replace',
+ coarseReason: 'unsupported-table',
+ context: { before: { code: 'table' }, after: { code: 'table' } },
+ },
+ })
+ expect(model.edits[0]!.descriptors).toHaveLength(1)
+ })
+
+ it.each([
+ ['a missing header', ['body']],
+ ['duplicate headers', ['header', 'header']],
+ ['a header after a body row', ['body', 'header']],
+ ['a misplaced caption', ['header', 'caption']],
+ ['duplicate captions', ['caption', 'caption', 'header']],
+ ['a body cell in the header', ['header-with-body-cell']],
+ ['a header cell in a body row', ['header', 'body-with-header-cell']],
+ ] as const)('T16 rejects %s transactionally', (_name, children) => {
+ const editor = createComparisonTestEditor('placeholder')
+ try {
+ const valid = tableDocument(editor.schema, { header: [{ text: 'valid' }], rows: [] })
+ const invalid = malformedTableDocument(editor.schema, children)
+ const model = createHierarchicalMarkdownComparisonModel(valid, invalid)
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({
+ kind: 'content',
+ primary: {
+ operation: 'replace',
+ coarseReason: 'unsupported-table',
+ context: { before: { code: 'table' }, after: { code: 'table' } },
+ },
+ })
+ expect(model.edits[0]!.descriptors).toHaveLength(1)
+ } finally {
+ editor.destroy()
+ }
+ })
+
+ it('T17 rejects a 10001-column table before attempting column alignment', () => {
+ const valid = { header: [{ text: 'valid' }], rows: [] }
+ const hugeWidth = {
+ header: Array.from({ length: 10_001 }, (_value, index) => ({ text: `column ${index}` })),
+ rows: [],
+ }
+ const model = compareTableSpecs(valid, hugeWidth)
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]!.primary.coarseReason).toBe('unsupported-table')
+ expect(model.edits[0]!.descriptors).toHaveLength(1)
+ })
+
+ it('F09 retains solved table work without partial edits when a later exact-evidence veto coarsens the table', () => {
+ const editor = createComparisonTestEditor('placeholder')
+ try {
+ const columnCount = 100
+ const bodyTextLength = Math.floor(DEFAULT_COMPARISON_TOKEN_LEDGER / (4 * columnCount ** 2)) - 6
+ const body = (suffix: string) => Array.from({ length: columnCount }, (_value, index) => ({
+ text: `${String.fromCodePoint(0x100 + index).repeat(bodyTextLength - 1)}${suffix}`,
+ }))
+ const beforeHeader = Array.from({ length: columnCount }, (_value, index) => ({ text: index === 0 ? 'q' : 'a' }))
+ const afterHeader = Array.from({ length: columnCount }, (_value, index) => ({ text: index === columnCount - 1 ? 'q' : 'b' }))
+ const headerRowProfileLength = 2 * columnCount
+ const bodyRowProfileLength = (bodyTextLength + 2) * columnCount
+ const rowCharge = 2 * (3 * headerRowProfileLength + bodyRowProfileLength)
+ const columnProfileLength = bodyTextLength + 6
+ const columnCharge = 2 * columnCount ** 2 * columnProfileLength
+ const remainingTokens = DEFAULT_COMPARISON_TOKEN_LEDGER - rowCharge - columnCharge
+ const laterProfileLength = Math.floor(remainingTokens / (2 * columnCount ** 2)) + 1
+ const laterTextLength = laterProfileLength - 3
+ const repeatedHeaders = (character: string) => Array.from(
+ { length: columnCount },
+ () => ({ text: character.repeat(laterTextLength) }),
+ )
+ const anchor = editor.schema.nodes.paragraph!.create(null, editor.schema.text('exact veto boundary anchor'))
+ const before = editor.schema.nodes.doc!.create(null, [
+ tableNode(editor.schema, { header: beforeHeader, rows: [body('x')] }),
+ anchor,
+ tableNode(editor.schema, { header: repeatedHeaders('c'), rows: [] }),
+ ])
+ const after = editor.schema.nodes.doc!.create(null, [
+ tableNode(editor.schema, { header: afterHeader, rows: [body('y')] }),
+ anchor,
+ tableNode(editor.schema, { header: repeatedHeaders('d'), rows: [] }),
+ ])
+ const model = createHierarchicalMarkdownComparisonModel(before, after)
+
+ expect(2 * columnCount ** 2 * laterProfileLength).toBeGreaterThan(remainingTokens)
+ expect(2 * columnCount ** 2 * laterProfileLength).toBeLessThan(DEFAULT_COMPARISON_TOKEN_LEDGER)
+ expect(model.edits.map(({ primary }) => primary.coarseReason)).toEqual([
+ 'table-evidence-conflict',
+ 'comparison-limit',
+ ])
+ expect(model.edits.every(({ descriptors }) => descriptors.length === 1)).toBe(true)
+ } finally {
+ editor.destroy()
+ }
+ })
+
+ it('T18 shares table token work across consecutive column plans', () => {
+ interface Column {
+ key: string
+ profile: readonly string[]
+ }
+ const before: Column[] = [
+ { key: 'before-a', profile: ['a', 'same-a'] },
+ { key: 'before-b', profile: ['b', 'same-b'] },
+ ]
+ const after: Column[] = [
+ { key: 'after-a', profile: ['a', 'same-a'] },
+ { key: 'after-b', profile: ['b', 'same-b'] },
+ ]
+ const work = { remainingCells: 8, remainingTokenComparisons: 20 }
+ const options = {
+ work,
+ fingerprint: ({ key }: Column) => key,
+ profile: ({ profile }: Column) => profile,
+ compatible: () => true,
+ }
+
+ const first = alignComparisonColumns(before, after, options)
+ expect(first.every((region) => !('coarseReason' in region && region.coarseReason === 'comparison-limit'))).toBe(true)
+ expect(work).toEqual({ remainingCells: 4, remainingTokenComparisons: 4 })
+
+ const second = alignComparisonColumns(before, after, options)
+ expect(second).toEqual([{
+ before: { from: 0, to: 2 },
+ after: { from: 0, to: 2 },
+ coarseReason: 'comparison-limit',
+ }])
+ expect(work).toEqual({ remainingCells: 4, remainingTokenComparisons: 4 })
+ })
+})
diff --git a/src/tests/markdown.spec.js b/src/tests/markdown.spec.js
index 2f5bb9e5011..f67768a5c50 100644
--- a/src/tests/markdown.spec.js
+++ b/src/tests/markdown.spec.js
@@ -175,6 +175,7 @@ describe('Markdown though editor', () => {
test('details', ({ markdownThroughEditor }) => {
expect(markdownThroughEditor('\n**summary**
\n* list\n\n\n')).toBe('\n**summary**
\n* list\n\n\n')
+ expect(markdownThroughEditor('\nsummary
\ncontent\n\n\n')).toBe('\nsummary
\ncontent\n\n\n')
})
test('nested details', ({ markdownThroughEditor }) => {
diff --git a/src/tests/markdownit/details.spec.js b/src/tests/markdownit/details.spec.js
index dd077287e52..86f1c636f08 100644
--- a/src/tests/markdownit/details.spec.js
+++ b/src/tests/markdownit/details.spec.js
@@ -11,6 +11,10 @@ describe('Details extension', () => {
const rendered = markdownit.render('\nsummary
\ncontent\n')
expect(stripIndent(rendered)).toBe('summary
content
')
})
+ it('renders the native open state', () => {
+ const rendered = markdownit.render('\nsummary
\ncontent\n')
+ expect(stripIndent(rendered)).toBe('summary
content
')
+ })
it('renders with empty summary', () => {
const rendered = markdownit.render('\n
\ncontent\n')
expect(stripIndent(rendered)).toBe('
content
')
diff --git a/src/tests/nodes/DetailsViewAccessibility.spec.ts b/src/tests/nodes/DetailsViewAccessibility.spec.ts
new file mode 100644
index 00000000000..b1c9d51ab94
--- /dev/null
+++ b/src/tests/nodes/DetailsViewAccessibility.spec.ts
@@ -0,0 +1,49 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { mount } from '@vue/test-utils'
+import { describe, expect, it, vi } from 'vitest'
+import DetailsView from '../../nodes/DetailsView.vue'
+
+function mountDetails(attrs: { open: boolean, openDetails: boolean }, updateAttributes = vi.fn()) {
+ return mount(DetailsView, {
+ props: { node: { attrs }, updateAttributes },
+ global: {
+ stubs: {
+ NodeViewWrapper: { template: '['$props']
+
+const attachment = {
+ alt: 'Diagram',
+ davPath: '/diagram.png',
+ fullUrl: '/diagram.png',
+ isImage: true,
+ metadata: null,
+ mimetype: 'image/png',
+ name: 'diagram.png',
+ previewUrl: '/preview.png',
+ size: 100,
+}
+
+beforeEach(() => {
+ vi.stubGlobal('ResizeObserver', class {
+ observe() {}
+ disconnect() {}
+ })
+ vi.stubGlobal('IntersectionObserver', class {
+ observe() {}
+ disconnect() {}
+ })
+})
+
+afterEach(() => vi.unstubAllGlobals())
+
+async function mountImage(isImage: boolean) {
+ const editor = { isEditable: false, off: vi.fn(), on: vi.fn() }
+ const wrapper = mount(ImageView, {
+ props: {
+ editor,
+ node: { attrs: { alt: 'Diagram', src: 'diagram.png' } },
+ decorations: [],
+ selected: false,
+ extension: { options: { noLazyImages: false } },
+ getPos: () => 0,
+ updateAttributes: vi.fn(),
+ deleteNode: vi.fn(),
+ view: {},
+ innerDecorations: {},
+ HTMLAttributes: {},
+ } as unknown as ImageViewProps,
+ global: {
+ provide: {
+ [ATTACHMENT_RESOLVER as symbol]: shallowRef({ resolve: vi.fn().mockResolvedValue({ ...attachment, isImage }) }),
+ },
+ stubs: {
+ NodeViewWrapper: { template: '('.media-wrapper')
+
+ expect(action.element.tagName).toBe('BUTTON')
+ expect(action.attributes('type')).toBe('button')
+ expect(action.attributes('aria-label')).toBe(label)
+ expect(action.element.tabIndex).toBe(0)
+ })
+
+ it('AUD-18 routes image button activation through the real modal handler', async () => {
+ const wrapper = await mountImage(true)
+ const view = wrapper.vm as unknown as { embeddedImageList: Array }
+ vi.spyOn(wrapper.vm, 'updateEmbeddedImageList').mockImplementation(async () => {
+ view.embeddedImageList = [{ ...attachment, src: 'diagram.png' }]
+ })
+
+ await wrapper.find('.media-wrapper').trigger('click')
+
+ expect(wrapper.vm.imageIndex).toBe(0)
+ expect(wrapper.vm.showImageModal).toBe(true)
+ })
+
+ it('AUD-18 routes attachment button activation through the real Viewer action', async () => {
+ const open = vi.fn()
+ vi.stubGlobal('OCA', { Viewer: { file: null, mimetypes: ['image/png'], open } })
+ const wrapper = await mountImage(false)
+
+ await wrapper.find('.media-wrapper').trigger('click')
+
+ expect(open).toHaveBeenCalledOnce()
+ expect(open).toHaveBeenCalledWith({ path: attachment.davPath })
+ })
+})
diff --git a/src/tests/playwrightConfig.spec.ts b/src/tests/playwrightConfig.spec.ts
new file mode 100644
index 00000000000..3811aa2248e
--- /dev/null
+++ b/src/tests/playwrightConfig.spec.ts
@@ -0,0 +1,76 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+const originalComparisonBaseURL = process.env.TEXT_COMPARISON_BASE_URL
+const originalComparisonE2E = process.env.TEXT_COMPARISON_E2E
+const originalBaseURL = process.env.baseURL
+
+afterEach(() => {
+ setEnvironment('TEXT_COMPARISON_BASE_URL', originalComparisonBaseURL)
+ setEnvironment('TEXT_COMPARISON_E2E', originalComparisonE2E)
+ setEnvironment('baseURL', originalBaseURL)
+})
+
+function setEnvironment(name: string, value: string | undefined) {
+ if (value === undefined) {
+ delete process.env[name]
+ } else {
+ process.env[name] = value
+ }
+}
+
+async function loadConfig(comparisonBaseURL: string | undefined, baseURL: string | undefined, comparisonE2E?: string) {
+ setEnvironment('TEXT_COMPARISON_BASE_URL', comparisonBaseURL)
+ setEnvironment('TEXT_COMPARISON_E2E', comparisonE2E)
+ setEnvironment('baseURL', baseURL)
+ vi.resetModules()
+ return (await import('../../playwright.config.ts')).default
+}
+
+describe('Playwright comparison server selection', () => {
+ it.each([
+ { name: 'unset values', comparisonBaseURL: undefined, baseURL: undefined, expected: 'http://localhost:8089/index.php/', managed: true },
+ { name: 'empty values', comparisonBaseURL: '', baseURL: '', expected: 'http://localhost:8089/index.php/', managed: true },
+ { name: 'generic external URL', comparisonBaseURL: '', baseURL: 'https://generic.example/index.php/', expected: 'https://generic.example/index.php/', managed: false },
+ { name: 'dedicated external URL', comparisonBaseURL: 'https://text.example/index.php/', baseURL: '', expected: 'https://text.example/index.php/', managed: false },
+ { name: 'dedicated precedence', comparisonBaseURL: 'https://text.example/index.php/', baseURL: 'https://generic.example/index.php/', expected: 'https://text.example/index.php/', managed: false },
+ ])('uses the selected URL for $name', async ({ comparisonBaseURL, baseURL, expected, managed }) => {
+ const config = await loadConfig(comparisonBaseURL, baseURL)
+
+ expect(config.use?.baseURL).toBe(expected)
+ expect(config.webServer === undefined).toBe(!managed)
+ })
+
+ it('routes comparison and memory tests to their dedicated projects', async () => {
+ const config = await loadConfig(undefined, undefined, '1')
+ const projects = config.projects ?? []
+ const byName = new Map(projects.map((project) => [project.name, project]))
+ const comparisonNames = [
+ 'comparison-chromium',
+ 'comparison-webkit',
+ 'comparison-chromium-memory',
+ ]
+
+ expect(projects.map(({ name }) => name)).toEqual(['chromium', ...comparisonNames])
+ for (const name of comparisonNames) {
+ const match = byName.get(name)?.testMatch
+ expect(match).toBeInstanceOf(RegExp)
+ expect((match as RegExp).test('playwright/comparison/comparison.spec.ts')).toBe(true)
+ expect((match as RegExp).test('playwright/example.spec.ts')).toBe(false)
+ }
+ for (const name of comparisonNames.slice(0, 2)) {
+ expect(byName.get(name)?.grepInvert).toEqual(/@memory/)
+ expect(byName.get(name)?.grep).toBeUndefined()
+ }
+ expect(byName.get('comparison-chromium-memory')?.grep).toEqual(/@memory/)
+ expect(byName.get('comparison-chromium-memory')?.grepInvert).toBeUndefined()
+ const ordinaryIgnore = byName.get('chromium')?.testIgnore
+ expect(ordinaryIgnore).toBeInstanceOf(RegExp)
+ expect((ordinaryIgnore as RegExp).test('playwright/comparison/comparison.spec.ts')).toBe(true)
+ expect((ordinaryIgnore as RegExp).test('playwright/example.spec.ts')).toBe(false)
+ })
+})
diff --git a/src/tests/services/AttachmentResolver.spec.js b/src/tests/services/AttachmentResolver.spec.js
index 507be93df32..5280056917c 100644
--- a/src/tests/services/AttachmentResolver.spec.js
+++ b/src/tests/services/AttachmentResolver.spec.js
@@ -36,11 +36,9 @@ function initAttachmentResolver(args) {
previewUrl: `http://nextcloud.local/apps/text/mediaPreview?documentId=${fileId}&sessionId=${sessionId}&sessionToken=${sessionToken}&mediaFileName=${a2name}"`,
},
]
- const axiosSpy = vi
- .spyOn(axios, 'post')
+ vi.spyOn(axios, 'post')
.mockReturnValue({ data: attachmentList })
const resolver = new AttachmentResolver(args)
- expect(axiosSpy).toHaveBeenCalled()
return resolver
}
@@ -55,6 +53,15 @@ describe('Image resolver', () => {
}
const currentDirectory = '/parentDir'
+ it('does not request attachment metadata for a direct URL', async () => {
+ const axiosSpy = vi.spyOn(axios, 'post').mockResolvedValue({ data: [] })
+ const resolver = new AttachmentResolver({ fileId })
+
+ await resolver.resolve('https://example.org/pic.jpg')
+
+ expect(axiosSpy).not.toHaveBeenCalled()
+ })
+
it('is a class with one constructor argument', () => {
const resolver = initAttachmentResolver({ fileId })
expect(resolver).toBeInstanceOf(AttachmentResolver)
diff --git a/vite.config.ts b/vite.config.ts
index 1830d335ca4..5d930dd6f08 100644
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -50,6 +50,15 @@ const config = createAppConfig(
},
config: {
base: process.env.BASE,
+ worker: {
+ rollupOptions: {
+ output: {
+ assetFileNames: 'js/[name]-[hash][extname]',
+ chunkFileNames: 'js/[name]-[hash].worker.chunk.mjs',
+ entryFileNames: 'js/[name]-[hash].worker.mjs',
+ },
+ },
+ },
resolve: {
dedupe: ['vue'],
},
(?.*)<\/summary>\s*$/
const DETAILS_END_REGEX = /^<\/details>\s*$/
const SUMMARY_REGEX = /(?<=^).*(?=<\/summary>\s*$)/
@@ -32,16 +31,22 @@ function parseDetails(
let detailsFound = false
let detailsSummary = null
+ let openDetails: boolean
let startLineCount = 2
- const m = state.src.slice(start, max).match(DETAILS_AND_SUMMARY_START_REGEX)
- if (m) {
+ const openingLine = state.src.slice(start, max)
+ const combined = openingLine.match(DETAILS_AND_SUMMARY_START_REGEX)
+ if (combined) {
// Details block start and summary in same line
- detailsSummary = m[0].trim()
+ detailsSummary = combined.groups!.summary!.trim()
+ openDetails = Boolean(combined.groups!.open)
startLineCount = 1
- } else if (!state.src.slice(start, max).match(DETAILS_START_REGEX)) {
- // Details block start in separate line
- return false
+ } else {
+ const opening = openingLine.match(DETAILS_START_REGEX)
+ if (!opening) {
+ return false
+ }
+ openDetails = Boolean(opening.groups!.open)
}
// Since start is found, we can report success here in validation mode
@@ -105,6 +110,9 @@ function parseDetails(
token.block = true
token.info = detailsSummary
token.map = [startLine, nextLine]
+ if (openDetails) {
+ token.attrSet('open', '')
+ }
token = state.push('details_summary', 'summary', 1)
token.block = false
diff --git a/src/nodes/Details.js b/src/nodes/Details.js
index 7b5f9073f8a..01b814f245c 100644
--- a/src/nodes/Details.js
+++ b/src/nodes/Details.js
@@ -67,6 +67,11 @@ const Details = Node.create({
openDetails: {
default: false,
},
+ open: {
+ default: false,
+ parseHTML: (element) => element.hasAttribute('open'),
+ renderHTML: ({ open }) => open ? { open: '' } : {},
+ },
}
},
@@ -91,7 +96,7 @@ const Details = Node.create({
},
toMarkdown: (state, node) => {
- state.write('\n')
+ state.write(node.attrs.open ? '\n' : '\n')
state.renderContent(node)
state.closeBlock(node)
state.ensureNewLine()
diff --git a/src/nodes/DetailsView.vue b/src/nodes/DetailsView.vue
index 65677b0db96..2ec5c094d4e 100644
--- a/src/nodes/DetailsView.vue
+++ b/src/nodes/DetailsView.vue
@@ -5,13 +5,17 @@
-
+
diff --git a/src/nodes/Image.ts b/src/nodes/Image.ts
index 405dc92a694..389be2d9947 100644
--- a/src/nodes/Image.ts
+++ b/src/nodes/Image.ts
@@ -17,6 +17,7 @@ const imageFileDropPluginKey = new PluginKey('imageFileDrop')
const imageExtractAttachmentsKey = new PluginKey('imageExtractAttachments')
interface ImageOptions extends TiptapImageOptions {
+ emitAttachmentEvents: boolean
noLazyImages: boolean
}
@@ -53,6 +54,7 @@ const Image = TiptapImage.extend({
addOptions() {
return {
...this.parent?.() as ImageOptions,
+ emitAttachmentEvents: true,
noLazyImages: false,
}
},
@@ -120,31 +122,33 @@ const Image = TiptapImage.extend({
},
},
}),
- new Plugin({
- key: imageExtractAttachmentsKey,
- state: {
- init(_, { doc }) {
- const attachmentSrcs = extractAttachmentSrcs(doc)
- emit('text:editor:attachments:updated', { attachmentSrcs })
- return { attachmentSrcs }
- },
- apply(tr, value, _oldState, newState) {
- if (!tr.docChanged) {
- return value
- }
- const attachmentSrcs = extractAttachmentSrcs(newState.doc)
- if (
- JSON.stringify(attachmentSrcs)
- === JSON.stringify(value?.attachmentSrcs)
- ) {
- return value
- }
-
- emit('text:editor:attachments:updated', { attachmentSrcs })
- return { attachmentSrcs }
- },
- },
- }),
+ ...(this.options.emitAttachmentEvents
+ ? [new Plugin({
+ key: imageExtractAttachmentsKey,
+ state: {
+ init(_, { doc }) {
+ const attachmentSrcs = extractAttachmentSrcs(doc)
+ emit('text:editor:attachments:updated', { attachmentSrcs })
+ return { attachmentSrcs }
+ },
+ apply(tr, value, _oldState, newState) {
+ if (!tr.docChanged) {
+ return value
+ }
+ const attachmentSrcs = extractAttachmentSrcs(newState.doc)
+ if (
+ JSON.stringify(attachmentSrcs)
+ === JSON.stringify(value?.attachmentSrcs)
+ ) {
+ return value
+ }
+
+ emit('text:editor:attachments:updated', { attachmentSrcs })
+ return { attachmentSrcs }
+ },
+ },
+ })]
+ : []),
]
},
diff --git a/src/nodes/ImageView.vue b/src/nodes/ImageView.vue
index eb2c7576c4d..cec809cbc51 100644
--- a/src/nodes/ImageView.vue
+++ b/src/nodes/ImageView.vue
@@ -24,8 +24,10 @@
v-if="isMediaAttachment"
contenteditable="false"
class="media">
-
![]()
{{ alt }}
{{ attachmentSize }}
-
+
-
+
+
@@ -593,7 +599,11 @@ export default {
.media-wrapper {
display: flex;
- // Overwrite some global rules for a elments
+ padding: 0;
+ border: 0;
+ background: transparent;
+ font: inherit;
+ cursor: pointer;
text-decoration: none;
color: var(--color-main-text);
diff --git a/src/services/AttachmentResolver.js b/src/services/AttachmentResolver.js
index 6d1f2fa0a98..bc915c98156 100644
--- a/src/services/AttachmentResolver.js
+++ b/src/services/AttachmentResolver.js
@@ -22,7 +22,6 @@ export default class AttachmentResolver {
this.#shareToken = shareToken
this.#currentDirectory = currentDirectory
this.#documentId = fileId ?? session.documentId
- this.#initAttachmentListPromise = this.#updateAttachmentList()
}
async #updateAttachmentList() {
@@ -52,7 +51,7 @@ export default class AttachmentResolver {
if (src.match(directoryRegexp)) {
const imageFileName = decodeURIComponent(src.replace(directoryRegexp, '').split('?')[0])
- // Wait until attachment list got fetched (initialized by constructor)
+ this.#initAttachmentListPromise ??= this.#updateAttachmentList()
await this.#initAttachmentListPromise
attachment = this.#findAttachment(imageFileName)
diff --git a/src/tests/comparison/ComparisonChangeList.spec.ts b/src/tests/comparison/ComparisonChangeList.spec.ts
new file mode 100644
index 00000000000..246e4914c97
--- /dev/null
+++ b/src/tests/comparison/ComparisonChangeList.spec.ts
@@ -0,0 +1,173 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { ComparisonDescriptor, ComparisonEdit } from '../../comparison/markdownComparisonTypes.ts'
+
+import * as l10n from '@nextcloud/l10n'
+import { mount } from '@vue/test-utils'
+import { schema } from 'prosemirror-schema-basic'
+import { describe, expect, it, vi } from 'vitest'
+import ComparisonChangeList from '../../components/ComparisonChangeList.vue'
+
+function descriptor(id: string, text: string, facets: ComparisonDescriptor['facets'] = ['text']): ComparisonDescriptor {
+ return {
+ id,
+ operation: 'replace',
+ detail: 'inline',
+ facets,
+ before: { from: 0, to: 1 },
+ after: { from: 0, to: 1 },
+ context: { before: null, after: null },
+ preview: { before: { kind: 'text', text }, after: { kind: 'text', text } },
+ signals: [],
+ }
+}
+
+const document = schema.node('doc', null, [schema.node('paragraph', null, schema.text('Body'))])
+
+describe('ComparisonChangeList', () => {
+ it('AUD-14 renders only the bounded page containing a high-cardinality current edit', () => {
+ const edits = Array.from({ length: 10_000 }, (_value, index): ComparisonEdit => {
+ const primary = descriptor(`member-${index}`, `preview-${index}`)
+ return { id: `edit-${index}`, kind: 'content', primary, descriptors: [primary] }
+ })
+ const wrapper = mount(ComparisonChangeList, {
+ props: { edits, currentId: 'edit-9999', beforeDocument: document, afterDocument: document },
+ })
+ const rows = wrapper.findAll('[data-comparison-select]')
+
+ expect(rows).toHaveLength(80)
+ expect(rows[0]!.attributes('data-comparison-select')).toBe('edit-9920')
+ expect(rows.at(-1)!.attributes('data-comparison-select')).toBe('edit-9999')
+ expect(wrapper.find('[data-comparison-select="edit-9999"]').attributes('aria-current')).toBe('true')
+ })
+
+ it('preserves the current change label when paging away from its row', async () => {
+ const edits = Array.from({ length: 160 }, (_value, index): ComparisonEdit => {
+ const primary = descriptor(`member-${index}`, `preview-${index}`)
+ return { id: `edit-${index}`, kind: 'content', primary, descriptors: [primary] }
+ })
+ const wrapper = mount(ComparisonChangeList, {
+ props: { edits, currentId: 'edit-159', beforeDocument: document, afterDocument: document },
+ })
+ const initialLabel = wrapper.emitted('currentLabel')!.at(-1)![0]
+
+ await wrapper.findAll('.text-comparison__change-pages button')[0]!.trigger('click')
+
+ expect(wrapper.findAll('[data-comparison-select]')[0]!.attributes('data-comparison-select')).toBe('edit-0')
+ expect(wrapper.find('[aria-current="true"]').exists()).toBe(false)
+ expect(wrapper.emitted('currentLabel')!.at(-1)![0]).toBe(initialLabel)
+ expect(initialLabel).not.toBe('')
+ })
+
+ it('AUD-14 unmounts records in collapsed sections', async () => {
+ const primary = descriptor('member', 'preview')
+ const edit: ComparisonEdit = { id: 'edit', kind: 'content', primary, descriptors: [primary] }
+ const wrapper = mount(ComparisonChangeList, {
+ props: { edits: [edit], beforeDocument: document, afterDocument: document },
+ })
+
+ await wrapper.get('.text-comparison__section-toggle').trigger('click')
+
+ expect(wrapper.findAll('[data-comparison-select]')).toHaveLength(0)
+ })
+
+ it('translates only the selected lookup entry for each record', () => {
+ const translate = vi.spyOn(l10n, 't')
+ const primary: ComparisonDescriptor = {
+ ...descriptor('member', 'preview', ['attribute']),
+ signals: [{ type: 'attribute', attribute: 'link', change: 'changed' }],
+ }
+ const edit: ComparisonEdit = { id: 'edit', kind: 'content', primary, descriptors: [primary] }
+
+ mount(ComparisonChangeList, {
+ props: { edits: [edit], beforeDocument: document, afterDocument: document },
+ })
+
+ const messages = translate.mock.calls.map(([, message]) => message)
+ expect(messages).toContain('Link changed')
+ expect(messages).not.toContain('Heading level changed')
+ translate.mockRestore()
+ })
+
+ it('V01 renders one row per first-class edit using explicit primary and all member descriptors', async () => {
+ const first = descriptor('member-first', 'wrong', ['formatting'])
+ const primary = descriptor('member-primary', 'primary')
+ const edit: ComparisonEdit = { id: 'edit-row', kind: 'content', primary, descriptors: [first, primary] }
+ const wrapper = mount(ComparisonChangeList, {
+ props: { edits: [edit], currentId: 'edit-row', beforeDocument: document, afterDocument: document },
+ })
+ const rows = wrapper.findAll('[data-comparison-select]')
+ expect(rows).toHaveLength(1)
+ expect(rows[0]!.attributes('data-comparison-select')).toBe('edit-row')
+ expect(rows[0]!.find('.text-comparison__change-item-content').exists()).toBe(true)
+ expect(rows[0]!.text()).toContain('primary')
+ expect(rows[0]!.text()).toContain('2 edits')
+ await rows[0]!.trigger('click')
+ expect(wrapper.emitted('select')).toEqual([['edit-row']])
+ })
+
+ it('renders explicit before and after previews for a replacement', () => {
+ const primary: ComparisonDescriptor = {
+ ...descriptor('member', 'unused'),
+ preview: {
+ before: { kind: 'text', text: 'before text' },
+ after: { kind: 'text', text: 'after text' },
+ },
+ }
+ const edit: ComparisonEdit = { id: 'edit', kind: 'content', primary, descriptors: [primary] }
+ const wrapper = mount(ComparisonChangeList, {
+ props: { edits: [edit], beforeDocument: document, afterDocument: document },
+ })
+
+ expect(wrapper.get('del.text-comparison__preview-before').text()).toBe('before text')
+ expect(wrapper.get('ins.text-comparison__preview-after').text()).toBe('after text')
+ })
+
+ it('labels a coarse composite change by its structural scope instead of an incidental task attribute', () => {
+ const primary: ComparisonDescriptor = {
+ ...descriptor('member', 'nested content', ['text', 'attribute', 'structure']),
+ coarseReason: 'ambiguous-attribution',
+ signals: [
+ { type: 'attribute', attribute: 'task-state', change: 'changed' },
+ { type: 'node' },
+ ],
+ }
+ const edit: ComparisonEdit = { id: 'edit', kind: 'content', primary, descriptors: [primary] }
+ const wrapper = mount(ComparisonChangeList, {
+ props: { edits: [edit], beforeDocument: document, afterDocument: document },
+ })
+
+ expect(wrapper.get('[data-comparison-select]').text()).toContain('Structure changed')
+ expect(wrapper.get('[data-comparison-select]').text()).not.toContain('Task state changed')
+ })
+
+ it.each([
+ ['insert', 'inline', 'Paragraph changed', 'Paragraph added'],
+ ['delete', 'inline', 'Paragraph changed', 'Paragraph removed'],
+ ['insert', 'block', 'Paragraph added', 'Paragraph changed'],
+ ['delete', 'block', 'Paragraph removed', 'Paragraph changed'],
+ ] as const)('labels a %s %s operation at the correct altitude', (operation, detail, expected, rejected) => {
+ const primary: ComparisonDescriptor = {
+ ...descriptor('member', 's'),
+ operation,
+ detail,
+ context: {
+ before: { code: 'paragraph', path: [], from: 0, to: 1 },
+ after: { code: 'paragraph', path: [], from: 0, to: 1 },
+ },
+ preview: operation === 'insert'
+ ? { before: null, after: { kind: 'text', text: 's' } }
+ : { before: { kind: 'text', text: 's' }, after: null },
+ }
+ const edit: ComparisonEdit = { id: 'edit', kind: 'content', primary, descriptors: [primary] }
+ const wrapper = mount(ComparisonChangeList, {
+ props: { edits: [edit], beforeDocument: document, afterDocument: document },
+ })
+
+ expect(wrapper.get('[data-comparison-select]').text()).toContain(expected)
+ expect(wrapper.get('[data-comparison-select]').text()).not.toContain(rejected)
+ })
+})
diff --git a/src/tests/comparison/MarkdownSourceComponent.spec.ts b/src/tests/comparison/MarkdownSourceComponent.spec.ts
new file mode 100644
index 00000000000..f095354e1e1
--- /dev/null
+++ b/src/tests/comparison/MarkdownSourceComponent.spec.ts
@@ -0,0 +1,187 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { mount } from '@vue/test-utils'
+import { describe, expect, it, vi } from 'vitest'
+import MarkdownSourceComparison from '../../components/MarkdownSourceComparison.vue'
+import { SOURCE_DIFF_LIMITS } from '../../comparison/markdownSourceComparison.ts'
+import {
+ COMPLETE_SOURCE_DISPLAY_LIMITS,
+ displayBoundedMarkdownSource,
+ displayMarkdownSource,
+} from '../../comparison/markdownSourceDisplay.ts'
+
+describe('Markdown source component', () => {
+ const multilineSource = (length: number) => {
+ const line = `${'x'.repeat(COMPLETE_SOURCE_DISPLAY_LIMITS.maximumVisibleCharactersPerLine - 1)}\n`
+ return line.repeat(Math.floor(length / line.length)) + 'x'.repeat(length % line.length)
+ }
+
+ it.each([
+ COMPLETE_SOURCE_DISPLAY_LIMITS.maximumVisibleCharactersPerSide - 1,
+ COMPLETE_SOURCE_DISPLAY_LIMITS.maximumVisibleCharactersPerSide,
+ ])('AUD-08 preserves complete source at the %i-character display boundary', (length) => {
+ const source = multilineSource(length)
+ expect(displayBoundedMarkdownSource(source)).toEqual({ text: source, truncated: false })
+ })
+
+ it('keeps supplementary characters well formed at the input boundary', () => {
+ const limit = COMPLETE_SOURCE_DISPLAY_LIMITS.maximumInputCharactersPerSide
+ const exact = `${multilineSource(limit - 2)}😀`
+ const crossingPrefix = multilineSource(limit - 1)
+ const crossing = `${crossingPrefix}😀`
+
+ expect(displayBoundedMarkdownSource(exact)).toEqual({ text: exact, truncated: false })
+ const result = displayBoundedMarkdownSource(crossing)
+ expect(result.text).toBe(crossingPrefix)
+ expect(result.text.length).toBeLessThanOrEqual(COMPLETE_SOURCE_DISPLAY_LIMITS.maximumVisibleCharactersPerSide)
+ expect(result.text.isWellFormed()).toBe(true)
+ expect(result.truncated).toBe(true)
+ })
+
+ it('keeps supplementary characters and visible controls intact at the output boundary', () => {
+ expect(displayMarkdownSource('abc😀', 5)).toBe('abc😀')
+ expect(displayMarkdownSource('abc😀', 4)).toBe('abc')
+ expect(displayMarkdownSource('\tremaining', 5)).toBe('⟦TAB⟧')
+ })
+
+ it.each([
+ ['high', '\uD83D', '⟦U+D83D⟧'],
+ ['low', '\uDE00', '⟦U+DE00⟧'],
+ ])('renders a lone %s surrogate as an exact reversible token', (_name, source, expected) => {
+ const result = displayBoundedMarkdownSource(source)
+
+ expect(result).toEqual({ text: expected, truncated: false })
+ expect(result.text).not.toContain('\uFFFD')
+ expect(result.text.isWellFormed()).toBe(true)
+ })
+
+ it('reports expansion truncation instead of silently omitting a supplementary character', () => {
+ const result = displayBoundedMarkdownSource(`${'\t'.repeat(200_000)}😀`)
+
+ expect(result.truncated).toBe(true)
+ expect(result.text).toHaveLength(COMPLETE_SOURCE_DISPLAY_LIMITS.maximumVisibleCharactersPerLine)
+ expect(result.text).not.toContain('\uFFFD')
+ expect(result.text.isWellFormed()).toBe(true)
+ expect(result.text.length).toBeLessThanOrEqual(COMPLETE_SOURCE_DISPLAY_LIMITS.maximumVisibleCharactersPerLine)
+ })
+
+ it('shows complete fallback immediately, then enhanced literal hunks', async () => {
+ const wrapper = mount(MarkdownSourceComparison, {
+ props: { beforeContent: 'old\t \n', afterContent: 'new\u200B\n', layoutMode: 'paired' },
+ })
+ expect(wrapper.find('[data-comparison-source-fallback]').exists()).toBe(true)
+ await vi.waitFor(() => expect(wrapper.find('[data-source-hunk]').exists()).toBe(true))
+ expect(wrapper.text()).toContain('old')
+ expect(wrapper.text()).toContain('new⟦ZWSP⟧')
+ })
+
+ it('AUD-05 exposes side, operation, whitespace, EOL, and missing-newline semantics', async () => {
+ const wrapper = mount(MarkdownSourceComparison, {
+ props: {
+ beforeContent: `old${String.fromCharCode(9)}\r\ntrail `,
+ afterContent: 'new\ntrail\n',
+ layoutMode: 'paired',
+ },
+ })
+ await vi.waitFor(() => expect(wrapper.find('[data-source-hunk]').exists()).toBe(true))
+
+ expect(wrapper.find('[data-source-side="before"]').text()).toBe('Before')
+ expect(wrapper.find('[data-source-side="after"]').text()).toBe('After')
+ expect(wrapper.find('[data-source-operation="removed"]').attributes('aria-label')).toContain('Removed line')
+ expect(wrapper.find('[data-source-operation="added"]').attributes('aria-label')).toContain('Added line')
+ expect(wrapper.find('[data-source-operation="removed"] [data-source-cue]').text()).toBe('−')
+ expect(wrapper.find('[data-source-operation="added"] [data-source-cue]').text()).toBe('+')
+ for (const token of ['TAB', 'CRLF', 'LF', '2 TRAILING SPACES', 'No newline at end of file']) {
+ expect(wrapper.text()).toContain(token)
+ }
+ })
+
+ it('omits per-line badges when paired line endings match', async () => {
+ const wrapper = mount(MarkdownSourceComparison, {
+ props: {
+ beforeContent: 'old\nunchanged\n',
+ afterContent: 'new\nunchanged\n',
+ layoutMode: 'paired',
+ },
+ })
+ await vi.waitFor(() => expect(wrapper.find('[data-source-hunk]').exists()).toBe(true))
+
+ expect(wrapper.findAll('[data-source-eol]')).toHaveLength(0)
+ })
+
+ it('AUD-13 renders the audited bidi and control set as visible inert source tokens', async () => {
+ const controls = '\u061C\u00AD\u200E\u200F\u0085\u2028\u2029'
+ const wrapper = mount(MarkdownSourceComparison, {
+ props: { beforeContent: controls, afterContent: '', layoutMode: 'paired' },
+ })
+ await vi.waitFor(() => expect(wrapper.find('[data-source-hunk]').exists()).toBe(true))
+
+ for (const token of ['ALM', 'SHY', 'LRM', 'RLM', 'NEL', 'LS', 'PS']) {
+ expect(wrapper.text()).toContain(token)
+ }
+ for (const control of controls) {
+ expect(wrapper.text()).not.toContain(control)
+ }
+ })
+
+ it('AUD-08 expands a large unchanged gap incrementally with observable source ranges', async () => {
+ const prefix = Array.from({ length: 3_000 }, (_value, index) => `prefix-${index}`)
+ const suffix = Array.from({ length: 3_000 }, (_value, index) => `suffix-${index}`)
+ const beforeContent = [...prefix, 'old literal', ...suffix].join('\n')
+ const afterContent = [...prefix, 'new literal', ...suffix].join('\n')
+ const wrapper = mount(MarkdownSourceComparison, {
+ props: { beforeContent, afterContent, layoutMode: 'paired' },
+ })
+ await vi.waitFor(() => expect(wrapper.findAll('.text-source-comparison__gap button')).toHaveLength(2))
+
+ await wrapper.findAll('[data-source-gap-toggle]')[0]!.trigger('click')
+
+ expect(wrapper.findAll('.text-source-comparison__row')).toHaveLength(SOURCE_DIFF_LIMITS.maximumGapPageRows + 7)
+ expect(wrapper.text()).toContain('prefix-0')
+ expect(wrapper.text()).toContain(`prefix-${SOURCE_DIFF_LIMITS.maximumGapPageRows - 1}`)
+ expect(wrapper.text()).not.toContain(`prefix-${SOURCE_DIFF_LIMITS.maximumGapPageRows}`)
+
+ await wrapper.find('[data-source-gap-more]').trigger('click')
+
+ expect(wrapper.findAll('.text-source-comparison__row')).toHaveLength(SOURCE_DIFF_LIMITS.maximumGapPageRows * 2 + 7)
+ expect(wrapper.text()).toContain(`prefix-${SOURCE_DIFF_LIMITS.maximumGapPageRows}`)
+ })
+
+ it('AUD-08 never expands gaps beyond the shared displayed-row ceiling', async () => {
+ const prefix = Array.from({ length: 3_000 }, (_value, index) => `prefix-${index}`)
+ const suffix = Array.from({ length: 3_000 }, (_value, index) => `suffix-${index}`)
+ const beforeContent = [...prefix, 'old literal', ...suffix].join('\n')
+ const afterContent = [...prefix, 'new literal', ...suffix].join('\n')
+ const wrapper = mount(MarkdownSourceComparison, {
+ props: { beforeContent, afterContent, layoutMode: 'paired' },
+ })
+ await vi.waitFor(() => expect(wrapper.findAll('[data-source-gap-toggle]')).toHaveLength(2))
+
+ for (const toggle of wrapper.findAll('[data-source-gap-toggle]')) {
+ await toggle.trigger('click')
+ while (wrapper.find('[data-source-gap-more]').exists()) {
+ await wrapper.find('[data-source-gap-more]').trigger('click')
+ }
+ }
+
+ expect(wrapper.findAll('.text-source-comparison__row')).toHaveLength(SOURCE_DIFF_LIMITS.maximumDisplayedRows)
+ expect(wrapper.text()).toContain('prefix-0')
+ expect(wrapper.text()).toContain('suffix-3')
+ expect(wrapper.text()).not.toContain('suffix-2999')
+ expect(wrapper.find('[data-source-gap-limited]').exists()).toBe(true)
+ }, 15_000)
+
+ it('V11 preserves bounded complete fallback when source enhancement is limited', async () => {
+ const beforeContent = 'x'.repeat(SOURCE_DIFF_LIMITS.maximumCharacters + 1)
+ const wrapper = mount(MarkdownSourceComparison, {
+ props: { beforeContent, afterContent: 'after', layoutMode: 'single' },
+ })
+ await vi.waitFor(() => expect(wrapper.find('[data-source-limited]').exists()).toBe(true))
+ expect(wrapper.find('[data-comparison-source-fallback]').exists()).toBe(true)
+ expect(wrapper.find('pre code').text()).toHaveLength(COMPLETE_SOURCE_DISPLAY_LIMITS.maximumVisibleCharactersPerLine)
+ expect(wrapper.findAll('[role="status"]').map((status) => status.text()).join(' ')).toContain('truncated')
+ })
+})
diff --git a/src/tests/comparison/MarkdownSourceFallback.spec.ts b/src/tests/comparison/MarkdownSourceFallback.spec.ts
new file mode 100644
index 00000000000..0791c0d5efc
--- /dev/null
+++ b/src/tests/comparison/MarkdownSourceFallback.spec.ts
@@ -0,0 +1,30 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { mount } from '@vue/test-utils'
+import { describe, expect, it, vi } from 'vitest'
+import MarkdownSourceFallback from '../../components/MarkdownSourceFallback.vue'
+
+vi.mock('../../comparison/markdownSourceComparison.ts', () => {
+ throw new Error('enhanced Source is unavailable')
+})
+
+describe('complete Markdown source fallback', () => {
+ it('always renders both complete snapshots as inert literal text with visible controls', () => {
+ const wrapper = mount(MarkdownSourceFallback, {
+ props: {
+ beforeContent: '\nzero\u200Bwidth',
+ afterContent: '\nlast',
+ },
+ })
+ const sources = wrapper.findAll('pre code')
+ expect(sources).toHaveLength(2)
+ expect(sources[0]!.text()).toContain('')
+ expect(sources[0]!.text()).toContain('⟦ZWSP⟧')
+ expect(sources[1]!.text()).toContain('')
+ expect(wrapper.find('script').exists()).toBe(false)
+ expect(wrapper.find('img').exists()).toBe(false)
+ })
+})
diff --git a/src/tests/comparison/a15HistoryDifferential.spec.ts b/src/tests/comparison/a15HistoryDifferential.spec.ts
new file mode 100644
index 00000000000..15e84bdb803
--- /dev/null
+++ b/src/tests/comparison/a15HistoryDifferential.spec.ts
@@ -0,0 +1,183 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { Node as ProseMirrorNode } from '@tiptap/pm/model'
+
+import { describe, expect, it } from 'vitest'
+import { createComparisonEditor } from '../../comparison/createComparisonEditor.ts'
+import { createHierarchicalMarkdownComparisonModel } from '../../comparison/hierarchicalMarkdownComparisonModel.ts'
+
+interface EditorLike {
+ state: { doc: ProseMirrorNode }
+ destroy: () => void
+}
+
+interface ExpectedReplacement {
+ operation: string
+ detail: string
+ before: string
+ after: string
+}
+
+interface RegressionCase {
+ name: string
+ before: string
+ after: string
+ expected: readonly ExpectedReplacement[]
+}
+
+const regressionCorpus: readonly RegressionCase[] = [
+ {
+ name: 'keeps an exact trailing block outside earlier replacements',
+ before: `# Wiki App
+
+Old build instructions.
+
+Shared footer.
+`,
+ after: `# Collective Wiki
+
+New installation instructions.
+
+Shared footer.
+`,
+ expected: [
+ { operation: 'insert', detail: 'inline', before: '', after: 'Collective ' },
+ { operation: 'delete', detail: 'inline', before: ' App', after: '' },
+ { operation: 'replace', detail: 'inline', before: 'Old build', after: 'New installation' },
+ ],
+ },
+ {
+ name: 'keeps a weighted multi-block gap precise',
+ before: `## Development Background: Ownership
+
+Individual users own files. Collective pages should be owned by the collective.
+
+## Stable anchor
+
+This block is unchanged.
+`,
+ after: `## Development background: Ownership
+
+Collective data is owned by the collective instead.
+
+## Stable anchor
+
+This block is unchanged.
+`,
+ expected: [
+ { operation: 'replace', detail: 'inline', before: 'B', after: 'b' },
+ { operation: 'delete', detail: 'inline', before: 'Individual users own files. ', after: '' },
+ { operation: 'replace', detail: 'inline', before: 'pages should be ', after: 'data is ' },
+ { operation: 'insert', detail: 'inline', before: '', after: ' instead' },
+ ],
+ },
+ {
+ name: 'reports code text and language replacements directly',
+ before: `\`\`\`
+const value = 1
+\`\`\`
+`,
+ after: `\`\`\`js
+const value = 1 // comment
+\`\`\`
+`,
+ expected: [
+ { operation: 'replace', detail: 'block', before: 'const value = 1', after: 'const value = 1 // comment' },
+ { operation: 'insert', detail: 'inline', before: '', after: ' // comment' },
+ ],
+ },
+ {
+ name: 'reports a removed list item as a node deletion',
+ before: `- Remove me
+- Keep me
+`,
+ after: `- Keep me
+`,
+ expected: [
+ { operation: 'delete', detail: 'block', before: 'Remove me', after: '' },
+ ],
+ },
+ {
+ name: 'does not expose parser-only Markdown syntax as a change signal',
+ before: `GNU AGPL v3 or later
+`,
+ after: `Files: *
+Copyright: Azul
+License: AGPL v3 or later
+`,
+ expected: [
+ {
+ operation: 'replace',
+ detail: 'inline',
+ before: 'GNU',
+ after: 'Files: *\nCopyright: Azul azul@example.com\nLicense:',
+ },
+ ],
+ },
+]
+
+function replacementOutput(beforeContent: string, afterContent: string) {
+ const beforeEditor = createComparisonEditor(beforeContent) as EditorLike
+ const afterEditor = createComparisonEditor(afterContent) as EditorLike
+ try {
+ const before = beforeEditor.state.doc
+ const after = afterEditor.state.doc
+ return createHierarchicalMarkdownComparisonModel(before, after).edits
+ .flatMap(({ descriptors }) => descriptors)
+ .map((descriptor) => ({
+ operation: descriptor.operation,
+ detail: descriptor.detail,
+ facets: descriptor.facets,
+ before: before.textBetween(descriptor.before.from, descriptor.before.to, '\n', '\ufffc'),
+ after: after.textBetween(descriptor.after.from, descriptor.after.to, '\n', '\ufffc'),
+ context: descriptor.context,
+ signals: descriptor.signals,
+ coarseReason: descriptor.coarseReason ?? null,
+ }))
+ } finally {
+ beforeEditor.destroy()
+ afterEditor.destroy()
+ }
+}
+
+function replacementProjection(replacements: ReturnType): ExpectedReplacement[] {
+ return replacements.map(({ operation, detail, before, after }) => ({ operation, detail, before, after }))
+}
+
+function corpusCase(name: string) {
+ return regressionCorpus.find((candidate) => candidate.name === name)!
+}
+
+describe('A15 repository-history regression corpus', () => {
+ it.each(regressionCorpus)('$name', ({ before, after, expected }) => {
+ const replacements = replacementOutput(before, after)
+
+ expect(replacementProjection(replacements)).toEqual(expected)
+ expect(replacements.every(({ coarseReason }) => coarseReason === null)).toBe(true)
+ })
+
+ it('keeps replacement descriptor signals observable', () => {
+ const code = corpusCase('reports code text and language replacements directly')
+ const codeReplacements = replacementOutput(code.before, code.after)
+ expect(codeReplacements[0]).toMatchObject({
+ facets: ['attribute'],
+ signals: [{ type: 'attribute', attribute: 'code-language', change: 'changed' }],
+ })
+
+ const deletion = corpusCase('reports a removed list item as a node deletion')
+ expect(replacementOutput(deletion.before, deletion.after)[0]).toMatchObject({
+ facets: ['text', 'structure'],
+ context: { before: { code: 'list-item' }, after: null },
+ signals: [{ type: 'node' }],
+ })
+
+ const syntax = corpusCase('does not expose parser-only Markdown syntax as a change signal')
+ expect(replacementOutput(syntax.before, syntax.after)[0]).toMatchObject({
+ facets: ['text', 'attribute', 'unknown'],
+ signals: [{ type: 'attribute', attribute: 'link', change: 'added' }],
+ })
+ })
+})
diff --git a/src/tests/comparison/comparisonAlignment.spec.ts b/src/tests/comparison/comparisonAlignment.spec.ts
new file mode 100644
index 00000000000..3783e9d7087
--- /dev/null
+++ b/src/tests/comparison/comparisonAlignment.spec.ts
@@ -0,0 +1,343 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { describe, expect, it } from 'vitest'
+import {
+ alignComparisonAxis,
+ createComparisonWorkLedger,
+ DEFAULT_COMPARISON_CELL_LEDGER,
+ DEFAULT_COMPARISON_TOKEN_LEDGER,
+ forcedIncreasingPairs,
+} from '../../comparison/comparisonAlignment.ts'
+
+function options(work = createComparisonWorkLedger()) {
+ return {
+ work,
+ fingerprint: (value: string) => value,
+ profile: (value: string) => [...value],
+ compatible: () => true,
+ }
+}
+
+interface EvidencedItem {
+ id: number
+ side: 'before' | 'after'
+}
+
+function evidencedOptions(work = createComparisonWorkLedger()) {
+ return {
+ work,
+ fingerprint: ({ id, side }: EvidencedItem) => `${side}:${id}`,
+ profile: ({ id, side }: EvidencedItem) => [`item:${id}`, side],
+ compatible: () => true,
+ }
+}
+
+function evidencedAxis(size: number, side: EvidencedItem['side']): EvidencedItem[] {
+ return Array.from({ length: size }, (_value, id) => ({ id, side }))
+}
+
+const FINAL_CELL_LEDGER = DEFAULT_COMPARISON_CELL_LEDGER
+const FINAL_TOKEN_LEDGER = DEFAULT_COMPARISON_TOKEN_LEDGER
+const FINAL_SQUARE_SIZE = Math.floor(Math.sqrt(FINAL_CELL_LEDGER))
+
+function permutations(values: readonly number[]): number[][] {
+ if (values.length < 2) {
+ return [Array.from(values)]
+ }
+ return values.flatMap((value, index) => permutations(values.toSpliced(index, 1))
+ .map((suffix) => [value, ...suffix]))
+}
+
+function exhaustiveForcedPairs(values: readonly number[]) {
+ let maximum = 0
+ const optimal: number[][] = []
+ for (let mask = 0; mask < 2 ** values.length; mask++) {
+ const indices = values.flatMap((_value, index) => mask & (1 << index) ? [index] : [])
+ if (!indices.every((index, offset) => offset === 0 || values[indices[offset - 1]!]! < values[index]!)) {
+ continue
+ }
+ if (indices.length > maximum) {
+ maximum = indices.length
+ optimal.length = 0
+ }
+ if (indices.length === maximum) {
+ optimal.push(indices)
+ }
+ }
+ return optimal[0]!.filter((index) => optimal.every((candidate) => candidate.includes(index)))
+ .map((before) => ({ before, after: values[before]! }))
+}
+
+describe('comparison alignment', () => {
+ it('uses the authoritative comparison-wide shipping ledgers', () => {
+ expect(createComparisonWorkLedger()).toEqual({
+ remainingCells: 40_000,
+ remainingTokenComparisons: 84_000_000,
+ })
+ })
+
+ it('pairs a whole equal axis without weighted work', () => {
+ const work = createComparisonWorkLedger()
+
+ expect(alignComparisonAxis(['alpha', 'beta'], ['alpha', 'beta'], options(work))).toEqual([
+ { before: 0, after: 0 },
+ { before: 1, after: 1 },
+ ])
+ expect(work).toEqual({
+ remainingCells: DEFAULT_COMPARISON_CELL_LEDGER,
+ remainingTokenComparisons: DEFAULT_COMPARISON_TOKEN_LEDGER,
+ })
+ })
+
+ it('A03 uses ordered unique fingerprints as exact anchors', () => {
+ const work = createComparisonWorkLedger()
+
+ expect(alignComparisonAxis(['alpha', 'omega'], ['new', 'alpha', 'omega'], options(work))).toEqual([
+ { before: null, after: 0 },
+ { before: 0, after: 1 },
+ { before: 1, after: 2 },
+ ])
+ expect(work.remainingCells).toBe(40_000)
+ })
+
+ it('matches exhaustive forced-LIS anchors for crossing candidates', () => {
+ for (let size = 1; size <= 6; size++) {
+ for (const values of permutations(Array.from({ length: size }, (_value, index) => index))) {
+ const pairs = values.map((after, before) => ({ before, after }))
+ expect(forcedIncreasingPairs(pairs), values.join(','))
+ .toEqual(exhaustiveForcedPairs(values))
+ }
+ }
+ })
+
+ it('aligns around the forced subset of crossing exact candidates', () => {
+ expect(alignComparisonAxis(['alpha', 'beta', 'gamma'], ['beta', 'gamma', 'alpha'], options())).toEqual([
+ { before: 0, after: null },
+ { before: 1, after: 0 },
+ { before: 2, after: 1 },
+ { before: null, after: 2 },
+ ])
+ })
+
+ it('retains the first exact duplicate when one is inserted', () => {
+ expect(alignComparisonAxis(['same'], ['same', 'same'], options())).toEqual([
+ { before: 0, after: 0 },
+ { before: null, after: 1 },
+ ])
+ })
+
+ it('retains the first exact duplicate when one is deleted', () => {
+ expect(alignComparisonAxis(['same', 'same'], ['same'], options())).toEqual([
+ { before: 0, after: 0 },
+ { before: 1, after: null },
+ ])
+ })
+
+ it('A09 pairs one compatible changed item without weighted work', () => {
+ const work = createComparisonWorkLedger()
+
+ expect(alignComparisonAxis(['before'], ['after'], options(work))).toEqual([
+ { before: 0, after: 0 },
+ ])
+ expect(work.remainingCells).toBe(DEFAULT_COMPARISON_CELL_LEDGER)
+ expect(work.remainingTokenComparisons).toBe(DEFAULT_COMPARISON_TOKEN_LEDGER)
+ })
+
+ it('leaves one incompatible changed item unmatched', () => {
+ const incompatible = {
+ ...options(),
+ compatible: () => false,
+ }
+
+ expect(alignComparisonAxis(['list'], ['quote'], incompatible)).toEqual([
+ { before: 0, after: null },
+ { before: null, after: 0 },
+ ])
+ })
+
+ it('A10 coarsens a multi-item rewrite with ambiguous exact attribution', () => {
+ expect(alignComparisonAxis(['aa', 'bb', 'cc'], ['xx', 'yy'], options())).toEqual([{
+ before: { from: 0, to: 3 },
+ after: { from: 0, to: 2 },
+ coarseReason: 'ambiguous-attribution',
+ }])
+ })
+
+ it.each([
+ Math.floor(FINAL_SQUARE_SIZE / 2),
+ FINAL_SQUARE_SIZE - 1,
+ ])('A11 keeps a final-ledger-derived unique-evidence %i square gap precise', (size) => {
+ const result = alignComparisonAxis(
+ evidencedAxis(size, 'before'),
+ evidencedAxis(size, 'after'),
+ evidencedOptions(),
+ )
+
+ expect(result).toHaveLength(size)
+ expect(result.every((step, index) => step.before === index && step.after === index)).toBe(true)
+ })
+
+ it('A12 keeps the largest default-ledger square gap precise', () => {
+ const work = createComparisonWorkLedger()
+ const size = FINAL_SQUARE_SIZE
+ const result = alignComparisonAxis(
+ evidencedAxis(size, 'before'),
+ evidencedAxis(size, 'after'),
+ evidencedOptions(work),
+ )
+
+ expect(result).toHaveLength(size)
+ expect(work.remainingCells).toBe(0)
+ expect(work.remainingTokenComparisons).toBe(FINAL_TOKEN_LEDGER - 4 * size ** 2)
+ })
+
+ it('A13 refuses the first generated cell and token overflows atomically', () => {
+ const cellWork = createComparisonWorkLedger()
+ const size = FINAL_SQUARE_SIZE
+ expect(alignComparisonAxis(
+ evidencedAxis(size + 1, 'before'),
+ evidencedAxis(size, 'after'),
+ evidencedOptions(cellWork),
+ )).toEqual([{
+ before: { from: 0, to: size + 1 },
+ after: { from: 0, to: size },
+ coarseReason: 'comparison-limit',
+ }])
+ expect(cellWork).toEqual(createComparisonWorkLedger())
+
+ const tokenWork = createComparisonWorkLedger()
+ const longProfile = Array.from({ length: Math.floor(FINAL_TOKEN_LEDGER / (2 * size * size)) + 1 }, () => 'x')
+ expect(alignComparisonAxis(
+ evidencedAxis(size, 'before'),
+ evidencedAxis(size, 'after'),
+ {
+ ...evidencedOptions(tokenWork),
+ profile: () => longProfile,
+ },
+ )).toEqual([{
+ before: { from: 0, to: size },
+ after: { from: 0, to: size },
+ coarseReason: 'comparison-limit',
+ }])
+ expect(tokenWork).toEqual(createComparisonWorkLedger())
+ })
+
+ it('A14 allocates final-ledger cell work by axis order without debiting a refused gap', () => {
+ interface Item {
+ fingerprint: string
+ profile: readonly string[]
+ }
+ const gap = (size: number, name: string, side: 'before' | 'after'): Item[] => (
+ Array.from({ length: size }, (_value, id) => ({
+ fingerprint: `${name}:${side}:${id}`,
+ profile: [`${name}:${id}`, side],
+ }))
+ )
+ const anchor = (name: string): Item => ({ fingerprint: name, profile: [name] })
+ const firstSize = Math.floor(FINAL_SQUARE_SIZE / 2)
+ const refusedSize = FINAL_SQUARE_SIZE
+ const lastSize = Math.max(2, Math.floor(firstSize / 10))
+ const before = [
+ ...gap(firstSize, 'first', 'before'),
+ anchor('anchor-1'),
+ ...gap(refusedSize, 'refused', 'before'),
+ anchor('anchor-2'),
+ ...gap(lastSize, 'last', 'before'),
+ ]
+ const after = [
+ ...gap(firstSize, 'first', 'after'),
+ anchor('anchor-1'),
+ ...gap(refusedSize, 'refused', 'after'),
+ anchor('anchor-2'),
+ ...gap(lastSize, 'last', 'after'),
+ ]
+ const work = createComparisonWorkLedger()
+ const result = alignComparisonAxis(before, after, {
+ work,
+ fingerprint: (item) => item.fingerprint,
+ profile: (item) => item.profile,
+ compatible: () => true,
+ })
+ const refusedStart = firstSize + 1
+
+ expect(result).toContainEqual({
+ before: { from: refusedStart, to: refusedStart + refusedSize },
+ after: { from: refusedStart, to: refusedStart + refusedSize },
+ coarseReason: 'comparison-limit',
+ })
+ expect(result.at(-1)).toEqual({ before: before.length - 1, after: after.length - 1 })
+ expect(work.remainingCells).toBe(FINAL_CELL_LEDGER - firstSize ** 2 - lastSize ** 2)
+ })
+
+ it('A14 retains token and tie debits while preserving work after a refused token gap', () => {
+ interface Item {
+ fingerprint: string
+ profile: readonly string[]
+ }
+ const gapSize = Math.floor(FINAL_SQUARE_SIZE / 2)
+ const firstAfterSize = gapSize - 1
+ const lastSize = Math.max(2, Math.floor(gapSize / 10))
+ const firstProduct = gapSize * firstAfterSize
+ const firstProfileLength = Math.floor(FINAL_TOKEN_LEDGER / (4 * firstProduct))
+ const firstProfile = Array.from({ length: firstProfileLength }, () => 'same')
+ const tieCharge = 2 * firstProduct * firstProfileLength
+ const refusedProfileLength = Math.floor((FINAL_TOKEN_LEDGER - tieCharge) / (2 * gapSize ** 2)) + 1
+ const refusedProfile = Array.from({ length: refusedProfileLength }, () => 'refused')
+ const gap = (size: number, name: string, side: 'before' | 'after', profile?: readonly string[]): Item[] => (
+ Array.from({ length: size }, (_value, id) => ({
+ fingerprint: `${name}:${side}:${id}`,
+ profile: profile ?? [`${name}:${id}`, side],
+ }))
+ )
+ const anchor = (name: string): Item => ({ fingerprint: name, profile: [name] })
+ const before = [
+ ...gap(gapSize, 'tie', 'before', firstProfile),
+ anchor('anchor-1'),
+ ...gap(gapSize, 'refused', 'before', refusedProfile),
+ anchor('anchor-2'),
+ ...gap(lastSize, 'last', 'before'),
+ ]
+ const after = [
+ ...gap(firstAfterSize, 'tie', 'after', firstProfile),
+ anchor('anchor-1'),
+ ...gap(gapSize, 'refused', 'after', refusedProfile),
+ anchor('anchor-2'),
+ ...gap(lastSize, 'last', 'after'),
+ ]
+ const work = createComparisonWorkLedger()
+ const result = alignComparisonAxis(before, after, {
+ work,
+ fingerprint: (item) => item.fingerprint,
+ profile: (item) => item.profile,
+ compatible: () => true,
+ })
+ const lastCharge = 4 * lastSize ** 2
+
+ expect(result[0]).toMatchObject({ coarseReason: 'ambiguous-attribution' })
+ expect(result).toContainEqual({
+ before: { from: gapSize + 1, to: 2 * gapSize + 1 },
+ after: { from: firstAfterSize + 1, to: firstAfterSize + gapSize + 1 },
+ coarseReason: 'comparison-limit',
+ })
+ expect(result.at(-1)).toEqual({ before: before.length - 1, after: after.length - 1 })
+ expect(work).toEqual({
+ remainingCells: FINAL_CELL_LEDGER - firstProduct - lastSize ** 2,
+ remainingTokenComparisons: FINAL_TOKEN_LEDGER - tieCharge - lastCharge,
+ })
+ })
+
+ it('P05 admits a skewed one-by-many gap by its exact cell charge', () => {
+ const work = createComparisonWorkLedger()
+ const result = alignComparisonAxis(
+ evidencedAxis(1, 'before'),
+ evidencedAxis(20_000, 'after'),
+ evidencedOptions(work),
+ )
+
+ expect(result).not.toContainEqual(expect.objectContaining({ coarseReason: 'comparison-limit' }))
+ expect(work.remainingCells).toBe(20_000)
+ })
+})
diff --git a/src/tests/comparison/comparisonAlignmentOracle.spec.ts b/src/tests/comparison/comparisonAlignmentOracle.spec.ts
new file mode 100644
index 00000000000..888fa76d654
--- /dev/null
+++ b/src/tests/comparison/comparisonAlignmentOracle.spec.ts
@@ -0,0 +1,167 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { ComparisonAlignmentStep, ComparisonWorkLedger } from '../../comparison/comparisonAlignment.ts'
+
+import { describe, expect, it } from 'vitest'
+import {
+ DEFAULT_COMPARISON_CELL_LEDGER,
+ DEFAULT_COMPARISON_TOKEN_LEDGER,
+ solveWeightedGap,
+} from '../../comparison/comparisonAlignment.ts'
+
+interface OracleItem {
+ fingerprint: string
+ profile: readonly string[]
+}
+
+interface Rational {
+ numerator: bigint
+ denominator: bigint
+}
+
+interface OracleMatch {
+ before: number
+ after: number
+}
+
+function compareRational(a: Rational, b: Rational) {
+ const difference = a.numerator * b.denominator - b.numerator * a.denominator
+ return difference < 0n ? -1 : difference > 0n ? 1 : 0
+}
+
+function addRational(a: Rational, b: Rational): Rational {
+ return {
+ numerator: a.numerator * b.denominator + b.numerator * a.denominator,
+ denominator: a.denominator * b.denominator,
+ }
+}
+
+function oraclePairScore(before: OracleItem, after: OracleItem): Rational {
+ if (before.fingerprint === after.fingerprint) {
+ return { numerator: 3n, denominator: 1n }
+ }
+ let prefix = 0
+ while (prefix < before.profile.length
+ && prefix < after.profile.length
+ && before.profile[prefix] === after.profile[prefix]) {
+ prefix++
+ }
+ let suffix = 0
+ const maximumSuffix = Math.min(before.profile.length, after.profile.length) - prefix
+ while (suffix < maximumSuffix
+ && before.profile[before.profile.length - suffix - 1] === after.profile[after.profile.length - suffix - 1]) {
+ suffix++
+ }
+ const denominator = BigInt(Math.max(before.profile.length, after.profile.length, 1))
+ return { numerator: denominator + BigInt(prefix + suffix), denominator }
+}
+
+function enumerateMatchings(
+ beforeCount: number,
+ afterCount: number,
+ beforeStart = 0,
+ afterStart = 0,
+): OracleMatch[][] {
+ const matchings: OracleMatch[][] = [[]]
+ for (let before = beforeStart; before < beforeCount; before++) {
+ for (let after = afterStart; after < afterCount; after++) {
+ for (const suffix of enumerateMatchings(beforeCount, afterCount, before + 1, after + 1)) {
+ matchings.push([{ before, after }, ...suffix])
+ }
+ }
+ }
+ return matchings
+}
+
+function oracleAlignment(before: readonly OracleItem[], after: readonly OracleItem[]) {
+ let bestScore: Rational = { numerator: -1n, denominator: 1n }
+ let best: OracleMatch[][] = []
+ for (const matching of enumerateMatchings(before.length, after.length)) {
+ const score = matching.reduce(
+ (total, pair) => addRational(total, oraclePairScore(before[pair.before]!, after[pair.after]!)),
+ { numerator: 0n, denominator: 1n },
+ )
+ const order = compareRational(score, bestScore)
+ if (order > 0) {
+ bestScore = score
+ best = [matching]
+ } else if (order === 0) {
+ best.push(matching)
+ }
+ }
+ const signatures = new Map(best.map((matching) => [
+ matching.map(({ before: a, after: b }) => `${a}:${b}`).join(','),
+ matching,
+ ]))
+ if (signatures.size > 1) {
+ return { coarseReason: 'ambiguous-attribution' as const }
+ }
+ return { steps: alignmentSteps(before.length, after.length, [...signatures.values()][0]!) }
+}
+
+function alignmentSteps(beforeCount: number, afterCount: number, matches: readonly OracleMatch[]) {
+ const steps: ComparisonAlignmentStep[] = []
+ let before = 0
+ let after = 0
+ for (const match of matches) {
+ while (before < match.before) {
+ steps.push({ before: before++, after: null })
+ }
+ while (after < match.after) {
+ steps.push({ before: null, after: after++ })
+ }
+ steps.push({ before: before++, after: after++ })
+ }
+ while (before < beforeCount) {
+ steps.push({ before: before++, after: null })
+ }
+ while (after < afterCount) {
+ steps.push({ before: null, after: after++ })
+ }
+ return steps
+}
+
+function axes(items: readonly OracleItem[], maximumLength: number): OracleItem[][] {
+ const result: OracleItem[][] = [[]]
+ for (let length = 1; length <= maximumLength; length++) {
+ for (const prefix of result.filter((axis) => axis.length === length - 1)) {
+ for (const item of items) {
+ result.push([...prefix, item])
+ }
+ }
+ }
+ return result
+}
+
+function freshWork(): ComparisonWorkLedger {
+ return {
+ remainingCells: DEFAULT_COMPARISON_CELL_LEDGER,
+ remainingTokenComparisons: DEFAULT_COMPARISON_TOKEN_LEDGER,
+ }
+}
+
+describe('comparison alignment exact oracles', () => {
+ it('matches an independent exact-rational and signature oracle exhaustively', () => {
+ const items: OracleItem[] = [
+ { fingerprint: 'a', profile: ['shared', 'a'] },
+ { fingerprint: 'b', profile: ['shared', 'b'] },
+ { fingerprint: 'c', profile: ['c'] },
+ ]
+ const candidates = axes(items, 3)
+ for (const before of candidates) {
+ for (const after of candidates) {
+ const actual = solveWeightedGap(before, after, {
+ work: freshWork(),
+ fingerprint: (item) => item.fingerprint,
+ profile: (item) => item.profile,
+ compatible: () => true,
+ })
+ expect(actual, `${before.map(({ fingerprint }) => fingerprint)} -> ${after.map(({ fingerprint }) => fingerprint)}`)
+ .toEqual(oracleAlignment(before, after))
+ }
+ }
+ })
+})
diff --git a/src/tests/comparison/comparisonDecorations.spec.ts b/src/tests/comparison/comparisonDecorations.spec.ts
new file mode 100644
index 00000000000..62b217b4f70
--- /dev/null
+++ b/src/tests/comparison/comparisonDecorations.spec.ts
@@ -0,0 +1,90 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { ComparisonDescriptor } from '../../comparison/markdownComparisonTypes.ts'
+
+import { EditorState } from '@tiptap/pm/state'
+import { schema } from 'prosemirror-schema-basic'
+import { describe, expect, it } from 'vitest'
+import { createComparisonDocumentIndex } from '../../comparison/comparisonDocumentIndex.ts'
+import { createComparisonEditor } from '../../comparison/createComparisonEditor.ts'
+import {
+ ComparisonProjectionError,
+ createComparisonDecorationPlugin,
+ prepareComparisonDecorations,
+} from '../../comparison/markdownComparison.ts'
+
+function descriptor(id: string, before: { from: number, to: number }, after = before): ComparisonDescriptor {
+ return {
+ id,
+ operation: 'replace',
+ detail: 'inline',
+ facets: ['text'],
+ before,
+ after,
+ context: { before: null, after: null },
+ preview: { before: null, after: null },
+ signals: [],
+ }
+}
+
+const doc = schema.node('doc', null, [schema.node('paragraph', null, schema.text('hello'))])
+
+describe('comparison decorations', () => {
+ it('does not infer a current descriptor without edit-owned selection', () => {
+ const change = descriptor('text', { from: 1, to: 4 })
+ const { key, plugin } = createComparisonDecorationPlugin([change], 'before', 'Changed')
+ const state = EditorState.create({ doc, plugins: [plugin] })
+ expect(key.getState(state)).toMatchObject({ activeIds: ['text'], currentIds: [] })
+ })
+
+ it('V04 projects non-empty ranges without creating any marker for a zero-length side', () => {
+ expect(prepareComparisonDecorations(doc, [descriptor('empty', { from: 2, to: 2 })], 'before')).toEqual([])
+ const projected = prepareComparisonDecorations(doc, [descriptor('text', { from: 1, to: 4 })], 'before')
+ expect(projected).toEqual([expect.objectContaining({ from: 1, to: 4, type: 'inline' })])
+ })
+
+ it('fails the complete projection when a non-empty range cannot be represented', () => {
+ const invalid = descriptor('invalid', { from: 99, to: 100 })
+ expect(() => prepareComparisonDecorations(doc, [invalid], 'before')).toThrow(ComparisonProjectionError)
+ })
+
+ it('AUD-04 decorates the enclosing list for a coarse nested-list range', () => {
+ const editor = createComparisonEditor('- outer\n - first\n - second')
+ try {
+ const index = createComparisonDocumentIndex(editor.state.doc)
+ const outerList = index.children[0]!
+ const nestedList = outerList.children[0]!.children[1]!
+ const firstItem = nestedList.children[0]!
+ const lastItem = nestedList.children.at(-1)!
+ const change = descriptor('nested-list', { from: firstItem.from, to: lastItem.to })
+ change.detail = 'block'
+ change.context.before = {
+ code: 'list-item',
+ path: firstItem.path,
+ from: firstItem.from,
+ to: firstItem.to,
+ }
+
+ expect(prepareComparisonDecorations(editor.state.doc, [change], 'before')).toEqual([
+ expect.objectContaining({ from: nestedList.from, to: nestedList.to, type: 'node' }),
+ ])
+ } finally {
+ editor.destroy()
+ }
+ })
+
+ it('invalidates prepared immutable decorations after a document transaction', () => {
+ const change = descriptor('text', { from: 1, to: 4 })
+ const { key, plugin } = createComparisonDecorationPlugin([change], 'before', 'Changed', {
+ activeIds: ['text'],
+ currentIds: ['text'],
+ })
+ const state = EditorState.create({ doc, plugins: [plugin] })
+ expect(key.getState(state)?.prepared).toHaveLength(1)
+ const changed = state.apply(state.tr.insertText('!', 1))
+ expect(key.getState(changed)).toMatchObject({ activeIds: [], currentIds: [], prepared: [] })
+ })
+})
diff --git a/src/tests/comparison/comparisonDocumentLocation.spec.ts b/src/tests/comparison/comparisonDocumentLocation.spec.ts
new file mode 100644
index 00000000000..42afa139dd6
--- /dev/null
+++ b/src/tests/comparison/comparisonDocumentLocation.spec.ts
@@ -0,0 +1,52 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { describe, expect, it, vi } from 'vitest'
+import { locateComparisonTarget } from '../../comparison/comparisonNavigation.ts'
+
+function scrollerIn(pane: HTMLElement) {
+ const scroller = document.createElement('div')
+ pane.append(scroller)
+ Object.defineProperties(scroller, {
+ clientHeight: { value: 300 },
+ scrollHeight: { value: 1200 },
+ scrollLeft: { value: 20 },
+ scrollTop: { value: 50 },
+ })
+ vi.spyOn(scroller, 'getBoundingClientRect').mockReturnValue({ height: 300, top: 100 } as DOMRect)
+ Object.defineProperty(scroller, 'scrollTo', { value: vi.fn() })
+ return scroller
+}
+
+describe('comparison document location', () => {
+ it('prefers the decorated DOM target', () => {
+ const pane = document.createElement('article')
+ const scroller = scrollerIn(pane)
+ const target = document.createElement('span')
+ target.dataset.comparisonChange = 'descriptor-1'
+ scroller.append(target)
+ vi.spyOn(target, 'getBoundingClientRect').mockReturnValue({ height: 20, top: 700 } as DOMRect)
+ const fallback = vi.fn(() => ({ top: 900, height: 1 }))
+ expect(locateComparisonTarget(pane, scroller, 'descriptor-1', 'smooth', fallback)).toBe(true)
+ expect(fallback).not.toHaveBeenCalled()
+ })
+
+ it('V04 centers a supplied position rectangle for a marker-free zero-length side', () => {
+ const pane = document.createElement('article')
+ const scroller = scrollerIn(pane)
+ const fallback = vi.fn(() => ({ top: 700, height: 1 }))
+ expect(locateComparisonTarget(pane, scroller, 'missing', 'auto', fallback)).toBe(true)
+ expect(scroller.scrollTo).toHaveBeenCalledWith({ behavior: 'auto', left: 20, top: 500.5 })
+ expect(pane.querySelector('[data-comparison-change="missing"]')).toBeNull()
+ })
+
+ it('fails closed for invalid or hidden panes', () => {
+ const pane = document.createElement('article')
+ const scroller = scrollerIn(pane)
+ pane.hidden = true
+ expect(locateComparisonTarget(pane, scroller, 'missing', 'auto', () => ({ top: 1, height: 1 }))).toBe(false)
+ expect(locateComparisonTarget(null, scroller, 'missing', 'auto')).toBe(false)
+ })
+})
diff --git a/src/tests/comparison/comparisonEditorLifecycle.spec.ts b/src/tests/comparison/comparisonEditorLifecycle.spec.ts
new file mode 100644
index 00000000000..ead3a8dbfbb
--- /dev/null
+++ b/src/tests/comparison/comparisonEditorLifecycle.spec.ts
@@ -0,0 +1,28 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { PluginKey, Plugin as ProseMirrorPlugin } from '@tiptap/pm/state'
+import { mount } from '@vue/test-utils'
+import { describe, expect, it, vi } from 'vitest'
+import ComparisonEditorContent from '../../components/ComparisonEditorContent.vue'
+import { createComparisonEditor } from '../../comparison/createComparisonEditor.ts'
+
+describe('comparison editor lifecycle boundary', () => {
+ it('mounts the detached editor with its comparison plugin and node views', async () => {
+ const editor = createComparisonEditor('::: info\nBefore\n:::')
+ const plugin = new ProseMirrorPlugin({ key: new PluginKey('comparison') })
+ const wrapper = mount(ComparisonEditorContent, { props: { editor, plugins: [plugin] } })
+ try {
+ await vi.waitFor(() => expect(wrapper.emitted('ready')).toHaveLength(1))
+ const content = wrapper.get('.text-comparison__content')
+ expect(editor.view.dom.parentElement).toBe(content.element)
+ expect(content.find('[data-node-view-wrapper][data-text-el="callout"]').exists()).toBe(true)
+ expect(plugin.spec.key?.get(editor.state)).toBeDefined()
+ } finally {
+ wrapper.unmount()
+ editor.destroy()
+ }
+ })
+})
diff --git a/src/tests/comparison/comparisonNavigation.spec.ts b/src/tests/comparison/comparisonNavigation.spec.ts
new file mode 100644
index 00000000000..f627fa4c048
--- /dev/null
+++ b/src/tests/comparison/comparisonNavigation.spec.ts
@@ -0,0 +1,61 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { ComparisonDescriptor, ComparisonEdit } from '../../comparison/markdownComparisonTypes.ts'
+
+import { describe, expect, it } from 'vitest'
+import {
+ currentIdAfterFilter,
+ currentOrdinal,
+ isPureFormatting,
+ moveCurrentId,
+} from '../../comparison/comparisonNavigation.ts'
+
+function descriptor(id: string, facets: ComparisonDescriptor['facets'], operation: ComparisonDescriptor['operation'] = 'replace'): ComparisonDescriptor {
+ return {
+ id,
+ operation,
+ detail: 'inline',
+ facets,
+ before: { from: 0, to: 1 },
+ after: { from: 0, to: 1 },
+ context: { before: null, after: null },
+ preview: { before: null, after: null },
+ signals: [],
+ }
+}
+
+function edit(id: string, descriptors: ComparisonDescriptor[]): ComparisonEdit {
+ return { id, kind: 'content', primary: descriptors.at(-1)!, descriptors }
+}
+
+describe('edit-first comparison navigation', () => {
+ const edits = [
+ edit('e0', [descriptor('d0', ['text'])]),
+ edit('e1', [descriptor('d1', ['formatting'])]),
+ edit('e2', [descriptor('d2a', ['formatting']), descriptor('d2b', ['text', 'formatting'])]),
+ edit('e3', [descriptor('d3', ['attribute'])]),
+ ]
+
+ it('requires every member to be formatting-only', () => {
+ expect(isPureFormatting(edits[1]!)).toBe(true)
+ expect(isPureFormatting(edits[2]!)).toBe(false)
+ })
+
+ it('V02 preserves the current edit or moves next then previous after filtering', () => {
+ expect(currentIdAfterFilter(edits, ['e0', 'e2', 'e3'], 'e2')).toBe('e2')
+ expect(currentIdAfterFilter(edits, ['e0', 'e2', 'e3'], 'e1')).toBe('e2')
+ expect(currentIdAfterFilter(edits, ['e0'], 'e1')).toBe('e0')
+ expect(currentIdAfterFilter(edits, [], 'e1')).toBeNull()
+ })
+
+ it('V01 wraps navigation and reports one ordinal per first-class edit', () => {
+ const active = ['e0', 'e2', 'e3']
+ expect(moveCurrentId(active, 'e0', -1)).toBe('e3')
+ expect(moveCurrentId(active, 'e3', 1)).toBe('e0')
+ expect(currentOrdinal(active, 'e2')).toBe(2)
+ expect(currentOrdinal([], null)).toBe(0)
+ })
+})
diff --git a/src/tests/comparison/comparisonPerformance.spec.ts b/src/tests/comparison/comparisonPerformance.spec.ts
new file mode 100644
index 00000000000..4cbdade1289
--- /dev/null
+++ b/src/tests/comparison/comparisonPerformance.spec.ts
@@ -0,0 +1,171 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { Node } from '@tiptap/pm/model'
+
+import { describe, expect, it } from 'vitest'
+import {
+ alignComparisonAxis,
+ createComparisonWorkLedger,
+ DEFAULT_COMPARISON_TOKEN_LEDGER,
+} from '../../comparison/comparisonAlignment.ts'
+import { createHierarchicalMarkdownComparisonModel } from '../../comparison/hierarchicalMarkdownComparisonModel.ts'
+import { prepareComparisonDecorations } from '../../comparison/markdownComparison.ts'
+import { createComparisonTestEditor } from './comparisonTestEditor.ts'
+
+interface Item {
+ key: string
+ profile: readonly string[]
+}
+
+function items(count: number, side: string): Item[] {
+ return Array.from({ length: count }, (_value, index) => ({
+ key: `${side}:${index}`,
+ profile: [`item:${index}`, side],
+ }))
+}
+
+function options(work = createComparisonWorkLedger()) {
+ return {
+ work,
+ fingerprint: ({ key }: Item) => key,
+ profile: ({ profile }: Item) => profile,
+ compatible: () => true,
+ }
+}
+
+describe('bounded comparison performance fixtures', () => {
+ it('AUD-14 projects near-limit one-sided descriptors within a bounded candidate budget', () => {
+ const editor = createComparisonTestEditor('placeholder')
+ try {
+ const headings = Array.from({ length: 6490 }, (_value, index) => (
+ editor.schema.nodes.heading!.create({ level: 1 }, editor.schema.text(`Section ${index}`))
+ ))
+ const populated = editor.schema.nodes.doc!.create(null, headings)
+ const empty = editor.schema.nodes.doc!.create()
+ const model = createHierarchicalMarkdownComparisonModel(populated, empty)
+ const descriptors = model.edits.flatMap(({ descriptors: members }) => members)
+
+ const prepared = prepareComparisonDecorations(populated, descriptors, 'before')
+
+ expect(prepared).toHaveLength(headings.length)
+ } finally {
+ editor.destroy()
+ }
+ })
+
+ it('P01 compares a near-6500-line exact-anchor document with negligible weighted work', () => {
+ const editor = createComparisonTestEditor('placeholder')
+ try {
+ const headings = Array.from({ length: 6490 }, (_value, index) => (
+ editor.schema.nodes.heading!.create({ level: 1 }, editor.schema.text(`Section ${index}`))
+ ))
+ const before = editor.schema.nodes.doc!.create(null, headings)
+ const changedHeading = editor.schema.nodes.heading!.create(
+ { level: 1 },
+ editor.schema.text('Section 3245 edited'),
+ )
+ const after = editor.schema.nodes.doc!.create(null, headings.with(3245, changedHeading))
+
+ const model = createHierarchicalMarkdownComparisonModel(before, after)
+
+ expect(model.edits).toHaveLength(1)
+
+ const work = createComparisonWorkLedger()
+ const axis = Array.from({ length: 6490 }, (_value, index) => ({
+ key: `anchor:${index}`,
+ profile: [`anchor:${index}`],
+ }))
+ const changed = axis.with(3245, { key: 'changed:3245', profile: ['changed:3245'] })
+ alignComparisonAxis(axis, changed, options(work))
+ expect(work).toEqual(createComparisonWorkLedger())
+ } finally {
+ editor.destroy()
+ }
+ })
+
+ it.each(['insert', 'delete'] as const)('places a near-6500-line one-sided %s axis in linear time', (operation) => {
+ const editor = createComparisonTestEditor('placeholder')
+ try {
+ const headings = Array.from({ length: 6490 }, (_value, index) => (
+ editor.schema.nodes.heading!.create({ level: 1 }, editor.schema.text(`Section ${index}`))
+ ))
+ const empty = editor.schema.nodes.doc!.create()
+ const populated = editor.schema.nodes.doc!.create(null, headings)
+ const model = operation === 'insert'
+ ? createHierarchicalMarkdownComparisonModel(empty, populated)
+ : createHierarchicalMarkdownComparisonModel(populated, empty)
+
+ expect(model.edits).toHaveLength(headings.length)
+ expect(model.edits.every(({ primary }) => primary.operation === operation)).toBe(true)
+ } finally {
+ editor.destroy()
+ }
+ })
+
+ it('P04 shares the final token ledger across nested production nodes', () => {
+ const editor = createComparisonTestEditor('placeholder')
+ try {
+ const firstBeforeCount = 100
+ const firstAfterCount = firstBeforeCount - 1
+ const firstProduct = firstBeforeCount * firstAfterCount
+ const firstLength = Math.floor(DEFAULT_COMPARISON_TOKEN_LEDGER / (4 * firstProduct))
+ const firstCharge = 2 * firstProduct * firstLength
+ const secondCount = 100
+ const secondLength = Math.floor((DEFAULT_COMPARISON_TOKEN_LEDGER - firstCharge) / (2 * secondCount ** 2)) + 1
+ const paragraphs = (count: number, character: string, length: number) => Array.from(
+ { length: count },
+ () => editor.schema.nodes.paragraph!.create(null, editor.schema.text(character.repeat(length))),
+ )
+ const quote = (children: readonly Node[]) => (
+ editor.schema.nodes.blockquote!.create(null, children)
+ )
+ const anchor = editor.schema.nodes.paragraph!.create(null, editor.schema.text('exact nested boundary anchor'))
+ const before = editor.schema.nodes.doc!.create(null, [
+ quote(paragraphs(firstBeforeCount, 'a', firstLength)),
+ anchor,
+ quote(paragraphs(secondCount, 'c', secondLength)),
+ ])
+ const after = editor.schema.nodes.doc!.create(null, [
+ quote(paragraphs(firstAfterCount, 'b', firstLength)),
+ anchor,
+ quote(paragraphs(secondCount, 'd', secondLength)),
+ ])
+ const model = createHierarchicalMarkdownComparisonModel(before, after)
+
+ expect(2 * secondCount ** 2 * (secondLength - 1)).toBeLessThanOrEqual(DEFAULT_COMPARISON_TOKEN_LEDGER - firstCharge)
+ expect(2 * secondCount ** 2 * secondLength).toBeGreaterThan(DEFAULT_COMPARISON_TOKEN_LEDGER - firstCharge)
+ expect(model.edits.map(({ primary }) => primary.coarseReason)).toEqual([
+ 'ambiguous-attribution',
+ 'comparison-limit',
+ ])
+ } finally {
+ editor.destroy()
+ }
+ })
+
+ it('P03 bounds many aggregate maximal gaps with one comparison-wide ledger', () => {
+ const gapCount = 5
+ const gapSize = 200
+ const before: Item[] = []
+ const after: Item[] = []
+ for (let gap = 0; gap < gapCount; gap++) {
+ before.push(...items(gapSize, `before-${gap}`))
+ after.push(...items(gapSize, `after-${gap}`))
+ if (gap < gapCount - 1) {
+ const anchor = { key: `anchor-${gap}`, profile: [`anchor-${gap}`] }
+ before.push(anchor)
+ after.push(anchor)
+ }
+ }
+ const work = createComparisonWorkLedger()
+
+ const result = alignComparisonAxis(before, after, options(work))
+ const limited = result.filter((region) => 'coarseReason' in region && region.coarseReason === 'comparison-limit')
+
+ expect(work.remainingCells).toBe(0)
+ expect(limited).toHaveLength(gapCount - 1)
+ })
+})
diff --git a/src/tests/comparison/comparisonPresentation.spec.ts b/src/tests/comparison/comparisonPresentation.spec.ts
new file mode 100644
index 00000000000..92be57d563f
--- /dev/null
+++ b/src/tests/comparison/comparisonPresentation.spec.ts
@@ -0,0 +1,28 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { ComparisonAttributeCode, ComparisonSignal } from '../../comparison/markdownComparisonTypes.ts'
+
+import { describe, expect, it } from 'vitest'
+import { selectComparisonSignal } from '../../comparison/comparisonPresentation.ts'
+
+const bold: ComparisonSignal = { type: 'mark', mark: 'bold', change: 'added' }
+const attribute = (code: ComparisonAttributeCode): ComparisonSignal => ({ type: 'attribute', attribute: code, change: 'changed' })
+
+describe('AUD-10 comparison presentation', () => {
+ it('selects the same strongest attribute regardless of descriptor storage order', () => {
+ const signals = [bold, attribute('image-alt'), attribute('image-target')]
+ expect(selectComparisonSignal(signals)).toEqual(attribute('image-target'))
+ expect(selectComparisonSignal([...signals].reverse())).toEqual(attribute('image-target'))
+ })
+
+ it('prioritizes every specific attribute and node structure over generic formatting', () => {
+ for (const code of ['link', 'task-state', 'heading-level', 'table-span', 'unknown-attribute'] as const) {
+ expect(selectComparisonSignal([bold, attribute(code)])).toEqual(attribute(code))
+ }
+ const node: ComparisonSignal = { type: 'node' }
+ expect(selectComparisonSignal([bold, node])).toEqual(node)
+ })
+})
diff --git a/src/tests/comparison/comparisonSections.spec.ts b/src/tests/comparison/comparisonSections.spec.ts
new file mode 100644
index 00000000000..2dd787ba6f4
--- /dev/null
+++ b/src/tests/comparison/comparisonSections.spec.ts
@@ -0,0 +1,76 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { Node } from '@tiptap/pm/model'
+import type { ComparisonDescriptor, ComparisonEdit } from '../../comparison/markdownComparisonTypes.ts'
+
+import { schema } from 'prosemirror-schema-basic'
+import { describe, expect, it } from 'vitest'
+import { buildComparisonSections, headingLocations, nearestHeading } from '../../comparison/comparisonSections.ts'
+
+function doc(...blocks: Array<[type: 'heading' | 'paragraph', text: string]>): Node {
+ return schema.node('doc', null, blocks.map(([type, text]) => schema.node(type, type === 'heading' ? { level: 1 } : null, text ? schema.text(text) : undefined)))
+}
+
+function descriptor(id: string, operation: ComparisonDescriptor['operation'], before: number, after: number): ComparisonDescriptor {
+ return {
+ id,
+ operation,
+ detail: 'inline',
+ facets: ['text'],
+ before: { from: before, to: before + 1 },
+ after: { from: after, to: after + 1 },
+ context: {
+ before: { code: 'paragraph', path: [1], from: before, to: before + 1 },
+ after: { code: 'paragraph', path: [1], from: after, to: after + 1 },
+ },
+ preview: { before: null, after: null },
+ signals: [],
+ }
+}
+
+function edit(id: string, primary: ComparisonDescriptor, members: ComparisonDescriptor[] = [primary]): ComparisonEdit {
+ return { id, kind: 'content', primary, descriptors: members }
+}
+
+describe('edit-first comparison sections', () => {
+ it('finds ordered headings and resolves the nearest preceding heading', () => {
+ const document = doc(['paragraph', 'Intro'], ['heading', 'One'], ['paragraph', 'Body'], ['heading', 'Two'])
+ const headings = headingLocations(document)
+ expect(headings.map(({ text }) => text)).toEqual(['One', 'Two'])
+ expect(nearestHeading(headings, 0)).toBe('')
+ expect(nearestHeading(headings, headings[1]!.from)).toBe('Two')
+ })
+
+ it('builds one row source per edit', () => {
+ const before = doc(['heading', 'Alpha'], ['paragraph', 'Before'])
+ const after = doc(['heading', 'Alpha'], ['paragraph', 'After'])
+ const headingEnd = after.child(0).nodeSize
+ const primary = descriptor('d-primary', 'replace', headingEnd, headingEnd)
+ const formatting = { ...descriptor('d-format', 'replace', headingEnd, headingEnd), facets: ['formatting'] as const }
+ const sections = buildComparisonSections([edit('edit-1', primary, [formatting, primary])], before, after)
+
+ expect(sections).toEqual([expect.objectContaining({
+ id: 'edit-1',
+ title: 'Alpha',
+ edits: [expect.objectContaining({ id: 'edit-1', primary })],
+ })])
+ })
+
+ it('uses Before context for deletions and the After title for a correlated rename', () => {
+ const before = doc(['heading', 'Old'], ['paragraph', 'Before'])
+ const after = doc(['heading', 'New'], ['paragraph', 'After'])
+ const beforeBody = before.child(0).nodeSize
+ const afterBody = after.child(0).nodeSize
+ const rename = descriptor('rename', 'replace', 0, 0)
+ rename.context.before = { code: 'heading', path: [0], from: 0, to: beforeBody }
+ rename.context.after = { code: 'heading', path: [0], from: 0, to: afterBody }
+ const deletion = descriptor('delete', 'delete', beforeBody, afterBody)
+ const sections = buildComparisonSections([edit('rename-edit', rename), edit('delete-edit', deletion)], before, after)
+
+ expect(sections.map(({ title }) => title)).toEqual(['New'])
+ expect(sections[0]!.edits.map(({ id }) => id)).toEqual(['rename-edit', 'delete-edit'])
+ })
+})
diff --git a/src/tests/comparison/comparisonTestEditor.ts b/src/tests/comparison/comparisonTestEditor.ts
new file mode 100644
index 00000000000..103a67e7973
--- /dev/null
+++ b/src/tests/comparison/comparisonTestEditor.ts
@@ -0,0 +1,19 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { createComparisonEditor } from '../../comparison/createComparisonEditor.ts'
+
+export function createComparisonTestEditor(content: string) {
+ return createComparisonEditor(content, { noLazyImages: true })
+}
+
+export function comparisonTestDocument(content: string) {
+ const editor = createComparisonEditor(content, { noLazyImages: true })
+ try {
+ return editor.state.doc
+ } finally {
+ editor.destroy()
+ }
+}
diff --git a/src/tests/comparison/createComparisonEditor.spec.ts b/src/tests/comparison/createComparisonEditor.spec.ts
new file mode 100644
index 00000000000..cda29bf339d
--- /dev/null
+++ b/src/tests/comparison/createComparisonEditor.spec.ts
@@ -0,0 +1,28 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { describe, expect, it } from 'vitest'
+import { createComparisonEditor } from '../../comparison/createComparisonEditor.ts'
+
+describe('comparison editor', () => {
+ it('creates a complete immutable detached Text editor with directional paragraphs', () => {
+ const editor = createComparisonEditor('English\n\nالعربية')
+ try {
+ expect(editor.options.element).toBeInstanceOf(HTMLElement)
+ expect((editor.options.element as HTMLElement).isConnected).toBe(false)
+ expect(editor.isEditable).toBe(false)
+ expect(editor.state.doc.textContent).toBe('Englishالعربية')
+ const directions: Array = []
+ editor.state.doc.descendants((node) => {
+ if (node.type.name === 'paragraph') {
+ directions.push(node.attrs.dir as string | null)
+ }
+ })
+ expect(directions.slice(0, 2)).toEqual(['ltr', 'rtl'])
+ } finally {
+ editor.destroy()
+ }
+ })
+})
diff --git a/src/tests/comparison/createMarkdownContentComparison.spec.ts b/src/tests/comparison/createMarkdownContentComparison.spec.ts
new file mode 100644
index 00000000000..53c3fd57479
--- /dev/null
+++ b/src/tests/comparison/createMarkdownContentComparison.spec.ts
@@ -0,0 +1,281 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { Editor } from '@tiptap/vue-3'
+import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from 'vitest'
+import { nextTick } from 'vue'
+import * as markdownComparison from '../../comparison/markdownComparison.ts'
+import { createMarkdownContentComparison } from '../../createMarkdownContentComparison.ts'
+
+const originalScrollTo = HTMLElement.prototype.scrollTo
+
+beforeAll(async () => {
+ HTMLElement.prototype.scrollTo = vi.fn()
+ await Promise.all([
+ import('../../components/MarkdownContentComparison.vue'),
+ import('../../components/MarkdownSourceFallback.vue'),
+ ])
+})
+
+afterAll(() => {
+ if (originalScrollTo) {
+ HTMLElement.prototype.scrollTo = originalScrollTo
+ } else {
+ delete (HTMLElement.prototype as Partial).scrollTo
+ }
+})
+
+afterEach(() => vi.restoreAllMocks())
+
+describe('Markdown comparison factory fallback and lifecycle', () => {
+ it('V09 reports syntax-only Markdown as no semantic edit and opens Source', async () => {
+ const el = document.createElement('div')
+ const instance = await createMarkdownContentComparison({
+ beforeContent: '*same rendered text*',
+ afterContent: '_same rendered text_',
+ el,
+ })
+
+ expect(el.querySelectorAll('[data-comparison-change]')).toHaveLength(0)
+ expect(el.querySelector('[role="status"]')?.textContent).toContain('No rendered differences')
+ const openSource = el.querySelector('[data-comparison-empty-action]')
+ expect(openSource).not.toBeNull()
+ openSource!.click()
+ await nextTick()
+ expect([...el.querySelectorAll('[role="tab"]')]
+ .find(({ textContent }) => textContent?.trim() === 'Markdown source')
+ ?.getAttribute('aria-selected')).toBe('true')
+ instance.destroy()
+ })
+
+ it('F05 remounts complete Source when rendered editor initialization fails', async () => {
+ vi.spyOn(Editor.prototype, 'mount').mockImplementation(() => {
+ throw new Error('forced mount failure')
+ })
+ const el = document.createElement('div')
+ const instance = await createMarkdownContentComparison({ beforeContent: 'before', afterContent: 'after', el })
+ expect(el.querySelector('[data-comparison-source-fallback]')).not.toBeNull()
+ expect(el.querySelectorAll('.ProseMirror')).toHaveLength(0)
+ expect(el.textContent).toContain('before')
+ expect(el.textContent).toContain('after')
+ instance.destroy()
+ instance.destroy()
+ expect(el.childElementCount).toBe(0)
+ })
+
+ it('F06 remounts complete Source without partial Documents when projection fails', async () => {
+ const originalSetAttribute = Element.prototype.setAttribute
+ vi.spyOn(Element.prototype, 'setAttribute').mockImplementation(function(this: Element, name, value) {
+ if (name === 'data-comparison-change') {
+ throw new Error('forced projection failure')
+ }
+ return originalSetAttribute.call(this, name, value)
+ })
+ const beforeContent = 'Complete projection before'
+ const afterContent = 'Complete projection after'
+ const el = document.createElement('div')
+ const instance = await createMarkdownContentComparison({ beforeContent, afterContent, el })
+ const fullDocuments = [...el.querySelectorAll('[role="tab"]')]
+ .find(({ textContent }) => textContent?.trim() === 'Full documents')
+
+ fullDocuments!.click()
+ await vi.waitFor(() => {
+ expect(el.querySelector('[data-comparison-source-fallback]')).not.toBeNull()
+ })
+ expect(el.querySelectorAll('.text-comparison__documents .ProseMirror')).toHaveLength(0)
+ expect(el.textContent).toContain(beforeContent)
+ expect(el.textContent).toContain(afterContent)
+ instance.destroy()
+ })
+
+ it('V12 can reopen the same pair after idempotent destroy without leaking root DOM', async () => {
+ const el = document.createElement('div')
+ for (let index = 0; index < 2; index++) {
+ const instance = await createMarkdownContentComparison({ beforeContent: 'Before', afterContent: 'After', el })
+ expect(el.querySelectorAll('.text-comparison-root')).toHaveLength(1)
+ instance.destroy()
+ instance.destroy()
+ expect(el.childElementCount).toBe(0)
+ }
+ })
+
+ it('keeps both document editors alive while switching views', async () => {
+ const el = document.createElement('div')
+ const instance = await createMarkdownContentComparison({ beforeContent: 'Before', afterContent: 'After', el })
+ expect(el.querySelectorAll('.ProseMirror')).toHaveLength(0)
+ expect(el.querySelectorAll('[data-comparison-source-fallback]')).toHaveLength(0)
+ const selectTab = async (label: string) => {
+ const tab = [...el.querySelectorAll('[role="tab"]')]
+ .find(({ textContent }) => textContent?.trim() === label)
+ expect(tab).toBeDefined()
+ tab!.click()
+ await nextTick()
+ }
+
+ await selectTab('Full documents')
+ expect(el.querySelectorAll('.ProseMirror')).toHaveLength(2)
+ await selectTab('Changes')
+ await selectTab('Full documents')
+
+ expect(el.querySelector('.text-comparison > [data-comparison-source-fallback]')).toBeNull()
+ expect(el.querySelectorAll('.ProseMirror')).toHaveLength(2)
+ instance.destroy()
+ })
+
+ it('omits duplicate heading anchors from the two comparison documents', async () => {
+ const el = document.createElement('div')
+ const instance = await createMarkdownContentComparison({
+ beforeContent: '# Shared heading\n\nBefore',
+ afterContent: '# Shared heading\n\nAfter',
+ el,
+ })
+ const documents = [...el.querySelectorAll('[role="tab"]')]
+ .find(({ textContent }) => textContent?.trim() === 'Full documents')
+
+ documents!.click()
+ await nextTick()
+
+ await vi.waitFor(() => expect(el.querySelectorAll('.ProseMirror')).toHaveLength(2))
+ await new Promise((resolve) => setTimeout(resolve, 0))
+ expect(el.querySelectorAll('.text-comparison__documents .heading-anchor[id]')).toHaveLength(0)
+ instance.destroy()
+ })
+
+ it('AUD-02 publishes the current selection when Documents mounts lazily', async () => {
+ const originalScrollTo = HTMLElement.prototype.scrollTo
+ const scrollTo = vi.fn()
+ HTMLElement.prototype.scrollTo = scrollTo
+ const el = document.createElement('div')
+ const instance = await createMarkdownContentComparison({
+ beforeContent: 'Old first.\n\nOld second.',
+ afterContent: 'New first.\n\nNew second.',
+ el,
+ })
+ const secondEdit = el.querySelectorAll('[data-comparison-select]')[1]
+
+ secondEdit!.click()
+ await vi.waitFor(() => {
+ expect(el.querySelectorAll('[data-comparison-change="change-1"][aria-current="true"]')).toHaveLength(2)
+ })
+ await vi.waitFor(() => expect(scrollTo).toHaveBeenCalled())
+ instance.destroy()
+ if (originalScrollTo) {
+ HTMLElement.prototype.scrollTo = originalScrollTo
+ } else {
+ delete (HTMLElement.prototype as Partial).scrollTo
+ }
+ })
+
+ it('AUD-11 locates the current edit on the newly visible side after a single-to-paired resize', async () => {
+ const originalResizeObserver = globalThis.ResizeObserver
+ const originalScrollTo = HTMLElement.prototype.scrollTo
+ const scrollTo = vi.fn()
+ let resizeTo!: (width: number) => void
+ HTMLElement.prototype.scrollTo = scrollTo
+ globalThis.ResizeObserver = class {
+ constructor(private readonly callback: ResizeObserverCallback) {}
+
+ observe(target: Element) {
+ resizeTo = (width) => this.callback([{ target, contentRect: { width } } as ResizeObserverEntry], this)
+ resizeTo(600)
+ }
+
+ disconnect() {}
+
+ unobserve() {}
+ } as typeof ResizeObserver
+ const el = document.createElement('div')
+ const instance = await createMarkdownContentComparison({
+ beforeContent: 'Old first.\n\nOld second.',
+ afterContent: 'New first.\n\nNew second.',
+ el,
+ })
+ try {
+ el.querySelectorAll('[data-comparison-select]')[1]!.click()
+ await vi.waitFor(() => expect(el.querySelector('.text-comparison--single')).not.toBeNull())
+ const afterScroller = el.querySelector('.text-comparison__document--after .text-comparison__document-scroller')!
+ await vi.waitFor(() => expect(scrollTo).toHaveBeenCalled())
+ expect(scrollTo.mock.contexts).not.toContain(afterScroller)
+
+ resizeTo(900)
+ await vi.waitFor(() => expect(el.querySelector('.text-comparison--paired')).not.toBeNull())
+
+ expect(scrollTo.mock.contexts).toContain(afterScroller)
+ } finally {
+ instance.destroy()
+ globalThis.ResizeObserver = originalResizeObserver
+ if (originalScrollTo) {
+ HTMLElement.prototype.scrollTo = originalScrollTo
+ } else {
+ delete (HTMLElement.prototype as Partial).scrollTo
+ }
+ }
+ })
+
+ it('keeps the working comparison when the loaded callback throws', async () => {
+ const el = document.createElement('div')
+ const creation = createMarkdownContentComparison({
+ beforeContent: 'Before',
+ afterContent: 'After',
+ el,
+ onLoaded: () => { throw new Error('callback failure') },
+ })
+ const instance = await Promise.race([
+ creation,
+ new Promise((resolve) => setTimeout(() => resolve(null), 1000)),
+ ])
+ expect(instance).not.toBeNull()
+ expect(el.querySelector('.text-comparison')).not.toBeNull()
+ expect(el.querySelector('[data-comparison-source-fallback]')).toBeNull()
+ instance?.destroy()
+ })
+
+ it('AUD-21 awaits a rejected loaded callback and keeps the working comparison', async () => {
+ const el = document.createElement('div')
+ let rejectLoaded!: (error: Error) => void
+ const onLoaded = vi.fn(() => new Promise((_resolve, reject) => {
+ rejectLoaded = reject
+ }))
+ const creation = createMarkdownContentComparison({
+ beforeContent: 'Before',
+ afterContent: 'After',
+ el,
+ onLoaded,
+ })
+ let creationSettled = false
+ void creation.then(() => {
+ creationSettled = true
+ })
+ await new Promise((resolve) => setTimeout(resolve, 0))
+
+ expect(onLoaded).toHaveBeenCalledOnce()
+ expect(creationSettled).toBe(false)
+ rejectLoaded(new Error('async callback failure'))
+ const instance = await creation
+
+ expect(el.querySelector('.text-comparison')).not.toBeNull()
+ expect(el.querySelector('[data-comparison-source-fallback]')).toBeNull()
+ instance.destroy()
+ })
+
+ it('F07 routes a descriptor model limit to complete Source', async () => {
+ vi.spyOn(markdownComparison, 'createMarkdownComparisonModel').mockImplementation(() => {
+ throw new markdownComparison.ComparisonModelLimitError()
+ })
+ const beforeContent = '# Complete before snapshot\n\nBefore body\n'
+ const afterContent = '# Complete after snapshot\n\nAfter body\n'
+ const el = document.createElement('div')
+
+ const instance = await createMarkdownContentComparison({ beforeContent, afterContent, el })
+
+ expect(el.querySelector('[data-comparison-source-fallback]')).not.toBeNull()
+ expect(el.querySelectorAll('.ProseMirror')).toHaveLength(0)
+ expect(el.textContent).toContain('Detailed rendered comparison unavailable')
+ expect(el.textContent).not.toContain('No rendered changes')
+ expect(el.textContent).toContain(beforeContent)
+ expect(el.textContent).toContain(afterContent)
+ instance.destroy()
+ })
+})
diff --git a/src/tests/comparison/hierarchicalMarkdownComparison.spec.ts b/src/tests/comparison/hierarchicalMarkdownComparison.spec.ts
new file mode 100644
index 00000000000..88ac12c2f13
--- /dev/null
+++ b/src/tests/comparison/hierarchicalMarkdownComparison.spec.ts
@@ -0,0 +1,363 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { Node } from '@tiptap/pm/model'
+import type { ComparisonEdit, ComparisonSide } from '../../comparison/markdownComparisonTypes.ts'
+
+import { Schema } from '@tiptap/pm/model'
+import { schema as basicSchema } from 'prosemirror-schema-basic'
+import { describe, expect, it } from 'vitest'
+import {
+ ComparisonModelLimitError,
+ createHierarchicalMarkdownComparisonModel,
+ MAX_INLINE_ENVELOPE_SIZE,
+ MAX_RENDERED_COMPARISON_DESCRIPTORS,
+} from '../../comparison/hierarchicalMarkdownComparisonModel.ts'
+import { comparisonTestDocument, createComparisonTestEditor } from './comparisonTestEditor.ts'
+
+function compare(beforeContent: string, afterContent: string) {
+ const before = comparisonTestDocument(beforeContent)
+ const after = comparisonTestDocument(afterContent)
+ return {
+ before,
+ after,
+ model: createHierarchicalMarkdownComparisonModel(before, after),
+ }
+}
+
+function meaningfulSize(doc: Node) {
+ return doc.content.size - (doc.lastChild?.content.size === 0 ? doc.lastChild.nodeSize : 0)
+}
+
+function editText(doc: { textBetween: (from: number, to: number, separator: string) => string }) {
+ return (edit: ComparisonEdit, side: ComparisonSide) => (
+ doc.textBetween(edit.primary[side].from, edit.primary[side].to, '\n')
+ )
+}
+
+describe('hierarchical markdown comparison', () => {
+ it('A01 emits no edit for two equal documents', () => {
+ const { model } = compare('# Title\n\nBody text.\n', '# Title\n\nBody text.\n')
+
+ expect(model.edits).toEqual([])
+ })
+
+ it('A02 normalizes separate schema instances without position or content drift', () => {
+ const beforeEditor = createComparisonTestEditor('# Title\n\nOriginal body.\n')
+ const afterEditor = createComparisonTestEditor('# Title\n\nUpdated body.\n')
+ try {
+ const before = beforeEditor.state.doc
+ const after = afterEditor.state.doc
+ expect(before.type.schema).not.toBe(after.type.schema)
+
+ const model = createHierarchicalMarkdownComparisonModel(before, after)
+
+ expect(model.edits).toHaveLength(1)
+ const [edit] = model.edits
+ expect(before.textBetween(edit!.primary.before.from, edit!.primary.before.to)).toBe('Original')
+ expect(after.textBetween(edit!.primary.after.from, edit!.primary.after.to)).toBe('Updated')
+ } finally {
+ beforeEditor.destroy()
+ afterEditor.destroy()
+ }
+ })
+
+ it('AUD-19 rejects cross-schema normalization that drops node attributes', () => {
+ const paragraph = basicSchema.spec.nodes.get('paragraph')!
+ const beforeSchema = new Schema({
+ nodes: basicSchema.spec.nodes.update('paragraph', { ...paragraph, attrs: { audit: { default: null } } }),
+ marks: basicSchema.spec.marks,
+ })
+ const afterSchema = new Schema({ nodes: basicSchema.spec.nodes, marks: basicSchema.spec.marks })
+ const before = beforeSchema.node('doc', null, [beforeSchema.node('paragraph', { audit: 'must-survive' }, beforeSchema.text('same'))])
+ const after = afterSchema.node('doc', null, [afterSchema.node('paragraph', null, afterSchema.text('same'))])
+
+ expect(() => createHierarchicalMarkdownComparisonModel(before, after)).toThrow(/schema normalization lost semantics/)
+ })
+
+ it('A05 retains the first repeated paragraph and inserts the second copy', () => {
+ const { after, model } = compare('Anchor\n\nSame\n', 'Anchor\n\nSame\n\nSame\n')
+ const text = editText(after)
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]!.primary.operation).toBe('insert')
+ expect(text(model.edits[0]!, 'after')).toBe('Same')
+ expect(model.edits[0]!.primary.after).toEqual({
+ from: after.child(0).nodeSize + after.child(1).nodeSize,
+ to: meaningfulSize(after),
+ })
+ })
+
+ it('A06 retains the first repeated paragraph and deletes the second copy', () => {
+ const { before, model } = compare('Anchor\n\nSame\n\nSame\n', 'Anchor\n\nSame\n')
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]!.primary.operation).toBe('delete')
+ expect(model.edits[0]!.primary.before).toEqual({
+ from: before.child(0).nodeSize + before.child(1).nodeSize,
+ to: meaningfulSize(before),
+ })
+ })
+
+ it.each([
+ ['insertion', '# Existing\n', '## Added\n\n# Existing\n', 'insert'],
+ ['deletion', '## Removed\n\n# Existing\n', '# Existing\n', 'delete'],
+ ] as const)('AUD-12 reports a heading %s as added or removed without adjacent heading attributes', (_name, beforeContent, afterContent, operation) => {
+ const { model } = compare(beforeContent, afterContent)
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]!.primary.operation).toBe(operation)
+ expect(model.edits[0]!.primary.signals).not.toContainEqual(expect.objectContaining({
+ type: 'attribute',
+ attribute: 'heading-level',
+ }))
+ })
+
+ it('A07 reports a paragraph turning into a heading as one semantic replacement', () => {
+ const { model } = compare('Shared title\n', '# Shared title\n')
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({
+ kind: 'content',
+ primary: {
+ detail: 'block',
+ operation: 'replace',
+ context: { before: { code: 'paragraph' }, after: { code: 'heading' } },
+ },
+ })
+ expect(model.edits[0]!.primary.facets).toContain('structure')
+ expect(model.edits[0]!.primary.signals).toContainEqual({
+ type: 'attribute',
+ attribute: 'heading-level',
+ change: 'added',
+ })
+ })
+
+ it('A08 does not pair incompatible non-text containers', () => {
+ const { model } = compare('- Shared item\n', '> Shared item\n')
+
+ expect(model.edits).toHaveLength(2)
+ expect(model.edits.map(({ primary }) => primary.operation).toSorted()).toEqual(['delete', 'insert'])
+ })
+
+ it.each([
+ ['section headings', '# Setup\n\n# Usage\n\n# Notes\n', '# Install\n\n# Config\n'],
+ ['shopping items', 'Buy milk\n\nBuy eggs\n\nBuy rice\n', 'Get bread\n\nGet jam\n'],
+ ])('A10 coarsens a no-affix %s rewrite', (_name, beforeContent, afterContent) => {
+ const { before, after, model } = compare(beforeContent, afterContent)
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]!.primary).toMatchObject({
+ coarseReason: 'ambiguous-attribution',
+ detail: 'block',
+ operation: 'replace',
+ before: { from: 0, to: meaningfulSize(before) },
+ after: { from: 0, to: meaningfulSize(after) },
+ })
+ })
+
+ it('reports one reordered block as one move edit', () => {
+ const { model } = compare(
+ 'Unique alpha\n\nUnique beta\n\nUnique gamma\n',
+ 'Unique beta\n\nUnique gamma\n\nUnique alpha\n',
+ )
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]!.primary).toMatchObject({
+ operation: 'move',
+ detail: 'block',
+ facets: ['structure'],
+ })
+ })
+
+ it('pairs uniquely compatible changed containers instead of coarsening their shared gap', () => {
+ const before = [
+ '# Operational notes',
+ '',
+ '> Draft maintenance window starts at 20:00.',
+ '',
+ '::: info',
+ 'The canary is limited to one region.',
+ ':::',
+ '',
+ '',
+ 'Draft runbook
',
+ '',
+ 'Rollback after two failed health checks.',
+ '',
+ '',
+ '',
+ ].join('\n')
+ const after = [
+ '# Operational notes',
+ '',
+ '> Approved maintenance window starts at 21:00.',
+ '',
+ '::: warn',
+ 'The canary is limited to two regions.',
+ ':::',
+ '',
+ '',
+ 'Approved runbook
',
+ '',
+ 'Rollback after one failed health check.',
+ '',
+ '',
+ '',
+ ].join('\n')
+ const { model } = compare(before, after)
+ const attributes = model.edits.flatMap(({ descriptors }) => descriptors)
+ .flatMap(({ signals }) => signals)
+ .filter((signal) => signal.type === 'attribute')
+ .map(({ attribute }) => attribute)
+ const primaryAttributes = model.edits
+ .flatMap(({ primary }) => primary.signals)
+ .filter((signal) => signal.type === 'attribute')
+ .map(({ attribute }) => attribute)
+
+ expect(model.edits.length).toBeGreaterThan(3)
+ expect(model.edits.every(({ primary }) => primary.coarseReason === undefined)).toBe(true)
+ expect(attributes).toContain('callout-type')
+ expect(attributes).toContain('details-state')
+ expect(primaryAttributes.filter((attribute) => attribute === 'callout-type')).toHaveLength(1)
+ expect(primaryAttributes.filter((attribute) => attribute === 'details-state')).toHaveLength(1)
+ })
+
+ it('does not label code content edits as language changes', () => {
+ const { model } = compare(
+ '```javascript\nconst stage = "draft"\n```\n',
+ '```typescript\nconst stage = "ready"\n```\n',
+ )
+ const languageEdits = model.edits.filter(({ primary }) => primary.signals.some((signal) => (
+ signal.type === 'attribute' && signal.attribute === 'code-language'
+ )))
+
+ expect(languageEdits).toHaveLength(1)
+ expect(model.edits.some(({ primary }) => (
+ primary.preview.before?.kind === 'text'
+ && primary.preview.before.text === 'draft'
+ && primary.signals.every((signal) => signal.type !== 'attribute' || signal.attribute !== 'code-language')
+ ))).toBe(true)
+ })
+
+ it('expands front-matter previews to complete changed lines', () => {
+ const { model } = compare([
+ '---',
+ 'release: atlas-2.4',
+ 'status: draft',
+ 'owner: Maya Chen',
+ 'tags: [payments, canary]',
+ 'legacy: true',
+ '---',
+ '',
+ '# Release record',
+ ].join('\n'), [
+ '---',
+ 'release: atlas-2.4.1',
+ 'status: approved',
+ 'owner: Noor Rahman',
+ 'tags: [payments, canary, customer-visible]',
+ 'approved-at: 2026-08-30T21:00:00+07:00',
+ '---',
+ '',
+ '# Release record',
+ ].join('\n'))
+ const previews = model.edits
+ .filter(({ primary }) => primary.context.before?.code === 'front-matter')
+ .map(({ primary }) => [primary.preview.before, primary.preview.after])
+ .flat()
+ .map((preview) => preview?.kind === 'text' ? preview.text : '')
+
+ expect(previews).toHaveLength(4)
+ expect(previews[0]).toMatch(/^release: atlas-2\.4\b/)
+ expect(previews[1]).toMatch(/^release: atlas-2\.4\.1\b/)
+ expect(previews[2]).toMatch(/^tags: \[payments, canary\]/)
+ expect(previews[3]).toMatch(/^tags: \[payments, canary, customer-visible\]/)
+ })
+
+ it('moves exact repeated section content with its unique heading anchor', () => {
+ const repeated = 'Health check passed.\n\nDeploy the stable build.'
+ const before = [
+ '# Repeated deployment notes',
+ `## Region A\n\n${repeated}`,
+ `## Region B\n\n${repeated}`,
+ `## Retired region\n\n${repeated}`,
+ `## Region C\n\n${repeated}`,
+ ].join('\n\n')
+ const after = [
+ '# Repeated deployment notes',
+ `## Region C\n\n${repeated}`,
+ `## Region A\n\n${repeated}`,
+ '## New region\n\nHealth check passed.\n\nDeploy the canary build.',
+ `## Region B\n\n${repeated}`,
+ ].join('\n\n')
+ const { before: beforeDoc, after: afterDoc, model } = compare(before, after)
+ const moved = model.edits.find(({ primary }) => primary.operation === 'move')!
+ const repeatedCopies = model.edits.filter(({ primary }) => primary.operation !== 'move')
+ .map((edit) => ({
+ operation: edit.primary.operation,
+ before: beforeDoc.textBetween(edit.primary.before.from, edit.primary.before.to, '\n'),
+ after: afterDoc.textBetween(edit.primary.after.from, edit.primary.after.to, '\n'),
+ }))
+
+ expect(model.edits).toHaveLength(7)
+ expect(beforeDoc.textBetween(moved.primary.before.from, moved.primary.before.to, '\n'))
+ .toBe('Region C\nHealth check passed.\nDeploy the stable build.')
+ expect(afterDoc.textBetween(moved.primary.after.from, moved.primary.after.to, '\n'))
+ .toBe('Region C\nHealth check passed.\nDeploy the stable build.')
+ expect(repeatedCopies.filter(({ before }) => before === 'Health check passed.')).toHaveLength(1)
+ expect(repeatedCopies.filter(({ after }) => after === 'Health check passed.')).toHaveLength(1)
+ })
+
+ it('F08 keeps a large inline envelope as one rendered block change', () => {
+ const shared = 'z'.repeat(MAX_INLINE_ENVELOPE_SIZE)
+ const { before, after, model } = compare(`start ${shared}\n`, `${shared} finish\n`)
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]!.primary).toMatchObject({
+ detail: 'block',
+ before: { from: 0, to: meaningfulSize(before) },
+ after: { from: 0, to: meaningfulSize(after) },
+ })
+ })
+
+ it('accepts 10000 descriptors and rejects 10001 at the production default', () => {
+ const editor = createComparisonTestEditor('placeholder')
+ try {
+ const document = (count: number, side: 'before' | 'after') => {
+ const nodes = Array.from({ length: count }, (_value, index) => [
+ editor.schema.nodes.paragraph!.create(null, editor.schema.text(`${side} ${index}`)),
+ editor.schema.nodes.heading!.create({ level: 2 }, editor.schema.text(`Exact anchor ${index}`)),
+ ]).flat()
+ return editor.schema.nodes.doc!.create(null, nodes)
+ }
+ const before = document(MAX_RENDERED_COMPARISON_DESCRIPTORS + 1, 'before')
+ const atLimit = createHierarchicalMarkdownComparisonModel(
+ editor.schema.nodes.doc!.create(null, before.content.content.slice(0, -2)),
+ document(MAX_RENDERED_COMPARISON_DESCRIPTORS, 'after'),
+ )
+
+ expect(MAX_RENDERED_COMPARISON_DESCRIPTORS).toBe(10_000)
+ expect(atLimit.edits).toHaveLength(MAX_RENDERED_COMPARISON_DESCRIPTORS)
+ expect(() => createHierarchicalMarkdownComparisonModel(
+ before,
+ document(MAX_RENDERED_COMPARISON_DESCRIPTORS + 1, 'after'),
+ )).toThrow(ComparisonModelLimitError)
+ } finally {
+ editor.destroy()
+ }
+ })
+
+ it('freezes the model and keeps the primary inside its own descriptors', () => {
+ const { model } = compare('one\n\ntwo\n', 'one edited\n\ntwo edited\n')
+
+ expect(Object.isFrozen(model)).toBe(true)
+ expect(Object.isFrozen(model.edits)).toBe(true)
+ expect(model.edits.every((edit) => edit.descriptors.includes(edit.primary))).toBe(true)
+ expect(new Set(model.edits.map(({ id }) => id))).toHaveLength(model.edits.length)
+ expect(new Set(model.edits.flatMap(({ descriptors }) => descriptors.map(({ id }) => id))))
+ .toHaveLength(model.edits.flatMap(({ descriptors }) => descriptors).length)
+ })
+})
diff --git a/src/tests/comparison/markdownSourceComparison.spec.ts b/src/tests/comparison/markdownSourceComparison.spec.ts
new file mode 100644
index 00000000000..3af9ec62b96
--- /dev/null
+++ b/src/tests/comparison/markdownSourceComparison.spec.ts
@@ -0,0 +1,214 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { SourceDiffHunk, SourceDiffLine } from '../../comparison/markdownSourceComparison.ts'
+
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { createMarkdownSourceComparison, materializeSourceDiffGap, SOURCE_DIFF_LIMITS } from '../../comparison/markdownSourceComparison.ts'
+import { compareMarkdownSourceLines } from '../../comparison/markdownSourceComparisonProtocol.ts'
+
+afterEach(() => vi.unstubAllGlobals())
+
+describe('literal Markdown source comparison', () => {
+ const lines = (hunks: readonly SourceDiffHunk[], side: 'before' | 'after') => hunks
+ .flatMap(({ rows }) => rows.flatMap((row) => row[side] ? [row[side]] : []))
+
+ it('V10 normalizes EOL only for matching while retaining literal line facts', async () => {
+ const model = await createMarkdownSourceComparison('tab\tvalue \r\nzero\u200Bwidth\nlast', 'tab value \nzero width\nlast\n')
+ expect(model.status).toBe('ready')
+ if (model.status !== 'ready') {
+ return
+ }
+ const before = lines(model.hunks, 'before')
+ const after = lines(model.hunks, 'after')
+ expect(before[0]).toMatchObject({ text: 'tab\tvalue ', eol: 'crlf' })
+ expect(before.some(({ text }) => text.includes('\u200b'))).toBe(true)
+ expect(before.at(-1)?.eol).toBe('none')
+ expect(after.at(-1)?.eol).toBe('lf')
+ })
+
+ it('AUD-14 materializes stable paired row records with the source model', async () => {
+ const model = await createMarkdownSourceComparison('old\nsame\n', 'new\nsame\n')
+ expect(model.status).toBe('ready')
+ if (model.status !== 'ready') {
+ return
+ }
+ const hunk = model.hunks[0]!
+
+ expect(hunk.rows.map(({ before, after }) => [before?.text, after?.text])).toEqual([['old', 'new'], ['same', 'same']])
+ expect(hunk.rows).toBe(hunk.rows)
+ })
+
+ it('AUD-08 represents large collapsed gaps without retained line clones', async () => {
+ const source = Array.from({ length: 10_000 }, (_value, index) => `line ${index}`).join('\n')
+ const model = await createMarkdownSourceComparison(source, source)
+ expect(model.status).toBe('ready')
+ if (model.status !== 'ready') {
+ return
+ }
+
+ expect(model.gaps).toEqual([{
+ id: 'source-gap-0',
+ slot: 0,
+ beforeFrom: 0,
+ beforeTo: 10_000,
+ afterFrom: 0,
+ afterTo: 10_000,
+ count: 10_000,
+ }])
+ })
+
+ it('AUD-08 materializes large gaps in bounded observable pages', async () => {
+ const source = Array.from({ length: 10_000 }, (_value, index) => `line ${index}`).join('\n')
+ const model = await createMarkdownSourceComparison(source, source)
+ expect(model.status).toBe('ready')
+ if (model.status !== 'ready') {
+ return
+ }
+ const gap = model.gaps[0]!
+
+ const firstPage = materializeSourceDiffGap(source, source, gap, Number.POSITIVE_INFINITY)
+ const secondPage = materializeSourceDiffGap(source, source, gap, SOURCE_DIFF_LIMITS.maximumGapPageRows, SOURCE_DIFF_LIMITS.maximumGapPageRows)
+
+ expect(firstPage).toHaveLength(SOURCE_DIFF_LIMITS.maximumGapPageRows)
+ expect(firstPage[0]?.before).toMatchObject({ number: 1, text: 'line 0' })
+ expect(firstPage.at(-1)?.after).toMatchObject({ number: SOURCE_DIFF_LIMITS.maximumGapPageRows, text: `line ${SOURCE_DIFF_LIMITS.maximumGapPageRows - 1}` })
+ expect(secondPage).toHaveLength(SOURCE_DIFF_LIMITS.maximumGapPageRows)
+ expect(secondPage[0]?.before).toMatchObject({ number: SOURCE_DIFF_LIMITS.maximumGapPageRows + 1, text: `line ${SOURCE_DIFF_LIMITS.maximumGapPageRows}` })
+ expect(secondPage.at(-1)?.after).toMatchObject({ number: SOURCE_DIFF_LIMITS.maximumGapPageRows * 2, text: `line ${SOURCE_DIFF_LIMITS.maximumGapPageRows * 2 - 1}` })
+ })
+
+ it('falls back when visible controls exceed the source display limit', async () => {
+ const source = `${'\t'.repeat(200_000)}😀`
+
+ await expect(createMarkdownSourceComparison(source, source)).resolves.toEqual({
+ status: 'limited',
+ reason: 'size',
+ })
+ })
+
+ it('retains complete literal lines when only line endings differ', async () => {
+ const beforeSource = 'same\r\nbytes\r\n'
+ const afterSource = 'same\nbytes\n'
+ const model = await createMarkdownSourceComparison(beforeSource, afterSource)
+ expect(model.status).toBe('ready')
+ if (model.status !== 'ready') {
+ return
+ }
+ expect(model.hunks).toEqual([])
+ expect(model.gaps).toHaveLength(1)
+ const rows = materializeSourceDiffGap(beforeSource, afterSource, model.gaps[0]!)
+ expect(rows.map(({ before }: { before?: SourceDiffLine }) => ({ text: before?.text, eol: before?.eol }))).toEqual([
+ { text: 'same', eol: 'crlf' },
+ { text: 'bytes', eol: 'crlf' },
+ ])
+ expect(rows.map(({ after }: { after?: SourceDiffLine }) => ({ text: after?.text, eol: after?.eol }))).toEqual([
+ { text: 'same', eol: 'lf' },
+ { text: 'bytes', eol: 'lf' },
+ ])
+ })
+
+ it('keeps syntax-only and HTML-like changes as literal text', async () => {
+ const model = await createMarkdownSourceComparison('# Heading\n', '# Heading #\n![]()
')
+ expect(model.status).toBe('ready')
+ if (model.status !== 'ready') {
+ return
+ }
+ expect(lines(model.hunks, 'before').map(({ text }) => text)).toContain('')
+ expect(lines(model.hunks, 'after').map(({ text }) => text)).toContain('![]()
')
+ })
+
+ it('reports limits and aborts without losing the caller fallback contract', async () => {
+ await expect(createMarkdownSourceComparison('x'.repeat(SOURCE_DIFF_LIMITS.maximumCharacters + 1), ''))
+ .resolves.toEqual({ status: 'limited', reason: 'size' })
+ const controller = new AbortController()
+ controller.abort()
+ await expect(createMarkdownSourceComparison('before', 'after', controller.signal)).rejects.toMatchObject({ name: 'AbortError' })
+ })
+
+ it('V11 terminates an in-flight worker when the caller aborts', async () => {
+ const terminate = vi.fn()
+ vi.stubGlobal('Worker', class {
+ addEventListener() {}
+ removeEventListener() {}
+ postMessage() {}
+ terminate() { terminate() }
+ })
+ const controller = new AbortController()
+ const comparison = createMarkdownSourceComparison('before', 'after', controller.signal)
+ controller.abort()
+ await expect(comparison).rejects.toMatchObject({ name: 'AbortError' })
+ expect(terminate).toHaveBeenCalledOnce()
+ })
+
+ it('terminates the worker when posting the comparison request throws', async () => {
+ const failure = new Error('post failure')
+ const terminate = vi.fn()
+ vi.stubGlobal('Worker', class {
+ addEventListener() {}
+ removeEventListener() {}
+ postMessage() {
+ throw failure
+ }
+
+ terminate() { terminate() }
+ })
+
+ await expect(createMarkdownSourceComparison('before', 'after')).rejects.toBe(failure)
+ expect(terminate).toHaveBeenCalledOnce()
+ })
+
+ it('rejects message decoding errors once and ignores a late success', async () => {
+ const workers: Array<{ onmessage?: EventListener, onmessageerror?: EventListener }> = []
+ const terminate = vi.fn()
+ vi.stubGlobal('Worker', class {
+ onmessage?: EventListener
+ onmessageerror?: EventListener
+ constructor() {
+ workers.push(this)
+ }
+
+ postMessage() {}
+
+ terminate() { terminate() }
+ })
+ const comparison = createMarkdownSourceComparison('before', 'after')
+
+ expect(workers[0]!.onmessageerror).toBeTypeOf('function')
+ workers[0]!.onmessageerror!(new MessageEvent('messageerror'))
+ workers[0]!.onmessage!(new MessageEvent('message', { data: { status: 'ready', changes: [] } }))
+
+ await expect(comparison).rejects.toThrow('Source comparison worker failed')
+ expect(terminate).toHaveBeenCalledOnce()
+ })
+
+ it('rejects malformed worker responses after cleanup', async () => {
+ const workers: Array<{ onmessage?: EventListener }> = []
+ const terminate = vi.fn()
+ vi.stubGlobal('Worker', class {
+ onmessage?: EventListener
+ constructor() {
+ workers.push(this)
+ }
+
+ postMessage() {}
+
+ terminate() { terminate() }
+ })
+ const comparison = createMarkdownSourceComparison('before', 'after')
+
+ workers[0]!.onmessage!(new MessageEvent('message', { data: null }))
+
+ await expect(comparison).rejects.toThrow('Source comparison worker failed')
+ expect(terminate).toHaveBeenCalledOnce()
+ })
+
+ it('uses the same bounded line protocol for main-thread and worker paths', () => {
+ expect(compareMarkdownSourceLines({ before: 'old\n', after: 'new\n', maximumEditLength: 10, timeoutMilliseconds: 1000 }))
+ .toMatchObject({ status: 'ready' })
+ expect(compareMarkdownSourceLines({ before: 'old\n', after: 'new\n', maximumEditLength: 0, timeoutMilliseconds: 1000 }))
+ .toEqual({ status: 'limited' })
+ })
+})
diff --git a/src/tests/comparison/markdownSourceComparisonWorker.spec.ts b/src/tests/comparison/markdownSourceComparisonWorker.spec.ts
new file mode 100644
index 00000000000..031caf28ae2
--- /dev/null
+++ b/src/tests/comparison/markdownSourceComparisonWorker.spec.ts
@@ -0,0 +1,30 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { SourceComparisonWorkerRequest } from '../../comparison/markdownSourceComparisonProtocol.ts'
+
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+afterEach(() => {
+ vi.resetModules()
+ vi.unstubAllGlobals()
+})
+
+describe('Markdown source comparison worker', () => {
+ it('delegates ready and limited messages to the shared protocol', async () => {
+ let listener: ((event: MessageEvent) => void) | undefined
+ const postMessage = vi.fn()
+ vi.stubGlobal('addEventListener', vi.fn((_type, callback) => {
+ listener = callback
+ }))
+ vi.stubGlobal('postMessage', postMessage)
+ await import('../../comparison/markdownSourceComparison.worker.ts')
+ expect(listener).toBeTypeOf('function')
+ listener?.(new MessageEvent('message', { data: { before: 'old\n', after: 'new\n', maximumEditLength: 10, timeoutMilliseconds: 1000 } }))
+ expect(postMessage).toHaveBeenLastCalledWith(expect.objectContaining({ status: 'ready' }))
+ listener?.(new MessageEvent('message', { data: { before: 'old\n', after: 'new\n', maximumEditLength: 0, timeoutMilliseconds: 1000 } }))
+ expect(postMessage).toHaveBeenLastCalledWith({ status: 'limited' })
+ })
+})
diff --git a/src/tests/comparison/renderedComparisonLimit.spec.ts b/src/tests/comparison/renderedComparisonLimit.spec.ts
new file mode 100644
index 00000000000..276e71aaaed
--- /dev/null
+++ b/src/tests/comparison/renderedComparisonLimit.spec.ts
@@ -0,0 +1,23 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { describe, expect, it } from 'vitest'
+import { exceedsRenderedComparisonLimit, RENDERED_COMPARISON_LIMITS } from '../../comparison/markdownComparison.ts'
+
+describe('rendered comparison preflight', () => {
+ it('accepts each exact geometry ceiling and rejects the first excess', () => {
+ const chars = RENDERED_COMPARISON_LIMITS.maximumCharactersPerSnapshot
+ const lineChars = RENDERED_COMPARISON_LIMITS.maximumCharactersPerLine
+ const line = `${'a'.repeat(lineChars - 1)}\n`
+ const source = (length: number) => line.repeat(Math.floor(length / line.length)) + 'a'.repeat(length % line.length)
+ expect(exceedsRenderedComparisonLimit(source(chars), 'after')).toBe(false)
+ expect(exceedsRenderedComparisonLimit(source(chars + 1), 'after')).toBe(true)
+ expect(exceedsRenderedComparisonLimit('a'.repeat(lineChars), 'after')).toBe(false)
+ expect(exceedsRenderedComparisonLimit('a'.repeat(lineChars + 1), 'after')).toBe(true)
+ const lines = RENDERED_COMPARISON_LIMITS.maximumLinesPerSnapshot
+ expect(exceedsRenderedComparisonLimit('x\n'.repeat(lines - 1), 'after')).toBe(false)
+ expect(exceedsRenderedComparisonLimit('x\r'.repeat(lines), 'after')).toBe(true)
+ })
+})
diff --git a/src/tests/comparison/tableGridComparison.spec.ts b/src/tests/comparison/tableGridComparison.spec.ts
new file mode 100644
index 00000000000..6d14c301559
--- /dev/null
+++ b/src/tests/comparison/tableGridComparison.spec.ts
@@ -0,0 +1,655 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { Schema } from '@tiptap/pm/model'
+import type { ComparisonEdit, ComparisonSide } from '../../comparison/markdownComparisonTypes.ts'
+
+import { Node as ProseMirrorNode } from '@tiptap/pm/model'
+import { describe, expect, it, vi } from 'vitest'
+import {
+ alignComparisonColumns,
+ DEFAULT_COMPARISON_TOKEN_LEDGER,
+} from '../../comparison/comparisonAlignment.ts'
+import { createHierarchicalMarkdownComparisonModel } from '../../comparison/hierarchicalMarkdownComparisonModel.ts'
+import { comparisonTestDocument, createComparisonTestEditor } from './comparisonTestEditor.ts'
+
+function markdownTable(header: readonly string[], rows: readonly (readonly string[])[]) {
+ return [
+ `| ${header.join(' | ')} |`,
+ `|${header.map(() => '---').join('|')}|`,
+ ...rows.map((row) => `| ${row.join(' | ')} |`),
+ ].join('\n')
+}
+
+function compare(before: string, after: string) {
+ return createHierarchicalMarkdownComparisonModel(
+ comparisonTestDocument(before),
+ comparisonTestDocument(after),
+ )
+}
+
+interface TableSpec {
+ header: readonly { text: string, colspan?: number, rowspan?: number }[]
+ rows: readonly (readonly { text: string, colspan?: number, rowspan?: number }[])[]
+}
+
+function tableNode(schema: Schema, spec: TableSpec) {
+ const text = (value: string) => value ? schema.text(value) : undefined
+ const cell = (name: 'tableHeader' | 'tableCell', value: TableSpec['header'][number]) => schema.nodes[name]!.create(
+ { colspan: value.colspan ?? 1, rowspan: value.rowspan ?? 1 },
+ name === 'tableHeader' ? text(value.text) : schema.nodes.paragraph!.create(null, text(value.text)),
+ )
+ const header = schema.nodes.tableHeadRow!.create(null, spec.header.map((value) => cell('tableHeader', value)))
+ const rows = spec.rows.map((row) => schema.nodes.tableRow!.create(null, row.map((value) => cell('tableCell', value))))
+ return schema.nodes.table!.create(null, [header, ...rows])
+}
+
+function tableDocument(schema: Schema, spec: TableSpec) {
+ return schema.nodes.doc!.create(null, tableNode(schema, spec))
+}
+
+function compareTableSpecs(before: TableSpec, after: TableSpec) {
+ const editor = createComparisonTestEditor('placeholder')
+ try {
+ return createHierarchicalMarkdownComparisonModel(
+ tableDocument(editor.schema, before),
+ tableDocument(editor.schema, after),
+ )
+ } finally {
+ editor.destroy()
+ }
+}
+
+function malformedTableDocument(
+ schema: Schema,
+ children: readonly ('caption' | 'header' | 'body' | 'header-with-body-cell' | 'body-with-header-cell')[],
+) {
+ const text = (value: string) => schema.text(value)
+ const headerCell = () => schema.nodes.tableHeader!.create(null, text('header'))
+ const bodyCell = () => schema.nodes.tableCell!.create(null, schema.nodes.paragraph!.create(null, text('body')))
+ const nodes = children.map((kind) => {
+ if (kind === 'caption') {
+ return schema.nodes.tableCaption!.create(null, text('caption'))
+ }
+ if (kind === 'header') {
+ return schema.nodes.tableHeadRow!.create(null, headerCell())
+ }
+ if (kind === 'body') {
+ return schema.nodes.tableRow!.create(null, bodyCell())
+ }
+ if (kind === 'header-with-body-cell') {
+ return schema.nodes.tableHeadRow!.create(null, bodyCell())
+ }
+ return schema.nodes.tableRow!.create(null, headerCell())
+ })
+ return schema.nodes.doc!.create(null, schema.nodes.table!.create(null, nodes))
+}
+
+function expectColumnEdit(
+ edit: ComparisonEdit,
+ operation: 'delete' | 'insert',
+ column: number,
+ rows: number,
+) {
+ const side: ComparisonSide = operation === 'delete' ? 'before' : 'after'
+ expect(edit.kind).toBe('table-column')
+ expect(edit.primary.operation).toBe(operation)
+ expect(edit.descriptors).toHaveLength(rows)
+ expect(edit.descriptors.every((descriptor) => descriptor.operation === operation)).toBe(true)
+ expect(edit.descriptors.map((descriptor) => descriptor.context[side]?.path.at(-1)))
+ .toEqual(Array.from({ length: rows }, () => column))
+ expect(edit.descriptors).toContain(edit.primary)
+}
+
+describe('sparse table comparison', () => {
+ it('AUD-14 does not materialize table profiles before matrix budget admission', () => {
+ const editor = createComparisonTestEditor('placeholder')
+ const columns = 201
+ const before = tableDocument(editor.schema, {
+ header: Array.from({ length: columns }, (_value, index) => ({ text: `before-${index}` })),
+ rows: [],
+ })
+ const after = tableDocument(editor.schema, {
+ header: Array.from({ length: columns }, (_value, index) => ({ text: `after-${index}` })),
+ rows: [],
+ })
+ const textContent = vi.spyOn(ProseMirrorNode.prototype, 'textContent', 'get')
+ try {
+ const model = createHierarchicalMarkdownComparisonModel(before, after)
+
+ expect(model.edits[0]!.primary.coarseReason).toBe('comparison-limit')
+ const tableCellReads = textContent.mock.contexts.filter((node) => (
+ (node as ProseMirrorNode).type.name === 'tableHeader'
+ )).length
+ expect(tableCellReads).toBeLessThanOrEqual(columns * 2 * 5)
+ } finally {
+ textContent.mockRestore()
+ editor.destroy()
+ }
+ })
+
+ it.each([
+ ['first', 0],
+ ['middle', 1],
+ ['last', 2],
+ ] as const)('T01 attributes the %s duplicate-body column deletion', (_name, column) => {
+ const widerHeader = ['A', 'B', 'C']
+ const narrowerHeader = widerHeader.filter((_value, index) => index !== column)
+ const wider = markdownTable(widerHeader, Array.from({ length: 2 }, () => ['x', 'x', 'x']))
+ const narrower = markdownTable(narrowerHeader, Array.from({ length: 2 }, () => ['x', 'x']))
+
+ const deletion = compare(wider, narrower)
+ expect(deletion.edits).toHaveLength(1)
+ expectColumnEdit(deletion.edits[0]!, 'delete', column, 3)
+ })
+
+ it.each([
+ ['first', 0],
+ ['middle', 1],
+ ['last', 2],
+ ] as const)('T02 attributes the %s duplicate-body column insertion', (_name, column) => {
+ const widerHeader = ['A', 'B', 'C']
+ const narrowerHeader = widerHeader.filter((_value, index) => index !== column)
+ const wider = markdownTable(widerHeader, Array.from({ length: 2 }, () => ['x', 'x', 'x']))
+ const narrower = markdownTable(narrowerHeader, Array.from({ length: 2 }, () => ['x', 'x']))
+
+ const insertion = compare(narrower, wider)
+ expect(insertion.edits).toHaveLength(1)
+ expectColumnEdit(insertion.edits[0]!, 'insert', column, 3)
+ })
+
+ it('T03 distinguishes duplicate headers with an exact body row', () => {
+ const model = compare(
+ markdownTable(['X', 'X', 'X'], [['a', 'b', 'c'], ['x', 'x', 'x']]),
+ markdownTable(['X', 'X'], [['a', 'b'], ['x', 'x']]),
+ )
+
+ expect(model.edits).toHaveLength(1)
+ expectColumnEdit(model.edits[0]!, 'delete', 2, 3)
+ })
+
+ it('T04 pairs equal duplicate-vector multiplicity by rank beside a unique deletion', () => {
+ const model = compare(
+ markdownTable(['A', 'X', 'X', 'C'], [['x', 'x', 'x', 'x']]),
+ markdownTable(['A', 'X', 'X'], [['x', 'x', 'x']]),
+ )
+
+ expect(model.edits).toHaveLength(1)
+ expectColumnEdit(model.edits[0]!, 'delete', 3, 2)
+ })
+
+ it('T05 keeps unequal identical-column multiplicity coarse', () => {
+ const model = compare(
+ markdownTable(['X', 'X', 'X'], [['', '', ''], ['x', 'x', 'x']]),
+ markdownTable(['X', 'X'], [['', ''], ['x', 'x']]),
+ )
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({
+ kind: 'content',
+ primary: {
+ operation: 'replace',
+ coarseReason: 'ambiguous-attribution',
+ context: { before: { code: 'table' }, after: { code: 'table' } },
+ },
+ })
+ })
+
+ it('T06 keeps a crossing exact column reorder coarse', () => {
+ const model = compare(
+ markdownTable(['A', 'B', 'C'], [['a', 'b', 'c']]),
+ markdownTable(['C', 'B', 'A'], [['c', 'b', 'a']]),
+ )
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({
+ kind: 'content',
+ primary: {
+ operation: 'replace',
+ coarseReason: 'table-evidence-conflict',
+ context: { before: { code: 'table' }, after: { code: 'table' } },
+ },
+ })
+ })
+
+ it('T07 keeps one edited retained column precise at cell altitude', () => {
+ const model = compare(
+ markdownTable(['A', 'B', 'C'], [['1', '2', '3']]),
+ markdownTable(['A', 'X', 'C'], [['1', 'changed', '3']]),
+ )
+ const descriptors = model.edits.flatMap(({ descriptors }) => descriptors)
+
+ expect(model.edits).toHaveLength(2)
+ expect(model.edits.every(({ kind }) => kind === 'content')).toBe(true)
+ expect(descriptors).toHaveLength(2)
+ expect(descriptors.map(({ context }) => context.before?.path)).toEqual([
+ [0, 0, 1],
+ [0, 1, 1],
+ ])
+ expect(descriptors.map(({ before, after }) => ({ before, after }))).toEqual([
+ { before: { from: 6, to: 7 }, after: { from: 6, to: 7 } },
+ { before: { from: 20, to: 21 }, after: { from: 20, to: 27 } },
+ ])
+ expect(descriptors.every(({ context }) => (
+ context.before?.code === 'table-cell' && context.after?.code === 'table-cell'
+ ))).toBe(true)
+ })
+
+ it('T08 keeps two adjacent edited columns precise when the optimum is unique', () => {
+ const model = compare(
+ markdownTable(['A', 'B old', 'C old', 'D'], [['1', 'before b', 'before c', '4']]),
+ markdownTable(['A', 'B new', 'C new', 'D'], [['1', 'after b', 'after c', '4']]),
+ )
+ const descriptors = model.edits.flatMap(({ descriptors }) => descriptors)
+
+ expect(descriptors).toHaveLength(4)
+ expect(model.edits.every(({ kind }) => kind === 'content')).toBe(true)
+ expect(descriptors.every(({ coarseReason }) => coarseReason === undefined)).toBe(true)
+ expect(descriptors.every(({ context }) => (
+ context.before?.code === 'table-cell' && context.after?.code === 'table-cell'
+ ))).toBe(true)
+ })
+
+ it('groups one column alignment change across its physical cells without duplicating content edits', () => {
+ const model = compare([
+ '# Evidence matrix',
+ '',
+ '| Signal | Evidence | State |',
+ '| :--- | :---: | ---: |',
+ '| API \\| worker | **Draft** [runbook](https://example.org/draft) | 10% |',
+ '| Screenshot |  | Pending |',
+ ].join('\n'), [
+ '# Evidence matrix',
+ '',
+ '| Signal | Evidence | State |',
+ '| ---: | :--- | :---: |',
+ '| API \\| worker | **Approved** [runbook](https://example.org/approved) | 25% |',
+ '| Screenshot |  | Complete |',
+ ].join('\n'))
+ const alignmentEdits = model.edits.filter(({ primary }) => primary.signals.some((signal) => (
+ signal.type === 'attribute' && signal.attribute === 'table-alignment'
+ )))
+ expect(model.edits).toHaveLength(7)
+ expect(alignmentEdits).toHaveLength(3)
+ expect(alignmentEdits.map(({ descriptors }) => descriptors.length)).toEqual([3, 3, 3])
+ expect(alignmentEdits.every(({ descriptors }) => descriptors.every(({ signals }) => signals.some((signal) => (
+ signal.type === 'attribute' && signal.attribute === 'table-alignment'
+ ))))).toBe(true)
+ })
+
+ it('T09 combines an edited retained column with one adjacent column deletion', () => {
+ const model = compare(
+ markdownTable(['A', 'B old', 'C'], [['1', 'before', '3']]),
+ markdownTable(['A', 'B new'], [['1', 'after']]),
+ )
+ const columnEdits = model.edits.filter(({ kind }) => kind === 'table-column')
+ const cellEdits = model.edits.filter(({ kind }) => kind === 'content')
+
+ expect(columnEdits).toHaveLength(1)
+ expectColumnEdit(columnEdits[0]!, 'delete', 2, 2)
+ expect(cellEdits).toHaveLength(2)
+ expect(cellEdits.flatMap(({ descriptors }) => descriptors).every(({ context }) => (
+ context.before?.code === 'table-cell' && context.after?.code === 'table-cell'
+ ))).toBe(true)
+ })
+
+ it('T10 keeps a row insertion at row altitude beside a column deletion', () => {
+ const model = compare(
+ markdownTable(['A', 'B', 'C'], [['one', 'x', 'x'], ['two', 'x', 'x']]),
+ markdownTable(['A', 'B'], [['one', 'x'], ['inserted row', 'unique'], ['two', 'x']]),
+ )
+ const columnEdits = model.edits.filter(({ kind }) => kind === 'table-column')
+ const rowInsertions = model.edits.filter(({ primary }) => (
+ primary.operation === 'insert' && primary.context.after?.code === 'table-row'
+ ))
+
+ expect(columnEdits).toHaveLength(1)
+ expectColumnEdit(columnEdits[0]!, 'delete', 2, 3)
+ expect(rowInsertions).toHaveLength(1)
+ })
+
+ it('T10 keeps a row deletion at row altitude beside a column insertion', () => {
+ const model = compare(
+ markdownTable(['A', 'B'], [['one', 'x'], ['deleted row', 'unique'], ['two', 'x']]),
+ markdownTable(['A', 'B', 'C'], [['one', 'x', 'x'], ['two', 'x', 'x']]),
+ )
+ const columnEdits = model.edits.filter(({ kind }) => kind === 'table-column')
+ const rowDeletions = model.edits.filter(({ primary }) => (
+ primary.operation === 'delete' && primary.context.before?.code === 'table-row'
+ ))
+
+ expect(columnEdits).toHaveLength(1)
+ expectColumnEdit(columnEdits[0]!, 'insert', 2, 3)
+ expect(rowDeletions).toHaveLength(1)
+ })
+
+ it('T11 keeps a ragged typo precise at physical-cell altitude', () => {
+ const model = compare(
+ markdownTable(['A', 'B', 'C'], [['one', 'before']]),
+ markdownTable(['A', 'B', 'C'], [['one', 'after']]),
+ )
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({
+ kind: 'content',
+ primary: {
+ operation: 'replace',
+ context: { before: { code: 'table-cell' }, after: { code: 'table-cell' } },
+ },
+ })
+ })
+
+ it.each([
+ ['fills', 'insert', ['one'], ['one', 'two']],
+ ['removes', 'delete', ['one', 'two'], ['one']],
+ ] as const)('T12 %s a ragged absent-present slot as one local cell change', (_name, operation, beforeRow, afterRow) => {
+ const model = compare(
+ markdownTable(['A', 'B'], [beforeRow]),
+ markdownTable(['A', 'B'], [afterRow]),
+ )
+ const side: ComparisonSide = operation === 'delete' ? 'before' : 'after'
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({ kind: 'content', primary: { operation } })
+ expect(model.edits[0]!.primary.context[side]?.code).toBe('table-cell')
+ })
+
+ it('T13 groups only present physical cells from a deleted ragged column', () => {
+ const wider = markdownTable(['A', 'B', 'C'], [
+ ['x', 'x'],
+ ['x', 'x', 'distinct C'],
+ ])
+ const narrower = markdownTable(['A', 'B'], [
+ ['x', 'x'],
+ ['x', 'x'],
+ ])
+ const model = compare(wider, narrower)
+
+ expect(model.edits).toHaveLength(1)
+ expectColumnEdit(model.edits[0]!, 'delete', 2, 2)
+ })
+
+ it.each(['deletion', 'insertion'] as const)('T14 fails a ragged middle identity conflict transactionally on %s', (direction) => {
+ const wider = markdownTable(['A', 'B', 'C'], [
+ ['x', 'x', 'x'],
+ ['x', 'x'],
+ ])
+ const narrower = markdownTable(['A', 'C'], [
+ ['x', 'x'],
+ ['x'],
+ ])
+ const model = direction === 'deletion'
+ ? compare(wider, narrower)
+ : compare(narrower, wider)
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({
+ kind: 'content',
+ primary: {
+ operation: 'replace',
+ coarseReason: 'table-evidence-conflict',
+ context: { before: { code: 'table' }, after: { code: 'table' } },
+ },
+ })
+ expect(model.edits[0]!.descriptors).toHaveLength(1)
+ })
+
+ it.each(['deletion', 'insertion'] as const)('AUD-01 fails closed when a ragged width change creates cross-row exact identity on %s', (direction) => {
+ for (const width of [2, 3, 4]) {
+ const wider = markdownTable(
+ Array.from({ length: width + 1 }, () => 'N'),
+ [
+ Array.from({ length: width }, () => 'x'),
+ Array.from({ length: width + 1 }, () => 'x'),
+ ],
+ )
+ const narrower = markdownTable(
+ Array.from({ length: width }, () => 'N'),
+ [
+ Array.from({ length: width - 1 }, () => 'x'),
+ Array.from({ length: width }, () => 'x'),
+ ],
+ )
+ const model = direction === 'deletion'
+ ? compare(wider, narrower)
+ : compare(narrower, wider)
+ const rowOperations = model.edits.filter(({ primary }) => (
+ primary.context.before?.code === 'table-row' || primary.context.after?.code === 'table-row'
+ ))
+
+ expect(rowOperations).toHaveLength(0)
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({
+ kind: 'content',
+ primary: {
+ operation: 'replace',
+ coarseReason: 'table-evidence-conflict',
+ context: { before: { code: 'table' }, after: { code: 'table' } },
+ },
+ })
+ expect(model.edits[0]!.descriptors).toHaveLength(1)
+ }
+ })
+
+ it.each(['deletion', 'insertion'] as const)('AUD-01 reconciles the complete row basis when row count and width change on %s', (direction) => {
+ const wider = markdownTable(['N', 'N', 'N'], [
+ ['x', 'x'],
+ ['x', 'x', 'x'],
+ ])
+ const narrower = markdownTable(['N', 'N'], [
+ ['inserted', 'unique'],
+ ['x'],
+ ['x', 'x'],
+ ])
+ const model = direction === 'deletion'
+ ? compare(wider, narrower)
+ : compare(narrower, wider)
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({
+ kind: 'content',
+ primary: {
+ operation: 'replace',
+ coarseReason: 'table-evidence-conflict',
+ context: { before: { code: 'table' }, after: { code: 'table' } },
+ },
+ })
+ expect(model.edits[0]!.descriptors).toHaveLength(1)
+ })
+
+ it.each(['deletion', 'insertion'] as const)('AUD-01 keeps a genuine ragged row replacement beside a column %s', (direction) => {
+ const wider = markdownTable(['A', 'B', 'C'], [
+ ['retained', 'x'],
+ ['deleted', 'y', 'z'],
+ ])
+ const narrower = markdownTable(['A', 'B'], [
+ ['inserted', 'q'],
+ ['retained', 'x'],
+ ])
+ const model = direction === 'deletion'
+ ? compare(wider, narrower)
+ : compare(narrower, wider)
+ const columnEdits = model.edits.filter(({ kind }) => kind === 'table-column')
+ const rowOperations = model.edits.filter(({ primary }) => (
+ primary.context.before?.code === 'table-row' || primary.context.after?.code === 'table-row'
+ ))
+
+ expect(columnEdits).toHaveLength(1)
+ expectColumnEdit(columnEdits[0]!, direction === 'deletion' ? 'delete' : 'insert', 2, 1)
+ expect(rowOperations.map(({ primary }) => primary.operation).toSorted()).toEqual(['delete', 'insert'])
+ expect(model.edits.every(({ primary }) => primary.coarseReason === undefined)).toBe(true)
+ })
+
+ it.each([
+ ['deletes', 'delete', 3, 2],
+ ['inserts', 'insert', 3, 4],
+ ] as const)('T15 %s the outer repeated row after retaining the first exact copies', (_name, operation, beforeCount, afterCount) => {
+ const rows = (count: number) => Array.from({ length: count }, () => ['Same', 'x'])
+ const model = compare(
+ markdownTable(['H1', 'H2'], rows(beforeCount)),
+ markdownTable(['H1', 'H2'], rows(afterCount)),
+ )
+ const side: ComparisonSide = operation === 'delete' ? 'before' : 'after'
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({ kind: 'content', primary: { operation } })
+ expect(model.edits[0]!.primary.context[side]?.code).toBe('table-row')
+ expect(model.edits[0]!.primary.context[side]?.path.at(-1)).toBe(operation === 'delete' ? 3 : 4)
+ })
+
+ it.each([
+ ['span', { header: [{ text: 'changed', colspan: 2 }], rows: [] }],
+ ['row span', { header: [{ text: 'changed', rowspan: 2 }], rows: [[{ text: 'body' }]] }],
+ ['malformed empty row', { header: [{ text: 'changed' }], rows: [[]] }],
+ ['more than 512 rows', {
+ header: [{ text: 'changed' }],
+ rows: Array.from({ length: 512 }, (_value, index) => [{ text: `row ${index}` }]),
+ }],
+ ['more than 10000 physical cells', {
+ header: Array.from({ length: 100 }, (_value, index) => ({ text: index === 0 ? 'changed' : `head ${index}` })),
+ rows: Array.from({ length: 100 }, (_value, row) => (
+ Array.from({ length: 100 }, (_cell, column) => ({ text: `cell ${row}:${column}` }))
+ )),
+ }],
+ ] as const)('T16 emits one unsupported-table edit for %s geometry', (_name, invalid) => {
+ const valid = { header: [{ text: 'valid' }], rows: [] }
+ const model = compareTableSpecs(valid, invalid)
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({
+ kind: 'content',
+ primary: {
+ operation: 'replace',
+ coarseReason: 'unsupported-table',
+ context: { before: { code: 'table' }, after: { code: 'table' } },
+ },
+ })
+ expect(model.edits[0]!.descriptors).toHaveLength(1)
+ })
+
+ it.each([
+ ['a missing header', ['body']],
+ ['duplicate headers', ['header', 'header']],
+ ['a header after a body row', ['body', 'header']],
+ ['a misplaced caption', ['header', 'caption']],
+ ['duplicate captions', ['caption', 'caption', 'header']],
+ ['a body cell in the header', ['header-with-body-cell']],
+ ['a header cell in a body row', ['header', 'body-with-header-cell']],
+ ] as const)('T16 rejects %s transactionally', (_name, children) => {
+ const editor = createComparisonTestEditor('placeholder')
+ try {
+ const valid = tableDocument(editor.schema, { header: [{ text: 'valid' }], rows: [] })
+ const invalid = malformedTableDocument(editor.schema, children)
+ const model = createHierarchicalMarkdownComparisonModel(valid, invalid)
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({
+ kind: 'content',
+ primary: {
+ operation: 'replace',
+ coarseReason: 'unsupported-table',
+ context: { before: { code: 'table' }, after: { code: 'table' } },
+ },
+ })
+ expect(model.edits[0]!.descriptors).toHaveLength(1)
+ } finally {
+ editor.destroy()
+ }
+ })
+
+ it('T17 rejects a 10001-column table before attempting column alignment', () => {
+ const valid = { header: [{ text: 'valid' }], rows: [] }
+ const hugeWidth = {
+ header: Array.from({ length: 10_001 }, (_value, index) => ({ text: `column ${index}` })),
+ rows: [],
+ }
+ const model = compareTableSpecs(valid, hugeWidth)
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]!.primary.coarseReason).toBe('unsupported-table')
+ expect(model.edits[0]!.descriptors).toHaveLength(1)
+ })
+
+ it('F09 retains solved table work without partial edits when a later exact-evidence veto coarsens the table', () => {
+ const editor = createComparisonTestEditor('placeholder')
+ try {
+ const columnCount = 100
+ const bodyTextLength = Math.floor(DEFAULT_COMPARISON_TOKEN_LEDGER / (4 * columnCount ** 2)) - 6
+ const body = (suffix: string) => Array.from({ length: columnCount }, (_value, index) => ({
+ text: `${String.fromCodePoint(0x100 + index).repeat(bodyTextLength - 1)}${suffix}`,
+ }))
+ const beforeHeader = Array.from({ length: columnCount }, (_value, index) => ({ text: index === 0 ? 'q' : 'a' }))
+ const afterHeader = Array.from({ length: columnCount }, (_value, index) => ({ text: index === columnCount - 1 ? 'q' : 'b' }))
+ const headerRowProfileLength = 2 * columnCount
+ const bodyRowProfileLength = (bodyTextLength + 2) * columnCount
+ const rowCharge = 2 * (3 * headerRowProfileLength + bodyRowProfileLength)
+ const columnProfileLength = bodyTextLength + 6
+ const columnCharge = 2 * columnCount ** 2 * columnProfileLength
+ const remainingTokens = DEFAULT_COMPARISON_TOKEN_LEDGER - rowCharge - columnCharge
+ const laterProfileLength = Math.floor(remainingTokens / (2 * columnCount ** 2)) + 1
+ const laterTextLength = laterProfileLength - 3
+ const repeatedHeaders = (character: string) => Array.from(
+ { length: columnCount },
+ () => ({ text: character.repeat(laterTextLength) }),
+ )
+ const anchor = editor.schema.nodes.paragraph!.create(null, editor.schema.text('exact veto boundary anchor'))
+ const before = editor.schema.nodes.doc!.create(null, [
+ tableNode(editor.schema, { header: beforeHeader, rows: [body('x')] }),
+ anchor,
+ tableNode(editor.schema, { header: repeatedHeaders('c'), rows: [] }),
+ ])
+ const after = editor.schema.nodes.doc!.create(null, [
+ tableNode(editor.schema, { header: afterHeader, rows: [body('y')] }),
+ anchor,
+ tableNode(editor.schema, { header: repeatedHeaders('d'), rows: [] }),
+ ])
+ const model = createHierarchicalMarkdownComparisonModel(before, after)
+
+ expect(2 * columnCount ** 2 * laterProfileLength).toBeGreaterThan(remainingTokens)
+ expect(2 * columnCount ** 2 * laterProfileLength).toBeLessThan(DEFAULT_COMPARISON_TOKEN_LEDGER)
+ expect(model.edits.map(({ primary }) => primary.coarseReason)).toEqual([
+ 'table-evidence-conflict',
+ 'comparison-limit',
+ ])
+ expect(model.edits.every(({ descriptors }) => descriptors.length === 1)).toBe(true)
+ } finally {
+ editor.destroy()
+ }
+ })
+
+ it('T18 shares table token work across consecutive column plans', () => {
+ interface Column {
+ key: string
+ profile: readonly string[]
+ }
+ const before: Column[] = [
+ { key: 'before-a', profile: ['a', 'same-a'] },
+ { key: 'before-b', profile: ['b', 'same-b'] },
+ ]
+ const after: Column[] = [
+ { key: 'after-a', profile: ['a', 'same-a'] },
+ { key: 'after-b', profile: ['b', 'same-b'] },
+ ]
+ const work = { remainingCells: 8, remainingTokenComparisons: 20 }
+ const options = {
+ work,
+ fingerprint: ({ key }: Column) => key,
+ profile: ({ profile }: Column) => profile,
+ compatible: () => true,
+ }
+
+ const first = alignComparisonColumns(before, after, options)
+ expect(first.every((region) => !('coarseReason' in region && region.coarseReason === 'comparison-limit'))).toBe(true)
+ expect(work).toEqual({ remainingCells: 4, remainingTokenComparisons: 4 })
+
+ const second = alignComparisonColumns(before, after, options)
+ expect(second).toEqual([{
+ before: { from: 0, to: 2 },
+ after: { from: 0, to: 2 },
+ coarseReason: 'comparison-limit',
+ }])
+ expect(work).toEqual({ remainingCells: 4, remainingTokenComparisons: 4 })
+ })
+})
diff --git a/src/tests/markdown.spec.js b/src/tests/markdown.spec.js
index 2f5bb9e5011..f67768a5c50 100644
--- a/src/tests/markdown.spec.js
+++ b/src/tests/markdown.spec.js
@@ -175,6 +175,7 @@ describe('Markdown though editor', () => {
test('details', ({ markdownThroughEditor }) => {
expect(markdownThroughEditor('\n**summary**
\n* list\n\n\n')).toBe('\n**summary**
\n* list\n\n\n')
+ expect(markdownThroughEditor('\nsummary
\ncontent\n\n\n')).toBe('\nsummary
\ncontent\n\n\n')
})
test('nested details', ({ markdownThroughEditor }) => {
diff --git a/src/tests/markdownit/details.spec.js b/src/tests/markdownit/details.spec.js
index dd077287e52..86f1c636f08 100644
--- a/src/tests/markdownit/details.spec.js
+++ b/src/tests/markdownit/details.spec.js
@@ -11,6 +11,10 @@ describe('Details extension', () => {
const rendered = markdownit.render('\nsummary
\ncontent\n')
expect(stripIndent(rendered)).toBe('summary
content
')
})
+ it('renders the native open state', () => {
+ const rendered = markdownit.render('\nsummary
\ncontent\n')
+ expect(stripIndent(rendered)).toBe('summary
content
')
+ })
it('renders with empty summary', () => {
const rendered = markdownit.render('\n
\ncontent\n')
expect(stripIndent(rendered)).toBe('
content
')
diff --git a/src/tests/nodes/DetailsViewAccessibility.spec.ts b/src/tests/nodes/DetailsViewAccessibility.spec.ts
new file mode 100644
index 00000000000..b1c9d51ab94
--- /dev/null
+++ b/src/tests/nodes/DetailsViewAccessibility.spec.ts
@@ -0,0 +1,49 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { mount } from '@vue/test-utils'
+import { describe, expect, it, vi } from 'vitest'
+import DetailsView from '../../nodes/DetailsView.vue'
+
+function mountDetails(attrs: { open: boolean, openDetails: boolean }, updateAttributes = vi.fn()) {
+ return mount(DetailsView, {
+ props: { node: { attrs }, updateAttributes },
+ global: {
+ stubs: {
+ NodeViewWrapper: { template: '['$props']
+
+const attachment = {
+ alt: 'Diagram',
+ davPath: '/diagram.png',
+ fullUrl: '/diagram.png',
+ isImage: true,
+ metadata: null,
+ mimetype: 'image/png',
+ name: 'diagram.png',
+ previewUrl: '/preview.png',
+ size: 100,
+}
+
+beforeEach(() => {
+ vi.stubGlobal('ResizeObserver', class {
+ observe() {}
+ disconnect() {}
+ })
+ vi.stubGlobal('IntersectionObserver', class {
+ observe() {}
+ disconnect() {}
+ })
+})
+
+afterEach(() => vi.unstubAllGlobals())
+
+async function mountImage(isImage: boolean) {
+ const editor = { isEditable: false, off: vi.fn(), on: vi.fn() }
+ const wrapper = mount(ImageView, {
+ props: {
+ editor,
+ node: { attrs: { alt: 'Diagram', src: 'diagram.png' } },
+ decorations: [],
+ selected: false,
+ extension: { options: { noLazyImages: false } },
+ getPos: () => 0,
+ updateAttributes: vi.fn(),
+ deleteNode: vi.fn(),
+ view: {},
+ innerDecorations: {},
+ HTMLAttributes: {},
+ } as unknown as ImageViewProps,
+ global: {
+ provide: {
+ [ATTACHMENT_RESOLVER as symbol]: shallowRef({ resolve: vi.fn().mockResolvedValue({ ...attachment, isImage }) }),
+ },
+ stubs: {
+ NodeViewWrapper: { template: '('.media-wrapper')
+
+ expect(action.element.tagName).toBe('BUTTON')
+ expect(action.attributes('type')).toBe('button')
+ expect(action.attributes('aria-label')).toBe(label)
+ expect(action.element.tabIndex).toBe(0)
+ })
+
+ it('AUD-18 routes image button activation through the real modal handler', async () => {
+ const wrapper = await mountImage(true)
+ const view = wrapper.vm as unknown as { embeddedImageList: Array }
+ vi.spyOn(wrapper.vm, 'updateEmbeddedImageList').mockImplementation(async () => {
+ view.embeddedImageList = [{ ...attachment, src: 'diagram.png' }]
+ })
+
+ await wrapper.find('.media-wrapper').trigger('click')
+
+ expect(wrapper.vm.imageIndex).toBe(0)
+ expect(wrapper.vm.showImageModal).toBe(true)
+ })
+
+ it('AUD-18 routes attachment button activation through the real Viewer action', async () => {
+ const open = vi.fn()
+ vi.stubGlobal('OCA', { Viewer: { file: null, mimetypes: ['image/png'], open } })
+ const wrapper = await mountImage(false)
+
+ await wrapper.find('.media-wrapper').trigger('click')
+
+ expect(open).toHaveBeenCalledOnce()
+ expect(open).toHaveBeenCalledWith({ path: attachment.davPath })
+ })
+})
diff --git a/src/tests/playwrightConfig.spec.ts b/src/tests/playwrightConfig.spec.ts
new file mode 100644
index 00000000000..3811aa2248e
--- /dev/null
+++ b/src/tests/playwrightConfig.spec.ts
@@ -0,0 +1,76 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+const originalComparisonBaseURL = process.env.TEXT_COMPARISON_BASE_URL
+const originalComparisonE2E = process.env.TEXT_COMPARISON_E2E
+const originalBaseURL = process.env.baseURL
+
+afterEach(() => {
+ setEnvironment('TEXT_COMPARISON_BASE_URL', originalComparisonBaseURL)
+ setEnvironment('TEXT_COMPARISON_E2E', originalComparisonE2E)
+ setEnvironment('baseURL', originalBaseURL)
+})
+
+function setEnvironment(name: string, value: string | undefined) {
+ if (value === undefined) {
+ delete process.env[name]
+ } else {
+ process.env[name] = value
+ }
+}
+
+async function loadConfig(comparisonBaseURL: string | undefined, baseURL: string | undefined, comparisonE2E?: string) {
+ setEnvironment('TEXT_COMPARISON_BASE_URL', comparisonBaseURL)
+ setEnvironment('TEXT_COMPARISON_E2E', comparisonE2E)
+ setEnvironment('baseURL', baseURL)
+ vi.resetModules()
+ return (await import('../../playwright.config.ts')).default
+}
+
+describe('Playwright comparison server selection', () => {
+ it.each([
+ { name: 'unset values', comparisonBaseURL: undefined, baseURL: undefined, expected: 'http://localhost:8089/index.php/', managed: true },
+ { name: 'empty values', comparisonBaseURL: '', baseURL: '', expected: 'http://localhost:8089/index.php/', managed: true },
+ { name: 'generic external URL', comparisonBaseURL: '', baseURL: 'https://generic.example/index.php/', expected: 'https://generic.example/index.php/', managed: false },
+ { name: 'dedicated external URL', comparisonBaseURL: 'https://text.example/index.php/', baseURL: '', expected: 'https://text.example/index.php/', managed: false },
+ { name: 'dedicated precedence', comparisonBaseURL: 'https://text.example/index.php/', baseURL: 'https://generic.example/index.php/', expected: 'https://text.example/index.php/', managed: false },
+ ])('uses the selected URL for $name', async ({ comparisonBaseURL, baseURL, expected, managed }) => {
+ const config = await loadConfig(comparisonBaseURL, baseURL)
+
+ expect(config.use?.baseURL).toBe(expected)
+ expect(config.webServer === undefined).toBe(!managed)
+ })
+
+ it('routes comparison and memory tests to their dedicated projects', async () => {
+ const config = await loadConfig(undefined, undefined, '1')
+ const projects = config.projects ?? []
+ const byName = new Map(projects.map((project) => [project.name, project]))
+ const comparisonNames = [
+ 'comparison-chromium',
+ 'comparison-webkit',
+ 'comparison-chromium-memory',
+ ]
+
+ expect(projects.map(({ name }) => name)).toEqual(['chromium', ...comparisonNames])
+ for (const name of comparisonNames) {
+ const match = byName.get(name)?.testMatch
+ expect(match).toBeInstanceOf(RegExp)
+ expect((match as RegExp).test('playwright/comparison/comparison.spec.ts')).toBe(true)
+ expect((match as RegExp).test('playwright/example.spec.ts')).toBe(false)
+ }
+ for (const name of comparisonNames.slice(0, 2)) {
+ expect(byName.get(name)?.grepInvert).toEqual(/@memory/)
+ expect(byName.get(name)?.grep).toBeUndefined()
+ }
+ expect(byName.get('comparison-chromium-memory')?.grep).toEqual(/@memory/)
+ expect(byName.get('comparison-chromium-memory')?.grepInvert).toBeUndefined()
+ const ordinaryIgnore = byName.get('chromium')?.testIgnore
+ expect(ordinaryIgnore).toBeInstanceOf(RegExp)
+ expect((ordinaryIgnore as RegExp).test('playwright/comparison/comparison.spec.ts')).toBe(true)
+ expect((ordinaryIgnore as RegExp).test('playwright/example.spec.ts')).toBe(false)
+ })
+})
diff --git a/src/tests/services/AttachmentResolver.spec.js b/src/tests/services/AttachmentResolver.spec.js
index 507be93df32..5280056917c 100644
--- a/src/tests/services/AttachmentResolver.spec.js
+++ b/src/tests/services/AttachmentResolver.spec.js
@@ -36,11 +36,9 @@ function initAttachmentResolver(args) {
previewUrl: `http://nextcloud.local/apps/text/mediaPreview?documentId=${fileId}&sessionId=${sessionId}&sessionToken=${sessionToken}&mediaFileName=${a2name}"`,
},
]
- const axiosSpy = vi
- .spyOn(axios, 'post')
+ vi.spyOn(axios, 'post')
.mockReturnValue({ data: attachmentList })
const resolver = new AttachmentResolver(args)
- expect(axiosSpy).toHaveBeenCalled()
return resolver
}
@@ -55,6 +53,15 @@ describe('Image resolver', () => {
}
const currentDirectory = '/parentDir'
+ it('does not request attachment metadata for a direct URL', async () => {
+ const axiosSpy = vi.spyOn(axios, 'post').mockResolvedValue({ data: [] })
+ const resolver = new AttachmentResolver({ fileId })
+
+ await resolver.resolve('https://example.org/pic.jpg')
+
+ expect(axiosSpy).not.toHaveBeenCalled()
+ })
+
it('is a class with one constructor argument', () => {
const resolver = initAttachmentResolver({ fileId })
expect(resolver).toBeInstanceOf(AttachmentResolver)
diff --git a/vite.config.ts b/vite.config.ts
index 1830d335ca4..5d930dd6f08 100644
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -50,6 +50,15 @@ const config = createAppConfig(
},
config: {
base: process.env.BASE,
+ worker: {
+ rollupOptions: {
+ output: {
+ assetFileNames: 'js/[name]-[hash][extname]',
+ chunkFileNames: 'js/[name]-[hash].worker.chunk.mjs',
+ entryFileNames: 'js/[name]-[hash].worker.mjs',
+ },
+ },
+ },
resolve: {
dedupe: ['vue'],
},
).*(?=<\/summary>\s*$)/
@@ -32,16 +31,22 @@ function parseDetails(
let detailsFound = false
let detailsSummary = null
+ let openDetails: boolean
let startLineCount = 2
- const m = state.src.slice(start, max).match(DETAILS_AND_SUMMARY_START_REGEX)
- if (m) {
+ const openingLine = state.src.slice(start, max)
+ const combined = openingLine.match(DETAILS_AND_SUMMARY_START_REGEX)
+ if (combined) {
// Details block start and summary in same line
- detailsSummary = m[0].trim()
+ detailsSummary = combined.groups!.summary!.trim()
+ openDetails = Boolean(combined.groups!.open)
startLineCount = 1
- } else if (!state.src.slice(start, max).match(DETAILS_START_REGEX)) {
- // Details block start in separate line
- return false
+ } else {
+ const opening = openingLine.match(DETAILS_START_REGEX)
+ if (!opening) {
+ return false
+ }
+ openDetails = Boolean(opening.groups!.open)
}
// Since start is found, we can report success here in validation mode
@@ -105,6 +110,9 @@ function parseDetails(
token.block = true
token.info = detailsSummary
token.map = [startLine, nextLine]
+ if (openDetails) {
+ token.attrSet('open', '')
+ }
token = state.push('details_summary', 'summary', 1)
token.block = false
diff --git a/src/nodes/Details.js b/src/nodes/Details.js
index 7b5f9073f8a..01b814f245c 100644
--- a/src/nodes/Details.js
+++ b/src/nodes/Details.js
@@ -67,6 +67,11 @@ const Details = Node.create({
openDetails: {
default: false,
},
+ open: {
+ default: false,
+ parseHTML: (element) => element.hasAttribute('open'),
+ renderHTML: ({ open }) => open ? { open: '' } : {},
+ },
}
},
@@ -91,7 +96,7 @@ const Details = Node.create({
},
toMarkdown: (state, node) => {
- state.write('\n')
+ state.write(node.attrs.open ? '\n' : '\n')
state.renderContent(node)
state.closeBlock(node)
state.ensureNewLine()
diff --git a/src/nodes/DetailsView.vue b/src/nodes/DetailsView.vue
index 65677b0db96..2ec5c094d4e 100644
--- a/src/nodes/DetailsView.vue
+++ b/src/nodes/DetailsView.vue
@@ -5,13 +5,17 @@
-
+
diff --git a/src/nodes/Image.ts b/src/nodes/Image.ts
index 405dc92a694..389be2d9947 100644
--- a/src/nodes/Image.ts
+++ b/src/nodes/Image.ts
@@ -17,6 +17,7 @@ const imageFileDropPluginKey = new PluginKey('imageFileDrop')
const imageExtractAttachmentsKey = new PluginKey('imageExtractAttachments')
interface ImageOptions extends TiptapImageOptions {
+ emitAttachmentEvents: boolean
noLazyImages: boolean
}
@@ -53,6 +54,7 @@ const Image = TiptapImage.extend({
addOptions() {
return {
...this.parent?.() as ImageOptions,
+ emitAttachmentEvents: true,
noLazyImages: false,
}
},
@@ -120,31 +122,33 @@ const Image = TiptapImage.extend({
},
},
}),
- new Plugin({
- key: imageExtractAttachmentsKey,
- state: {
- init(_, { doc }) {
- const attachmentSrcs = extractAttachmentSrcs(doc)
- emit('text:editor:attachments:updated', { attachmentSrcs })
- return { attachmentSrcs }
- },
- apply(tr, value, _oldState, newState) {
- if (!tr.docChanged) {
- return value
- }
- const attachmentSrcs = extractAttachmentSrcs(newState.doc)
- if (
- JSON.stringify(attachmentSrcs)
- === JSON.stringify(value?.attachmentSrcs)
- ) {
- return value
- }
-
- emit('text:editor:attachments:updated', { attachmentSrcs })
- return { attachmentSrcs }
- },
- },
- }),
+ ...(this.options.emitAttachmentEvents
+ ? [new Plugin({
+ key: imageExtractAttachmentsKey,
+ state: {
+ init(_, { doc }) {
+ const attachmentSrcs = extractAttachmentSrcs(doc)
+ emit('text:editor:attachments:updated', { attachmentSrcs })
+ return { attachmentSrcs }
+ },
+ apply(tr, value, _oldState, newState) {
+ if (!tr.docChanged) {
+ return value
+ }
+ const attachmentSrcs = extractAttachmentSrcs(newState.doc)
+ if (
+ JSON.stringify(attachmentSrcs)
+ === JSON.stringify(value?.attachmentSrcs)
+ ) {
+ return value
+ }
+
+ emit('text:editor:attachments:updated', { attachmentSrcs })
+ return { attachmentSrcs }
+ },
+ },
+ })]
+ : []),
]
},
diff --git a/src/nodes/ImageView.vue b/src/nodes/ImageView.vue
index eb2c7576c4d..cec809cbc51 100644
--- a/src/nodes/ImageView.vue
+++ b/src/nodes/ImageView.vue
@@ -24,8 +24,10 @@
v-if="isMediaAttachment"
contenteditable="false"
class="media">
-
![]()
{{ alt }}
{{ attachmentSize }}
-
+
-
+
+
@@ -593,7 +599,11 @@ export default {
.media-wrapper {
display: flex;
- // Overwrite some global rules for a elments
+ padding: 0;
+ border: 0;
+ background: transparent;
+ font: inherit;
+ cursor: pointer;
text-decoration: none;
color: var(--color-main-text);
diff --git a/src/services/AttachmentResolver.js b/src/services/AttachmentResolver.js
index 6d1f2fa0a98..bc915c98156 100644
--- a/src/services/AttachmentResolver.js
+++ b/src/services/AttachmentResolver.js
@@ -22,7 +22,6 @@ export default class AttachmentResolver {
this.#shareToken = shareToken
this.#currentDirectory = currentDirectory
this.#documentId = fileId ?? session.documentId
- this.#initAttachmentListPromise = this.#updateAttachmentList()
}
async #updateAttachmentList() {
@@ -52,7 +51,7 @@ export default class AttachmentResolver {
if (src.match(directoryRegexp)) {
const imageFileName = decodeURIComponent(src.replace(directoryRegexp, '').split('?')[0])
- // Wait until attachment list got fetched (initialized by constructor)
+ this.#initAttachmentListPromise ??= this.#updateAttachmentList()
await this.#initAttachmentListPromise
attachment = this.#findAttachment(imageFileName)
diff --git a/src/tests/comparison/ComparisonChangeList.spec.ts b/src/tests/comparison/ComparisonChangeList.spec.ts
new file mode 100644
index 00000000000..246e4914c97
--- /dev/null
+++ b/src/tests/comparison/ComparisonChangeList.spec.ts
@@ -0,0 +1,173 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { ComparisonDescriptor, ComparisonEdit } from '../../comparison/markdownComparisonTypes.ts'
+
+import * as l10n from '@nextcloud/l10n'
+import { mount } from '@vue/test-utils'
+import { schema } from 'prosemirror-schema-basic'
+import { describe, expect, it, vi } from 'vitest'
+import ComparisonChangeList from '../../components/ComparisonChangeList.vue'
+
+function descriptor(id: string, text: string, facets: ComparisonDescriptor['facets'] = ['text']): ComparisonDescriptor {
+ return {
+ id,
+ operation: 'replace',
+ detail: 'inline',
+ facets,
+ before: { from: 0, to: 1 },
+ after: { from: 0, to: 1 },
+ context: { before: null, after: null },
+ preview: { before: { kind: 'text', text }, after: { kind: 'text', text } },
+ signals: [],
+ }
+}
+
+const document = schema.node('doc', null, [schema.node('paragraph', null, schema.text('Body'))])
+
+describe('ComparisonChangeList', () => {
+ it('AUD-14 renders only the bounded page containing a high-cardinality current edit', () => {
+ const edits = Array.from({ length: 10_000 }, (_value, index): ComparisonEdit => {
+ const primary = descriptor(`member-${index}`, `preview-${index}`)
+ return { id: `edit-${index}`, kind: 'content', primary, descriptors: [primary] }
+ })
+ const wrapper = mount(ComparisonChangeList, {
+ props: { edits, currentId: 'edit-9999', beforeDocument: document, afterDocument: document },
+ })
+ const rows = wrapper.findAll('[data-comparison-select]')
+
+ expect(rows).toHaveLength(80)
+ expect(rows[0]!.attributes('data-comparison-select')).toBe('edit-9920')
+ expect(rows.at(-1)!.attributes('data-comparison-select')).toBe('edit-9999')
+ expect(wrapper.find('[data-comparison-select="edit-9999"]').attributes('aria-current')).toBe('true')
+ })
+
+ it('preserves the current change label when paging away from its row', async () => {
+ const edits = Array.from({ length: 160 }, (_value, index): ComparisonEdit => {
+ const primary = descriptor(`member-${index}`, `preview-${index}`)
+ return { id: `edit-${index}`, kind: 'content', primary, descriptors: [primary] }
+ })
+ const wrapper = mount(ComparisonChangeList, {
+ props: { edits, currentId: 'edit-159', beforeDocument: document, afterDocument: document },
+ })
+ const initialLabel = wrapper.emitted('currentLabel')!.at(-1)![0]
+
+ await wrapper.findAll('.text-comparison__change-pages button')[0]!.trigger('click')
+
+ expect(wrapper.findAll('[data-comparison-select]')[0]!.attributes('data-comparison-select')).toBe('edit-0')
+ expect(wrapper.find('[aria-current="true"]').exists()).toBe(false)
+ expect(wrapper.emitted('currentLabel')!.at(-1)![0]).toBe(initialLabel)
+ expect(initialLabel).not.toBe('')
+ })
+
+ it('AUD-14 unmounts records in collapsed sections', async () => {
+ const primary = descriptor('member', 'preview')
+ const edit: ComparisonEdit = { id: 'edit', kind: 'content', primary, descriptors: [primary] }
+ const wrapper = mount(ComparisonChangeList, {
+ props: { edits: [edit], beforeDocument: document, afterDocument: document },
+ })
+
+ await wrapper.get('.text-comparison__section-toggle').trigger('click')
+
+ expect(wrapper.findAll('[data-comparison-select]')).toHaveLength(0)
+ })
+
+ it('translates only the selected lookup entry for each record', () => {
+ const translate = vi.spyOn(l10n, 't')
+ const primary: ComparisonDescriptor = {
+ ...descriptor('member', 'preview', ['attribute']),
+ signals: [{ type: 'attribute', attribute: 'link', change: 'changed' }],
+ }
+ const edit: ComparisonEdit = { id: 'edit', kind: 'content', primary, descriptors: [primary] }
+
+ mount(ComparisonChangeList, {
+ props: { edits: [edit], beforeDocument: document, afterDocument: document },
+ })
+
+ const messages = translate.mock.calls.map(([, message]) => message)
+ expect(messages).toContain('Link changed')
+ expect(messages).not.toContain('Heading level changed')
+ translate.mockRestore()
+ })
+
+ it('V01 renders one row per first-class edit using explicit primary and all member descriptors', async () => {
+ const first = descriptor('member-first', 'wrong', ['formatting'])
+ const primary = descriptor('member-primary', 'primary')
+ const edit: ComparisonEdit = { id: 'edit-row', kind: 'content', primary, descriptors: [first, primary] }
+ const wrapper = mount(ComparisonChangeList, {
+ props: { edits: [edit], currentId: 'edit-row', beforeDocument: document, afterDocument: document },
+ })
+ const rows = wrapper.findAll('[data-comparison-select]')
+ expect(rows).toHaveLength(1)
+ expect(rows[0]!.attributes('data-comparison-select')).toBe('edit-row')
+ expect(rows[0]!.find('.text-comparison__change-item-content').exists()).toBe(true)
+ expect(rows[0]!.text()).toContain('primary')
+ expect(rows[0]!.text()).toContain('2 edits')
+ await rows[0]!.trigger('click')
+ expect(wrapper.emitted('select')).toEqual([['edit-row']])
+ })
+
+ it('renders explicit before and after previews for a replacement', () => {
+ const primary: ComparisonDescriptor = {
+ ...descriptor('member', 'unused'),
+ preview: {
+ before: { kind: 'text', text: 'before text' },
+ after: { kind: 'text', text: 'after text' },
+ },
+ }
+ const edit: ComparisonEdit = { id: 'edit', kind: 'content', primary, descriptors: [primary] }
+ const wrapper = mount(ComparisonChangeList, {
+ props: { edits: [edit], beforeDocument: document, afterDocument: document },
+ })
+
+ expect(wrapper.get('del.text-comparison__preview-before').text()).toBe('before text')
+ expect(wrapper.get('ins.text-comparison__preview-after').text()).toBe('after text')
+ })
+
+ it('labels a coarse composite change by its structural scope instead of an incidental task attribute', () => {
+ const primary: ComparisonDescriptor = {
+ ...descriptor('member', 'nested content', ['text', 'attribute', 'structure']),
+ coarseReason: 'ambiguous-attribution',
+ signals: [
+ { type: 'attribute', attribute: 'task-state', change: 'changed' },
+ { type: 'node' },
+ ],
+ }
+ const edit: ComparisonEdit = { id: 'edit', kind: 'content', primary, descriptors: [primary] }
+ const wrapper = mount(ComparisonChangeList, {
+ props: { edits: [edit], beforeDocument: document, afterDocument: document },
+ })
+
+ expect(wrapper.get('[data-comparison-select]').text()).toContain('Structure changed')
+ expect(wrapper.get('[data-comparison-select]').text()).not.toContain('Task state changed')
+ })
+
+ it.each([
+ ['insert', 'inline', 'Paragraph changed', 'Paragraph added'],
+ ['delete', 'inline', 'Paragraph changed', 'Paragraph removed'],
+ ['insert', 'block', 'Paragraph added', 'Paragraph changed'],
+ ['delete', 'block', 'Paragraph removed', 'Paragraph changed'],
+ ] as const)('labels a %s %s operation at the correct altitude', (operation, detail, expected, rejected) => {
+ const primary: ComparisonDescriptor = {
+ ...descriptor('member', 's'),
+ operation,
+ detail,
+ context: {
+ before: { code: 'paragraph', path: [], from: 0, to: 1 },
+ after: { code: 'paragraph', path: [], from: 0, to: 1 },
+ },
+ preview: operation === 'insert'
+ ? { before: null, after: { kind: 'text', text: 's' } }
+ : { before: { kind: 'text', text: 's' }, after: null },
+ }
+ const edit: ComparisonEdit = { id: 'edit', kind: 'content', primary, descriptors: [primary] }
+ const wrapper = mount(ComparisonChangeList, {
+ props: { edits: [edit], beforeDocument: document, afterDocument: document },
+ })
+
+ expect(wrapper.get('[data-comparison-select]').text()).toContain(expected)
+ expect(wrapper.get('[data-comparison-select]').text()).not.toContain(rejected)
+ })
+})
diff --git a/src/tests/comparison/MarkdownSourceComponent.spec.ts b/src/tests/comparison/MarkdownSourceComponent.spec.ts
new file mode 100644
index 00000000000..f095354e1e1
--- /dev/null
+++ b/src/tests/comparison/MarkdownSourceComponent.spec.ts
@@ -0,0 +1,187 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { mount } from '@vue/test-utils'
+import { describe, expect, it, vi } from 'vitest'
+import MarkdownSourceComparison from '../../components/MarkdownSourceComparison.vue'
+import { SOURCE_DIFF_LIMITS } from '../../comparison/markdownSourceComparison.ts'
+import {
+ COMPLETE_SOURCE_DISPLAY_LIMITS,
+ displayBoundedMarkdownSource,
+ displayMarkdownSource,
+} from '../../comparison/markdownSourceDisplay.ts'
+
+describe('Markdown source component', () => {
+ const multilineSource = (length: number) => {
+ const line = `${'x'.repeat(COMPLETE_SOURCE_DISPLAY_LIMITS.maximumVisibleCharactersPerLine - 1)}\n`
+ return line.repeat(Math.floor(length / line.length)) + 'x'.repeat(length % line.length)
+ }
+
+ it.each([
+ COMPLETE_SOURCE_DISPLAY_LIMITS.maximumVisibleCharactersPerSide - 1,
+ COMPLETE_SOURCE_DISPLAY_LIMITS.maximumVisibleCharactersPerSide,
+ ])('AUD-08 preserves complete source at the %i-character display boundary', (length) => {
+ const source = multilineSource(length)
+ expect(displayBoundedMarkdownSource(source)).toEqual({ text: source, truncated: false })
+ })
+
+ it('keeps supplementary characters well formed at the input boundary', () => {
+ const limit = COMPLETE_SOURCE_DISPLAY_LIMITS.maximumInputCharactersPerSide
+ const exact = `${multilineSource(limit - 2)}😀`
+ const crossingPrefix = multilineSource(limit - 1)
+ const crossing = `${crossingPrefix}😀`
+
+ expect(displayBoundedMarkdownSource(exact)).toEqual({ text: exact, truncated: false })
+ const result = displayBoundedMarkdownSource(crossing)
+ expect(result.text).toBe(crossingPrefix)
+ expect(result.text.length).toBeLessThanOrEqual(COMPLETE_SOURCE_DISPLAY_LIMITS.maximumVisibleCharactersPerSide)
+ expect(result.text.isWellFormed()).toBe(true)
+ expect(result.truncated).toBe(true)
+ })
+
+ it('keeps supplementary characters and visible controls intact at the output boundary', () => {
+ expect(displayMarkdownSource('abc😀', 5)).toBe('abc😀')
+ expect(displayMarkdownSource('abc😀', 4)).toBe('abc')
+ expect(displayMarkdownSource('\tremaining', 5)).toBe('⟦TAB⟧')
+ })
+
+ it.each([
+ ['high', '\uD83D', '⟦U+D83D⟧'],
+ ['low', '\uDE00', '⟦U+DE00⟧'],
+ ])('renders a lone %s surrogate as an exact reversible token', (_name, source, expected) => {
+ const result = displayBoundedMarkdownSource(source)
+
+ expect(result).toEqual({ text: expected, truncated: false })
+ expect(result.text).not.toContain('\uFFFD')
+ expect(result.text.isWellFormed()).toBe(true)
+ })
+
+ it('reports expansion truncation instead of silently omitting a supplementary character', () => {
+ const result = displayBoundedMarkdownSource(`${'\t'.repeat(200_000)}😀`)
+
+ expect(result.truncated).toBe(true)
+ expect(result.text).toHaveLength(COMPLETE_SOURCE_DISPLAY_LIMITS.maximumVisibleCharactersPerLine)
+ expect(result.text).not.toContain('\uFFFD')
+ expect(result.text.isWellFormed()).toBe(true)
+ expect(result.text.length).toBeLessThanOrEqual(COMPLETE_SOURCE_DISPLAY_LIMITS.maximumVisibleCharactersPerLine)
+ })
+
+ it('shows complete fallback immediately, then enhanced literal hunks', async () => {
+ const wrapper = mount(MarkdownSourceComparison, {
+ props: { beforeContent: 'old\t \n', afterContent: 'new\u200B\n', layoutMode: 'paired' },
+ })
+ expect(wrapper.find('[data-comparison-source-fallback]').exists()).toBe(true)
+ await vi.waitFor(() => expect(wrapper.find('[data-source-hunk]').exists()).toBe(true))
+ expect(wrapper.text()).toContain('old')
+ expect(wrapper.text()).toContain('new⟦ZWSP⟧')
+ })
+
+ it('AUD-05 exposes side, operation, whitespace, EOL, and missing-newline semantics', async () => {
+ const wrapper = mount(MarkdownSourceComparison, {
+ props: {
+ beforeContent: `old${String.fromCharCode(9)}\r\ntrail `,
+ afterContent: 'new\ntrail\n',
+ layoutMode: 'paired',
+ },
+ })
+ await vi.waitFor(() => expect(wrapper.find('[data-source-hunk]').exists()).toBe(true))
+
+ expect(wrapper.find('[data-source-side="before"]').text()).toBe('Before')
+ expect(wrapper.find('[data-source-side="after"]').text()).toBe('After')
+ expect(wrapper.find('[data-source-operation="removed"]').attributes('aria-label')).toContain('Removed line')
+ expect(wrapper.find('[data-source-operation="added"]').attributes('aria-label')).toContain('Added line')
+ expect(wrapper.find('[data-source-operation="removed"] [data-source-cue]').text()).toBe('−')
+ expect(wrapper.find('[data-source-operation="added"] [data-source-cue]').text()).toBe('+')
+ for (const token of ['TAB', 'CRLF', 'LF', '2 TRAILING SPACES', 'No newline at end of file']) {
+ expect(wrapper.text()).toContain(token)
+ }
+ })
+
+ it('omits per-line badges when paired line endings match', async () => {
+ const wrapper = mount(MarkdownSourceComparison, {
+ props: {
+ beforeContent: 'old\nunchanged\n',
+ afterContent: 'new\nunchanged\n',
+ layoutMode: 'paired',
+ },
+ })
+ await vi.waitFor(() => expect(wrapper.find('[data-source-hunk]').exists()).toBe(true))
+
+ expect(wrapper.findAll('[data-source-eol]')).toHaveLength(0)
+ })
+
+ it('AUD-13 renders the audited bidi and control set as visible inert source tokens', async () => {
+ const controls = '\u061C\u00AD\u200E\u200F\u0085\u2028\u2029'
+ const wrapper = mount(MarkdownSourceComparison, {
+ props: { beforeContent: controls, afterContent: '', layoutMode: 'paired' },
+ })
+ await vi.waitFor(() => expect(wrapper.find('[data-source-hunk]').exists()).toBe(true))
+
+ for (const token of ['ALM', 'SHY', 'LRM', 'RLM', 'NEL', 'LS', 'PS']) {
+ expect(wrapper.text()).toContain(token)
+ }
+ for (const control of controls) {
+ expect(wrapper.text()).not.toContain(control)
+ }
+ })
+
+ it('AUD-08 expands a large unchanged gap incrementally with observable source ranges', async () => {
+ const prefix = Array.from({ length: 3_000 }, (_value, index) => `prefix-${index}`)
+ const suffix = Array.from({ length: 3_000 }, (_value, index) => `suffix-${index}`)
+ const beforeContent = [...prefix, 'old literal', ...suffix].join('\n')
+ const afterContent = [...prefix, 'new literal', ...suffix].join('\n')
+ const wrapper = mount(MarkdownSourceComparison, {
+ props: { beforeContent, afterContent, layoutMode: 'paired' },
+ })
+ await vi.waitFor(() => expect(wrapper.findAll('.text-source-comparison__gap button')).toHaveLength(2))
+
+ await wrapper.findAll('[data-source-gap-toggle]')[0]!.trigger('click')
+
+ expect(wrapper.findAll('.text-source-comparison__row')).toHaveLength(SOURCE_DIFF_LIMITS.maximumGapPageRows + 7)
+ expect(wrapper.text()).toContain('prefix-0')
+ expect(wrapper.text()).toContain(`prefix-${SOURCE_DIFF_LIMITS.maximumGapPageRows - 1}`)
+ expect(wrapper.text()).not.toContain(`prefix-${SOURCE_DIFF_LIMITS.maximumGapPageRows}`)
+
+ await wrapper.find('[data-source-gap-more]').trigger('click')
+
+ expect(wrapper.findAll('.text-source-comparison__row')).toHaveLength(SOURCE_DIFF_LIMITS.maximumGapPageRows * 2 + 7)
+ expect(wrapper.text()).toContain(`prefix-${SOURCE_DIFF_LIMITS.maximumGapPageRows}`)
+ })
+
+ it('AUD-08 never expands gaps beyond the shared displayed-row ceiling', async () => {
+ const prefix = Array.from({ length: 3_000 }, (_value, index) => `prefix-${index}`)
+ const suffix = Array.from({ length: 3_000 }, (_value, index) => `suffix-${index}`)
+ const beforeContent = [...prefix, 'old literal', ...suffix].join('\n')
+ const afterContent = [...prefix, 'new literal', ...suffix].join('\n')
+ const wrapper = mount(MarkdownSourceComparison, {
+ props: { beforeContent, afterContent, layoutMode: 'paired' },
+ })
+ await vi.waitFor(() => expect(wrapper.findAll('[data-source-gap-toggle]')).toHaveLength(2))
+
+ for (const toggle of wrapper.findAll('[data-source-gap-toggle]')) {
+ await toggle.trigger('click')
+ while (wrapper.find('[data-source-gap-more]').exists()) {
+ await wrapper.find('[data-source-gap-more]').trigger('click')
+ }
+ }
+
+ expect(wrapper.findAll('.text-source-comparison__row')).toHaveLength(SOURCE_DIFF_LIMITS.maximumDisplayedRows)
+ expect(wrapper.text()).toContain('prefix-0')
+ expect(wrapper.text()).toContain('suffix-3')
+ expect(wrapper.text()).not.toContain('suffix-2999')
+ expect(wrapper.find('[data-source-gap-limited]').exists()).toBe(true)
+ }, 15_000)
+
+ it('V11 preserves bounded complete fallback when source enhancement is limited', async () => {
+ const beforeContent = 'x'.repeat(SOURCE_DIFF_LIMITS.maximumCharacters + 1)
+ const wrapper = mount(MarkdownSourceComparison, {
+ props: { beforeContent, afterContent: 'after', layoutMode: 'single' },
+ })
+ await vi.waitFor(() => expect(wrapper.find('[data-source-limited]').exists()).toBe(true))
+ expect(wrapper.find('[data-comparison-source-fallback]').exists()).toBe(true)
+ expect(wrapper.find('pre code').text()).toHaveLength(COMPLETE_SOURCE_DISPLAY_LIMITS.maximumVisibleCharactersPerLine)
+ expect(wrapper.findAll('[role="status"]').map((status) => status.text()).join(' ')).toContain('truncated')
+ })
+})
diff --git a/src/tests/comparison/MarkdownSourceFallback.spec.ts b/src/tests/comparison/MarkdownSourceFallback.spec.ts
new file mode 100644
index 00000000000..0791c0d5efc
--- /dev/null
+++ b/src/tests/comparison/MarkdownSourceFallback.spec.ts
@@ -0,0 +1,30 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { mount } from '@vue/test-utils'
+import { describe, expect, it, vi } from 'vitest'
+import MarkdownSourceFallback from '../../components/MarkdownSourceFallback.vue'
+
+vi.mock('../../comparison/markdownSourceComparison.ts', () => {
+ throw new Error('enhanced Source is unavailable')
+})
+
+describe('complete Markdown source fallback', () => {
+ it('always renders both complete snapshots as inert literal text with visible controls', () => {
+ const wrapper = mount(MarkdownSourceFallback, {
+ props: {
+ beforeContent: '\nzero\u200Bwidth',
+ afterContent: '\nlast',
+ },
+ })
+ const sources = wrapper.findAll('pre code')
+ expect(sources).toHaveLength(2)
+ expect(sources[0]!.text()).toContain('')
+ expect(sources[0]!.text()).toContain('⟦ZWSP⟧')
+ expect(sources[1]!.text()).toContain('')
+ expect(wrapper.find('script').exists()).toBe(false)
+ expect(wrapper.find('img').exists()).toBe(false)
+ })
+})
diff --git a/src/tests/comparison/a15HistoryDifferential.spec.ts b/src/tests/comparison/a15HistoryDifferential.spec.ts
new file mode 100644
index 00000000000..15e84bdb803
--- /dev/null
+++ b/src/tests/comparison/a15HistoryDifferential.spec.ts
@@ -0,0 +1,183 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { Node as ProseMirrorNode } from '@tiptap/pm/model'
+
+import { describe, expect, it } from 'vitest'
+import { createComparisonEditor } from '../../comparison/createComparisonEditor.ts'
+import { createHierarchicalMarkdownComparisonModel } from '../../comparison/hierarchicalMarkdownComparisonModel.ts'
+
+interface EditorLike {
+ state: { doc: ProseMirrorNode }
+ destroy: () => void
+}
+
+interface ExpectedReplacement {
+ operation: string
+ detail: string
+ before: string
+ after: string
+}
+
+interface RegressionCase {
+ name: string
+ before: string
+ after: string
+ expected: readonly ExpectedReplacement[]
+}
+
+const regressionCorpus: readonly RegressionCase[] = [
+ {
+ name: 'keeps an exact trailing block outside earlier replacements',
+ before: `# Wiki App
+
+Old build instructions.
+
+Shared footer.
+`,
+ after: `# Collective Wiki
+
+New installation instructions.
+
+Shared footer.
+`,
+ expected: [
+ { operation: 'insert', detail: 'inline', before: '', after: 'Collective ' },
+ { operation: 'delete', detail: 'inline', before: ' App', after: '' },
+ { operation: 'replace', detail: 'inline', before: 'Old build', after: 'New installation' },
+ ],
+ },
+ {
+ name: 'keeps a weighted multi-block gap precise',
+ before: `## Development Background: Ownership
+
+Individual users own files. Collective pages should be owned by the collective.
+
+## Stable anchor
+
+This block is unchanged.
+`,
+ after: `## Development background: Ownership
+
+Collective data is owned by the collective instead.
+
+## Stable anchor
+
+This block is unchanged.
+`,
+ expected: [
+ { operation: 'replace', detail: 'inline', before: 'B', after: 'b' },
+ { operation: 'delete', detail: 'inline', before: 'Individual users own files. ', after: '' },
+ { operation: 'replace', detail: 'inline', before: 'pages should be ', after: 'data is ' },
+ { operation: 'insert', detail: 'inline', before: '', after: ' instead' },
+ ],
+ },
+ {
+ name: 'reports code text and language replacements directly',
+ before: `\`\`\`
+const value = 1
+\`\`\`
+`,
+ after: `\`\`\`js
+const value = 1 // comment
+\`\`\`
+`,
+ expected: [
+ { operation: 'replace', detail: 'block', before: 'const value = 1', after: 'const value = 1 // comment' },
+ { operation: 'insert', detail: 'inline', before: '', after: ' // comment' },
+ ],
+ },
+ {
+ name: 'reports a removed list item as a node deletion',
+ before: `- Remove me
+- Keep me
+`,
+ after: `- Keep me
+`,
+ expected: [
+ { operation: 'delete', detail: 'block', before: 'Remove me', after: '' },
+ ],
+ },
+ {
+ name: 'does not expose parser-only Markdown syntax as a change signal',
+ before: `GNU AGPL v3 or later
+`,
+ after: `Files: *
+Copyright: Azul
+License: AGPL v3 or later
+`,
+ expected: [
+ {
+ operation: 'replace',
+ detail: 'inline',
+ before: 'GNU',
+ after: 'Files: *\nCopyright: Azul azul@example.com\nLicense:',
+ },
+ ],
+ },
+]
+
+function replacementOutput(beforeContent: string, afterContent: string) {
+ const beforeEditor = createComparisonEditor(beforeContent) as EditorLike
+ const afterEditor = createComparisonEditor(afterContent) as EditorLike
+ try {
+ const before = beforeEditor.state.doc
+ const after = afterEditor.state.doc
+ return createHierarchicalMarkdownComparisonModel(before, after).edits
+ .flatMap(({ descriptors }) => descriptors)
+ .map((descriptor) => ({
+ operation: descriptor.operation,
+ detail: descriptor.detail,
+ facets: descriptor.facets,
+ before: before.textBetween(descriptor.before.from, descriptor.before.to, '\n', '\ufffc'),
+ after: after.textBetween(descriptor.after.from, descriptor.after.to, '\n', '\ufffc'),
+ context: descriptor.context,
+ signals: descriptor.signals,
+ coarseReason: descriptor.coarseReason ?? null,
+ }))
+ } finally {
+ beforeEditor.destroy()
+ afterEditor.destroy()
+ }
+}
+
+function replacementProjection(replacements: ReturnType): ExpectedReplacement[] {
+ return replacements.map(({ operation, detail, before, after }) => ({ operation, detail, before, after }))
+}
+
+function corpusCase(name: string) {
+ return regressionCorpus.find((candidate) => candidate.name === name)!
+}
+
+describe('A15 repository-history regression corpus', () => {
+ it.each(regressionCorpus)('$name', ({ before, after, expected }) => {
+ const replacements = replacementOutput(before, after)
+
+ expect(replacementProjection(replacements)).toEqual(expected)
+ expect(replacements.every(({ coarseReason }) => coarseReason === null)).toBe(true)
+ })
+
+ it('keeps replacement descriptor signals observable', () => {
+ const code = corpusCase('reports code text and language replacements directly')
+ const codeReplacements = replacementOutput(code.before, code.after)
+ expect(codeReplacements[0]).toMatchObject({
+ facets: ['attribute'],
+ signals: [{ type: 'attribute', attribute: 'code-language', change: 'changed' }],
+ })
+
+ const deletion = corpusCase('reports a removed list item as a node deletion')
+ expect(replacementOutput(deletion.before, deletion.after)[0]).toMatchObject({
+ facets: ['text', 'structure'],
+ context: { before: { code: 'list-item' }, after: null },
+ signals: [{ type: 'node' }],
+ })
+
+ const syntax = corpusCase('does not expose parser-only Markdown syntax as a change signal')
+ expect(replacementOutput(syntax.before, syntax.after)[0]).toMatchObject({
+ facets: ['text', 'attribute', 'unknown'],
+ signals: [{ type: 'attribute', attribute: 'link', change: 'added' }],
+ })
+ })
+})
diff --git a/src/tests/comparison/comparisonAlignment.spec.ts b/src/tests/comparison/comparisonAlignment.spec.ts
new file mode 100644
index 00000000000..3783e9d7087
--- /dev/null
+++ b/src/tests/comparison/comparisonAlignment.spec.ts
@@ -0,0 +1,343 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { describe, expect, it } from 'vitest'
+import {
+ alignComparisonAxis,
+ createComparisonWorkLedger,
+ DEFAULT_COMPARISON_CELL_LEDGER,
+ DEFAULT_COMPARISON_TOKEN_LEDGER,
+ forcedIncreasingPairs,
+} from '../../comparison/comparisonAlignment.ts'
+
+function options(work = createComparisonWorkLedger()) {
+ return {
+ work,
+ fingerprint: (value: string) => value,
+ profile: (value: string) => [...value],
+ compatible: () => true,
+ }
+}
+
+interface EvidencedItem {
+ id: number
+ side: 'before' | 'after'
+}
+
+function evidencedOptions(work = createComparisonWorkLedger()) {
+ return {
+ work,
+ fingerprint: ({ id, side }: EvidencedItem) => `${side}:${id}`,
+ profile: ({ id, side }: EvidencedItem) => [`item:${id}`, side],
+ compatible: () => true,
+ }
+}
+
+function evidencedAxis(size: number, side: EvidencedItem['side']): EvidencedItem[] {
+ return Array.from({ length: size }, (_value, id) => ({ id, side }))
+}
+
+const FINAL_CELL_LEDGER = DEFAULT_COMPARISON_CELL_LEDGER
+const FINAL_TOKEN_LEDGER = DEFAULT_COMPARISON_TOKEN_LEDGER
+const FINAL_SQUARE_SIZE = Math.floor(Math.sqrt(FINAL_CELL_LEDGER))
+
+function permutations(values: readonly number[]): number[][] {
+ if (values.length < 2) {
+ return [Array.from(values)]
+ }
+ return values.flatMap((value, index) => permutations(values.toSpliced(index, 1))
+ .map((suffix) => [value, ...suffix]))
+}
+
+function exhaustiveForcedPairs(values: readonly number[]) {
+ let maximum = 0
+ const optimal: number[][] = []
+ for (let mask = 0; mask < 2 ** values.length; mask++) {
+ const indices = values.flatMap((_value, index) => mask & (1 << index) ? [index] : [])
+ if (!indices.every((index, offset) => offset === 0 || values[indices[offset - 1]!]! < values[index]!)) {
+ continue
+ }
+ if (indices.length > maximum) {
+ maximum = indices.length
+ optimal.length = 0
+ }
+ if (indices.length === maximum) {
+ optimal.push(indices)
+ }
+ }
+ return optimal[0]!.filter((index) => optimal.every((candidate) => candidate.includes(index)))
+ .map((before) => ({ before, after: values[before]! }))
+}
+
+describe('comparison alignment', () => {
+ it('uses the authoritative comparison-wide shipping ledgers', () => {
+ expect(createComparisonWorkLedger()).toEqual({
+ remainingCells: 40_000,
+ remainingTokenComparisons: 84_000_000,
+ })
+ })
+
+ it('pairs a whole equal axis without weighted work', () => {
+ const work = createComparisonWorkLedger()
+
+ expect(alignComparisonAxis(['alpha', 'beta'], ['alpha', 'beta'], options(work))).toEqual([
+ { before: 0, after: 0 },
+ { before: 1, after: 1 },
+ ])
+ expect(work).toEqual({
+ remainingCells: DEFAULT_COMPARISON_CELL_LEDGER,
+ remainingTokenComparisons: DEFAULT_COMPARISON_TOKEN_LEDGER,
+ })
+ })
+
+ it('A03 uses ordered unique fingerprints as exact anchors', () => {
+ const work = createComparisonWorkLedger()
+
+ expect(alignComparisonAxis(['alpha', 'omega'], ['new', 'alpha', 'omega'], options(work))).toEqual([
+ { before: null, after: 0 },
+ { before: 0, after: 1 },
+ { before: 1, after: 2 },
+ ])
+ expect(work.remainingCells).toBe(40_000)
+ })
+
+ it('matches exhaustive forced-LIS anchors for crossing candidates', () => {
+ for (let size = 1; size <= 6; size++) {
+ for (const values of permutations(Array.from({ length: size }, (_value, index) => index))) {
+ const pairs = values.map((after, before) => ({ before, after }))
+ expect(forcedIncreasingPairs(pairs), values.join(','))
+ .toEqual(exhaustiveForcedPairs(values))
+ }
+ }
+ })
+
+ it('aligns around the forced subset of crossing exact candidates', () => {
+ expect(alignComparisonAxis(['alpha', 'beta', 'gamma'], ['beta', 'gamma', 'alpha'], options())).toEqual([
+ { before: 0, after: null },
+ { before: 1, after: 0 },
+ { before: 2, after: 1 },
+ { before: null, after: 2 },
+ ])
+ })
+
+ it('retains the first exact duplicate when one is inserted', () => {
+ expect(alignComparisonAxis(['same'], ['same', 'same'], options())).toEqual([
+ { before: 0, after: 0 },
+ { before: null, after: 1 },
+ ])
+ })
+
+ it('retains the first exact duplicate when one is deleted', () => {
+ expect(alignComparisonAxis(['same', 'same'], ['same'], options())).toEqual([
+ { before: 0, after: 0 },
+ { before: 1, after: null },
+ ])
+ })
+
+ it('A09 pairs one compatible changed item without weighted work', () => {
+ const work = createComparisonWorkLedger()
+
+ expect(alignComparisonAxis(['before'], ['after'], options(work))).toEqual([
+ { before: 0, after: 0 },
+ ])
+ expect(work.remainingCells).toBe(DEFAULT_COMPARISON_CELL_LEDGER)
+ expect(work.remainingTokenComparisons).toBe(DEFAULT_COMPARISON_TOKEN_LEDGER)
+ })
+
+ it('leaves one incompatible changed item unmatched', () => {
+ const incompatible = {
+ ...options(),
+ compatible: () => false,
+ }
+
+ expect(alignComparisonAxis(['list'], ['quote'], incompatible)).toEqual([
+ { before: 0, after: null },
+ { before: null, after: 0 },
+ ])
+ })
+
+ it('A10 coarsens a multi-item rewrite with ambiguous exact attribution', () => {
+ expect(alignComparisonAxis(['aa', 'bb', 'cc'], ['xx', 'yy'], options())).toEqual([{
+ before: { from: 0, to: 3 },
+ after: { from: 0, to: 2 },
+ coarseReason: 'ambiguous-attribution',
+ }])
+ })
+
+ it.each([
+ Math.floor(FINAL_SQUARE_SIZE / 2),
+ FINAL_SQUARE_SIZE - 1,
+ ])('A11 keeps a final-ledger-derived unique-evidence %i square gap precise', (size) => {
+ const result = alignComparisonAxis(
+ evidencedAxis(size, 'before'),
+ evidencedAxis(size, 'after'),
+ evidencedOptions(),
+ )
+
+ expect(result).toHaveLength(size)
+ expect(result.every((step, index) => step.before === index && step.after === index)).toBe(true)
+ })
+
+ it('A12 keeps the largest default-ledger square gap precise', () => {
+ const work = createComparisonWorkLedger()
+ const size = FINAL_SQUARE_SIZE
+ const result = alignComparisonAxis(
+ evidencedAxis(size, 'before'),
+ evidencedAxis(size, 'after'),
+ evidencedOptions(work),
+ )
+
+ expect(result).toHaveLength(size)
+ expect(work.remainingCells).toBe(0)
+ expect(work.remainingTokenComparisons).toBe(FINAL_TOKEN_LEDGER - 4 * size ** 2)
+ })
+
+ it('A13 refuses the first generated cell and token overflows atomically', () => {
+ const cellWork = createComparisonWorkLedger()
+ const size = FINAL_SQUARE_SIZE
+ expect(alignComparisonAxis(
+ evidencedAxis(size + 1, 'before'),
+ evidencedAxis(size, 'after'),
+ evidencedOptions(cellWork),
+ )).toEqual([{
+ before: { from: 0, to: size + 1 },
+ after: { from: 0, to: size },
+ coarseReason: 'comparison-limit',
+ }])
+ expect(cellWork).toEqual(createComparisonWorkLedger())
+
+ const tokenWork = createComparisonWorkLedger()
+ const longProfile = Array.from({ length: Math.floor(FINAL_TOKEN_LEDGER / (2 * size * size)) + 1 }, () => 'x')
+ expect(alignComparisonAxis(
+ evidencedAxis(size, 'before'),
+ evidencedAxis(size, 'after'),
+ {
+ ...evidencedOptions(tokenWork),
+ profile: () => longProfile,
+ },
+ )).toEqual([{
+ before: { from: 0, to: size },
+ after: { from: 0, to: size },
+ coarseReason: 'comparison-limit',
+ }])
+ expect(tokenWork).toEqual(createComparisonWorkLedger())
+ })
+
+ it('A14 allocates final-ledger cell work by axis order without debiting a refused gap', () => {
+ interface Item {
+ fingerprint: string
+ profile: readonly string[]
+ }
+ const gap = (size: number, name: string, side: 'before' | 'after'): Item[] => (
+ Array.from({ length: size }, (_value, id) => ({
+ fingerprint: `${name}:${side}:${id}`,
+ profile: [`${name}:${id}`, side],
+ }))
+ )
+ const anchor = (name: string): Item => ({ fingerprint: name, profile: [name] })
+ const firstSize = Math.floor(FINAL_SQUARE_SIZE / 2)
+ const refusedSize = FINAL_SQUARE_SIZE
+ const lastSize = Math.max(2, Math.floor(firstSize / 10))
+ const before = [
+ ...gap(firstSize, 'first', 'before'),
+ anchor('anchor-1'),
+ ...gap(refusedSize, 'refused', 'before'),
+ anchor('anchor-2'),
+ ...gap(lastSize, 'last', 'before'),
+ ]
+ const after = [
+ ...gap(firstSize, 'first', 'after'),
+ anchor('anchor-1'),
+ ...gap(refusedSize, 'refused', 'after'),
+ anchor('anchor-2'),
+ ...gap(lastSize, 'last', 'after'),
+ ]
+ const work = createComparisonWorkLedger()
+ const result = alignComparisonAxis(before, after, {
+ work,
+ fingerprint: (item) => item.fingerprint,
+ profile: (item) => item.profile,
+ compatible: () => true,
+ })
+ const refusedStart = firstSize + 1
+
+ expect(result).toContainEqual({
+ before: { from: refusedStart, to: refusedStart + refusedSize },
+ after: { from: refusedStart, to: refusedStart + refusedSize },
+ coarseReason: 'comparison-limit',
+ })
+ expect(result.at(-1)).toEqual({ before: before.length - 1, after: after.length - 1 })
+ expect(work.remainingCells).toBe(FINAL_CELL_LEDGER - firstSize ** 2 - lastSize ** 2)
+ })
+
+ it('A14 retains token and tie debits while preserving work after a refused token gap', () => {
+ interface Item {
+ fingerprint: string
+ profile: readonly string[]
+ }
+ const gapSize = Math.floor(FINAL_SQUARE_SIZE / 2)
+ const firstAfterSize = gapSize - 1
+ const lastSize = Math.max(2, Math.floor(gapSize / 10))
+ const firstProduct = gapSize * firstAfterSize
+ const firstProfileLength = Math.floor(FINAL_TOKEN_LEDGER / (4 * firstProduct))
+ const firstProfile = Array.from({ length: firstProfileLength }, () => 'same')
+ const tieCharge = 2 * firstProduct * firstProfileLength
+ const refusedProfileLength = Math.floor((FINAL_TOKEN_LEDGER - tieCharge) / (2 * gapSize ** 2)) + 1
+ const refusedProfile = Array.from({ length: refusedProfileLength }, () => 'refused')
+ const gap = (size: number, name: string, side: 'before' | 'after', profile?: readonly string[]): Item[] => (
+ Array.from({ length: size }, (_value, id) => ({
+ fingerprint: `${name}:${side}:${id}`,
+ profile: profile ?? [`${name}:${id}`, side],
+ }))
+ )
+ const anchor = (name: string): Item => ({ fingerprint: name, profile: [name] })
+ const before = [
+ ...gap(gapSize, 'tie', 'before', firstProfile),
+ anchor('anchor-1'),
+ ...gap(gapSize, 'refused', 'before', refusedProfile),
+ anchor('anchor-2'),
+ ...gap(lastSize, 'last', 'before'),
+ ]
+ const after = [
+ ...gap(firstAfterSize, 'tie', 'after', firstProfile),
+ anchor('anchor-1'),
+ ...gap(gapSize, 'refused', 'after', refusedProfile),
+ anchor('anchor-2'),
+ ...gap(lastSize, 'last', 'after'),
+ ]
+ const work = createComparisonWorkLedger()
+ const result = alignComparisonAxis(before, after, {
+ work,
+ fingerprint: (item) => item.fingerprint,
+ profile: (item) => item.profile,
+ compatible: () => true,
+ })
+ const lastCharge = 4 * lastSize ** 2
+
+ expect(result[0]).toMatchObject({ coarseReason: 'ambiguous-attribution' })
+ expect(result).toContainEqual({
+ before: { from: gapSize + 1, to: 2 * gapSize + 1 },
+ after: { from: firstAfterSize + 1, to: firstAfterSize + gapSize + 1 },
+ coarseReason: 'comparison-limit',
+ })
+ expect(result.at(-1)).toEqual({ before: before.length - 1, after: after.length - 1 })
+ expect(work).toEqual({
+ remainingCells: FINAL_CELL_LEDGER - firstProduct - lastSize ** 2,
+ remainingTokenComparisons: FINAL_TOKEN_LEDGER - tieCharge - lastCharge,
+ })
+ })
+
+ it('P05 admits a skewed one-by-many gap by its exact cell charge', () => {
+ const work = createComparisonWorkLedger()
+ const result = alignComparisonAxis(
+ evidencedAxis(1, 'before'),
+ evidencedAxis(20_000, 'after'),
+ evidencedOptions(work),
+ )
+
+ expect(result).not.toContainEqual(expect.objectContaining({ coarseReason: 'comparison-limit' }))
+ expect(work.remainingCells).toBe(20_000)
+ })
+})
diff --git a/src/tests/comparison/comparisonAlignmentOracle.spec.ts b/src/tests/comparison/comparisonAlignmentOracle.spec.ts
new file mode 100644
index 00000000000..888fa76d654
--- /dev/null
+++ b/src/tests/comparison/comparisonAlignmentOracle.spec.ts
@@ -0,0 +1,167 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { ComparisonAlignmentStep, ComparisonWorkLedger } from '../../comparison/comparisonAlignment.ts'
+
+import { describe, expect, it } from 'vitest'
+import {
+ DEFAULT_COMPARISON_CELL_LEDGER,
+ DEFAULT_COMPARISON_TOKEN_LEDGER,
+ solveWeightedGap,
+} from '../../comparison/comparisonAlignment.ts'
+
+interface OracleItem {
+ fingerprint: string
+ profile: readonly string[]
+}
+
+interface Rational {
+ numerator: bigint
+ denominator: bigint
+}
+
+interface OracleMatch {
+ before: number
+ after: number
+}
+
+function compareRational(a: Rational, b: Rational) {
+ const difference = a.numerator * b.denominator - b.numerator * a.denominator
+ return difference < 0n ? -1 : difference > 0n ? 1 : 0
+}
+
+function addRational(a: Rational, b: Rational): Rational {
+ return {
+ numerator: a.numerator * b.denominator + b.numerator * a.denominator,
+ denominator: a.denominator * b.denominator,
+ }
+}
+
+function oraclePairScore(before: OracleItem, after: OracleItem): Rational {
+ if (before.fingerprint === after.fingerprint) {
+ return { numerator: 3n, denominator: 1n }
+ }
+ let prefix = 0
+ while (prefix < before.profile.length
+ && prefix < after.profile.length
+ && before.profile[prefix] === after.profile[prefix]) {
+ prefix++
+ }
+ let suffix = 0
+ const maximumSuffix = Math.min(before.profile.length, after.profile.length) - prefix
+ while (suffix < maximumSuffix
+ && before.profile[before.profile.length - suffix - 1] === after.profile[after.profile.length - suffix - 1]) {
+ suffix++
+ }
+ const denominator = BigInt(Math.max(before.profile.length, after.profile.length, 1))
+ return { numerator: denominator + BigInt(prefix + suffix), denominator }
+}
+
+function enumerateMatchings(
+ beforeCount: number,
+ afterCount: number,
+ beforeStart = 0,
+ afterStart = 0,
+): OracleMatch[][] {
+ const matchings: OracleMatch[][] = [[]]
+ for (let before = beforeStart; before < beforeCount; before++) {
+ for (let after = afterStart; after < afterCount; after++) {
+ for (const suffix of enumerateMatchings(beforeCount, afterCount, before + 1, after + 1)) {
+ matchings.push([{ before, after }, ...suffix])
+ }
+ }
+ }
+ return matchings
+}
+
+function oracleAlignment(before: readonly OracleItem[], after: readonly OracleItem[]) {
+ let bestScore: Rational = { numerator: -1n, denominator: 1n }
+ let best: OracleMatch[][] = []
+ for (const matching of enumerateMatchings(before.length, after.length)) {
+ const score = matching.reduce(
+ (total, pair) => addRational(total, oraclePairScore(before[pair.before]!, after[pair.after]!)),
+ { numerator: 0n, denominator: 1n },
+ )
+ const order = compareRational(score, bestScore)
+ if (order > 0) {
+ bestScore = score
+ best = [matching]
+ } else if (order === 0) {
+ best.push(matching)
+ }
+ }
+ const signatures = new Map(best.map((matching) => [
+ matching.map(({ before: a, after: b }) => `${a}:${b}`).join(','),
+ matching,
+ ]))
+ if (signatures.size > 1) {
+ return { coarseReason: 'ambiguous-attribution' as const }
+ }
+ return { steps: alignmentSteps(before.length, after.length, [...signatures.values()][0]!) }
+}
+
+function alignmentSteps(beforeCount: number, afterCount: number, matches: readonly OracleMatch[]) {
+ const steps: ComparisonAlignmentStep[] = []
+ let before = 0
+ let after = 0
+ for (const match of matches) {
+ while (before < match.before) {
+ steps.push({ before: before++, after: null })
+ }
+ while (after < match.after) {
+ steps.push({ before: null, after: after++ })
+ }
+ steps.push({ before: before++, after: after++ })
+ }
+ while (before < beforeCount) {
+ steps.push({ before: before++, after: null })
+ }
+ while (after < afterCount) {
+ steps.push({ before: null, after: after++ })
+ }
+ return steps
+}
+
+function axes(items: readonly OracleItem[], maximumLength: number): OracleItem[][] {
+ const result: OracleItem[][] = [[]]
+ for (let length = 1; length <= maximumLength; length++) {
+ for (const prefix of result.filter((axis) => axis.length === length - 1)) {
+ for (const item of items) {
+ result.push([...prefix, item])
+ }
+ }
+ }
+ return result
+}
+
+function freshWork(): ComparisonWorkLedger {
+ return {
+ remainingCells: DEFAULT_COMPARISON_CELL_LEDGER,
+ remainingTokenComparisons: DEFAULT_COMPARISON_TOKEN_LEDGER,
+ }
+}
+
+describe('comparison alignment exact oracles', () => {
+ it('matches an independent exact-rational and signature oracle exhaustively', () => {
+ const items: OracleItem[] = [
+ { fingerprint: 'a', profile: ['shared', 'a'] },
+ { fingerprint: 'b', profile: ['shared', 'b'] },
+ { fingerprint: 'c', profile: ['c'] },
+ ]
+ const candidates = axes(items, 3)
+ for (const before of candidates) {
+ for (const after of candidates) {
+ const actual = solveWeightedGap(before, after, {
+ work: freshWork(),
+ fingerprint: (item) => item.fingerprint,
+ profile: (item) => item.profile,
+ compatible: () => true,
+ })
+ expect(actual, `${before.map(({ fingerprint }) => fingerprint)} -> ${after.map(({ fingerprint }) => fingerprint)}`)
+ .toEqual(oracleAlignment(before, after))
+ }
+ }
+ })
+})
diff --git a/src/tests/comparison/comparisonDecorations.spec.ts b/src/tests/comparison/comparisonDecorations.spec.ts
new file mode 100644
index 00000000000..62b217b4f70
--- /dev/null
+++ b/src/tests/comparison/comparisonDecorations.spec.ts
@@ -0,0 +1,90 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { ComparisonDescriptor } from '../../comparison/markdownComparisonTypes.ts'
+
+import { EditorState } from '@tiptap/pm/state'
+import { schema } from 'prosemirror-schema-basic'
+import { describe, expect, it } from 'vitest'
+import { createComparisonDocumentIndex } from '../../comparison/comparisonDocumentIndex.ts'
+import { createComparisonEditor } from '../../comparison/createComparisonEditor.ts'
+import {
+ ComparisonProjectionError,
+ createComparisonDecorationPlugin,
+ prepareComparisonDecorations,
+} from '../../comparison/markdownComparison.ts'
+
+function descriptor(id: string, before: { from: number, to: number }, after = before): ComparisonDescriptor {
+ return {
+ id,
+ operation: 'replace',
+ detail: 'inline',
+ facets: ['text'],
+ before,
+ after,
+ context: { before: null, after: null },
+ preview: { before: null, after: null },
+ signals: [],
+ }
+}
+
+const doc = schema.node('doc', null, [schema.node('paragraph', null, schema.text('hello'))])
+
+describe('comparison decorations', () => {
+ it('does not infer a current descriptor without edit-owned selection', () => {
+ const change = descriptor('text', { from: 1, to: 4 })
+ const { key, plugin } = createComparisonDecorationPlugin([change], 'before', 'Changed')
+ const state = EditorState.create({ doc, plugins: [plugin] })
+ expect(key.getState(state)).toMatchObject({ activeIds: ['text'], currentIds: [] })
+ })
+
+ it('V04 projects non-empty ranges without creating any marker for a zero-length side', () => {
+ expect(prepareComparisonDecorations(doc, [descriptor('empty', { from: 2, to: 2 })], 'before')).toEqual([])
+ const projected = prepareComparisonDecorations(doc, [descriptor('text', { from: 1, to: 4 })], 'before')
+ expect(projected).toEqual([expect.objectContaining({ from: 1, to: 4, type: 'inline' })])
+ })
+
+ it('fails the complete projection when a non-empty range cannot be represented', () => {
+ const invalid = descriptor('invalid', { from: 99, to: 100 })
+ expect(() => prepareComparisonDecorations(doc, [invalid], 'before')).toThrow(ComparisonProjectionError)
+ })
+
+ it('AUD-04 decorates the enclosing list for a coarse nested-list range', () => {
+ const editor = createComparisonEditor('- outer\n - first\n - second')
+ try {
+ const index = createComparisonDocumentIndex(editor.state.doc)
+ const outerList = index.children[0]!
+ const nestedList = outerList.children[0]!.children[1]!
+ const firstItem = nestedList.children[0]!
+ const lastItem = nestedList.children.at(-1)!
+ const change = descriptor('nested-list', { from: firstItem.from, to: lastItem.to })
+ change.detail = 'block'
+ change.context.before = {
+ code: 'list-item',
+ path: firstItem.path,
+ from: firstItem.from,
+ to: firstItem.to,
+ }
+
+ expect(prepareComparisonDecorations(editor.state.doc, [change], 'before')).toEqual([
+ expect.objectContaining({ from: nestedList.from, to: nestedList.to, type: 'node' }),
+ ])
+ } finally {
+ editor.destroy()
+ }
+ })
+
+ it('invalidates prepared immutable decorations after a document transaction', () => {
+ const change = descriptor('text', { from: 1, to: 4 })
+ const { key, plugin } = createComparisonDecorationPlugin([change], 'before', 'Changed', {
+ activeIds: ['text'],
+ currentIds: ['text'],
+ })
+ const state = EditorState.create({ doc, plugins: [plugin] })
+ expect(key.getState(state)?.prepared).toHaveLength(1)
+ const changed = state.apply(state.tr.insertText('!', 1))
+ expect(key.getState(changed)).toMatchObject({ activeIds: [], currentIds: [], prepared: [] })
+ })
+})
diff --git a/src/tests/comparison/comparisonDocumentLocation.spec.ts b/src/tests/comparison/comparisonDocumentLocation.spec.ts
new file mode 100644
index 00000000000..42afa139dd6
--- /dev/null
+++ b/src/tests/comparison/comparisonDocumentLocation.spec.ts
@@ -0,0 +1,52 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { describe, expect, it, vi } from 'vitest'
+import { locateComparisonTarget } from '../../comparison/comparisonNavigation.ts'
+
+function scrollerIn(pane: HTMLElement) {
+ const scroller = document.createElement('div')
+ pane.append(scroller)
+ Object.defineProperties(scroller, {
+ clientHeight: { value: 300 },
+ scrollHeight: { value: 1200 },
+ scrollLeft: { value: 20 },
+ scrollTop: { value: 50 },
+ })
+ vi.spyOn(scroller, 'getBoundingClientRect').mockReturnValue({ height: 300, top: 100 } as DOMRect)
+ Object.defineProperty(scroller, 'scrollTo', { value: vi.fn() })
+ return scroller
+}
+
+describe('comparison document location', () => {
+ it('prefers the decorated DOM target', () => {
+ const pane = document.createElement('article')
+ const scroller = scrollerIn(pane)
+ const target = document.createElement('span')
+ target.dataset.comparisonChange = 'descriptor-1'
+ scroller.append(target)
+ vi.spyOn(target, 'getBoundingClientRect').mockReturnValue({ height: 20, top: 700 } as DOMRect)
+ const fallback = vi.fn(() => ({ top: 900, height: 1 }))
+ expect(locateComparisonTarget(pane, scroller, 'descriptor-1', 'smooth', fallback)).toBe(true)
+ expect(fallback).not.toHaveBeenCalled()
+ })
+
+ it('V04 centers a supplied position rectangle for a marker-free zero-length side', () => {
+ const pane = document.createElement('article')
+ const scroller = scrollerIn(pane)
+ const fallback = vi.fn(() => ({ top: 700, height: 1 }))
+ expect(locateComparisonTarget(pane, scroller, 'missing', 'auto', fallback)).toBe(true)
+ expect(scroller.scrollTo).toHaveBeenCalledWith({ behavior: 'auto', left: 20, top: 500.5 })
+ expect(pane.querySelector('[data-comparison-change="missing"]')).toBeNull()
+ })
+
+ it('fails closed for invalid or hidden panes', () => {
+ const pane = document.createElement('article')
+ const scroller = scrollerIn(pane)
+ pane.hidden = true
+ expect(locateComparisonTarget(pane, scroller, 'missing', 'auto', () => ({ top: 1, height: 1 }))).toBe(false)
+ expect(locateComparisonTarget(null, scroller, 'missing', 'auto')).toBe(false)
+ })
+})
diff --git a/src/tests/comparison/comparisonEditorLifecycle.spec.ts b/src/tests/comparison/comparisonEditorLifecycle.spec.ts
new file mode 100644
index 00000000000..ead3a8dbfbb
--- /dev/null
+++ b/src/tests/comparison/comparisonEditorLifecycle.spec.ts
@@ -0,0 +1,28 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { PluginKey, Plugin as ProseMirrorPlugin } from '@tiptap/pm/state'
+import { mount } from '@vue/test-utils'
+import { describe, expect, it, vi } from 'vitest'
+import ComparisonEditorContent from '../../components/ComparisonEditorContent.vue'
+import { createComparisonEditor } from '../../comparison/createComparisonEditor.ts'
+
+describe('comparison editor lifecycle boundary', () => {
+ it('mounts the detached editor with its comparison plugin and node views', async () => {
+ const editor = createComparisonEditor('::: info\nBefore\n:::')
+ const plugin = new ProseMirrorPlugin({ key: new PluginKey('comparison') })
+ const wrapper = mount(ComparisonEditorContent, { props: { editor, plugins: [plugin] } })
+ try {
+ await vi.waitFor(() => expect(wrapper.emitted('ready')).toHaveLength(1))
+ const content = wrapper.get('.text-comparison__content')
+ expect(editor.view.dom.parentElement).toBe(content.element)
+ expect(content.find('[data-node-view-wrapper][data-text-el="callout"]').exists()).toBe(true)
+ expect(plugin.spec.key?.get(editor.state)).toBeDefined()
+ } finally {
+ wrapper.unmount()
+ editor.destroy()
+ }
+ })
+})
diff --git a/src/tests/comparison/comparisonNavigation.spec.ts b/src/tests/comparison/comparisonNavigation.spec.ts
new file mode 100644
index 00000000000..f627fa4c048
--- /dev/null
+++ b/src/tests/comparison/comparisonNavigation.spec.ts
@@ -0,0 +1,61 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { ComparisonDescriptor, ComparisonEdit } from '../../comparison/markdownComparisonTypes.ts'
+
+import { describe, expect, it } from 'vitest'
+import {
+ currentIdAfterFilter,
+ currentOrdinal,
+ isPureFormatting,
+ moveCurrentId,
+} from '../../comparison/comparisonNavigation.ts'
+
+function descriptor(id: string, facets: ComparisonDescriptor['facets'], operation: ComparisonDescriptor['operation'] = 'replace'): ComparisonDescriptor {
+ return {
+ id,
+ operation,
+ detail: 'inline',
+ facets,
+ before: { from: 0, to: 1 },
+ after: { from: 0, to: 1 },
+ context: { before: null, after: null },
+ preview: { before: null, after: null },
+ signals: [],
+ }
+}
+
+function edit(id: string, descriptors: ComparisonDescriptor[]): ComparisonEdit {
+ return { id, kind: 'content', primary: descriptors.at(-1)!, descriptors }
+}
+
+describe('edit-first comparison navigation', () => {
+ const edits = [
+ edit('e0', [descriptor('d0', ['text'])]),
+ edit('e1', [descriptor('d1', ['formatting'])]),
+ edit('e2', [descriptor('d2a', ['formatting']), descriptor('d2b', ['text', 'formatting'])]),
+ edit('e3', [descriptor('d3', ['attribute'])]),
+ ]
+
+ it('requires every member to be formatting-only', () => {
+ expect(isPureFormatting(edits[1]!)).toBe(true)
+ expect(isPureFormatting(edits[2]!)).toBe(false)
+ })
+
+ it('V02 preserves the current edit or moves next then previous after filtering', () => {
+ expect(currentIdAfterFilter(edits, ['e0', 'e2', 'e3'], 'e2')).toBe('e2')
+ expect(currentIdAfterFilter(edits, ['e0', 'e2', 'e3'], 'e1')).toBe('e2')
+ expect(currentIdAfterFilter(edits, ['e0'], 'e1')).toBe('e0')
+ expect(currentIdAfterFilter(edits, [], 'e1')).toBeNull()
+ })
+
+ it('V01 wraps navigation and reports one ordinal per first-class edit', () => {
+ const active = ['e0', 'e2', 'e3']
+ expect(moveCurrentId(active, 'e0', -1)).toBe('e3')
+ expect(moveCurrentId(active, 'e3', 1)).toBe('e0')
+ expect(currentOrdinal(active, 'e2')).toBe(2)
+ expect(currentOrdinal([], null)).toBe(0)
+ })
+})
diff --git a/src/tests/comparison/comparisonPerformance.spec.ts b/src/tests/comparison/comparisonPerformance.spec.ts
new file mode 100644
index 00000000000..4cbdade1289
--- /dev/null
+++ b/src/tests/comparison/comparisonPerformance.spec.ts
@@ -0,0 +1,171 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { Node } from '@tiptap/pm/model'
+
+import { describe, expect, it } from 'vitest'
+import {
+ alignComparisonAxis,
+ createComparisonWorkLedger,
+ DEFAULT_COMPARISON_TOKEN_LEDGER,
+} from '../../comparison/comparisonAlignment.ts'
+import { createHierarchicalMarkdownComparisonModel } from '../../comparison/hierarchicalMarkdownComparisonModel.ts'
+import { prepareComparisonDecorations } from '../../comparison/markdownComparison.ts'
+import { createComparisonTestEditor } from './comparisonTestEditor.ts'
+
+interface Item {
+ key: string
+ profile: readonly string[]
+}
+
+function items(count: number, side: string): Item[] {
+ return Array.from({ length: count }, (_value, index) => ({
+ key: `${side}:${index}`,
+ profile: [`item:${index}`, side],
+ }))
+}
+
+function options(work = createComparisonWorkLedger()) {
+ return {
+ work,
+ fingerprint: ({ key }: Item) => key,
+ profile: ({ profile }: Item) => profile,
+ compatible: () => true,
+ }
+}
+
+describe('bounded comparison performance fixtures', () => {
+ it('AUD-14 projects near-limit one-sided descriptors within a bounded candidate budget', () => {
+ const editor = createComparisonTestEditor('placeholder')
+ try {
+ const headings = Array.from({ length: 6490 }, (_value, index) => (
+ editor.schema.nodes.heading!.create({ level: 1 }, editor.schema.text(`Section ${index}`))
+ ))
+ const populated = editor.schema.nodes.doc!.create(null, headings)
+ const empty = editor.schema.nodes.doc!.create()
+ const model = createHierarchicalMarkdownComparisonModel(populated, empty)
+ const descriptors = model.edits.flatMap(({ descriptors: members }) => members)
+
+ const prepared = prepareComparisonDecorations(populated, descriptors, 'before')
+
+ expect(prepared).toHaveLength(headings.length)
+ } finally {
+ editor.destroy()
+ }
+ })
+
+ it('P01 compares a near-6500-line exact-anchor document with negligible weighted work', () => {
+ const editor = createComparisonTestEditor('placeholder')
+ try {
+ const headings = Array.from({ length: 6490 }, (_value, index) => (
+ editor.schema.nodes.heading!.create({ level: 1 }, editor.schema.text(`Section ${index}`))
+ ))
+ const before = editor.schema.nodes.doc!.create(null, headings)
+ const changedHeading = editor.schema.nodes.heading!.create(
+ { level: 1 },
+ editor.schema.text('Section 3245 edited'),
+ )
+ const after = editor.schema.nodes.doc!.create(null, headings.with(3245, changedHeading))
+
+ const model = createHierarchicalMarkdownComparisonModel(before, after)
+
+ expect(model.edits).toHaveLength(1)
+
+ const work = createComparisonWorkLedger()
+ const axis = Array.from({ length: 6490 }, (_value, index) => ({
+ key: `anchor:${index}`,
+ profile: [`anchor:${index}`],
+ }))
+ const changed = axis.with(3245, { key: 'changed:3245', profile: ['changed:3245'] })
+ alignComparisonAxis(axis, changed, options(work))
+ expect(work).toEqual(createComparisonWorkLedger())
+ } finally {
+ editor.destroy()
+ }
+ })
+
+ it.each(['insert', 'delete'] as const)('places a near-6500-line one-sided %s axis in linear time', (operation) => {
+ const editor = createComparisonTestEditor('placeholder')
+ try {
+ const headings = Array.from({ length: 6490 }, (_value, index) => (
+ editor.schema.nodes.heading!.create({ level: 1 }, editor.schema.text(`Section ${index}`))
+ ))
+ const empty = editor.schema.nodes.doc!.create()
+ const populated = editor.schema.nodes.doc!.create(null, headings)
+ const model = operation === 'insert'
+ ? createHierarchicalMarkdownComparisonModel(empty, populated)
+ : createHierarchicalMarkdownComparisonModel(populated, empty)
+
+ expect(model.edits).toHaveLength(headings.length)
+ expect(model.edits.every(({ primary }) => primary.operation === operation)).toBe(true)
+ } finally {
+ editor.destroy()
+ }
+ })
+
+ it('P04 shares the final token ledger across nested production nodes', () => {
+ const editor = createComparisonTestEditor('placeholder')
+ try {
+ const firstBeforeCount = 100
+ const firstAfterCount = firstBeforeCount - 1
+ const firstProduct = firstBeforeCount * firstAfterCount
+ const firstLength = Math.floor(DEFAULT_COMPARISON_TOKEN_LEDGER / (4 * firstProduct))
+ const firstCharge = 2 * firstProduct * firstLength
+ const secondCount = 100
+ const secondLength = Math.floor((DEFAULT_COMPARISON_TOKEN_LEDGER - firstCharge) / (2 * secondCount ** 2)) + 1
+ const paragraphs = (count: number, character: string, length: number) => Array.from(
+ { length: count },
+ () => editor.schema.nodes.paragraph!.create(null, editor.schema.text(character.repeat(length))),
+ )
+ const quote = (children: readonly Node[]) => (
+ editor.schema.nodes.blockquote!.create(null, children)
+ )
+ const anchor = editor.schema.nodes.paragraph!.create(null, editor.schema.text('exact nested boundary anchor'))
+ const before = editor.schema.nodes.doc!.create(null, [
+ quote(paragraphs(firstBeforeCount, 'a', firstLength)),
+ anchor,
+ quote(paragraphs(secondCount, 'c', secondLength)),
+ ])
+ const after = editor.schema.nodes.doc!.create(null, [
+ quote(paragraphs(firstAfterCount, 'b', firstLength)),
+ anchor,
+ quote(paragraphs(secondCount, 'd', secondLength)),
+ ])
+ const model = createHierarchicalMarkdownComparisonModel(before, after)
+
+ expect(2 * secondCount ** 2 * (secondLength - 1)).toBeLessThanOrEqual(DEFAULT_COMPARISON_TOKEN_LEDGER - firstCharge)
+ expect(2 * secondCount ** 2 * secondLength).toBeGreaterThan(DEFAULT_COMPARISON_TOKEN_LEDGER - firstCharge)
+ expect(model.edits.map(({ primary }) => primary.coarseReason)).toEqual([
+ 'ambiguous-attribution',
+ 'comparison-limit',
+ ])
+ } finally {
+ editor.destroy()
+ }
+ })
+
+ it('P03 bounds many aggregate maximal gaps with one comparison-wide ledger', () => {
+ const gapCount = 5
+ const gapSize = 200
+ const before: Item[] = []
+ const after: Item[] = []
+ for (let gap = 0; gap < gapCount; gap++) {
+ before.push(...items(gapSize, `before-${gap}`))
+ after.push(...items(gapSize, `after-${gap}`))
+ if (gap < gapCount - 1) {
+ const anchor = { key: `anchor-${gap}`, profile: [`anchor-${gap}`] }
+ before.push(anchor)
+ after.push(anchor)
+ }
+ }
+ const work = createComparisonWorkLedger()
+
+ const result = alignComparisonAxis(before, after, options(work))
+ const limited = result.filter((region) => 'coarseReason' in region && region.coarseReason === 'comparison-limit')
+
+ expect(work.remainingCells).toBe(0)
+ expect(limited).toHaveLength(gapCount - 1)
+ })
+})
diff --git a/src/tests/comparison/comparisonPresentation.spec.ts b/src/tests/comparison/comparisonPresentation.spec.ts
new file mode 100644
index 00000000000..92be57d563f
--- /dev/null
+++ b/src/tests/comparison/comparisonPresentation.spec.ts
@@ -0,0 +1,28 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { ComparisonAttributeCode, ComparisonSignal } from '../../comparison/markdownComparisonTypes.ts'
+
+import { describe, expect, it } from 'vitest'
+import { selectComparisonSignal } from '../../comparison/comparisonPresentation.ts'
+
+const bold: ComparisonSignal = { type: 'mark', mark: 'bold', change: 'added' }
+const attribute = (code: ComparisonAttributeCode): ComparisonSignal => ({ type: 'attribute', attribute: code, change: 'changed' })
+
+describe('AUD-10 comparison presentation', () => {
+ it('selects the same strongest attribute regardless of descriptor storage order', () => {
+ const signals = [bold, attribute('image-alt'), attribute('image-target')]
+ expect(selectComparisonSignal(signals)).toEqual(attribute('image-target'))
+ expect(selectComparisonSignal([...signals].reverse())).toEqual(attribute('image-target'))
+ })
+
+ it('prioritizes every specific attribute and node structure over generic formatting', () => {
+ for (const code of ['link', 'task-state', 'heading-level', 'table-span', 'unknown-attribute'] as const) {
+ expect(selectComparisonSignal([bold, attribute(code)])).toEqual(attribute(code))
+ }
+ const node: ComparisonSignal = { type: 'node' }
+ expect(selectComparisonSignal([bold, node])).toEqual(node)
+ })
+})
diff --git a/src/tests/comparison/comparisonSections.spec.ts b/src/tests/comparison/comparisonSections.spec.ts
new file mode 100644
index 00000000000..2dd787ba6f4
--- /dev/null
+++ b/src/tests/comparison/comparisonSections.spec.ts
@@ -0,0 +1,76 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { Node } from '@tiptap/pm/model'
+import type { ComparisonDescriptor, ComparisonEdit } from '../../comparison/markdownComparisonTypes.ts'
+
+import { schema } from 'prosemirror-schema-basic'
+import { describe, expect, it } from 'vitest'
+import { buildComparisonSections, headingLocations, nearestHeading } from '../../comparison/comparisonSections.ts'
+
+function doc(...blocks: Array<[type: 'heading' | 'paragraph', text: string]>): Node {
+ return schema.node('doc', null, blocks.map(([type, text]) => schema.node(type, type === 'heading' ? { level: 1 } : null, text ? schema.text(text) : undefined)))
+}
+
+function descriptor(id: string, operation: ComparisonDescriptor['operation'], before: number, after: number): ComparisonDescriptor {
+ return {
+ id,
+ operation,
+ detail: 'inline',
+ facets: ['text'],
+ before: { from: before, to: before + 1 },
+ after: { from: after, to: after + 1 },
+ context: {
+ before: { code: 'paragraph', path: [1], from: before, to: before + 1 },
+ after: { code: 'paragraph', path: [1], from: after, to: after + 1 },
+ },
+ preview: { before: null, after: null },
+ signals: [],
+ }
+}
+
+function edit(id: string, primary: ComparisonDescriptor, members: ComparisonDescriptor[] = [primary]): ComparisonEdit {
+ return { id, kind: 'content', primary, descriptors: members }
+}
+
+describe('edit-first comparison sections', () => {
+ it('finds ordered headings and resolves the nearest preceding heading', () => {
+ const document = doc(['paragraph', 'Intro'], ['heading', 'One'], ['paragraph', 'Body'], ['heading', 'Two'])
+ const headings = headingLocations(document)
+ expect(headings.map(({ text }) => text)).toEqual(['One', 'Two'])
+ expect(nearestHeading(headings, 0)).toBe('')
+ expect(nearestHeading(headings, headings[1]!.from)).toBe('Two')
+ })
+
+ it('builds one row source per edit', () => {
+ const before = doc(['heading', 'Alpha'], ['paragraph', 'Before'])
+ const after = doc(['heading', 'Alpha'], ['paragraph', 'After'])
+ const headingEnd = after.child(0).nodeSize
+ const primary = descriptor('d-primary', 'replace', headingEnd, headingEnd)
+ const formatting = { ...descriptor('d-format', 'replace', headingEnd, headingEnd), facets: ['formatting'] as const }
+ const sections = buildComparisonSections([edit('edit-1', primary, [formatting, primary])], before, after)
+
+ expect(sections).toEqual([expect.objectContaining({
+ id: 'edit-1',
+ title: 'Alpha',
+ edits: [expect.objectContaining({ id: 'edit-1', primary })],
+ })])
+ })
+
+ it('uses Before context for deletions and the After title for a correlated rename', () => {
+ const before = doc(['heading', 'Old'], ['paragraph', 'Before'])
+ const after = doc(['heading', 'New'], ['paragraph', 'After'])
+ const beforeBody = before.child(0).nodeSize
+ const afterBody = after.child(0).nodeSize
+ const rename = descriptor('rename', 'replace', 0, 0)
+ rename.context.before = { code: 'heading', path: [0], from: 0, to: beforeBody }
+ rename.context.after = { code: 'heading', path: [0], from: 0, to: afterBody }
+ const deletion = descriptor('delete', 'delete', beforeBody, afterBody)
+ const sections = buildComparisonSections([edit('rename-edit', rename), edit('delete-edit', deletion)], before, after)
+
+ expect(sections.map(({ title }) => title)).toEqual(['New'])
+ expect(sections[0]!.edits.map(({ id }) => id)).toEqual(['rename-edit', 'delete-edit'])
+ })
+})
diff --git a/src/tests/comparison/comparisonTestEditor.ts b/src/tests/comparison/comparisonTestEditor.ts
new file mode 100644
index 00000000000..103a67e7973
--- /dev/null
+++ b/src/tests/comparison/comparisonTestEditor.ts
@@ -0,0 +1,19 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { createComparisonEditor } from '../../comparison/createComparisonEditor.ts'
+
+export function createComparisonTestEditor(content: string) {
+ return createComparisonEditor(content, { noLazyImages: true })
+}
+
+export function comparisonTestDocument(content: string) {
+ const editor = createComparisonEditor(content, { noLazyImages: true })
+ try {
+ return editor.state.doc
+ } finally {
+ editor.destroy()
+ }
+}
diff --git a/src/tests/comparison/createComparisonEditor.spec.ts b/src/tests/comparison/createComparisonEditor.spec.ts
new file mode 100644
index 00000000000..cda29bf339d
--- /dev/null
+++ b/src/tests/comparison/createComparisonEditor.spec.ts
@@ -0,0 +1,28 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { describe, expect, it } from 'vitest'
+import { createComparisonEditor } from '../../comparison/createComparisonEditor.ts'
+
+describe('comparison editor', () => {
+ it('creates a complete immutable detached Text editor with directional paragraphs', () => {
+ const editor = createComparisonEditor('English\n\nالعربية')
+ try {
+ expect(editor.options.element).toBeInstanceOf(HTMLElement)
+ expect((editor.options.element as HTMLElement).isConnected).toBe(false)
+ expect(editor.isEditable).toBe(false)
+ expect(editor.state.doc.textContent).toBe('Englishالعربية')
+ const directions: Array = []
+ editor.state.doc.descendants((node) => {
+ if (node.type.name === 'paragraph') {
+ directions.push(node.attrs.dir as string | null)
+ }
+ })
+ expect(directions.slice(0, 2)).toEqual(['ltr', 'rtl'])
+ } finally {
+ editor.destroy()
+ }
+ })
+})
diff --git a/src/tests/comparison/createMarkdownContentComparison.spec.ts b/src/tests/comparison/createMarkdownContentComparison.spec.ts
new file mode 100644
index 00000000000..53c3fd57479
--- /dev/null
+++ b/src/tests/comparison/createMarkdownContentComparison.spec.ts
@@ -0,0 +1,281 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { Editor } from '@tiptap/vue-3'
+import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from 'vitest'
+import { nextTick } from 'vue'
+import * as markdownComparison from '../../comparison/markdownComparison.ts'
+import { createMarkdownContentComparison } from '../../createMarkdownContentComparison.ts'
+
+const originalScrollTo = HTMLElement.prototype.scrollTo
+
+beforeAll(async () => {
+ HTMLElement.prototype.scrollTo = vi.fn()
+ await Promise.all([
+ import('../../components/MarkdownContentComparison.vue'),
+ import('../../components/MarkdownSourceFallback.vue'),
+ ])
+})
+
+afterAll(() => {
+ if (originalScrollTo) {
+ HTMLElement.prototype.scrollTo = originalScrollTo
+ } else {
+ delete (HTMLElement.prototype as Partial).scrollTo
+ }
+})
+
+afterEach(() => vi.restoreAllMocks())
+
+describe('Markdown comparison factory fallback and lifecycle', () => {
+ it('V09 reports syntax-only Markdown as no semantic edit and opens Source', async () => {
+ const el = document.createElement('div')
+ const instance = await createMarkdownContentComparison({
+ beforeContent: '*same rendered text*',
+ afterContent: '_same rendered text_',
+ el,
+ })
+
+ expect(el.querySelectorAll('[data-comparison-change]')).toHaveLength(0)
+ expect(el.querySelector('[role="status"]')?.textContent).toContain('No rendered differences')
+ const openSource = el.querySelector('[data-comparison-empty-action]')
+ expect(openSource).not.toBeNull()
+ openSource!.click()
+ await nextTick()
+ expect([...el.querySelectorAll('[role="tab"]')]
+ .find(({ textContent }) => textContent?.trim() === 'Markdown source')
+ ?.getAttribute('aria-selected')).toBe('true')
+ instance.destroy()
+ })
+
+ it('F05 remounts complete Source when rendered editor initialization fails', async () => {
+ vi.spyOn(Editor.prototype, 'mount').mockImplementation(() => {
+ throw new Error('forced mount failure')
+ })
+ const el = document.createElement('div')
+ const instance = await createMarkdownContentComparison({ beforeContent: 'before', afterContent: 'after', el })
+ expect(el.querySelector('[data-comparison-source-fallback]')).not.toBeNull()
+ expect(el.querySelectorAll('.ProseMirror')).toHaveLength(0)
+ expect(el.textContent).toContain('before')
+ expect(el.textContent).toContain('after')
+ instance.destroy()
+ instance.destroy()
+ expect(el.childElementCount).toBe(0)
+ })
+
+ it('F06 remounts complete Source without partial Documents when projection fails', async () => {
+ const originalSetAttribute = Element.prototype.setAttribute
+ vi.spyOn(Element.prototype, 'setAttribute').mockImplementation(function(this: Element, name, value) {
+ if (name === 'data-comparison-change') {
+ throw new Error('forced projection failure')
+ }
+ return originalSetAttribute.call(this, name, value)
+ })
+ const beforeContent = 'Complete projection before'
+ const afterContent = 'Complete projection after'
+ const el = document.createElement('div')
+ const instance = await createMarkdownContentComparison({ beforeContent, afterContent, el })
+ const fullDocuments = [...el.querySelectorAll('[role="tab"]')]
+ .find(({ textContent }) => textContent?.trim() === 'Full documents')
+
+ fullDocuments!.click()
+ await vi.waitFor(() => {
+ expect(el.querySelector('[data-comparison-source-fallback]')).not.toBeNull()
+ })
+ expect(el.querySelectorAll('.text-comparison__documents .ProseMirror')).toHaveLength(0)
+ expect(el.textContent).toContain(beforeContent)
+ expect(el.textContent).toContain(afterContent)
+ instance.destroy()
+ })
+
+ it('V12 can reopen the same pair after idempotent destroy without leaking root DOM', async () => {
+ const el = document.createElement('div')
+ for (let index = 0; index < 2; index++) {
+ const instance = await createMarkdownContentComparison({ beforeContent: 'Before', afterContent: 'After', el })
+ expect(el.querySelectorAll('.text-comparison-root')).toHaveLength(1)
+ instance.destroy()
+ instance.destroy()
+ expect(el.childElementCount).toBe(0)
+ }
+ })
+
+ it('keeps both document editors alive while switching views', async () => {
+ const el = document.createElement('div')
+ const instance = await createMarkdownContentComparison({ beforeContent: 'Before', afterContent: 'After', el })
+ expect(el.querySelectorAll('.ProseMirror')).toHaveLength(0)
+ expect(el.querySelectorAll('[data-comparison-source-fallback]')).toHaveLength(0)
+ const selectTab = async (label: string) => {
+ const tab = [...el.querySelectorAll('[role="tab"]')]
+ .find(({ textContent }) => textContent?.trim() === label)
+ expect(tab).toBeDefined()
+ tab!.click()
+ await nextTick()
+ }
+
+ await selectTab('Full documents')
+ expect(el.querySelectorAll('.ProseMirror')).toHaveLength(2)
+ await selectTab('Changes')
+ await selectTab('Full documents')
+
+ expect(el.querySelector('.text-comparison > [data-comparison-source-fallback]')).toBeNull()
+ expect(el.querySelectorAll('.ProseMirror')).toHaveLength(2)
+ instance.destroy()
+ })
+
+ it('omits duplicate heading anchors from the two comparison documents', async () => {
+ const el = document.createElement('div')
+ const instance = await createMarkdownContentComparison({
+ beforeContent: '# Shared heading\n\nBefore',
+ afterContent: '# Shared heading\n\nAfter',
+ el,
+ })
+ const documents = [...el.querySelectorAll('[role="tab"]')]
+ .find(({ textContent }) => textContent?.trim() === 'Full documents')
+
+ documents!.click()
+ await nextTick()
+
+ await vi.waitFor(() => expect(el.querySelectorAll('.ProseMirror')).toHaveLength(2))
+ await new Promise((resolve) => setTimeout(resolve, 0))
+ expect(el.querySelectorAll('.text-comparison__documents .heading-anchor[id]')).toHaveLength(0)
+ instance.destroy()
+ })
+
+ it('AUD-02 publishes the current selection when Documents mounts lazily', async () => {
+ const originalScrollTo = HTMLElement.prototype.scrollTo
+ const scrollTo = vi.fn()
+ HTMLElement.prototype.scrollTo = scrollTo
+ const el = document.createElement('div')
+ const instance = await createMarkdownContentComparison({
+ beforeContent: 'Old first.\n\nOld second.',
+ afterContent: 'New first.\n\nNew second.',
+ el,
+ })
+ const secondEdit = el.querySelectorAll('[data-comparison-select]')[1]
+
+ secondEdit!.click()
+ await vi.waitFor(() => {
+ expect(el.querySelectorAll('[data-comparison-change="change-1"][aria-current="true"]')).toHaveLength(2)
+ })
+ await vi.waitFor(() => expect(scrollTo).toHaveBeenCalled())
+ instance.destroy()
+ if (originalScrollTo) {
+ HTMLElement.prototype.scrollTo = originalScrollTo
+ } else {
+ delete (HTMLElement.prototype as Partial).scrollTo
+ }
+ })
+
+ it('AUD-11 locates the current edit on the newly visible side after a single-to-paired resize', async () => {
+ const originalResizeObserver = globalThis.ResizeObserver
+ const originalScrollTo = HTMLElement.prototype.scrollTo
+ const scrollTo = vi.fn()
+ let resizeTo!: (width: number) => void
+ HTMLElement.prototype.scrollTo = scrollTo
+ globalThis.ResizeObserver = class {
+ constructor(private readonly callback: ResizeObserverCallback) {}
+
+ observe(target: Element) {
+ resizeTo = (width) => this.callback([{ target, contentRect: { width } } as ResizeObserverEntry], this)
+ resizeTo(600)
+ }
+
+ disconnect() {}
+
+ unobserve() {}
+ } as typeof ResizeObserver
+ const el = document.createElement('div')
+ const instance = await createMarkdownContentComparison({
+ beforeContent: 'Old first.\n\nOld second.',
+ afterContent: 'New first.\n\nNew second.',
+ el,
+ })
+ try {
+ el.querySelectorAll('[data-comparison-select]')[1]!.click()
+ await vi.waitFor(() => expect(el.querySelector('.text-comparison--single')).not.toBeNull())
+ const afterScroller = el.querySelector('.text-comparison__document--after .text-comparison__document-scroller')!
+ await vi.waitFor(() => expect(scrollTo).toHaveBeenCalled())
+ expect(scrollTo.mock.contexts).not.toContain(afterScroller)
+
+ resizeTo(900)
+ await vi.waitFor(() => expect(el.querySelector('.text-comparison--paired')).not.toBeNull())
+
+ expect(scrollTo.mock.contexts).toContain(afterScroller)
+ } finally {
+ instance.destroy()
+ globalThis.ResizeObserver = originalResizeObserver
+ if (originalScrollTo) {
+ HTMLElement.prototype.scrollTo = originalScrollTo
+ } else {
+ delete (HTMLElement.prototype as Partial).scrollTo
+ }
+ }
+ })
+
+ it('keeps the working comparison when the loaded callback throws', async () => {
+ const el = document.createElement('div')
+ const creation = createMarkdownContentComparison({
+ beforeContent: 'Before',
+ afterContent: 'After',
+ el,
+ onLoaded: () => { throw new Error('callback failure') },
+ })
+ const instance = await Promise.race([
+ creation,
+ new Promise((resolve) => setTimeout(() => resolve(null), 1000)),
+ ])
+ expect(instance).not.toBeNull()
+ expect(el.querySelector('.text-comparison')).not.toBeNull()
+ expect(el.querySelector('[data-comparison-source-fallback]')).toBeNull()
+ instance?.destroy()
+ })
+
+ it('AUD-21 awaits a rejected loaded callback and keeps the working comparison', async () => {
+ const el = document.createElement('div')
+ let rejectLoaded!: (error: Error) => void
+ const onLoaded = vi.fn(() => new Promise((_resolve, reject) => {
+ rejectLoaded = reject
+ }))
+ const creation = createMarkdownContentComparison({
+ beforeContent: 'Before',
+ afterContent: 'After',
+ el,
+ onLoaded,
+ })
+ let creationSettled = false
+ void creation.then(() => {
+ creationSettled = true
+ })
+ await new Promise((resolve) => setTimeout(resolve, 0))
+
+ expect(onLoaded).toHaveBeenCalledOnce()
+ expect(creationSettled).toBe(false)
+ rejectLoaded(new Error('async callback failure'))
+ const instance = await creation
+
+ expect(el.querySelector('.text-comparison')).not.toBeNull()
+ expect(el.querySelector('[data-comparison-source-fallback]')).toBeNull()
+ instance.destroy()
+ })
+
+ it('F07 routes a descriptor model limit to complete Source', async () => {
+ vi.spyOn(markdownComparison, 'createMarkdownComparisonModel').mockImplementation(() => {
+ throw new markdownComparison.ComparisonModelLimitError()
+ })
+ const beforeContent = '# Complete before snapshot\n\nBefore body\n'
+ const afterContent = '# Complete after snapshot\n\nAfter body\n'
+ const el = document.createElement('div')
+
+ const instance = await createMarkdownContentComparison({ beforeContent, afterContent, el })
+
+ expect(el.querySelector('[data-comparison-source-fallback]')).not.toBeNull()
+ expect(el.querySelectorAll('.ProseMirror')).toHaveLength(0)
+ expect(el.textContent).toContain('Detailed rendered comparison unavailable')
+ expect(el.textContent).not.toContain('No rendered changes')
+ expect(el.textContent).toContain(beforeContent)
+ expect(el.textContent).toContain(afterContent)
+ instance.destroy()
+ })
+})
diff --git a/src/tests/comparison/hierarchicalMarkdownComparison.spec.ts b/src/tests/comparison/hierarchicalMarkdownComparison.spec.ts
new file mode 100644
index 00000000000..88ac12c2f13
--- /dev/null
+++ b/src/tests/comparison/hierarchicalMarkdownComparison.spec.ts
@@ -0,0 +1,363 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { Node } from '@tiptap/pm/model'
+import type { ComparisonEdit, ComparisonSide } from '../../comparison/markdownComparisonTypes.ts'
+
+import { Schema } from '@tiptap/pm/model'
+import { schema as basicSchema } from 'prosemirror-schema-basic'
+import { describe, expect, it } from 'vitest'
+import {
+ ComparisonModelLimitError,
+ createHierarchicalMarkdownComparisonModel,
+ MAX_INLINE_ENVELOPE_SIZE,
+ MAX_RENDERED_COMPARISON_DESCRIPTORS,
+} from '../../comparison/hierarchicalMarkdownComparisonModel.ts'
+import { comparisonTestDocument, createComparisonTestEditor } from './comparisonTestEditor.ts'
+
+function compare(beforeContent: string, afterContent: string) {
+ const before = comparisonTestDocument(beforeContent)
+ const after = comparisonTestDocument(afterContent)
+ return {
+ before,
+ after,
+ model: createHierarchicalMarkdownComparisonModel(before, after),
+ }
+}
+
+function meaningfulSize(doc: Node) {
+ return doc.content.size - (doc.lastChild?.content.size === 0 ? doc.lastChild.nodeSize : 0)
+}
+
+function editText(doc: { textBetween: (from: number, to: number, separator: string) => string }) {
+ return (edit: ComparisonEdit, side: ComparisonSide) => (
+ doc.textBetween(edit.primary[side].from, edit.primary[side].to, '\n')
+ )
+}
+
+describe('hierarchical markdown comparison', () => {
+ it('A01 emits no edit for two equal documents', () => {
+ const { model } = compare('# Title\n\nBody text.\n', '# Title\n\nBody text.\n')
+
+ expect(model.edits).toEqual([])
+ })
+
+ it('A02 normalizes separate schema instances without position or content drift', () => {
+ const beforeEditor = createComparisonTestEditor('# Title\n\nOriginal body.\n')
+ const afterEditor = createComparisonTestEditor('# Title\n\nUpdated body.\n')
+ try {
+ const before = beforeEditor.state.doc
+ const after = afterEditor.state.doc
+ expect(before.type.schema).not.toBe(after.type.schema)
+
+ const model = createHierarchicalMarkdownComparisonModel(before, after)
+
+ expect(model.edits).toHaveLength(1)
+ const [edit] = model.edits
+ expect(before.textBetween(edit!.primary.before.from, edit!.primary.before.to)).toBe('Original')
+ expect(after.textBetween(edit!.primary.after.from, edit!.primary.after.to)).toBe('Updated')
+ } finally {
+ beforeEditor.destroy()
+ afterEditor.destroy()
+ }
+ })
+
+ it('AUD-19 rejects cross-schema normalization that drops node attributes', () => {
+ const paragraph = basicSchema.spec.nodes.get('paragraph')!
+ const beforeSchema = new Schema({
+ nodes: basicSchema.spec.nodes.update('paragraph', { ...paragraph, attrs: { audit: { default: null } } }),
+ marks: basicSchema.spec.marks,
+ })
+ const afterSchema = new Schema({ nodes: basicSchema.spec.nodes, marks: basicSchema.spec.marks })
+ const before = beforeSchema.node('doc', null, [beforeSchema.node('paragraph', { audit: 'must-survive' }, beforeSchema.text('same'))])
+ const after = afterSchema.node('doc', null, [afterSchema.node('paragraph', null, afterSchema.text('same'))])
+
+ expect(() => createHierarchicalMarkdownComparisonModel(before, after)).toThrow(/schema normalization lost semantics/)
+ })
+
+ it('A05 retains the first repeated paragraph and inserts the second copy', () => {
+ const { after, model } = compare('Anchor\n\nSame\n', 'Anchor\n\nSame\n\nSame\n')
+ const text = editText(after)
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]!.primary.operation).toBe('insert')
+ expect(text(model.edits[0]!, 'after')).toBe('Same')
+ expect(model.edits[0]!.primary.after).toEqual({
+ from: after.child(0).nodeSize + after.child(1).nodeSize,
+ to: meaningfulSize(after),
+ })
+ })
+
+ it('A06 retains the first repeated paragraph and deletes the second copy', () => {
+ const { before, model } = compare('Anchor\n\nSame\n\nSame\n', 'Anchor\n\nSame\n')
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]!.primary.operation).toBe('delete')
+ expect(model.edits[0]!.primary.before).toEqual({
+ from: before.child(0).nodeSize + before.child(1).nodeSize,
+ to: meaningfulSize(before),
+ })
+ })
+
+ it.each([
+ ['insertion', '# Existing\n', '## Added\n\n# Existing\n', 'insert'],
+ ['deletion', '## Removed\n\n# Existing\n', '# Existing\n', 'delete'],
+ ] as const)('AUD-12 reports a heading %s as added or removed without adjacent heading attributes', (_name, beforeContent, afterContent, operation) => {
+ const { model } = compare(beforeContent, afterContent)
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]!.primary.operation).toBe(operation)
+ expect(model.edits[0]!.primary.signals).not.toContainEqual(expect.objectContaining({
+ type: 'attribute',
+ attribute: 'heading-level',
+ }))
+ })
+
+ it('A07 reports a paragraph turning into a heading as one semantic replacement', () => {
+ const { model } = compare('Shared title\n', '# Shared title\n')
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({
+ kind: 'content',
+ primary: {
+ detail: 'block',
+ operation: 'replace',
+ context: { before: { code: 'paragraph' }, after: { code: 'heading' } },
+ },
+ })
+ expect(model.edits[0]!.primary.facets).toContain('structure')
+ expect(model.edits[0]!.primary.signals).toContainEqual({
+ type: 'attribute',
+ attribute: 'heading-level',
+ change: 'added',
+ })
+ })
+
+ it('A08 does not pair incompatible non-text containers', () => {
+ const { model } = compare('- Shared item\n', '> Shared item\n')
+
+ expect(model.edits).toHaveLength(2)
+ expect(model.edits.map(({ primary }) => primary.operation).toSorted()).toEqual(['delete', 'insert'])
+ })
+
+ it.each([
+ ['section headings', '# Setup\n\n# Usage\n\n# Notes\n', '# Install\n\n# Config\n'],
+ ['shopping items', 'Buy milk\n\nBuy eggs\n\nBuy rice\n', 'Get bread\n\nGet jam\n'],
+ ])('A10 coarsens a no-affix %s rewrite', (_name, beforeContent, afterContent) => {
+ const { before, after, model } = compare(beforeContent, afterContent)
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]!.primary).toMatchObject({
+ coarseReason: 'ambiguous-attribution',
+ detail: 'block',
+ operation: 'replace',
+ before: { from: 0, to: meaningfulSize(before) },
+ after: { from: 0, to: meaningfulSize(after) },
+ })
+ })
+
+ it('reports one reordered block as one move edit', () => {
+ const { model } = compare(
+ 'Unique alpha\n\nUnique beta\n\nUnique gamma\n',
+ 'Unique beta\n\nUnique gamma\n\nUnique alpha\n',
+ )
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]!.primary).toMatchObject({
+ operation: 'move',
+ detail: 'block',
+ facets: ['structure'],
+ })
+ })
+
+ it('pairs uniquely compatible changed containers instead of coarsening their shared gap', () => {
+ const before = [
+ '# Operational notes',
+ '',
+ '> Draft maintenance window starts at 20:00.',
+ '',
+ '::: info',
+ 'The canary is limited to one region.',
+ ':::',
+ '',
+ '',
+ 'Draft runbook
',
+ '',
+ 'Rollback after two failed health checks.',
+ '',
+ '',
+ '',
+ ].join('\n')
+ const after = [
+ '# Operational notes',
+ '',
+ '> Approved maintenance window starts at 21:00.',
+ '',
+ '::: warn',
+ 'The canary is limited to two regions.',
+ ':::',
+ '',
+ '',
+ 'Approved runbook
',
+ '',
+ 'Rollback after one failed health check.',
+ '',
+ '',
+ '',
+ ].join('\n')
+ const { model } = compare(before, after)
+ const attributes = model.edits.flatMap(({ descriptors }) => descriptors)
+ .flatMap(({ signals }) => signals)
+ .filter((signal) => signal.type === 'attribute')
+ .map(({ attribute }) => attribute)
+ const primaryAttributes = model.edits
+ .flatMap(({ primary }) => primary.signals)
+ .filter((signal) => signal.type === 'attribute')
+ .map(({ attribute }) => attribute)
+
+ expect(model.edits.length).toBeGreaterThan(3)
+ expect(model.edits.every(({ primary }) => primary.coarseReason === undefined)).toBe(true)
+ expect(attributes).toContain('callout-type')
+ expect(attributes).toContain('details-state')
+ expect(primaryAttributes.filter((attribute) => attribute === 'callout-type')).toHaveLength(1)
+ expect(primaryAttributes.filter((attribute) => attribute === 'details-state')).toHaveLength(1)
+ })
+
+ it('does not label code content edits as language changes', () => {
+ const { model } = compare(
+ '```javascript\nconst stage = "draft"\n```\n',
+ '```typescript\nconst stage = "ready"\n```\n',
+ )
+ const languageEdits = model.edits.filter(({ primary }) => primary.signals.some((signal) => (
+ signal.type === 'attribute' && signal.attribute === 'code-language'
+ )))
+
+ expect(languageEdits).toHaveLength(1)
+ expect(model.edits.some(({ primary }) => (
+ primary.preview.before?.kind === 'text'
+ && primary.preview.before.text === 'draft'
+ && primary.signals.every((signal) => signal.type !== 'attribute' || signal.attribute !== 'code-language')
+ ))).toBe(true)
+ })
+
+ it('expands front-matter previews to complete changed lines', () => {
+ const { model } = compare([
+ '---',
+ 'release: atlas-2.4',
+ 'status: draft',
+ 'owner: Maya Chen',
+ 'tags: [payments, canary]',
+ 'legacy: true',
+ '---',
+ '',
+ '# Release record',
+ ].join('\n'), [
+ '---',
+ 'release: atlas-2.4.1',
+ 'status: approved',
+ 'owner: Noor Rahman',
+ 'tags: [payments, canary, customer-visible]',
+ 'approved-at: 2026-08-30T21:00:00+07:00',
+ '---',
+ '',
+ '# Release record',
+ ].join('\n'))
+ const previews = model.edits
+ .filter(({ primary }) => primary.context.before?.code === 'front-matter')
+ .map(({ primary }) => [primary.preview.before, primary.preview.after])
+ .flat()
+ .map((preview) => preview?.kind === 'text' ? preview.text : '')
+
+ expect(previews).toHaveLength(4)
+ expect(previews[0]).toMatch(/^release: atlas-2\.4\b/)
+ expect(previews[1]).toMatch(/^release: atlas-2\.4\.1\b/)
+ expect(previews[2]).toMatch(/^tags: \[payments, canary\]/)
+ expect(previews[3]).toMatch(/^tags: \[payments, canary, customer-visible\]/)
+ })
+
+ it('moves exact repeated section content with its unique heading anchor', () => {
+ const repeated = 'Health check passed.\n\nDeploy the stable build.'
+ const before = [
+ '# Repeated deployment notes',
+ `## Region A\n\n${repeated}`,
+ `## Region B\n\n${repeated}`,
+ `## Retired region\n\n${repeated}`,
+ `## Region C\n\n${repeated}`,
+ ].join('\n\n')
+ const after = [
+ '# Repeated deployment notes',
+ `## Region C\n\n${repeated}`,
+ `## Region A\n\n${repeated}`,
+ '## New region\n\nHealth check passed.\n\nDeploy the canary build.',
+ `## Region B\n\n${repeated}`,
+ ].join('\n\n')
+ const { before: beforeDoc, after: afterDoc, model } = compare(before, after)
+ const moved = model.edits.find(({ primary }) => primary.operation === 'move')!
+ const repeatedCopies = model.edits.filter(({ primary }) => primary.operation !== 'move')
+ .map((edit) => ({
+ operation: edit.primary.operation,
+ before: beforeDoc.textBetween(edit.primary.before.from, edit.primary.before.to, '\n'),
+ after: afterDoc.textBetween(edit.primary.after.from, edit.primary.after.to, '\n'),
+ }))
+
+ expect(model.edits).toHaveLength(7)
+ expect(beforeDoc.textBetween(moved.primary.before.from, moved.primary.before.to, '\n'))
+ .toBe('Region C\nHealth check passed.\nDeploy the stable build.')
+ expect(afterDoc.textBetween(moved.primary.after.from, moved.primary.after.to, '\n'))
+ .toBe('Region C\nHealth check passed.\nDeploy the stable build.')
+ expect(repeatedCopies.filter(({ before }) => before === 'Health check passed.')).toHaveLength(1)
+ expect(repeatedCopies.filter(({ after }) => after === 'Health check passed.')).toHaveLength(1)
+ })
+
+ it('F08 keeps a large inline envelope as one rendered block change', () => {
+ const shared = 'z'.repeat(MAX_INLINE_ENVELOPE_SIZE)
+ const { before, after, model } = compare(`start ${shared}\n`, `${shared} finish\n`)
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]!.primary).toMatchObject({
+ detail: 'block',
+ before: { from: 0, to: meaningfulSize(before) },
+ after: { from: 0, to: meaningfulSize(after) },
+ })
+ })
+
+ it('accepts 10000 descriptors and rejects 10001 at the production default', () => {
+ const editor = createComparisonTestEditor('placeholder')
+ try {
+ const document = (count: number, side: 'before' | 'after') => {
+ const nodes = Array.from({ length: count }, (_value, index) => [
+ editor.schema.nodes.paragraph!.create(null, editor.schema.text(`${side} ${index}`)),
+ editor.schema.nodes.heading!.create({ level: 2 }, editor.schema.text(`Exact anchor ${index}`)),
+ ]).flat()
+ return editor.schema.nodes.doc!.create(null, nodes)
+ }
+ const before = document(MAX_RENDERED_COMPARISON_DESCRIPTORS + 1, 'before')
+ const atLimit = createHierarchicalMarkdownComparisonModel(
+ editor.schema.nodes.doc!.create(null, before.content.content.slice(0, -2)),
+ document(MAX_RENDERED_COMPARISON_DESCRIPTORS, 'after'),
+ )
+
+ expect(MAX_RENDERED_COMPARISON_DESCRIPTORS).toBe(10_000)
+ expect(atLimit.edits).toHaveLength(MAX_RENDERED_COMPARISON_DESCRIPTORS)
+ expect(() => createHierarchicalMarkdownComparisonModel(
+ before,
+ document(MAX_RENDERED_COMPARISON_DESCRIPTORS + 1, 'after'),
+ )).toThrow(ComparisonModelLimitError)
+ } finally {
+ editor.destroy()
+ }
+ })
+
+ it('freezes the model and keeps the primary inside its own descriptors', () => {
+ const { model } = compare('one\n\ntwo\n', 'one edited\n\ntwo edited\n')
+
+ expect(Object.isFrozen(model)).toBe(true)
+ expect(Object.isFrozen(model.edits)).toBe(true)
+ expect(model.edits.every((edit) => edit.descriptors.includes(edit.primary))).toBe(true)
+ expect(new Set(model.edits.map(({ id }) => id))).toHaveLength(model.edits.length)
+ expect(new Set(model.edits.flatMap(({ descriptors }) => descriptors.map(({ id }) => id))))
+ .toHaveLength(model.edits.flatMap(({ descriptors }) => descriptors).length)
+ })
+})
diff --git a/src/tests/comparison/markdownSourceComparison.spec.ts b/src/tests/comparison/markdownSourceComparison.spec.ts
new file mode 100644
index 00000000000..3af9ec62b96
--- /dev/null
+++ b/src/tests/comparison/markdownSourceComparison.spec.ts
@@ -0,0 +1,214 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { SourceDiffHunk, SourceDiffLine } from '../../comparison/markdownSourceComparison.ts'
+
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { createMarkdownSourceComparison, materializeSourceDiffGap, SOURCE_DIFF_LIMITS } from '../../comparison/markdownSourceComparison.ts'
+import { compareMarkdownSourceLines } from '../../comparison/markdownSourceComparisonProtocol.ts'
+
+afterEach(() => vi.unstubAllGlobals())
+
+describe('literal Markdown source comparison', () => {
+ const lines = (hunks: readonly SourceDiffHunk[], side: 'before' | 'after') => hunks
+ .flatMap(({ rows }) => rows.flatMap((row) => row[side] ? [row[side]] : []))
+
+ it('V10 normalizes EOL only for matching while retaining literal line facts', async () => {
+ const model = await createMarkdownSourceComparison('tab\tvalue \r\nzero\u200Bwidth\nlast', 'tab value \nzero width\nlast\n')
+ expect(model.status).toBe('ready')
+ if (model.status !== 'ready') {
+ return
+ }
+ const before = lines(model.hunks, 'before')
+ const after = lines(model.hunks, 'after')
+ expect(before[0]).toMatchObject({ text: 'tab\tvalue ', eol: 'crlf' })
+ expect(before.some(({ text }) => text.includes('\u200b'))).toBe(true)
+ expect(before.at(-1)?.eol).toBe('none')
+ expect(after.at(-1)?.eol).toBe('lf')
+ })
+
+ it('AUD-14 materializes stable paired row records with the source model', async () => {
+ const model = await createMarkdownSourceComparison('old\nsame\n', 'new\nsame\n')
+ expect(model.status).toBe('ready')
+ if (model.status !== 'ready') {
+ return
+ }
+ const hunk = model.hunks[0]!
+
+ expect(hunk.rows.map(({ before, after }) => [before?.text, after?.text])).toEqual([['old', 'new'], ['same', 'same']])
+ expect(hunk.rows).toBe(hunk.rows)
+ })
+
+ it('AUD-08 represents large collapsed gaps without retained line clones', async () => {
+ const source = Array.from({ length: 10_000 }, (_value, index) => `line ${index}`).join('\n')
+ const model = await createMarkdownSourceComparison(source, source)
+ expect(model.status).toBe('ready')
+ if (model.status !== 'ready') {
+ return
+ }
+
+ expect(model.gaps).toEqual([{
+ id: 'source-gap-0',
+ slot: 0,
+ beforeFrom: 0,
+ beforeTo: 10_000,
+ afterFrom: 0,
+ afterTo: 10_000,
+ count: 10_000,
+ }])
+ })
+
+ it('AUD-08 materializes large gaps in bounded observable pages', async () => {
+ const source = Array.from({ length: 10_000 }, (_value, index) => `line ${index}`).join('\n')
+ const model = await createMarkdownSourceComparison(source, source)
+ expect(model.status).toBe('ready')
+ if (model.status !== 'ready') {
+ return
+ }
+ const gap = model.gaps[0]!
+
+ const firstPage = materializeSourceDiffGap(source, source, gap, Number.POSITIVE_INFINITY)
+ const secondPage = materializeSourceDiffGap(source, source, gap, SOURCE_DIFF_LIMITS.maximumGapPageRows, SOURCE_DIFF_LIMITS.maximumGapPageRows)
+
+ expect(firstPage).toHaveLength(SOURCE_DIFF_LIMITS.maximumGapPageRows)
+ expect(firstPage[0]?.before).toMatchObject({ number: 1, text: 'line 0' })
+ expect(firstPage.at(-1)?.after).toMatchObject({ number: SOURCE_DIFF_LIMITS.maximumGapPageRows, text: `line ${SOURCE_DIFF_LIMITS.maximumGapPageRows - 1}` })
+ expect(secondPage).toHaveLength(SOURCE_DIFF_LIMITS.maximumGapPageRows)
+ expect(secondPage[0]?.before).toMatchObject({ number: SOURCE_DIFF_LIMITS.maximumGapPageRows + 1, text: `line ${SOURCE_DIFF_LIMITS.maximumGapPageRows}` })
+ expect(secondPage.at(-1)?.after).toMatchObject({ number: SOURCE_DIFF_LIMITS.maximumGapPageRows * 2, text: `line ${SOURCE_DIFF_LIMITS.maximumGapPageRows * 2 - 1}` })
+ })
+
+ it('falls back when visible controls exceed the source display limit', async () => {
+ const source = `${'\t'.repeat(200_000)}😀`
+
+ await expect(createMarkdownSourceComparison(source, source)).resolves.toEqual({
+ status: 'limited',
+ reason: 'size',
+ })
+ })
+
+ it('retains complete literal lines when only line endings differ', async () => {
+ const beforeSource = 'same\r\nbytes\r\n'
+ const afterSource = 'same\nbytes\n'
+ const model = await createMarkdownSourceComparison(beforeSource, afterSource)
+ expect(model.status).toBe('ready')
+ if (model.status !== 'ready') {
+ return
+ }
+ expect(model.hunks).toEqual([])
+ expect(model.gaps).toHaveLength(1)
+ const rows = materializeSourceDiffGap(beforeSource, afterSource, model.gaps[0]!)
+ expect(rows.map(({ before }: { before?: SourceDiffLine }) => ({ text: before?.text, eol: before?.eol }))).toEqual([
+ { text: 'same', eol: 'crlf' },
+ { text: 'bytes', eol: 'crlf' },
+ ])
+ expect(rows.map(({ after }: { after?: SourceDiffLine }) => ({ text: after?.text, eol: after?.eol }))).toEqual([
+ { text: 'same', eol: 'lf' },
+ { text: 'bytes', eol: 'lf' },
+ ])
+ })
+
+ it('keeps syntax-only and HTML-like changes as literal text', async () => {
+ const model = await createMarkdownSourceComparison('# Heading\n', '# Heading #\n![]()
')
+ expect(model.status).toBe('ready')
+ if (model.status !== 'ready') {
+ return
+ }
+ expect(lines(model.hunks, 'before').map(({ text }) => text)).toContain('')
+ expect(lines(model.hunks, 'after').map(({ text }) => text)).toContain('![]()
')
+ })
+
+ it('reports limits and aborts without losing the caller fallback contract', async () => {
+ await expect(createMarkdownSourceComparison('x'.repeat(SOURCE_DIFF_LIMITS.maximumCharacters + 1), ''))
+ .resolves.toEqual({ status: 'limited', reason: 'size' })
+ const controller = new AbortController()
+ controller.abort()
+ await expect(createMarkdownSourceComparison('before', 'after', controller.signal)).rejects.toMatchObject({ name: 'AbortError' })
+ })
+
+ it('V11 terminates an in-flight worker when the caller aborts', async () => {
+ const terminate = vi.fn()
+ vi.stubGlobal('Worker', class {
+ addEventListener() {}
+ removeEventListener() {}
+ postMessage() {}
+ terminate() { terminate() }
+ })
+ const controller = new AbortController()
+ const comparison = createMarkdownSourceComparison('before', 'after', controller.signal)
+ controller.abort()
+ await expect(comparison).rejects.toMatchObject({ name: 'AbortError' })
+ expect(terminate).toHaveBeenCalledOnce()
+ })
+
+ it('terminates the worker when posting the comparison request throws', async () => {
+ const failure = new Error('post failure')
+ const terminate = vi.fn()
+ vi.stubGlobal('Worker', class {
+ addEventListener() {}
+ removeEventListener() {}
+ postMessage() {
+ throw failure
+ }
+
+ terminate() { terminate() }
+ })
+
+ await expect(createMarkdownSourceComparison('before', 'after')).rejects.toBe(failure)
+ expect(terminate).toHaveBeenCalledOnce()
+ })
+
+ it('rejects message decoding errors once and ignores a late success', async () => {
+ const workers: Array<{ onmessage?: EventListener, onmessageerror?: EventListener }> = []
+ const terminate = vi.fn()
+ vi.stubGlobal('Worker', class {
+ onmessage?: EventListener
+ onmessageerror?: EventListener
+ constructor() {
+ workers.push(this)
+ }
+
+ postMessage() {}
+
+ terminate() { terminate() }
+ })
+ const comparison = createMarkdownSourceComparison('before', 'after')
+
+ expect(workers[0]!.onmessageerror).toBeTypeOf('function')
+ workers[0]!.onmessageerror!(new MessageEvent('messageerror'))
+ workers[0]!.onmessage!(new MessageEvent('message', { data: { status: 'ready', changes: [] } }))
+
+ await expect(comparison).rejects.toThrow('Source comparison worker failed')
+ expect(terminate).toHaveBeenCalledOnce()
+ })
+
+ it('rejects malformed worker responses after cleanup', async () => {
+ const workers: Array<{ onmessage?: EventListener }> = []
+ const terminate = vi.fn()
+ vi.stubGlobal('Worker', class {
+ onmessage?: EventListener
+ constructor() {
+ workers.push(this)
+ }
+
+ postMessage() {}
+
+ terminate() { terminate() }
+ })
+ const comparison = createMarkdownSourceComparison('before', 'after')
+
+ workers[0]!.onmessage!(new MessageEvent('message', { data: null }))
+
+ await expect(comparison).rejects.toThrow('Source comparison worker failed')
+ expect(terminate).toHaveBeenCalledOnce()
+ })
+
+ it('uses the same bounded line protocol for main-thread and worker paths', () => {
+ expect(compareMarkdownSourceLines({ before: 'old\n', after: 'new\n', maximumEditLength: 10, timeoutMilliseconds: 1000 }))
+ .toMatchObject({ status: 'ready' })
+ expect(compareMarkdownSourceLines({ before: 'old\n', after: 'new\n', maximumEditLength: 0, timeoutMilliseconds: 1000 }))
+ .toEqual({ status: 'limited' })
+ })
+})
diff --git a/src/tests/comparison/markdownSourceComparisonWorker.spec.ts b/src/tests/comparison/markdownSourceComparisonWorker.spec.ts
new file mode 100644
index 00000000000..031caf28ae2
--- /dev/null
+++ b/src/tests/comparison/markdownSourceComparisonWorker.spec.ts
@@ -0,0 +1,30 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { SourceComparisonWorkerRequest } from '../../comparison/markdownSourceComparisonProtocol.ts'
+
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+afterEach(() => {
+ vi.resetModules()
+ vi.unstubAllGlobals()
+})
+
+describe('Markdown source comparison worker', () => {
+ it('delegates ready and limited messages to the shared protocol', async () => {
+ let listener: ((event: MessageEvent) => void) | undefined
+ const postMessage = vi.fn()
+ vi.stubGlobal('addEventListener', vi.fn((_type, callback) => {
+ listener = callback
+ }))
+ vi.stubGlobal('postMessage', postMessage)
+ await import('../../comparison/markdownSourceComparison.worker.ts')
+ expect(listener).toBeTypeOf('function')
+ listener?.(new MessageEvent('message', { data: { before: 'old\n', after: 'new\n', maximumEditLength: 10, timeoutMilliseconds: 1000 } }))
+ expect(postMessage).toHaveBeenLastCalledWith(expect.objectContaining({ status: 'ready' }))
+ listener?.(new MessageEvent('message', { data: { before: 'old\n', after: 'new\n', maximumEditLength: 0, timeoutMilliseconds: 1000 } }))
+ expect(postMessage).toHaveBeenLastCalledWith({ status: 'limited' })
+ })
+})
diff --git a/src/tests/comparison/renderedComparisonLimit.spec.ts b/src/tests/comparison/renderedComparisonLimit.spec.ts
new file mode 100644
index 00000000000..276e71aaaed
--- /dev/null
+++ b/src/tests/comparison/renderedComparisonLimit.spec.ts
@@ -0,0 +1,23 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { describe, expect, it } from 'vitest'
+import { exceedsRenderedComparisonLimit, RENDERED_COMPARISON_LIMITS } from '../../comparison/markdownComparison.ts'
+
+describe('rendered comparison preflight', () => {
+ it('accepts each exact geometry ceiling and rejects the first excess', () => {
+ const chars = RENDERED_COMPARISON_LIMITS.maximumCharactersPerSnapshot
+ const lineChars = RENDERED_COMPARISON_LIMITS.maximumCharactersPerLine
+ const line = `${'a'.repeat(lineChars - 1)}\n`
+ const source = (length: number) => line.repeat(Math.floor(length / line.length)) + 'a'.repeat(length % line.length)
+ expect(exceedsRenderedComparisonLimit(source(chars), 'after')).toBe(false)
+ expect(exceedsRenderedComparisonLimit(source(chars + 1), 'after')).toBe(true)
+ expect(exceedsRenderedComparisonLimit('a'.repeat(lineChars), 'after')).toBe(false)
+ expect(exceedsRenderedComparisonLimit('a'.repeat(lineChars + 1), 'after')).toBe(true)
+ const lines = RENDERED_COMPARISON_LIMITS.maximumLinesPerSnapshot
+ expect(exceedsRenderedComparisonLimit('x\n'.repeat(lines - 1), 'after')).toBe(false)
+ expect(exceedsRenderedComparisonLimit('x\r'.repeat(lines), 'after')).toBe(true)
+ })
+})
diff --git a/src/tests/comparison/tableGridComparison.spec.ts b/src/tests/comparison/tableGridComparison.spec.ts
new file mode 100644
index 00000000000..6d14c301559
--- /dev/null
+++ b/src/tests/comparison/tableGridComparison.spec.ts
@@ -0,0 +1,655 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { Schema } from '@tiptap/pm/model'
+import type { ComparisonEdit, ComparisonSide } from '../../comparison/markdownComparisonTypes.ts'
+
+import { Node as ProseMirrorNode } from '@tiptap/pm/model'
+import { describe, expect, it, vi } from 'vitest'
+import {
+ alignComparisonColumns,
+ DEFAULT_COMPARISON_TOKEN_LEDGER,
+} from '../../comparison/comparisonAlignment.ts'
+import { createHierarchicalMarkdownComparisonModel } from '../../comparison/hierarchicalMarkdownComparisonModel.ts'
+import { comparisonTestDocument, createComparisonTestEditor } from './comparisonTestEditor.ts'
+
+function markdownTable(header: readonly string[], rows: readonly (readonly string[])[]) {
+ return [
+ `| ${header.join(' | ')} |`,
+ `|${header.map(() => '---').join('|')}|`,
+ ...rows.map((row) => `| ${row.join(' | ')} |`),
+ ].join('\n')
+}
+
+function compare(before: string, after: string) {
+ return createHierarchicalMarkdownComparisonModel(
+ comparisonTestDocument(before),
+ comparisonTestDocument(after),
+ )
+}
+
+interface TableSpec {
+ header: readonly { text: string, colspan?: number, rowspan?: number }[]
+ rows: readonly (readonly { text: string, colspan?: number, rowspan?: number }[])[]
+}
+
+function tableNode(schema: Schema, spec: TableSpec) {
+ const text = (value: string) => value ? schema.text(value) : undefined
+ const cell = (name: 'tableHeader' | 'tableCell', value: TableSpec['header'][number]) => schema.nodes[name]!.create(
+ { colspan: value.colspan ?? 1, rowspan: value.rowspan ?? 1 },
+ name === 'tableHeader' ? text(value.text) : schema.nodes.paragraph!.create(null, text(value.text)),
+ )
+ const header = schema.nodes.tableHeadRow!.create(null, spec.header.map((value) => cell('tableHeader', value)))
+ const rows = spec.rows.map((row) => schema.nodes.tableRow!.create(null, row.map((value) => cell('tableCell', value))))
+ return schema.nodes.table!.create(null, [header, ...rows])
+}
+
+function tableDocument(schema: Schema, spec: TableSpec) {
+ return schema.nodes.doc!.create(null, tableNode(schema, spec))
+}
+
+function compareTableSpecs(before: TableSpec, after: TableSpec) {
+ const editor = createComparisonTestEditor('placeholder')
+ try {
+ return createHierarchicalMarkdownComparisonModel(
+ tableDocument(editor.schema, before),
+ tableDocument(editor.schema, after),
+ )
+ } finally {
+ editor.destroy()
+ }
+}
+
+function malformedTableDocument(
+ schema: Schema,
+ children: readonly ('caption' | 'header' | 'body' | 'header-with-body-cell' | 'body-with-header-cell')[],
+) {
+ const text = (value: string) => schema.text(value)
+ const headerCell = () => schema.nodes.tableHeader!.create(null, text('header'))
+ const bodyCell = () => schema.nodes.tableCell!.create(null, schema.nodes.paragraph!.create(null, text('body')))
+ const nodes = children.map((kind) => {
+ if (kind === 'caption') {
+ return schema.nodes.tableCaption!.create(null, text('caption'))
+ }
+ if (kind === 'header') {
+ return schema.nodes.tableHeadRow!.create(null, headerCell())
+ }
+ if (kind === 'body') {
+ return schema.nodes.tableRow!.create(null, bodyCell())
+ }
+ if (kind === 'header-with-body-cell') {
+ return schema.nodes.tableHeadRow!.create(null, bodyCell())
+ }
+ return schema.nodes.tableRow!.create(null, headerCell())
+ })
+ return schema.nodes.doc!.create(null, schema.nodes.table!.create(null, nodes))
+}
+
+function expectColumnEdit(
+ edit: ComparisonEdit,
+ operation: 'delete' | 'insert',
+ column: number,
+ rows: number,
+) {
+ const side: ComparisonSide = operation === 'delete' ? 'before' : 'after'
+ expect(edit.kind).toBe('table-column')
+ expect(edit.primary.operation).toBe(operation)
+ expect(edit.descriptors).toHaveLength(rows)
+ expect(edit.descriptors.every((descriptor) => descriptor.operation === operation)).toBe(true)
+ expect(edit.descriptors.map((descriptor) => descriptor.context[side]?.path.at(-1)))
+ .toEqual(Array.from({ length: rows }, () => column))
+ expect(edit.descriptors).toContain(edit.primary)
+}
+
+describe('sparse table comparison', () => {
+ it('AUD-14 does not materialize table profiles before matrix budget admission', () => {
+ const editor = createComparisonTestEditor('placeholder')
+ const columns = 201
+ const before = tableDocument(editor.schema, {
+ header: Array.from({ length: columns }, (_value, index) => ({ text: `before-${index}` })),
+ rows: [],
+ })
+ const after = tableDocument(editor.schema, {
+ header: Array.from({ length: columns }, (_value, index) => ({ text: `after-${index}` })),
+ rows: [],
+ })
+ const textContent = vi.spyOn(ProseMirrorNode.prototype, 'textContent', 'get')
+ try {
+ const model = createHierarchicalMarkdownComparisonModel(before, after)
+
+ expect(model.edits[0]!.primary.coarseReason).toBe('comparison-limit')
+ const tableCellReads = textContent.mock.contexts.filter((node) => (
+ (node as ProseMirrorNode).type.name === 'tableHeader'
+ )).length
+ expect(tableCellReads).toBeLessThanOrEqual(columns * 2 * 5)
+ } finally {
+ textContent.mockRestore()
+ editor.destroy()
+ }
+ })
+
+ it.each([
+ ['first', 0],
+ ['middle', 1],
+ ['last', 2],
+ ] as const)('T01 attributes the %s duplicate-body column deletion', (_name, column) => {
+ const widerHeader = ['A', 'B', 'C']
+ const narrowerHeader = widerHeader.filter((_value, index) => index !== column)
+ const wider = markdownTable(widerHeader, Array.from({ length: 2 }, () => ['x', 'x', 'x']))
+ const narrower = markdownTable(narrowerHeader, Array.from({ length: 2 }, () => ['x', 'x']))
+
+ const deletion = compare(wider, narrower)
+ expect(deletion.edits).toHaveLength(1)
+ expectColumnEdit(deletion.edits[0]!, 'delete', column, 3)
+ })
+
+ it.each([
+ ['first', 0],
+ ['middle', 1],
+ ['last', 2],
+ ] as const)('T02 attributes the %s duplicate-body column insertion', (_name, column) => {
+ const widerHeader = ['A', 'B', 'C']
+ const narrowerHeader = widerHeader.filter((_value, index) => index !== column)
+ const wider = markdownTable(widerHeader, Array.from({ length: 2 }, () => ['x', 'x', 'x']))
+ const narrower = markdownTable(narrowerHeader, Array.from({ length: 2 }, () => ['x', 'x']))
+
+ const insertion = compare(narrower, wider)
+ expect(insertion.edits).toHaveLength(1)
+ expectColumnEdit(insertion.edits[0]!, 'insert', column, 3)
+ })
+
+ it('T03 distinguishes duplicate headers with an exact body row', () => {
+ const model = compare(
+ markdownTable(['X', 'X', 'X'], [['a', 'b', 'c'], ['x', 'x', 'x']]),
+ markdownTable(['X', 'X'], [['a', 'b'], ['x', 'x']]),
+ )
+
+ expect(model.edits).toHaveLength(1)
+ expectColumnEdit(model.edits[0]!, 'delete', 2, 3)
+ })
+
+ it('T04 pairs equal duplicate-vector multiplicity by rank beside a unique deletion', () => {
+ const model = compare(
+ markdownTable(['A', 'X', 'X', 'C'], [['x', 'x', 'x', 'x']]),
+ markdownTable(['A', 'X', 'X'], [['x', 'x', 'x']]),
+ )
+
+ expect(model.edits).toHaveLength(1)
+ expectColumnEdit(model.edits[0]!, 'delete', 3, 2)
+ })
+
+ it('T05 keeps unequal identical-column multiplicity coarse', () => {
+ const model = compare(
+ markdownTable(['X', 'X', 'X'], [['', '', ''], ['x', 'x', 'x']]),
+ markdownTable(['X', 'X'], [['', ''], ['x', 'x']]),
+ )
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({
+ kind: 'content',
+ primary: {
+ operation: 'replace',
+ coarseReason: 'ambiguous-attribution',
+ context: { before: { code: 'table' }, after: { code: 'table' } },
+ },
+ })
+ })
+
+ it('T06 keeps a crossing exact column reorder coarse', () => {
+ const model = compare(
+ markdownTable(['A', 'B', 'C'], [['a', 'b', 'c']]),
+ markdownTable(['C', 'B', 'A'], [['c', 'b', 'a']]),
+ )
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({
+ kind: 'content',
+ primary: {
+ operation: 'replace',
+ coarseReason: 'table-evidence-conflict',
+ context: { before: { code: 'table' }, after: { code: 'table' } },
+ },
+ })
+ })
+
+ it('T07 keeps one edited retained column precise at cell altitude', () => {
+ const model = compare(
+ markdownTable(['A', 'B', 'C'], [['1', '2', '3']]),
+ markdownTable(['A', 'X', 'C'], [['1', 'changed', '3']]),
+ )
+ const descriptors = model.edits.flatMap(({ descriptors }) => descriptors)
+
+ expect(model.edits).toHaveLength(2)
+ expect(model.edits.every(({ kind }) => kind === 'content')).toBe(true)
+ expect(descriptors).toHaveLength(2)
+ expect(descriptors.map(({ context }) => context.before?.path)).toEqual([
+ [0, 0, 1],
+ [0, 1, 1],
+ ])
+ expect(descriptors.map(({ before, after }) => ({ before, after }))).toEqual([
+ { before: { from: 6, to: 7 }, after: { from: 6, to: 7 } },
+ { before: { from: 20, to: 21 }, after: { from: 20, to: 27 } },
+ ])
+ expect(descriptors.every(({ context }) => (
+ context.before?.code === 'table-cell' && context.after?.code === 'table-cell'
+ ))).toBe(true)
+ })
+
+ it('T08 keeps two adjacent edited columns precise when the optimum is unique', () => {
+ const model = compare(
+ markdownTable(['A', 'B old', 'C old', 'D'], [['1', 'before b', 'before c', '4']]),
+ markdownTable(['A', 'B new', 'C new', 'D'], [['1', 'after b', 'after c', '4']]),
+ )
+ const descriptors = model.edits.flatMap(({ descriptors }) => descriptors)
+
+ expect(descriptors).toHaveLength(4)
+ expect(model.edits.every(({ kind }) => kind === 'content')).toBe(true)
+ expect(descriptors.every(({ coarseReason }) => coarseReason === undefined)).toBe(true)
+ expect(descriptors.every(({ context }) => (
+ context.before?.code === 'table-cell' && context.after?.code === 'table-cell'
+ ))).toBe(true)
+ })
+
+ it('groups one column alignment change across its physical cells without duplicating content edits', () => {
+ const model = compare([
+ '# Evidence matrix',
+ '',
+ '| Signal | Evidence | State |',
+ '| :--- | :---: | ---: |',
+ '| API \\| worker | **Draft** [runbook](https://example.org/draft) | 10% |',
+ '| Screenshot |  | Pending |',
+ ].join('\n'), [
+ '# Evidence matrix',
+ '',
+ '| Signal | Evidence | State |',
+ '| ---: | :--- | :---: |',
+ '| API \\| worker | **Approved** [runbook](https://example.org/approved) | 25% |',
+ '| Screenshot |  | Complete |',
+ ].join('\n'))
+ const alignmentEdits = model.edits.filter(({ primary }) => primary.signals.some((signal) => (
+ signal.type === 'attribute' && signal.attribute === 'table-alignment'
+ )))
+ expect(model.edits).toHaveLength(7)
+ expect(alignmentEdits).toHaveLength(3)
+ expect(alignmentEdits.map(({ descriptors }) => descriptors.length)).toEqual([3, 3, 3])
+ expect(alignmentEdits.every(({ descriptors }) => descriptors.every(({ signals }) => signals.some((signal) => (
+ signal.type === 'attribute' && signal.attribute === 'table-alignment'
+ ))))).toBe(true)
+ })
+
+ it('T09 combines an edited retained column with one adjacent column deletion', () => {
+ const model = compare(
+ markdownTable(['A', 'B old', 'C'], [['1', 'before', '3']]),
+ markdownTable(['A', 'B new'], [['1', 'after']]),
+ )
+ const columnEdits = model.edits.filter(({ kind }) => kind === 'table-column')
+ const cellEdits = model.edits.filter(({ kind }) => kind === 'content')
+
+ expect(columnEdits).toHaveLength(1)
+ expectColumnEdit(columnEdits[0]!, 'delete', 2, 2)
+ expect(cellEdits).toHaveLength(2)
+ expect(cellEdits.flatMap(({ descriptors }) => descriptors).every(({ context }) => (
+ context.before?.code === 'table-cell' && context.after?.code === 'table-cell'
+ ))).toBe(true)
+ })
+
+ it('T10 keeps a row insertion at row altitude beside a column deletion', () => {
+ const model = compare(
+ markdownTable(['A', 'B', 'C'], [['one', 'x', 'x'], ['two', 'x', 'x']]),
+ markdownTable(['A', 'B'], [['one', 'x'], ['inserted row', 'unique'], ['two', 'x']]),
+ )
+ const columnEdits = model.edits.filter(({ kind }) => kind === 'table-column')
+ const rowInsertions = model.edits.filter(({ primary }) => (
+ primary.operation === 'insert' && primary.context.after?.code === 'table-row'
+ ))
+
+ expect(columnEdits).toHaveLength(1)
+ expectColumnEdit(columnEdits[0]!, 'delete', 2, 3)
+ expect(rowInsertions).toHaveLength(1)
+ })
+
+ it('T10 keeps a row deletion at row altitude beside a column insertion', () => {
+ const model = compare(
+ markdownTable(['A', 'B'], [['one', 'x'], ['deleted row', 'unique'], ['two', 'x']]),
+ markdownTable(['A', 'B', 'C'], [['one', 'x', 'x'], ['two', 'x', 'x']]),
+ )
+ const columnEdits = model.edits.filter(({ kind }) => kind === 'table-column')
+ const rowDeletions = model.edits.filter(({ primary }) => (
+ primary.operation === 'delete' && primary.context.before?.code === 'table-row'
+ ))
+
+ expect(columnEdits).toHaveLength(1)
+ expectColumnEdit(columnEdits[0]!, 'insert', 2, 3)
+ expect(rowDeletions).toHaveLength(1)
+ })
+
+ it('T11 keeps a ragged typo precise at physical-cell altitude', () => {
+ const model = compare(
+ markdownTable(['A', 'B', 'C'], [['one', 'before']]),
+ markdownTable(['A', 'B', 'C'], [['one', 'after']]),
+ )
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({
+ kind: 'content',
+ primary: {
+ operation: 'replace',
+ context: { before: { code: 'table-cell' }, after: { code: 'table-cell' } },
+ },
+ })
+ })
+
+ it.each([
+ ['fills', 'insert', ['one'], ['one', 'two']],
+ ['removes', 'delete', ['one', 'two'], ['one']],
+ ] as const)('T12 %s a ragged absent-present slot as one local cell change', (_name, operation, beforeRow, afterRow) => {
+ const model = compare(
+ markdownTable(['A', 'B'], [beforeRow]),
+ markdownTable(['A', 'B'], [afterRow]),
+ )
+ const side: ComparisonSide = operation === 'delete' ? 'before' : 'after'
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({ kind: 'content', primary: { operation } })
+ expect(model.edits[0]!.primary.context[side]?.code).toBe('table-cell')
+ })
+
+ it('T13 groups only present physical cells from a deleted ragged column', () => {
+ const wider = markdownTable(['A', 'B', 'C'], [
+ ['x', 'x'],
+ ['x', 'x', 'distinct C'],
+ ])
+ const narrower = markdownTable(['A', 'B'], [
+ ['x', 'x'],
+ ['x', 'x'],
+ ])
+ const model = compare(wider, narrower)
+
+ expect(model.edits).toHaveLength(1)
+ expectColumnEdit(model.edits[0]!, 'delete', 2, 2)
+ })
+
+ it.each(['deletion', 'insertion'] as const)('T14 fails a ragged middle identity conflict transactionally on %s', (direction) => {
+ const wider = markdownTable(['A', 'B', 'C'], [
+ ['x', 'x', 'x'],
+ ['x', 'x'],
+ ])
+ const narrower = markdownTable(['A', 'C'], [
+ ['x', 'x'],
+ ['x'],
+ ])
+ const model = direction === 'deletion'
+ ? compare(wider, narrower)
+ : compare(narrower, wider)
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({
+ kind: 'content',
+ primary: {
+ operation: 'replace',
+ coarseReason: 'table-evidence-conflict',
+ context: { before: { code: 'table' }, after: { code: 'table' } },
+ },
+ })
+ expect(model.edits[0]!.descriptors).toHaveLength(1)
+ })
+
+ it.each(['deletion', 'insertion'] as const)('AUD-01 fails closed when a ragged width change creates cross-row exact identity on %s', (direction) => {
+ for (const width of [2, 3, 4]) {
+ const wider = markdownTable(
+ Array.from({ length: width + 1 }, () => 'N'),
+ [
+ Array.from({ length: width }, () => 'x'),
+ Array.from({ length: width + 1 }, () => 'x'),
+ ],
+ )
+ const narrower = markdownTable(
+ Array.from({ length: width }, () => 'N'),
+ [
+ Array.from({ length: width - 1 }, () => 'x'),
+ Array.from({ length: width }, () => 'x'),
+ ],
+ )
+ const model = direction === 'deletion'
+ ? compare(wider, narrower)
+ : compare(narrower, wider)
+ const rowOperations = model.edits.filter(({ primary }) => (
+ primary.context.before?.code === 'table-row' || primary.context.after?.code === 'table-row'
+ ))
+
+ expect(rowOperations).toHaveLength(0)
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({
+ kind: 'content',
+ primary: {
+ operation: 'replace',
+ coarseReason: 'table-evidence-conflict',
+ context: { before: { code: 'table' }, after: { code: 'table' } },
+ },
+ })
+ expect(model.edits[0]!.descriptors).toHaveLength(1)
+ }
+ })
+
+ it.each(['deletion', 'insertion'] as const)('AUD-01 reconciles the complete row basis when row count and width change on %s', (direction) => {
+ const wider = markdownTable(['N', 'N', 'N'], [
+ ['x', 'x'],
+ ['x', 'x', 'x'],
+ ])
+ const narrower = markdownTable(['N', 'N'], [
+ ['inserted', 'unique'],
+ ['x'],
+ ['x', 'x'],
+ ])
+ const model = direction === 'deletion'
+ ? compare(wider, narrower)
+ : compare(narrower, wider)
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({
+ kind: 'content',
+ primary: {
+ operation: 'replace',
+ coarseReason: 'table-evidence-conflict',
+ context: { before: { code: 'table' }, after: { code: 'table' } },
+ },
+ })
+ expect(model.edits[0]!.descriptors).toHaveLength(1)
+ })
+
+ it.each(['deletion', 'insertion'] as const)('AUD-01 keeps a genuine ragged row replacement beside a column %s', (direction) => {
+ const wider = markdownTable(['A', 'B', 'C'], [
+ ['retained', 'x'],
+ ['deleted', 'y', 'z'],
+ ])
+ const narrower = markdownTable(['A', 'B'], [
+ ['inserted', 'q'],
+ ['retained', 'x'],
+ ])
+ const model = direction === 'deletion'
+ ? compare(wider, narrower)
+ : compare(narrower, wider)
+ const columnEdits = model.edits.filter(({ kind }) => kind === 'table-column')
+ const rowOperations = model.edits.filter(({ primary }) => (
+ primary.context.before?.code === 'table-row' || primary.context.after?.code === 'table-row'
+ ))
+
+ expect(columnEdits).toHaveLength(1)
+ expectColumnEdit(columnEdits[0]!, direction === 'deletion' ? 'delete' : 'insert', 2, 1)
+ expect(rowOperations.map(({ primary }) => primary.operation).toSorted()).toEqual(['delete', 'insert'])
+ expect(model.edits.every(({ primary }) => primary.coarseReason === undefined)).toBe(true)
+ })
+
+ it.each([
+ ['deletes', 'delete', 3, 2],
+ ['inserts', 'insert', 3, 4],
+ ] as const)('T15 %s the outer repeated row after retaining the first exact copies', (_name, operation, beforeCount, afterCount) => {
+ const rows = (count: number) => Array.from({ length: count }, () => ['Same', 'x'])
+ const model = compare(
+ markdownTable(['H1', 'H2'], rows(beforeCount)),
+ markdownTable(['H1', 'H2'], rows(afterCount)),
+ )
+ const side: ComparisonSide = operation === 'delete' ? 'before' : 'after'
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({ kind: 'content', primary: { operation } })
+ expect(model.edits[0]!.primary.context[side]?.code).toBe('table-row')
+ expect(model.edits[0]!.primary.context[side]?.path.at(-1)).toBe(operation === 'delete' ? 3 : 4)
+ })
+
+ it.each([
+ ['span', { header: [{ text: 'changed', colspan: 2 }], rows: [] }],
+ ['row span', { header: [{ text: 'changed', rowspan: 2 }], rows: [[{ text: 'body' }]] }],
+ ['malformed empty row', { header: [{ text: 'changed' }], rows: [[]] }],
+ ['more than 512 rows', {
+ header: [{ text: 'changed' }],
+ rows: Array.from({ length: 512 }, (_value, index) => [{ text: `row ${index}` }]),
+ }],
+ ['more than 10000 physical cells', {
+ header: Array.from({ length: 100 }, (_value, index) => ({ text: index === 0 ? 'changed' : `head ${index}` })),
+ rows: Array.from({ length: 100 }, (_value, row) => (
+ Array.from({ length: 100 }, (_cell, column) => ({ text: `cell ${row}:${column}` }))
+ )),
+ }],
+ ] as const)('T16 emits one unsupported-table edit for %s geometry', (_name, invalid) => {
+ const valid = { header: [{ text: 'valid' }], rows: [] }
+ const model = compareTableSpecs(valid, invalid)
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({
+ kind: 'content',
+ primary: {
+ operation: 'replace',
+ coarseReason: 'unsupported-table',
+ context: { before: { code: 'table' }, after: { code: 'table' } },
+ },
+ })
+ expect(model.edits[0]!.descriptors).toHaveLength(1)
+ })
+
+ it.each([
+ ['a missing header', ['body']],
+ ['duplicate headers', ['header', 'header']],
+ ['a header after a body row', ['body', 'header']],
+ ['a misplaced caption', ['header', 'caption']],
+ ['duplicate captions', ['caption', 'caption', 'header']],
+ ['a body cell in the header', ['header-with-body-cell']],
+ ['a header cell in a body row', ['header', 'body-with-header-cell']],
+ ] as const)('T16 rejects %s transactionally', (_name, children) => {
+ const editor = createComparisonTestEditor('placeholder')
+ try {
+ const valid = tableDocument(editor.schema, { header: [{ text: 'valid' }], rows: [] })
+ const invalid = malformedTableDocument(editor.schema, children)
+ const model = createHierarchicalMarkdownComparisonModel(valid, invalid)
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({
+ kind: 'content',
+ primary: {
+ operation: 'replace',
+ coarseReason: 'unsupported-table',
+ context: { before: { code: 'table' }, after: { code: 'table' } },
+ },
+ })
+ expect(model.edits[0]!.descriptors).toHaveLength(1)
+ } finally {
+ editor.destroy()
+ }
+ })
+
+ it('T17 rejects a 10001-column table before attempting column alignment', () => {
+ const valid = { header: [{ text: 'valid' }], rows: [] }
+ const hugeWidth = {
+ header: Array.from({ length: 10_001 }, (_value, index) => ({ text: `column ${index}` })),
+ rows: [],
+ }
+ const model = compareTableSpecs(valid, hugeWidth)
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]!.primary.coarseReason).toBe('unsupported-table')
+ expect(model.edits[0]!.descriptors).toHaveLength(1)
+ })
+
+ it('F09 retains solved table work without partial edits when a later exact-evidence veto coarsens the table', () => {
+ const editor = createComparisonTestEditor('placeholder')
+ try {
+ const columnCount = 100
+ const bodyTextLength = Math.floor(DEFAULT_COMPARISON_TOKEN_LEDGER / (4 * columnCount ** 2)) - 6
+ const body = (suffix: string) => Array.from({ length: columnCount }, (_value, index) => ({
+ text: `${String.fromCodePoint(0x100 + index).repeat(bodyTextLength - 1)}${suffix}`,
+ }))
+ const beforeHeader = Array.from({ length: columnCount }, (_value, index) => ({ text: index === 0 ? 'q' : 'a' }))
+ const afterHeader = Array.from({ length: columnCount }, (_value, index) => ({ text: index === columnCount - 1 ? 'q' : 'b' }))
+ const headerRowProfileLength = 2 * columnCount
+ const bodyRowProfileLength = (bodyTextLength + 2) * columnCount
+ const rowCharge = 2 * (3 * headerRowProfileLength + bodyRowProfileLength)
+ const columnProfileLength = bodyTextLength + 6
+ const columnCharge = 2 * columnCount ** 2 * columnProfileLength
+ const remainingTokens = DEFAULT_COMPARISON_TOKEN_LEDGER - rowCharge - columnCharge
+ const laterProfileLength = Math.floor(remainingTokens / (2 * columnCount ** 2)) + 1
+ const laterTextLength = laterProfileLength - 3
+ const repeatedHeaders = (character: string) => Array.from(
+ { length: columnCount },
+ () => ({ text: character.repeat(laterTextLength) }),
+ )
+ const anchor = editor.schema.nodes.paragraph!.create(null, editor.schema.text('exact veto boundary anchor'))
+ const before = editor.schema.nodes.doc!.create(null, [
+ tableNode(editor.schema, { header: beforeHeader, rows: [body('x')] }),
+ anchor,
+ tableNode(editor.schema, { header: repeatedHeaders('c'), rows: [] }),
+ ])
+ const after = editor.schema.nodes.doc!.create(null, [
+ tableNode(editor.schema, { header: afterHeader, rows: [body('y')] }),
+ anchor,
+ tableNode(editor.schema, { header: repeatedHeaders('d'), rows: [] }),
+ ])
+ const model = createHierarchicalMarkdownComparisonModel(before, after)
+
+ expect(2 * columnCount ** 2 * laterProfileLength).toBeGreaterThan(remainingTokens)
+ expect(2 * columnCount ** 2 * laterProfileLength).toBeLessThan(DEFAULT_COMPARISON_TOKEN_LEDGER)
+ expect(model.edits.map(({ primary }) => primary.coarseReason)).toEqual([
+ 'table-evidence-conflict',
+ 'comparison-limit',
+ ])
+ expect(model.edits.every(({ descriptors }) => descriptors.length === 1)).toBe(true)
+ } finally {
+ editor.destroy()
+ }
+ })
+
+ it('T18 shares table token work across consecutive column plans', () => {
+ interface Column {
+ key: string
+ profile: readonly string[]
+ }
+ const before: Column[] = [
+ { key: 'before-a', profile: ['a', 'same-a'] },
+ { key: 'before-b', profile: ['b', 'same-b'] },
+ ]
+ const after: Column[] = [
+ { key: 'after-a', profile: ['a', 'same-a'] },
+ { key: 'after-b', profile: ['b', 'same-b'] },
+ ]
+ const work = { remainingCells: 8, remainingTokenComparisons: 20 }
+ const options = {
+ work,
+ fingerprint: ({ key }: Column) => key,
+ profile: ({ profile }: Column) => profile,
+ compatible: () => true,
+ }
+
+ const first = alignComparisonColumns(before, after, options)
+ expect(first.every((region) => !('coarseReason' in region && region.coarseReason === 'comparison-limit'))).toBe(true)
+ expect(work).toEqual({ remainingCells: 4, remainingTokenComparisons: 4 })
+
+ const second = alignComparisonColumns(before, after, options)
+ expect(second).toEqual([{
+ before: { from: 0, to: 2 },
+ after: { from: 0, to: 2 },
+ coarseReason: 'comparison-limit',
+ }])
+ expect(work).toEqual({ remainingCells: 4, remainingTokenComparisons: 4 })
+ })
+})
diff --git a/src/tests/markdown.spec.js b/src/tests/markdown.spec.js
index 2f5bb9e5011..f67768a5c50 100644
--- a/src/tests/markdown.spec.js
+++ b/src/tests/markdown.spec.js
@@ -175,6 +175,7 @@ describe('Markdown though editor', () => {
test('details', ({ markdownThroughEditor }) => {
expect(markdownThroughEditor('\n**summary**
\n* list\n\n\n')).toBe('\n**summary**
\n* list\n\n\n')
+ expect(markdownThroughEditor('\nsummary
\ncontent\n\n\n')).toBe('\nsummary
\ncontent\n\n\n')
})
test('nested details', ({ markdownThroughEditor }) => {
diff --git a/src/tests/markdownit/details.spec.js b/src/tests/markdownit/details.spec.js
index dd077287e52..86f1c636f08 100644
--- a/src/tests/markdownit/details.spec.js
+++ b/src/tests/markdownit/details.spec.js
@@ -11,6 +11,10 @@ describe('Details extension', () => {
const rendered = markdownit.render('\nsummary
\ncontent\n')
expect(stripIndent(rendered)).toBe('summary
content
')
})
+ it('renders the native open state', () => {
+ const rendered = markdownit.render('\nsummary
\ncontent\n')
+ expect(stripIndent(rendered)).toBe('summary
content
')
+ })
it('renders with empty summary', () => {
const rendered = markdownit.render('\n
\ncontent\n')
expect(stripIndent(rendered)).toBe('
content
')
diff --git a/src/tests/nodes/DetailsViewAccessibility.spec.ts b/src/tests/nodes/DetailsViewAccessibility.spec.ts
new file mode 100644
index 00000000000..b1c9d51ab94
--- /dev/null
+++ b/src/tests/nodes/DetailsViewAccessibility.spec.ts
@@ -0,0 +1,49 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { mount } from '@vue/test-utils'
+import { describe, expect, it, vi } from 'vitest'
+import DetailsView from '../../nodes/DetailsView.vue'
+
+function mountDetails(attrs: { open: boolean, openDetails: boolean }, updateAttributes = vi.fn()) {
+ return mount(DetailsView, {
+ props: { node: { attrs }, updateAttributes },
+ global: {
+ stubs: {
+ NodeViewWrapper: { template: '['$props']
+
+const attachment = {
+ alt: 'Diagram',
+ davPath: '/diagram.png',
+ fullUrl: '/diagram.png',
+ isImage: true,
+ metadata: null,
+ mimetype: 'image/png',
+ name: 'diagram.png',
+ previewUrl: '/preview.png',
+ size: 100,
+}
+
+beforeEach(() => {
+ vi.stubGlobal('ResizeObserver', class {
+ observe() {}
+ disconnect() {}
+ })
+ vi.stubGlobal('IntersectionObserver', class {
+ observe() {}
+ disconnect() {}
+ })
+})
+
+afterEach(() => vi.unstubAllGlobals())
+
+async function mountImage(isImage: boolean) {
+ const editor = { isEditable: false, off: vi.fn(), on: vi.fn() }
+ const wrapper = mount(ImageView, {
+ props: {
+ editor,
+ node: { attrs: { alt: 'Diagram', src: 'diagram.png' } },
+ decorations: [],
+ selected: false,
+ extension: { options: { noLazyImages: false } },
+ getPos: () => 0,
+ updateAttributes: vi.fn(),
+ deleteNode: vi.fn(),
+ view: {},
+ innerDecorations: {},
+ HTMLAttributes: {},
+ } as unknown as ImageViewProps,
+ global: {
+ provide: {
+ [ATTACHMENT_RESOLVER as symbol]: shallowRef({ resolve: vi.fn().mockResolvedValue({ ...attachment, isImage }) }),
+ },
+ stubs: {
+ NodeViewWrapper: { template: '('.media-wrapper')
+
+ expect(action.element.tagName).toBe('BUTTON')
+ expect(action.attributes('type')).toBe('button')
+ expect(action.attributes('aria-label')).toBe(label)
+ expect(action.element.tabIndex).toBe(0)
+ })
+
+ it('AUD-18 routes image button activation through the real modal handler', async () => {
+ const wrapper = await mountImage(true)
+ const view = wrapper.vm as unknown as { embeddedImageList: Array }
+ vi.spyOn(wrapper.vm, 'updateEmbeddedImageList').mockImplementation(async () => {
+ view.embeddedImageList = [{ ...attachment, src: 'diagram.png' }]
+ })
+
+ await wrapper.find('.media-wrapper').trigger('click')
+
+ expect(wrapper.vm.imageIndex).toBe(0)
+ expect(wrapper.vm.showImageModal).toBe(true)
+ })
+
+ it('AUD-18 routes attachment button activation through the real Viewer action', async () => {
+ const open = vi.fn()
+ vi.stubGlobal('OCA', { Viewer: { file: null, mimetypes: ['image/png'], open } })
+ const wrapper = await mountImage(false)
+
+ await wrapper.find('.media-wrapper').trigger('click')
+
+ expect(open).toHaveBeenCalledOnce()
+ expect(open).toHaveBeenCalledWith({ path: attachment.davPath })
+ })
+})
diff --git a/src/tests/playwrightConfig.spec.ts b/src/tests/playwrightConfig.spec.ts
new file mode 100644
index 00000000000..3811aa2248e
--- /dev/null
+++ b/src/tests/playwrightConfig.spec.ts
@@ -0,0 +1,76 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+const originalComparisonBaseURL = process.env.TEXT_COMPARISON_BASE_URL
+const originalComparisonE2E = process.env.TEXT_COMPARISON_E2E
+const originalBaseURL = process.env.baseURL
+
+afterEach(() => {
+ setEnvironment('TEXT_COMPARISON_BASE_URL', originalComparisonBaseURL)
+ setEnvironment('TEXT_COMPARISON_E2E', originalComparisonE2E)
+ setEnvironment('baseURL', originalBaseURL)
+})
+
+function setEnvironment(name: string, value: string | undefined) {
+ if (value === undefined) {
+ delete process.env[name]
+ } else {
+ process.env[name] = value
+ }
+}
+
+async function loadConfig(comparisonBaseURL: string | undefined, baseURL: string | undefined, comparisonE2E?: string) {
+ setEnvironment('TEXT_COMPARISON_BASE_URL', comparisonBaseURL)
+ setEnvironment('TEXT_COMPARISON_E2E', comparisonE2E)
+ setEnvironment('baseURL', baseURL)
+ vi.resetModules()
+ return (await import('../../playwright.config.ts')).default
+}
+
+describe('Playwright comparison server selection', () => {
+ it.each([
+ { name: 'unset values', comparisonBaseURL: undefined, baseURL: undefined, expected: 'http://localhost:8089/index.php/', managed: true },
+ { name: 'empty values', comparisonBaseURL: '', baseURL: '', expected: 'http://localhost:8089/index.php/', managed: true },
+ { name: 'generic external URL', comparisonBaseURL: '', baseURL: 'https://generic.example/index.php/', expected: 'https://generic.example/index.php/', managed: false },
+ { name: 'dedicated external URL', comparisonBaseURL: 'https://text.example/index.php/', baseURL: '', expected: 'https://text.example/index.php/', managed: false },
+ { name: 'dedicated precedence', comparisonBaseURL: 'https://text.example/index.php/', baseURL: 'https://generic.example/index.php/', expected: 'https://text.example/index.php/', managed: false },
+ ])('uses the selected URL for $name', async ({ comparisonBaseURL, baseURL, expected, managed }) => {
+ const config = await loadConfig(comparisonBaseURL, baseURL)
+
+ expect(config.use?.baseURL).toBe(expected)
+ expect(config.webServer === undefined).toBe(!managed)
+ })
+
+ it('routes comparison and memory tests to their dedicated projects', async () => {
+ const config = await loadConfig(undefined, undefined, '1')
+ const projects = config.projects ?? []
+ const byName = new Map(projects.map((project) => [project.name, project]))
+ const comparisonNames = [
+ 'comparison-chromium',
+ 'comparison-webkit',
+ 'comparison-chromium-memory',
+ ]
+
+ expect(projects.map(({ name }) => name)).toEqual(['chromium', ...comparisonNames])
+ for (const name of comparisonNames) {
+ const match = byName.get(name)?.testMatch
+ expect(match).toBeInstanceOf(RegExp)
+ expect((match as RegExp).test('playwright/comparison/comparison.spec.ts')).toBe(true)
+ expect((match as RegExp).test('playwright/example.spec.ts')).toBe(false)
+ }
+ for (const name of comparisonNames.slice(0, 2)) {
+ expect(byName.get(name)?.grepInvert).toEqual(/@memory/)
+ expect(byName.get(name)?.grep).toBeUndefined()
+ }
+ expect(byName.get('comparison-chromium-memory')?.grep).toEqual(/@memory/)
+ expect(byName.get('comparison-chromium-memory')?.grepInvert).toBeUndefined()
+ const ordinaryIgnore = byName.get('chromium')?.testIgnore
+ expect(ordinaryIgnore).toBeInstanceOf(RegExp)
+ expect((ordinaryIgnore as RegExp).test('playwright/comparison/comparison.spec.ts')).toBe(true)
+ expect((ordinaryIgnore as RegExp).test('playwright/example.spec.ts')).toBe(false)
+ })
+})
diff --git a/src/tests/services/AttachmentResolver.spec.js b/src/tests/services/AttachmentResolver.spec.js
index 507be93df32..5280056917c 100644
--- a/src/tests/services/AttachmentResolver.spec.js
+++ b/src/tests/services/AttachmentResolver.spec.js
@@ -36,11 +36,9 @@ function initAttachmentResolver(args) {
previewUrl: `http://nextcloud.local/apps/text/mediaPreview?documentId=${fileId}&sessionId=${sessionId}&sessionToken=${sessionToken}&mediaFileName=${a2name}"`,
},
]
- const axiosSpy = vi
- .spyOn(axios, 'post')
+ vi.spyOn(axios, 'post')
.mockReturnValue({ data: attachmentList })
const resolver = new AttachmentResolver(args)
- expect(axiosSpy).toHaveBeenCalled()
return resolver
}
@@ -55,6 +53,15 @@ describe('Image resolver', () => {
}
const currentDirectory = '/parentDir'
+ it('does not request attachment metadata for a direct URL', async () => {
+ const axiosSpy = vi.spyOn(axios, 'post').mockResolvedValue({ data: [] })
+ const resolver = new AttachmentResolver({ fileId })
+
+ await resolver.resolve('https://example.org/pic.jpg')
+
+ expect(axiosSpy).not.toHaveBeenCalled()
+ })
+
it('is a class with one constructor argument', () => {
const resolver = initAttachmentResolver({ fileId })
expect(resolver).toBeInstanceOf(AttachmentResolver)
diff --git a/vite.config.ts b/vite.config.ts
index 1830d335ca4..5d930dd6f08 100644
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -50,6 +50,15 @@ const config = createAppConfig(
},
config: {
base: process.env.BASE,
+ worker: {
+ rollupOptions: {
+ output: {
+ assetFileNames: 'js/[name]-[hash][extname]',
+ chunkFileNames: 'js/[name]-[hash].worker.chunk.mjs',
+ entryFileNames: 'js/[name]-[hash].worker.mjs',
+ },
+ },
+ },
resolve: {
dedupe: ['vue'],
},
\n' : '
\n')
state.renderContent(node)
state.closeBlock(node)
state.ensureNewLine()
diff --git a/src/nodes/DetailsView.vue b/src/nodes/DetailsView.vue
index 65677b0db96..2ec5c094d4e 100644
--- a/src/nodes/DetailsView.vue
+++ b/src/nodes/DetailsView.vue
@@ -5,13 +5,17 @@
-
+
diff --git a/src/nodes/Image.ts b/src/nodes/Image.ts
index 405dc92a694..389be2d9947 100644
--- a/src/nodes/Image.ts
+++ b/src/nodes/Image.ts
@@ -17,6 +17,7 @@ const imageFileDropPluginKey = new PluginKey('imageFileDrop')
const imageExtractAttachmentsKey = new PluginKey('imageExtractAttachments')
interface ImageOptions extends TiptapImageOptions {
+ emitAttachmentEvents: boolean
noLazyImages: boolean
}
@@ -53,6 +54,7 @@ const Image = TiptapImage.extend({
addOptions() {
return {
...this.parent?.() as ImageOptions,
+ emitAttachmentEvents: true,
noLazyImages: false,
}
},
@@ -120,31 +122,33 @@ const Image = TiptapImage.extend({
},
},
}),
- new Plugin({
- key: imageExtractAttachmentsKey,
- state: {
- init(_, { doc }) {
- const attachmentSrcs = extractAttachmentSrcs(doc)
- emit('text:editor:attachments:updated', { attachmentSrcs })
- return { attachmentSrcs }
- },
- apply(tr, value, _oldState, newState) {
- if (!tr.docChanged) {
- return value
- }
- const attachmentSrcs = extractAttachmentSrcs(newState.doc)
- if (
- JSON.stringify(attachmentSrcs)
- === JSON.stringify(value?.attachmentSrcs)
- ) {
- return value
- }
-
- emit('text:editor:attachments:updated', { attachmentSrcs })
- return { attachmentSrcs }
- },
- },
- }),
+ ...(this.options.emitAttachmentEvents
+ ? [new Plugin({
+ key: imageExtractAttachmentsKey,
+ state: {
+ init(_, { doc }) {
+ const attachmentSrcs = extractAttachmentSrcs(doc)
+ emit('text:editor:attachments:updated', { attachmentSrcs })
+ return { attachmentSrcs }
+ },
+ apply(tr, value, _oldState, newState) {
+ if (!tr.docChanged) {
+ return value
+ }
+ const attachmentSrcs = extractAttachmentSrcs(newState.doc)
+ if (
+ JSON.stringify(attachmentSrcs)
+ === JSON.stringify(value?.attachmentSrcs)
+ ) {
+ return value
+ }
+
+ emit('text:editor:attachments:updated', { attachmentSrcs })
+ return { attachmentSrcs }
+ },
+ },
+ })]
+ : []),
]
},
diff --git a/src/nodes/ImageView.vue b/src/nodes/ImageView.vue
index eb2c7576c4d..cec809cbc51 100644
--- a/src/nodes/ImageView.vue
+++ b/src/nodes/ImageView.vue
@@ -24,8 +24,10 @@
v-if="isMediaAttachment"
contenteditable="false"
class="media">
-
![]()
{{ alt }}
{{ attachmentSize }}
-
+
\nlast',
+ },
+ })
+ const sources = wrapper.findAll('pre code')
+ expect(sources).toHaveLength(2)
+ expect(sources[0]!.text()).toContain('')
+ expect(sources[0]!.text()).toContain('⟦ZWSP⟧')
+ expect(sources[1]!.text()).toContain('')
+ expect(wrapper.find('script').exists()).toBe(false)
+ expect(wrapper.find('img').exists()).toBe(false)
+ })
+})
diff --git a/src/tests/comparison/a15HistoryDifferential.spec.ts b/src/tests/comparison/a15HistoryDifferential.spec.ts
new file mode 100644
index 00000000000..15e84bdb803
--- /dev/null
+++ b/src/tests/comparison/a15HistoryDifferential.spec.ts
@@ -0,0 +1,183 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { Node as ProseMirrorNode } from '@tiptap/pm/model'
+
+import { describe, expect, it } from 'vitest'
+import { createComparisonEditor } from '../../comparison/createComparisonEditor.ts'
+import { createHierarchicalMarkdownComparisonModel } from '../../comparison/hierarchicalMarkdownComparisonModel.ts'
+
+interface EditorLike {
+ state: { doc: ProseMirrorNode }
+ destroy: () => void
+}
+
+interface ExpectedReplacement {
+ operation: string
+ detail: string
+ before: string
+ after: string
+}
+
+interface RegressionCase {
+ name: string
+ before: string
+ after: string
+ expected: readonly ExpectedReplacement[]
+}
+
+const regressionCorpus: readonly RegressionCase[] = [
+ {
+ name: 'keeps an exact trailing block outside earlier replacements',
+ before: `# Wiki App
+
+Old build instructions.
+
+Shared footer.
+`,
+ after: `# Collective Wiki
+
+New installation instructions.
+
+Shared footer.
+`,
+ expected: [
+ { operation: 'insert', detail: 'inline', before: '', after: 'Collective ' },
+ { operation: 'delete', detail: 'inline', before: ' App', after: '' },
+ { operation: 'replace', detail: 'inline', before: 'Old build', after: 'New installation' },
+ ],
+ },
+ {
+ name: 'keeps a weighted multi-block gap precise',
+ before: `## Development Background: Ownership
+
+Individual users own files. Collective pages should be owned by the collective.
+
+## Stable anchor
+
+This block is unchanged.
+`,
+ after: `## Development background: Ownership
+
+Collective data is owned by the collective instead.
+
+## Stable anchor
+
+This block is unchanged.
+`,
+ expected: [
+ { operation: 'replace', detail: 'inline', before: 'B', after: 'b' },
+ { operation: 'delete', detail: 'inline', before: 'Individual users own files. ', after: '' },
+ { operation: 'replace', detail: 'inline', before: 'pages should be ', after: 'data is ' },
+ { operation: 'insert', detail: 'inline', before: '', after: ' instead' },
+ ],
+ },
+ {
+ name: 'reports code text and language replacements directly',
+ before: `\`\`\`
+const value = 1
+\`\`\`
+`,
+ after: `\`\`\`js
+const value = 1 // comment
+\`\`\`
+`,
+ expected: [
+ { operation: 'replace', detail: 'block', before: 'const value = 1', after: 'const value = 1 // comment' },
+ { operation: 'insert', detail: 'inline', before: '', after: ' // comment' },
+ ],
+ },
+ {
+ name: 'reports a removed list item as a node deletion',
+ before: `- Remove me
+- Keep me
+`,
+ after: `- Keep me
+`,
+ expected: [
+ { operation: 'delete', detail: 'block', before: 'Remove me', after: '' },
+ ],
+ },
+ {
+ name: 'does not expose parser-only Markdown syntax as a change signal',
+ before: `GNU AGPL v3 or later
+`,
+ after: `Files: *
+Copyright: Azul
+License: AGPL v3 or later
+`,
+ expected: [
+ {
+ operation: 'replace',
+ detail: 'inline',
+ before: 'GNU',
+ after: 'Files: *\nCopyright: Azul azul@example.com\nLicense:',
+ },
+ ],
+ },
+]
+
+function replacementOutput(beforeContent: string, afterContent: string) {
+ const beforeEditor = createComparisonEditor(beforeContent) as EditorLike
+ const afterEditor = createComparisonEditor(afterContent) as EditorLike
+ try {
+ const before = beforeEditor.state.doc
+ const after = afterEditor.state.doc
+ return createHierarchicalMarkdownComparisonModel(before, after).edits
+ .flatMap(({ descriptors }) => descriptors)
+ .map((descriptor) => ({
+ operation: descriptor.operation,
+ detail: descriptor.detail,
+ facets: descriptor.facets,
+ before: before.textBetween(descriptor.before.from, descriptor.before.to, '\n', '\ufffc'),
+ after: after.textBetween(descriptor.after.from, descriptor.after.to, '\n', '\ufffc'),
+ context: descriptor.context,
+ signals: descriptor.signals,
+ coarseReason: descriptor.coarseReason ?? null,
+ }))
+ } finally {
+ beforeEditor.destroy()
+ afterEditor.destroy()
+ }
+}
+
+function replacementProjection(replacements: ReturnType): ExpectedReplacement[] {
+ return replacements.map(({ operation, detail, before, after }) => ({ operation, detail, before, after }))
+}
+
+function corpusCase(name: string) {
+ return regressionCorpus.find((candidate) => candidate.name === name)!
+}
+
+describe('A15 repository-history regression corpus', () => {
+ it.each(regressionCorpus)('$name', ({ before, after, expected }) => {
+ const replacements = replacementOutput(before, after)
+
+ expect(replacementProjection(replacements)).toEqual(expected)
+ expect(replacements.every(({ coarseReason }) => coarseReason === null)).toBe(true)
+ })
+
+ it('keeps replacement descriptor signals observable', () => {
+ const code = corpusCase('reports code text and language replacements directly')
+ const codeReplacements = replacementOutput(code.before, code.after)
+ expect(codeReplacements[0]).toMatchObject({
+ facets: ['attribute'],
+ signals: [{ type: 'attribute', attribute: 'code-language', change: 'changed' }],
+ })
+
+ const deletion = corpusCase('reports a removed list item as a node deletion')
+ expect(replacementOutput(deletion.before, deletion.after)[0]).toMatchObject({
+ facets: ['text', 'structure'],
+ context: { before: { code: 'list-item' }, after: null },
+ signals: [{ type: 'node' }],
+ })
+
+ const syntax = corpusCase('does not expose parser-only Markdown syntax as a change signal')
+ expect(replacementOutput(syntax.before, syntax.after)[0]).toMatchObject({
+ facets: ['text', 'attribute', 'unknown'],
+ signals: [{ type: 'attribute', attribute: 'link', change: 'added' }],
+ })
+ })
+})
diff --git a/src/tests/comparison/comparisonAlignment.spec.ts b/src/tests/comparison/comparisonAlignment.spec.ts
new file mode 100644
index 00000000000..3783e9d7087
--- /dev/null
+++ b/src/tests/comparison/comparisonAlignment.spec.ts
@@ -0,0 +1,343 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { describe, expect, it } from 'vitest'
+import {
+ alignComparisonAxis,
+ createComparisonWorkLedger,
+ DEFAULT_COMPARISON_CELL_LEDGER,
+ DEFAULT_COMPARISON_TOKEN_LEDGER,
+ forcedIncreasingPairs,
+} from '../../comparison/comparisonAlignment.ts'
+
+function options(work = createComparisonWorkLedger()) {
+ return {
+ work,
+ fingerprint: (value: string) => value,
+ profile: (value: string) => [...value],
+ compatible: () => true,
+ }
+}
+
+interface EvidencedItem {
+ id: number
+ side: 'before' | 'after'
+}
+
+function evidencedOptions(work = createComparisonWorkLedger()) {
+ return {
+ work,
+ fingerprint: ({ id, side }: EvidencedItem) => `${side}:${id}`,
+ profile: ({ id, side }: EvidencedItem) => [`item:${id}`, side],
+ compatible: () => true,
+ }
+}
+
+function evidencedAxis(size: number, side: EvidencedItem['side']): EvidencedItem[] {
+ return Array.from({ length: size }, (_value, id) => ({ id, side }))
+}
+
+const FINAL_CELL_LEDGER = DEFAULT_COMPARISON_CELL_LEDGER
+const FINAL_TOKEN_LEDGER = DEFAULT_COMPARISON_TOKEN_LEDGER
+const FINAL_SQUARE_SIZE = Math.floor(Math.sqrt(FINAL_CELL_LEDGER))
+
+function permutations(values: readonly number[]): number[][] {
+ if (values.length < 2) {
+ return [Array.from(values)]
+ }
+ return values.flatMap((value, index) => permutations(values.toSpliced(index, 1))
+ .map((suffix) => [value, ...suffix]))
+}
+
+function exhaustiveForcedPairs(values: readonly number[]) {
+ let maximum = 0
+ const optimal: number[][] = []
+ for (let mask = 0; mask < 2 ** values.length; mask++) {
+ const indices = values.flatMap((_value, index) => mask & (1 << index) ? [index] : [])
+ if (!indices.every((index, offset) => offset === 0 || values[indices[offset - 1]!]! < values[index]!)) {
+ continue
+ }
+ if (indices.length > maximum) {
+ maximum = indices.length
+ optimal.length = 0
+ }
+ if (indices.length === maximum) {
+ optimal.push(indices)
+ }
+ }
+ return optimal[0]!.filter((index) => optimal.every((candidate) => candidate.includes(index)))
+ .map((before) => ({ before, after: values[before]! }))
+}
+
+describe('comparison alignment', () => {
+ it('uses the authoritative comparison-wide shipping ledgers', () => {
+ expect(createComparisonWorkLedger()).toEqual({
+ remainingCells: 40_000,
+ remainingTokenComparisons: 84_000_000,
+ })
+ })
+
+ it('pairs a whole equal axis without weighted work', () => {
+ const work = createComparisonWorkLedger()
+
+ expect(alignComparisonAxis(['alpha', 'beta'], ['alpha', 'beta'], options(work))).toEqual([
+ { before: 0, after: 0 },
+ { before: 1, after: 1 },
+ ])
+ expect(work).toEqual({
+ remainingCells: DEFAULT_COMPARISON_CELL_LEDGER,
+ remainingTokenComparisons: DEFAULT_COMPARISON_TOKEN_LEDGER,
+ })
+ })
+
+ it('A03 uses ordered unique fingerprints as exact anchors', () => {
+ const work = createComparisonWorkLedger()
+
+ expect(alignComparisonAxis(['alpha', 'omega'], ['new', 'alpha', 'omega'], options(work))).toEqual([
+ { before: null, after: 0 },
+ { before: 0, after: 1 },
+ { before: 1, after: 2 },
+ ])
+ expect(work.remainingCells).toBe(40_000)
+ })
+
+ it('matches exhaustive forced-LIS anchors for crossing candidates', () => {
+ for (let size = 1; size <= 6; size++) {
+ for (const values of permutations(Array.from({ length: size }, (_value, index) => index))) {
+ const pairs = values.map((after, before) => ({ before, after }))
+ expect(forcedIncreasingPairs(pairs), values.join(','))
+ .toEqual(exhaustiveForcedPairs(values))
+ }
+ }
+ })
+
+ it('aligns around the forced subset of crossing exact candidates', () => {
+ expect(alignComparisonAxis(['alpha', 'beta', 'gamma'], ['beta', 'gamma', 'alpha'], options())).toEqual([
+ { before: 0, after: null },
+ { before: 1, after: 0 },
+ { before: 2, after: 1 },
+ { before: null, after: 2 },
+ ])
+ })
+
+ it('retains the first exact duplicate when one is inserted', () => {
+ expect(alignComparisonAxis(['same'], ['same', 'same'], options())).toEqual([
+ { before: 0, after: 0 },
+ { before: null, after: 1 },
+ ])
+ })
+
+ it('retains the first exact duplicate when one is deleted', () => {
+ expect(alignComparisonAxis(['same', 'same'], ['same'], options())).toEqual([
+ { before: 0, after: 0 },
+ { before: 1, after: null },
+ ])
+ })
+
+ it('A09 pairs one compatible changed item without weighted work', () => {
+ const work = createComparisonWorkLedger()
+
+ expect(alignComparisonAxis(['before'], ['after'], options(work))).toEqual([
+ { before: 0, after: 0 },
+ ])
+ expect(work.remainingCells).toBe(DEFAULT_COMPARISON_CELL_LEDGER)
+ expect(work.remainingTokenComparisons).toBe(DEFAULT_COMPARISON_TOKEN_LEDGER)
+ })
+
+ it('leaves one incompatible changed item unmatched', () => {
+ const incompatible = {
+ ...options(),
+ compatible: () => false,
+ }
+
+ expect(alignComparisonAxis(['list'], ['quote'], incompatible)).toEqual([
+ { before: 0, after: null },
+ { before: null, after: 0 },
+ ])
+ })
+
+ it('A10 coarsens a multi-item rewrite with ambiguous exact attribution', () => {
+ expect(alignComparisonAxis(['aa', 'bb', 'cc'], ['xx', 'yy'], options())).toEqual([{
+ before: { from: 0, to: 3 },
+ after: { from: 0, to: 2 },
+ coarseReason: 'ambiguous-attribution',
+ }])
+ })
+
+ it.each([
+ Math.floor(FINAL_SQUARE_SIZE / 2),
+ FINAL_SQUARE_SIZE - 1,
+ ])('A11 keeps a final-ledger-derived unique-evidence %i square gap precise', (size) => {
+ const result = alignComparisonAxis(
+ evidencedAxis(size, 'before'),
+ evidencedAxis(size, 'after'),
+ evidencedOptions(),
+ )
+
+ expect(result).toHaveLength(size)
+ expect(result.every((step, index) => step.before === index && step.after === index)).toBe(true)
+ })
+
+ it('A12 keeps the largest default-ledger square gap precise', () => {
+ const work = createComparisonWorkLedger()
+ const size = FINAL_SQUARE_SIZE
+ const result = alignComparisonAxis(
+ evidencedAxis(size, 'before'),
+ evidencedAxis(size, 'after'),
+ evidencedOptions(work),
+ )
+
+ expect(result).toHaveLength(size)
+ expect(work.remainingCells).toBe(0)
+ expect(work.remainingTokenComparisons).toBe(FINAL_TOKEN_LEDGER - 4 * size ** 2)
+ })
+
+ it('A13 refuses the first generated cell and token overflows atomically', () => {
+ const cellWork = createComparisonWorkLedger()
+ const size = FINAL_SQUARE_SIZE
+ expect(alignComparisonAxis(
+ evidencedAxis(size + 1, 'before'),
+ evidencedAxis(size, 'after'),
+ evidencedOptions(cellWork),
+ )).toEqual([{
+ before: { from: 0, to: size + 1 },
+ after: { from: 0, to: size },
+ coarseReason: 'comparison-limit',
+ }])
+ expect(cellWork).toEqual(createComparisonWorkLedger())
+
+ const tokenWork = createComparisonWorkLedger()
+ const longProfile = Array.from({ length: Math.floor(FINAL_TOKEN_LEDGER / (2 * size * size)) + 1 }, () => 'x')
+ expect(alignComparisonAxis(
+ evidencedAxis(size, 'before'),
+ evidencedAxis(size, 'after'),
+ {
+ ...evidencedOptions(tokenWork),
+ profile: () => longProfile,
+ },
+ )).toEqual([{
+ before: { from: 0, to: size },
+ after: { from: 0, to: size },
+ coarseReason: 'comparison-limit',
+ }])
+ expect(tokenWork).toEqual(createComparisonWorkLedger())
+ })
+
+ it('A14 allocates final-ledger cell work by axis order without debiting a refused gap', () => {
+ interface Item {
+ fingerprint: string
+ profile: readonly string[]
+ }
+ const gap = (size: number, name: string, side: 'before' | 'after'): Item[] => (
+ Array.from({ length: size }, (_value, id) => ({
+ fingerprint: `${name}:${side}:${id}`,
+ profile: [`${name}:${id}`, side],
+ }))
+ )
+ const anchor = (name: string): Item => ({ fingerprint: name, profile: [name] })
+ const firstSize = Math.floor(FINAL_SQUARE_SIZE / 2)
+ const refusedSize = FINAL_SQUARE_SIZE
+ const lastSize = Math.max(2, Math.floor(firstSize / 10))
+ const before = [
+ ...gap(firstSize, 'first', 'before'),
+ anchor('anchor-1'),
+ ...gap(refusedSize, 'refused', 'before'),
+ anchor('anchor-2'),
+ ...gap(lastSize, 'last', 'before'),
+ ]
+ const after = [
+ ...gap(firstSize, 'first', 'after'),
+ anchor('anchor-1'),
+ ...gap(refusedSize, 'refused', 'after'),
+ anchor('anchor-2'),
+ ...gap(lastSize, 'last', 'after'),
+ ]
+ const work = createComparisonWorkLedger()
+ const result = alignComparisonAxis(before, after, {
+ work,
+ fingerprint: (item) => item.fingerprint,
+ profile: (item) => item.profile,
+ compatible: () => true,
+ })
+ const refusedStart = firstSize + 1
+
+ expect(result).toContainEqual({
+ before: { from: refusedStart, to: refusedStart + refusedSize },
+ after: { from: refusedStart, to: refusedStart + refusedSize },
+ coarseReason: 'comparison-limit',
+ })
+ expect(result.at(-1)).toEqual({ before: before.length - 1, after: after.length - 1 })
+ expect(work.remainingCells).toBe(FINAL_CELL_LEDGER - firstSize ** 2 - lastSize ** 2)
+ })
+
+ it('A14 retains token and tie debits while preserving work after a refused token gap', () => {
+ interface Item {
+ fingerprint: string
+ profile: readonly string[]
+ }
+ const gapSize = Math.floor(FINAL_SQUARE_SIZE / 2)
+ const firstAfterSize = gapSize - 1
+ const lastSize = Math.max(2, Math.floor(gapSize / 10))
+ const firstProduct = gapSize * firstAfterSize
+ const firstProfileLength = Math.floor(FINAL_TOKEN_LEDGER / (4 * firstProduct))
+ const firstProfile = Array.from({ length: firstProfileLength }, () => 'same')
+ const tieCharge = 2 * firstProduct * firstProfileLength
+ const refusedProfileLength = Math.floor((FINAL_TOKEN_LEDGER - tieCharge) / (2 * gapSize ** 2)) + 1
+ const refusedProfile = Array.from({ length: refusedProfileLength }, () => 'refused')
+ const gap = (size: number, name: string, side: 'before' | 'after', profile?: readonly string[]): Item[] => (
+ Array.from({ length: size }, (_value, id) => ({
+ fingerprint: `${name}:${side}:${id}`,
+ profile: profile ?? [`${name}:${id}`, side],
+ }))
+ )
+ const anchor = (name: string): Item => ({ fingerprint: name, profile: [name] })
+ const before = [
+ ...gap(gapSize, 'tie', 'before', firstProfile),
+ anchor('anchor-1'),
+ ...gap(gapSize, 'refused', 'before', refusedProfile),
+ anchor('anchor-2'),
+ ...gap(lastSize, 'last', 'before'),
+ ]
+ const after = [
+ ...gap(firstAfterSize, 'tie', 'after', firstProfile),
+ anchor('anchor-1'),
+ ...gap(gapSize, 'refused', 'after', refusedProfile),
+ anchor('anchor-2'),
+ ...gap(lastSize, 'last', 'after'),
+ ]
+ const work = createComparisonWorkLedger()
+ const result = alignComparisonAxis(before, after, {
+ work,
+ fingerprint: (item) => item.fingerprint,
+ profile: (item) => item.profile,
+ compatible: () => true,
+ })
+ const lastCharge = 4 * lastSize ** 2
+
+ expect(result[0]).toMatchObject({ coarseReason: 'ambiguous-attribution' })
+ expect(result).toContainEqual({
+ before: { from: gapSize + 1, to: 2 * gapSize + 1 },
+ after: { from: firstAfterSize + 1, to: firstAfterSize + gapSize + 1 },
+ coarseReason: 'comparison-limit',
+ })
+ expect(result.at(-1)).toEqual({ before: before.length - 1, after: after.length - 1 })
+ expect(work).toEqual({
+ remainingCells: FINAL_CELL_LEDGER - firstProduct - lastSize ** 2,
+ remainingTokenComparisons: FINAL_TOKEN_LEDGER - tieCharge - lastCharge,
+ })
+ })
+
+ it('P05 admits a skewed one-by-many gap by its exact cell charge', () => {
+ const work = createComparisonWorkLedger()
+ const result = alignComparisonAxis(
+ evidencedAxis(1, 'before'),
+ evidencedAxis(20_000, 'after'),
+ evidencedOptions(work),
+ )
+
+ expect(result).not.toContainEqual(expect.objectContaining({ coarseReason: 'comparison-limit' }))
+ expect(work.remainingCells).toBe(20_000)
+ })
+})
diff --git a/src/tests/comparison/comparisonAlignmentOracle.spec.ts b/src/tests/comparison/comparisonAlignmentOracle.spec.ts
new file mode 100644
index 00000000000..888fa76d654
--- /dev/null
+++ b/src/tests/comparison/comparisonAlignmentOracle.spec.ts
@@ -0,0 +1,167 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { ComparisonAlignmentStep, ComparisonWorkLedger } from '../../comparison/comparisonAlignment.ts'
+
+import { describe, expect, it } from 'vitest'
+import {
+ DEFAULT_COMPARISON_CELL_LEDGER,
+ DEFAULT_COMPARISON_TOKEN_LEDGER,
+ solveWeightedGap,
+} from '../../comparison/comparisonAlignment.ts'
+
+interface OracleItem {
+ fingerprint: string
+ profile: readonly string[]
+}
+
+interface Rational {
+ numerator: bigint
+ denominator: bigint
+}
+
+interface OracleMatch {
+ before: number
+ after: number
+}
+
+function compareRational(a: Rational, b: Rational) {
+ const difference = a.numerator * b.denominator - b.numerator * a.denominator
+ return difference < 0n ? -1 : difference > 0n ? 1 : 0
+}
+
+function addRational(a: Rational, b: Rational): Rational {
+ return {
+ numerator: a.numerator * b.denominator + b.numerator * a.denominator,
+ denominator: a.denominator * b.denominator,
+ }
+}
+
+function oraclePairScore(before: OracleItem, after: OracleItem): Rational {
+ if (before.fingerprint === after.fingerprint) {
+ return { numerator: 3n, denominator: 1n }
+ }
+ let prefix = 0
+ while (prefix < before.profile.length
+ && prefix < after.profile.length
+ && before.profile[prefix] === after.profile[prefix]) {
+ prefix++
+ }
+ let suffix = 0
+ const maximumSuffix = Math.min(before.profile.length, after.profile.length) - prefix
+ while (suffix < maximumSuffix
+ && before.profile[before.profile.length - suffix - 1] === after.profile[after.profile.length - suffix - 1]) {
+ suffix++
+ }
+ const denominator = BigInt(Math.max(before.profile.length, after.profile.length, 1))
+ return { numerator: denominator + BigInt(prefix + suffix), denominator }
+}
+
+function enumerateMatchings(
+ beforeCount: number,
+ afterCount: number,
+ beforeStart = 0,
+ afterStart = 0,
+): OracleMatch[][] {
+ const matchings: OracleMatch[][] = [[]]
+ for (let before = beforeStart; before < beforeCount; before++) {
+ for (let after = afterStart; after < afterCount; after++) {
+ for (const suffix of enumerateMatchings(beforeCount, afterCount, before + 1, after + 1)) {
+ matchings.push([{ before, after }, ...suffix])
+ }
+ }
+ }
+ return matchings
+}
+
+function oracleAlignment(before: readonly OracleItem[], after: readonly OracleItem[]) {
+ let bestScore: Rational = { numerator: -1n, denominator: 1n }
+ let best: OracleMatch[][] = []
+ for (const matching of enumerateMatchings(before.length, after.length)) {
+ const score = matching.reduce(
+ (total, pair) => addRational(total, oraclePairScore(before[pair.before]!, after[pair.after]!)),
+ { numerator: 0n, denominator: 1n },
+ )
+ const order = compareRational(score, bestScore)
+ if (order > 0) {
+ bestScore = score
+ best = [matching]
+ } else if (order === 0) {
+ best.push(matching)
+ }
+ }
+ const signatures = new Map(best.map((matching) => [
+ matching.map(({ before: a, after: b }) => `${a}:${b}`).join(','),
+ matching,
+ ]))
+ if (signatures.size > 1) {
+ return { coarseReason: 'ambiguous-attribution' as const }
+ }
+ return { steps: alignmentSteps(before.length, after.length, [...signatures.values()][0]!) }
+}
+
+function alignmentSteps(beforeCount: number, afterCount: number, matches: readonly OracleMatch[]) {
+ const steps: ComparisonAlignmentStep[] = []
+ let before = 0
+ let after = 0
+ for (const match of matches) {
+ while (before < match.before) {
+ steps.push({ before: before++, after: null })
+ }
+ while (after < match.after) {
+ steps.push({ before: null, after: after++ })
+ }
+ steps.push({ before: before++, after: after++ })
+ }
+ while (before < beforeCount) {
+ steps.push({ before: before++, after: null })
+ }
+ while (after < afterCount) {
+ steps.push({ before: null, after: after++ })
+ }
+ return steps
+}
+
+function axes(items: readonly OracleItem[], maximumLength: number): OracleItem[][] {
+ const result: OracleItem[][] = [[]]
+ for (let length = 1; length <= maximumLength; length++) {
+ for (const prefix of result.filter((axis) => axis.length === length - 1)) {
+ for (const item of items) {
+ result.push([...prefix, item])
+ }
+ }
+ }
+ return result
+}
+
+function freshWork(): ComparisonWorkLedger {
+ return {
+ remainingCells: DEFAULT_COMPARISON_CELL_LEDGER,
+ remainingTokenComparisons: DEFAULT_COMPARISON_TOKEN_LEDGER,
+ }
+}
+
+describe('comparison alignment exact oracles', () => {
+ it('matches an independent exact-rational and signature oracle exhaustively', () => {
+ const items: OracleItem[] = [
+ { fingerprint: 'a', profile: ['shared', 'a'] },
+ { fingerprint: 'b', profile: ['shared', 'b'] },
+ { fingerprint: 'c', profile: ['c'] },
+ ]
+ const candidates = axes(items, 3)
+ for (const before of candidates) {
+ for (const after of candidates) {
+ const actual = solveWeightedGap(before, after, {
+ work: freshWork(),
+ fingerprint: (item) => item.fingerprint,
+ profile: (item) => item.profile,
+ compatible: () => true,
+ })
+ expect(actual, `${before.map(({ fingerprint }) => fingerprint)} -> ${after.map(({ fingerprint }) => fingerprint)}`)
+ .toEqual(oracleAlignment(before, after))
+ }
+ }
+ })
+})
diff --git a/src/tests/comparison/comparisonDecorations.spec.ts b/src/tests/comparison/comparisonDecorations.spec.ts
new file mode 100644
index 00000000000..62b217b4f70
--- /dev/null
+++ b/src/tests/comparison/comparisonDecorations.spec.ts
@@ -0,0 +1,90 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { ComparisonDescriptor } from '../../comparison/markdownComparisonTypes.ts'
+
+import { EditorState } from '@tiptap/pm/state'
+import { schema } from 'prosemirror-schema-basic'
+import { describe, expect, it } from 'vitest'
+import { createComparisonDocumentIndex } from '../../comparison/comparisonDocumentIndex.ts'
+import { createComparisonEditor } from '../../comparison/createComparisonEditor.ts'
+import {
+ ComparisonProjectionError,
+ createComparisonDecorationPlugin,
+ prepareComparisonDecorations,
+} from '../../comparison/markdownComparison.ts'
+
+function descriptor(id: string, before: { from: number, to: number }, after = before): ComparisonDescriptor {
+ return {
+ id,
+ operation: 'replace',
+ detail: 'inline',
+ facets: ['text'],
+ before,
+ after,
+ context: { before: null, after: null },
+ preview: { before: null, after: null },
+ signals: [],
+ }
+}
+
+const doc = schema.node('doc', null, [schema.node('paragraph', null, schema.text('hello'))])
+
+describe('comparison decorations', () => {
+ it('does not infer a current descriptor without edit-owned selection', () => {
+ const change = descriptor('text', { from: 1, to: 4 })
+ const { key, plugin } = createComparisonDecorationPlugin([change], 'before', 'Changed')
+ const state = EditorState.create({ doc, plugins: [plugin] })
+ expect(key.getState(state)).toMatchObject({ activeIds: ['text'], currentIds: [] })
+ })
+
+ it('V04 projects non-empty ranges without creating any marker for a zero-length side', () => {
+ expect(prepareComparisonDecorations(doc, [descriptor('empty', { from: 2, to: 2 })], 'before')).toEqual([])
+ const projected = prepareComparisonDecorations(doc, [descriptor('text', { from: 1, to: 4 })], 'before')
+ expect(projected).toEqual([expect.objectContaining({ from: 1, to: 4, type: 'inline' })])
+ })
+
+ it('fails the complete projection when a non-empty range cannot be represented', () => {
+ const invalid = descriptor('invalid', { from: 99, to: 100 })
+ expect(() => prepareComparisonDecorations(doc, [invalid], 'before')).toThrow(ComparisonProjectionError)
+ })
+
+ it('AUD-04 decorates the enclosing list for a coarse nested-list range', () => {
+ const editor = createComparisonEditor('- outer\n - first\n - second')
+ try {
+ const index = createComparisonDocumentIndex(editor.state.doc)
+ const outerList = index.children[0]!
+ const nestedList = outerList.children[0]!.children[1]!
+ const firstItem = nestedList.children[0]!
+ const lastItem = nestedList.children.at(-1)!
+ const change = descriptor('nested-list', { from: firstItem.from, to: lastItem.to })
+ change.detail = 'block'
+ change.context.before = {
+ code: 'list-item',
+ path: firstItem.path,
+ from: firstItem.from,
+ to: firstItem.to,
+ }
+
+ expect(prepareComparisonDecorations(editor.state.doc, [change], 'before')).toEqual([
+ expect.objectContaining({ from: nestedList.from, to: nestedList.to, type: 'node' }),
+ ])
+ } finally {
+ editor.destroy()
+ }
+ })
+
+ it('invalidates prepared immutable decorations after a document transaction', () => {
+ const change = descriptor('text', { from: 1, to: 4 })
+ const { key, plugin } = createComparisonDecorationPlugin([change], 'before', 'Changed', {
+ activeIds: ['text'],
+ currentIds: ['text'],
+ })
+ const state = EditorState.create({ doc, plugins: [plugin] })
+ expect(key.getState(state)?.prepared).toHaveLength(1)
+ const changed = state.apply(state.tr.insertText('!', 1))
+ expect(key.getState(changed)).toMatchObject({ activeIds: [], currentIds: [], prepared: [] })
+ })
+})
diff --git a/src/tests/comparison/comparisonDocumentLocation.spec.ts b/src/tests/comparison/comparisonDocumentLocation.spec.ts
new file mode 100644
index 00000000000..42afa139dd6
--- /dev/null
+++ b/src/tests/comparison/comparisonDocumentLocation.spec.ts
@@ -0,0 +1,52 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { describe, expect, it, vi } from 'vitest'
+import { locateComparisonTarget } from '../../comparison/comparisonNavigation.ts'
+
+function scrollerIn(pane: HTMLElement) {
+ const scroller = document.createElement('div')
+ pane.append(scroller)
+ Object.defineProperties(scroller, {
+ clientHeight: { value: 300 },
+ scrollHeight: { value: 1200 },
+ scrollLeft: { value: 20 },
+ scrollTop: { value: 50 },
+ })
+ vi.spyOn(scroller, 'getBoundingClientRect').mockReturnValue({ height: 300, top: 100 } as DOMRect)
+ Object.defineProperty(scroller, 'scrollTo', { value: vi.fn() })
+ return scroller
+}
+
+describe('comparison document location', () => {
+ it('prefers the decorated DOM target', () => {
+ const pane = document.createElement('article')
+ const scroller = scrollerIn(pane)
+ const target = document.createElement('span')
+ target.dataset.comparisonChange = 'descriptor-1'
+ scroller.append(target)
+ vi.spyOn(target, 'getBoundingClientRect').mockReturnValue({ height: 20, top: 700 } as DOMRect)
+ const fallback = vi.fn(() => ({ top: 900, height: 1 }))
+ expect(locateComparisonTarget(pane, scroller, 'descriptor-1', 'smooth', fallback)).toBe(true)
+ expect(fallback).not.toHaveBeenCalled()
+ })
+
+ it('V04 centers a supplied position rectangle for a marker-free zero-length side', () => {
+ const pane = document.createElement('article')
+ const scroller = scrollerIn(pane)
+ const fallback = vi.fn(() => ({ top: 700, height: 1 }))
+ expect(locateComparisonTarget(pane, scroller, 'missing', 'auto', fallback)).toBe(true)
+ expect(scroller.scrollTo).toHaveBeenCalledWith({ behavior: 'auto', left: 20, top: 500.5 })
+ expect(pane.querySelector('[data-comparison-change="missing"]')).toBeNull()
+ })
+
+ it('fails closed for invalid or hidden panes', () => {
+ const pane = document.createElement('article')
+ const scroller = scrollerIn(pane)
+ pane.hidden = true
+ expect(locateComparisonTarget(pane, scroller, 'missing', 'auto', () => ({ top: 1, height: 1 }))).toBe(false)
+ expect(locateComparisonTarget(null, scroller, 'missing', 'auto')).toBe(false)
+ })
+})
diff --git a/src/tests/comparison/comparisonEditorLifecycle.spec.ts b/src/tests/comparison/comparisonEditorLifecycle.spec.ts
new file mode 100644
index 00000000000..ead3a8dbfbb
--- /dev/null
+++ b/src/tests/comparison/comparisonEditorLifecycle.spec.ts
@@ -0,0 +1,28 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { PluginKey, Plugin as ProseMirrorPlugin } from '@tiptap/pm/state'
+import { mount } from '@vue/test-utils'
+import { describe, expect, it, vi } from 'vitest'
+import ComparisonEditorContent from '../../components/ComparisonEditorContent.vue'
+import { createComparisonEditor } from '../../comparison/createComparisonEditor.ts'
+
+describe('comparison editor lifecycle boundary', () => {
+ it('mounts the detached editor with its comparison plugin and node views', async () => {
+ const editor = createComparisonEditor('::: info\nBefore\n:::')
+ const plugin = new ProseMirrorPlugin({ key: new PluginKey('comparison') })
+ const wrapper = mount(ComparisonEditorContent, { props: { editor, plugins: [plugin] } })
+ try {
+ await vi.waitFor(() => expect(wrapper.emitted('ready')).toHaveLength(1))
+ const content = wrapper.get('.text-comparison__content')
+ expect(editor.view.dom.parentElement).toBe(content.element)
+ expect(content.find('[data-node-view-wrapper][data-text-el="callout"]').exists()).toBe(true)
+ expect(plugin.spec.key?.get(editor.state)).toBeDefined()
+ } finally {
+ wrapper.unmount()
+ editor.destroy()
+ }
+ })
+})
diff --git a/src/tests/comparison/comparisonNavigation.spec.ts b/src/tests/comparison/comparisonNavigation.spec.ts
new file mode 100644
index 00000000000..f627fa4c048
--- /dev/null
+++ b/src/tests/comparison/comparisonNavigation.spec.ts
@@ -0,0 +1,61 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { ComparisonDescriptor, ComparisonEdit } from '../../comparison/markdownComparisonTypes.ts'
+
+import { describe, expect, it } from 'vitest'
+import {
+ currentIdAfterFilter,
+ currentOrdinal,
+ isPureFormatting,
+ moveCurrentId,
+} from '../../comparison/comparisonNavigation.ts'
+
+function descriptor(id: string, facets: ComparisonDescriptor['facets'], operation: ComparisonDescriptor['operation'] = 'replace'): ComparisonDescriptor {
+ return {
+ id,
+ operation,
+ detail: 'inline',
+ facets,
+ before: { from: 0, to: 1 },
+ after: { from: 0, to: 1 },
+ context: { before: null, after: null },
+ preview: { before: null, after: null },
+ signals: [],
+ }
+}
+
+function edit(id: string, descriptors: ComparisonDescriptor[]): ComparisonEdit {
+ return { id, kind: 'content', primary: descriptors.at(-1)!, descriptors }
+}
+
+describe('edit-first comparison navigation', () => {
+ const edits = [
+ edit('e0', [descriptor('d0', ['text'])]),
+ edit('e1', [descriptor('d1', ['formatting'])]),
+ edit('e2', [descriptor('d2a', ['formatting']), descriptor('d2b', ['text', 'formatting'])]),
+ edit('e3', [descriptor('d3', ['attribute'])]),
+ ]
+
+ it('requires every member to be formatting-only', () => {
+ expect(isPureFormatting(edits[1]!)).toBe(true)
+ expect(isPureFormatting(edits[2]!)).toBe(false)
+ })
+
+ it('V02 preserves the current edit or moves next then previous after filtering', () => {
+ expect(currentIdAfterFilter(edits, ['e0', 'e2', 'e3'], 'e2')).toBe('e2')
+ expect(currentIdAfterFilter(edits, ['e0', 'e2', 'e3'], 'e1')).toBe('e2')
+ expect(currentIdAfterFilter(edits, ['e0'], 'e1')).toBe('e0')
+ expect(currentIdAfterFilter(edits, [], 'e1')).toBeNull()
+ })
+
+ it('V01 wraps navigation and reports one ordinal per first-class edit', () => {
+ const active = ['e0', 'e2', 'e3']
+ expect(moveCurrentId(active, 'e0', -1)).toBe('e3')
+ expect(moveCurrentId(active, 'e3', 1)).toBe('e0')
+ expect(currentOrdinal(active, 'e2')).toBe(2)
+ expect(currentOrdinal([], null)).toBe(0)
+ })
+})
diff --git a/src/tests/comparison/comparisonPerformance.spec.ts b/src/tests/comparison/comparisonPerformance.spec.ts
new file mode 100644
index 00000000000..4cbdade1289
--- /dev/null
+++ b/src/tests/comparison/comparisonPerformance.spec.ts
@@ -0,0 +1,171 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { Node } from '@tiptap/pm/model'
+
+import { describe, expect, it } from 'vitest'
+import {
+ alignComparisonAxis,
+ createComparisonWorkLedger,
+ DEFAULT_COMPARISON_TOKEN_LEDGER,
+} from '../../comparison/comparisonAlignment.ts'
+import { createHierarchicalMarkdownComparisonModel } from '../../comparison/hierarchicalMarkdownComparisonModel.ts'
+import { prepareComparisonDecorations } from '../../comparison/markdownComparison.ts'
+import { createComparisonTestEditor } from './comparisonTestEditor.ts'
+
+interface Item {
+ key: string
+ profile: readonly string[]
+}
+
+function items(count: number, side: string): Item[] {
+ return Array.from({ length: count }, (_value, index) => ({
+ key: `${side}:${index}`,
+ profile: [`item:${index}`, side],
+ }))
+}
+
+function options(work = createComparisonWorkLedger()) {
+ return {
+ work,
+ fingerprint: ({ key }: Item) => key,
+ profile: ({ profile }: Item) => profile,
+ compatible: () => true,
+ }
+}
+
+describe('bounded comparison performance fixtures', () => {
+ it('AUD-14 projects near-limit one-sided descriptors within a bounded candidate budget', () => {
+ const editor = createComparisonTestEditor('placeholder')
+ try {
+ const headings = Array.from({ length: 6490 }, (_value, index) => (
+ editor.schema.nodes.heading!.create({ level: 1 }, editor.schema.text(`Section ${index}`))
+ ))
+ const populated = editor.schema.nodes.doc!.create(null, headings)
+ const empty = editor.schema.nodes.doc!.create()
+ const model = createHierarchicalMarkdownComparisonModel(populated, empty)
+ const descriptors = model.edits.flatMap(({ descriptors: members }) => members)
+
+ const prepared = prepareComparisonDecorations(populated, descriptors, 'before')
+
+ expect(prepared).toHaveLength(headings.length)
+ } finally {
+ editor.destroy()
+ }
+ })
+
+ it('P01 compares a near-6500-line exact-anchor document with negligible weighted work', () => {
+ const editor = createComparisonTestEditor('placeholder')
+ try {
+ const headings = Array.from({ length: 6490 }, (_value, index) => (
+ editor.schema.nodes.heading!.create({ level: 1 }, editor.schema.text(`Section ${index}`))
+ ))
+ const before = editor.schema.nodes.doc!.create(null, headings)
+ const changedHeading = editor.schema.nodes.heading!.create(
+ { level: 1 },
+ editor.schema.text('Section 3245 edited'),
+ )
+ const after = editor.schema.nodes.doc!.create(null, headings.with(3245, changedHeading))
+
+ const model = createHierarchicalMarkdownComparisonModel(before, after)
+
+ expect(model.edits).toHaveLength(1)
+
+ const work = createComparisonWorkLedger()
+ const axis = Array.from({ length: 6490 }, (_value, index) => ({
+ key: `anchor:${index}`,
+ profile: [`anchor:${index}`],
+ }))
+ const changed = axis.with(3245, { key: 'changed:3245', profile: ['changed:3245'] })
+ alignComparisonAxis(axis, changed, options(work))
+ expect(work).toEqual(createComparisonWorkLedger())
+ } finally {
+ editor.destroy()
+ }
+ })
+
+ it.each(['insert', 'delete'] as const)('places a near-6500-line one-sided %s axis in linear time', (operation) => {
+ const editor = createComparisonTestEditor('placeholder')
+ try {
+ const headings = Array.from({ length: 6490 }, (_value, index) => (
+ editor.schema.nodes.heading!.create({ level: 1 }, editor.schema.text(`Section ${index}`))
+ ))
+ const empty = editor.schema.nodes.doc!.create()
+ const populated = editor.schema.nodes.doc!.create(null, headings)
+ const model = operation === 'insert'
+ ? createHierarchicalMarkdownComparisonModel(empty, populated)
+ : createHierarchicalMarkdownComparisonModel(populated, empty)
+
+ expect(model.edits).toHaveLength(headings.length)
+ expect(model.edits.every(({ primary }) => primary.operation === operation)).toBe(true)
+ } finally {
+ editor.destroy()
+ }
+ })
+
+ it('P04 shares the final token ledger across nested production nodes', () => {
+ const editor = createComparisonTestEditor('placeholder')
+ try {
+ const firstBeforeCount = 100
+ const firstAfterCount = firstBeforeCount - 1
+ const firstProduct = firstBeforeCount * firstAfterCount
+ const firstLength = Math.floor(DEFAULT_COMPARISON_TOKEN_LEDGER / (4 * firstProduct))
+ const firstCharge = 2 * firstProduct * firstLength
+ const secondCount = 100
+ const secondLength = Math.floor((DEFAULT_COMPARISON_TOKEN_LEDGER - firstCharge) / (2 * secondCount ** 2)) + 1
+ const paragraphs = (count: number, character: string, length: number) => Array.from(
+ { length: count },
+ () => editor.schema.nodes.paragraph!.create(null, editor.schema.text(character.repeat(length))),
+ )
+ const quote = (children: readonly Node[]) => (
+ editor.schema.nodes.blockquote!.create(null, children)
+ )
+ const anchor = editor.schema.nodes.paragraph!.create(null, editor.schema.text('exact nested boundary anchor'))
+ const before = editor.schema.nodes.doc!.create(null, [
+ quote(paragraphs(firstBeforeCount, 'a', firstLength)),
+ anchor,
+ quote(paragraphs(secondCount, 'c', secondLength)),
+ ])
+ const after = editor.schema.nodes.doc!.create(null, [
+ quote(paragraphs(firstAfterCount, 'b', firstLength)),
+ anchor,
+ quote(paragraphs(secondCount, 'd', secondLength)),
+ ])
+ const model = createHierarchicalMarkdownComparisonModel(before, after)
+
+ expect(2 * secondCount ** 2 * (secondLength - 1)).toBeLessThanOrEqual(DEFAULT_COMPARISON_TOKEN_LEDGER - firstCharge)
+ expect(2 * secondCount ** 2 * secondLength).toBeGreaterThan(DEFAULT_COMPARISON_TOKEN_LEDGER - firstCharge)
+ expect(model.edits.map(({ primary }) => primary.coarseReason)).toEqual([
+ 'ambiguous-attribution',
+ 'comparison-limit',
+ ])
+ } finally {
+ editor.destroy()
+ }
+ })
+
+ it('P03 bounds many aggregate maximal gaps with one comparison-wide ledger', () => {
+ const gapCount = 5
+ const gapSize = 200
+ const before: Item[] = []
+ const after: Item[] = []
+ for (let gap = 0; gap < gapCount; gap++) {
+ before.push(...items(gapSize, `before-${gap}`))
+ after.push(...items(gapSize, `after-${gap}`))
+ if (gap < gapCount - 1) {
+ const anchor = { key: `anchor-${gap}`, profile: [`anchor-${gap}`] }
+ before.push(anchor)
+ after.push(anchor)
+ }
+ }
+ const work = createComparisonWorkLedger()
+
+ const result = alignComparisonAxis(before, after, options(work))
+ const limited = result.filter((region) => 'coarseReason' in region && region.coarseReason === 'comparison-limit')
+
+ expect(work.remainingCells).toBe(0)
+ expect(limited).toHaveLength(gapCount - 1)
+ })
+})
diff --git a/src/tests/comparison/comparisonPresentation.spec.ts b/src/tests/comparison/comparisonPresentation.spec.ts
new file mode 100644
index 00000000000..92be57d563f
--- /dev/null
+++ b/src/tests/comparison/comparisonPresentation.spec.ts
@@ -0,0 +1,28 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { ComparisonAttributeCode, ComparisonSignal } from '../../comparison/markdownComparisonTypes.ts'
+
+import { describe, expect, it } from 'vitest'
+import { selectComparisonSignal } from '../../comparison/comparisonPresentation.ts'
+
+const bold: ComparisonSignal = { type: 'mark', mark: 'bold', change: 'added' }
+const attribute = (code: ComparisonAttributeCode): ComparisonSignal => ({ type: 'attribute', attribute: code, change: 'changed' })
+
+describe('AUD-10 comparison presentation', () => {
+ it('selects the same strongest attribute regardless of descriptor storage order', () => {
+ const signals = [bold, attribute('image-alt'), attribute('image-target')]
+ expect(selectComparisonSignal(signals)).toEqual(attribute('image-target'))
+ expect(selectComparisonSignal([...signals].reverse())).toEqual(attribute('image-target'))
+ })
+
+ it('prioritizes every specific attribute and node structure over generic formatting', () => {
+ for (const code of ['link', 'task-state', 'heading-level', 'table-span', 'unknown-attribute'] as const) {
+ expect(selectComparisonSignal([bold, attribute(code)])).toEqual(attribute(code))
+ }
+ const node: ComparisonSignal = { type: 'node' }
+ expect(selectComparisonSignal([bold, node])).toEqual(node)
+ })
+})
diff --git a/src/tests/comparison/comparisonSections.spec.ts b/src/tests/comparison/comparisonSections.spec.ts
new file mode 100644
index 00000000000..2dd787ba6f4
--- /dev/null
+++ b/src/tests/comparison/comparisonSections.spec.ts
@@ -0,0 +1,76 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { Node } from '@tiptap/pm/model'
+import type { ComparisonDescriptor, ComparisonEdit } from '../../comparison/markdownComparisonTypes.ts'
+
+import { schema } from 'prosemirror-schema-basic'
+import { describe, expect, it } from 'vitest'
+import { buildComparisonSections, headingLocations, nearestHeading } from '../../comparison/comparisonSections.ts'
+
+function doc(...blocks: Array<[type: 'heading' | 'paragraph', text: string]>): Node {
+ return schema.node('doc', null, blocks.map(([type, text]) => schema.node(type, type === 'heading' ? { level: 1 } : null, text ? schema.text(text) : undefined)))
+}
+
+function descriptor(id: string, operation: ComparisonDescriptor['operation'], before: number, after: number): ComparisonDescriptor {
+ return {
+ id,
+ operation,
+ detail: 'inline',
+ facets: ['text'],
+ before: { from: before, to: before + 1 },
+ after: { from: after, to: after + 1 },
+ context: {
+ before: { code: 'paragraph', path: [1], from: before, to: before + 1 },
+ after: { code: 'paragraph', path: [1], from: after, to: after + 1 },
+ },
+ preview: { before: null, after: null },
+ signals: [],
+ }
+}
+
+function edit(id: string, primary: ComparisonDescriptor, members: ComparisonDescriptor[] = [primary]): ComparisonEdit {
+ return { id, kind: 'content', primary, descriptors: members }
+}
+
+describe('edit-first comparison sections', () => {
+ it('finds ordered headings and resolves the nearest preceding heading', () => {
+ const document = doc(['paragraph', 'Intro'], ['heading', 'One'], ['paragraph', 'Body'], ['heading', 'Two'])
+ const headings = headingLocations(document)
+ expect(headings.map(({ text }) => text)).toEqual(['One', 'Two'])
+ expect(nearestHeading(headings, 0)).toBe('')
+ expect(nearestHeading(headings, headings[1]!.from)).toBe('Two')
+ })
+
+ it('builds one row source per edit', () => {
+ const before = doc(['heading', 'Alpha'], ['paragraph', 'Before'])
+ const after = doc(['heading', 'Alpha'], ['paragraph', 'After'])
+ const headingEnd = after.child(0).nodeSize
+ const primary = descriptor('d-primary', 'replace', headingEnd, headingEnd)
+ const formatting = { ...descriptor('d-format', 'replace', headingEnd, headingEnd), facets: ['formatting'] as const }
+ const sections = buildComparisonSections([edit('edit-1', primary, [formatting, primary])], before, after)
+
+ expect(sections).toEqual([expect.objectContaining({
+ id: 'edit-1',
+ title: 'Alpha',
+ edits: [expect.objectContaining({ id: 'edit-1', primary })],
+ })])
+ })
+
+ it('uses Before context for deletions and the After title for a correlated rename', () => {
+ const before = doc(['heading', 'Old'], ['paragraph', 'Before'])
+ const after = doc(['heading', 'New'], ['paragraph', 'After'])
+ const beforeBody = before.child(0).nodeSize
+ const afterBody = after.child(0).nodeSize
+ const rename = descriptor('rename', 'replace', 0, 0)
+ rename.context.before = { code: 'heading', path: [0], from: 0, to: beforeBody }
+ rename.context.after = { code: 'heading', path: [0], from: 0, to: afterBody }
+ const deletion = descriptor('delete', 'delete', beforeBody, afterBody)
+ const sections = buildComparisonSections([edit('rename-edit', rename), edit('delete-edit', deletion)], before, after)
+
+ expect(sections.map(({ title }) => title)).toEqual(['New'])
+ expect(sections[0]!.edits.map(({ id }) => id)).toEqual(['rename-edit', 'delete-edit'])
+ })
+})
diff --git a/src/tests/comparison/comparisonTestEditor.ts b/src/tests/comparison/comparisonTestEditor.ts
new file mode 100644
index 00000000000..103a67e7973
--- /dev/null
+++ b/src/tests/comparison/comparisonTestEditor.ts
@@ -0,0 +1,19 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { createComparisonEditor } from '../../comparison/createComparisonEditor.ts'
+
+export function createComparisonTestEditor(content: string) {
+ return createComparisonEditor(content, { noLazyImages: true })
+}
+
+export function comparisonTestDocument(content: string) {
+ const editor = createComparisonEditor(content, { noLazyImages: true })
+ try {
+ return editor.state.doc
+ } finally {
+ editor.destroy()
+ }
+}
diff --git a/src/tests/comparison/createComparisonEditor.spec.ts b/src/tests/comparison/createComparisonEditor.spec.ts
new file mode 100644
index 00000000000..cda29bf339d
--- /dev/null
+++ b/src/tests/comparison/createComparisonEditor.spec.ts
@@ -0,0 +1,28 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { describe, expect, it } from 'vitest'
+import { createComparisonEditor } from '../../comparison/createComparisonEditor.ts'
+
+describe('comparison editor', () => {
+ it('creates a complete immutable detached Text editor with directional paragraphs', () => {
+ const editor = createComparisonEditor('English\n\nالعربية')
+ try {
+ expect(editor.options.element).toBeInstanceOf(HTMLElement)
+ expect((editor.options.element as HTMLElement).isConnected).toBe(false)
+ expect(editor.isEditable).toBe(false)
+ expect(editor.state.doc.textContent).toBe('Englishالعربية')
+ const directions: Array = []
+ editor.state.doc.descendants((node) => {
+ if (node.type.name === 'paragraph') {
+ directions.push(node.attrs.dir as string | null)
+ }
+ })
+ expect(directions.slice(0, 2)).toEqual(['ltr', 'rtl'])
+ } finally {
+ editor.destroy()
+ }
+ })
+})
diff --git a/src/tests/comparison/createMarkdownContentComparison.spec.ts b/src/tests/comparison/createMarkdownContentComparison.spec.ts
new file mode 100644
index 00000000000..53c3fd57479
--- /dev/null
+++ b/src/tests/comparison/createMarkdownContentComparison.spec.ts
@@ -0,0 +1,281 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { Editor } from '@tiptap/vue-3'
+import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from 'vitest'
+import { nextTick } from 'vue'
+import * as markdownComparison from '../../comparison/markdownComparison.ts'
+import { createMarkdownContentComparison } from '../../createMarkdownContentComparison.ts'
+
+const originalScrollTo = HTMLElement.prototype.scrollTo
+
+beforeAll(async () => {
+ HTMLElement.prototype.scrollTo = vi.fn()
+ await Promise.all([
+ import('../../components/MarkdownContentComparison.vue'),
+ import('../../components/MarkdownSourceFallback.vue'),
+ ])
+})
+
+afterAll(() => {
+ if (originalScrollTo) {
+ HTMLElement.prototype.scrollTo = originalScrollTo
+ } else {
+ delete (HTMLElement.prototype as Partial).scrollTo
+ }
+})
+
+afterEach(() => vi.restoreAllMocks())
+
+describe('Markdown comparison factory fallback and lifecycle', () => {
+ it('V09 reports syntax-only Markdown as no semantic edit and opens Source', async () => {
+ const el = document.createElement('div')
+ const instance = await createMarkdownContentComparison({
+ beforeContent: '*same rendered text*',
+ afterContent: '_same rendered text_',
+ el,
+ })
+
+ expect(el.querySelectorAll('[data-comparison-change]')).toHaveLength(0)
+ expect(el.querySelector('[role="status"]')?.textContent).toContain('No rendered differences')
+ const openSource = el.querySelector('[data-comparison-empty-action]')
+ expect(openSource).not.toBeNull()
+ openSource!.click()
+ await nextTick()
+ expect([...el.querySelectorAll('[role="tab"]')]
+ .find(({ textContent }) => textContent?.trim() === 'Markdown source')
+ ?.getAttribute('aria-selected')).toBe('true')
+ instance.destroy()
+ })
+
+ it('F05 remounts complete Source when rendered editor initialization fails', async () => {
+ vi.spyOn(Editor.prototype, 'mount').mockImplementation(() => {
+ throw new Error('forced mount failure')
+ })
+ const el = document.createElement('div')
+ const instance = await createMarkdownContentComparison({ beforeContent: 'before', afterContent: 'after', el })
+ expect(el.querySelector('[data-comparison-source-fallback]')).not.toBeNull()
+ expect(el.querySelectorAll('.ProseMirror')).toHaveLength(0)
+ expect(el.textContent).toContain('before')
+ expect(el.textContent).toContain('after')
+ instance.destroy()
+ instance.destroy()
+ expect(el.childElementCount).toBe(0)
+ })
+
+ it('F06 remounts complete Source without partial Documents when projection fails', async () => {
+ const originalSetAttribute = Element.prototype.setAttribute
+ vi.spyOn(Element.prototype, 'setAttribute').mockImplementation(function(this: Element, name, value) {
+ if (name === 'data-comparison-change') {
+ throw new Error('forced projection failure')
+ }
+ return originalSetAttribute.call(this, name, value)
+ })
+ const beforeContent = 'Complete projection before'
+ const afterContent = 'Complete projection after'
+ const el = document.createElement('div')
+ const instance = await createMarkdownContentComparison({ beforeContent, afterContent, el })
+ const fullDocuments = [...el.querySelectorAll('[role="tab"]')]
+ .find(({ textContent }) => textContent?.trim() === 'Full documents')
+
+ fullDocuments!.click()
+ await vi.waitFor(() => {
+ expect(el.querySelector('[data-comparison-source-fallback]')).not.toBeNull()
+ })
+ expect(el.querySelectorAll('.text-comparison__documents .ProseMirror')).toHaveLength(0)
+ expect(el.textContent).toContain(beforeContent)
+ expect(el.textContent).toContain(afterContent)
+ instance.destroy()
+ })
+
+ it('V12 can reopen the same pair after idempotent destroy without leaking root DOM', async () => {
+ const el = document.createElement('div')
+ for (let index = 0; index < 2; index++) {
+ const instance = await createMarkdownContentComparison({ beforeContent: 'Before', afterContent: 'After', el })
+ expect(el.querySelectorAll('.text-comparison-root')).toHaveLength(1)
+ instance.destroy()
+ instance.destroy()
+ expect(el.childElementCount).toBe(0)
+ }
+ })
+
+ it('keeps both document editors alive while switching views', async () => {
+ const el = document.createElement('div')
+ const instance = await createMarkdownContentComparison({ beforeContent: 'Before', afterContent: 'After', el })
+ expect(el.querySelectorAll('.ProseMirror')).toHaveLength(0)
+ expect(el.querySelectorAll('[data-comparison-source-fallback]')).toHaveLength(0)
+ const selectTab = async (label: string) => {
+ const tab = [...el.querySelectorAll('[role="tab"]')]
+ .find(({ textContent }) => textContent?.trim() === label)
+ expect(tab).toBeDefined()
+ tab!.click()
+ await nextTick()
+ }
+
+ await selectTab('Full documents')
+ expect(el.querySelectorAll('.ProseMirror')).toHaveLength(2)
+ await selectTab('Changes')
+ await selectTab('Full documents')
+
+ expect(el.querySelector('.text-comparison > [data-comparison-source-fallback]')).toBeNull()
+ expect(el.querySelectorAll('.ProseMirror')).toHaveLength(2)
+ instance.destroy()
+ })
+
+ it('omits duplicate heading anchors from the two comparison documents', async () => {
+ const el = document.createElement('div')
+ const instance = await createMarkdownContentComparison({
+ beforeContent: '# Shared heading\n\nBefore',
+ afterContent: '# Shared heading\n\nAfter',
+ el,
+ })
+ const documents = [...el.querySelectorAll('[role="tab"]')]
+ .find(({ textContent }) => textContent?.trim() === 'Full documents')
+
+ documents!.click()
+ await nextTick()
+
+ await vi.waitFor(() => expect(el.querySelectorAll('.ProseMirror')).toHaveLength(2))
+ await new Promise((resolve) => setTimeout(resolve, 0))
+ expect(el.querySelectorAll('.text-comparison__documents .heading-anchor[id]')).toHaveLength(0)
+ instance.destroy()
+ })
+
+ it('AUD-02 publishes the current selection when Documents mounts lazily', async () => {
+ const originalScrollTo = HTMLElement.prototype.scrollTo
+ const scrollTo = vi.fn()
+ HTMLElement.prototype.scrollTo = scrollTo
+ const el = document.createElement('div')
+ const instance = await createMarkdownContentComparison({
+ beforeContent: 'Old first.\n\nOld second.',
+ afterContent: 'New first.\n\nNew second.',
+ el,
+ })
+ const secondEdit = el.querySelectorAll('[data-comparison-select]')[1]
+
+ secondEdit!.click()
+ await vi.waitFor(() => {
+ expect(el.querySelectorAll('[data-comparison-change="change-1"][aria-current="true"]')).toHaveLength(2)
+ })
+ await vi.waitFor(() => expect(scrollTo).toHaveBeenCalled())
+ instance.destroy()
+ if (originalScrollTo) {
+ HTMLElement.prototype.scrollTo = originalScrollTo
+ } else {
+ delete (HTMLElement.prototype as Partial).scrollTo
+ }
+ })
+
+ it('AUD-11 locates the current edit on the newly visible side after a single-to-paired resize', async () => {
+ const originalResizeObserver = globalThis.ResizeObserver
+ const originalScrollTo = HTMLElement.prototype.scrollTo
+ const scrollTo = vi.fn()
+ let resizeTo!: (width: number) => void
+ HTMLElement.prototype.scrollTo = scrollTo
+ globalThis.ResizeObserver = class {
+ constructor(private readonly callback: ResizeObserverCallback) {}
+
+ observe(target: Element) {
+ resizeTo = (width) => this.callback([{ target, contentRect: { width } } as ResizeObserverEntry], this)
+ resizeTo(600)
+ }
+
+ disconnect() {}
+
+ unobserve() {}
+ } as typeof ResizeObserver
+ const el = document.createElement('div')
+ const instance = await createMarkdownContentComparison({
+ beforeContent: 'Old first.\n\nOld second.',
+ afterContent: 'New first.\n\nNew second.',
+ el,
+ })
+ try {
+ el.querySelectorAll('[data-comparison-select]')[1]!.click()
+ await vi.waitFor(() => expect(el.querySelector('.text-comparison--single')).not.toBeNull())
+ const afterScroller = el.querySelector('.text-comparison__document--after .text-comparison__document-scroller')!
+ await vi.waitFor(() => expect(scrollTo).toHaveBeenCalled())
+ expect(scrollTo.mock.contexts).not.toContain(afterScroller)
+
+ resizeTo(900)
+ await vi.waitFor(() => expect(el.querySelector('.text-comparison--paired')).not.toBeNull())
+
+ expect(scrollTo.mock.contexts).toContain(afterScroller)
+ } finally {
+ instance.destroy()
+ globalThis.ResizeObserver = originalResizeObserver
+ if (originalScrollTo) {
+ HTMLElement.prototype.scrollTo = originalScrollTo
+ } else {
+ delete (HTMLElement.prototype as Partial).scrollTo
+ }
+ }
+ })
+
+ it('keeps the working comparison when the loaded callback throws', async () => {
+ const el = document.createElement('div')
+ const creation = createMarkdownContentComparison({
+ beforeContent: 'Before',
+ afterContent: 'After',
+ el,
+ onLoaded: () => { throw new Error('callback failure') },
+ })
+ const instance = await Promise.race([
+ creation,
+ new Promise((resolve) => setTimeout(() => resolve(null), 1000)),
+ ])
+ expect(instance).not.toBeNull()
+ expect(el.querySelector('.text-comparison')).not.toBeNull()
+ expect(el.querySelector('[data-comparison-source-fallback]')).toBeNull()
+ instance?.destroy()
+ })
+
+ it('AUD-21 awaits a rejected loaded callback and keeps the working comparison', async () => {
+ const el = document.createElement('div')
+ let rejectLoaded!: (error: Error) => void
+ const onLoaded = vi.fn(() => new Promise((_resolve, reject) => {
+ rejectLoaded = reject
+ }))
+ const creation = createMarkdownContentComparison({
+ beforeContent: 'Before',
+ afterContent: 'After',
+ el,
+ onLoaded,
+ })
+ let creationSettled = false
+ void creation.then(() => {
+ creationSettled = true
+ })
+ await new Promise((resolve) => setTimeout(resolve, 0))
+
+ expect(onLoaded).toHaveBeenCalledOnce()
+ expect(creationSettled).toBe(false)
+ rejectLoaded(new Error('async callback failure'))
+ const instance = await creation
+
+ expect(el.querySelector('.text-comparison')).not.toBeNull()
+ expect(el.querySelector('[data-comparison-source-fallback]')).toBeNull()
+ instance.destroy()
+ })
+
+ it('F07 routes a descriptor model limit to complete Source', async () => {
+ vi.spyOn(markdownComparison, 'createMarkdownComparisonModel').mockImplementation(() => {
+ throw new markdownComparison.ComparisonModelLimitError()
+ })
+ const beforeContent = '# Complete before snapshot\n\nBefore body\n'
+ const afterContent = '# Complete after snapshot\n\nAfter body\n'
+ const el = document.createElement('div')
+
+ const instance = await createMarkdownContentComparison({ beforeContent, afterContent, el })
+
+ expect(el.querySelector('[data-comparison-source-fallback]')).not.toBeNull()
+ expect(el.querySelectorAll('.ProseMirror')).toHaveLength(0)
+ expect(el.textContent).toContain('Detailed rendered comparison unavailable')
+ expect(el.textContent).not.toContain('No rendered changes')
+ expect(el.textContent).toContain(beforeContent)
+ expect(el.textContent).toContain(afterContent)
+ instance.destroy()
+ })
+})
diff --git a/src/tests/comparison/hierarchicalMarkdownComparison.spec.ts b/src/tests/comparison/hierarchicalMarkdownComparison.spec.ts
new file mode 100644
index 00000000000..88ac12c2f13
--- /dev/null
+++ b/src/tests/comparison/hierarchicalMarkdownComparison.spec.ts
@@ -0,0 +1,363 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { Node } from '@tiptap/pm/model'
+import type { ComparisonEdit, ComparisonSide } from '../../comparison/markdownComparisonTypes.ts'
+
+import { Schema } from '@tiptap/pm/model'
+import { schema as basicSchema } from 'prosemirror-schema-basic'
+import { describe, expect, it } from 'vitest'
+import {
+ ComparisonModelLimitError,
+ createHierarchicalMarkdownComparisonModel,
+ MAX_INLINE_ENVELOPE_SIZE,
+ MAX_RENDERED_COMPARISON_DESCRIPTORS,
+} from '../../comparison/hierarchicalMarkdownComparisonModel.ts'
+import { comparisonTestDocument, createComparisonTestEditor } from './comparisonTestEditor.ts'
+
+function compare(beforeContent: string, afterContent: string) {
+ const before = comparisonTestDocument(beforeContent)
+ const after = comparisonTestDocument(afterContent)
+ return {
+ before,
+ after,
+ model: createHierarchicalMarkdownComparisonModel(before, after),
+ }
+}
+
+function meaningfulSize(doc: Node) {
+ return doc.content.size - (doc.lastChild?.content.size === 0 ? doc.lastChild.nodeSize : 0)
+}
+
+function editText(doc: { textBetween: (from: number, to: number, separator: string) => string }) {
+ return (edit: ComparisonEdit, side: ComparisonSide) => (
+ doc.textBetween(edit.primary[side].from, edit.primary[side].to, '\n')
+ )
+}
+
+describe('hierarchical markdown comparison', () => {
+ it('A01 emits no edit for two equal documents', () => {
+ const { model } = compare('# Title\n\nBody text.\n', '# Title\n\nBody text.\n')
+
+ expect(model.edits).toEqual([])
+ })
+
+ it('A02 normalizes separate schema instances without position or content drift', () => {
+ const beforeEditor = createComparisonTestEditor('# Title\n\nOriginal body.\n')
+ const afterEditor = createComparisonTestEditor('# Title\n\nUpdated body.\n')
+ try {
+ const before = beforeEditor.state.doc
+ const after = afterEditor.state.doc
+ expect(before.type.schema).not.toBe(after.type.schema)
+
+ const model = createHierarchicalMarkdownComparisonModel(before, after)
+
+ expect(model.edits).toHaveLength(1)
+ const [edit] = model.edits
+ expect(before.textBetween(edit!.primary.before.from, edit!.primary.before.to)).toBe('Original')
+ expect(after.textBetween(edit!.primary.after.from, edit!.primary.after.to)).toBe('Updated')
+ } finally {
+ beforeEditor.destroy()
+ afterEditor.destroy()
+ }
+ })
+
+ it('AUD-19 rejects cross-schema normalization that drops node attributes', () => {
+ const paragraph = basicSchema.spec.nodes.get('paragraph')!
+ const beforeSchema = new Schema({
+ nodes: basicSchema.spec.nodes.update('paragraph', { ...paragraph, attrs: { audit: { default: null } } }),
+ marks: basicSchema.spec.marks,
+ })
+ const afterSchema = new Schema({ nodes: basicSchema.spec.nodes, marks: basicSchema.spec.marks })
+ const before = beforeSchema.node('doc', null, [beforeSchema.node('paragraph', { audit: 'must-survive' }, beforeSchema.text('same'))])
+ const after = afterSchema.node('doc', null, [afterSchema.node('paragraph', null, afterSchema.text('same'))])
+
+ expect(() => createHierarchicalMarkdownComparisonModel(before, after)).toThrow(/schema normalization lost semantics/)
+ })
+
+ it('A05 retains the first repeated paragraph and inserts the second copy', () => {
+ const { after, model } = compare('Anchor\n\nSame\n', 'Anchor\n\nSame\n\nSame\n')
+ const text = editText(after)
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]!.primary.operation).toBe('insert')
+ expect(text(model.edits[0]!, 'after')).toBe('Same')
+ expect(model.edits[0]!.primary.after).toEqual({
+ from: after.child(0).nodeSize + after.child(1).nodeSize,
+ to: meaningfulSize(after),
+ })
+ })
+
+ it('A06 retains the first repeated paragraph and deletes the second copy', () => {
+ const { before, model } = compare('Anchor\n\nSame\n\nSame\n', 'Anchor\n\nSame\n')
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]!.primary.operation).toBe('delete')
+ expect(model.edits[0]!.primary.before).toEqual({
+ from: before.child(0).nodeSize + before.child(1).nodeSize,
+ to: meaningfulSize(before),
+ })
+ })
+
+ it.each([
+ ['insertion', '# Existing\n', '## Added\n\n# Existing\n', 'insert'],
+ ['deletion', '## Removed\n\n# Existing\n', '# Existing\n', 'delete'],
+ ] as const)('AUD-12 reports a heading %s as added or removed without adjacent heading attributes', (_name, beforeContent, afterContent, operation) => {
+ const { model } = compare(beforeContent, afterContent)
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]!.primary.operation).toBe(operation)
+ expect(model.edits[0]!.primary.signals).not.toContainEqual(expect.objectContaining({
+ type: 'attribute',
+ attribute: 'heading-level',
+ }))
+ })
+
+ it('A07 reports a paragraph turning into a heading as one semantic replacement', () => {
+ const { model } = compare('Shared title\n', '# Shared title\n')
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({
+ kind: 'content',
+ primary: {
+ detail: 'block',
+ operation: 'replace',
+ context: { before: { code: 'paragraph' }, after: { code: 'heading' } },
+ },
+ })
+ expect(model.edits[0]!.primary.facets).toContain('structure')
+ expect(model.edits[0]!.primary.signals).toContainEqual({
+ type: 'attribute',
+ attribute: 'heading-level',
+ change: 'added',
+ })
+ })
+
+ it('A08 does not pair incompatible non-text containers', () => {
+ const { model } = compare('- Shared item\n', '> Shared item\n')
+
+ expect(model.edits).toHaveLength(2)
+ expect(model.edits.map(({ primary }) => primary.operation).toSorted()).toEqual(['delete', 'insert'])
+ })
+
+ it.each([
+ ['section headings', '# Setup\n\n# Usage\n\n# Notes\n', '# Install\n\n# Config\n'],
+ ['shopping items', 'Buy milk\n\nBuy eggs\n\nBuy rice\n', 'Get bread\n\nGet jam\n'],
+ ])('A10 coarsens a no-affix %s rewrite', (_name, beforeContent, afterContent) => {
+ const { before, after, model } = compare(beforeContent, afterContent)
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]!.primary).toMatchObject({
+ coarseReason: 'ambiguous-attribution',
+ detail: 'block',
+ operation: 'replace',
+ before: { from: 0, to: meaningfulSize(before) },
+ after: { from: 0, to: meaningfulSize(after) },
+ })
+ })
+
+ it('reports one reordered block as one move edit', () => {
+ const { model } = compare(
+ 'Unique alpha\n\nUnique beta\n\nUnique gamma\n',
+ 'Unique beta\n\nUnique gamma\n\nUnique alpha\n',
+ )
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]!.primary).toMatchObject({
+ operation: 'move',
+ detail: 'block',
+ facets: ['structure'],
+ })
+ })
+
+ it('pairs uniquely compatible changed containers instead of coarsening their shared gap', () => {
+ const before = [
+ '# Operational notes',
+ '',
+ '> Draft maintenance window starts at 20:00.',
+ '',
+ '::: info',
+ 'The canary is limited to one region.',
+ ':::',
+ '',
+ '![]()
')
+ expect(model.status).toBe('ready')
+ if (model.status !== 'ready') {
+ return
+ }
+ expect(lines(model.hunks, 'before').map(({ text }) => text)).toContain('')
+ expect(lines(model.hunks, 'after').map(({ text }) => text)).toContain('![]()
')
+ })
+
+ it('reports limits and aborts without losing the caller fallback contract', async () => {
+ await expect(createMarkdownSourceComparison('x'.repeat(SOURCE_DIFF_LIMITS.maximumCharacters + 1), ''))
+ .resolves.toEqual({ status: 'limited', reason: 'size' })
+ const controller = new AbortController()
+ controller.abort()
+ await expect(createMarkdownSourceComparison('before', 'after', controller.signal)).rejects.toMatchObject({ name: 'AbortError' })
+ })
+
+ it('V11 terminates an in-flight worker when the caller aborts', async () => {
+ const terminate = vi.fn()
+ vi.stubGlobal('Worker', class {
+ addEventListener() {}
+ removeEventListener() {}
+ postMessage() {}
+ terminate() { terminate() }
+ })
+ const controller = new AbortController()
+ const comparison = createMarkdownSourceComparison('before', 'after', controller.signal)
+ controller.abort()
+ await expect(comparison).rejects.toMatchObject({ name: 'AbortError' })
+ expect(terminate).toHaveBeenCalledOnce()
+ })
+
+ it('terminates the worker when posting the comparison request throws', async () => {
+ const failure = new Error('post failure')
+ const terminate = vi.fn()
+ vi.stubGlobal('Worker', class {
+ addEventListener() {}
+ removeEventListener() {}
+ postMessage() {
+ throw failure
+ }
+
+ terminate() { terminate() }
+ })
+
+ await expect(createMarkdownSourceComparison('before', 'after')).rejects.toBe(failure)
+ expect(terminate).toHaveBeenCalledOnce()
+ })
+
+ it('rejects message decoding errors once and ignores a late success', async () => {
+ const workers: Array<{ onmessage?: EventListener, onmessageerror?: EventListener }> = []
+ const terminate = vi.fn()
+ vi.stubGlobal('Worker', class {
+ onmessage?: EventListener
+ onmessageerror?: EventListener
+ constructor() {
+ workers.push(this)
+ }
+
+ postMessage() {}
+
+ terminate() { terminate() }
+ })
+ const comparison = createMarkdownSourceComparison('before', 'after')
+
+ expect(workers[0]!.onmessageerror).toBeTypeOf('function')
+ workers[0]!.onmessageerror!(new MessageEvent('messageerror'))
+ workers[0]!.onmessage!(new MessageEvent('message', { data: { status: 'ready', changes: [] } }))
+
+ await expect(comparison).rejects.toThrow('Source comparison worker failed')
+ expect(terminate).toHaveBeenCalledOnce()
+ })
+
+ it('rejects malformed worker responses after cleanup', async () => {
+ const workers: Array<{ onmessage?: EventListener }> = []
+ const terminate = vi.fn()
+ vi.stubGlobal('Worker', class {
+ onmessage?: EventListener
+ constructor() {
+ workers.push(this)
+ }
+
+ postMessage() {}
+
+ terminate() { terminate() }
+ })
+ const comparison = createMarkdownSourceComparison('before', 'after')
+
+ workers[0]!.onmessage!(new MessageEvent('message', { data: null }))
+
+ await expect(comparison).rejects.toThrow('Source comparison worker failed')
+ expect(terminate).toHaveBeenCalledOnce()
+ })
+
+ it('uses the same bounded line protocol for main-thread and worker paths', () => {
+ expect(compareMarkdownSourceLines({ before: 'old\n', after: 'new\n', maximumEditLength: 10, timeoutMilliseconds: 1000 }))
+ .toMatchObject({ status: 'ready' })
+ expect(compareMarkdownSourceLines({ before: 'old\n', after: 'new\n', maximumEditLength: 0, timeoutMilliseconds: 1000 }))
+ .toEqual({ status: 'limited' })
+ })
+})
diff --git a/src/tests/comparison/markdownSourceComparisonWorker.spec.ts b/src/tests/comparison/markdownSourceComparisonWorker.spec.ts
new file mode 100644
index 00000000000..031caf28ae2
--- /dev/null
+++ b/src/tests/comparison/markdownSourceComparisonWorker.spec.ts
@@ -0,0 +1,30 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { SourceComparisonWorkerRequest } from '../../comparison/markdownSourceComparisonProtocol.ts'
+
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+afterEach(() => {
+ vi.resetModules()
+ vi.unstubAllGlobals()
+})
+
+describe('Markdown source comparison worker', () => {
+ it('delegates ready and limited messages to the shared protocol', async () => {
+ let listener: ((event: MessageEvent) => void) | undefined
+ const postMessage = vi.fn()
+ vi.stubGlobal('addEventListener', vi.fn((_type, callback) => {
+ listener = callback
+ }))
+ vi.stubGlobal('postMessage', postMessage)
+ await import('../../comparison/markdownSourceComparison.worker.ts')
+ expect(listener).toBeTypeOf('function')
+ listener?.(new MessageEvent('message', { data: { before: 'old\n', after: 'new\n', maximumEditLength: 10, timeoutMilliseconds: 1000 } }))
+ expect(postMessage).toHaveBeenLastCalledWith(expect.objectContaining({ status: 'ready' }))
+ listener?.(new MessageEvent('message', { data: { before: 'old\n', after: 'new\n', maximumEditLength: 0, timeoutMilliseconds: 1000 } }))
+ expect(postMessage).toHaveBeenLastCalledWith({ status: 'limited' })
+ })
+})
diff --git a/src/tests/comparison/renderedComparisonLimit.spec.ts b/src/tests/comparison/renderedComparisonLimit.spec.ts
new file mode 100644
index 00000000000..276e71aaaed
--- /dev/null
+++ b/src/tests/comparison/renderedComparisonLimit.spec.ts
@@ -0,0 +1,23 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { describe, expect, it } from 'vitest'
+import { exceedsRenderedComparisonLimit, RENDERED_COMPARISON_LIMITS } from '../../comparison/markdownComparison.ts'
+
+describe('rendered comparison preflight', () => {
+ it('accepts each exact geometry ceiling and rejects the first excess', () => {
+ const chars = RENDERED_COMPARISON_LIMITS.maximumCharactersPerSnapshot
+ const lineChars = RENDERED_COMPARISON_LIMITS.maximumCharactersPerLine
+ const line = `${'a'.repeat(lineChars - 1)}\n`
+ const source = (length: number) => line.repeat(Math.floor(length / line.length)) + 'a'.repeat(length % line.length)
+ expect(exceedsRenderedComparisonLimit(source(chars), 'after')).toBe(false)
+ expect(exceedsRenderedComparisonLimit(source(chars + 1), 'after')).toBe(true)
+ expect(exceedsRenderedComparisonLimit('a'.repeat(lineChars), 'after')).toBe(false)
+ expect(exceedsRenderedComparisonLimit('a'.repeat(lineChars + 1), 'after')).toBe(true)
+ const lines = RENDERED_COMPARISON_LIMITS.maximumLinesPerSnapshot
+ expect(exceedsRenderedComparisonLimit('x\n'.repeat(lines - 1), 'after')).toBe(false)
+ expect(exceedsRenderedComparisonLimit('x\r'.repeat(lines), 'after')).toBe(true)
+ })
+})
diff --git a/src/tests/comparison/tableGridComparison.spec.ts b/src/tests/comparison/tableGridComparison.spec.ts
new file mode 100644
index 00000000000..6d14c301559
--- /dev/null
+++ b/src/tests/comparison/tableGridComparison.spec.ts
@@ -0,0 +1,655 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { Schema } from '@tiptap/pm/model'
+import type { ComparisonEdit, ComparisonSide } from '../../comparison/markdownComparisonTypes.ts'
+
+import { Node as ProseMirrorNode } from '@tiptap/pm/model'
+import { describe, expect, it, vi } from 'vitest'
+import {
+ alignComparisonColumns,
+ DEFAULT_COMPARISON_TOKEN_LEDGER,
+} from '../../comparison/comparisonAlignment.ts'
+import { createHierarchicalMarkdownComparisonModel } from '../../comparison/hierarchicalMarkdownComparisonModel.ts'
+import { comparisonTestDocument, createComparisonTestEditor } from './comparisonTestEditor.ts'
+
+function markdownTable(header: readonly string[], rows: readonly (readonly string[])[]) {
+ return [
+ `| ${header.join(' | ')} |`,
+ `|${header.map(() => '---').join('|')}|`,
+ ...rows.map((row) => `| ${row.join(' | ')} |`),
+ ].join('\n')
+}
+
+function compare(before: string, after: string) {
+ return createHierarchicalMarkdownComparisonModel(
+ comparisonTestDocument(before),
+ comparisonTestDocument(after),
+ )
+}
+
+interface TableSpec {
+ header: readonly { text: string, colspan?: number, rowspan?: number }[]
+ rows: readonly (readonly { text: string, colspan?: number, rowspan?: number }[])[]
+}
+
+function tableNode(schema: Schema, spec: TableSpec) {
+ const text = (value: string) => value ? schema.text(value) : undefined
+ const cell = (name: 'tableHeader' | 'tableCell', value: TableSpec['header'][number]) => schema.nodes[name]!.create(
+ { colspan: value.colspan ?? 1, rowspan: value.rowspan ?? 1 },
+ name === 'tableHeader' ? text(value.text) : schema.nodes.paragraph!.create(null, text(value.text)),
+ )
+ const header = schema.nodes.tableHeadRow!.create(null, spec.header.map((value) => cell('tableHeader', value)))
+ const rows = spec.rows.map((row) => schema.nodes.tableRow!.create(null, row.map((value) => cell('tableCell', value))))
+ return schema.nodes.table!.create(null, [header, ...rows])
+}
+
+function tableDocument(schema: Schema, spec: TableSpec) {
+ return schema.nodes.doc!.create(null, tableNode(schema, spec))
+}
+
+function compareTableSpecs(before: TableSpec, after: TableSpec) {
+ const editor = createComparisonTestEditor('placeholder')
+ try {
+ return createHierarchicalMarkdownComparisonModel(
+ tableDocument(editor.schema, before),
+ tableDocument(editor.schema, after),
+ )
+ } finally {
+ editor.destroy()
+ }
+}
+
+function malformedTableDocument(
+ schema: Schema,
+ children: readonly ('caption' | 'header' | 'body' | 'header-with-body-cell' | 'body-with-header-cell')[],
+) {
+ const text = (value: string) => schema.text(value)
+ const headerCell = () => schema.nodes.tableHeader!.create(null, text('header'))
+ const bodyCell = () => schema.nodes.tableCell!.create(null, schema.nodes.paragraph!.create(null, text('body')))
+ const nodes = children.map((kind) => {
+ if (kind === 'caption') {
+ return schema.nodes.tableCaption!.create(null, text('caption'))
+ }
+ if (kind === 'header') {
+ return schema.nodes.tableHeadRow!.create(null, headerCell())
+ }
+ if (kind === 'body') {
+ return schema.nodes.tableRow!.create(null, bodyCell())
+ }
+ if (kind === 'header-with-body-cell') {
+ return schema.nodes.tableHeadRow!.create(null, bodyCell())
+ }
+ return schema.nodes.tableRow!.create(null, headerCell())
+ })
+ return schema.nodes.doc!.create(null, schema.nodes.table!.create(null, nodes))
+}
+
+function expectColumnEdit(
+ edit: ComparisonEdit,
+ operation: 'delete' | 'insert',
+ column: number,
+ rows: number,
+) {
+ const side: ComparisonSide = operation === 'delete' ? 'before' : 'after'
+ expect(edit.kind).toBe('table-column')
+ expect(edit.primary.operation).toBe(operation)
+ expect(edit.descriptors).toHaveLength(rows)
+ expect(edit.descriptors.every((descriptor) => descriptor.operation === operation)).toBe(true)
+ expect(edit.descriptors.map((descriptor) => descriptor.context[side]?.path.at(-1)))
+ .toEqual(Array.from({ length: rows }, () => column))
+ expect(edit.descriptors).toContain(edit.primary)
+}
+
+describe('sparse table comparison', () => {
+ it('AUD-14 does not materialize table profiles before matrix budget admission', () => {
+ const editor = createComparisonTestEditor('placeholder')
+ const columns = 201
+ const before = tableDocument(editor.schema, {
+ header: Array.from({ length: columns }, (_value, index) => ({ text: `before-${index}` })),
+ rows: [],
+ })
+ const after = tableDocument(editor.schema, {
+ header: Array.from({ length: columns }, (_value, index) => ({ text: `after-${index}` })),
+ rows: [],
+ })
+ const textContent = vi.spyOn(ProseMirrorNode.prototype, 'textContent', 'get')
+ try {
+ const model = createHierarchicalMarkdownComparisonModel(before, after)
+
+ expect(model.edits[0]!.primary.coarseReason).toBe('comparison-limit')
+ const tableCellReads = textContent.mock.contexts.filter((node) => (
+ (node as ProseMirrorNode).type.name === 'tableHeader'
+ )).length
+ expect(tableCellReads).toBeLessThanOrEqual(columns * 2 * 5)
+ } finally {
+ textContent.mockRestore()
+ editor.destroy()
+ }
+ })
+
+ it.each([
+ ['first', 0],
+ ['middle', 1],
+ ['last', 2],
+ ] as const)('T01 attributes the %s duplicate-body column deletion', (_name, column) => {
+ const widerHeader = ['A', 'B', 'C']
+ const narrowerHeader = widerHeader.filter((_value, index) => index !== column)
+ const wider = markdownTable(widerHeader, Array.from({ length: 2 }, () => ['x', 'x', 'x']))
+ const narrower = markdownTable(narrowerHeader, Array.from({ length: 2 }, () => ['x', 'x']))
+
+ const deletion = compare(wider, narrower)
+ expect(deletion.edits).toHaveLength(1)
+ expectColumnEdit(deletion.edits[0]!, 'delete', column, 3)
+ })
+
+ it.each([
+ ['first', 0],
+ ['middle', 1],
+ ['last', 2],
+ ] as const)('T02 attributes the %s duplicate-body column insertion', (_name, column) => {
+ const widerHeader = ['A', 'B', 'C']
+ const narrowerHeader = widerHeader.filter((_value, index) => index !== column)
+ const wider = markdownTable(widerHeader, Array.from({ length: 2 }, () => ['x', 'x', 'x']))
+ const narrower = markdownTable(narrowerHeader, Array.from({ length: 2 }, () => ['x', 'x']))
+
+ const insertion = compare(narrower, wider)
+ expect(insertion.edits).toHaveLength(1)
+ expectColumnEdit(insertion.edits[0]!, 'insert', column, 3)
+ })
+
+ it('T03 distinguishes duplicate headers with an exact body row', () => {
+ const model = compare(
+ markdownTable(['X', 'X', 'X'], [['a', 'b', 'c'], ['x', 'x', 'x']]),
+ markdownTable(['X', 'X'], [['a', 'b'], ['x', 'x']]),
+ )
+
+ expect(model.edits).toHaveLength(1)
+ expectColumnEdit(model.edits[0]!, 'delete', 2, 3)
+ })
+
+ it('T04 pairs equal duplicate-vector multiplicity by rank beside a unique deletion', () => {
+ const model = compare(
+ markdownTable(['A', 'X', 'X', 'C'], [['x', 'x', 'x', 'x']]),
+ markdownTable(['A', 'X', 'X'], [['x', 'x', 'x']]),
+ )
+
+ expect(model.edits).toHaveLength(1)
+ expectColumnEdit(model.edits[0]!, 'delete', 3, 2)
+ })
+
+ it('T05 keeps unequal identical-column multiplicity coarse', () => {
+ const model = compare(
+ markdownTable(['X', 'X', 'X'], [['', '', ''], ['x', 'x', 'x']]),
+ markdownTable(['X', 'X'], [['', ''], ['x', 'x']]),
+ )
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({
+ kind: 'content',
+ primary: {
+ operation: 'replace',
+ coarseReason: 'ambiguous-attribution',
+ context: { before: { code: 'table' }, after: { code: 'table' } },
+ },
+ })
+ })
+
+ it('T06 keeps a crossing exact column reorder coarse', () => {
+ const model = compare(
+ markdownTable(['A', 'B', 'C'], [['a', 'b', 'c']]),
+ markdownTable(['C', 'B', 'A'], [['c', 'b', 'a']]),
+ )
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({
+ kind: 'content',
+ primary: {
+ operation: 'replace',
+ coarseReason: 'table-evidence-conflict',
+ context: { before: { code: 'table' }, after: { code: 'table' } },
+ },
+ })
+ })
+
+ it('T07 keeps one edited retained column precise at cell altitude', () => {
+ const model = compare(
+ markdownTable(['A', 'B', 'C'], [['1', '2', '3']]),
+ markdownTable(['A', 'X', 'C'], [['1', 'changed', '3']]),
+ )
+ const descriptors = model.edits.flatMap(({ descriptors }) => descriptors)
+
+ expect(model.edits).toHaveLength(2)
+ expect(model.edits.every(({ kind }) => kind === 'content')).toBe(true)
+ expect(descriptors).toHaveLength(2)
+ expect(descriptors.map(({ context }) => context.before?.path)).toEqual([
+ [0, 0, 1],
+ [0, 1, 1],
+ ])
+ expect(descriptors.map(({ before, after }) => ({ before, after }))).toEqual([
+ { before: { from: 6, to: 7 }, after: { from: 6, to: 7 } },
+ { before: { from: 20, to: 21 }, after: { from: 20, to: 27 } },
+ ])
+ expect(descriptors.every(({ context }) => (
+ context.before?.code === 'table-cell' && context.after?.code === 'table-cell'
+ ))).toBe(true)
+ })
+
+ it('T08 keeps two adjacent edited columns precise when the optimum is unique', () => {
+ const model = compare(
+ markdownTable(['A', 'B old', 'C old', 'D'], [['1', 'before b', 'before c', '4']]),
+ markdownTable(['A', 'B new', 'C new', 'D'], [['1', 'after b', 'after c', '4']]),
+ )
+ const descriptors = model.edits.flatMap(({ descriptors }) => descriptors)
+
+ expect(descriptors).toHaveLength(4)
+ expect(model.edits.every(({ kind }) => kind === 'content')).toBe(true)
+ expect(descriptors.every(({ coarseReason }) => coarseReason === undefined)).toBe(true)
+ expect(descriptors.every(({ context }) => (
+ context.before?.code === 'table-cell' && context.after?.code === 'table-cell'
+ ))).toBe(true)
+ })
+
+ it('groups one column alignment change across its physical cells without duplicating content edits', () => {
+ const model = compare([
+ '# Evidence matrix',
+ '',
+ '| Signal | Evidence | State |',
+ '| :--- | :---: | ---: |',
+ '| API \\| worker | **Draft** [runbook](https://example.org/draft) | 10% |',
+ '| Screenshot |  | Pending |',
+ ].join('\n'), [
+ '# Evidence matrix',
+ '',
+ '| Signal | Evidence | State |',
+ '| ---: | :--- | :---: |',
+ '| API \\| worker | **Approved** [runbook](https://example.org/approved) | 25% |',
+ '| Screenshot |  | Complete |',
+ ].join('\n'))
+ const alignmentEdits = model.edits.filter(({ primary }) => primary.signals.some((signal) => (
+ signal.type === 'attribute' && signal.attribute === 'table-alignment'
+ )))
+ expect(model.edits).toHaveLength(7)
+ expect(alignmentEdits).toHaveLength(3)
+ expect(alignmentEdits.map(({ descriptors }) => descriptors.length)).toEqual([3, 3, 3])
+ expect(alignmentEdits.every(({ descriptors }) => descriptors.every(({ signals }) => signals.some((signal) => (
+ signal.type === 'attribute' && signal.attribute === 'table-alignment'
+ ))))).toBe(true)
+ })
+
+ it('T09 combines an edited retained column with one adjacent column deletion', () => {
+ const model = compare(
+ markdownTable(['A', 'B old', 'C'], [['1', 'before', '3']]),
+ markdownTable(['A', 'B new'], [['1', 'after']]),
+ )
+ const columnEdits = model.edits.filter(({ kind }) => kind === 'table-column')
+ const cellEdits = model.edits.filter(({ kind }) => kind === 'content')
+
+ expect(columnEdits).toHaveLength(1)
+ expectColumnEdit(columnEdits[0]!, 'delete', 2, 2)
+ expect(cellEdits).toHaveLength(2)
+ expect(cellEdits.flatMap(({ descriptors }) => descriptors).every(({ context }) => (
+ context.before?.code === 'table-cell' && context.after?.code === 'table-cell'
+ ))).toBe(true)
+ })
+
+ it('T10 keeps a row insertion at row altitude beside a column deletion', () => {
+ const model = compare(
+ markdownTable(['A', 'B', 'C'], [['one', 'x', 'x'], ['two', 'x', 'x']]),
+ markdownTable(['A', 'B'], [['one', 'x'], ['inserted row', 'unique'], ['two', 'x']]),
+ )
+ const columnEdits = model.edits.filter(({ kind }) => kind === 'table-column')
+ const rowInsertions = model.edits.filter(({ primary }) => (
+ primary.operation === 'insert' && primary.context.after?.code === 'table-row'
+ ))
+
+ expect(columnEdits).toHaveLength(1)
+ expectColumnEdit(columnEdits[0]!, 'delete', 2, 3)
+ expect(rowInsertions).toHaveLength(1)
+ })
+
+ it('T10 keeps a row deletion at row altitude beside a column insertion', () => {
+ const model = compare(
+ markdownTable(['A', 'B'], [['one', 'x'], ['deleted row', 'unique'], ['two', 'x']]),
+ markdownTable(['A', 'B', 'C'], [['one', 'x', 'x'], ['two', 'x', 'x']]),
+ )
+ const columnEdits = model.edits.filter(({ kind }) => kind === 'table-column')
+ const rowDeletions = model.edits.filter(({ primary }) => (
+ primary.operation === 'delete' && primary.context.before?.code === 'table-row'
+ ))
+
+ expect(columnEdits).toHaveLength(1)
+ expectColumnEdit(columnEdits[0]!, 'insert', 2, 3)
+ expect(rowDeletions).toHaveLength(1)
+ })
+
+ it('T11 keeps a ragged typo precise at physical-cell altitude', () => {
+ const model = compare(
+ markdownTable(['A', 'B', 'C'], [['one', 'before']]),
+ markdownTable(['A', 'B', 'C'], [['one', 'after']]),
+ )
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({
+ kind: 'content',
+ primary: {
+ operation: 'replace',
+ context: { before: { code: 'table-cell' }, after: { code: 'table-cell' } },
+ },
+ })
+ })
+
+ it.each([
+ ['fills', 'insert', ['one'], ['one', 'two']],
+ ['removes', 'delete', ['one', 'two'], ['one']],
+ ] as const)('T12 %s a ragged absent-present slot as one local cell change', (_name, operation, beforeRow, afterRow) => {
+ const model = compare(
+ markdownTable(['A', 'B'], [beforeRow]),
+ markdownTable(['A', 'B'], [afterRow]),
+ )
+ const side: ComparisonSide = operation === 'delete' ? 'before' : 'after'
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({ kind: 'content', primary: { operation } })
+ expect(model.edits[0]!.primary.context[side]?.code).toBe('table-cell')
+ })
+
+ it('T13 groups only present physical cells from a deleted ragged column', () => {
+ const wider = markdownTable(['A', 'B', 'C'], [
+ ['x', 'x'],
+ ['x', 'x', 'distinct C'],
+ ])
+ const narrower = markdownTable(['A', 'B'], [
+ ['x', 'x'],
+ ['x', 'x'],
+ ])
+ const model = compare(wider, narrower)
+
+ expect(model.edits).toHaveLength(1)
+ expectColumnEdit(model.edits[0]!, 'delete', 2, 2)
+ })
+
+ it.each(['deletion', 'insertion'] as const)('T14 fails a ragged middle identity conflict transactionally on %s', (direction) => {
+ const wider = markdownTable(['A', 'B', 'C'], [
+ ['x', 'x', 'x'],
+ ['x', 'x'],
+ ])
+ const narrower = markdownTable(['A', 'C'], [
+ ['x', 'x'],
+ ['x'],
+ ])
+ const model = direction === 'deletion'
+ ? compare(wider, narrower)
+ : compare(narrower, wider)
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({
+ kind: 'content',
+ primary: {
+ operation: 'replace',
+ coarseReason: 'table-evidence-conflict',
+ context: { before: { code: 'table' }, after: { code: 'table' } },
+ },
+ })
+ expect(model.edits[0]!.descriptors).toHaveLength(1)
+ })
+
+ it.each(['deletion', 'insertion'] as const)('AUD-01 fails closed when a ragged width change creates cross-row exact identity on %s', (direction) => {
+ for (const width of [2, 3, 4]) {
+ const wider = markdownTable(
+ Array.from({ length: width + 1 }, () => 'N'),
+ [
+ Array.from({ length: width }, () => 'x'),
+ Array.from({ length: width + 1 }, () => 'x'),
+ ],
+ )
+ const narrower = markdownTable(
+ Array.from({ length: width }, () => 'N'),
+ [
+ Array.from({ length: width - 1 }, () => 'x'),
+ Array.from({ length: width }, () => 'x'),
+ ],
+ )
+ const model = direction === 'deletion'
+ ? compare(wider, narrower)
+ : compare(narrower, wider)
+ const rowOperations = model.edits.filter(({ primary }) => (
+ primary.context.before?.code === 'table-row' || primary.context.after?.code === 'table-row'
+ ))
+
+ expect(rowOperations).toHaveLength(0)
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({
+ kind: 'content',
+ primary: {
+ operation: 'replace',
+ coarseReason: 'table-evidence-conflict',
+ context: { before: { code: 'table' }, after: { code: 'table' } },
+ },
+ })
+ expect(model.edits[0]!.descriptors).toHaveLength(1)
+ }
+ })
+
+ it.each(['deletion', 'insertion'] as const)('AUD-01 reconciles the complete row basis when row count and width change on %s', (direction) => {
+ const wider = markdownTable(['N', 'N', 'N'], [
+ ['x', 'x'],
+ ['x', 'x', 'x'],
+ ])
+ const narrower = markdownTable(['N', 'N'], [
+ ['inserted', 'unique'],
+ ['x'],
+ ['x', 'x'],
+ ])
+ const model = direction === 'deletion'
+ ? compare(wider, narrower)
+ : compare(narrower, wider)
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({
+ kind: 'content',
+ primary: {
+ operation: 'replace',
+ coarseReason: 'table-evidence-conflict',
+ context: { before: { code: 'table' }, after: { code: 'table' } },
+ },
+ })
+ expect(model.edits[0]!.descriptors).toHaveLength(1)
+ })
+
+ it.each(['deletion', 'insertion'] as const)('AUD-01 keeps a genuine ragged row replacement beside a column %s', (direction) => {
+ const wider = markdownTable(['A', 'B', 'C'], [
+ ['retained', 'x'],
+ ['deleted', 'y', 'z'],
+ ])
+ const narrower = markdownTable(['A', 'B'], [
+ ['inserted', 'q'],
+ ['retained', 'x'],
+ ])
+ const model = direction === 'deletion'
+ ? compare(wider, narrower)
+ : compare(narrower, wider)
+ const columnEdits = model.edits.filter(({ kind }) => kind === 'table-column')
+ const rowOperations = model.edits.filter(({ primary }) => (
+ primary.context.before?.code === 'table-row' || primary.context.after?.code === 'table-row'
+ ))
+
+ expect(columnEdits).toHaveLength(1)
+ expectColumnEdit(columnEdits[0]!, direction === 'deletion' ? 'delete' : 'insert', 2, 1)
+ expect(rowOperations.map(({ primary }) => primary.operation).toSorted()).toEqual(['delete', 'insert'])
+ expect(model.edits.every(({ primary }) => primary.coarseReason === undefined)).toBe(true)
+ })
+
+ it.each([
+ ['deletes', 'delete', 3, 2],
+ ['inserts', 'insert', 3, 4],
+ ] as const)('T15 %s the outer repeated row after retaining the first exact copies', (_name, operation, beforeCount, afterCount) => {
+ const rows = (count: number) => Array.from({ length: count }, () => ['Same', 'x'])
+ const model = compare(
+ markdownTable(['H1', 'H2'], rows(beforeCount)),
+ markdownTable(['H1', 'H2'], rows(afterCount)),
+ )
+ const side: ComparisonSide = operation === 'delete' ? 'before' : 'after'
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({ kind: 'content', primary: { operation } })
+ expect(model.edits[0]!.primary.context[side]?.code).toBe('table-row')
+ expect(model.edits[0]!.primary.context[side]?.path.at(-1)).toBe(operation === 'delete' ? 3 : 4)
+ })
+
+ it.each([
+ ['span', { header: [{ text: 'changed', colspan: 2 }], rows: [] }],
+ ['row span', { header: [{ text: 'changed', rowspan: 2 }], rows: [[{ text: 'body' }]] }],
+ ['malformed empty row', { header: [{ text: 'changed' }], rows: [[]] }],
+ ['more than 512 rows', {
+ header: [{ text: 'changed' }],
+ rows: Array.from({ length: 512 }, (_value, index) => [{ text: `row ${index}` }]),
+ }],
+ ['more than 10000 physical cells', {
+ header: Array.from({ length: 100 }, (_value, index) => ({ text: index === 0 ? 'changed' : `head ${index}` })),
+ rows: Array.from({ length: 100 }, (_value, row) => (
+ Array.from({ length: 100 }, (_cell, column) => ({ text: `cell ${row}:${column}` }))
+ )),
+ }],
+ ] as const)('T16 emits one unsupported-table edit for %s geometry', (_name, invalid) => {
+ const valid = { header: [{ text: 'valid' }], rows: [] }
+ const model = compareTableSpecs(valid, invalid)
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({
+ kind: 'content',
+ primary: {
+ operation: 'replace',
+ coarseReason: 'unsupported-table',
+ context: { before: { code: 'table' }, after: { code: 'table' } },
+ },
+ })
+ expect(model.edits[0]!.descriptors).toHaveLength(1)
+ })
+
+ it.each([
+ ['a missing header', ['body']],
+ ['duplicate headers', ['header', 'header']],
+ ['a header after a body row', ['body', 'header']],
+ ['a misplaced caption', ['header', 'caption']],
+ ['duplicate captions', ['caption', 'caption', 'header']],
+ ['a body cell in the header', ['header-with-body-cell']],
+ ['a header cell in a body row', ['header', 'body-with-header-cell']],
+ ] as const)('T16 rejects %s transactionally', (_name, children) => {
+ const editor = createComparisonTestEditor('placeholder')
+ try {
+ const valid = tableDocument(editor.schema, { header: [{ text: 'valid' }], rows: [] })
+ const invalid = malformedTableDocument(editor.schema, children)
+ const model = createHierarchicalMarkdownComparisonModel(valid, invalid)
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]).toMatchObject({
+ kind: 'content',
+ primary: {
+ operation: 'replace',
+ coarseReason: 'unsupported-table',
+ context: { before: { code: 'table' }, after: { code: 'table' } },
+ },
+ })
+ expect(model.edits[0]!.descriptors).toHaveLength(1)
+ } finally {
+ editor.destroy()
+ }
+ })
+
+ it('T17 rejects a 10001-column table before attempting column alignment', () => {
+ const valid = { header: [{ text: 'valid' }], rows: [] }
+ const hugeWidth = {
+ header: Array.from({ length: 10_001 }, (_value, index) => ({ text: `column ${index}` })),
+ rows: [],
+ }
+ const model = compareTableSpecs(valid, hugeWidth)
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]!.primary.coarseReason).toBe('unsupported-table')
+ expect(model.edits[0]!.descriptors).toHaveLength(1)
+ })
+
+ it('F09 retains solved table work without partial edits when a later exact-evidence veto coarsens the table', () => {
+ const editor = createComparisonTestEditor('placeholder')
+ try {
+ const columnCount = 100
+ const bodyTextLength = Math.floor(DEFAULT_COMPARISON_TOKEN_LEDGER / (4 * columnCount ** 2)) - 6
+ const body = (suffix: string) => Array.from({ length: columnCount }, (_value, index) => ({
+ text: `${String.fromCodePoint(0x100 + index).repeat(bodyTextLength - 1)}${suffix}`,
+ }))
+ const beforeHeader = Array.from({ length: columnCount }, (_value, index) => ({ text: index === 0 ? 'q' : 'a' }))
+ const afterHeader = Array.from({ length: columnCount }, (_value, index) => ({ text: index === columnCount - 1 ? 'q' : 'b' }))
+ const headerRowProfileLength = 2 * columnCount
+ const bodyRowProfileLength = (bodyTextLength + 2) * columnCount
+ const rowCharge = 2 * (3 * headerRowProfileLength + bodyRowProfileLength)
+ const columnProfileLength = bodyTextLength + 6
+ const columnCharge = 2 * columnCount ** 2 * columnProfileLength
+ const remainingTokens = DEFAULT_COMPARISON_TOKEN_LEDGER - rowCharge - columnCharge
+ const laterProfileLength = Math.floor(remainingTokens / (2 * columnCount ** 2)) + 1
+ const laterTextLength = laterProfileLength - 3
+ const repeatedHeaders = (character: string) => Array.from(
+ { length: columnCount },
+ () => ({ text: character.repeat(laterTextLength) }),
+ )
+ const anchor = editor.schema.nodes.paragraph!.create(null, editor.schema.text('exact veto boundary anchor'))
+ const before = editor.schema.nodes.doc!.create(null, [
+ tableNode(editor.schema, { header: beforeHeader, rows: [body('x')] }),
+ anchor,
+ tableNode(editor.schema, { header: repeatedHeaders('c'), rows: [] }),
+ ])
+ const after = editor.schema.nodes.doc!.create(null, [
+ tableNode(editor.schema, { header: afterHeader, rows: [body('y')] }),
+ anchor,
+ tableNode(editor.schema, { header: repeatedHeaders('d'), rows: [] }),
+ ])
+ const model = createHierarchicalMarkdownComparisonModel(before, after)
+
+ expect(2 * columnCount ** 2 * laterProfileLength).toBeGreaterThan(remainingTokens)
+ expect(2 * columnCount ** 2 * laterProfileLength).toBeLessThan(DEFAULT_COMPARISON_TOKEN_LEDGER)
+ expect(model.edits.map(({ primary }) => primary.coarseReason)).toEqual([
+ 'table-evidence-conflict',
+ 'comparison-limit',
+ ])
+ expect(model.edits.every(({ descriptors }) => descriptors.length === 1)).toBe(true)
+ } finally {
+ editor.destroy()
+ }
+ })
+
+ it('T18 shares table token work across consecutive column plans', () => {
+ interface Column {
+ key: string
+ profile: readonly string[]
+ }
+ const before: Column[] = [
+ { key: 'before-a', profile: ['a', 'same-a'] },
+ { key: 'before-b', profile: ['b', 'same-b'] },
+ ]
+ const after: Column[] = [
+ { key: 'after-a', profile: ['a', 'same-a'] },
+ { key: 'after-b', profile: ['b', 'same-b'] },
+ ]
+ const work = { remainingCells: 8, remainingTokenComparisons: 20 }
+ const options = {
+ work,
+ fingerprint: ({ key }: Column) => key,
+ profile: ({ profile }: Column) => profile,
+ compatible: () => true,
+ }
+
+ const first = alignComparisonColumns(before, after, options)
+ expect(first.every((region) => !('coarseReason' in region && region.coarseReason === 'comparison-limit'))).toBe(true)
+ expect(work).toEqual({ remainingCells: 4, remainingTokenComparisons: 4 })
+
+ const second = alignComparisonColumns(before, after, options)
+ expect(second).toEqual([{
+ before: { from: 0, to: 2 },
+ after: { from: 0, to: 2 },
+ coarseReason: 'comparison-limit',
+ }])
+ expect(work).toEqual({ remainingCells: 4, remainingTokenComparisons: 4 })
+ })
+})
diff --git a/src/tests/markdown.spec.js b/src/tests/markdown.spec.js
index 2f5bb9e5011..f67768a5c50 100644
--- a/src/tests/markdown.spec.js
+++ b/src/tests/markdown.spec.js
@@ -175,6 +175,7 @@ describe('Markdown though editor', () => {
test('details', ({ markdownThroughEditor }) => {
expect(markdownThroughEditor('')
})
+ it('renders the native open state', () => {
+ const rendered = markdownit.render('')
+ })
it('renders with empty summary', () => {
const rendered = markdownit.render('
')
diff --git a/src/tests/nodes/DetailsViewAccessibility.spec.ts b/src/tests/nodes/DetailsViewAccessibility.spec.ts
new file mode 100644
index 00000000000..b1c9d51ab94
--- /dev/null
+++ b/src/tests/nodes/DetailsViewAccessibility.spec.ts
@@ -0,0 +1,49 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { mount } from '@vue/test-utils'
+import { describe, expect, it, vi } from 'vitest'
+import DetailsView from '../../nodes/DetailsView.vue'
+
+function mountDetails(attrs: { open: boolean, openDetails: boolean }, updateAttributes = vi.fn()) {
+ return mount(DetailsView, {
+ props: { node: { attrs }, updateAttributes },
+ global: {
+ stubs: {
+ NodeViewWrapper: { template: '['$props']
+
+const attachment = {
+ alt: 'Diagram',
+ davPath: '/diagram.png',
+ fullUrl: '/diagram.png',
+ isImage: true,
+ metadata: null,
+ mimetype: 'image/png',
+ name: 'diagram.png',
+ previewUrl: '/preview.png',
+ size: 100,
+}
+
+beforeEach(() => {
+ vi.stubGlobal('ResizeObserver', class {
+ observe() {}
+ disconnect() {}
+ })
+ vi.stubGlobal('IntersectionObserver', class {
+ observe() {}
+ disconnect() {}
+ })
+})
+
+afterEach(() => vi.unstubAllGlobals())
+
+async function mountImage(isImage: boolean) {
+ const editor = { isEditable: false, off: vi.fn(), on: vi.fn() }
+ const wrapper = mount(ImageView, {
+ props: {
+ editor,
+ node: { attrs: { alt: 'Diagram', src: 'diagram.png' } },
+ decorations: [],
+ selected: false,
+ extension: { options: { noLazyImages: false } },
+ getPos: () => 0,
+ updateAttributes: vi.fn(),
+ deleteNode: vi.fn(),
+ view: {},
+ innerDecorations: {},
+ HTMLAttributes: {},
+ } as unknown as ImageViewProps,
+ global: {
+ provide: {
+ [ATTACHMENT_RESOLVER as symbol]: shallowRef({ resolve: vi.fn().mockResolvedValue({ ...attachment, isImage }) }),
+ },
+ stubs: {
+ NodeViewWrapper: { template: '('.media-wrapper')
+
+ expect(action.element.tagName).toBe('BUTTON')
+ expect(action.attributes('type')).toBe('button')
+ expect(action.attributes('aria-label')).toBe(label)
+ expect(action.element.tabIndex).toBe(0)
+ })
+
+ it('AUD-18 routes image button activation through the real modal handler', async () => {
+ const wrapper = await mountImage(true)
+ const view = wrapper.vm as unknown as { embeddedImageList: Array }
+ vi.spyOn(wrapper.vm, 'updateEmbeddedImageList').mockImplementation(async () => {
+ view.embeddedImageList = [{ ...attachment, src: 'diagram.png' }]
+ })
+
+ await wrapper.find('.media-wrapper').trigger('click')
+
+ expect(wrapper.vm.imageIndex).toBe(0)
+ expect(wrapper.vm.showImageModal).toBe(true)
+ })
+
+ it('AUD-18 routes attachment button activation through the real Viewer action', async () => {
+ const open = vi.fn()
+ vi.stubGlobal('OCA', { Viewer: { file: null, mimetypes: ['image/png'], open } })
+ const wrapper = await mountImage(false)
+
+ await wrapper.find('.media-wrapper').trigger('click')
+
+ expect(open).toHaveBeenCalledOnce()
+ expect(open).toHaveBeenCalledWith({ path: attachment.davPath })
+ })
+})
diff --git a/src/tests/playwrightConfig.spec.ts b/src/tests/playwrightConfig.spec.ts
new file mode 100644
index 00000000000..3811aa2248e
--- /dev/null
+++ b/src/tests/playwrightConfig.spec.ts
@@ -0,0 +1,76 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+const originalComparisonBaseURL = process.env.TEXT_COMPARISON_BASE_URL
+const originalComparisonE2E = process.env.TEXT_COMPARISON_E2E
+const originalBaseURL = process.env.baseURL
+
+afterEach(() => {
+ setEnvironment('TEXT_COMPARISON_BASE_URL', originalComparisonBaseURL)
+ setEnvironment('TEXT_COMPARISON_E2E', originalComparisonE2E)
+ setEnvironment('baseURL', originalBaseURL)
+})
+
+function setEnvironment(name: string, value: string | undefined) {
+ if (value === undefined) {
+ delete process.env[name]
+ } else {
+ process.env[name] = value
+ }
+}
+
+async function loadConfig(comparisonBaseURL: string | undefined, baseURL: string | undefined, comparisonE2E?: string) {
+ setEnvironment('TEXT_COMPARISON_BASE_URL', comparisonBaseURL)
+ setEnvironment('TEXT_COMPARISON_E2E', comparisonE2E)
+ setEnvironment('baseURL', baseURL)
+ vi.resetModules()
+ return (await import('../../playwright.config.ts')).default
+}
+
+describe('Playwright comparison server selection', () => {
+ it.each([
+ { name: 'unset values', comparisonBaseURL: undefined, baseURL: undefined, expected: 'http://localhost:8089/index.php/', managed: true },
+ { name: 'empty values', comparisonBaseURL: '', baseURL: '', expected: 'http://localhost:8089/index.php/', managed: true },
+ { name: 'generic external URL', comparisonBaseURL: '', baseURL: 'https://generic.example/index.php/', expected: 'https://generic.example/index.php/', managed: false },
+ { name: 'dedicated external URL', comparisonBaseURL: 'https://text.example/index.php/', baseURL: '', expected: 'https://text.example/index.php/', managed: false },
+ { name: 'dedicated precedence', comparisonBaseURL: 'https://text.example/index.php/', baseURL: 'https://generic.example/index.php/', expected: 'https://text.example/index.php/', managed: false },
+ ])('uses the selected URL for $name', async ({ comparisonBaseURL, baseURL, expected, managed }) => {
+ const config = await loadConfig(comparisonBaseURL, baseURL)
+
+ expect(config.use?.baseURL).toBe(expected)
+ expect(config.webServer === undefined).toBe(!managed)
+ })
+
+ it('routes comparison and memory tests to their dedicated projects', async () => {
+ const config = await loadConfig(undefined, undefined, '1')
+ const projects = config.projects ?? []
+ const byName = new Map(projects.map((project) => [project.name, project]))
+ const comparisonNames = [
+ 'comparison-chromium',
+ 'comparison-webkit',
+ 'comparison-chromium-memory',
+ ]
+
+ expect(projects.map(({ name }) => name)).toEqual(['chromium', ...comparisonNames])
+ for (const name of comparisonNames) {
+ const match = byName.get(name)?.testMatch
+ expect(match).toBeInstanceOf(RegExp)
+ expect((match as RegExp).test('playwright/comparison/comparison.spec.ts')).toBe(true)
+ expect((match as RegExp).test('playwright/example.spec.ts')).toBe(false)
+ }
+ for (const name of comparisonNames.slice(0, 2)) {
+ expect(byName.get(name)?.grepInvert).toEqual(/@memory/)
+ expect(byName.get(name)?.grep).toBeUndefined()
+ }
+ expect(byName.get('comparison-chromium-memory')?.grep).toEqual(/@memory/)
+ expect(byName.get('comparison-chromium-memory')?.grepInvert).toBeUndefined()
+ const ordinaryIgnore = byName.get('chromium')?.testIgnore
+ expect(ordinaryIgnore).toBeInstanceOf(RegExp)
+ expect((ordinaryIgnore as RegExp).test('playwright/comparison/comparison.spec.ts')).toBe(true)
+ expect((ordinaryIgnore as RegExp).test('playwright/example.spec.ts')).toBe(false)
+ })
+})
diff --git a/src/tests/services/AttachmentResolver.spec.js b/src/tests/services/AttachmentResolver.spec.js
index 507be93df32..5280056917c 100644
--- a/src/tests/services/AttachmentResolver.spec.js
+++ b/src/tests/services/AttachmentResolver.spec.js
@@ -36,11 +36,9 @@ function initAttachmentResolver(args) {
previewUrl: `http://nextcloud.local/apps/text/mediaPreview?documentId=${fileId}&sessionId=${sessionId}&sessionToken=${sessionToken}&mediaFileName=${a2name}"`,
},
]
- const axiosSpy = vi
- .spyOn(axios, 'post')
+ vi.spyOn(axios, 'post')
.mockReturnValue({ data: attachmentList })
const resolver = new AttachmentResolver(args)
- expect(axiosSpy).toHaveBeenCalled()
return resolver
}
@@ -55,6 +53,15 @@ describe('Image resolver', () => {
}
const currentDirectory = '/parentDir'
+ it('does not request attachment metadata for a direct URL', async () => {
+ const axiosSpy = vi.spyOn(axios, 'post').mockResolvedValue({ data: [] })
+ const resolver = new AttachmentResolver({ fileId })
+
+ await resolver.resolve('https://example.org/pic.jpg')
+
+ expect(axiosSpy).not.toHaveBeenCalled()
+ })
+
it('is a class with one constructor argument', () => {
const resolver = initAttachmentResolver({ fileId })
expect(resolver).toBeInstanceOf(AttachmentResolver)
diff --git a/vite.config.ts b/vite.config.ts
index 1830d335ca4..5d930dd6f08 100644
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -50,6 +50,15 @@ const config = createAppConfig(
},
config: {
base: process.env.BASE,
+ worker: {
+ rollupOptions: {
+ output: {
+ assetFileNames: 'js/[name]-[hash][extname]',
+ chunkFileNames: 'js/[name]-[hash].worker.chunk.mjs',
+ entryFileNames: 'js/[name]-[hash].worker.mjs',
+ },
+ },
+ },
resolve: {
dedupe: ['vue'],
},
-
+
+
@@ -593,7 +599,11 @@ export default {
.media-wrapper {
display: flex;
- // Overwrite some global rules for a elments
+ padding: 0;
+ border: 0;
+ background: transparent;
+ font: inherit;
+ cursor: pointer;
text-decoration: none;
color: var(--color-main-text);
diff --git a/src/services/AttachmentResolver.js b/src/services/AttachmentResolver.js
index 6d1f2fa0a98..bc915c98156 100644
--- a/src/services/AttachmentResolver.js
+++ b/src/services/AttachmentResolver.js
@@ -22,7 +22,6 @@ export default class AttachmentResolver {
this.#shareToken = shareToken
this.#currentDirectory = currentDirectory
this.#documentId = fileId ?? session.documentId
- this.#initAttachmentListPromise = this.#updateAttachmentList()
}
async #updateAttachmentList() {
@@ -52,7 +51,7 @@ export default class AttachmentResolver {
if (src.match(directoryRegexp)) {
const imageFileName = decodeURIComponent(src.replace(directoryRegexp, '').split('?')[0])
- // Wait until attachment list got fetched (initialized by constructor)
+ this.#initAttachmentListPromise ??= this.#updateAttachmentList()
await this.#initAttachmentListPromise
attachment = this.#findAttachment(imageFileName)
diff --git a/src/tests/comparison/ComparisonChangeList.spec.ts b/src/tests/comparison/ComparisonChangeList.spec.ts
new file mode 100644
index 00000000000..246e4914c97
--- /dev/null
+++ b/src/tests/comparison/ComparisonChangeList.spec.ts
@@ -0,0 +1,173 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { ComparisonDescriptor, ComparisonEdit } from '../../comparison/markdownComparisonTypes.ts'
+
+import * as l10n from '@nextcloud/l10n'
+import { mount } from '@vue/test-utils'
+import { schema } from 'prosemirror-schema-basic'
+import { describe, expect, it, vi } from 'vitest'
+import ComparisonChangeList from '../../components/ComparisonChangeList.vue'
+
+function descriptor(id: string, text: string, facets: ComparisonDescriptor['facets'] = ['text']): ComparisonDescriptor {
+ return {
+ id,
+ operation: 'replace',
+ detail: 'inline',
+ facets,
+ before: { from: 0, to: 1 },
+ after: { from: 0, to: 1 },
+ context: { before: null, after: null },
+ preview: { before: { kind: 'text', text }, after: { kind: 'text', text } },
+ signals: [],
+ }
+}
+
+const document = schema.node('doc', null, [schema.node('paragraph', null, schema.text('Body'))])
+
+describe('ComparisonChangeList', () => {
+ it('AUD-14 renders only the bounded page containing a high-cardinality current edit', () => {
+ const edits = Array.from({ length: 10_000 }, (_value, index): ComparisonEdit => {
+ const primary = descriptor(`member-${index}`, `preview-${index}`)
+ return { id: `edit-${index}`, kind: 'content', primary, descriptors: [primary] }
+ })
+ const wrapper = mount(ComparisonChangeList, {
+ props: { edits, currentId: 'edit-9999', beforeDocument: document, afterDocument: document },
+ })
+ const rows = wrapper.findAll('[data-comparison-select]')
+
+ expect(rows).toHaveLength(80)
+ expect(rows[0]!.attributes('data-comparison-select')).toBe('edit-9920')
+ expect(rows.at(-1)!.attributes('data-comparison-select')).toBe('edit-9999')
+ expect(wrapper.find('[data-comparison-select="edit-9999"]').attributes('aria-current')).toBe('true')
+ })
+
+ it('preserves the current change label when paging away from its row', async () => {
+ const edits = Array.from({ length: 160 }, (_value, index): ComparisonEdit => {
+ const primary = descriptor(`member-${index}`, `preview-${index}`)
+ return { id: `edit-${index}`, kind: 'content', primary, descriptors: [primary] }
+ })
+ const wrapper = mount(ComparisonChangeList, {
+ props: { edits, currentId: 'edit-159', beforeDocument: document, afterDocument: document },
+ })
+ const initialLabel = wrapper.emitted('currentLabel')!.at(-1)![0]
+
+ await wrapper.findAll('.text-comparison__change-pages button')[0]!.trigger('click')
+
+ expect(wrapper.findAll('[data-comparison-select]')[0]!.attributes('data-comparison-select')).toBe('edit-0')
+ expect(wrapper.find('[aria-current="true"]').exists()).toBe(false)
+ expect(wrapper.emitted('currentLabel')!.at(-1)![0]).toBe(initialLabel)
+ expect(initialLabel).not.toBe('')
+ })
+
+ it('AUD-14 unmounts records in collapsed sections', async () => {
+ const primary = descriptor('member', 'preview')
+ const edit: ComparisonEdit = { id: 'edit', kind: 'content', primary, descriptors: [primary] }
+ const wrapper = mount(ComparisonChangeList, {
+ props: { edits: [edit], beforeDocument: document, afterDocument: document },
+ })
+
+ await wrapper.get('.text-comparison__section-toggle').trigger('click')
+
+ expect(wrapper.findAll('[data-comparison-select]')).toHaveLength(0)
+ })
+
+ it('translates only the selected lookup entry for each record', () => {
+ const translate = vi.spyOn(l10n, 't')
+ const primary: ComparisonDescriptor = {
+ ...descriptor('member', 'preview', ['attribute']),
+ signals: [{ type: 'attribute', attribute: 'link', change: 'changed' }],
+ }
+ const edit: ComparisonEdit = { id: 'edit', kind: 'content', primary, descriptors: [primary] }
+
+ mount(ComparisonChangeList, {
+ props: { edits: [edit], beforeDocument: document, afterDocument: document },
+ })
+
+ const messages = translate.mock.calls.map(([, message]) => message)
+ expect(messages).toContain('Link changed')
+ expect(messages).not.toContain('Heading level changed')
+ translate.mockRestore()
+ })
+
+ it('V01 renders one row per first-class edit using explicit primary and all member descriptors', async () => {
+ const first = descriptor('member-first', 'wrong', ['formatting'])
+ const primary = descriptor('member-primary', 'primary')
+ const edit: ComparisonEdit = { id: 'edit-row', kind: 'content', primary, descriptors: [first, primary] }
+ const wrapper = mount(ComparisonChangeList, {
+ props: { edits: [edit], currentId: 'edit-row', beforeDocument: document, afterDocument: document },
+ })
+ const rows = wrapper.findAll('[data-comparison-select]')
+ expect(rows).toHaveLength(1)
+ expect(rows[0]!.attributes('data-comparison-select')).toBe('edit-row')
+ expect(rows[0]!.find('.text-comparison__change-item-content').exists()).toBe(true)
+ expect(rows[0]!.text()).toContain('primary')
+ expect(rows[0]!.text()).toContain('2 edits')
+ await rows[0]!.trigger('click')
+ expect(wrapper.emitted('select')).toEqual([['edit-row']])
+ })
+
+ it('renders explicit before and after previews for a replacement', () => {
+ const primary: ComparisonDescriptor = {
+ ...descriptor('member', 'unused'),
+ preview: {
+ before: { kind: 'text', text: 'before text' },
+ after: { kind: 'text', text: 'after text' },
+ },
+ }
+ const edit: ComparisonEdit = { id: 'edit', kind: 'content', primary, descriptors: [primary] }
+ const wrapper = mount(ComparisonChangeList, {
+ props: { edits: [edit], beforeDocument: document, afterDocument: document },
+ })
+
+ expect(wrapper.get('del.text-comparison__preview-before').text()).toBe('before text')
+ expect(wrapper.get('ins.text-comparison__preview-after').text()).toBe('after text')
+ })
+
+ it('labels a coarse composite change by its structural scope instead of an incidental task attribute', () => {
+ const primary: ComparisonDescriptor = {
+ ...descriptor('member', 'nested content', ['text', 'attribute', 'structure']),
+ coarseReason: 'ambiguous-attribution',
+ signals: [
+ { type: 'attribute', attribute: 'task-state', change: 'changed' },
+ { type: 'node' },
+ ],
+ }
+ const edit: ComparisonEdit = { id: 'edit', kind: 'content', primary, descriptors: [primary] }
+ const wrapper = mount(ComparisonChangeList, {
+ props: { edits: [edit], beforeDocument: document, afterDocument: document },
+ })
+
+ expect(wrapper.get('[data-comparison-select]').text()).toContain('Structure changed')
+ expect(wrapper.get('[data-comparison-select]').text()).not.toContain('Task state changed')
+ })
+
+ it.each([
+ ['insert', 'inline', 'Paragraph changed', 'Paragraph added'],
+ ['delete', 'inline', 'Paragraph changed', 'Paragraph removed'],
+ ['insert', 'block', 'Paragraph added', 'Paragraph changed'],
+ ['delete', 'block', 'Paragraph removed', 'Paragraph changed'],
+ ] as const)('labels a %s %s operation at the correct altitude', (operation, detail, expected, rejected) => {
+ const primary: ComparisonDescriptor = {
+ ...descriptor('member', 's'),
+ operation,
+ detail,
+ context: {
+ before: { code: 'paragraph', path: [], from: 0, to: 1 },
+ after: { code: 'paragraph', path: [], from: 0, to: 1 },
+ },
+ preview: operation === 'insert'
+ ? { before: null, after: { kind: 'text', text: 's' } }
+ : { before: { kind: 'text', text: 's' }, after: null },
+ }
+ const edit: ComparisonEdit = { id: 'edit', kind: 'content', primary, descriptors: [primary] }
+ const wrapper = mount(ComparisonChangeList, {
+ props: { edits: [edit], beforeDocument: document, afterDocument: document },
+ })
+
+ expect(wrapper.get('[data-comparison-select]').text()).toContain(expected)
+ expect(wrapper.get('[data-comparison-select]').text()).not.toContain(rejected)
+ })
+})
diff --git a/src/tests/comparison/MarkdownSourceComponent.spec.ts b/src/tests/comparison/MarkdownSourceComponent.spec.ts
new file mode 100644
index 00000000000..f095354e1e1
--- /dev/null
+++ b/src/tests/comparison/MarkdownSourceComponent.spec.ts
@@ -0,0 +1,187 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { mount } from '@vue/test-utils'
+import { describe, expect, it, vi } from 'vitest'
+import MarkdownSourceComparison from '../../components/MarkdownSourceComparison.vue'
+import { SOURCE_DIFF_LIMITS } from '../../comparison/markdownSourceComparison.ts'
+import {
+ COMPLETE_SOURCE_DISPLAY_LIMITS,
+ displayBoundedMarkdownSource,
+ displayMarkdownSource,
+} from '../../comparison/markdownSourceDisplay.ts'
+
+describe('Markdown source component', () => {
+ const multilineSource = (length: number) => {
+ const line = `${'x'.repeat(COMPLETE_SOURCE_DISPLAY_LIMITS.maximumVisibleCharactersPerLine - 1)}\n`
+ return line.repeat(Math.floor(length / line.length)) + 'x'.repeat(length % line.length)
+ }
+
+ it.each([
+ COMPLETE_SOURCE_DISPLAY_LIMITS.maximumVisibleCharactersPerSide - 1,
+ COMPLETE_SOURCE_DISPLAY_LIMITS.maximumVisibleCharactersPerSide,
+ ])('AUD-08 preserves complete source at the %i-character display boundary', (length) => {
+ const source = multilineSource(length)
+ expect(displayBoundedMarkdownSource(source)).toEqual({ text: source, truncated: false })
+ })
+
+ it('keeps supplementary characters well formed at the input boundary', () => {
+ const limit = COMPLETE_SOURCE_DISPLAY_LIMITS.maximumInputCharactersPerSide
+ const exact = `${multilineSource(limit - 2)}😀`
+ const crossingPrefix = multilineSource(limit - 1)
+ const crossing = `${crossingPrefix}😀`
+
+ expect(displayBoundedMarkdownSource(exact)).toEqual({ text: exact, truncated: false })
+ const result = displayBoundedMarkdownSource(crossing)
+ expect(result.text).toBe(crossingPrefix)
+ expect(result.text.length).toBeLessThanOrEqual(COMPLETE_SOURCE_DISPLAY_LIMITS.maximumVisibleCharactersPerSide)
+ expect(result.text.isWellFormed()).toBe(true)
+ expect(result.truncated).toBe(true)
+ })
+
+ it('keeps supplementary characters and visible controls intact at the output boundary', () => {
+ expect(displayMarkdownSource('abc😀', 5)).toBe('abc😀')
+ expect(displayMarkdownSource('abc😀', 4)).toBe('abc')
+ expect(displayMarkdownSource('\tremaining', 5)).toBe('⟦TAB⟧')
+ })
+
+ it.each([
+ ['high', '\uD83D', '⟦U+D83D⟧'],
+ ['low', '\uDE00', '⟦U+DE00⟧'],
+ ])('renders a lone %s surrogate as an exact reversible token', (_name, source, expected) => {
+ const result = displayBoundedMarkdownSource(source)
+
+ expect(result).toEqual({ text: expected, truncated: false })
+ expect(result.text).not.toContain('\uFFFD')
+ expect(result.text.isWellFormed()).toBe(true)
+ })
+
+ it('reports expansion truncation instead of silently omitting a supplementary character', () => {
+ const result = displayBoundedMarkdownSource(`${'\t'.repeat(200_000)}😀`)
+
+ expect(result.truncated).toBe(true)
+ expect(result.text).toHaveLength(COMPLETE_SOURCE_DISPLAY_LIMITS.maximumVisibleCharactersPerLine)
+ expect(result.text).not.toContain('\uFFFD')
+ expect(result.text.isWellFormed()).toBe(true)
+ expect(result.text.length).toBeLessThanOrEqual(COMPLETE_SOURCE_DISPLAY_LIMITS.maximumVisibleCharactersPerLine)
+ })
+
+ it('shows complete fallback immediately, then enhanced literal hunks', async () => {
+ const wrapper = mount(MarkdownSourceComparison, {
+ props: { beforeContent: 'old\t \n', afterContent: 'new\u200B\n', layoutMode: 'paired' },
+ })
+ expect(wrapper.find('[data-comparison-source-fallback]').exists()).toBe(true)
+ await vi.waitFor(() => expect(wrapper.find('[data-source-hunk]').exists()).toBe(true))
+ expect(wrapper.text()).toContain('old')
+ expect(wrapper.text()).toContain('new⟦ZWSP⟧')
+ })
+
+ it('AUD-05 exposes side, operation, whitespace, EOL, and missing-newline semantics', async () => {
+ const wrapper = mount(MarkdownSourceComparison, {
+ props: {
+ beforeContent: `old${String.fromCharCode(9)}\r\ntrail `,
+ afterContent: 'new\ntrail\n',
+ layoutMode: 'paired',
+ },
+ })
+ await vi.waitFor(() => expect(wrapper.find('[data-source-hunk]').exists()).toBe(true))
+
+ expect(wrapper.find('[data-source-side="before"]').text()).toBe('Before')
+ expect(wrapper.find('[data-source-side="after"]').text()).toBe('After')
+ expect(wrapper.find('[data-source-operation="removed"]').attributes('aria-label')).toContain('Removed line')
+ expect(wrapper.find('[data-source-operation="added"]').attributes('aria-label')).toContain('Added line')
+ expect(wrapper.find('[data-source-operation="removed"] [data-source-cue]').text()).toBe('−')
+ expect(wrapper.find('[data-source-operation="added"] [data-source-cue]').text()).toBe('+')
+ for (const token of ['TAB', 'CRLF', 'LF', '2 TRAILING SPACES', 'No newline at end of file']) {
+ expect(wrapper.text()).toContain(token)
+ }
+ })
+
+ it('omits per-line badges when paired line endings match', async () => {
+ const wrapper = mount(MarkdownSourceComparison, {
+ props: {
+ beforeContent: 'old\nunchanged\n',
+ afterContent: 'new\nunchanged\n',
+ layoutMode: 'paired',
+ },
+ })
+ await vi.waitFor(() => expect(wrapper.find('[data-source-hunk]').exists()).toBe(true))
+
+ expect(wrapper.findAll('[data-source-eol]')).toHaveLength(0)
+ })
+
+ it('AUD-13 renders the audited bidi and control set as visible inert source tokens', async () => {
+ const controls = '\u061C\u00AD\u200E\u200F\u0085\u2028\u2029'
+ const wrapper = mount(MarkdownSourceComparison, {
+ props: { beforeContent: controls, afterContent: '', layoutMode: 'paired' },
+ })
+ await vi.waitFor(() => expect(wrapper.find('[data-source-hunk]').exists()).toBe(true))
+
+ for (const token of ['ALM', 'SHY', 'LRM', 'RLM', 'NEL', 'LS', 'PS']) {
+ expect(wrapper.text()).toContain(token)
+ }
+ for (const control of controls) {
+ expect(wrapper.text()).not.toContain(control)
+ }
+ })
+
+ it('AUD-08 expands a large unchanged gap incrementally with observable source ranges', async () => {
+ const prefix = Array.from({ length: 3_000 }, (_value, index) => `prefix-${index}`)
+ const suffix = Array.from({ length: 3_000 }, (_value, index) => `suffix-${index}`)
+ const beforeContent = [...prefix, 'old literal', ...suffix].join('\n')
+ const afterContent = [...prefix, 'new literal', ...suffix].join('\n')
+ const wrapper = mount(MarkdownSourceComparison, {
+ props: { beforeContent, afterContent, layoutMode: 'paired' },
+ })
+ await vi.waitFor(() => expect(wrapper.findAll('.text-source-comparison__gap button')).toHaveLength(2))
+
+ await wrapper.findAll('[data-source-gap-toggle]')[0]!.trigger('click')
+
+ expect(wrapper.findAll('.text-source-comparison__row')).toHaveLength(SOURCE_DIFF_LIMITS.maximumGapPageRows + 7)
+ expect(wrapper.text()).toContain('prefix-0')
+ expect(wrapper.text()).toContain(`prefix-${SOURCE_DIFF_LIMITS.maximumGapPageRows - 1}`)
+ expect(wrapper.text()).not.toContain(`prefix-${SOURCE_DIFF_LIMITS.maximumGapPageRows}`)
+
+ await wrapper.find('[data-source-gap-more]').trigger('click')
+
+ expect(wrapper.findAll('.text-source-comparison__row')).toHaveLength(SOURCE_DIFF_LIMITS.maximumGapPageRows * 2 + 7)
+ expect(wrapper.text()).toContain(`prefix-${SOURCE_DIFF_LIMITS.maximumGapPageRows}`)
+ })
+
+ it('AUD-08 never expands gaps beyond the shared displayed-row ceiling', async () => {
+ const prefix = Array.from({ length: 3_000 }, (_value, index) => `prefix-${index}`)
+ const suffix = Array.from({ length: 3_000 }, (_value, index) => `suffix-${index}`)
+ const beforeContent = [...prefix, 'old literal', ...suffix].join('\n')
+ const afterContent = [...prefix, 'new literal', ...suffix].join('\n')
+ const wrapper = mount(MarkdownSourceComparison, {
+ props: { beforeContent, afterContent, layoutMode: 'paired' },
+ })
+ await vi.waitFor(() => expect(wrapper.findAll('[data-source-gap-toggle]')).toHaveLength(2))
+
+ for (const toggle of wrapper.findAll('[data-source-gap-toggle]')) {
+ await toggle.trigger('click')
+ while (wrapper.find('[data-source-gap-more]').exists()) {
+ await wrapper.find('[data-source-gap-more]').trigger('click')
+ }
+ }
+
+ expect(wrapper.findAll('.text-source-comparison__row')).toHaveLength(SOURCE_DIFF_LIMITS.maximumDisplayedRows)
+ expect(wrapper.text()).toContain('prefix-0')
+ expect(wrapper.text()).toContain('suffix-3')
+ expect(wrapper.text()).not.toContain('suffix-2999')
+ expect(wrapper.find('[data-source-gap-limited]').exists()).toBe(true)
+ }, 15_000)
+
+ it('V11 preserves bounded complete fallback when source enhancement is limited', async () => {
+ const beforeContent = 'x'.repeat(SOURCE_DIFF_LIMITS.maximumCharacters + 1)
+ const wrapper = mount(MarkdownSourceComparison, {
+ props: { beforeContent, afterContent: 'after', layoutMode: 'single' },
+ })
+ await vi.waitFor(() => expect(wrapper.find('[data-source-limited]').exists()).toBe(true))
+ expect(wrapper.find('[data-comparison-source-fallback]').exists()).toBe(true)
+ expect(wrapper.find('pre code').text()).toHaveLength(COMPLETE_SOURCE_DISPLAY_LIMITS.maximumVisibleCharactersPerLine)
+ expect(wrapper.findAll('[role="status"]').map((status) => status.text()).join(' ')).toContain('truncated')
+ })
+})
diff --git a/src/tests/comparison/MarkdownSourceFallback.spec.ts b/src/tests/comparison/MarkdownSourceFallback.spec.ts
new file mode 100644
index 00000000000..0791c0d5efc
--- /dev/null
+++ b/src/tests/comparison/MarkdownSourceFallback.spec.ts
@@ -0,0 +1,30 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import { mount } from '@vue/test-utils'
+import { describe, expect, it, vi } from 'vitest'
+import MarkdownSourceFallback from '../../components/MarkdownSourceFallback.vue'
+
+vi.mock('../../comparison/markdownSourceComparison.ts', () => {
+ throw new Error('enhanced Source is unavailable')
+})
+
+describe('complete Markdown source fallback', () => {
+ it('always renders both complete snapshots as inert literal text with visible controls', () => {
+ const wrapper = mount(MarkdownSourceFallback, {
+ props: {
+ beforeContent: '\nzero\u200Bwidth',
+ afterContent: '',
+ '
',
+ '',
+ ].join('\n')
+ const after = [
+ '# Operational notes',
+ '',
+ '> Approved maintenance window starts at 21:00.',
+ '',
+ '::: warn',
+ 'The canary is limited to two regions.',
+ ':::',
+ '',
+ 'Draft runbook
', + '', + 'Rollback after two failed health checks.', + '', + '',
+ '
',
+ '',
+ ].join('\n')
+ const { model } = compare(before, after)
+ const attributes = model.edits.flatMap(({ descriptors }) => descriptors)
+ .flatMap(({ signals }) => signals)
+ .filter((signal) => signal.type === 'attribute')
+ .map(({ attribute }) => attribute)
+ const primaryAttributes = model.edits
+ .flatMap(({ primary }) => primary.signals)
+ .filter((signal) => signal.type === 'attribute')
+ .map(({ attribute }) => attribute)
+
+ expect(model.edits.length).toBeGreaterThan(3)
+ expect(model.edits.every(({ primary }) => primary.coarseReason === undefined)).toBe(true)
+ expect(attributes).toContain('callout-type')
+ expect(attributes).toContain('details-state')
+ expect(primaryAttributes.filter((attribute) => attribute === 'callout-type')).toHaveLength(1)
+ expect(primaryAttributes.filter((attribute) => attribute === 'details-state')).toHaveLength(1)
+ })
+
+ it('does not label code content edits as language changes', () => {
+ const { model } = compare(
+ '```javascript\nconst stage = "draft"\n```\n',
+ '```typescript\nconst stage = "ready"\n```\n',
+ )
+ const languageEdits = model.edits.filter(({ primary }) => primary.signals.some((signal) => (
+ signal.type === 'attribute' && signal.attribute === 'code-language'
+ )))
+
+ expect(languageEdits).toHaveLength(1)
+ expect(model.edits.some(({ primary }) => (
+ primary.preview.before?.kind === 'text'
+ && primary.preview.before.text === 'draft'
+ && primary.signals.every((signal) => signal.type !== 'attribute' || signal.attribute !== 'code-language')
+ ))).toBe(true)
+ })
+
+ it('expands front-matter previews to complete changed lines', () => {
+ const { model } = compare([
+ '---',
+ 'release: atlas-2.4',
+ 'status: draft',
+ 'owner: Maya Chen',
+ 'tags: [payments, canary]',
+ 'legacy: true',
+ '---',
+ '',
+ '# Release record',
+ ].join('\n'), [
+ '---',
+ 'release: atlas-2.4.1',
+ 'status: approved',
+ 'owner: Noor Rahman',
+ 'tags: [payments, canary, customer-visible]',
+ 'approved-at: 2026-08-30T21:00:00+07:00',
+ '---',
+ '',
+ '# Release record',
+ ].join('\n'))
+ const previews = model.edits
+ .filter(({ primary }) => primary.context.before?.code === 'front-matter')
+ .map(({ primary }) => [primary.preview.before, primary.preview.after])
+ .flat()
+ .map((preview) => preview?.kind === 'text' ? preview.text : '')
+
+ expect(previews).toHaveLength(4)
+ expect(previews[0]).toMatch(/^release: atlas-2\.4\b/)
+ expect(previews[1]).toMatch(/^release: atlas-2\.4\.1\b/)
+ expect(previews[2]).toMatch(/^tags: \[payments, canary\]/)
+ expect(previews[3]).toMatch(/^tags: \[payments, canary, customer-visible\]/)
+ })
+
+ it('moves exact repeated section content with its unique heading anchor', () => {
+ const repeated = 'Health check passed.\n\nDeploy the stable build.'
+ const before = [
+ '# Repeated deployment notes',
+ `## Region A\n\n${repeated}`,
+ `## Region B\n\n${repeated}`,
+ `## Retired region\n\n${repeated}`,
+ `## Region C\n\n${repeated}`,
+ ].join('\n\n')
+ const after = [
+ '# Repeated deployment notes',
+ `## Region C\n\n${repeated}`,
+ `## Region A\n\n${repeated}`,
+ '## New region\n\nHealth check passed.\n\nDeploy the canary build.',
+ `## Region B\n\n${repeated}`,
+ ].join('\n\n')
+ const { before: beforeDoc, after: afterDoc, model } = compare(before, after)
+ const moved = model.edits.find(({ primary }) => primary.operation === 'move')!
+ const repeatedCopies = model.edits.filter(({ primary }) => primary.operation !== 'move')
+ .map((edit) => ({
+ operation: edit.primary.operation,
+ before: beforeDoc.textBetween(edit.primary.before.from, edit.primary.before.to, '\n'),
+ after: afterDoc.textBetween(edit.primary.after.from, edit.primary.after.to, '\n'),
+ }))
+
+ expect(model.edits).toHaveLength(7)
+ expect(beforeDoc.textBetween(moved.primary.before.from, moved.primary.before.to, '\n'))
+ .toBe('Region C\nHealth check passed.\nDeploy the stable build.')
+ expect(afterDoc.textBetween(moved.primary.after.from, moved.primary.after.to, '\n'))
+ .toBe('Region C\nHealth check passed.\nDeploy the stable build.')
+ expect(repeatedCopies.filter(({ before }) => before === 'Health check passed.')).toHaveLength(1)
+ expect(repeatedCopies.filter(({ after }) => after === 'Health check passed.')).toHaveLength(1)
+ })
+
+ it('F08 keeps a large inline envelope as one rendered block change', () => {
+ const shared = 'z'.repeat(MAX_INLINE_ENVELOPE_SIZE)
+ const { before, after, model } = compare(`start ${shared}\n`, `${shared} finish\n`)
+
+ expect(model.edits).toHaveLength(1)
+ expect(model.edits[0]!.primary).toMatchObject({
+ detail: 'block',
+ before: { from: 0, to: meaningfulSize(before) },
+ after: { from: 0, to: meaningfulSize(after) },
+ })
+ })
+
+ it('accepts 10000 descriptors and rejects 10001 at the production default', () => {
+ const editor = createComparisonTestEditor('placeholder')
+ try {
+ const document = (count: number, side: 'before' | 'after') => {
+ const nodes = Array.from({ length: count }, (_value, index) => [
+ editor.schema.nodes.paragraph!.create(null, editor.schema.text(`${side} ${index}`)),
+ editor.schema.nodes.heading!.create({ level: 2 }, editor.schema.text(`Exact anchor ${index}`)),
+ ]).flat()
+ return editor.schema.nodes.doc!.create(null, nodes)
+ }
+ const before = document(MAX_RENDERED_COMPARISON_DESCRIPTORS + 1, 'before')
+ const atLimit = createHierarchicalMarkdownComparisonModel(
+ editor.schema.nodes.doc!.create(null, before.content.content.slice(0, -2)),
+ document(MAX_RENDERED_COMPARISON_DESCRIPTORS, 'after'),
+ )
+
+ expect(MAX_RENDERED_COMPARISON_DESCRIPTORS).toBe(10_000)
+ expect(atLimit.edits).toHaveLength(MAX_RENDERED_COMPARISON_DESCRIPTORS)
+ expect(() => createHierarchicalMarkdownComparisonModel(
+ before,
+ document(MAX_RENDERED_COMPARISON_DESCRIPTORS + 1, 'after'),
+ )).toThrow(ComparisonModelLimitError)
+ } finally {
+ editor.destroy()
+ }
+ })
+
+ it('freezes the model and keeps the primary inside its own descriptors', () => {
+ const { model } = compare('one\n\ntwo\n', 'one edited\n\ntwo edited\n')
+
+ expect(Object.isFrozen(model)).toBe(true)
+ expect(Object.isFrozen(model.edits)).toBe(true)
+ expect(model.edits.every((edit) => edit.descriptors.includes(edit.primary))).toBe(true)
+ expect(new Set(model.edits.map(({ id }) => id))).toHaveLength(model.edits.length)
+ expect(new Set(model.edits.flatMap(({ descriptors }) => descriptors.map(({ id }) => id))))
+ .toHaveLength(model.edits.flatMap(({ descriptors }) => descriptors).length)
+ })
+})
diff --git a/src/tests/comparison/markdownSourceComparison.spec.ts b/src/tests/comparison/markdownSourceComparison.spec.ts
new file mode 100644
index 00000000000..3af9ec62b96
--- /dev/null
+++ b/src/tests/comparison/markdownSourceComparison.spec.ts
@@ -0,0 +1,214 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { SourceDiffHunk, SourceDiffLine } from '../../comparison/markdownSourceComparison.ts'
+
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { createMarkdownSourceComparison, materializeSourceDiffGap, SOURCE_DIFF_LIMITS } from '../../comparison/markdownSourceComparison.ts'
+import { compareMarkdownSourceLines } from '../../comparison/markdownSourceComparisonProtocol.ts'
+
+afterEach(() => vi.unstubAllGlobals())
+
+describe('literal Markdown source comparison', () => {
+ const lines = (hunks: readonly SourceDiffHunk[], side: 'before' | 'after') => hunks
+ .flatMap(({ rows }) => rows.flatMap((row) => row[side] ? [row[side]] : []))
+
+ it('V10 normalizes EOL only for matching while retaining literal line facts', async () => {
+ const model = await createMarkdownSourceComparison('tab\tvalue \r\nzero\u200Bwidth\nlast', 'tab value \nzero width\nlast\n')
+ expect(model.status).toBe('ready')
+ if (model.status !== 'ready') {
+ return
+ }
+ const before = lines(model.hunks, 'before')
+ const after = lines(model.hunks, 'after')
+ expect(before[0]).toMatchObject({ text: 'tab\tvalue ', eol: 'crlf' })
+ expect(before.some(({ text }) => text.includes('\u200b'))).toBe(true)
+ expect(before.at(-1)?.eol).toBe('none')
+ expect(after.at(-1)?.eol).toBe('lf')
+ })
+
+ it('AUD-14 materializes stable paired row records with the source model', async () => {
+ const model = await createMarkdownSourceComparison('old\nsame\n', 'new\nsame\n')
+ expect(model.status).toBe('ready')
+ if (model.status !== 'ready') {
+ return
+ }
+ const hunk = model.hunks[0]!
+
+ expect(hunk.rows.map(({ before, after }) => [before?.text, after?.text])).toEqual([['old', 'new'], ['same', 'same']])
+ expect(hunk.rows).toBe(hunk.rows)
+ })
+
+ it('AUD-08 represents large collapsed gaps without retained line clones', async () => {
+ const source = Array.from({ length: 10_000 }, (_value, index) => `line ${index}`).join('\n')
+ const model = await createMarkdownSourceComparison(source, source)
+ expect(model.status).toBe('ready')
+ if (model.status !== 'ready') {
+ return
+ }
+
+ expect(model.gaps).toEqual([{
+ id: 'source-gap-0',
+ slot: 0,
+ beforeFrom: 0,
+ beforeTo: 10_000,
+ afterFrom: 0,
+ afterTo: 10_000,
+ count: 10_000,
+ }])
+ })
+
+ it('AUD-08 materializes large gaps in bounded observable pages', async () => {
+ const source = Array.from({ length: 10_000 }, (_value, index) => `line ${index}`).join('\n')
+ const model = await createMarkdownSourceComparison(source, source)
+ expect(model.status).toBe('ready')
+ if (model.status !== 'ready') {
+ return
+ }
+ const gap = model.gaps[0]!
+
+ const firstPage = materializeSourceDiffGap(source, source, gap, Number.POSITIVE_INFINITY)
+ const secondPage = materializeSourceDiffGap(source, source, gap, SOURCE_DIFF_LIMITS.maximumGapPageRows, SOURCE_DIFF_LIMITS.maximumGapPageRows)
+
+ expect(firstPage).toHaveLength(SOURCE_DIFF_LIMITS.maximumGapPageRows)
+ expect(firstPage[0]?.before).toMatchObject({ number: 1, text: 'line 0' })
+ expect(firstPage.at(-1)?.after).toMatchObject({ number: SOURCE_DIFF_LIMITS.maximumGapPageRows, text: `line ${SOURCE_DIFF_LIMITS.maximumGapPageRows - 1}` })
+ expect(secondPage).toHaveLength(SOURCE_DIFF_LIMITS.maximumGapPageRows)
+ expect(secondPage[0]?.before).toMatchObject({ number: SOURCE_DIFF_LIMITS.maximumGapPageRows + 1, text: `line ${SOURCE_DIFF_LIMITS.maximumGapPageRows}` })
+ expect(secondPage.at(-1)?.after).toMatchObject({ number: SOURCE_DIFF_LIMITS.maximumGapPageRows * 2, text: `line ${SOURCE_DIFF_LIMITS.maximumGapPageRows * 2 - 1}` })
+ })
+
+ it('falls back when visible controls exceed the source display limit', async () => {
+ const source = `${'\t'.repeat(200_000)}😀`
+
+ await expect(createMarkdownSourceComparison(source, source)).resolves.toEqual({
+ status: 'limited',
+ reason: 'size',
+ })
+ })
+
+ it('retains complete literal lines when only line endings differ', async () => {
+ const beforeSource = 'same\r\nbytes\r\n'
+ const afterSource = 'same\nbytes\n'
+ const model = await createMarkdownSourceComparison(beforeSource, afterSource)
+ expect(model.status).toBe('ready')
+ if (model.status !== 'ready') {
+ return
+ }
+ expect(model.hunks).toEqual([])
+ expect(model.gaps).toHaveLength(1)
+ const rows = materializeSourceDiffGap(beforeSource, afterSource, model.gaps[0]!)
+ expect(rows.map(({ before }: { before?: SourceDiffLine }) => ({ text: before?.text, eol: before?.eol }))).toEqual([
+ { text: 'same', eol: 'crlf' },
+ { text: 'bytes', eol: 'crlf' },
+ ])
+ expect(rows.map(({ after }: { after?: SourceDiffLine }) => ({ text: after?.text, eol: after?.eol }))).toEqual([
+ { text: 'same', eol: 'lf' },
+ { text: 'bytes', eol: 'lf' },
+ ])
+ })
+
+ it('keeps syntax-only and HTML-like changes as literal text', async () => {
+ const model = await createMarkdownSourceComparison('# Heading\n', '# Heading #\nApproved runbook
', + '', + 'Rollback after one failed health check.', + '', + '\n
\n')).toBe('**summary**
\n* list\n\n\n
\n')
+ expect(markdownThroughEditor('**summary**
\n* list\n\n\n
\n')).toBe('summary
\ncontent\n\n\n
\n')
})
test('nested details', ({ markdownThroughEditor }) => {
diff --git a/src/tests/markdownit/details.spec.js b/src/tests/markdownit/details.spec.js
index dd077287e52..86f1c636f08 100644
--- a/src/tests/markdownit/details.spec.js
+++ b/src/tests/markdownit/details.spec.js
@@ -11,6 +11,10 @@ describe('Details extension', () => {
const rendered = markdownit.render('summary
\ncontent\n\n\n
')
expect(stripIndent(rendered)).toBe('summary
\ncontent\nsummary
content
\n
')
+ expect(stripIndent(rendered)).toBe('summary
\ncontent\nsummary
content
\n
')
expect(stripIndent(rendered)).toBe('\ncontent\n
content