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

fix: use lightweight film look during document preview playback (#11221)

Adam Eivy01fbfb30146f
diff --git a/client/src/components/musicVideo/CompositionPreviewPlayer.jsx b/client/src/components/musicVideo/CompositionPreviewPlayer.jsx
index 56134de1c6..cd68e9a5fd 100644
--- a/client/src/components/musicVideo/CompositionPreviewPlayer.jsx
+++ b/client/src/components/musicVideo/CompositionPreviewPlayer.jsx
@@ -90,13 +90,18 @@ export default function CompositionPreviewPlayer({ project, audioUrl, seekReques
const tick = () => {
const time = audioRef.current?.currentTime || 0;
const frameIndex = Math.floor(time * fps + 1e-9);
- if (frameIndex !== posted) { posted = frameIndex; setT(time); preview.seek(time); }
+ if (frameIndex !== posted) { posted = frameIndex; setT(time); preview.seek(time, { playing: true }); }
handle = requestAnimationFrame(tick);
};
handle = requestAnimationFrame(tick);
return () => cancelAnimationFrame(handle);
}, [playing, fps, preview.seek]);
+ // Pause/end repaints the current frame with the exact render filter.
+ useEffect(() => {
+ if (!playing && preview.ready) seek(audioRef.current?.currentTime || 0);
+ }, [playing, preview.ready, seek]);
+
const togglePlay = () => {
const audio = audioRef.current;
if (!audio) return;
diff --git a/client/src/components/musicVideo/CompositionPreviewPlayer.test.jsx b/client/src/components/musicVideo/CompositionPreviewPlayer.test.jsx
index 55216cf50e..86c69c3e1d 100644
--- a/client/src/components/musicVideo/CompositionPreviewPlayer.test.jsx
+++ b/client/src/components/musicVideo/CompositionPreviewPlayer.test.jsx
@@ -1,5 +1,5 @@
import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { act, render, screen, waitFor } from '@testing-library/react';
+import { act, fireEvent, render, screen, waitFor } from '@testing-library/react';
const api = vi.hoisted(() => ({
getMusicVideoCompositionPreview: vi.fn(),
@@ -62,6 +62,27 @@ beforeEach(() => {
});
describe('CompositionPreviewPlayer', () => {
+ it('sends motion mode during playback and exact mode on pause and scrub without reopening', async () => {
+ const play = vi.spyOn(HTMLMediaElement.prototype, 'play').mockResolvedValue();
+ const pause = vi.spyOn(HTMLMediaElement.prototype, 'pause').mockImplementation(() => {});
+ const raf = vi.spyOn(window, 'requestAnimationFrame').mockImplementation(() => 1);
+ const cancel = vi.spyOn(window, 'cancelAnimationFrame').mockImplementation(() => {});
+ try {
+ const { container } = render(<CompositionPreviewPlayer project={project} audioUrl='/song.mp3' />);
+ await waitFor(() => expect(screen.getByRole('button', { name: 'Play' })).toBeEnabled());
+ fireEvent.click(screen.getByRole('button', { name: 'Play' }));
+ const tick = raf.mock.calls.at(-1)[0];
+ container.querySelector('audio').currentTime = 2;
+ act(() => tick());
+ expect(socket.emit).toHaveBeenLastCalledWith('generated-preview:seek', expect.objectContaining({ t: 2, playing: true }));
+ fireEvent.click(screen.getByRole('button', { name: 'Pause' }));
+ await waitFor(() => expect(socket.emit).toHaveBeenLastCalledWith('generated-preview:seek', expect.objectContaining({ t: 2, playing: false })));
+ fireEvent.change(screen.getByLabelText('Scrub the composition preview'), { target: { value: '3' } });
+ expect(socket.emit).toHaveBeenLastCalledWith('generated-preview:seek', expect.objectContaining({ t: 3, playing: false }));
+ expect(opens()).toHaveLength(1);
+ } finally { play.mockRestore(); pause.mockRestore(); raf.mockRestore(); cancel.mockRestore(); }
+ });
+
it('opens an isolated preview and never fetches media or mounts generated HTML', async () => {
render(<CompositionPreviewPlayer project={project} audioUrl={null} />);
await screen.findByTitle('Composition document preview');
diff --git a/client/src/hooks/useGeneratedPreview.js b/client/src/hooks/useGeneratedPreview.js
index f1081c7fdd..e340be6665 100644
--- a/client/src/hooks/useGeneratedPreview.js
+++ b/client/src/hooks/useGeneratedPreview.js
@@ -43,7 +43,7 @@ export default function useGeneratedPreview({ active, request, controls = null }
const [state, setState] = useState(EMPTY);
const requestKey = active && request ? JSON.stringify(request) : '';
- const seek = useCallback((t) => {
+ const seek = useCallback((t, { playing = false } = {}) => {
const current = pending.current;
if (!current?.sessionId) return;
current.generation += 1;
@@ -52,6 +52,7 @@ export default function useGeneratedPreview({ active, request, controls = null }
sessionId: current.sessionId,
generation: current.generation,
t,
+ playing,
});
}, []);
diff --git a/docs/HTML_COMPOSITIONS.md b/docs/HTML_COMPOSITIONS.md
index ca1ebb86da..354300623d 100644
--- a/docs/HTML_COMPOSITIONS.md
+++ b/docs/HTML_COMPOSITIONS.md
@@ -311,6 +311,12 @@ what the preview shows and what the render bakes:
audio is copied back untouched. Paid clips are never regenerated to change
the feel. The pass takes the second half of the render's progress bar and a
cancel aborts it.
+- **The composition document preview** carries playback mode with each seek
+ into the OS-isolated preview worker. Playing frames use the same lightweight
+ motion layers as the animatic: CSS focus/tone/saturation and weave on the
+ root, with pointer-transparent overlays above document and lyric layers.
+ Pause, scrub and frame stepping restore the exact SVG filter. This mode is
+ preview-only; final renders remain exact and generated HTML stays isolated.
- **The storyboard animatic** (the docked preview for footage projects) shows
the look live over the whole picture, lyrics included, on the song frame.
Paused, that is the exact filter; **while the song plays** it is the light
diff --git a/server/lib/filmLook.browser.test.js b/server/lib/filmLook.browser.test.js
new file mode 100644
index 0000000000..065642f19f
--- /dev/null
+++ b/server/lib/filmLook.browser.test.js
@@ -0,0 +1,77 @@
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { existsSync } from 'node:fs';
+import { chromium } from 'playwright-core';
+import { browserSuiteCanRun } from './browserSuiteGate.js';
+import { filmLookFilterMarkup, filmLookPreset, filmLookRuntimeSource } from './filmLook.js';
+
+const chrome = [process.env.CHROME_PATH, chromium.executablePath(),
+ '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome', '/usr/bin/google-chrome', '/usr/bin/chromium',
+].find((path) => path && existsSync(path));
+const canRun = browserSuiteCanRun('film look runtime browser', { Chrome: chrome });
+const width = 390;
+const height = 219;
+const picture = '<button id="picture" style="position:fixed;inset:0;width:100%;height:100%;border:0;background:linear-gradient(35deg,#261349,#e8bf43)">Example picture</button><div id="lyric" style="position:fixed;inset:0;z-index:2147483647;pointer-events:none;color:white">Example lyric</div>';
+const composition = '<script>portosComposition = { fps: 30, seek() {} };</script>';
+const html = (head, body) => `<!doctype html><html><head><style>html,body{margin:0;width:100%;height:100%}</style>${head}</head><body>${body}</body></html>`;
+
+describe.skipIf(!canRun)('film look runtime in Chrome', () => {
+ let browser;
+ beforeAll(async () => { browser = await chromium.launch({ executablePath: chrome, headless: true }); });
+ afterAll(async () => { await browser?.close(); });
+
+ // Uniquely pins the rendered pixels, rather than just checking unchanged SVG source.
+ it('keeps exact render captures byte-identical to the standalone filter across frames and restores them after playing', async () => {
+ const page = await browser.newPage({ viewport: { width, height } });
+ const reference = await browser.newPage({ viewport: { width, height } });
+ try {
+ const look = filmLookPreset('neon-rain');
+ await page.setContent(html(`<script>${filmLookRuntimeSource(look)}</script>`, picture + composition));
+ for (const frame of [12, 47]) {
+ const exact = filmLookFilterMarkup(look, { frame, width, height });
+ await reference.setContent(html('', picture + exact.svg));
+ await reference.evaluate((filter) => { document.documentElement.style.filter = filter; }, exact.css);
+ await page.evaluate((n) => globalThis.portosComposition.seek(n / 30), frame);
+ const expected = await reference.screenshot();
+ expect(Buffer.compare(await page.screenshot(), expected)).toBe(0);
+ await page.evaluate(() => globalThis.__portosFilmLook.playback(true));
+ expect(await page.evaluate(() => document.documentElement.style.filter)).not.toContain('url(');
+ await page.evaluate(() => globalThis.__portosFilmLook.playback(false));
+ expect(Buffer.compare(await page.screenshot(), expected)).toBe(0);
+ }
+ } finally { await page.close(); await reference.close(); }
+ }, 30000);
+
+ it('keeps motion overlays above max-z-index lyrics and out of hit testing while reusing their tiles', async () => {
+ const page = await browser.newPage({ viewport: { width, height } });
+ const errors = [];
+ page.on('pageerror', (error) => errors.push(error.message));
+ try {
+ const look = { ...filmLookPreset('vhs'), vignette: 1, weave: 0 };
+ await page.setContent(html(`<script>${filmLookRuntimeSource(look)}</script>`, picture + composition));
+ const result = await page.evaluate(() => {
+ globalThis.__portosFilmLook.playback(true);
+ const overlay = document.querySelector('[data-portos-film-look-motion]');
+ const grain = overlay.querySelector('[data-film-look-layer="grain"]');
+ const image = grain.style.backgroundImage;
+ globalThis.portosComposition.seek(1);
+ const hit = document.elementFromPoint(195, 100);
+ // Temporarily make only the vignette interactive to ask Chrome which layer paints on top.
+ const vignette = overlay.querySelector('[data-film-look-layer="vignette"]');
+ vignette.style.pointerEvents = 'auto';
+ const top = document.elementFromPoint(195, 100);
+ vignette.style.pointerEvents = 'none';
+ return {
+ last: document.documentElement.lastElementChild === overlay,
+ hit: hit.id, top: top.dataset.filmLookLayer,
+ reused: grain === overlay.querySelector('[data-film-look-layer="grain"]') && grain.style.backgroundImage === image,
+ filter: document.documentElement.style.filter,
+ pointers: [...overlay.children].map((child) => getComputedStyle(child).pointerEvents),
+ };
+ });
+ expect(result).toMatchObject({ last: true, hit: 'picture', top: 'vignette', reused: true });
+ expect(result.filter).not.toContain('url(');
+ expect(result.pointers.every((value) => value === 'none')).toBe(true);
+ expect(errors).toEqual([]);
+ } finally { await page.close(); }
+ });
+});
diff --git a/server/lib/filmLook.js b/server/lib/filmLook.js
index f99a97d03c..83d65746b8 100644
--- a/server/lib/filmLook.js
+++ b/server/lib/filmLook.js
@@ -363,15 +363,6 @@ export function filmLookFilterMarkup(look, { frame = 0, width = 1920, height = 1
};
}
-const FILM_LOOK_TILE_PX = 256;
-const svgDataUrl = (markup) => `data:image/svg+xml,${encodeURIComponent(`<svg xmlns="http://www.w3.org/2000/svg" ${markup}</svg>`)}`;
-const frameHash = (seed) => {
- let x = Math.imul(seed + 0x9e3779b9, 0x85ebca6b) >>> 0;
- x ^= x >>> 13; x = Math.imul(x, 0xc2b2ae35) >>> 0; x ^= x >>> 16;
- return (x >>> 0) / 4294967296;
-};
-const hexColor = (value, fallback) => (typeof value === 'string' && /^#[0-9a-f]{6}$/i.test(value) ? value : fallback);
-
/**
* The look as a PLAYING picture can afford it: no SVG filter, which a browser
* re-runs over every decoded video frame (the full chain drops a phone's
@@ -388,6 +379,19 @@ const hexColor = (value, fallback) => (typeof value === 'string' && /^#[0-9a-f]{
export function filmLookMotionLayers(look, { frame = 0, width = 1920, height = 1080 } = {}) {
const settings = normalizeFilmLook(look);
if (!settings || isFilmLookNeutral(settings)) return null;
+ return filmLookMotionMarkup(settings, { frame, width, height });
+}
+
+// Inlined into the page runtime; all dependencies stay inside this function.
+function filmLookMotionMarkup(settings, { frame = 0, width = 1920, height = 1080 } = {}) {
+ const FILM_LOOK_TILE_PX = 256;
+ const svgDataUrl = (markup) => `data:image/svg+xml,${encodeURIComponent(`<svg xmlns="http://www.w3.org/2000/svg" ${markup}</svg>`)}`;
+ const frameHash = (seed) => {
+ let x = Math.imul(seed + 0x9e3779b9, 0x85ebca6b) >>> 0;
+ x ^= x >>> 13; x = Math.imul(x, 0xc2b2ae35) >>> 0; x ^= x >>> 16;
+ return (x >>> 0) / 4294967296;
+ };
+ const hexColor = (value, fallback) => (typeof value === 'string' && /^#[0-9a-f]{6}$/i.test(value) ? value : fallback);
const v = (key) => (Number.isFinite(settings[key]) ? settings[key] : 0);
const n = (value) => Number(value.toFixed(4));
const w = Math.max(1, width);
@@ -467,7 +471,8 @@ export function filmLookMotionLayers(look, { frame = 0, width = 1920, height = 1
* document's own scripts. It exposes `window.__portosFilmLook`:
*
* apply(look) put a (normalized) look on the page, or null to clear it
- * frame(n) redraw the filter for song frame n (grain, weave, flicker, leak)
+ * frame(n) redraw for song frame n (grain, weave, flicker, leak)
+ * playback(on) use cheap motion layers while a live preview plays; exact by default
* look the look currently applied
*
* `globalThis.portosComposition` is intercepted when the document assigns it so
@@ -478,15 +483,63 @@ export function filmLookMotionLayers(look, { frame = 0, width = 1920, height = 1
export function filmLookRuntimeSource(look = null) {
return `(() => {
const markup = ${filmLookFilterMarkup.toString()};
+ const motion = ${filmLookMotionMarkup.toString()};
const ID = 'portos-film-look';
let look = ${JSON.stringify(normalizeFilmLook(look))};
let frame = 0;
let fps = 24;
let host = null;
+ let overlays = null;
+ let playing = false;
+ let savedTransform = null;
+ const clearMotion = (root) => {
+ if (overlays) { overlays.remove(); overlays = null; }
+ if (savedTransform !== null) { root.style.transform = savedTransform; savedTransform = null; }
+ };
+ const drawMotion = (root, size) => {
+ if (host) { host.remove(); host = null; }
+ const built = motion(look, size);
+ root.style.filter = built.filter || '';
+ if (savedTransform === null) savedTransform = root.style.transform;
+ root.style.transform = [savedTransform, built.transform].filter(Boolean).join(' ');
+ if (!overlays) {
+ overlays = document.createElement('div');
+ overlays.dataset.portosFilmLookMotion = '1';
+ overlays.setAttribute('aria-hidden', 'true');
+ overlays.style.cssText = 'position:fixed;inset:0;overflow:hidden;pointer-events:none;z-index:2147483647';
+ }
+ // A root child after body also paints after max-z-index lyrics/title layers.
+ if (root.lastElementChild !== overlays) root.appendChild(overlays);
+ const keys = new Set(built.overlays.map((layer) => layer.key));
+ for (const child of [...overlays.children]) if (!keys.has(child.dataset.filmLookLayer)) child.remove();
+ for (const [index, layer] of built.overlays.entries()) {
+ let el = [...overlays.children].find((child) => child.dataset.filmLookLayer === layer.key);
+ if (!el) { el = document.createElement('div'); el.dataset.filmLookLayer = layer.key; }
+ // Reuse the nodes and tile URLs across frames: only the tile transform changes.
+ el.style.position = 'absolute'; el.style.pointerEvents = 'none';
+ el.style.opacity = layer.opacity; el.style.mixBlendMode = layer.blend;
+ el.style.left = '0'; el.style.top = '0';
+ el.style.width = layer.kind === 'tile' ? '200%' : '100%';
+ el.style.height = layer.kind === 'tile' ? '200%' : '100%';
+ if (layer.kind === 'flat') el.style.backgroundColor = layer.color;
+ if (layer.kind === 'gradient') el.style.backgroundImage = layer.gradient;
+ if (layer.kind === 'tile') {
+ el.style.backgroundImage = 'url("' + layer.image + '")';
+ el.style.backgroundSize = layer.size[0] + 'px ' + layer.size[1] + 'px';
+ el.style.backgroundRepeat = 'repeat';
+ el.style.transform = 'translate(' + (-layer.shift[0] * 50) + '%, ' + (-layer.shift[1] * 50) + '%)';
+ }
+ el.style.zIndex = String(index);
+ if (el.parentNode !== overlays) overlays.appendChild(el);
+ }
+ };
const draw = () => {
const root = document.documentElement;
if (!root) return;
- const built = look ? markup(look, { frame, width: root.clientWidth || innerWidth || 1920, height: root.clientHeight || innerHeight || 1080, id: ID }) : null;
+ const size = { frame, width: root.clientWidth || innerWidth || 1920, height: root.clientHeight || innerHeight || 1080, id: ID };
+ if (playing && look) { drawMotion(root, size); return; }
+ clearMotion(root);
+ const built = look ? markup(look, size) : null;
if (!built || !built.active) {
if (host) { host.remove(); host = null; }
root.style.filter = '';
@@ -504,7 +557,8 @@ export function filmLookRuntimeSource(look = null) {
};
const api = {
apply(next) { look = next && typeof next === 'object' ? next : null; draw(); },
- frame(n) { const next = Math.max(0, Math.floor(Number(n) || 0)); if (next !== frame || !host) { frame = next; if (look) draw(); } },
+ playback(value) { const next = value === true; if (next !== playing) { playing = next; draw(); } },
+ frame(n) { const next = Math.max(0, Math.floor(Number(n) || 0)); if (next !== frame || (!host && !overlays)) { frame = next; if (look) draw(); } },
get look() { return look; },
};
Object.defineProperty(window, '__portosFilmLook', { value: api, configurable: false, writable: false });
diff --git a/server/lib/filmLook.test.js b/server/lib/filmLook.test.js
index e49392fa02..fe9fbf903c 100644
--- a/server/lib/filmLook.test.js
+++ b/server/lib/filmLook.test.js
@@ -1,4 +1,5 @@
import { describe, expect, it } from 'vitest';
+import { runInNewContext } from 'node:vm';
import {
FILM_LOOK_CONTROLS, FILM_LOOK_PRESETS, describeFilmLook, filmLookFilterMarkup, filmLookMotionLayers, filmLookPreset, filmLookRuntimeSource,
isFilmLookNeutral, normalizeFilmLook,
@@ -86,6 +87,52 @@ describe('film look filter markup', () => {
});
describe('film look runtime', () => {
+ // Catches motion mode retaining the per-frame SVG chain or pause failing to restore render parity.
+ it('switches the inlined page runtime between cheap reusable motion layers and the exact seek filter', () => {
+ const element = () => ({
+ style: { filter: '', transform: '' }, dataset: {}, children: [], isConnected: false,
+ setAttribute() {},
+ get lastElementChild() { return this.children.at(-1); },
+ appendChild(child) { child.remove(); this.children.push(child); child.parent = this; child.parentNode = this; child.isConnected = true; },
+ remove() { if (this.parent) this.parent.children = this.parent.children.filter((child) => child !== this); this.isConnected = false; },
+ });
+ const root = Object.assign(element(), { clientWidth: 390, clientHeight: 219 });
+ root.style.transform = 'scale(0.9)';
+ const context = { document: { documentElement: root, body: root, readyState: 'complete', createElement: element, createElementNS: element }, addEventListener() {} };
+ context.window = context;
+ const look = filmLookPreset('vhs');
+ runInNewContext(filmLookRuntimeSource(look), context);
+ const api = context.__portosFilmLook;
+ context.portosComposition = { fps: 30, seek: (t) => t };
+ context.portosComposition.seek(0.4);
+ const exact = filmLookFilterMarkup(look, { frame: 12, width: 390, height: 219 });
+ expect(root.style.filter).toBe(exact.css);
+ expect(root.children[0].innerHTML).toBe('<defs>' + exact.filter + '</defs>');
+ api.playback(true);
+ expect(root.style.filter).not.toContain('url(');
+ const overlays = root.lastElementChild;
+ const grain = overlays.children.find((child) => child.dataset.filmLookLayer === 'grain');
+ const originalImage = grain.style.backgroundImage;
+ const originalShift = grain.style.transform;
+ context.portosComposition.seek(0.5);
+ expect(root.lastElementChild).toBe(overlays);
+ expect(overlays.children.find((child) => child.dataset.filmLookLayer === 'grain')).toBe(grain);
+ expect(grain.style.backgroundImage).toBe(originalImage);
+ expect(grain.style.transform).not.toBe(originalShift);
+ expect(overlays.style.cssText).toContain('pointer-events:none;z-index:2147483647');
+ expect(overlays.children.every((child) => child.style.pointerEvents === 'none')).toBe(true);
+ api.playback(false);
+ expect(root.style.filter).toBe(exact.css);
+ expect(root.style.transform).toBe('scale(0.9)');
+ expect(overlays.isConnected).toBe(false);
+ expect(root.lastElementChild.innerHTML).toBe('<defs>' + filmLookFilterMarkup(look, { frame: 15, width: 390, height: 219 }).filter + '</defs>');
+ api.playback(true);
+ api.apply(null);
+ expect(root.style.filter).toBe('');
+ expect(root.style.transform).toBe('scale(0.9)');
+ expect(root.children).toHaveLength(0);
+ });
+
it('carries the markup, the starting look and the composition seek hook into a page', () => {
const source = filmLookRuntimeSource({ grain: 0.3, preset: 'custom' });
expect(source).toContain('function filmLookFilterMarkup');
diff --git a/server/services/generatedPreview/sessions.js b/server/services/generatedPreview/sessions.js
index 202d73a1a4..40daa0acd4 100644
--- a/server/services/generatedPreview/sessions.js
+++ b/server/services/generatedPreview/sessions.js
@@ -48,6 +48,7 @@ const seekSchema = z.object({
sessionId: z.string().uuid(),
generation: z.number().int().nonnegative(),
t: z.number().min(0).max(86400),
+ playing: z.boolean().optional(),
}).strict();
const commandSchema = z.object({
@@ -175,7 +176,7 @@ async function applyJson(page, globalName, value) {
await page.evaluate(`globalThis.${globalName} && globalThis.${globalName}.apply(${literal})`);
}
-async function seekPage(session, t) {
+async function seekPage(session, t, playing = false) {
const time = Number(t);
if (session.kind === 'code-animation') return;
if (session.lyrics) {
@@ -185,6 +186,7 @@ async function seekPage(session, t) {
}
await session.page.evaluate(`(() => {
const time = ${time};
+ globalThis.__portosFilmLook?.playback(${playing === true});
window.postMessage({ type: 'mv-code:seek', t: time }, '*');
window.postMessage({ type: 'portos-mv:seek', t: time }, '*');
const seek = globalThis.portosComposition && globalThis.portosComposition.seek;
@@ -200,13 +202,13 @@ function emitFrame(session, generation, data) {
armIdle(session);
}
-async function runSeek(session, generation, t) {
+async function runSeek(session, generation, t, playing = false) {
if (session.seekTail) {
- session.pendingSeek = { generation, t };
+ session.pendingSeek = { generation, t, playing };
return;
}
session.seekTail = (async () => {
- let next = { generation, t };
+ let next = { generation, t, playing };
while (next && !session.closed) {
const current = next;
session.pendingSeek = null;
@@ -215,7 +217,7 @@ async function runSeek(session, generation, t) {
continue;
}
try {
- await seekPage(session, current.t);
+ await seekPage(session, current.t, current.playing);
emitFrame(session, current.generation, await capture(session.page));
session.appliedGeneration = current.generation;
} catch (error) {
@@ -574,7 +576,7 @@ async function seekGeneratedPreview(socket, data) {
if (!parsed.success) return;
const session = sessions.get(parsed.data.sessionId);
if (!session || session.socket.id !== socket.id || session.closed) return;
- await runSeek(session, parsed.data.generation, parsed.data.t);
+ await runSeek(session, parsed.data.generation, parsed.data.t, parsed.data.playing);
}
async function commandGeneratedPreview(socket, data) {
diff --git a/server/services/generatedPreview/sessions.test.js b/server/services/generatedPreview/sessions.test.js
new file mode 100644
index 0000000000..b2c12a4675
--- /dev/null
+++ b/server/services/generatedPreview/sessions.test.js
@@ -0,0 +1,55 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+const fixture = vi.hoisted(() => ({ page: null }));
+vi.mock('../musicVideo/projects.js', () => ({ getProject: async () => ({ composition: { document: { directory: 'example-document' } } }) }));
+vi.mock('../musicVideo/documentRender.js', () => ({ openIsolatedDocumentPreview: async () => ({
+ page: fixture.page, scratchRoot: null, width: 390, height: 219, fps: 30, durationSec: 10,
+}) }));
+import { closeSession, registerGeneratedPreviewHandlers } from './sessions.js';
+
+const socket = { id: 'preview-test-socket', handlers: new Map(), emit: vi.fn(), on(event, fn) { this.handlers.set(event, fn); } };
+afterEach(async () => { for (const [event, payload] of socket.emit.mock.calls) if (event === 'generated-preview:opened') await closeSession(payload.sessionId); socket.handlers.clear(); socket.emit.mockClear(); });
+
+// Catches playback state being lost at the queued worker boundary, especially the final pause behind an active seek.
+describe('isolated document preview playback', () => {
+ it('captures motion during play and the exact frame after a queued pause, while rejecting another socket', async () => {
+ const frame = { t: 0, playing: false };
+ let hold;
+ let entered;
+ const started = new Promise((resolve) => { entered = resolve; });
+ const globals = {
+ __portosFilmLook: { apply() {}, playback(on) { frame.playing = on; } },
+ __portosTitleCard: { apply() {} },
+ portosComposition: { async seek(t) {
+ frame.t = t;
+ if (t === 1) { entered(); await new Promise((resolve) => { hold = resolve; }); }
+ } },
+ };
+ fixture.page = {
+ evaluate: (source) => new Function('globalThis', 'window', 'return ' + source)(globals, { postMessage() {} }),
+ send: async () => ({ data: JSON.stringify(frame) }),
+ close: async () => {},
+ };
+ registerGeneratedPreviewHandlers(socket);
+ const requestId = '00000000-0000-4000-8000-000000000001';
+ socket.handlers.get('generated-preview:open')({ requestId, kind: 'music-video', projectId: 'example' });
+ await vi.waitFor(() => expect(socket.emit).toHaveBeenCalledWith('generated-preview:opened', expect.any(Object)));
+ const sessionId = socket.emit.mock.calls.find(([event]) => event === 'generated-preview:opened')[1].sessionId;
+ const seek = (generation, t, playing) => socket.handlers.get('generated-preview:seek')({ requestId, sessionId, generation, t, ...(playing === undefined ? {} : { playing }) });
+ seek(1, 1, true);
+ await started;
+ seek(2, 2, true);
+ seek(3, 3); // Older clients and explicit seeks default to the exact filter.
+ await Promise.resolve();
+ hold();
+ await vi.waitFor(() => expect(socket.emit.mock.calls.filter(([event]) => event === 'generated-preview:frame').at(-1)[1]).toMatchObject({ generation: 3, data: JSON.stringify({ t: 3, playing: false }) }));
+ expect(socket.emit.mock.calls.filter(([event]) => event === 'generated-preview:frame').map(([, payload]) => JSON.parse(payload.data))).toEqual([
+ { t: 0, playing: false }, { t: 1, playing: true }, { t: 3, playing: false },
+ ]);
+ const other = { ...socket, id: 'other-preview-socket', handlers: new Map() };
+ registerGeneratedPreviewHandlers(other);
+ other.handlers.get('generated-preview:seek')({ requestId, sessionId, generation: 4, t: 4, playing: true });
+ await Promise.resolve();
+ expect(frame).toEqual({ t: 3, playing: false });
+ });
+});