Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

test(media): retain bounded preview load failure evidence (#10798)

[._.]/ Adam Eivyd29f527012d7
diff --git a/server/services/musicVideo/documentRender.browser.test.js b/server/services/musicVideo/documentRender.browser.test.js
index b0aa954d71..90fe23fc02 100644
--- a/server/services/musicVideo/documentRender.browser.test.js
+++ b/server/services/musicVideo/documentRender.browser.test.js
@@ -1,4 +1,5 @@
import { richSceneSource } from './__richSceneFixture.js';
+import { _withTestPreviewLoadDiagnostics } from './testPreviewLoadDiagnostics.js';
/**
* The shipped layered template with real Chrome and ffmpeg: an excerpt of a
* composition-document project seeks the selected take's <video> on SONG time
@@ -216,8 +217,11 @@ describe.skipIf(!canRun)('layered template with real Chrome and ffmpeg', () => {
WebGL2RenderingContext.prototype.deleteTexture = function (value) { live.delete(value); return remove.call(this, value); };
window.liveTextureCount = () => live.size;
});
- await page.setContent(preview.html);
- await page.waitForFunction(() => typeof window.portosComposition?.seek === 'function');
+ await _withTestPreviewLoadDiagnostics(page, async markReadiness => {
+ await page.setContent(preview.html);
+ markReadiness();
+ await page.waitForFunction(() => typeof window.portosComposition?.seek === 'function');
+ });
const transports = await page.evaluate(() => ['RTCPeerConnection', 'webkitRTCPeerConnection', 'WebTransport'].map(key => {
const descriptor = Object.getOwnPropertyDescriptor(globalThis, key);
let message; try { new globalThis[key](); } catch (error) { message = error.message; }
diff --git a/server/services/musicVideo/testPreviewLoadDiagnostics.js b/server/services/musicVideo/testPreviewLoadDiagnostics.js
new file mode 100644
index 0000000000..6ebb53afd3
--- /dev/null
+++ b/server/services/musicVideo/testPreviewLoadDiagnostics.js
@@ -0,0 +1,71 @@
+// Test-only observer: retain phase facts before owned-page cleanup without
+// copying document source, URLs, error messages or console arguments.
+const LIMIT = 1000;
+const count = value => Number.isInteger(value) && value >= 0 ? Math.min(value, LIMIT) : 'unavailable';
+const flag = value => typeof value === 'boolean' ? value : 'unavailable';
+
+export async function _withTestPreviewLoadDiagnostics(page, load) {
+ const started = Date.now();
+ const facts = { domContentLoaded: false, load: false, crashed: false, closed: false,
+ scriptRequested: 0, scriptFinished: 0, scriptFailed: 0,
+ consoleWarning: 0, consoleError: 0, typeError: 0, syntaxError: 0, otherError: 0 };
+ const increment = key => { facts[key] = Math.min(LIMIT, facts[key] + 1); };
+ const events = {
+ domcontentloaded: () => { facts.domContentLoaded = true; },
+ load: () => { facts.load = true; },
+ crash: () => { facts.crashed = true; },
+ close: () => { facts.closed = true; },
+ request: request => { if (request.resourceType() === 'script') increment('scriptRequested'); },
+ requestfinished: request => { if (request.resourceType() === 'script') increment('scriptFinished'); },
+ requestfailed: request => { if (request.resourceType() === 'script') increment('scriptFailed'); },
+ console: message => {
+ if (message.type() === 'warning') increment('consoleWarning');
+ if (message.type() === 'error') increment('consoleError');
+ },
+ pageerror: error => increment(error.name === 'TypeError' ? 'typeError' : error.name === 'SyntaxError' ? 'syntaxError' : 'otherError'),
+ };
+ for (const [event, listener] of Object.entries(events)) page.on(event, listener);
+ let phase = 'load';
+ try {
+ // The caller keeps its existing Playwright load and semantic deadlines.
+ // Observations never replace load with a weaker lifecycle event.
+ await load(() => { phase = 'composition-readiness'; });
+ } catch (error) {
+ const failure = { phase, elapsedMs: Math.min(Date.now() - started, 3600000), ...facts,
+ pageClosed: page.isClosed(), browserConnected: page.context().browser()?.isConnected() ?? false };
+ let timer;
+ try {
+ const documentFacts = await Promise.race([
+ Promise.resolve().then(() => page.evaluate(() => {
+ let moduleCount = 0, externalScriptCount = 0;
+ for (let i = 0; i < Math.min(document.scripts.length, 1000); i++) {
+ const script = document.scripts[i];
+ if (script.type === 'module') moduleCount++;
+ if (script.hasAttribute('src')) externalScriptCount++;
+ }
+ return { readyState: document.readyState,
+ compositionReady: typeof window.portosComposition?.seek === 'function',
+ scriptCount: document.scripts.length, moduleCount, externalScriptCount };
+ })),
+ new Promise(resolve => { timer = setTimeout(() => resolve(null), 250); }),
+ ]);
+ // Treat page evaluation as untrusted even in a synthetic proof. Only
+ // these scalars can leave the page; never stringify the returned object.
+ failure.documentProbe = documentFacts ? 'captured' : 'deadline';
+ if (documentFacts) Object.assign(failure, {
+ readyState: ['loading', 'interactive', 'complete'].includes(documentFacts.readyState) ? documentFacts.readyState : 'unavailable',
+ compositionReady: flag(documentFacts.compositionReady),
+ scriptCount: count(documentFacts.scriptCount),
+ moduleCount: count(documentFacts.moduleCount),
+ externalScriptCount: count(documentFacts.externalScriptCount),
+ });
+ } catch { failure.documentProbe = 'unavailable'; }
+ finally { clearTimeout(timer); }
+ // Attach to the original failure so reporters retain these facts even if
+ // cleanup subsequently fails. No console/error body enters the snapshot.
+ error.message += `; preview lifecycle: ${JSON.stringify(failure)}`;
+ throw error;
+ } finally {
+ for (const [event, listener] of Object.entries(events)) page.off(event, listener);
+ }
+}
diff --git a/server/services/musicVideo/testPreviewLoadDiagnostics.test.js b/server/services/musicVideo/testPreviewLoadDiagnostics.test.js
new file mode 100644
index 0000000000..46e650864d
--- /dev/null
+++ b/server/services/musicVideo/testPreviewLoadDiagnostics.test.js
@@ -0,0 +1,69 @@
+import { EventEmitter } from 'node:events';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { _withTestPreviewLoadDiagnostics } from './testPreviewLoadDiagnostics.js';
+
+function fixture(evaluate = vi.fn().mockResolvedValue({ readyState: 'interactive', compositionReady: false,
+ scriptCount: 3, moduleCount: 1, externalScriptCount: 0 })) {
+ return Object.assign(new EventEmitter(), { evaluate, isClosed: () => false,
+ context: () => ({ browser: () => ({ isConnected: () => true }) }) });
+}
+const snapshot = error => JSON.parse(error.message.split('; preview lifecycle: ')[1]);
+afterEach(() => vi.useRealTimers());
+
+describe('preview load failure evidence', () => {
+ it('retains bounded phase facts on the original failure without console text, URLs or page data', async () => {
+ const page = fixture(vi.fn().mockResolvedValue({ readyState: 'secret', compositionReady: 'secret',
+ scriptCount: 10000, moduleCount: -1, externalScriptCount: 'secret', source: 'secret' }));
+ const failure = new Error('load deadline');
+ await expect(_withTestPreviewLoadDiagnostics(page, async () => {
+ page.emit('domcontentloaded');
+ for (let i = 0; i < 1005; i++) page.emit('console', { type: () => 'warning', text: () => { throw new Error('Do not read console text'); } });
+ page.emit('pageerror', { name: 'SyntaxError', message: 'secret' });
+ page.emit('pageerror', { name: 'secret', message: 'secret' });
+ page.emit('requestfailed', { resourceType: () => 'script', url: () => { throw new Error('Do not read URLs'); } });
+ throw failure;
+ })).rejects.toBe(failure);
+ expect(snapshot(failure)).toMatchObject({ phase: 'load', domContentLoaded: true, load: false,
+ consoleWarning: 1000, syntaxError: 1, otherError: 1, scriptFailed: 1,
+ browserConnected: true, pageClosed: false, documentProbe: 'captured',
+ readyState: 'unavailable', compositionReady: 'unavailable', scriptCount: 1000,
+ moduleCount: 'unavailable', externalScriptCount: 'unavailable' });
+ expect(failure.message).not.toContain('secret');
+ expect(page.eventNames()).toEqual([]);
+ });
+
+ it('bounds an unresponsive renderer probe and owns its late rejection before cleanup', async () => {
+ vi.useFakeTimers();
+ let rejectProbe;
+ const page = fixture(vi.fn(() => new Promise((_, reject) => { rejectProbe = reject; })));
+ const failure = new Error('semantic deadline');
+ const result = _withTestPreviewLoadDiagnostics(page, async markReadiness => {
+ page.emit('load'); markReadiness(); throw failure;
+ });
+ const checked = expect(result).rejects.toBe(failure);
+ await vi.advanceTimersByTimeAsync(250);
+ await checked;
+ expect(snapshot(failure)).toMatchObject({ phase: 'composition-readiness', load: true, documentProbe: 'deadline' });
+ rejectProbe(new Error('late private renderer error'));
+ await Promise.resolve();
+ expect(page.eventNames()).toEqual([]);
+ expect(vi.getTimerCount()).toBe(0);
+ });
+
+ it('preserves a disconnected page failure when document evaluation rejects', async () => {
+ const page = fixture(vi.fn().mockRejectedValue(new Error('private evaluation error')));
+ page.isClosed = () => true;
+ page.context = () => ({ browser: () => ({ isConnected: () => false }) });
+ const failure = new Error('load failed');
+ await expect(_withTestPreviewLoadDiagnostics(page, async () => { throw failure; })).rejects.toBe(failure);
+ expect(snapshot(failure)).toMatchObject({ pageClosed: true, browserConnected: false, documentProbe: 'unavailable' });
+ expect(page.eventNames()).toEqual([]);
+ });
+
+ it('does not probe or retain observers after successful load and semantic readiness', async () => {
+ const page = fixture();
+ await _withTestPreviewLoadDiagnostics(page, async markReadiness => { page.emit('load'); markReadiness(); });
+ expect(page.evaluate).not.toHaveBeenCalled();
+ expect(page.eventNames()).toEqual([]);
+ });
+});