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]);