Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

fix(desktop): 释放失败清单与更新说明的原生响应资源 (#5438)

FicoWangb900eb565e3f
diff --git a/apps/desktop/src/main/__tests__/cdnResponseLifecycle.test.ts b/apps/desktop/src/main/__tests__/cdnResponseLifecycle.test.ts
new file mode 100644
index 0000000000..eaa65a3848
--- /dev/null
+++ b/apps/desktop/src/main/__tests__/cdnResponseLifecycle.test.ts
@@ -0,0 +1,165 @@
+import { EventEmitter } from 'node:events';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+const requestMock = vi.hoisted(() => vi.fn());
+vi.mock('electron', () => ({ app: { isPackaged: true }, net: { request: requestMock } }));
+vi.mock('../logger', () => ({
+ createLogger: () => ({ info: vi.fn(), warn: vi.fn(), error: vi.fn() }),
+}));
+vi.mock('../canaryFlagStore', () => ({ read: () => false }));
+vi.mock('../updateChannelStore', () => ({ isBetaChannelEnabled: () => false }));
+vi.mock('../clientEndpointsService', () => ({ getClientEndpoint: () => 'https://cdn.example.test' }));
+
+// Model response and request lifetimes separately: Electron's writable request
+// can emit close before response data/end. Only response termination owns the body.
+function transport(action: (request: EventEmitter, response: EventEmitter) => void) {
+ const requests: Array<EventEmitter & { end: ReturnType<typeof vi.fn>; abort: ReturnType<typeof vi.fn> }> = [];
+ const responses: Array<EventEmitter & { statusCode: number }> = [];
+ requestMock.mockImplementation(() => {
+ const response = Object.assign(new EventEmitter(), { statusCode: 200 });
+ const request = Object.assign(new EventEmitter(), {
+ end: vi.fn(() => action(request, response)),
+ abort: vi.fn(() => {
+ // Exercise re-entrant cleanup and error listeners on discarded bodies.
+ request.emit('error', new Error('aborted'));
+ if (response.listenerCount('error')) response.emit('error', new Error('aborted body'));
+ response.emit('close');
+ }),
+ });
+ requests.push(request);
+ responses.push(response);
+ return request;
+ });
+ return { requests, responses };
+}
+
+beforeEach(() => {
+ vi.resetModules();
+ requestMock.mockReset();
+ vi.useFakeTimers();
+});
+afterEach(() => vi.useRealTimers());
+
+describe.each(['manifest', 'release'] as const)('%s response lifecycle', (consumer) => {
+ async function start() {
+ if (consumer === 'manifest') {
+ const { fetchManifest } = await import('../manifestService');
+ return { call: (signal?: AbortSignal) => fetchManifest(100, signal), good: '{"app":{"version":"1.0.0"}}' };
+ }
+ const { fetchReleaseNotesIndex } = await import('../releaseNotesService');
+ return { call: fetchReleaseNotesIndex, good: '["1.0.0"]' };
+ }
+
+ it.each([403, 404, 429, 500, 503])('aborts HTTP %s without waiting for a body or changing retry classification', async (status) => {
+ const { call } = await start();
+ const { requests, responses } = transport((request, response) => {
+ Object.assign(response, { statusCode: status });
+ request.emit('response', response);
+ });
+ await expect(call()).resolves.toBeNull();
+ expect(requests).toHaveLength(1);
+ expect(requests[0].abort).toHaveBeenCalledTimes(1);
+ // Late errors must remain handled after the HTTP result has settled.
+ expect(() => responses[0].emit('error', new Error('late error'))).not.toThrow();
+ expect(vi.getTimerCount()).toBe(0);
+ });
+
+ it.each(['no headers', 'unfinished 200', 'stream error', 'early response close', 'network error', 'end throws'])('releases %s and settles within the existing retry budget', async (scenario) => {
+ const { call } = await start();
+ const { requests } = transport((request, response) => {
+ if (scenario === 'end throws') throw new Error('synchronous end failure');
+ if (scenario === 'network error') { request.emit('error', new Error('offline')); return; }
+ if (scenario === 'no headers') return;
+ request.emit('response', response);
+ response.emit('data', Buffer.from('{'));
+ if (scenario === 'stream error') response.emit('error', new Error('broken stream'));
+ if (scenario === 'early response close') response.emit('close');
+ });
+ const pending = call();
+ await vi.runAllTimersAsync();
+ await expect(pending).resolves.toBeNull();
+ expect(requests).toHaveLength(consumer === 'manifest' ? 1 : 4);
+ for (const request of requests) expect(request.abort).toHaveBeenCalledTimes(1);
+ expect(vi.getTimerCount()).toBe(0);
+ });
+
+ it.each(['', '{invalid'])('fully consumes invalid JSON %j without retrying', async (body) => {
+ const { call } = await start();
+ const { requests } = transport((request, response) => {
+ request.emit('response', response);
+ response.emit('data', Buffer.from(body));
+ response.emit('end');
+ response.emit('close');
+ });
+ await expect(call()).resolves.toBeNull();
+ expect(requests).toHaveLength(1);
+ expect(requests[0].abort).not.toHaveBeenCalled();
+ expect(vi.getTimerCount()).toBe(0);
+ });
+
+ it('waits for response end despite an earlier writable request close', async () => {
+ const { call, good } = await start();
+ const { requests, responses } = transport((request, response) => {
+ request.emit('close');
+ request.emit('response', response);
+ response.emit('data', Buffer.from(good));
+ });
+ const settled = vi.fn();
+ const pending = call().then(settled);
+ await Promise.resolve();
+ expect(settled).not.toHaveBeenCalled();
+ expect(vi.getTimerCount()).toBe(1);
+ responses[0].emit('end');
+ responses[0].emit('close');
+ await pending;
+ expect(settled).toHaveBeenCalledTimes(1);
+ expect(settled.mock.calls[0][0]).not.toBeNull();
+ expect(requests[0].abort).not.toHaveBeenCalled();
+ expect(vi.getTimerCount()).toBe(0);
+ });
+
+ it('aborts oversized 200 bodies and ignores later data/end', async () => {
+ const { call } = await start();
+ const { requests } = transport((request, response) => {
+ request.emit('response', response);
+ const chunk = Buffer.alloc(1024 * 1024, ' ');
+ for (let i = 0; i < 9; i++) response.emit('data', chunk);
+ response.emit('end');
+ });
+ await expect(call()).resolves.toBeNull();
+ expect(requests).toHaveLength(1);
+ expect(requests[0].abort).toHaveBeenCalledTimes(1);
+ expect(vi.getTimerCount()).toBe(0);
+ });
+});
+
+describe('manifest caller cancellation', () => {
+ it.each(['before creation', 'during creation', 'before headers', 'after headers'])('handles cancellation %s', async (when) => {
+ const { fetchManifest, getCachedManifest } = await import('../manifestService');
+ const controller = new AbortController();
+ const remove = vi.spyOn(controller.signal, 'removeEventListener');
+ const { requests, responses } = transport((request, response) => {
+ if (when === 'after headers') request.emit('response', response);
+ });
+ if (when === 'before creation') controller.abort();
+ if (when === 'during creation') {
+ const create = requestMock.getMockImplementation()!;
+ requestMock.mockImplementation(() => { controller.abort(); return create(); });
+ }
+ const pending = fetchManifest(100, controller.signal);
+ controller.abort();
+ await expect(pending).resolves.toBeNull();
+ if (when === 'before creation') expect(requestMock).not.toHaveBeenCalled();
+ else {
+ expect(requests[0].abort).toHaveBeenCalledTimes(1);
+ expect(remove).toHaveBeenCalled();
+ // A late response cannot resurrect a completed request or update cache.
+ requests[0].emit('response', responses[0]);
+ responses[0].emit('data', Buffer.from('{"app":{"version":"9.0.0"}}'));
+ responses[0].emit('end');
+ expect(getCachedManifest()).toBeNull();
+ if (when === 'during creation') expect(requests[0].end).not.toHaveBeenCalled();
+ }
+ expect(vi.getTimerCount()).toBe(0);
+ });
+});
diff --git a/apps/desktop/src/main/__tests__/clientEndpointsService.test.ts b/apps/desktop/src/main/__tests__/clientEndpointsService.test.ts
index bd3815e8ab..357bd92413 100644
--- a/apps/desktop/src/main/__tests__/clientEndpointsService.test.ts
+++ b/apps/desktop/src/main/__tests__/clientEndpointsService.test.ts
@@ -1508,6 +1508,24 @@ describe('netlog 产物事后核对(verifyEndpointNetLogCapture)', () => {
});
describe('getter / IPC', () => {
+ it('aborts a non-200 endpoint response instead of draining without a deadline', async () => {
+ resetClientEndpointsForTest(TEST_CLIENT_ENDPOINTS, {
+ buildRegion: 'cn',
+ realmManifestBaseUrls: {
+ cn: 'https://manifest.cn.example.com/app',
+ global: 'https://manifest.global.example.com/app',
+ },
+ });
+ const response = Object.assign(new EventEmitter(), { statusCode: 404 });
+ const request = Object.assign(new EventEmitter(), {
+ end: vi.fn(() => request.emit('response', response)),
+ abort: vi.fn(() => response.emit('error', new Error('cancelled'))),
+ });
+ netRequest.mockReturnValueOnce(request);
+ await expect(loadClientEndpointsForRealm('global')).rejects.toThrow('http-404');
+ expect(request.abort).toHaveBeenCalledTimes(1);
+ });
+
it('默认不是离线缓存启动', () => {
expect(isUsingCachedClientEndpoints()).toBe(false);
});
diff --git a/apps/desktop/src/main/__tests__/manifestService.test.ts b/apps/desktop/src/main/__tests__/manifestService.test.ts
index 3d7113255b..0904fdf4e4 100644
--- a/apps/desktop/src/main/__tests__/manifestService.test.ts
+++ b/apps/desktop/src/main/__tests__/manifestService.test.ts
@@ -107,6 +107,20 @@ describe('manifestService cache channel identity', () => {
expect(String(netRequest.mock.calls[0]?.[0])).not.toContain('-beta.json');
});
+ it('aborts an unread non-200 response before removing cancellation ownership', async () => {
+ const request = Object.assign(new EventEmitter(), { end: vi.fn(), abort: vi.fn() });
+ const response = Object.assign(new EventEmitter(), { statusCode: 404 });
+ netRequest.mockReturnValueOnce(request);
+ const controller = new AbortController();
+ const service = await import('../manifestService');
+ const pending = service.fetchManifest(1_000, controller.signal);
+ request.emit('response', response);
+ await expect(pending).resolves.toBeNull();
+ expect(request.abort).toHaveBeenCalledTimes(1);
+ controller.abort();
+ expect(request.abort).toHaveBeenCalledTimes(1);
+ });
+
it('does not cache a fetch that finishes after the shared channel changes', async () => {
mockManifestResponse(RELEASE_MANIFEST, () => {
isBetaChannelEnabled.mockReturnValue(true);
diff --git a/apps/desktop/src/main/__tests__/releaseNotesService.test.ts b/apps/desktop/src/main/__tests__/releaseNotesService.test.ts
index 5b0204de16..1c9ee56b0d 100644
--- a/apps/desktop/src/main/__tests__/releaseNotesService.test.ts
+++ b/apps/desktop/src/main/__tests__/releaseNotesService.test.ts
@@ -234,6 +234,7 @@ describe('releaseNotesService', () => {
const notes = await promise;
expect(notes).toBeNull();
expect(requestMock).toHaveBeenCalledTimes(1);
+ expect(req.abort).toHaveBeenCalledTimes(1);
});
it('全部重试耗尽后返回 null', async () => {
diff --git a/apps/desktop/src/main/clientEndpointsService.ts b/apps/desktop/src/main/clientEndpointsService.ts
index 659b577ca2..6672bf7caa 100644
--- a/apps/desktop/src/main/clientEndpointsService.ts
+++ b/apps/desktop/src/main/clientEndpointsService.ts
@@ -237,18 +237,19 @@ function fetchTextViaNet(url: string, timeoutMs: number): Promise<ManifestFetchR
}, timeoutMs);
request.on('response', (response) => {
+ response.on('error', (err) =>
+ finish({ ok: false, detail: describeFetchError(err), raw: rawFetchError(err) }, timeout),
+ );
if (response.statusCode !== 200) {
- response.on('data', () => {});
finish({ ok: false, detail: `http-${response.statusCode}` }, timeout);
+ // A discarded error body may never end; don't drain without a timeout.
+ request.abort();
return;
}
response.on('data', (chunk) => {
body += chunk.toString();
});
response.on('end', () => finish({ ok: true, text: body }, timeout));
- response.on('error', (err) =>
- finish({ ok: false, detail: describeFetchError(err), raw: rawFetchError(err) }, timeout),
- );
});
request.on('error', (err) =>
finish({ ok: false, detail: describeFetchError(err), raw: rawFetchError(err) }, timeout),
diff --git a/apps/desktop/src/main/maker-host/__tests__/providerCatalogRealmReload.test.ts b/apps/desktop/src/main/maker-host/__tests__/providerCatalogRealmReload.test.ts
index 590c70ed33..a71543a4df 100644
--- a/apps/desktop/src/main/maker-host/__tests__/providerCatalogRealmReload.test.ts
+++ b/apps/desktop/src/main/maker-host/__tests__/providerCatalogRealmReload.test.ts
@@ -1,4 +1,5 @@
import { randomUUID } from 'node:crypto';
+import { EventEmitter } from 'node:events';
import { promises as fsp } from 'node:fs';
import os from 'node:os';
import path from 'node:path';
@@ -30,12 +31,14 @@ const h = vi.hoisted(() => ({
getGrokAccessToken: vi.fn(),
recoverGrokAuthAfterRejection: vi.fn(),
warn: vi.fn(),
+ request: vi.fn(),
+ catalogIo: null as Parameters<typeof import('@cindy/model-providers').loadCatalog>[1] | null,
}));
vi.mock('electron', () => ({
app: { getPath: () => os.tmpdir() },
BrowserWindow: { getAllWindows: () => [] },
- net: { request: vi.fn() },
+ net: { request: h.request },
}));
vi.mock('@cindy/model-providers', async (importOriginal) => {
@@ -43,8 +46,13 @@ vi.mock('@cindy/model-providers', async (importOriginal) => {
return {
...actual,
loadCatalog: vi.fn(
- (source: Record<string, unknown>, _io: unknown, onResolved?: (result: unknown) => void) =>
+ (
+ source: Record<string, unknown>,
+ io: Parameters<typeof import('@cindy/model-providers').loadCatalog>[1],
+ onResolved?: (result: unknown) => void,
+ ) =>
new Promise((resolve) => {
+ h.catalogIo = io;
h.loads.push({
source,
resolve: (
@@ -1312,4 +1320,21 @@ describe('provider catalog realm reload', () => {
else process.env.XDT_DISABLE_MODELS_FETCH = savedForceOff;
}
});
+
+ it('aborts a non-200 catalog body before dropping its timeout', async () => {
+ if (!h.catalogIo) {
+ const loading = ensureActiveCatalogLoaded();
+ h.loads.at(-1)!.resolve(BUNDLED_CATALOG);
+ await loading;
+ }
+ const response = Object.assign(new EventEmitter(), { statusCode: 404 });
+ const request = Object.assign(new EventEmitter(), {
+ setHeader: vi.fn(),
+ end: vi.fn(() => request.emit('response', response)),
+ abort: vi.fn(() => response.emit('error', new Error('cancelled'))),
+ });
+ h.request.mockReturnValueOnce(request);
+ await expect(h.catalogIo!.fetchText!('https://catalog.example.test', 100)).rejects.toThrow('HTTP 404');
+ expect(request.abort).toHaveBeenCalledTimes(1);
+ });
});
diff --git a/apps/desktop/src/main/maker-host/createDesktopProviderService.ts b/apps/desktop/src/main/maker-host/createDesktopProviderService.ts
index 4d2623da4b..c928106960 100644
--- a/apps/desktop/src/main/maker-host/createDesktopProviderService.ts
+++ b/apps/desktop/src/main/maker-host/createDesktopProviderService.ts
@@ -163,10 +163,15 @@ function fetchText(url: string, timeoutMs: number): Promise<string> {
}, timeoutMs);
request.on('response', (response) => {
+ response.on('error', (err) => {
+ clearTimeout(timer);
+ settle(() => reject(err));
+ });
if (response.statusCode !== 200) {
clearTimeout(timer);
- response.on('data', () => {});
settle(() => reject(new Error(`catalog fetch HTTP ${response.statusCode}`)));
+ // No error body is needed; draining after clearing the timer can hang.
+ request.abort();
return;
}
response.on('data', (chunk) => {
@@ -176,10 +181,6 @@ function fetchText(url: string, timeoutMs: number): Promise<string> {
clearTimeout(timer);
settle(() => resolve(body));
});
- response.on('error', (err) => {
- clearTimeout(timer);
- settle(() => reject(err));
- });
});
request.on('error', (err) => {
clearTimeout(timer);
diff --git a/apps/desktop/src/main/manifestService.ts b/apps/desktop/src/main/manifestService.ts
index a1c019a22d..79a2c9dca8 100644
--- a/apps/desktop/src/main/manifestService.ts
+++ b/apps/desktop/src/main/manifestService.ts
@@ -100,6 +100,8 @@ export interface Manifest {
// ── Constants ──────────────────────────────────────────────────────────────
const REQUEST_TIMEOUT_MS = 30_000;
+// Metadata only: bound accumulation even when a server keeps streaming a 200.
+const MAX_RESPONSE_BYTES = 8 * 1024 * 1024;
// ── State ──────────────────────────────────────────────────────────────────
@@ -179,30 +181,50 @@ export async function fetchManifest(
try {
const request = net.request(url);
let body = '';
+ let bodyBytes = 0;
let settled = false;
- let timeout: ReturnType<typeof setTimeout> | undefined;
+ let aborted = false;
const finish = (value: Manifest | null, abortRequest = false): void => {
- if (settled) return;
- settled = true;
- if (timeout) clearTimeout(timeout);
- signal?.removeEventListener('abort', onAbort);
- if (abortRequest) request.abort();
- resolve(value);
+ if (!settled) {
+ settled = true;
+ if (timeout) clearTimeout(timeout);
+ signal?.removeEventListener('abort', onAbort);
+ resolve(value);
+ }
+ // Promise settlement must not prevent late response/error cleanup.
+ if (abortRequest && !aborted) {
+ aborted = true;
+ request.abort();
+ }
};
const onAbort = (): void => finish(null, true);
+ const timeout = setTimeout(() => finish(null, true), timeoutMs ?? REQUEST_TIMEOUT_MS);
signal?.addEventListener('abort', onAbort, { once: true });
- timeout = setTimeout(() => finish(null, true), timeoutMs ?? REQUEST_TIMEOUT_MS);
-
request.on('response', (response) => {
+ // Keep an error listener even on responses discarded at the headers.
+ response.on('error', () => finish(null, true));
+ response.on('aborted', () => finish(null, true));
+ if (settled) {
+ finish(null, true);
+ return;
+ }
if (response.statusCode !== 200) {
log.info('HTTP %d for %s', response.statusCode, url);
- finish(null);
+ // Unread Electron responses retain the native loader and data pipe.
+ finish(null, true);
return;
}
response.on('data', (chunk) => {
+ if (settled) return;
+ bodyBytes += Buffer.byteLength(chunk);
+ if (bodyBytes > MAX_RESPONSE_BYTES) {
+ body = '';
+ finish(null, true);
+ return;
+ }
body += chunk.toString();
});
response.on('end', () => {
@@ -226,12 +248,16 @@ export async function fetchManifest(
finish(null);
}
});
- response.on('error', () => finish(null));
});
- request.on('error', () => finish(null));
+ request.on('error', () => finish(null, true));
try {
+ // A signal can be cancelled while the request is being constructed.
+ if (signal?.aborted) {
+ onAbort();
+ return;
+ }
request.end();
} catch {
finish(null, true);
@@ -310,7 +336,6 @@ export function probeBetaManifest(timeoutMs = 8_000): Promise<boolean> {
const request = net.request(url);
let body = '';
let settled = false;
- let timeout: ReturnType<typeof setTimeout> | undefined;
const finish = (value: boolean, abortRequest = false): void => {
if (settled) return;
settled = true;
@@ -318,7 +343,7 @@ export function probeBetaManifest(timeoutMs = 8_000): Promise<boolean> {
if (abortRequest) request.abort();
resolve(value);
};
- timeout = setTimeout(() => finish(false, true), timeoutMs);
+ const timeout = setTimeout(() => finish(false, true), timeoutMs);
request.on('response', (response) => {
if (response.statusCode !== 200) {
response.on('data', () => {});
diff --git a/apps/desktop/src/main/releaseNotesService.ts b/apps/desktop/src/main/releaseNotesService.ts
index a8c1389946..10088e4851 100644
--- a/apps/desktop/src/main/releaseNotesService.ts
+++ b/apps/desktop/src/main/releaseNotesService.ts
@@ -45,6 +45,7 @@ const log = createLogger('releaseNotesService');
// ── Constants ──────────────────────────────────────────────────────────────
const REQUEST_TIMEOUT_MS = 15_000;
+const MAX_RESPONSE_BYTES = 8 * 1024 * 1024;
const MAX_RETRIES = 3;
const RETRY_BASE_DELAY_MS = 1_000;
@@ -81,61 +82,77 @@ function fetchCdnJsonOnce<T>(url: string): Promise<FetchAttempt<T>> {
const request = net.request(url);
const decoder = new StringDecoder('utf8');
let body = '';
+ let bodyBytes = 0;
let settled = false;
+ let aborted = false;
- const timeout = setTimeout(() => {
+ const finish = (value: FetchAttempt<T>, abortRequest = false): void => {
if (!settled) {
settled = true;
+ if (timeout) clearTimeout(timeout);
+ resolve(value);
+ }
+ // Resource cleanup is independent of settling the business result.
+ if (abortRequest && !aborted) {
+ aborted = true;
request.abort();
- log.info('Timeout: %s', url);
- resolve({ ok: false, retryable: true });
}
+ };
+ const timeout = setTimeout(() => {
+ log.info('Timeout: %s', url);
+ finish({ ok: false, retryable: true }, true);
}, REQUEST_TIMEOUT_MS);
request.on('response', (response) => {
+ response.on('error', (err) => {
+ log.error('Response error for %s:', url, err);
+ finish({ ok: false, retryable: true }, true);
+ });
+ response.on('aborted', () => finish({ ok: false, retryable: true }, true));
+ if (settled) {
+ finish({ ok: false, retryable: true }, true);
+ return;
+ }
if (response.statusCode !== 200) {
log.info('HTTP %d for %s', response.statusCode, url);
- clearTimeout(timeout);
- settled = true;
- resolve({ ok: false, retryable: false });
+ // No error body is needed; don't leave an unread native loader alive.
+ finish({ ok: false, retryable: false }, true);
return;
}
response.on('data', (chunk) => {
+ if (settled) return;
+ bodyBytes += Buffer.byteLength(chunk);
+ if (bodyBytes > MAX_RESPONSE_BYTES) {
+ body = '';
+ finish({ ok: false, retryable: false }, true);
+ return;
+ }
body += decoder.write(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
});
response.on('end', () => {
- clearTimeout(timeout);
if (settled) return;
- settled = true;
try {
body += decoder.end();
- resolve({ ok: true, data: JSON.parse(body) as T });
+ finish({ ok: true, data: JSON.parse(body) as T });
} catch (err) {
log.error('JSON parse failed for %s:', url, err);
- resolve({ ok: false, retryable: false });
- }
- });
- response.on('error', (err) => {
- log.error('Response error for %s:', url, err);
- clearTimeout(timeout);
- if (!settled) {
- settled = true;
- resolve({ ok: false, retryable: true });
+ finish({ ok: false, retryable: false });
}
});
});
request.on('error', (err) => {
log.error('Request error for %s:', url, err);
- clearTimeout(timeout);
- if (!settled) {
- settled = true;
- resolve({ ok: false, retryable: true });
- }
+ finish({ ok: false, retryable: true }, true);
});
- request.end();
+ try {
+ request.end();
+ } catch (err) {
+ log.error('Request start failed for %s:', url, err);
+ finish({ ok: false, retryable: true }, true);
+ }
} catch (err) {
log.error('Unexpected error for %s:', url, err);
resolve({ ok: false, retryable: true });
diff --git a/apps/desktop/src/renderer/components/layout/__tests__/WallpaperVideo.test.tsx b/apps/desktop/src/renderer/components/layout/__tests__/WallpaperVideo.test.tsx
index d3a28c3cbf..d5baf26ad8 100644
--- a/apps/desktop/src/renderer/components/layout/__tests__/WallpaperVideo.test.tsx
+++ b/apps/desktop/src/renderer/components/layout/__tests__/WallpaperVideo.test.tsx
@@ -215,7 +215,12 @@ describe('dynamic wallpaper lifecycle', () => {
fireEvent.playing(standard);
state.tier = 'hd';
rerender(<WallpaperVideo wallpaperId="cindy-window" motion="dynamic" />);
- await waitFor(() => expect(document.querySelector('video')!.src).toContain('-hd.mp4'));
+ // A new DOM node can precede passive cleanup of the old decoder. Wait for
+ // both lifecycle obligations, not just the mutation observer's DOM signal.
+ await waitFor(() => {
+ expect(document.querySelector('video')!.src).toContain('-hd.mp4');
+ expect(standard.getAttribute('src')).toBeNull();
+ });
const hd = document.querySelector('video')!;
expect(hd.src).toContain('cindy-window-hd.mp4');
expect(document.querySelectorAll('video')).toHaveLength(1);