Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

Stop reporting a refresh the document abandoned as a failed request (#4809)

Nick Gomezf3d51c3788d1
diff --git a/.changeset/pagelist-refresh-teardown-quiet.md b/.changeset/pagelist-refresh-teardown-quiet.md
new file mode 100644
index 000000000..965a46d95
--- /dev/null
+++ b/.changeset/pagelist-refresh-teardown-quiet.md
@@ -0,0 +1,5 @@
+---
+"@inkeep/open-knowledge": patch
+---
+
+Reloading the app, leaving it, or closing the window no longer logs the page-list refreshes it abandoned as failed requests.
diff --git a/packages/app/package.json b/packages/app/package.json
index b98def461..7d0dd8c4b 100644
--- a/packages/app/package.json
+++ b/packages/app/package.json
@@ -37,7 +37,7 @@
"measure:stress": "bash scripts/measure-stress.sh",
"measure:sweep": "bash scripts/measure-sweep.sh",
"perf:compare": "bash scripts/perf-compare.sh",
- "test:e2e": "playwright test tests/stress/list-item-drag.e2e.ts tests/stress/ux-interactions.e2e.ts tests/stress/file-tree-create.e2e.ts tests/stress/file-tree-drag-to-root.e2e.ts tests/stress/file-tree-deselect-to-root.e2e.ts tests/stress/file-tree-collapse-spaced-folder.e2e.ts tests/stress/sidebar-file-list-fills.e2e.ts tests/stress/file-tree-sticky-collapse.e2e.ts tests/stress/file-tree-collapse-persistence.e2e.ts tests/stress/file-tree-fractional-zoom.e2e.ts tests/stress/create-then-rename-editable.e2e.ts tests/stress/find-replace.e2e.ts tests/stress/editor-tabs.e2e.ts tests/stress/crdt-stress.e2e.ts tests/stress/slash-command.e2e.ts tests/stress/paste-fidelity.e2e.ts tests/stress/fr-7a-disconnect-source-mode.e2e.ts tests/stress/docs-open.e2e.ts tests/stress/frozen-table-headers.e2e.ts tests/stress/asset-embed.e2e.ts tests/stress/asset-embed-advanced.e2e.ts tests/stress/asset-click-dispatch.e2e.ts tests/stress/handoff.e2e.ts tests/stress/multi-agent-presence.e2e.ts tests/stress/editor-mode-persistence.e2e.ts tests/stress/lint-config-toggle.e2e.ts tests/stress/plugin-enable-notice.e2e.ts tests/stress/schema-edit-fields-view.e2e.ts tests/stress/sidebar-search-pill.e2e.ts tests/stress/navigation-history.e2e.ts tests/stress/command-palette-semantic.e2e.ts tests/stress/agent-activity-panel.e2e.ts tests/stress/drop-pipeline-auto-open.e2e.ts tests/stress/command-palette-flicker.e2e.ts tests/stress/cm6-list-hanging-indent.e2e.ts tests/stress/ng7-rapid-nav-coherence.e2e.ts tests/stress/reveal-on-activate.e2e.ts tests/stress/selection-indicator.e2e.ts tests/stress/new-file-cross-doc-bleed.e2e.ts tests/stress/new-item-shortcut-fast-path.e2e.ts tests/stress/editor-mode-flip-cross-doc-bleed.e2e.ts tests/stress/editor-area-viewport-resize.e2e.ts tests/stress/qa-sidebar-responsive.e2e.ts tests/stress/prd-6955-reassertion-repro.e2e.ts tests/stress/prd-6955-reassertion-wedge.e2e.ts tests/stress/prd-6914-repro.e2e.ts tests/stress/showall-lazy-tree.e2e.ts tests/stress/tabs-component-strip.e2e.ts tests/stress/source-find-scroll.e2e.ts tests/stress/harness-app-warmth.e2e.ts tests/stress/qa-canary-authoring-both-modes.e2e.ts tests/stress/qa-canary-live-typing.e2e.ts tests/stress/keystroke-cadence-danger-space.e2e.ts tests/stress/jsx-unregistered-backspace-delete.e2e.ts tests/stress/jsx-unregistered-ime-concurrent.e2e.ts tests/stress/jsx-backspace-delete.e2e.ts tests/stress/link-authoring-bytes.e2e.ts tests/stress/link-authoring-apex.e2e.ts tests/stress/command-palette-parity.e2e.ts tests/stress/settings-search.e2e.ts tests/stress/okf-generated-index-settings.e2e.ts tests/stress/okf-recommended-skill-install.e2e.ts tests/stress/chip-popover-positioning.e2e.ts tests/stress/docs-open-scroll-restore.e2e.ts tests/stress/file-tree-decoration-chip-strip-repro.e2e.ts tests/stress/grip-click-nodeselect.e2e.ts tests/stress/jsx-halo-semantics.e2e.ts tests/stress/jsx-image-body-click.e2e.ts tests/stress/jsx-prop-panel-placeholder.e2e.ts tests/stress/jsx-range-encompass-halo.e2e.ts tests/stress/jsx-wildcard-convert.e2e.ts tests/stress/markdown-lint.e2e.ts tests/stress/frontmatter-schema-badge.e2e.ts tests/stress/frontmatter-glob-picker.e2e.ts tests/stress/unified-problems.e2e.ts tests/stress/mid-type-recovery.e2e.ts tests/stress/observer-a-multi-client.e2e.ts tests/stress/outline-toolbar-occlusion.e2e.ts tests/stress/selection-surface-pane-clip.e2e.ts tests/stress/quiet-tree-hidden-doc.e2e.ts tests/stress/raw-mdx-fallback-onblur-upgrade.e2e.ts tests/stress/rename-noext-probe.e2e.ts tests/stress/show-ok-folders.e2e.ts tests/stress/source-polish.e2e.ts tests/stress/warm-skeleton-scroll-restore.e2e.ts tests/stress/props-toggle-scroll-preserve.e2e.ts tests/stress/yjs-no-dual-import.e2e.ts tests/stress/graph-panel-surfaces.e2e.ts tests/stress/asset-embed-real-fidelity.e2e.ts tests/stress/image-invalid-placeholder.e2e.ts tests/stress/local-target-audit.e2e.ts tests/stress/rename-content-preservation.e2e.ts tests/stress/rename-consolidation.e2e.ts tests/stress/outline-active-heading.e2e.ts tests/stress/outline-navigation.e2e.ts tests/stress/prd-7627-default-swatch.e2e.ts tests/stress/clipboard-dollar-math-source-fallback.e2e.ts tests/stress/source-mode-undo-keymap.e2e.ts tests/stress/source-undo-mode-flip.e2e.ts tests/stress/timeline-recovered-restore.e2e.ts tests/stress/blank-line-preservation.e2e.ts tests/stress/landing-helpers.e2e.ts tests/stress/agent-follow-scroll.e2e.ts tests/stress/mode-switch-landing.e2e.ts tests/stress/mode-switch-ordinal-divergence.e2e.ts tests/stress/comment-annotation-visibility.e2e.ts tests/stress/comment-opens-in-panel.e2e.ts tests/stress/qa-miles-edge-blanks.e2e.ts tests/stress/prop-upload.e2e.ts tests/stress/slash-command-auto-open.e2e.ts tests/stress/clipboard-relative-url-source-fallback.e2e.ts tests/stress/editor-split-view.e2e.ts tests/stress/language-load-failure.e2e.ts tests/stress/language-first-paint.e2e.ts tests/stress/user-text-direction.e2e.ts tests/stress/pseudolocale.e2e.ts tests/stress/language-picker.e2e.ts tests/stress/zh-hans-coverage-sweep.e2e.ts tests/stress/preview-tab-promotion.e2e.ts tests/stress/cv-paint-lock-click.e2e.ts tests/stress/cv-auto-paint-lock-click.e2e.ts tests/stress/history-traversal-preview-tab.e2e.ts tests/stress/tab-close-scroll-restore.e2e.ts tests/stress/skills-sidebar-open.e2e.ts tests/stress/trailing-affordance.e2e.ts tests/stress/text-doc-composer-inset.e2e.ts tests/stress/composer-control-alignment.e2e.ts tests/stress/agents-settings-accessible-names.e2e.ts tests/stress/composer-growth-eof-reveal.e2e.ts tests/stress/theme-fade.e2e.ts tests/stress/theme-color-conversion.e2e.ts tests/stress/composer-open-caret-reveal.e2e.ts tests/stress/spellcheck-browser-absence.e2e.ts tests/stress/agents-panel-reload-visibility.e2e.ts tests/stress/rail-flex-distribution-law.e2e.ts tests/stress/audit-409-console-record.e2e.ts",
+ "test:e2e": "playwright test tests/stress/list-item-drag.e2e.ts tests/stress/ux-interactions.e2e.ts tests/stress/file-tree-create.e2e.ts tests/stress/file-tree-drag-to-root.e2e.ts tests/stress/file-tree-deselect-to-root.e2e.ts tests/stress/file-tree-collapse-spaced-folder.e2e.ts tests/stress/sidebar-file-list-fills.e2e.ts tests/stress/file-tree-sticky-collapse.e2e.ts tests/stress/file-tree-collapse-persistence.e2e.ts tests/stress/file-tree-fractional-zoom.e2e.ts tests/stress/create-then-rename-editable.e2e.ts tests/stress/find-replace.e2e.ts tests/stress/editor-tabs.e2e.ts tests/stress/crdt-stress.e2e.ts tests/stress/slash-command.e2e.ts tests/stress/paste-fidelity.e2e.ts tests/stress/fr-7a-disconnect-source-mode.e2e.ts tests/stress/docs-open.e2e.ts tests/stress/frozen-table-headers.e2e.ts tests/stress/asset-embed.e2e.ts tests/stress/asset-embed-advanced.e2e.ts tests/stress/asset-click-dispatch.e2e.ts tests/stress/handoff.e2e.ts tests/stress/multi-agent-presence.e2e.ts tests/stress/editor-mode-persistence.e2e.ts tests/stress/lint-config-toggle.e2e.ts tests/stress/plugin-enable-notice.e2e.ts tests/stress/schema-edit-fields-view.e2e.ts tests/stress/sidebar-search-pill.e2e.ts tests/stress/navigation-history.e2e.ts tests/stress/command-palette-semantic.e2e.ts tests/stress/agent-activity-panel.e2e.ts tests/stress/drop-pipeline-auto-open.e2e.ts tests/stress/command-palette-flicker.e2e.ts tests/stress/cm6-list-hanging-indent.e2e.ts tests/stress/ng7-rapid-nav-coherence.e2e.ts tests/stress/reveal-on-activate.e2e.ts tests/stress/selection-indicator.e2e.ts tests/stress/new-file-cross-doc-bleed.e2e.ts tests/stress/new-item-shortcut-fast-path.e2e.ts tests/stress/editor-mode-flip-cross-doc-bleed.e2e.ts tests/stress/editor-area-viewport-resize.e2e.ts tests/stress/qa-sidebar-responsive.e2e.ts tests/stress/prd-6955-reassertion-repro.e2e.ts tests/stress/prd-6955-reassertion-wedge.e2e.ts tests/stress/prd-6914-repro.e2e.ts tests/stress/showall-lazy-tree.e2e.ts tests/stress/tabs-component-strip.e2e.ts tests/stress/source-find-scroll.e2e.ts tests/stress/harness-app-warmth.e2e.ts tests/stress/qa-canary-authoring-both-modes.e2e.ts tests/stress/qa-canary-live-typing.e2e.ts tests/stress/keystroke-cadence-danger-space.e2e.ts tests/stress/jsx-unregistered-backspace-delete.e2e.ts tests/stress/jsx-unregistered-ime-concurrent.e2e.ts tests/stress/jsx-backspace-delete.e2e.ts tests/stress/link-authoring-bytes.e2e.ts tests/stress/link-authoring-apex.e2e.ts tests/stress/command-palette-parity.e2e.ts tests/stress/settings-search.e2e.ts tests/stress/okf-generated-index-settings.e2e.ts tests/stress/okf-recommended-skill-install.e2e.ts tests/stress/chip-popover-positioning.e2e.ts tests/stress/docs-open-scroll-restore.e2e.ts tests/stress/file-tree-decoration-chip-strip-repro.e2e.ts tests/stress/grip-click-nodeselect.e2e.ts tests/stress/jsx-halo-semantics.e2e.ts tests/stress/jsx-image-body-click.e2e.ts tests/stress/jsx-prop-panel-placeholder.e2e.ts tests/stress/jsx-range-encompass-halo.e2e.ts tests/stress/jsx-wildcard-convert.e2e.ts tests/stress/markdown-lint.e2e.ts tests/stress/frontmatter-schema-badge.e2e.ts tests/stress/frontmatter-glob-picker.e2e.ts tests/stress/unified-problems.e2e.ts tests/stress/mid-type-recovery.e2e.ts tests/stress/observer-a-multi-client.e2e.ts tests/stress/outline-toolbar-occlusion.e2e.ts tests/stress/selection-surface-pane-clip.e2e.ts tests/stress/quiet-tree-hidden-doc.e2e.ts tests/stress/raw-mdx-fallback-onblur-upgrade.e2e.ts tests/stress/rename-noext-probe.e2e.ts tests/stress/show-ok-folders.e2e.ts tests/stress/source-polish.e2e.ts tests/stress/warm-skeleton-scroll-restore.e2e.ts tests/stress/props-toggle-scroll-preserve.e2e.ts tests/stress/yjs-no-dual-import.e2e.ts tests/stress/graph-panel-surfaces.e2e.ts tests/stress/asset-embed-real-fidelity.e2e.ts tests/stress/image-invalid-placeholder.e2e.ts tests/stress/local-target-audit.e2e.ts tests/stress/rename-content-preservation.e2e.ts tests/stress/rename-consolidation.e2e.ts tests/stress/outline-active-heading.e2e.ts tests/stress/outline-navigation.e2e.ts tests/stress/prd-7627-default-swatch.e2e.ts tests/stress/clipboard-dollar-math-source-fallback.e2e.ts tests/stress/source-mode-undo-keymap.e2e.ts tests/stress/source-undo-mode-flip.e2e.ts tests/stress/timeline-recovered-restore.e2e.ts tests/stress/blank-line-preservation.e2e.ts tests/stress/landing-helpers.e2e.ts tests/stress/agent-follow-scroll.e2e.ts tests/stress/mode-switch-landing.e2e.ts tests/stress/mode-switch-ordinal-divergence.e2e.ts tests/stress/comment-annotation-visibility.e2e.ts tests/stress/comment-opens-in-panel.e2e.ts tests/stress/qa-miles-edge-blanks.e2e.ts tests/stress/prop-upload.e2e.ts tests/stress/slash-command-auto-open.e2e.ts tests/stress/clipboard-relative-url-source-fallback.e2e.ts tests/stress/editor-split-view.e2e.ts tests/stress/language-load-failure.e2e.ts tests/stress/language-first-paint.e2e.ts tests/stress/user-text-direction.e2e.ts tests/stress/pseudolocale.e2e.ts tests/stress/language-picker.e2e.ts tests/stress/zh-hans-coverage-sweep.e2e.ts tests/stress/preview-tab-promotion.e2e.ts tests/stress/cv-paint-lock-click.e2e.ts tests/stress/cv-auto-paint-lock-click.e2e.ts tests/stress/history-traversal-preview-tab.e2e.ts tests/stress/tab-close-scroll-restore.e2e.ts tests/stress/skills-sidebar-open.e2e.ts tests/stress/trailing-affordance.e2e.ts tests/stress/text-doc-composer-inset.e2e.ts tests/stress/composer-control-alignment.e2e.ts tests/stress/agents-settings-accessible-names.e2e.ts tests/stress/composer-growth-eof-reveal.e2e.ts tests/stress/theme-fade.e2e.ts tests/stress/theme-color-conversion.e2e.ts tests/stress/composer-open-caret-reveal.e2e.ts tests/stress/spellcheck-browser-absence.e2e.ts tests/stress/agents-panel-reload-visibility.e2e.ts tests/stress/rail-flex-distribution-law.e2e.ts tests/stress/audit-409-console-record.e2e.ts tests/stress/pagelist-refresh-lifetime.e2e.ts",
"test:e2e:install-browsers": "playwright install chromium webkit firefox",
"test:visual": "playwright test --config playwright.visual.config.ts",
"test:visual:update": "playwright test --config playwright.visual.config.ts --update-snapshots",
diff --git a/packages/app/src/components/PageListContext.teardown-reporting.dom.test.tsx b/packages/app/src/components/PageListContext.teardown-reporting.dom.test.tsx
new file mode 100644
index 000000000..514261f27
--- /dev/null
+++ b/packages/app/src/components/PageListContext.teardown-reporting.dom.test.tsx
@@ -0,0 +1,495 @@
+import { act, cleanup, render, screen, waitFor } from '@testing-library/react';
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
+import { __resetDocumentListInflightForTests } from '@/lib/documents-fetch';
+
+vi.doMock('@/lib/documents-events', () => ({
+ subscribeToDocumentsChanged: () => () => {},
+}));
+
+vi.doMock('@/editor/page-list-cache', () => ({
+ buildPageIconsIndex: () => new Map<string, string>(),
+ buildPagesBySlugIndex: () => new Map<string, string>(),
+ buildPagesByBasenameIndex: () => new Map<string, string>(),
+ setPageListCache: () => {},
+}));
+
+const LOAD_PAGES_FAILURE = '[PageListContext] Failed to load pages:';
+const LOAD_ASSETS_FAILURE = '[PageListContext] Failed to load referenced assets:';
+
+interface Deferred {
+ resolve: (response: Response) => void;
+ reject: (cause: unknown) => void;
+}
+
+interface DocumentListEntry {
+ kind: 'document' | 'asset' | 'folder' | 'file';
+ path?: string;
+}
+
+let pageRequests: Deferred[] = [];
+let documentRequests: Deferred[] = [];
+let originalFetch: typeof globalThis.fetch;
+let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
+let consoleWarnSpy: ReturnType<typeof vi.spyOn>;
+
+function jsonRes(body: unknown) {
+ return { ok: true, status: 200, json: async () => body } as Response;
+}
+
+function unreadableBodyRes() {
+ return {
+ ok: true,
+ status: 200,
+ json: async () => {
+ throw new SyntaxError('Unexpected end of JSON input');
+ },
+ } as Response;
+}
+
+function errorRes(status: number, body: unknown) {
+ return { ok: false, status, json: async () => body } as Response;
+}
+
+function pagesBody(docNames: readonly string[]) {
+ return {
+ pages: docNames.map((docName) => ({
+ docName,
+ title: docName,
+ size: 1,
+ modified: '2026-01-01T00:00:00.000Z',
+ })),
+ };
+}
+
+function loadPagesFailures(): unknown[][] {
+ return consoleErrorSpy.mock.calls.filter((call) => call[0] === LOAD_PAGES_FAILURE);
+}
+
+function loadAssetsFailures(): unknown[][] {
+ return consoleWarnSpy.mock.calls.filter((call) => call[0] === LOAD_ASSETS_FAILURE);
+}
+
+async function takeRound(): Promise<{ pages: Deferred; documents: Deferred }> {
+ await waitFor(() => {
+ expect(pageRequests.length).toBeGreaterThan(0);
+ expect(documentRequests.length).toBeGreaterThan(0);
+ });
+ const pages = pageRequests.shift();
+ const documents = documentRequests.shift();
+ if (!pages || !documents) throw new Error('takeRound: no in-flight request pair');
+ return { pages, documents };
+}
+
+async function flush(run: () => void) {
+ await act(async () => {
+ run();
+ await Promise.resolve();
+ await Promise.resolve();
+ });
+}
+
+const SEEDED_DOCUMENTS: DocumentListEntry[] = [
+ { kind: 'asset', path: 'images/diagram.png' },
+ { kind: 'folder', path: 'archive' },
+ { kind: 'file', path: 'notes/todo.txt' },
+];
+
+async function seedKnownPaths() {
+ const first = await takeRound();
+ await flush(() => {
+ first.pages.resolve(jsonRes(pagesBody(['Alpha'])));
+ first.documents.resolve(jsonRes({ documents: SEEDED_DOCUMENTS }));
+ });
+ await waitFor(() => {
+ expect(screen.getByTestId('assets').textContent).toBe('images/diagram.png');
+ });
+ expect(screen.getByTestId('folders').textContent).toBe('archive');
+ expect(screen.getByTestId('files').textContent).toBe('notes/todo.txt');
+}
+
+function expectKnownPathsCleared() {
+ expect(screen.getByTestId('assets').textContent).toBe('');
+ expect(screen.getByTestId('folders').textContent).toBe('');
+ expect(screen.getByTestId('files').textContent).toBe('');
+}
+
+function expectKnownPathsIntact() {
+ expect(screen.getByTestId('assets').textContent).toBe('images/diagram.png');
+ expect(screen.getByTestId('folders').textContent).toBe('archive');
+ expect(screen.getByTestId('files').textContent).toBe('notes/todo.txt');
+}
+
+async function issueNextRound() {
+ await flush(() => {
+ window.dispatchEvent(new Event('focus'));
+ });
+ return takeRound();
+}
+
+beforeEach(() => {
+ pageRequests = [];
+ documentRequests = [];
+ __resetDocumentListInflightForTests();
+ consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+ consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+ originalFetch = globalThis.fetch;
+ globalThis.fetch = ((input: RequestInfo | URL) => {
+ const url = String(input);
+ const queue = url.includes('/api/pages')
+ ? pageRequests
+ : url.includes('/api/documents')
+ ? documentRequests
+ : null;
+ if (queue === null) return Promise.reject(new Error(`unexpected fetch: ${url}`));
+ return new Promise<Response>((resolve, reject) => {
+ queue.push({ resolve, reject });
+ });
+ }) as typeof globalThis.fetch;
+});
+
+afterEach(() => {
+ cleanup();
+ globalThis.fetch = originalFetch;
+ consoleErrorSpy.mockRestore();
+ consoleWarnSpy.mockRestore();
+ __resetDocumentListInflightForTests();
+});
+
+const { PageListProvider, usePageList } = await import('./PageListContext');
+
+function Probe() {
+ const { loading, error, pages, assetPaths, folderPaths, filePaths } = usePageList();
+ return (
+ <div>
+ <span data-testid="phase">{loading ? 'loading' : 'ready'}</span>
+ <span data-testid="error">{error ?? ''}</span>
+ <span data-testid="pages">{[...pages].sort().join(',')}</span>
+ <span data-testid="assets">{[...assetPaths].sort().join(',')}</span>
+ <span data-testid="folders">{[...folderPaths].sort().join(',')}</span>
+ <span data-testid="files">{[...filePaths].sort().join(',')}</span>
+ </div>
+ );
+}
+
+function renderProvider() {
+ render(
+ <PageListProvider>
+ <Probe />
+ </PageListProvider>,
+ );
+}
+
+describe('PageListProvider teardown reporting', () => {
+ test('a /api/pages failure on a live document reaches the error log and the error state', async () => {
+ renderProvider();
+ const round = await takeRound();
+
+ await flush(() => {
+ round.pages.reject(new TypeError('Failed to fetch'));
+ round.documents.resolve(jsonRes({ documents: [] }));
+ });
+
+ await waitFor(() => {
+ expect(screen.getByTestId('error').textContent).toBe('Failed to fetch');
+ });
+ expect(loadPagesFailures()).toHaveLength(1);
+ });
+
+ test('a /api/pages failure that follows a non-bfcache pagehide reaches neither', async () => {
+ renderProvider();
+ const round = await takeRound();
+
+ await flush(() => {
+ window.dispatchEvent(new PageTransitionEvent('pagehide', { persisted: false }));
+ round.pages.reject(new TypeError('Failed to fetch'));
+ round.documents.resolve(jsonRes({ documents: [] }));
+ });
+
+ await waitFor(() => {
+ expect(screen.getByTestId('phase').textContent).toBe('ready');
+ });
+ expect(screen.getByTestId('error').textContent).toBe('');
+ expect(loadPagesFailures()).toEqual([]);
+ });
+
+ test('a refresh issued after the pagehide latched is still reported when it fails', async () => {
+ renderProvider();
+ const first = await takeRound();
+ await flush(() => {
+ first.pages.resolve(jsonRes(pagesBody(['Alpha'])));
+ first.documents.resolve(jsonRes({ documents: [] }));
+ });
+ await waitFor(() => {
+ expect(screen.getByTestId('phase').textContent).toBe('ready');
+ });
+
+ await flush(() => {
+ window.dispatchEvent(new PageTransitionEvent('pagehide', { persisted: false }));
+ window.dispatchEvent(new Event('focus'));
+ });
+
+ const second = await takeRound();
+ await flush(() => {
+ second.pages.reject(new TypeError('Failed to fetch'));
+ second.documents.resolve(jsonRes({ documents: [] }));
+ });
+
+ await waitFor(() => {
+ expect(screen.getByTestId('error').textContent).toBe('Failed to fetch');
+ });
+ expect(loadPagesFailures()).toHaveLength(1);
+ });
+
+ test('a trailing refresh the scheduler queued while the document was live is not reported when teardown kills it', async () => {
+ renderProvider();
+ const first = await takeRound();
+
+ await flush(() => {
+ window.dispatchEvent(new Event('focus'));
+ });
+
+ await flush(() => {
+ window.dispatchEvent(new PageTransitionEvent('pagehide', { persisted: false }));
+ first.pages.reject(new TypeError('Failed to fetch'));
+ first.documents.resolve(jsonRes({ documents: [] }));
+ });
+
+ const trailing = await takeRound();
+ await flush(() => {
+ trailing.pages.reject(new TypeError('Failed to fetch'));
+ trailing.documents.resolve(jsonRes({ documents: [] }));
+ });
+
+ await waitFor(() => {
+ expect(screen.getByTestId('phase').textContent).toBe('ready');
+ });
+ expect(screen.getByTestId('error').textContent).toBe('');
+ expect(loadPagesFailures()).toEqual([]);
+ });
+
+ test('a trailing refresh the scheduler queued after the pagehide latched is still reported when it fails', async () => {
+ renderProvider();
+ const first = await takeRound();
+
+ await flush(() => {
+ window.dispatchEvent(new PageTransitionEvent('pagehide', { persisted: false }));
+ window.dispatchEvent(new Event('focus'));
+ });
+
+ await flush(() => {
+ first.pages.reject(new TypeError('Failed to fetch'));
+ first.documents.resolve(jsonRes({ documents: [] }));
+ });
+
+ const trailing = await takeRound();
+ await flush(() => {
+ trailing.pages.reject(new TypeError('Failed to fetch'));
+ trailing.documents.resolve(jsonRes({ documents: [] }));
+ });
+
+ await waitFor(() => {
+ expect(screen.getByTestId('error').textContent).toBe('Failed to fetch');
+ });
+ expect(loadPagesFailures()).toHaveLength(1);
+ });
+
+ test('a trailing refresh queued while live is reported when the document comes back before it fails', async () => {
+ renderProvider();
+ const first = await takeRound();
+
+ await flush(() => {
+ window.dispatchEvent(new Event('focus'));
+ });
+
+ await flush(() => {
+ window.dispatchEvent(new PageTransitionEvent('pagehide', { persisted: false }));
+ first.pages.resolve(jsonRes(pagesBody(['Alpha'])));
+ first.documents.resolve(jsonRes({ documents: [] }));
+ });
+
+ const trailing = await takeRound();
+ await flush(() => {
+ window.dispatchEvent(new PageTransitionEvent('pageshow', { persisted: true }));
+ trailing.pages.reject(new TypeError('Failed to fetch'));
+ trailing.documents.resolve(jsonRes({ documents: [] }));
+ });
+
+ await waitFor(() => {
+ expect(screen.getByTestId('error').textContent).toBe('Failed to fetch');
+ });
+ expect(loadPagesFailures()).toHaveLength(1);
+ });
+
+ test('a refresh issued while live after an earlier latched ask was consumed is not reported when teardown kills it', async () => {
+ renderProvider();
+ const first = await takeRound();
+ await flush(() => {
+ first.pages.resolve(jsonRes(pagesBody(['Alpha'])));
+ first.documents.resolve(jsonRes({ documents: [] }));
+ });
+ await waitFor(() => {
+ expect(screen.getByTestId('phase').textContent).toBe('ready');
+ });
+
+ await flush(() => {
+ window.dispatchEvent(new PageTransitionEvent('pagehide', { persisted: false }));
+ window.dispatchEvent(new Event('focus'));
+ });
+
+ const latched = await takeRound();
+ await flush(() => {
+ latched.pages.resolve(jsonRes(pagesBody(['Alpha', 'Beta'])));
+ latched.documents.resolve(jsonRes({ documents: [] }));
+ });
+ await waitFor(() => {
+ expect(screen.getByTestId('pages').textContent).toBe('Alpha,Beta');
+ });
+
+ await flush(() => {
+ window.dispatchEvent(new PageTransitionEvent('pageshow', { persisted: true }));
+ window.dispatchEvent(new Event('focus'));
+ });
+
+ const revived = await takeRound();
+ await flush(() => {
+ window.dispatchEvent(new PageTransitionEvent('pagehide', { persisted: false }));
+ revived.pages.reject(new TypeError('Failed to fetch'));
+ revived.documents.resolve(jsonRes({ documents: [] }));
+ });
+
+ await waitFor(() => {
+ expect(screen.getByTestId('phase').textContent).toBe('ready');
+ });
+ expect(screen.getByTestId('error').textContent).toBe('');
+ expect(loadPagesFailures()).toEqual([]);
+ });
+
+ test('a throw raised while applying a fetched page list during teardown is still reported', async () => {
+ renderProvider();
+ const round = await takeRound();
+
+ await flush(() => {
+ window.dispatchEvent(new PageTransitionEvent('pagehide', { persisted: false }));
+ round.pages.resolve(jsonRes({ pages: [null] }));
+ round.documents.resolve(jsonRes({ documents: [] }));
+ });
+
+ await waitFor(() => {
+ expect(loadPagesFailures()).toHaveLength(1);
+ });
+ });
+
+ test('a failed referenced-assets refresh on a live document reports and clears the known paths', async () => {
+ renderProvider();
+ await seedKnownPaths();
+
+ const second = await issueNextRound();
+ await flush(() => {
+ second.pages.resolve(jsonRes(pagesBody(['Alpha', 'Beta'])));
+ second.documents.reject(new TypeError('Failed to fetch'));
+ });
+
+ await waitFor(() => {
+ expect(loadAssetsFailures()).toHaveLength(1);
+ });
+ expectKnownPathsCleared();
+ });
+
+ test('an unusable /api/documents payload on a live document reports and clears the known paths', async () => {
+ renderProvider();
+ await seedKnownPaths();
+
+ const second = await issueNextRound();
+ await flush(() => {
+ second.pages.resolve(jsonRes(pagesBody(['Alpha', 'Beta'])));
+ second.documents.resolve(unreadableBodyRes());
+ });
+
+ await waitFor(() => {
+ expect(loadAssetsFailures()).toHaveLength(1);
+ });
+ expectKnownPathsCleared();
+ });
+
+ test('an unusable /api/documents payload during teardown preserves the known paths and the provider reports nothing', async () => {
+ renderProvider();
+ await seedKnownPaths();
+
+ const second = await issueNextRound();
+ await flush(() => {
+ window.dispatchEvent(new PageTransitionEvent('pagehide', { persisted: false }));
+ second.pages.resolve(jsonRes(pagesBody(['Alpha', 'Beta'])));
+ second.documents.resolve(unreadableBodyRes());
+ });
+
+ await waitFor(() => {
+ expect(screen.getByTestId('pages').textContent).toBe('Alpha,Beta');
+ });
+ expectKnownPathsIntact();
+ expect(loadAssetsFailures()).toEqual([]);
+ });
+
+ test('a non-ok /api/pages status on a live document reaches the error log and the error state', async () => {
+ renderProvider();
+ const round = await takeRound();
+
+ await flush(() => {
+ round.pages.resolve(errorRes(503, { title: 'page list unavailable' }));
+ round.documents.resolve(jsonRes({ documents: [] }));
+ });
+
+ await waitFor(() => {
+ expect(screen.getByTestId('error').textContent).toBe('page list unavailable');
+ });
+ expect(loadPagesFailures()).toHaveLength(1);
+ });
+
+ test('a non-ok /api/pages status that follows a non-bfcache pagehide reaches neither', async () => {
+ renderProvider();
+ const round = await takeRound();
+
+ await flush(() => {
+ window.dispatchEvent(new PageTransitionEvent('pagehide', { persisted: false }));
+ round.pages.resolve(errorRes(503, { title: 'page list unavailable' }));
+ round.documents.resolve(jsonRes({ documents: [] }));
+ });
+
+ await waitFor(() => {
+ expect(screen.getByTestId('phase').textContent).toBe('ready');
+ });
+ expect(screen.getByTestId('error').textContent).toBe('');
+ expect(loadPagesFailures()).toEqual([]);
+ });
+
+ test('an unreadable /api/pages body on a live document reaches the error log and the error state', async () => {
+ renderProvider();
+ const round = await takeRound();
+
+ await flush(() => {
+ round.pages.resolve(unreadableBodyRes());
+ round.documents.resolve(jsonRes({ documents: [] }));
+ });
+
+ await waitFor(() => {
+ expect(screen.getByTestId('error').textContent).toBe('Unexpected end of JSON input');
+ });
+ expect(loadPagesFailures()).toHaveLength(1);
+ });
+
+ test('an unreadable /api/pages body that follows a non-bfcache pagehide reaches neither', async () => {
+ renderProvider();
+ const round = await takeRound();
+
+ await flush(() => {
+ window.dispatchEvent(new PageTransitionEvent('pagehide', { persisted: false }));
+ round.pages.resolve(unreadableBodyRes());
+ round.documents.resolve(jsonRes({ documents: [] }));
+ });
+
+ await waitFor(() => {
+ expect(screen.getByTestId('phase').textContent).toBe('ready');
+ });
+ expect(screen.getByTestId('error').textContent).toBe('');
+ expect(loadPagesFailures()).toEqual([]);
+ });
+});
diff --git a/packages/app/src/components/PageListContext.tsx b/packages/app/src/components/PageListContext.tsx
index 53deae3a5..ad67b2777 100644
--- a/packages/app/src/components/PageListContext.tsx
+++ b/packages/app/src/components/PageListContext.tsx
@@ -9,6 +9,10 @@ import {
} from '@/editor/page-list-cache';
import { subscribeToDocumentsChanged } from '@/lib/documents-events';
import { fetchDocumentListShared } from '@/lib/documents-fetch';
+import {
+ type DocumentTeardownObserver,
+ installDocumentTeardownObserver,
+} from '@/lib/install-document-teardown-observer';
import { parseApiError } from '@/lib/parse-api-error';
import { pageListReady } from '@/lib/perf/startup-marks';
import { createRefreshScheduler } from '@/lib/refresh-scheduler';
@@ -112,7 +116,9 @@ async function loadDocumentListSummary(): Promise<{
throw new Error(parseApiError(body) ?? `/api/documents responded with ${status}`);
}
const data = (body ?? {}) as { documents?: DocumentListEntry[] };
- if (!Array.isArray(data.documents)) return { assetPaths: [], folderPaths: [], filePaths: [] };
+ if (!Array.isArray(data.documents)) {
+ throw new Error(parseApiError(body) ?? '/api/documents returned no usable documents field');
+ }
const assetPaths = data.documents
.filter((entry): entry is DocumentListEntry & { kind: 'asset'; path: string } => {
return entry.kind === 'asset' && typeof entry.path === 'string' && entry.path.length > 0;
@@ -150,18 +156,26 @@ export function PageListProvider({ children }: { children: ReactNode }) {
const [loading, setLoading] = useState(true);
const [error, setError] = useState<string | null>(null);
const latestRequestIdRef = useRef(0);
+ const documentTeardownRef = useRef<DocumentTeardownObserver | null>(null);
- function refetch() {
+ function runRefresh(issuedWhileLive: boolean) {
const requestId = ++latestRequestIdRef.current;
+ const abandonedByTeardown = () =>
+ issuedWhileLive && documentTeardownRef.current?.isUnloading() === true;
return Promise.all([
- loadPages(),
- loadDocumentListSummary().catch((err) => {
+ loadPages().catch((err: unknown) => {
+ if (abandonedByTeardown()) return null;
+ throw err;
+ }),
+ loadDocumentListSummary().catch((err: unknown) => {
+ if (abandonedByTeardown()) return null;
logLoadAssetsError(err);
return { assetPaths: [], folderPaths: [], filePaths: [] };
}),
])
.then(([pageSummaries, documentList]) => {
if (requestId !== latestRequestIdRef.current) return;
+ if (pageSummaries === null) return;
const pageNames = new Set(pageSummaries.map((page) => page.docName));
setServerPages(pageNames);
setServerPageTitles(
@@ -183,9 +197,11 @@ export function PageListProvider({ children }: { children: ReactNode }) {
),
),
);
- setServerAssetPaths(new Set(documentList.assetPaths));
- setServerFolderPaths(new Set(documentList.folderPaths));
- setServerFilePaths(new Set(documentList.filePaths));
+ if (documentList !== null) {
+ setServerAssetPaths(new Set(documentList.assetPaths));
+ setServerFolderPaths(new Set(documentList.folderPaths));
+ setServerFilePaths(new Set(documentList.filePaths));
+ }
setOptimisticPages((prev) => pruneConfirmedOptimisticPages(prev, pageNames));
setError(null);
pageListReady();
@@ -201,6 +217,10 @@ export function PageListProvider({ children }: { children: ReactNode }) {
});
}
+ function refetch() {
+ return runRefresh(documentTeardownRef.current?.isUnloading() !== true);
+ }
+
function addPage(docName: string) {
setOptimisticPages((prev) => {
if (prev.has(docName)) return prev;
@@ -213,12 +233,22 @@ export function PageListProvider({ children }: { children: ReactNode }) {
// biome-ignore lint/correctness/useExhaustiveDependencies: run only on mount
useEffect(() => {
- const scheduler = createRefreshScheduler(refetch);
- scheduler.request();
+ documentTeardownRef.current = installDocumentTeardownObserver();
+ let requestedWhileLive = true;
+ const scheduler = createRefreshScheduler(() => {
+ const issuedWhileLive = requestedWhileLive;
+ requestedWhileLive = true;
+ return runRefresh(issuedWhileLive);
+ });
+ const requestRefresh = () => {
+ if (documentTeardownRef.current?.isUnloading() === true) requestedWhileLive = false;
+ scheduler.request();
+ };
+ requestRefresh();
let pushFlushTimer: ReturnType<typeof setTimeout> | null = null;
const handleResume = () => {
if (document.visibilityState === 'visible') {
- scheduler.request();
+ requestRefresh();
}
};
window.addEventListener('focus', handleResume);
@@ -228,7 +258,7 @@ export function PageListProvider({ children }: { children: ReactNode }) {
if (pushFlushTimer !== null) return;
pushFlushTimer = setTimeout(() => {
pushFlushTimer = null;
- scheduler.request();
+ requestRefresh();
}, PUSH_REFRESH_COALESCE_MS);
});
return () => {
@@ -237,6 +267,8 @@ export function PageListProvider({ children }: { children: ReactNode }) {
window.removeEventListener('focus', handleResume);
window.removeEventListener('visibilitychange', handleResume);
unsubscribe();
+ documentTeardownRef.current?.uninstall();
+ documentTeardownRef.current = null;
};
}, []);
diff --git a/packages/app/src/lib/install-document-teardown-observer.test.ts b/packages/app/src/lib/install-document-teardown-observer.test.ts
new file mode 100644
index 000000000..efd5288bc
--- /dev/null
+++ b/packages/app/src/lib/install-document-teardown-observer.test.ts
@@ -0,0 +1,144 @@
+import { describe, expect, it } from 'vitest';
+import { installDocumentTeardownObserver } from './install-document-teardown-observer';
+
+type Listener = (event: Event) => void;
+
+function makeFakeTarget() {
+ const listeners = new Map<string, Listener>();
+ return {
+ addEventListener(type: string, listener: Listener) {
+ listeners.set(type, listener);
+ },
+ removeEventListener(type: string) {
+ listeners.delete(type);
+ },
+ emit(type: string, props: Record<string, unknown> = {}) {
+ listeners.get(type)?.(Object.assign(new Event(type), props));
+ },
+ };
+}
+
+function makeFakeDoc(visibilityState: DocumentVisibilityState) {
+ const target = makeFakeTarget();
+ return Object.assign(target, {
+ visibilityState,
+ setVisibility(v: DocumentVisibilityState) {
+ (this as { visibilityState: DocumentVisibilityState }).visibilityState = v;
+ },
+ });
+}
+
+function makeObserver(initialVisibility: DocumentVisibilityState = 'visible') {
+ const win = makeFakeTarget();
+ const doc = makeFakeDoc(initialVisibility);
+ return { win, doc, observer: installDocumentTeardownObserver({ win, doc }) };
+}
+
+describe('installDocumentTeardownObserver', () => {
+ it('reports unloading once a pagehide announces the document will be destroyed', () => {
+ const { win, observer } = makeObserver();
+ expect(observer.isUnloading()).toBe(false);
+
+ win.emit('pagehide', { persisted: false });
+
+ expect(observer.isUnloading()).toBe(true);
+ });
+
+ it('does not report unloading for a pagehide that retains the document in the back/forward cache', () => {
+ const { win, observer } = makeObserver();
+
+ win.emit('pagehide', { persisted: true });
+
+ expect(observer.isUnloading()).toBe(false);
+
+ win.emit('pagehide', { persisted: false });
+
+ expect(observer.isUnloading()).toBe(true);
+ });
+
+ it('does not report unloading for a pagehide that carries no persisted flag', () => {
+ const { win, observer } = makeObserver();
+
+ win.emit('pagehide');
+
+ expect(observer.isUnloading()).toBe(false);
+
+ win.emit('pagehide', { persisted: false });
+
+ expect(observer.isUnloading()).toBe(true);
+ });
+
+ it('does not report unloading when the tab is merely switched away from', () => {
+ const { win, doc, observer } = makeObserver();
+
+ doc.setVisibility('hidden');
+ doc.emit('visibilitychange');
+
+ expect(observer.isUnloading()).toBe(false);
+
+ win.emit('pagehide', { persisted: false });
+
+ expect(observer.isUnloading()).toBe(true);
+
+ doc.setVisibility('visible');
+ doc.emit('visibilitychange');
+
+ expect(observer.isUnloading()).toBe(false);
+ });
+
+ it('keeps reporting unloading through the hidden visibilitychange that unload fires after pagehide', () => {
+ const { win, doc, observer } = makeObserver();
+
+ win.emit('pagehide', { persisted: false });
+ expect(observer.isUnloading()).toBe(true);
+
+ doc.setVisibility('hidden');
+ doc.emit('visibilitychange');
+
+ expect(observer.isUnloading()).toBe(true);
+ });
+
+ it('stops reporting unloading once a restored document announces pageshow', () => {
+ const { win, observer } = makeObserver();
+ win.emit('pagehide', { persisted: false });
+ expect(observer.isUnloading()).toBe(true);
+
+ win.emit('pageshow');
+
+ expect(observer.isUnloading()).toBe(false);
+ });
+
+ it('ignores a pagehide delivered after uninstall', () => {
+ const { win, observer } = makeObserver();
+ win.emit('pagehide', { persisted: false });
+ expect(observer.isUnloading()).toBe(true);
+ win.emit('pageshow');
+ expect(observer.isUnloading()).toBe(false);
+
+ observer.uninstall();
+ win.emit('pagehide', { persisted: false });
+
+ expect(observer.isUnloading()).toBe(false);
+ });
+
+ it('ignores the restore signals delivered after uninstall', () => {
+ const { win, doc, observer } = makeObserver();
+ win.emit('pagehide', { persisted: false });
+ expect(observer.isUnloading()).toBe(true);
+
+ observer.uninstall();
+ win.emit('pageshow');
+ doc.setVisibility('visible');
+ doc.emit('visibilitychange');
+
+ expect(observer.isUnloading()).toBe(true);
+ });
+
+ it('never reports unloading when there is no document to observe', () => {
+ const observer = installDocumentTeardownObserver();
+
+ expect(observer.isUnloading()).toBe(false);
+ expect(() => observer.uninstall()).not.toThrow();
+ expect(observer.isUnloading()).toBe(false);
+ });
+});
diff --git a/packages/app/src/lib/install-document-teardown-observer.ts b/packages/app/src/lib/install-document-teardown-observer.ts
new file mode 100644
index 000000000..aa4341e49
--- /dev/null
+++ b/packages/app/src/lib/install-document-teardown-observer.ts
@@ -0,0 +1,45 @@
+export interface DocumentTeardownDeps {
+ win?: Pick<Window, 'addEventListener' | 'removeEventListener'>;
+ doc?: Pick<Document, 'addEventListener' | 'removeEventListener'> & {
+ readonly visibilityState: DocumentVisibilityState;
+ };
+}
+
+export interface DocumentTeardownObserver {
+ isUnloading: () => boolean;
+ uninstall: () => void;
+}
+
+export function installDocumentTeardownObserver(
+ deps: DocumentTeardownDeps = {},
+): DocumentTeardownObserver {
+ const win = deps.win ?? (typeof window !== 'undefined' ? window : undefined);
+ const doc = deps.doc ?? (typeof document !== 'undefined' ? document : undefined);
+ if (win === undefined || doc === undefined) {
+ return { isUnloading: () => false, uninstall: () => {} };
+ }
+
+ let unloading = false;
+ const onPageHide = (event: PageTransitionEvent): void => {
+ if (event.persisted === false) unloading = true;
+ };
+ const onPageShow = (): void => {
+ unloading = false;
+ };
+ const onVisibility = (): void => {
+ if (doc.visibilityState === 'visible') unloading = false;
+ };
+
+ win.addEventListener('pagehide', onPageHide);
+ win.addEventListener('pageshow', onPageShow);
+ doc.addEventListener('visibilitychange', onVisibility);
+
+ return {
+ isUnloading: () => unloading,
+ uninstall() {
+ win.removeEventListener('pagehide', onPageHide);
+ win.removeEventListener('pageshow', onPageShow);
+ doc.removeEventListener('visibilitychange', onVisibility);
+ },
+ };
+}
diff --git a/packages/app/tests/stress/pagelist-refresh-lifetime.e2e.ts b/packages/app/tests/stress/pagelist-refresh-lifetime.e2e.ts
new file mode 100644
index 000000000..9b745fafa
--- /dev/null
+++ b/packages/app/tests/stress/pagelist-refresh-lifetime.e2e.ts
@@ -0,0 +1,354 @@
+import { randomUUID } from 'node:crypto';
+import type { Page } from '@playwright/test';
+import {
+ type ApiHelpers,
+ expect,
+ type LogEntry,
+ test,
+ waitForActiveProviderSynced as waitForProvider,
+} from './_helpers';
+
+const PAGES_ROUTE = '**/api/pages';
+const PAGES_PATH = '/api/pages';
+const LOAD_PAGES_FAILURE = '[PageListContext] Failed to load pages';
+const SETTLE_TIMEOUT_MS = 20_000;
+const HOLD_LIVENESS_CEILING_MS = 15_000;
+const PROVIDER_SYNC_BUDGET_MS = 60_000;
+const PROVIDER_SYNC_WAITS_PER_ABANDONMENT_TEST = 2;
+const ABANDONMENT_TEST_TIMEOUT_MS =
+ 4 * SETTLE_TIMEOUT_MS +
+ HOLD_LIVENESS_CEILING_MS +
+ PROVIDER_SYNC_WAITS_PER_ABANDONMENT_TEST * PROVIDER_SYNC_BUDGET_MS;
+const SERVICE_UNAVAILABLE = 503;
+const OK_STATUS = 200;
+const DOCUMENTS_ROUTE = '**/api/documents';
+const DOCUMENTS_PATH = '/api/documents';
+const LOAD_ASSETS_FAILURE = '[PageListContext] Failed to load referenced assets';
+const WARN_CONSOLE_TYPES = new Set(['warning', 'warn']);
+
+interface ServedPageListsView {
+ readonly pagesResponseStatuses: number[];
+}
+
+interface ProviderProbe {
+ readonly consoleErrors: LogEntry[];
+ readonly pagesResponseStatuses: number[];
+}
+
+interface AssetsProbe extends ServedPageListsView {
+ readonly consoleWarnings: LogEntry[];
+ readonly documentsResponseStatuses: number[];
+}
+
+// STOP: key every assertion here on console message TEXT, never on filterCriticalErrors or location().url — Vite 8 auto-enables server.forwardConsole under an agent harness (AI_AGENT / CLAUDECODE / CURSOR_* / CODEX_*) and re-attributes every console url to /@vite/client, which _helpers/error-filters.ts classifies as benign for load-failure text, so a url-keyed or guard-keyed assertion passes on unfixed code.
+function attachProviderProbe(page: Page): ProviderProbe {
+ const consoleErrors: LogEntry[] = [];
+ const pagesResponseStatuses: number[] = [];
+ page.on('pageerror', (err) => consoleErrors.push({ type: 'uncaught', text: err.message }));
+ page.on('console', (msg) => {
+ if (msg.type() !== 'error') return;
+ const location = msg.location();
+ consoleErrors.push({
+ type: 'error',
+ text: msg.text(),
+ url: location.url,
+ line: location.lineNumber,
+ });
+ });
+ page.on('response', (response) => {
+ if (URL.parse(response.url())?.pathname === PAGES_PATH) {
+ pagesResponseStatuses.push(response.status());
+ }
+ });
+ return { consoleErrors, pagesResponseStatuses };
+}
+
+function attachAssetsProbe(page: Page): AssetsProbe {
+ const consoleWarnings: LogEntry[] = [];
+ const pagesResponseStatuses: number[] = [];
+ const documentsResponseStatuses: number[] = [];
+ page.on('console', (msg) => {
+ if (!WARN_CONSOLE_TYPES.has(msg.type())) return;
+ const location = msg.location();
+ consoleWarnings.push({
+ type: msg.type(),
+ text: msg.text(),
+ url: location.url,
+ line: location.lineNumber,
+ });
+ });
+ page.on('response', (response) => {
+ const pathname = URL.parse(response.url())?.pathname;
+ if (pathname === PAGES_PATH) pagesResponseStatuses.push(response.status());
+ if (pathname === DOCUMENTS_PATH) documentsResponseStatuses.push(response.status());
+ });
+ return { consoleWarnings, pagesResponseStatuses, documentsResponseStatuses };
+}
+
+function loadPagesFailures(probe: ProviderProbe): LogEntry[] {
+ return probe.consoleErrors.filter((entry) => entry.text.includes(LOAD_PAGES_FAILURE));
+}
+
+function loadAssetsFailures(probe: AssetsProbe): LogEntry[] {
+ return probe.consoleWarnings.filter((entry) => entry.text.includes(LOAD_ASSETS_FAILURE));
+}
+
+function servedPageListsSince(probe: ServedPageListsView, mark: number): number {
+ return probe.pagesResponseStatuses.slice(mark).filter((status) => status === OK_STATUS).length;
+}
+
+function servedDocumentListsSince(probe: AssetsProbe, mark: number): number {
+ return probe.documentsResponseStatuses.slice(mark).filter((status) => status === OK_STATUS)
+ .length;
+}
+
+async function openScratchDocument(page: Page, api: ApiHelpers, suffix: string): Promise<void> {
+ await api.createPage(`plr-${suffix}.md`);
+ await page.goto(`/#/plr-${suffix}`);
+ await waitForProvider(page);
+ await page.waitForSelector('.ProseMirror:not(.composer-prosemirror)');
+}
+
+async function pushAndAwaitServedPageList(
+ probe: ServedPageListsView,
+ api: ApiHelpers,
+ path: string,
+ message: string,
+): Promise<void> {
+ const mark = probe.pagesResponseStatuses.length;
+ await api.createPage(path);
+ await expect
+ .poll(() => servedPageListsSince(probe, mark), { message, timeout: SETTLE_TIMEOUT_MS })
+ .toBeGreaterThan(0);
+}
+
+test.describe('PageListProvider refresh lifetime', () => {
+ test('a document navigation that abandons an in-flight push-refresh is not reported as a failed /api/pages request', async ({
+ page,
+ api,
+ }) => {
+ test.setTimeout(ABANDONMENT_TEST_TIMEOUT_MS);
+
+ const probe = attachProviderProbe(page);
+ const suffix = randomUUID().slice(0, 8);
+ await openScratchDocument(page, api, suffix);
+
+ let handlerEntries = 0;
+ let releaseHeldRequests: () => void = () => undefined;
+ const held = new Promise<void>((resolve) => {
+ releaseHeldRequests = resolve;
+ });
+ await page.route(PAGES_ROUTE, async (route) => {
+ handlerEntries += 1;
+ await Promise.race([
+ held,
+ new Promise<void>((resolve) => {
+ setTimeout(resolve, HOLD_LIVENESS_CEILING_MS);
+ }),
+ ]);
+ await route.continue().catch(() => undefined);
+ });
+
+ try {
+ await api.createPage(`plr-push-${suffix}.md`);
+ await expect
+ .poll(() => handlerEntries, {
+ message:
+ 'the push-refresh /api/pages request must reach the route handler, so the navigation below has a genuinely in-flight request to abandon',
+ timeout: SETTLE_TIMEOUT_MS,
+ })
+ .toBeGreaterThan(0);
+ expect(
+ loadPagesFailures(probe),
+ 'the provider must be quiet before the navigation, so any failure reported afterwards is attributable to it',
+ ).toEqual([]);
+
+ await page.reload();
+ } finally {
+ releaseHeldRequests();
+ await page.unroute(PAGES_ROUTE);
+ }
+
+ await waitForProvider(page);
+ await page.waitForSelector('.ProseMirror:not(.composer-prosemirror)');
+ await pushAndAwaitServedPageList(
+ probe,
+ api,
+ `plr-after-${suffix}.md`,
+ 'the reloaded document must serve its own push-refresh, proving the provider is live again and the abandoned request has had its chance to settle',
+ );
+
+ expect(
+ loadPagesFailures(probe),
+ 'a push-refresh abandoned because its own document was torn down is not a failed request',
+ ).toEqual([]);
+ });
+
+ test('a genuine network failure of /api/pages on a live document is still reported', async ({
+ page,
+ api,
+ }) => {
+ const probe = attachProviderProbe(page);
+ const suffix = randomUUID().slice(0, 8);
+ await openScratchDocument(page, api, suffix);
+
+ await page.route(PAGES_ROUTE, (route) => route.abort('failed'));
+ await api.createPage(`plr-push-${suffix}.md`);
+
+ await expect
+ .poll(() => loadPagesFailures(probe).length, {
+ message: 'a network-level failure on a live document must still reach the error log',
+ timeout: SETTLE_TIMEOUT_MS,
+ })
+ .toBeGreaterThan(0);
+ const [firstFailure] = loadPagesFailures(probe);
+ expect(
+ firstFailure?.text,
+ 'a live network failure carries the same text a navigation-abandoned request carries, so message text can never be the discriminator',
+ ).toContain('TypeError: Failed to fetch');
+ });
+
+ test('a 5xx from /api/pages on a live document is still reported', async ({ page, api }) => {
+ const probe = attachProviderProbe(page);
+ const suffix = randomUUID().slice(0, 8);
+ await openScratchDocument(page, api, suffix);
+
+ await page.route(PAGES_ROUTE, (route) =>
+ route.fulfill({
+ status: SERVICE_UNAVAILABLE,
+ contentType: 'application/json',
+ body: '{}',
+ }),
+ );
+ await api.createPage(`plr-push-${suffix}.md`);
+
+ await expect
+ .poll(() => loadPagesFailures(probe).length, {
+ message: 'a server error on a live document must still reach the error log',
+ timeout: SETTLE_TIMEOUT_MS,
+ })
+ .toBeGreaterThan(0);
+ const [firstFailure] = loadPagesFailures(probe);
+ expect(
+ firstFailure?.text,
+ 'a served error status surfaces as its own message rather than as a fetch rejection',
+ ).toContain(`${PAGES_PATH} responded with ${SERVICE_UNAVAILABLE}`);
+ });
+
+ test('an undisturbed push-refresh on a live document reports nothing', async ({ page, api }) => {
+ const probe = attachProviderProbe(page);
+ const suffix = randomUUID().slice(0, 8);
+ await openScratchDocument(page, api, suffix);
+
+ await pushAndAwaitServedPageList(
+ probe,
+ api,
+ `plr-push-${suffix}.md`,
+ 'the push-refresh must actually serve a page list, so the absence asserted below is a measured quiet rather than an unexercised path',
+ );
+
+ expect(loadPagesFailures(probe), 'an undisturbed push-refresh must report nothing').toEqual([]);
+ });
+
+ test('a document navigation that abandons an in-flight referenced-assets refresh is not reported as a failed /api/documents request', async ({
+ page,
+ api,
+ }) => {
+ test.setTimeout(ABANDONMENT_TEST_TIMEOUT_MS);
+
+ const probe = attachAssetsProbe(page);
+ const suffix = randomUUID().slice(0, 8);
+ await openScratchDocument(page, api, suffix);
+
+ let handlerEntries = 0;
+ let releaseHeldRequests: () => void = () => undefined;
+ const held = new Promise<void>((resolve) => {
+ releaseHeldRequests = resolve;
+ });
+ await page.route(DOCUMENTS_ROUTE, async (route) => {
+ handlerEntries += 1;
+ await Promise.race([
+ held,
+ new Promise<void>((resolve) => {
+ setTimeout(resolve, HOLD_LIVENESS_CEILING_MS);
+ }),
+ ]);
+ await route.continue().catch(() => undefined);
+ });
+
+ try {
+ const pagesMark = probe.pagesResponseStatuses.length;
+ await api.createPage(`plr-push-${suffix}.md`);
+ await expect
+ .poll(() => handlerEntries, {
+ message:
+ 'the push-refresh /api/documents request must reach the route handler, so the navigation below has a genuinely in-flight referenced-assets request to abandon',
+ timeout: SETTLE_TIMEOUT_MS,
+ })
+ .toBeGreaterThan(0);
+ await expect
+ .poll(() => servedPageListsSince(probe, pagesMark), {
+ message:
+ 'the provider must serve its own page list before the navigation, proving the held referenced-assets request belongs to a refresh the provider itself started',
+ timeout: SETTLE_TIMEOUT_MS,
+ })
+ .toBeGreaterThan(0);
+ expect(
+ loadAssetsFailures(probe),
+ 'the provider must be quiet before the navigation, so any referenced-assets failure reported afterwards is attributable to it',
+ ).toEqual([]);
+
+ await page.reload();
+ } finally {
+ releaseHeldRequests();
+ await page.unroute(DOCUMENTS_ROUTE);
+ }
+
+ await waitForProvider(page);
+ await page.waitForSelector('.ProseMirror:not(.composer-prosemirror)');
+ const documentsMark = probe.documentsResponseStatuses.length;
+ await pushAndAwaitServedPageList(
+ probe,
+ api,
+ `plr-after-${suffix}.md`,
+ 'the reloaded document must serve its own push-refresh, proving the provider is live again and the abandoned request has had its chance to settle',
+ );
+ await expect
+ .poll(() => servedDocumentListsSince(probe, documentsMark), {
+ message:
+ 'the reloaded provider must also serve a referenced-assets request, so the absence asserted below is a measured quiet on the assets leg rather than an unexercised path',
+ timeout: SETTLE_TIMEOUT_MS,
+ })
+ .toBeGreaterThan(0);
+
+ expect(
+ loadAssetsFailures(probe),
+ 'a referenced-assets refresh abandoned because its own document was torn down is not a failed request',
+ ).toEqual([]);
+ });
+
+ test('a genuine network failure of /api/documents on a live document is still reported', async ({
+ page,
+ api,
+ }) => {
+ const probe = attachAssetsProbe(page);
+ const suffix = randomUUID().slice(0, 8);
+ await openScratchDocument(page, api, suffix);
+
+ await page.route(DOCUMENTS_ROUTE, (route) => route.abort('failed'));
+ await api.createPage(`plr-push-${suffix}.md`);
+
+ await expect
+ .poll(() => loadAssetsFailures(probe).length, {
+ message:
+ 'a network-level failure of the referenced-assets request on a live document must still reach the warning log',
+ timeout: SETTLE_TIMEOUT_MS,
+ })
+ .toBeGreaterThan(0);
+ const [firstFailure] = loadAssetsFailures(probe);
+ expect(
+ firstFailure?.text,
+ 'a live referenced-assets network failure carries the same text a navigation-abandoned request carries, so message text can never be the discriminator',
+ ).toContain('TypeError: Failed to fetch');
+ });
+});