From 30d4cd26c65637254f5f1fa374fe5160af9593c9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20=C3=81ngel?= Date: Wed, 18 Nov 2026 17:15:05 +0000 Subject: [PATCH] fix(studio): copy, duplicate and audio lane updates work in a sealed preview (#8192) * fix(studio): copy, duplicate and audio lane updates work in a sealed preview * fix(studio): a sealed copy keeps its starting selection, and a stale lane read is dropped * fix(studio): a saved lane value outlasts an older sealed read, and cut deletes in its own project --- .../src/hooks/domEditCommits.sealed.test.ts | 29 +++ .../src/hooks/timelineAudioGroupVolume.ts | 2 +- .../src/hooks/timelineEditingHelpers.ts | 13 +- .../src/hooks/useClipboard.sealed.test.ts | 151 +++++++++++++++ packages/studio/src/hooks/useClipboard.ts | 178 +++++++++++------- .../src/hooks/useDomEditAttributeCommits.ts | 8 +- .../studio/src/hooks/usePreviewPersistence.ts | 18 +- .../player/lib/automationStoreSync.test.ts | 73 ++++++- .../src/player/lib/automationStoreSync.ts | 21 +++ 9 files changed, 409 insertions(+), 84 deletions(-) create mode 100644 packages/studio/src/hooks/useClipboard.sealed.test.ts diff --git a/packages/studio/src/hooks/domEditCommits.sealed.test.ts b/packages/studio/src/hooks/domEditCommits.sealed.test.ts index dc9dfa7421..83f106fde3 100644 --- a/packages/studio/src/hooks/domEditCommits.sealed.test.ts +++ b/packages/studio/src/hooks/domEditCommits.sealed.test.ts @@ -14,6 +14,8 @@ import type { DomEditSelection } from "../components/editor/domEditing"; import type { PersistDomEditOperations } from "./domEditCommitTypes"; import { commitDomStyles } from "./domStyleCommit"; import { useDomEditAttributeCommits } from "./useDomEditAttributeCommits"; +import { usePlayerStore } from "../player/store/playerStore"; +import { syncStoredAutomationFromFrame } from "../player/lib/automationStoreSync"; (globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT: boolean }).IS_REACT_ACT_ENVIRONMENT = true; @@ -158,6 +160,33 @@ describe("DOM edit commits in a sealed preview", () => { expect(card.getAttribute("title")).toBe("Card"); }); + it("records a sealed automation save in the timeline's store", async () => { + const { iframe, selection } = await sealedCard(``); + const clip = { id: "card", key: "card", tag: "audio", start: 0, duration: 4, track: 1 }; + usePlayerStore.setState({ elements: [{ ...clip, domId: "card", volume: 1 }] }); + const commits = attributeCommits( + iframe, + selection, + vi.fn(async () => undefined), + ); + await act(() => commits.handleDomAttributeQuietCommit("volume", "0.25")); + await vi.waitFor(() => expect(usePlayerStore.getState().elements[0]?.volume).toBe(0.25)); + usePlayerStore.getState().reset(); + }); + + it("drops a sealed lane read when the frame loads before it answers", async () => { + const { iframe } = await sealedCard(``); + const clip = { id: "card", key: "card", tag: "audio", start: 0, duration: 4, track: 1 }; + usePlayerStore.setState({ elements: [{ ...clip, domId: "card", volume: 1 }] }); + syncStoredAutomationFromFrame(iframe); + iframe.dispatchEvent(new Event("load")); + await settle(); + expect(usePlayerStore.getState().elements[0]?.volume).toBe(1); + syncStoredAutomationFromFrame(iframe); + await vi.waitFor(() => expect(usePlayerStore.getState().elements[0]?.volume).toBe(0.25)); + usePlayerStore.getState().reset(); + }); + it("never puts back a value over a newer edit that saved", async () => { const { card, iframe, selection } = await sealedCard( `
Hi
`, diff --git a/packages/studio/src/hooks/timelineAudioGroupVolume.ts b/packages/studio/src/hooks/timelineAudioGroupVolume.ts index 72de070eae..2ff67164d2 100644 --- a/packages/studio/src/hooks/timelineAudioGroupVolume.ts +++ b/packages/studio/src/hooks/timelineAudioGroupVolume.ts @@ -117,7 +117,7 @@ const GROUP_ATTR_TO_MIRROR: Record< * * Invalidating the parse cache is necessary but not sufficient — it only * ensures the NEXT parse is honest, and a live attribute patch does not cause - * one. Same reason `commitDataAttribute` carries `syncStoredAutomationFromPreview`. + * one. Same reason `commitDataAttribute` carries `syncStoredAutomationFromFrame`. */ function syncStoredGroupAttribute(groupId: string, attr: string, value: string | null): void { const toPatch = GROUP_ATTR_TO_MIRROR[attr]; diff --git a/packages/studio/src/hooks/timelineEditingHelpers.ts b/packages/studio/src/hooks/timelineEditingHelpers.ts index f66f72a004..a9ae466723 100644 --- a/packages/studio/src/hooks/timelineEditingHelpers.ts +++ b/packages/studio/src/hooks/timelineEditingHelpers.ts @@ -159,7 +159,18 @@ export function findTimelineElementInIframe( ): Element | null { try { const doc = iframe?.contentDocument; - if (!doc) return null; + return doc ? findTimelineElementInDocument(doc, element, activeCompositionPath) : null; + } catch { + return null; + } +} + +export function findTimelineElementInDocument( + doc: Document, + element: TimelineElement, + activeCompositionPath: string | null, +): Element | null { + try { if (element.kind === "composition" && element.compositionSrc) { return findElementForTimelineElement(doc, element, { activeCompositionPath, diff --git a/packages/studio/src/hooks/useClipboard.sealed.test.ts b/packages/studio/src/hooks/useClipboard.sealed.test.ts new file mode 100644 index 0000000000..e732699d6a --- /dev/null +++ b/packages/studio/src/hooks/useClipboard.sealed.test.ts @@ -0,0 +1,151 @@ +// @vitest-environment happy-dom +import React, { act } from "react"; +import { createRoot, type Root } from "react-dom/client"; +import { ensureHfIds } from "@hyperframes/parsers/hf-ids"; +import { afterEach, expect, it, vi } from "vitest"; +import { useClipboard } from "./useClipboard"; +import { usePlayerStore, type TimelineElement } from "../player"; +import type { DomEditSelection } from "../components/editor/domEditing"; +import { sealedPreviewFrame } from "../player/lib/sealedPreviewFrame.test-helpers"; + +(globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT: boolean }).IS_REACT_ACT_ENVIRONMENT = true; + +const SAVED = ` +
+

Title

+

Other

+
`; + +let root: Root | null = null; +afterEach(() => { + act(() => root?.unmount()); + root = null; + vi.unstubAllGlobals(); + usePlayerStore.getState().reset(); + document.body.innerHTML = ""; +}); + +/** A sealed preview of SAVED, with the runtime's hide on the clip, and the saved file served. */ +function sealedClipboard(domSelection: DomEditSelection | null) { + const preview = new DOMParser().parseFromString(ensureHfIds(SAVED), "text/html"); + document.body.innerHTML = preview.body.innerHTML; + document.getElementById("title")!.style.cssText = "visibility: hidden; display: none"; + vi.stubGlobal( + "fetch", + vi.fn(async () => new Response(JSON.stringify({ content: SAVED }))), + ); + const { iframe } = sealedPreviewFrame(); + const writes: string[] = []; + const deleted: string[] = []; + const view = { projectId: "p" }; + let api: ReturnType | null = null; + function Harness() { + api = useClipboard({ + projectId: view.projectId, + activeCompPath: "index.html", + domEditSelectionRef: { current: domSelection }, + showToast: () => {}, + writeProjectFile: async (_path: string, content: string) => void writes.push(content), + recordEdit: async () => {}, + reloadPreview: () => {}, + handleTimelineElementsDelete: async (elements) => + void deleted.push(...elements.map((el) => el.id)), + handleDomEditElementDelete: async () => {}, + previewIframeRef: { current: iframe }, + waitForPendingDomEditSaves: () => Promise.resolve(), + }); + return null; + } + root = createRoot(document.createElement("div")); + act(() => root?.render(React.createElement(Harness))); + const openProject = (projectId: string) => { + view.projectId = projectId; + act(() => root?.render(React.createElement(Harness))); + }; + return { clipboard: () => api as ReturnType, writes, deleted, openProject }; +} + +const clipOf = (id: string, tag: string, start: number, track: number): TimelineElement => ({ + id, + domId: id, + tag, + start, + duration: 2, + track, + authoredTrack: track, + sourceFile: "index.html", +}); +const CLIPS = [clipOf("title", "h1", 2, 0), clipOf("other", "h2", 6, 1)]; + +function selectClip(id: string) { + usePlayerStore.setState({ selectedElementId: id, selectedElementIds: new Set([id]) }); +} + +function selectTitleClip() { + usePlayerStore.setState({ elements: CLIPS }); + selectClip("title"); +} + +it("duplicates a timeline clip from a sealed preview, as saved", async () => { + selectTitleClip(); + const { clipboard, writes } = sealedClipboard(null); + expect(await clipboard().handleDuplicate()).toBe(true); + expect(writes[0]?.match(/>Title<\/h1>/g)).toHaveLength(2); + expect(writes[0]).not.toContain("display: none"); +}); + +it("copies a timeline clip from a sealed preview, as saved", async () => { + selectTitleClip(); + const { clipboard, writes } = sealedClipboard(null); + expect(clipboard().handleCopy()).toBe(true); + await clipboard().handlePaste(); + expect(writes[0]).toContain(">Title"); + expect(writes[0]).not.toContain("display: none"); +}); + +it("copies a canvas selection from a sealed preview, as saved", async () => { + const selection = { + id: "title", + selector: "#title", + sourceFile: "index.html", + } as DomEditSelection; + const { clipboard, writes } = sealedClipboard(selection); + expect(clipboard().handleCopy()).toBe(true); + await clipboard().handlePaste(); + expect(writes[0]).toContain(">Title"); + expect(writes[0]).not.toContain("display: none"); +}); + +it("leaves the clipboard as it was when a sealed preview lacks the element", async () => { + const selection = { id: "gone", selector: "#gone", sourceFile: "index.html" } as DomEditSelection; + const { clipboard, writes } = sealedClipboard(selection); + clipboard().handleCopy(); + await clipboard().handlePaste(); + expect(writes).toEqual([]); +}); + +it("cuts, and duplicates, the clip selected when the key was pressed, not one selected meanwhile", async () => { + selectTitleClip(); + const { clipboard, writes, deleted } = sealedClipboard(null); + const cut = clipboard().handleCut(); + selectClip("other"); + expect(await cut).toBe(true); + expect(deleted).toEqual(["title"]); + await clipboard().handlePaste(); + expect(writes[0]?.match(/>Title<\/h1>/g)).toHaveLength(2); + selectClip("title"); + const duplicate = clipboard().handleDuplicate(); + selectClip("other"); + expect(await duplicate).toBe(true); + expect(writes[1]?.match(/>Title<\/h1>/g)).toHaveLength(2); + expect(writes[1]?.match(/>Other<\/h2>/g)).toHaveLength(1); +}); + +it("deletes nothing when another project opened while a sealed cut waited", async () => { + selectTitleClip(); + const { clipboard, deleted, openProject } = sealedClipboard(null); + const cut = clipboard().handleCut(); + openProject("q"); + expect(await cut).toBe(false); + expect(deleted).toEqual([]); +}); diff --git a/packages/studio/src/hooks/useClipboard.ts b/packages/studio/src/hooks/useClipboard.ts index da89a9639c..fa7ac05e4d 100644 --- a/packages/studio/src/hooks/useClipboard.ts +++ b/packages/studio/src/hooks/useClipboard.ts @@ -18,7 +18,8 @@ import { extendRootDurationInSource } from "../utils/rootDuration"; import { saveProjectFilesWithHistory } from "../utils/studioFileHistory"; import { formatTimelineAttributeNumber } from "../player/components/timelineEditing"; import { findElementForSelection } from "../components/editor/domEditingElement"; -import { findTimelineElementInIframe, readFileContent } from "./timelineEditingHelpers"; +import { findTimelineElementInDocument, readFileContent } from "./timelineEditingHelpers"; +import { previewDocumentCopy, previewFrameOpaque } from "../player/lib/previewChannel"; import { buildTimelineElementKey } from "../player/lib/timelineElementHelpers"; import { timeRangesOverlap } from "../player/components/timelineCollision"; import { @@ -93,20 +94,47 @@ function clipToast(verbPast: string, clipCount: number): string { return clipCount > 1 ? `${verbPast} ${clipCount} clips` : `${verbPast} clip`; } -function getSelectedDomElement( - iframeRef: React.MutableRefObject, - selection: DomEditSelection, - activeCompositionPath: string | null, -): Element | null { +/** A sealed frame's document is read off a copy of it, so it comes later. */ +function inPreviewDocument( + iframe: HTMLIFrameElement | null, + find: (doc: Document | null) => T, +): T | Promise { + if (iframe && previewFrameOpaque(iframe)) return previewDocumentCopy(iframe).then(find); let doc: Document | null = null; try { - doc = iframeRef.current?.contentDocument ?? null; + doc = iframe?.contentDocument ?? null; } catch { - return null; + doc = null; } - if (!doc) return null; + return find(doc); +} - return findElementForSelection(doc, selection, activeCompositionPath); +type CopyTarget = T | { refused: string } | null; +const refusal = (target: unknown): target is { refused: string } => + typeof target === "object" && target !== null && "refused" in target; + +type Toast = (message: string, tone?: "error" | "info") => void; + +function foundOrToast(found: CopyTarget, showToast: Toast): T | null { + if (!refusal(found)) return found; + showToast(found.refused, "info"); + return null; +} + +/** A miss found now toasts and copies nothing; a sealed frame's arrives later, as the copy's error. */ +function copyFound( + found: CopyTarget | Promise>, + copy: (target: T) => Promise, + showToast: Toast, +): Promise | null { + if (found instanceof Promise) + return found.then((target) => { + if (target === null) throw new Error("Nothing selected to copy."); + if (refusal(target)) throw new Error(target.refused); + return copy(target); + }); + const target = foundOrToast(found, showToast); + return target === null ? null : copy(target); } function savedMarkupElseLive(saved: Document, live: Element, sourceFile: string): string { @@ -269,8 +297,7 @@ export function useClipboard({ // After any save still in flight on the file, so a copy right after an edit takes the edit. const readSaved = useCallback( - async (path: string): Promise => { - const pid = projectIdRef.current; + async (path: string, pid: string | null): Promise => { if (!pid) throw new Error("No project is open."); // Only the order matters here; a failed save already shows its own banner. await waitForPendingDomEditSaves().catch(() => {}); @@ -281,34 +308,33 @@ export function useClipboard({ [waitForPendingDomEditSaves, writeProjectFile], ); - // Resolved through findTimelineElementInIframe, the same composition-aware + // Resolved through findTimelineElementInDocument, the same composition-aware // lookup every other timeline editor uses — unlike findElementForSelection, // it can address a composition-instance clip's root. - const findSelectedClips = useCallback((): { - elements: TimelineElement[]; - lives: Element[]; - } | null => { - const selected = getSelectedElements(); - if (selected.length === 0) return null; - const lives: Element[] = []; - for (const element of selected) { - const live = findTimelineElementInIframe(previewIframeRef.current, element, activeCompPath); - if (!live) { - showToast(`Unable to copy "${element.label ?? element.id}".`, "info"); - return null; + const findSelectedClips = useCallback( + ( + selected: TimelineElement[], + doc: Document | null, + ): CopyTarget<{ elements: TimelineElement[]; lives: Element[] }> => { + if (selected.length === 0) return null; + const lives: Element[] = []; + for (const element of selected) { + const live = doc && findTimelineElementInDocument(doc, element, activeCompPath); + if (!live) return { refused: `Unable to copy "${element.label ?? element.id}".` }; + lives.push(live); } - lives.push(live); - } - return { elements: selected, lives }; - }, [activeCompPath, previewIframeRef, showToast]); + return { elements: selected, lives }; + }, + [activeCompPath], + ); const readClips = useCallback( - async (targets: { - elements: TimelineElement[]; - lives: Element[]; - }): Promise => { + async ( + targets: { elements: TimelineElement[]; lives: Element[] }, + pid: string | null, + ): Promise => { const paths = targets.elements.map((el) => el.sourceFile || activeCompPath || "index.html"); - const markup = await readSavedMarkup(readSaved, paths, targets.lives); + const markup = await readSavedMarkup((path) => readSaved(path, pid), paths, targets.lives); return targets.elements.map((element, index) => ({ html: markup[index] as string, start: element.start, @@ -322,41 +348,50 @@ export function useClipboard({ [activeCompPath, readSaved], ); + // The gesture's selection and project, taken before a sealed frame's read: the person can move on meanwhile. const copyTimelineSelection = useCallback((): Promise | null => { - const targets = findSelectedClips(); - if (!targets) return null; - const sourceFile = targets.elements[0]?.sourceFile || activeCompPath || "index.html"; - return readClips(targets).then((clips) => { - showToast(clips.length > 1 ? `Copied ${clips.length} clips` : "Copied clip", "info"); - return { - kind: "timeline-clip", - clips, - sourceFile, - projectId: projectIdRef.current ?? undefined, - copiedInComposition: activeCompPath || "index.html", - }; - }); - }, [activeCompPath, findSelectedClips, readClips, showToast]); + const selected = getSelectedElements(); + const pid = projectIdRef.current; + const found = inPreviewDocument(previewIframeRef.current, (doc) => + findSelectedClips(selected, doc), + ); + const copy = (targets: { elements: TimelineElement[]; lives: Element[] }) => { + const sourceFile = targets.elements[0]?.sourceFile || activeCompPath || "index.html"; + return readClips(targets, pid).then((clips): ClipboardPayload => { + showToast(clips.length > 1 ? `Copied ${clips.length} clips` : "Copied clip", "info"); + return { + kind: "timeline-clip", + clips, + sourceFile, + projectId: pid ?? undefined, + copiedInComposition: activeCompPath || "index.html", + }; + }); + }; + return copyFound(found, copy, showToast); + }, [activeCompPath, findSelectedClips, previewIframeRef, readClips, showToast]); const copyDomSelection = useCallback( (domSelection: DomEditSelection): Promise | null => { - const live = getSelectedDomElement(previewIframeRef, domSelection, activeCompPath); - if (!live) { - showToast("Unable to copy this element.", "info"); - return null; - } - const sourceFile = domSelection.sourceFile || activeCompPath || "index.html"; - return readSaved(sourceFile).then((content) => { - showToast("Copied element", "info"); - return { - kind: "dom-element", - html: savedMarkupElseLive(parseSavedSource(content), live, sourceFile), - sourceFile, - projectId: projectIdRef.current ?? undefined, - originSelector: domSelection.selector, - originSelectorIndex: domSelection.selectorIndex, - }; + const pid = projectIdRef.current; + const found = inPreviewDocument(previewIframeRef.current, (doc) => { + const live = doc && findElementForSelection(doc, domSelection, activeCompPath); + return live ?? { refused: "Unable to copy this element." }; }); + const sourceFile = domSelection.sourceFile || activeCompPath || "index.html"; + const copy = (live: Element) => + readSaved(sourceFile, pid).then((content): ClipboardPayload => { + showToast("Copied element", "info"); + return { + kind: "dom-element", + html: savedMarkupElseLive(parseSavedSource(content), live, sourceFile), + sourceFile, + projectId: pid ?? undefined, + originSelector: domSelection.selector, + originSelectorIndex: domSelection.selectorIndex, + }; + }); + return copyFound(found, copy, showToast); }, [activeCompPath, previewIframeRef, readSaved, showToast], ); @@ -456,10 +491,13 @@ export function useClipboard({ // selection's end or start here, the playhead or the copy's own time there). const handleDuplicate = useCallback( async (options?: InPlace): Promise => { - const targets = findSelectedClips(); - if (!targets) return false; + const selected = getSelectedElements(); const pid = projectIdRef.current; - if (!pid) return false; + const found = await inPreviewDocument(previewIframeRef.current, (doc) => + findSelectedClips(selected, doc), + ); + const targets = foundOrToast(found, showToast); + if (!targets || !pid || projectIdRef.current !== pid) return false; const { elements } = targets; const pathOf = (el: TimelineElement) => el.sourceFile || activeCompPath || "index.html"; @@ -473,7 +511,7 @@ export function useClipboard({ ); try { - const clips = await readClips(targets); + const clips = await readClips(targets, pid); let ids: string[] = []; const duplicate = (originalContent: string) => { const liveElements = usePlayerStore @@ -513,6 +551,7 @@ export function useClipboard({ [ activeCompPath, findSelectedClips, + previewIframeRef, readClips, recordEdit, reloadPreview, @@ -524,8 +563,9 @@ export function useClipboard({ const handleCut = useCallback(async (): Promise => { const selected = getSelectedElements(); const domSelection = domEditSelectionRef.current; + const pid = projectIdRef.current; const copied = copyToClipboard(); - if (!copied || !(await copied)) return false; + if (!copied || !(await copied) || projectIdRef.current !== pid) return false; if (selected.length > 0) { // One call for the whole selection, not one per element: the batched diff --git a/packages/studio/src/hooks/useDomEditAttributeCommits.ts b/packages/studio/src/hooks/useDomEditAttributeCommits.ts index c8c39bcca1..6e78f9be2f 100644 --- a/packages/studio/src/hooks/useDomEditAttributeCommits.ts +++ b/packages/studio/src/hooks/useDomEditAttributeCommits.ts @@ -11,7 +11,7 @@ import { reportDomEditPersistFailure, } from "./domEditPersistFailure"; import { bumpDomEditCommitMapVersion, runDomEditCommit } from "./domEditCommitRunner"; -import { syncStoredAutomationFromPreview } from "../player/lib/automationStoreSync"; +import { syncStoredAutomationFromFrame } from "../player/lib/automationStoreSync"; import { HF_AUDIO_GROUP_ATTR, HF_AUDIO_GROUP_TAG } from "@hyperframes/core/audio-groups"; import { invalidateGroupInfoCache } from "../player/lib/timelineGroupInfo"; import { editSealedSelection } from "../components/editor/previewSelection"; @@ -215,7 +215,7 @@ export function useDomEditAttributeCommits({ // the audio while the lane went on drawing what it had, until a reload. // One sink here rather than a sync in each writer, because three of them // shipped without one. - syncStoredAutomationFromPreview(previewIframeRef.current?.contentDocument ?? null); + syncStoredAutomationFromFrame(previewIframeRef.current); }, onSettled: options.onSettled, onFinally: isLatestCommit.release, @@ -318,7 +318,7 @@ export function useDomEditAttributeCommits({ resync: () => { refreshDomEditSelectionFromPreview(selection); if (options.syncAutomation) { - syncStoredAutomationFromPreview(previewIframeRef.current?.contentDocument ?? null); + syncStoredAutomationFromFrame(previewIframeRef.current); } }, onSettled: (ok) => { @@ -482,7 +482,7 @@ export function useDomEditAttributeCommits({ // the audio while the lane went on drawing what it had, until a reload. // One sink here rather than a sync in each writer, because three of them // shipped without one. - syncStoredAutomationFromPreview(previewIframeRef.current?.contentDocument ?? null); + syncStoredAutomationFromFrame(previewIframeRef.current); }, onFinally: isLatestCommit.release, }); diff --git a/packages/studio/src/hooks/usePreviewPersistence.ts b/packages/studio/src/hooks/usePreviewPersistence.ts index aeb603117c..016b893aa7 100644 --- a/packages/studio/src/hooks/usePreviewPersistence.ts +++ b/packages/studio/src/hooks/usePreviewPersistence.ts @@ -30,7 +30,10 @@ import { import { settleNestedReads } from "../utils/gsapSoftReload"; import { readProjectFileContent } from "../utils/studioFileHistory"; import { usePlayerStore } from "../player"; -import { syncStoredAutomationFromPreview } from "../player/lib/automationStoreSync"; +import { + syncStoredAutomationFromFrame, + syncStoredAutomationFromPreview, +} from "../player/lib/automationStoreSync"; /** The restore payload the undo/redo preview-sync consumes (from the history store). */ interface HistoryPreviewRestore { @@ -123,6 +126,11 @@ async function clearLegacyStudioMotionFile( // ── Hook ── +const projectFileReader = (projectId: string | null) => (path: string) => + projectId + ? readProjectFileContent(projectId, path) + : Promise.reject(new Error("No project is open to read nested files from.")); + export function usePreviewPersistence({ showToast, readOptionalProjectFile: _readOptionalProjectFile, @@ -226,16 +234,12 @@ export function usePreviewPersistence({ // attributes onto the live DOM and re-runs the timeline at the SAME playhead, // falling back to reloadPreview for anything structural (split/delete undo), // multi-file, sub-comp, or a permanent soft-reload failure. - const projectId = usePlayerStore.getState().timelineProjectId; const nestedFiles = await settleNestedReads( readUndoNestedFiles( previewIframeRef.current, activeCompPathRef.current, restore.files, - (path) => - projectId - ? readProjectFileContent(projectId, path) - : Promise.reject(new Error("No project is open to read nested files from.")), + projectFileReader(usePlayerStore.getState().timelineProjectId), ), ); const held = heldPreviewDoc(); @@ -260,7 +264,7 @@ export function usePreviewPersistence({ // player store keeps its own copy and that copy is what the automation lanes // draw — so without this an undone envelope edit stayed invisible until a // reload. The full path above waits for the reloaded preview to report instead. - syncStoredAutomationFromPreview(previewIframeRef.current?.contentDocument ?? null); + syncStoredAutomationFromFrame(previewIframeRef.current); }, [previewIframeRef, activeCompPathRef, reloadPreview, heldPreviewDoc], ); diff --git a/packages/studio/src/player/lib/automationStoreSync.test.ts b/packages/studio/src/player/lib/automationStoreSync.test.ts index d8c8ea94e1..a1873bbe7a 100644 --- a/packages/studio/src/player/lib/automationStoreSync.test.ts +++ b/packages/studio/src/player/lib/automationStoreSync.test.ts @@ -1,6 +1,10 @@ // @vitest-environment happy-dom -import { beforeEach, describe, expect, it } from "vitest"; -import { syncStoredAutomationFromPreview, syncStoredElementAttribute } from "./automationStoreSync"; +import { beforeEach, describe, expect, it, vi } from "vitest"; +import { + syncStoredAutomationFromFrame, + syncStoredAutomationFromPreview, + syncStoredElementAttribute, +} from "./automationStoreSync"; import { usePlayerStore, type TimelineElement } from "../store/playerStore"; const TWO_POINTS = '{"version":1,"lanes":[{"target":"volume","points":[{"t":0,"v":1}]}]}'; @@ -28,8 +32,26 @@ function previewWith(attrs: Record): Document { return doc; } +// A sealed frame's document copy, answered when the test says. +const copies = vi.hoisted(() => [] as Array<(doc: Document) => void>); +vi.mock("./previewChannel", async (importOriginal) => ({ + ...(await importOriginal()), + previewFrameOpaque: (iframe: HTMLIFrameElement) => iframe.dataset.sealed === "true", + previewDocumentCopy: () => new Promise((resolve) => copies.push(resolve)), +})); + +function frame(sealed: boolean, doc?: Document): HTMLIFrameElement { + const iframe = document.createElement("iframe"); + iframe.dataset.sealed = String(sealed); + if (doc) Object.defineProperty(iframe, "contentDocument", { value: doc }); + return iframe; +} + +const settle = () => new Promise((resolve) => setTimeout(resolve)); + beforeEach(() => { usePlayerStore.getState().reset(); + copies.length = 0; }); describe("syncStoredElementAttribute", () => { @@ -163,3 +185,50 @@ describe("syncStoredAutomationFromPreview", () => { expect(stored?.audioGroupFxChain).toBe(chain); }); }); + +describe("syncStoredAutomationFromFrame", () => { + beforeEach(() => + usePlayerStore.setState({ elements: [el({ volume: 1 })], timelineProjectId: "a" }), + ); + const volume = () => usePlayerStore.getState().elements[0]?.volume; + + it("records a sealed frame's copy once it arrives", async () => { + syncStoredAutomationFromFrame(frame(true)); + copies[0]!(previewWith({ "data-volume": "0.2" })); + await settle(); + expect(volume()).toBe(0.2); + }); + + it("keeps the later of two sealed reads when the earlier answers last", async () => { + syncStoredAutomationFromFrame(frame(true)); + syncStoredAutomationFromFrame(frame(true)); + copies[1]!(previewWith({ "data-volume": "0.8" })); + copies[0]!(previewWith({ "data-volume": "0.2" })); + await settle(); + expect(volume()).toBe(0.8); + }); + + it("drops a sealed read once a live sync ran after it", async () => { + syncStoredAutomationFromFrame(frame(true)); + syncStoredAutomationFromFrame(frame(false, previewWith({ "data-volume": "0.8" }))); + copies[0]!(previewWith({ "data-volume": "0.2" })); + await settle(); + expect(volume()).toBe(0.8); + }); + + it("drops a sealed read once the timeline saved a newer value", async () => { + syncStoredAutomationFromFrame(frame(true)); + syncStoredElementAttribute(el(), "data-volume", "0.8"); + copies[0]!(previewWith({ "data-volume": "0.2" })); + await settle(); + expect(volume()).toBe(0.8); + }); + + it("drops a sealed read once another project is open", async () => { + syncStoredAutomationFromFrame(frame(true)); + usePlayerStore.setState({ timelineProjectId: "b" }); + copies[0]!(previewWith({ "data-volume": "0.2" })); + await settle(); + expect(volume()).toBe(1); + }); +}); diff --git a/packages/studio/src/player/lib/automationStoreSync.ts b/packages/studio/src/player/lib/automationStoreSync.ts index 0d926e4adb..e115be2953 100644 --- a/packages/studio/src/player/lib/automationStoreSync.ts +++ b/packages/studio/src/player/lib/automationStoreSync.ts @@ -30,6 +30,10 @@ import { resolveMediaElement, } from "./timelineElementHelpers"; import { elementVolume, parseStoredVolume } from "./storedVolume"; +import { previewDocumentCopy, previewFrameOpaque } from "./previewChannel"; + +/** Every sync and saved-value write: a sealed read lands only if none ran after it began. */ +let syncs = 0; /** * Re-read every element's automation, FX-chain, fade and volume attributes from the preview @@ -67,6 +71,7 @@ function syncedFields(doc: Document, element: TimelineElement, node: Element) { } export function syncStoredAutomationFromPreview(doc: Document | null | undefined): void { + syncs += 1; if (!doc) return; const findNode = previewElementFinder(doc); usePlayerStore.setState((state) => { @@ -86,6 +91,21 @@ export function syncStoredAutomationFromPreview(doc: Document | null | undefined }); } +/** + * `syncStoredAutomationFromPreview` for a preview frame. A sealed one is read off a copy, which lands + * only if no other sync or saved write ran and the project is the one read; a frame load drops the read. + */ +export function syncStoredAutomationFromFrame(iframe: HTMLIFrameElement | null | undefined): void { + if (!iframe) return; + if (!previewFrameOpaque(iframe)) return syncStoredAutomationFromPreview(iframe.contentDocument); + const read = ++syncs; + const project = usePlayerStore.getState().timelineProjectId; + void previewDocumentCopy(iframe).then((doc) => { + if (read === syncs && usePlayerStore.getState().timelineProjectId === project) + syncStoredAutomationFromPreview(doc); + }); +} + /** Discovery's rule (applyFadeMetadataFromElement): a fade of 0 is no fade. */ const storedFade = (seconds: number) => (seconds > 0 ? seconds : undefined); @@ -106,6 +126,7 @@ export function syncStoredElementAttribute( ): void { const fields = STORED_FIELD[attr]?.(value); if (!fields) return; + syncs += 1; const key = getTimelineElementIdentity(target); const same = (element: TimelineElement) => (Object.keys(fields) as (keyof TimelineElement)[]).every((k) => element[k] === fields[k]);