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
JavaScript ai-agentsdashboarddeveloper-toolsdigital-twinquantified-selfsecond-brainself-hostedtailscale
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.jsxindex 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, seekRequesconst 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.jsxindex 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.jsindex 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.mdindex 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 changethe feel. The pass takes the second half of the render's progress bar and acancel 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) showsthe 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 lightdiff --git a/server/lib/filmLook.browser.test.js b/server/lib/filmLook.browser.test.jsnew file mode 100644index 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.jsindex 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 = 1export 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.jsindex 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.jsindex 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.jsnew file mode 100644index 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 });+ });+});