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

Code Animation preview: leave Record-only pages their own loop, hand the clock back after a recording

Claude6a6cba53ff02
diff --git a/client/src/components/codeAnimation/CodeAnimationPreview.test.jsx b/client/src/components/codeAnimation/CodeAnimationPreview.test.jsx
index 01b75c170a..76edbfaa1d 100644
--- a/client/src/components/codeAnimation/CodeAnimationPreview.test.jsx
+++ b/client/src/components/codeAnimation/CodeAnimationPreview.test.jsx
@@ -315,6 +315,33 @@ describe('CodeAnimationPreview playhead', () => {
await user.click(screen.getByRole('button', { name: 'Pause' }));
expect(screen.getByRole('button', { name: 'Play' })).toBeTruthy();
});
+
+ it('leaves the film its own clock while recording, then holds it at the playhead again', async () => {
+ const user = userEvent.setup();
+ vi.spyOn(HTMLMediaElement.prototype, 'play').mockResolvedValue(undefined);
+ vi.spyOn(HTMLMediaElement.prototype, 'pause').mockImplementation(() => {});
+ renderPreview({ audioUrl: '/data/music/take.wav' });
+ await user.click(screen.getByRole('button', { name: 'Preview without audio' }));
+ await waitFor(() => expect(seeks().at(-1)).toMatchObject({ t: 0, playing: false }));
+ const open = previewOpens().at(-1)[1];
+ const sessionId = socket.__sessions.get(open.requestId);
+ fireEvent.change(screen.getByLabelText('Playhead'), { target: { value: '2.5' } });
+ await user.click(screen.getByRole('button', { name: 'Play' }));
+
+ await user.click(screen.getByRole('button', { name: /record \(real-time\)/i }));
+ const recordAt = socket.emit.mock.calls.findIndex(([event, payload]) => event === 'generated-preview:command' && payload.action === 'record');
+ expect(recordAt).toBeGreaterThan(-1);
+ await waitFor(() => expect(screen.getByRole('button', { name: 'Play' })).toBeDisabled());
+ expect(socket.emit.mock.calls.slice(recordAt).some(([event]) => event === 'generated-preview:seek')).toBe(false);
+
+ await act(async () => {
+ for (const fn of socket.__handlers.get('generated-preview:recording') || []) {
+ fn({ requestId: open.requestId, sessionId, index: 0, count: 1, mime: 'video/webm', chunk: btoa('x') });
+ }
+ });
+ await waitFor(() => expect(socket.emit.mock.calls.slice(recordAt).some(([event, payload]) => event === 'generated-preview:seek' && payload.playing === false)).toBe(true));
+ expect(screen.getByRole('button', { name: 'Play' })).toBeEnabled();
+ });
});
describe('CodeAnimationPreview frame-exact export', () => {
diff --git a/client/src/components/codeAnimation/CodeAnimationTransport.jsx b/client/src/components/codeAnimation/CodeAnimationTransport.jsx
index 31419d8b0b..b2fd0363bf 100644
--- a/client/src/components/codeAnimation/CodeAnimationTransport.jsx
+++ b/client/src/components/codeAnimation/CodeAnimationTransport.jsx
@@ -40,29 +40,37 @@ export default function CodeAnimationTransport({ preview, duration, fps = 24, au
return clock ? clock.from + (performance.now() - clock.startedAt) / 1000 : t;
}, [audioUrl, t]);
- const pause = useCallback((time) => {
+ // Stops local playback only; `pause` also holds the film at that time.
+ const stop = useCallback((time) => {
const next = Math.min(Math.max(0, Number.isFinite(time) ? time : 0), end);
audioRef.current?.pause?.();
if (audioRef.current && audioUrl) audioRef.current.currentTime = next;
clockRef.current = null;
setPlaying(false);
setT(next);
- seekPreview(next);
- }, [end, audioUrl, seekPreview]);
+ return next;
+ }, [end, audioUrl]);
+ const pause = useCallback((time) => seekPreview(stop(time)), [stop, seekPreview]);
// Effects below read the latest clock through this ref, so a tick or a new
// session does not re-run them.
const latest = useRef(null);
- latest.current = { now, pause, end, duration, fps, seekPreview, playing };
+ latest.current = { now, stop, pause, end, duration, fps, seekPreview, playing };
// A new session opens on the film's own loop; take it over at the start.
useEffect(() => {
if (preview.ready) latest.current.pause(0);
}, [preview.ready, preview.sessionId]);
- // A real-time record runs on the film's own clock.
+ // A real-time record runs on the film's own clock, so starting one stops
+ // playback without a seek (which would hold the clock again); once it ends
+ // the film is held back at the playhead.
+ const wasDisabled = useRef(disabled);
useEffect(() => {
- if (disabled && latest.current.playing) latest.current.pause(latest.current.now());
+ const clock = latest.current;
+ if (disabled) clock.stop(clock.now());
+ else if (wasDisabled.current) clock.pause(clock.now());
+ wasDisabled.current = disabled;
}, [disabled]);
const play = async () => {
diff --git a/server/services/generatedPreview/sessions.js b/server/services/generatedPreview/sessions.js
index d50fb4dbbc..04bd704a12 100644
--- a/server/services/generatedPreview/sessions.js
+++ b/server/services/generatedPreview/sessions.js
@@ -182,9 +182,12 @@ async function applyJson(page, globalName, value) {
// A Code Animation page runs its own requestAnimationFrame clock. A seek takes
// that clock over: callbacks are held (not dropped) so releasing them, before a
// real-time record, resumes the page's loop. One native frame passes after the
-// hold so a callback already queued cannot paint over the requested time.
+// hold so a callback already queued cannot paint over the requested time. A
+// page without renderFrame(t) (Record-only, or a module not yet run) keeps its
+// own loop, since nothing else could draw the held frames.
const holdCodeAnimationClock = (time) => `(async () => {
const w = window;
+ if (typeof w.renderFrame !== 'function') return false;
if (!w.__portosClock) {
const raf = w.requestAnimationFrame.bind(w);
const clock = { raf, held: [], on: false };
@@ -200,7 +203,8 @@ const holdCodeAnimationClock = (time) => `(async () => {
clock.on = true;
await Promise.race([new Promise((resolve) => clock.raf(() => resolve())), new Promise((resolve) => setTimeout(resolve, 100))]);
}
- if (typeof w.renderFrame === 'function') w.renderFrame(${time});
+ await w.renderFrame(${time});
+ return true;
})()`;
const RELEASE_CODE_ANIMATION_CLOCK = `(() => {
diff --git a/server/services/generatedPreview/sessions.test.js b/server/services/generatedPreview/sessions.test.js
index 8f0ea4f6de..d8548bc5d4 100644
--- a/server/services/generatedPreview/sessions.test.js
+++ b/server/services/generatedPreview/sessions.test.js
@@ -608,4 +608,26 @@ describe('code animation playhead', () => {
await vi.waitFor(() => expect(win.postMessage).toHaveBeenCalledWith({ type: 'example:record' }, '*'));
await vi.waitFor(() => expect(drawn.at(-1)).toBeGreaterThanOrEqual(100));
});
+
+ it('leaves a page without renderFrame on its own loop', async () => {
+ let frames = 0;
+ const win = { requestAnimationFrame: (callback) => setTimeout(() => callback(performance.now()), 1), postMessage: vi.fn() };
+ const tick = () => { frames += 1; win.requestAnimationFrame(tick); };
+ fixture.page = {
+ evaluate: (source) => new Function('window', 'return ' + source)(win),
+ send: async () => ({ data: 'frame' }),
+ close: async () => {},
+ };
+ registerGeneratedPreviewHandlers(socket);
+ const requestId = '00000000-0000-4000-8000-000000000003';
+ socket.handlers.get('generated-preview:open')({ requestId, kind: 'code-animation', html: '<canvas></canvas>' });
+ 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;
+ tick();
+
+ socket.handlers.get('generated-preview:seek')({ requestId, sessionId, generation: 1, t: 2.5 });
+ await new Promise((resolve) => setTimeout(resolve, 20));
+ const after = frames;
+ await vi.waitFor(() => expect(frames).toBeGreaterThan(after + 3));
+ });
});