Beautiful, AI-native markdown IDE and LLM wiki
TypeScript 2nd-brainagent-skillsclaudecodexcompany-braindocsknowledge-knowledge-baseknowledge-managementllmllm-wikillm-wiki-karpathymarkdownmarkdown-editormdmdxnotespkmsecond-brainskills
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.mdnew file mode 100644index 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.jsonindex 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.tsxnew file mode 100644index 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.tsxindex 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 mountuseEffect(() => {- 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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');+ });+});