Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

Preserve editor viewport across Chat visits (#6548)

Nick Gomeze7d072a8f21a
diff --git a/.changeset/retain-editor-viewport-on-pane-switch.md b/.changeset/retain-editor-viewport-on-pane-switch.md
new file mode 100644
index 000000000..f89009793
--- /dev/null
+++ b/.changeset/retain-editor-viewport-on-pane-switch.md
@@ -0,0 +1,5 @@
+---
+'@inkeep/open-knowledge': patch
+---
+
+Preserve the editor's viewport and caret when switching to Agents and back in a narrow window, and prevent position resets when navigating or typing immediately after switching editor modes or jumping to source.
diff --git a/packages/app/src/components/BottomComposer.dom.test.tsx b/packages/app/src/components/BottomComposer.dom.test.tsx
index 7b046f3e2..6a15b6e1e 100644
--- a/packages/app/src/components/BottomComposer.dom.test.tsx
+++ b/packages/app/src/components/BottomComposer.dom.test.tsx
@@ -239,7 +239,12 @@ const ALL_INSTALLED: Record<string, { installed: boolean | null }> = {
async function renderComposer(
docName = 'notes',
- props: Partial<{ dismissed: boolean; onDismiss: () => void; onReopen: () => void }> = {},
+ props: Partial<{
+ dismissed: boolean;
+ editorVisible: boolean;
+ onDismiss: () => void;
+ onReopen: () => void;
+ }> = {},
options: { strict?: boolean; surface?: EditorSurface } = {},
) {
const { BottomComposer } = await import('./BottomComposer');
@@ -1632,10 +1637,8 @@ describe('BottomComposer (end-of-document scroll compensation)', () => {
'switching documents under an already-mounted, already-open composer is not the card ' +
'arriving over a caret. Scrolling `.editor-doc-scroll` here is a delta ' +
'ScrollPreservingContainer did not write, so it reads as an external scroll and abandons ' +
- 'the restore it is mid-way through. The reveal effect keys on `dismissed` alone so a ' +
- 'switch never re-runs it. `switched-doc` deliberately carries a caret BELOW the ' +
- 'occlusion line the first reveal left behind, so widening those dependencies produces a ' +
- 'write and reds this assertion. Give both stubs the same caret and it passes either way',
+ 'the restore it is mid-way through. The completed arrival has consumed its reveal, so ' +
+ '`switched-doc` must keep its viewport even with a caret below the occlusion line',
).toBe(afterOpen);
});
@@ -1687,9 +1690,8 @@ describe('BottomComposer (end-of-document scroll compensation)', () => {
cmPort.writes,
'toggling into source mode under an already-open card is not the card arriving. ' +
'mode-switch-landing owns where the source view lands, and a reveal firing here writes a ' +
- 'scroll delta that landing did not make. The reveal effect keys on `dismissed` alone so ' +
- 'the toggle never re-runs it, and adding `effectiveSurface` back to those dependencies ' +
- 'produces a write here',
+ 'scroll delta that landing did not make. The completed arrival has consumed its reveal, ' +
+ 'so the source viewport must stay with its mode-switch landing',
).toHaveLength(0);
expect(wysiwygPort.writes.length).toBe(afterOpen);
});
@@ -1796,6 +1798,49 @@ describe('BottomComposer (end-of-document scroll compensation)', () => {
).toBeGreaterThan(beforeRemount);
});
+ test('a composer mounted under a hidden editor reveals on its first visible arrival, and a later hide and show does not reveal again', async () => {
+ const { BottomComposer } = await import('./BottomComposer');
+ const port = plantScrollport(100);
+ await registerCaseEditor('hidden-mount-doc', caretEditorStub(port, CARET_INSIDE_THE_GAP));
+
+ const { rerender } = await renderComposer(
+ 'hidden-mount-doc',
+ { editorVisible: false },
+ { strict: true },
+ );
+ await nextFrame();
+ await nextFrame();
+ expect(
+ port.writes,
+ 'a hidden editor card has no caret on screen for the composer to clear, so a mount under ' +
+ 'it has to leave the scrollport alone',
+ ).toHaveLength(0);
+
+ rerender(<BottomComposer docName="hidden-mount-doc" surface="wysiwyg" editorVisible />);
+ await nextFrame();
+ await nextFrame();
+ expect(
+ port.writes,
+ 'the editor showing for the first time under a composer that mounted while it was hidden ' +
+ 'is the card arriving over a caret it has never revealed. Gating the reveal on the ' +
+ 'mount-time visibility alone leaves that caret under the card',
+ ).not.toHaveLength(0);
+
+ port.el.scrollTop = 100;
+ const beforeRoundTrip = port.writes.length;
+ rerender(<BottomComposer docName="hidden-mount-doc" surface="wysiwyg" editorVisible={false} />);
+ await nextFrame();
+ rerender(<BottomComposer docName="hidden-mount-doc" surface="wysiwyg" editorVisible />);
+ await nextFrame();
+ await nextFrame();
+ expect(
+ port.writes.length,
+ 'a Chat visit hides and shows the editor under a composer that already revealed. That is ' +
+ 'not an arrival, and a reveal here writes a delta the viewport restore did not make. The ' +
+ 'scroll is reset into the gap first, so a reveal on every show reds this',
+ ).toBe(beforeRoundTrip);
+ });
+
test('a reveal frame yields to a held scroll suppression, and a reopen recovers it', async () => {
const { acquireScrollRestoreSuppression } = await import(
'@/editor/scroll-restore-coordination'
@@ -1826,8 +1871,8 @@ describe('BottomComposer (end-of-document scroll compensation)', () => {
expect(
port.writes,
'yielding costs the caret its reveal for that arrival, so it stays where the seam left it ' +
- 'until the card arrives again. Closing and reopening flips `dismissed`, which is the ' +
- 'only dependency the reveal effect has, so it re-runs and reveals',
+ 'until the card arrives again. Closing and reopening flips `dismissed`, which marks the ' +
+ 'arrival reveal owed again and re-runs the effect, so it reveals',
).not.toHaveLength(0);
});
diff --git a/packages/app/src/components/BottomComposer.tsx b/packages/app/src/components/BottomComposer.tsx
index 0ef115677..51d896b10 100644
--- a/packages/app/src/components/BottomComposer.tsx
+++ b/packages/app/src/components/BottomComposer.tsx
@@ -136,6 +136,7 @@ export function BottomComposer({
docName,
surface,
folderPath,
+ editorVisible = true,
dismissed = false,
onDismiss,
onReopen,
@@ -143,6 +144,7 @@ export function BottomComposer({
docName?: string | null;
surface?: EditorSurface;
folderPath?: string;
+ editorVisible?: boolean;
dismissed?: boolean;
onDismiss?: () => void;
onReopen?: () => void;
@@ -258,6 +260,7 @@ export function BottomComposer({
}, [dismissed, docName, folderMode]);
const openAndFocus = useEffectEvent(() => {
+ if (!editorVisible) return;
if (dismissed) onReopen?.();
else inputRef.current?.focus();
});
@@ -265,17 +268,25 @@ export function BottomComposer({
const readPaintedOver = useEffectEvent(() => ({
docName: activeDocOrNull,
effectiveSurface,
+ editorVisible,
}));
+ const arrivalRevealOwedRef = useRef(true);
useEffect(() => {
- if (dismissed) return;
+ if (dismissed) {
+ arrivalRevealOwedRef.current = true;
+ return;
+ }
+ if (!editorVisible || !arrivalRevealOwedRef.current) return;
const arrivedOver = readPaintedOver();
const arrivedOverDoc = arrivedOver.docName;
if (arrivedOverDoc == null) return;
const arrivedOverSurface = arrivedOver.effectiveSurface;
const frame = requestAnimationFrame(() => {
+ arrivalRevealOwedRef.current = false;
const paintedOver = readPaintedOver();
if (
+ !paintedOver.editorVisible ||
paintedOver.docName !== arrivedOverDoc ||
paintedOver.effectiveSurface !== arrivedOverSurface
) {
@@ -291,7 +302,7 @@ export function BottomComposer({
});
});
return () => cancelAnimationFrame(frame);
- }, [dismissed]);
+ }, [dismissed, editorVisible]);
useEffect(() => {
return subscribeToOpenAskAiComposer(openAndFocus);
@@ -299,6 +310,7 @@ export function BottomComposer({
useEffect(() => {
const onKeyDown = (event: KeyboardEvent) => {
+ if (!readPaintedOver().editorVisible) return;
if (!matchesKeyboardShortcut(event, 'open-ask-ai')) return;
if (isOverlayLayerOpen()) return;
if (isNativeTextControl(event.target)) return;
diff --git a/packages/app/src/components/EditorArea.dom.test.tsx b/packages/app/src/components/EditorArea.dom.test.tsx
index b47607028..6b34cea87 100644
--- a/packages/app/src/components/EditorArea.dom.test.tsx
+++ b/packages/app/src/components/EditorArea.dom.test.tsx
@@ -5667,6 +5667,51 @@ describe('EditorArea with the editor hidden', () => {
expect(agentsHandle().style.display).toBe('none');
});
+ test.each([
+ {
+ pane: 'Chat',
+ open: { agentsVisible: true },
+ closed: { agentsVisible: false },
+ },
+ {
+ pane: 'a right Terminal',
+ open: { terminalVisible: true, terminalPlacement: 'right' },
+ closed: { terminalVisible: false, terminalPlacement: 'right' },
+ },
+ ] as const)(
+ 'closing $pane while the editor is hidden mounts no composer until the editor shows',
+ async ({ open, closed }) => {
+ const view = render(<EditorArea {...hiddenProps} {...closed} />);
+ await settle();
+ expect(screen.queryByTestId('bottom-composer')).not.toBeNull();
+ view.rerender(<EditorArea {...hiddenProps} {...open} />);
+ await settle();
+ expect(
+ screen.queryByTestId('bottom-composer'),
+ 'precondition: an open pane beside the shown editor keeps the composer out',
+ ).toBeNull();
+
+ view.rerender(<EditorArea {...hiddenProps} {...open} editorVisible={false} />);
+ await settle();
+ view.rerender(<EditorArea {...hiddenProps} {...closed} editorVisible={false} />);
+ await settle();
+ expect(
+ screen.queryByTestId('bottom-composer'),
+ 'a hidden editor keeps the pane visibility it had when it was last shown, so closing the ' +
+ 'pane under it must not mount a composer inside the hidden card. Reading either pane ' +
+ 'live, or dropping its field from that snapshot, mounts one here',
+ ).toBeNull();
+
+ view.rerender(<EditorArea {...hiddenProps} {...closed} />);
+ await settle();
+ expect(
+ screen.queryByTestId('bottom-composer'),
+ 'showing the editor again with no pane open has to bring the composer back, so the ' +
+ 'hidden-state absence above is the snapshot and not a gate that never opens',
+ ).not.toBeNull();
+ },
+ );
+
test('a right terminal and chat share the row in proportion to their current widths', async () => {
groupLayout = { 'editor-main': 40, 'terminal-column': 25, 'agents-column': 35 };
const view = render(
diff --git a/packages/app/src/components/EditorArea.tsx b/packages/app/src/components/EditorArea.tsx
index 30e110899..be881b80f 100644
--- a/packages/app/src/components/EditorArea.tsx
+++ b/packages/app/src/components/EditorArea.tsx
@@ -898,6 +898,17 @@ function EditorAreaInner({
const editorCardRef = useRef<HTMLDivElement | null>(null);
const lastEditorCardSizeRef = useRef<EditorCardSize | null>(null);
const [editorCardPin, setEditorCardPin] = useState<EditorCardSize | null>(null);
+ const [paneVisibilityWhileEditorShown, setPaneVisibilityWhileEditorShown] = useState({
+ terminalVisible,
+ agentsVisible,
+ });
+ if (
+ editorVisible &&
+ (paneVisibilityWhileEditorShown.terminalVisible !== terminalVisible ||
+ paneVisibilityWhileEditorShown.agentsVisible !== agentsVisible)
+ ) {
+ setPaneVisibilityWhileEditorShown({ terminalVisible, agentsVisible });
+ }
useLayoutEffect(() => {
const card = editorCardRef.current;
if (card == null || !editorVisible || typeof ResizeObserver === 'undefined') return;
@@ -2424,7 +2435,9 @@ function EditorAreaInner({
/>
) : null}
</div>
- {showFolderComposer ? <BottomComposer folderPath={activeTarget.folderPath} /> : null}
+ {showFolderComposer ? (
+ <BottomComposer folderPath={activeTarget.folderPath} editorVisible={editorVisible} />
+ ) : null}
</div>
);
const showAgentActivity = docPanelMode === 'agent' && docPanelAgentId !== null;
@@ -2524,8 +2537,7 @@ function EditorAreaInner({
} else {
const showBottomComposer =
shouldShowBottomComposer({
- terminalVisible,
- agentsVisible,
+ ...(editorVisible ? { terminalVisible, agentsVisible } : paneVisibilityWhileEditorShown),
isEmbedded,
activeDocName,
}) &&
@@ -2588,6 +2600,7 @@ function EditorAreaInner({
<BottomComposer
docName={activeDocName}
surface={editingSurface}
+ editorVisible={editorVisible}
dismissed={composerDismissed}
onDismiss={() => setComposerDismissed(true)}
onReopen={() => setComposerDismissed(false)}
diff --git a/packages/app/src/editor/landing-controller.browser.test.ts b/packages/app/src/editor/landing-controller.browser.test.ts
new file mode 100644
index 000000000..1e248b8cf
--- /dev/null
+++ b/packages/app/src/editor/landing-controller.browser.test.ts
@@ -0,0 +1,123 @@
+import { afterEach, beforeEach, expect, test, vi } from 'vitest';
+import { userEvent } from 'vitest/browser';
+import { matchesKeyboardShortcut } from '@/lib/keyboard-shortcuts';
+import { type LandingHandle, type LandingOutcome, startLanding } from './landing-controller';
+import { getDocScrollState, isScrollRestoreSuppressed } from './scroll-restore-coordination';
+
+const disposers: Array<() => void> = [];
+
+beforeEach(() => {
+ vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout'] });
+});
+
+afterEach(async () => {
+ for (const dispose of disposers.splice(0).reverse()) dispose();
+ vi.useRealTimers();
+ await userEvent.cleanup();
+});
+
+function fixture(startInMicrotask = false) {
+ const docName = `native-landing-${crypto.randomUUID()}`;
+ const container = document.createElement('div');
+ const content = document.createElement('div');
+ container.style.cssText = 'height: 300px; overflow: auto;';
+ content.style.cssText = 'height: 2000px;';
+ content.contentEditable = 'true';
+ content.textContent = 'Landing target';
+ container.append(content);
+ document.body.append(container);
+ disposers.push(() => container.remove());
+ content.focus();
+ expect(document.activeElement).toBe(content);
+ const outcomes: LandingOutcome[] = [];
+ const events: Array<Record<string, unknown>> = [];
+ let handle: LandingHandle | undefined;
+ disposers.push(() => handle?.cancel('superseded'));
+ const record = (phase: string, event: KeyboardEvent) => {
+ events.push({
+ phase,
+ key: event.key,
+ code: event.code,
+ trusted: event.isTrusted,
+ eventPhase: event.eventPhase,
+ prevented: event.defaultPrevented,
+ });
+ };
+ const stopAtDescendant = (event: KeyboardEvent) => {
+ record('descendant', event);
+ event.stopPropagation();
+ };
+ content.addEventListener('keydown', stopAtDescendant);
+ const start = () => {
+ handle = startLanding({
+ docName,
+ container,
+ contentColumn: content,
+ measureTarget: () => ({ top: 56, height: 40 }),
+ placement: 'top',
+ intent: 'toggle',
+ grade: 'exact',
+ landedMode: 'source',
+ onOutcome: (outcome) => {
+ outcomes.push(outcome);
+ events.push({ phase: 'outcome', ...outcome });
+ },
+ });
+ events.push({ phase: 'started', suppressed: isScrollRestoreSuppressed(docName) });
+ };
+ const fromWindow = (event: KeyboardEvent) => {
+ if (!matchesKeyboardShortcut(event, 'toggle-editor-mode')) return;
+ record('window', event);
+ event.preventDefault();
+ if (startInMicrotask) queueMicrotask(start);
+ else start();
+ queueMicrotask(() => record('window-microtask', event));
+ };
+ const startFromWindow = () => {
+ window.addEventListener('keydown', fromWindow, true);
+ disposers.push(() => window.removeEventListener('keydown', fromWindow, true));
+ };
+ return { docName, container, content, outcomes, events, start, startFromWindow };
+}
+
+test.each([false, true])(
+ 'native initiating toggle chord keeps its landing (microtask start: %s)',
+ async (startInMicrotask) => {
+ const f = fixture(startInMicrotask);
+ f.startFromWindow();
+ await userEvent.keyboard('{Control>}{Alt>}m{/Alt}{/Control}');
+ expect(f.events.filter((event) => event.phase === 'window')).toEqual([
+ expect.objectContaining({ code: 'KeyM', trusted: true }),
+ ]);
+ expect(f.events).toContainEqual(
+ expect.objectContaining({ phase: 'started', suppressed: true }),
+ );
+ expect(f.events).toContainEqual(
+ expect.objectContaining({ phase: 'descendant', code: 'KeyM', trusted: true }),
+ );
+ expect(f.outcomes).toEqual([]);
+ vi.advanceTimersToNextTimer();
+ expect(f.outcomes).toEqual([{ status: 'landed', delta: 0 }]);
+ expect(getDocScrollState(f.docName)?.mode).toBe('source');
+ },
+);
+
+test.each(['End', 'e'])(
+ 'later native %s keeps its viewport despite descendant stopPropagation',
+ async (key) => {
+ const f = fixture();
+ f.start();
+ expect(isScrollRestoreSuppressed(f.docName)).toBe(true);
+ await userEvent.keyboard(key === 'End' ? '{End}' : key);
+ expect(f.events).toContainEqual(
+ expect.objectContaining({ phase: 'descendant', key, trusted: true }),
+ );
+ expect(f.outcomes).toEqual([{ status: 'cancelled', reason: 'user-scroll' }]);
+ expect(isScrollRestoreSuppressed(f.docName)).toBe(false);
+ f.container.scrollTop = 1000;
+ f.container.dispatchEvent(new Event('contentvisibilityautostatechange'));
+ vi.runAllTimers();
+ expect(f.container.scrollTop).toBe(1000);
+ expect(getDocScrollState(f.docName)).toBeUndefined();
+ },
+);
diff --git a/packages/app/src/editor/landing-controller.test.ts b/packages/app/src/editor/landing-controller.test.ts
index 6e00355ed..fc9454703 100644
--- a/packages/app/src/editor/landing-controller.test.ts
+++ b/packages/app/src/editor/landing-controller.test.ts
@@ -21,6 +21,7 @@ import {
const TOOLBAR = 56;
const VIEWPORT = 800;
+const handles: LandingHandle[] = [];
function buildScroller(scrollHeight = 6000): { container: HTMLElement; content: HTMLElement } {
const container = document.createElement('div');
@@ -54,7 +55,9 @@ function startLandingWith(overrides: StartOverrides): LandingHandle {
toolbarOffset: TOOLBAR,
...overrides,
};
- return startLanding(params);
+ const handle = startLanding(params);
+ handles.push(handle);
+ return handle;
}
function markNamed(name: string): { properties?: Record<string, unknown> } | undefined {
@@ -72,6 +75,7 @@ beforeEach(() => {
});
afterEach(() => {
+ for (const handle of handles.splice(0)) handle.cancel('superseded');
vi.useRealTimers();
vi.unstubAllGlobals();
document.body.replaceChildren();
@@ -243,6 +247,75 @@ describe('startLanding — cancel and abandon', () => {
expect(container.scrollTop).toBe(afterDispatch);
});
+ test.each(['End', 'e'])(
+ 'keyboard %s keeps the newer viewport after pending landing work',
+ (key) => {
+ const { container, content } = buildScroller();
+ startLandingWith({
+ container,
+ contentColumn: content,
+ measureTarget: () => ({ top: TOOLBAR, height: 40 }),
+ placement: 'top',
+ });
+ expect(isScrollRestoreSuppressed('doc')).toBe(true);
+ content.addEventListener('keydown', (event) => event.stopPropagation());
+
+ content.dispatchEvent(new KeyboardEvent('keydown', { key, bubbles: true }));
+ container.scrollTop = 1843;
+ container.dispatchEvent(new Event('contentvisibilityautostatechange'));
+ vi.runAllTimers();
+
+ expect(getDocScrollState('doc')).toBeUndefined();
+ expect(container.scrollTop).toBe(1843);
+ },
+ );
+
+ test('does not cancel when the initiating keydown starts the landing during window capture', () => {
+ const { container, content } = buildScroller();
+ const outcomes: LandingOutcome[] = [];
+ const startFromWindow = (): void => {
+ startLandingWith({
+ container,
+ contentColumn: content,
+ measureTarget: () => ({ top: TOOLBAR, height: 40 }),
+ placement: 'top',
+ onOutcome: (o) => outcomes.push(o),
+ });
+ };
+ const stopAtDescendant = (event: KeyboardEvent): void => event.stopPropagation();
+ content.addEventListener('keydown', stopAtDescendant);
+ window.addEventListener('keydown', startFromWindow, true);
+
+ content.dispatchEvent(new KeyboardEvent('keydown', { key: 'm', bubbles: true }));
+
+ window.removeEventListener('keydown', startFromWindow, true);
+ content.removeEventListener('keydown', stopAtDescendant);
+ expect(outcomes).toEqual([]);
+
+ vi.advanceTimersByTime(150);
+
+ expect(outcomes).toEqual([{ status: 'landed', delta: 0 }]);
+ });
+
+ test('keyboard input outside the landing container leaves its landing active', () => {
+ const { container } = buildScroller();
+ const outside = document.createElement('div');
+ document.body.append(outside);
+ const outcomes: LandingOutcome[] = [];
+ startLandingWith({
+ container,
+ measureTarget: () => ({ top: 1000, height: 40 }),
+ onOutcome: (outcome) => outcomes.push(outcome),
+ });
+
+ outside.dispatchEvent(new KeyboardEvent('keydown', { key: 'e', bubbles: true }));
+
+ expect(isScrollRestoreSuppressed('doc')).toBe(true);
+ expect(outcomes).toEqual([]);
+ vi.advanceTimersByTime(150);
+ expect(outcomes).toEqual([{ status: 'landed', delta: 0 }]);
+ });
+
test('cancels on a touch gesture', () => {
const { container } = buildScroller();
const outcomes: LandingOutcome[] = [];
diff --git a/packages/app/src/editor/landing-controller.ts b/packages/app/src/editor/landing-controller.ts
index 06d359eee..48d835da3 100644
--- a/packages/app/src/editor/landing-controller.ts
+++ b/packages/app/src/editor/landing-controller.ts
@@ -130,6 +130,7 @@ export function startLanding(params: StartLandingParams): LandingHandle {
resizeObserver?.disconnect();
container.removeEventListener('wheel', onUserInterrupt);
container.removeEventListener('touchstart', onUserInterrupt);
+ window.removeEventListener('keydown', onKeyboardInterrupt, true);
container.removeEventListener('contentvisibilityautostatechange', onSignal, true);
container.style.overflowAnchor = priorOverflowAnchor;
suppression.release();
@@ -189,6 +190,10 @@ export function startLanding(params: StartLandingParams): LandingHandle {
cancel('user-scroll');
}
+ function onKeyboardInterrupt(event: KeyboardEvent): void {
+ if (event.composedPath().includes(container)) onUserInterrupt();
+ }
+
function onSignal(): void {
if (closed) return;
const { measurable, moved } = dispatch();
@@ -202,6 +207,7 @@ export function startLanding(params: StartLandingParams): LandingHandle {
container.addEventListener('contentvisibilityautostatechange', onSignal, true);
container.addEventListener('wheel', onUserInterrupt, { passive: true });
container.addEventListener('touchstart', onUserInterrupt, { passive: true });
+ window.addEventListener('keydown', onKeyboardInterrupt, true);
if (typeof ResizeObserver !== 'undefined' && contentColumn) {
resizeObserver = new ResizeObserver(onSignal);
resizeObserver.observe(contentColumn);
diff --git a/packages/app/tests/stress/_helpers/index.ts b/packages/app/tests/stress/_helpers/index.ts
index 432d14743..54a09755f 100644
--- a/packages/app/tests/stress/_helpers/index.ts
+++ b/packages/app/tests/stress/_helpers/index.ts
@@ -89,6 +89,7 @@ export {
CHUNK_WRAPPER_SELECTOR,
injectForcedEstimateError,
landingMarkCount,
+ readEditorCaretLine,
readSourceCaretHead,
readWysiwygCaretHead,
scrollWysiwygBlockToTop,
diff --git a/packages/app/tests/stress/_helpers/landing.ts b/packages/app/tests/stress/_helpers/landing.ts
index 2fe62cfc1..dd8fc7131 100644
--- a/packages/app/tests/stress/_helpers/landing.ts
+++ b/packages/app/tests/stress/_helpers/landing.ts
@@ -416,6 +416,51 @@ export async function readSourceCaretHead(page: Page): Promise<number> {
}, SOURCE_SELECTOR);
}
+export function readEditorCaretLine(element: Element, mode: 'source' | 'visual') {
+ if (mode === 'source') {
+ const content = element.matches('.cm-content')
+ ? element
+ : element.closest('.cm-editor')?.querySelector('.cm-content');
+ const handle = content as
+ | (Element & {
+ cmTile?: { root?: { view?: unknown } };
+ cmView?: { rootView?: { view?: unknown } };
+ })
+ | null
+ | undefined;
+ const view = (handle?.cmTile?.root?.view ?? handle?.cmView?.rootView?.view) as
+ | {
+ state: {
+ selection: { main: { head: number; empty: boolean } };
+ doc: { lineAt: (pos: number) => { to: number; text: string } };
+ };
+ }
+ | undefined;
+ if (!view) throw new Error('readEditorCaretLine: no CodeMirror view on the element');
+ const selection = view.state.selection.main;
+ const line = view.state.doc.lineAt(selection.head);
+ return {
+ collapsed: selection.empty,
+ atParagraphEnd: selection.empty && selection.head === line.to,
+ text: line.text,
+ };
+ }
+ const root = element.closest('.ProseMirror') as
+ | (Element & { editor?: typeof window.__activeEditor })
+ | null;
+ const editor = root?.editor;
+ if (!editor) throw new Error('readEditorCaretLine: no ProseMirror editor on the element');
+ const selection = editor.state.selection;
+ return {
+ collapsed: selection.empty,
+ atParagraphEnd:
+ selection.empty &&
+ selection.$from.parent.isTextblock &&
+ selection.$from.parentOffset === selection.$from.parent.content.size,
+ text: selection.$from.parent.textContent,
+ };
+}
+
export async function readWysiwygCaretHead(page: Page): Promise<number> {
return page.evaluate(() => {
const editor = window.__activeEditor;
diff --git a/packages/app/tests/stress/editor-pane-cards.e2e.ts b/packages/app/tests/stress/editor-pane-cards.e2e.ts
index cacaf48ab..fd23f3a2e 100644
--- a/packages/app/tests/stress/editor-pane-cards.e2e.ts
+++ b/packages/app/tests/stress/editor-pane-cards.e2e.ts
@@ -1,3 +1,5 @@
+import { writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
import AxeBuilder from '@axe-core/playwright';
import type {
ThreadClientFrame,
@@ -5,9 +7,12 @@ import type {
} from '@inkeep/open-knowledge-core/acp/thread-protocol';
import type { Locator, Page, WebSocketRoute } from '@playwright/test';
import { PANE_CARD_GAP_PX } from '../../src/components/ui/pane-card';
+import { SCROLL_PIN_SLACK_PX } from '../../src/editor/document-scrollports';
import {
acpCatalogBody,
expect,
+ placeCaretAtEndOfText,
+ readEditorCaretLine,
switchColorThemeAndSettleFade,
test,
waitForActiveProviderSynced,
@@ -80,6 +85,22 @@ async function openChat(page: Page): Promise<void> {
await expect(page.locator('[data-dragging="true"]')).toHaveCount(0);
}
+async function dispatchAskAiShortcut(locator: Locator): Promise<boolean> {
+ return locator.evaluate((element, isMac) => {
+ const event = new KeyboardEvent('keydown', {
+ key: 'l',
+ code: 'KeyL',
+ metaKey: isMac,
+ ctrlKey: !isMac,
+ shiftKey: true,
+ bubbles: true,
+ cancelable: true,
+ });
+ element.dispatchEvent(event);
+ return event.defaultPrevented;
+ }, process.platform === 'darwin');
+}
+
async function noSidewaysScroll(page: Page): Promise<void> {
const overflow = await page.evaluate(() => ({
scrollWidth: document.documentElement.scrollWidth,
@@ -1149,13 +1170,10 @@ for (const mode of ['source', 'visual'] as const) {
await expect(surface).toBeVisible({ timeout: BOOT_TIMEOUT_MS });
const lineEndKey = process.platform === 'darwin' ? 'Meta+ArrowRight' : 'End';
if (mode === 'source') {
- await surface.evaluate((element) => {
- for (let node = element.parentElement; node; node = node.parentElement) {
- const overflowY = getComputedStyle(node).overflowY;
- if (overflowY === 'auto' || overflowY === 'scroll') node.scrollTop = node.scrollHeight;
- }
- });
- await surface.getByText('Mode paragraph 59', { exact: true }).click();
+ await surface.focus();
+ await expect(surface).toBeFocused();
+ await page.keyboard.press('ControlOrMeta+End');
+ await page.keyboard.press('ArrowLeft');
await page.keyboard.press('End');
} else {
await surface.locator('p').last().click();
@@ -1176,6 +1194,11 @@ for (const mode of ['source', 'visual'] as const) {
}
return 0;
});
+ const editorScrollport = surface.locator(
+ 'xpath=ancestor::*[@data-testid="editor-scroll-container"]',
+ );
+ await waitForComposerViewportInset(page, surface);
+ const viewportBefore = await parkScrollportNearEnd(editorScrollport, 41);
const bytesBefore = await readDocument();
const scrollBefore = await scrollTopOf();
expect(scrollBefore).toBeGreaterThan(0);
@@ -1183,6 +1206,7 @@ for (const mode of ['source', 'visual'] as const) {
await page.getByTestId(AGENTS_HEADER_BUTTON).click();
await expect(page.locator(CHAT_CARD)).toBeVisible();
await expect(page.locator(EDITOR_CARD)).toBeHidden();
+ await waitForAnimationsFinished(surface);
await page.getByTestId('header-pane-button-editor').click();
await expect(page.locator(EDITOR_CARD)).toBeVisible();
await expect(page.locator(CHAT_CARD)).toBeHidden();
@@ -1190,21 +1214,23 @@ for (const mode of ['source', 'visual'] as const) {
await expect(modeToggle).toHaveAttribute('aria-checked', 'true');
await expect(surface).toBeVisible();
expect(await readDocument()).toBe(bytesBefore);
+ await waitForComposerViewportInset(page, surface);
+ await test.info().attach('viewport-round-trip', {
+ body: JSON.stringify({
+ mode,
+ before: viewportBefore,
+ after: await readScrollportExtent(editorScrollport),
+ }),
+ contentType: 'application/json',
+ });
await expect.poll(scrollTopOf).toBeGreaterThanOrEqual(scrollBefore - 2);
expect(await scrollTopOf()).toBeLessThanOrEqual(scrollBefore + 2);
await surface.focus();
- const caret = await page.evaluate(() => {
- const selection = window.getSelection();
- return {
- text: selection?.focusNode?.textContent ?? '',
- offset: selection?.focusOffset ?? -1,
- collapsed: selection?.isCollapsed ?? false,
- };
- });
+ const caret = await surface.evaluate(readEditorCaretLine, mode);
expect(caret.collapsed).toBe(true);
expect(caret.text.endsWith('Mode paragraph 59 edited')).toBe(true);
- expect(caret.offset).toBe(caret.text.length);
+ expect(caret.atParagraphEnd).toBe(true);
await page.keyboard.press('ControlOrMeta+z');
await expect.poll(readDocument).not.toContain('Mode paragraph 59 edited');
expect(await readDocument()).toBe(seededBytes);
@@ -1488,3 +1514,269 @@ test('a second client edit made while narrow Chat is selected appears once and k
await clientB.close();
}
});
+
+async function waitForAnimationsFinished(target: Locator): Promise<void> {
+ await target.evaluate(async (element) => {
+ await Promise.all(element.getAnimations().map((animation) => animation.finished));
+ });
+}
+
+function readScrollportExtent(scrollport: Locator) {
+ return scrollport.evaluate((element) => ({
+ scrollTop: element.scrollTop,
+ scrollHeight: element.scrollHeight,
+ clientHeight: element.clientHeight,
+ clientWidth: element.clientWidth,
+ }));
+}
+
+async function parkScrollportNearEnd(scrollport: Locator, endOffsetPx: number) {
+ await expect
+ .poll(() => scrollport.evaluate((element) => element.scrollHeight - element.clientHeight))
+ .toBeGreaterThan(endOffsetPx);
+ await scrollport.evaluate((element, offset) => {
+ element.scrollTop = element.scrollHeight - element.clientHeight - offset;
+ }, endOffsetPx);
+ const extent = await readScrollportExtent(scrollport);
+ expect(extent.scrollHeight - extent.clientHeight - extent.scrollTop).toBe(endOffsetPx);
+ return extent;
+}
+
+async function waitForComposerViewportInset(page: Page, inset: Locator): Promise<void> {
+ await expect(page.getByTestId('bottom-composer')).toBeVisible();
+ await expect
+ .poll(() =>
+ inset.evaluate((element) =>
+ Number.parseFloat(getComputedStyle(element).getPropertyValue('--ask-composer-height')),
+ ),
+ )
+ .toBeGreaterThan(0);
+ await Promise.all([
+ waitForAnimationsFinished(inset),
+ waitForAnimationsFinished(page.getByTestId('bottom-composer')),
+ ]);
+}
+
+async function expectChatVisitToPreserveViewport(
+ page: Page,
+ scrollport: Locator,
+ inset: Locator,
+): Promise<void> {
+ await waitForComposerViewportInset(page, inset);
+ const before = await parkScrollportNearEnd(scrollport, 41);
+ await page.getByTestId(AGENTS_HEADER_BUTTON).click();
+ await expect(page.locator(CHAT_CARD)).toBeVisible();
+ await expect(page.locator(EDITOR_CARD)).toBeHidden();
+ await waitForAnimationsFinished(inset);
+ await page.getByTestId('header-pane-button-editor').click();
+ await expect(page.locator(EDITOR_CARD)).toBeVisible();
+ await expect(page.locator(CHAT_CARD)).toBeHidden();
+ await waitForComposerViewportInset(page, inset);
+ const after = await readScrollportExtent(scrollport);
+ await test.info().attach('consumer-viewport-round-trip', {
+ body: JSON.stringify({ before, after }),
+ contentType: 'application/json',
+ });
+ expect(after.scrollTop).toBeGreaterThanOrEqual(before.scrollTop - 2);
+ expect(after.scrollTop).toBeLessThanOrEqual(before.scrollTop + 2);
+}
+
+test('a narrow Chat visit preserves the standalone text viewport', async ({
+ page,
+ workerServer,
+}) => {
+ const docName = `pane-viewport-text-${test.info().workerIndex}.ts`;
+ const content = Array.from(
+ { length: 120 },
+ (_, index) => `export const line${index} = ${index};`,
+ ).join('\n');
+ await writeFile(join(workerServer.contentDir, docName), `${content}\n`);
+ await page.setViewportSize({ width: 767, height: 800 });
+ await page.goto(`/#/${docName}`);
+ const surface = page.locator('[data-text-doc-editor] .cm-content');
+ await expect(surface).toBeVisible({ timeout: BOOT_TIMEOUT_MS });
+ await expect(surface).toContainText('export const line0 = 0;');
+ await surface.focus();
+ await expect(surface).toBeFocused();
+ await page.keyboard.press('ControlOrMeta+End');
+ await expect(surface.getByText('export const line119 = 119;', { exact: true })).toBeVisible();
+ await expectChatVisitToPreserveViewport(
+ page,
+ page.locator('[data-text-doc-editor] .cm-scroller'),
+ surface,
+ );
+});
+
+test('a narrow Chat visit preserves the standalone Mermaid source viewport', async ({
+ page,
+ workerServer,
+}) => {
+ const docName = `pane-viewport-mermaid-${test.info().workerIndex}.mmd`;
+ const content = `flowchart TD\n${Array.from({ length: 120 }, (_, index) => `N${index} --> N${index + 1}`).join('\n')}\n`;
+ await writeFile(join(workerServer.contentDir, docName), content);
+ await page.setViewportSize({ width: 767, height: 800 });
+ await page.goto(`/#/${docName}`);
+ const host = page.locator('[data-mermaid-doc-editor]');
+ await expect(host).toBeVisible({ timeout: BOOT_TIMEOUT_MS });
+ await page.getByRole('radio', { name: 'Markdown source' }).click();
+ const surface = host.locator('.cm-content');
+ await expect(surface).toBeVisible({ timeout: BOOT_TIMEOUT_MS });
+ await expect(surface).toContainText('flowchart TD');
+ await surface.focus();
+ await expect(surface).toBeFocused();
+ await page.keyboard.press('ControlOrMeta+End');
+ await expect(surface.getByText('N119 --> N120', { exact: true })).toBeVisible();
+ await expectChatVisitToPreserveViewport(page, host.locator('.cm-scroller'), host);
+});
+
+test('a narrow Chat visit preserves the conflict viewport', async ({ page, api }) => {
+ const docName = `pane-viewport-conflict-${test.info().workerIndex}`;
+ const file = `${docName}.md`;
+ const base = Array.from({ length: 120 }, (_, index) => `Original line ${index}`).join('\n');
+ const ours = Array.from({ length: 120 }, (_, index) => `Current line ${index}`).join('\n');
+ const theirs = Array.from({ length: 120 }, (_, index) => `Incoming line ${index}`).join('\n');
+ await api.seedDocs([{ name: docName, markdown: `${ours}\n` }]);
+ await page.route('**/api/sync/conflicts', (route) =>
+ route.fulfill({
+ json: {
+ conflicts: [
+ { file, docName, detectedAt: '2026-10-15T00:00:00.000Z', conflict: 'merge-native' },
+ ],
+ },
+ }),
+ );
+ await page.route('**/api/sync/conflict-content?**', (route) =>
+ route.fulfill({
+ json: {
+ file,
+ base,
+ ours,
+ theirs,
+ kind: 'both-modified',
+ conflict: 'merge-native',
+ conflictKind: 'git',
+ resolutionOptions: ['mine', 'theirs', 'content'],
+ },
+ }),
+ );
+ await page.setViewportSize({ width: 767, height: 800 });
+ await page.goto(`/#/${docName}`);
+ const scrollport = page.locator(`${EDITOR_CARD} .conflict-view`);
+ await expect(scrollport).toBeVisible({ timeout: BOOT_TIMEOUT_MS });
+ const inset = scrollport.locator('diffs-container');
+ await expect(inset).toHaveCount(1);
+ await expect(scrollport.getByText('Current line 0', { exact: true })).toBeAttached();
+ await page.getByTestId('header-pane-button-editor').focus();
+ await page.keyboard.press('ArrowLeft');
+ await expectChatVisitToPreserveViewport(page, scrollport, inset);
+});
+
+test('a narrow Chat visit keeps a collapsed Ask AI inactive', async ({ page, api }) => {
+ await openDoc(page, api, 767);
+ await expect(page.getByTestId('bottom-composer')).toBeVisible();
+ await page.getByTestId('ask-ai-collapse').click();
+ await expect(page.getByTestId('bottom-composer')).toHaveCount(0);
+ await page.getByTestId(AGENTS_HEADER_BUTTON).click();
+ await expect(page.locator(CHAT_CARD)).toBeVisible();
+ await expect(page.locator(EDITOR_CARD)).toBeHidden();
+ const visibleButton = page.getByTestId(AGENTS_HEADER_BUTTON);
+ await visibleButton.focus();
+ await expect(visibleButton).toBeFocused();
+ await page.keyboard.press('ControlOrMeta+Shift+L');
+ await expect(visibleButton).toBeFocused();
+ const claimed = await dispatchAskAiShortcut(visibleButton);
+ expect(claimed).toBe(false);
+ await page.evaluate(() =>
+ window.dispatchEvent(new CustomEvent('open-knowledge:open-ask-ai-composer')),
+ );
+ await expect(visibleButton).toBeFocused();
+ await page.getByTestId('header-pane-button-editor').click();
+ await expect(page.locator(EDITOR_CARD)).toBeVisible();
+ await expect(page.getByTestId('bottom-composer')).toHaveCount(0);
+});
+
+test('hiding a folder editor leaves Ask AI shortcuts unclaimed until it shows', async ({
+ page,
+ api,
+}) => {
+ const folder = `pane-folder-${test.info().workerIndex}`;
+ await api.seedDocs([{ name: `${folder}/child`, markdown: '# Folder child\n' }]);
+ await page.setViewportSize({ width: 767, height: 800 });
+ await page.goto(`/#/${folder}`);
+ const composer = page.getByTestId('bottom-composer');
+ await expect(composer).toBeVisible();
+ await expect(composer.getByTestId(`composer-context-chip-file-${folder}`)).toContainText(folder);
+ const input = composer.locator('[contenteditable="true"]');
+ await expect(input).toHaveCount(1);
+ const editorButton = page.getByTestId('header-pane-button-editor');
+ await editorButton.focus();
+ expect(await dispatchAskAiShortcut(editorButton)).toBe(true);
+ await expect(input).toBeFocused();
+ await page.keyboard.press('ControlOrMeta+k');
+ const paletteInput = page.locator('[data-slot="command-input"]');
+ await paletteInput.fill('hide editor');
+ await page.getByTestId('command-palette-toggle-editor').click();
+ await expect(paletteInput).toBeHidden();
+ await expect(page.locator(EDITOR_CARD)).toBeHidden();
+ await expect(composer).toHaveCount(1);
+ await editorButton.focus();
+ await page.keyboard.press('ControlOrMeta+Shift+L');
+ await expect(editorButton).toBeFocused();
+ expect(await dispatchAskAiShortcut(editorButton)).toBe(false);
+ await editorButton.click();
+ await expect(composer).toBeVisible();
+ await editorButton.focus();
+ await page.keyboard.press('ControlOrMeta+Shift+L');
+ await expect(input).toBeFocused();
+});
+
+for (const endOffsetPx of [SCROLL_PIN_SLACK_PX / 2, SCROLL_PIN_SLACK_PX + 1]) {
+ test(`hiding a wide editor beside Chat ${endOffsetPx}px above its end mounts no composer and preserves its viewport`, async ({
+ page,
+ api,
+ }) => {
+ const docName = `pane-viewport-wide-${endOffsetPx}-${test.info().workerIndex}`;
+ const content = Array.from({ length: 120 }, (_, index) => `Wide paragraph ${index}`).join(
+ ' \n',
+ );
+ await api.seedDocs([{ name: docName, markdown: `# Wide viewport\n\n${content}\n` }]);
+ await page.setViewportSize({ width: 1400, height: 800 });
+ await page.goto(`/#/${docName}`);
+ await waitForActiveProviderSynced(page);
+ const surface = page.locator(`${EDITOR_CARD} .ProseMirror:not(.composer-prosemirror)`).first();
+ await expect(surface).toBeVisible({ timeout: BOOT_TIMEOUT_MS });
+ await openChat(page);
+ await expect(page.getByTestId('bottom-composer')).toHaveCount(0);
+ await waitForAnimationsFinished(surface);
+ const caret = await placeCaretAtEndOfText(page, 'Wide paragraph 119');
+ const documentEnd = await page.evaluate(() => {
+ const editor = window.__activeEditor;
+ if (!editor) throw new Error('The wide editor is not mounted');
+ return editor.state.doc.content.size - 1;
+ });
+ expect(caret.pmCaret).toBe(documentEnd);
+ const scrollport = surface.locator('xpath=ancestor::*[@data-testid="editor-scroll-container"]');
+ const before = await parkScrollportNearEnd(scrollport, endOffsetPx);
+ await page.getByTestId('header-pane-button-editor').click();
+ await expect(page.locator(EDITOR_CARD)).toBeHidden();
+ await expect(page.locator(CHAT_CARD)).toBeVisible();
+ await expect(surface).toBeAttached();
+ await waitForAnimationsFinished(surface);
+ await expect.soft(page.getByTestId('bottom-composer')).toHaveCount(0);
+ await page.getByTestId('header-pane-button-editor').click();
+ await expect(page.locator(EDITOR_CARD)).toBeVisible();
+ await expect(page.locator(CHAT_CARD)).toBeVisible();
+ await expect(page.getByTestId('bottom-composer')).toHaveCount(0);
+ await expect
+ .poll(() => scrollport.evaluate((element) => element.clientWidth))
+ .toBe(before.clientWidth);
+ await waitForAnimationsFinished(surface);
+ const after = await readScrollportExtent(scrollport);
+ await test.info().attach('wide-viewport-round-trip', {
+ body: JSON.stringify({ before, after }),
+ contentType: 'application/json',
+ });
+ expect(after.scrollTop).toBeGreaterThanOrEqual(before.scrollTop - 2);
+ expect(after.scrollTop).toBeLessThanOrEqual(before.scrollTop + 2);
+ });
+}