Files
hyperframes/packages/studio/src/hooks/timelineTimingSync.test.ts
T
Miguel Ángel cd82ce044d perf(studio): drag and resize any number of selected clips, saved in one write per file (#4937)
* feat(studio): hand-move and hand-resize any number of selected clips

* test(studio): bench dragging and resizing every clip, frame cost and drop time

* test(studio): give the bench browser launch the run timeout

* test(studio): bench request timeline offsets

* fix(studio): joining or leaving a multi-clip drag restyles a clip instead of remounting it

* fix(studio): restore the linked-selection import and mark the drag bench complex

* test(studio): find a clip's track row through the per-clip wrapper

* test(studio): resolve track rows through the per-clip wrapper in the remaining cases

* perf(studio): write a group edit's GSAP changes as one request per file

* test(studio): cover the batched GSAP write and keep the owned-chain cases

* test(studio): bench profile of the drag's pointer moves

* perf(studio): sync a group edit's root duration once per file, not once per clip

* feat(studio): a timeline move registers a still-saving revert so Cmd+Z right after it need not wait

* test(studio): the reverted move stays reverted when its save lands

* test(studio): bench prints the heaviest call chain on request

* perf(studio): preflight a many-clip selection against one index of the live tweens

* test(studio): share one timeline across the indexed lookups

* test(studio): bench failure output skips resource 404 noise

* fix(studio): the live-tween index skips timeline entries that are not objects

* fix(studio): the live-tween index skips a null timeline entry

* test(studio): bench reports the first drag frame apart from the steady ones

* test(studio): bench lists inclusive time per function on request

* test(studio): bench reports when the last write of an action landed

* test(studio): bench reports medians of save, frame and first-frame times

* refactor(studio): move the live-tween index out of gsapRuntimeKeyframes to keep it under the line cap

* fix(studio): wire the live-tween index imports and drop an unused test binding

* style(studio): format the files CI flagged

* fix(studio): keep the bench and the scale helper out of fallow's findings

* refactor(studio): one exact tween-index lookup, finish a batch file once, reuse the duration sync

* fix(studio): the tween index lists a tween once per key

* fix(studio): restore the batch-finish and named-parameter helpers

* fix(studio): undo reverts an edit still saving before painting an older predicted step

* style(studio): format the batch duration sync

* chore(studio): keep the new comments within the block and share limits

* test(studio): settle the pending edit even when the undo-order test fails

* perf(studio-server): retime every clip in a GSAP batch with one parse and one hold sync

* test(studio-server): a batch of clip retimes writes what single requests in turn write

* style: format the retime fold and its tests

* perf(parsers): clip matchers in one retime share a DOM query cache

* perf(parsers): look up every clip id in one DOM walk when retiming

* perf(studio): re-resolving the same selected node keeps its source check

* perf(studio): a drop re-renders only the selection that actually changed

* test(studio): report main-thread task time of a bulk drop

* perf(studio): a group drop updates the timeline store once, not once per clip

* fix(studio): re-reading index.html keeps sub-composition keyframes

* refactor(studio): one owner for clip-retime no-op rules and selection options

* fix(studio): reuse a source check only for the same target, and re-check on a new cache version

* fix(studio): undo confirms a reverted save only once its history claim counted

* refactor: split a retime's application out of the one-parse fold; share test fixtures

* perf(studio): drop the per-clip wrapper node so timeline scrolling stays within budget

* refactor(studio): name the drag passenger style after the passenger it styles

* fix(studio): undo keeps a move undone when its history claim landed before the key

* fix(studio): undo a timeline move and its tween shift in one step

* refactor(studio): one owner of a timeline gesture's undo window

* refactor(studio): move single-clip move and resize into their own hook

* fix(studio): a reload or second tab never joins another page's undo step

* fix(studio): a delete and its ripple stay one undo step however late the ripple lands

* fix(studio-server): date a held undo step by its last write, not by the edit that ends it
2026-10-05 01:14:24 +00:00

851 lines
32 KiB
TypeScript

// @vitest-environment happy-dom
import { afterEach, describe, expect, it, vi } from "vitest";
import { usePlayerStore } from "../player/store/playerStore";
import { jsonResponse, requestUrl } from "./fetchStubTestUtils";
import type { TimelineElement } from "../player/store/playerStore";
import {
captureDurationRollback,
finishClipTimingFallback,
finishGroupTimingGsapFallback,
finishTimelineTimingFallback,
foldGsapMutationIntoHistory,
readFileContent,
shiftGsapPositions,
} from "./timelineTimingSync";
const writeProjectFile = async () => {};
afterEach(() => {
usePlayerStore.getState().reset();
vi.restoreAllMocks();
vi.unstubAllGlobals();
});
/**
* Stub fetch: `/files/` reads return contents from the queue (repeating the
* last entry), the GSAP-mutation endpoint owns the first/last contents as its
* atomic before/after pair, and rollback succeeds conditionally.
*/
function stubFetch(
fileContents: string[],
gsapBody: unknown | Error,
supportsOwnedMutations = true,
gsapStatus = 200,
) {
const fetchMock = vi.fn(async (input: Parameters<typeof fetch>[0]): Promise<Response> => {
const url = requestUrl(input);
if (url.includes("/gsap-mutation-capabilities")) {
return supportsOwnedMutations
? jsonResponse({ atomicOwnershipPairs: true })
: new Response(JSON.stringify({ error: "not found" }), { status: 404 });
}
if (url.includes("/files/")) {
return jsonResponse({ content: fileContents.at(-1) });
}
if (url.includes("/gsap-mutation-rollback/")) {
return jsonResponse({ ok: true, restored: true, conflict: false });
}
if (url.includes("/gsap-mutations/")) {
if (gsapBody instanceof Error) {
return new Response(JSON.stringify({ error: gsapBody.message }), { status: 500 });
}
return new Response(JSON.stringify(gsapBody), {
status: gsapStatus,
headers: { "content-type": "application/json" },
});
}
throw new Error(`Unexpected fetch: ${url}`);
});
vi.stubGlobal("fetch", fetchMock);
return fetchMock;
}
function clipFallbackInput(overrides: {
reloadPreview: () => void;
recordEdit: (edit: unknown) => Promise<void>;
}) {
return {
iframe: null,
reloadPreview: overrides.reloadPreview,
projectId: "p1",
targetPath: "index.html",
domId: "clip",
label: "Move timeline clip",
recordEdit: overrides.recordEdit as never,
writeProjectFile,
edit: { kind: "shift", delta: 1 } as const,
};
}
describe("finishClipTimingFallback failure domains", () => {
it("rolls back and skips preview sync when history recording fails", async () => {
stubFetch(["<before>", "<before>", "<after>"], {
mutated: true,
scriptText: "tl.to()",
before: "<before>",
after: "<after>",
});
const reloadPreview = vi.fn();
const foldError = new Error("history fold failed");
const recordEdit = vi.fn(async () => {
throw foldError;
});
const consoleError = vi.spyOn(console, "error").mockImplementation(() => {});
await finishClipTimingFallback(clipFallbackInput({ reloadPreview, recordEdit }));
expect(recordEdit).toHaveBeenCalledTimes(1);
expect(reloadPreview).not.toHaveBeenCalled();
expect(consoleError).toHaveBeenCalledWith(expect.stringContaining("GSAP"), foldError);
const rollback = vi
.mocked(fetch)
.mock.calls.find(([input]) => requestUrl(input).includes("/gsap-mutation-rollback/"));
expect(JSON.parse(String(rollback?.[1]?.body))).toEqual({
expected: "<after>",
restore: "<before>",
});
});
it("reloads when the mutation endpoint fails after dispatch", async () => {
stubFetch(["<before>"], new Error("mutation blew up"));
const reloadPreview = vi.fn();
const recordEdit = vi.fn(async () => {});
const consoleError = vi.spyOn(console, "error").mockImplementation(() => {});
await finishClipTimingFallback(clipFallbackInput({ reloadPreview, recordEdit }));
expect(recordEdit).not.toHaveBeenCalled();
expect(reloadPreview).toHaveBeenCalledTimes(1);
expect(consoleError).toHaveBeenCalledTimes(1);
});
it("reloads when a successful response omits the exact ownership pair", async () => {
stubFetch(["<possible-write>"], {});
const reloadPreview = vi.fn();
const recordEdit = vi.fn(async () => {});
const consoleError = vi.spyOn(console, "error").mockImplementation(() => {});
await finishClipTimingFallback(clipFallbackInput({ reloadPreview, recordEdit }));
expect(recordEdit).not.toHaveBeenCalled();
expect(reloadPreview).toHaveBeenCalledTimes(1);
expect(consoleError).toHaveBeenCalledWith(
expect.stringContaining("GSAP"),
expect.objectContaining({ message: "Invalid owned GSAP mutation response" }),
);
});
it("reloads when the mutation transport fails after dispatch", async () => {
const transportError = new TypeError("connection reset");
vi.stubGlobal(
"fetch",
vi.fn(async (input: Parameters<typeof fetch>[0]) => {
const url = requestUrl(input);
if (url.includes("/gsap-mutation-capabilities")) {
return jsonResponse({ atomicOwnershipPairs: true });
}
if (url.includes("/gsap-mutations/")) throw transportError;
throw new Error(`Unexpected fetch: ${url}`);
}),
);
const reloadPreview = vi.fn();
const recordEdit = vi.fn(async () => {});
const consoleError = vi.spyOn(console, "error").mockImplementation(() => {});
await finishClipTimingFallback(clipFallbackInput({ reloadPreview, recordEdit }));
expect(recordEdit).not.toHaveBeenCalled();
expect(reloadPreview).toHaveBeenCalledTimes(1);
expect(consoleError).toHaveBeenCalledWith(
expect.stringContaining("GSAP"),
expect.objectContaining({ cause: transportError }),
);
});
it("reloads the preview when the mutation endpoint reports an ownership conflict", async () => {
stubFetch(
["<successor>"],
{ error: "file changed during GSAP mutation", conflict: true },
true,
409,
);
const reloadPreview = vi.fn();
const recordEdit = vi.fn(async () => {});
vi.spyOn(console, "error").mockImplementation(() => {});
await finishClipTimingFallback(clipFallbackInput({ reloadPreview, recordEdit }));
expect(recordEdit).not.toHaveBeenCalled();
expect(reloadPreview).toHaveBeenCalledTimes(1);
});
it("records the fold and syncs on the happy path", async () => {
stubFetch(["<before>", "<before>", "<after>"], {
mutated: true,
scriptText: "tl.to()",
before: "<before>",
after: "<after>",
});
const reloadPreview = vi.fn();
const recordEdit = vi.fn(async () => {});
await finishClipTimingFallback(clipFallbackInput({ reloadPreview, recordEdit }));
expect(recordEdit).toHaveBeenCalledTimes(1);
expect(reloadPreview).toHaveBeenCalledTimes(1);
});
it("preflights ownership support before sending a mutation", async () => {
const fetchMock = stubFetch(["<before>"], { mutated: true, scriptText: null }, false);
const reloadPreview = vi.fn();
const recordEdit = vi.fn(async () => {});
const consoleError = vi.spyOn(console, "error").mockImplementation(() => {});
await finishClipTimingFallback(clipFallbackInput({ reloadPreview, recordEdit }));
expect(
fetchMock.mock.calls.some(([input]) => requestUrl(input).includes("/gsap-mutations/")),
).toBe(false);
expect(recordEdit).not.toHaveBeenCalled();
expect(reloadPreview).toHaveBeenCalledTimes(1);
expect(consoleError).toHaveBeenCalledWith(
expect.stringContaining("GSAP"),
expect.objectContaining({ message: "Server does not support owned GSAP mutations" }),
);
});
it("reloads and surfaces a server that violates its advertised ownership contract", async () => {
const fetchMock = stubFetch(["<after>"], { mutated: true, scriptText: null });
const reloadPreview = vi.fn();
const recordEdit = vi.fn(async () => {});
const consoleError = vi.spyOn(console, "error").mockImplementation(() => {});
await finishClipTimingFallback(clipFallbackInput({ reloadPreview, recordEdit }));
expect(
fetchMock.mock.calls.some(([input]) => requestUrl(input).includes("/gsap-mutations/")),
).toBe(true);
expect(
fetchMock.mock.calls.some(([input]) =>
requestUrl(input).includes("/gsap-mutation-rollback/"),
),
).toBe(false);
expect(recordEdit).not.toHaveBeenCalled();
expect(reloadPreview).toHaveBeenCalledTimes(1);
expect(consoleError).toHaveBeenCalledWith(
expect.stringContaining("GSAP"),
expect.objectContaining({
message: "Invalid owned GSAP mutation response",
}),
);
});
});
describe("captureDurationRollback", () => {
it("restores the pre-sync duration only when it changed", () => {
usePlayerStore.getState().setDuration(4);
const rollback = captureDurationRollback(null);
// No change → rollback is a no-op (no spurious set).
rollback();
expect(usePlayerStore.getState().duration).toBe(4);
usePlayerStore.getState().setDuration(9);
rollback();
expect(usePlayerStore.getState().duration).toBe(4);
});
});
describe("fetch URL encoding (user-influenced segments)", () => {
it("URI-encodes the projectId in file reads", async () => {
const fetchMock = stubFetch(["<html>"], {});
await readFileContent("p/../evil", "index.html");
expect(requestUrl(fetchMock.mock.calls[0]![0])).toBe(
"/api/projects/p%2F..%2Fevil/files/index.html",
);
});
it("URI-encodes the projectId in GSAP mutation calls", async () => {
const fetchMock = stubFetch([], {
mutated: false,
scriptText: null,
before: "<html>",
after: "<html>",
});
await shiftGsapPositions("p one", "scenes/intro.html", "clip", 1);
expect(requestUrl(fetchMock.mock.calls[0]![0])).toBe(
"/api/projects/p%20one/gsap-mutations/scenes%2Fintro.html",
);
});
});
/**
* Live-preview iframe stub: inline GSAP script elements plus the runtime hooks
* the timing rebind needs. `appendedScripts` records any script a sync path
* executes — the rebind-only path must record NONE — and `scriptEls` lets tests
* assert the original script elements were left untouched in the document.
*/
const LIVE_SCRIPT =
'window.__timelines = window.__timelines || {}; window.__timelines["root"] = tl;';
const LIVE_CAPTION_SCRIPT =
'window.__timelines = window.__timelines || {}; window.__timelines["captions"] = capTl;';
function buildLivePreviewIframe(liveScripts: string[] = [LIVE_SCRIPT]) {
const scriptEls = liveScripts.map((text) => {
const el = document.createElement("script");
el.textContent = text;
return el;
});
const container = document.createElement("div");
for (const el of scriptEls) container.appendChild(el);
const contentWindow = {
gsap: { timeline: vi.fn(), set: vi.fn() },
__hfForceTimelineRebind: vi.fn() as unknown,
__timelines: { root: { kill: vi.fn() } } as Record<string, unknown>,
__player: { getTime: () => 0, seek: vi.fn() },
__hfStudioManualEditsApply: vi.fn(),
};
const appendedScripts: string[] = [];
const realAppendChild = container.appendChild.bind(container);
container.appendChild = <T extends Node>(node: T): T => {
const result = realAppendChild(node);
if (node instanceof HTMLScriptElement) appendedScripts.push(node.textContent ?? "");
return result;
};
const contentDocument = {
querySelectorAll: (sel: string) => (sel === "script:not([src])" ? scriptEls : []),
createElement: (tag: string) => document.createElement(tag),
body: container,
head: document.createElement("div"),
};
return {
iframe: { contentWindow, contentDocument } as unknown as HTMLIFrameElement,
contentWindow,
container,
scriptEls,
appendedScripts,
};
}
describe("nothing-to-rewrite timing edits rebind in place (no script re-execution)", () => {
it("single clip without a domId: rebinds + seeks, executes NO script, no full reload", async () => {
// A selector-addressed clip (e.g. a .sub caption) has no domId, so there is
// no GSAP mutation to run — the timing attributes are already live-patched
// and __timelines is still valid, so the runtime only needs to re-derive
// the clip windows (rebind) and re-seek. Re-running init-style scripts
// (three.js setups etc.) is exactly the unsafe case this must avoid.
const { iframe, contentWindow, container, scriptEls, appendedScripts } =
buildLivePreviewIframe();
const reloadPreview = vi.fn();
await finishClipTimingFallback({
...clipFallbackInput({ reloadPreview, recordEdit: vi.fn(async () => {}) }),
iframe,
domId: undefined,
});
expect(reloadPreview).not.toHaveBeenCalled();
expect(contentWindow.__hfForceTimelineRebind).toHaveBeenCalledTimes(1);
expect(contentWindow.__player.seek).toHaveBeenCalledTimes(1);
expect(contentWindow.__hfStudioManualEditsApply).toHaveBeenCalledTimes(1);
// NO script executed, the original script element untouched in place.
expect(appendedScripts).toHaveLength(0);
expect(container.contains(scriptEls[0]!)).toBe(true);
expect(scriptEls[0]!.textContent).toBe(LIVE_SCRIPT);
});
it("multi-script document (e.g. three.js + captions): rebind-only, both scripts untouched", async () => {
// Real compositions commonly hold heavy inline scripts (main timeline,
// three.js setup, captions). None of them may run twice — the rebind path
// must not create, remove, or re-execute any of them.
const { iframe, contentWindow, container, scriptEls, appendedScripts } = buildLivePreviewIframe(
[LIVE_SCRIPT, LIVE_CAPTION_SCRIPT],
);
const rootKill = vi.fn();
const captionsKill = vi.fn();
contentWindow.__timelines = { root: { kill: rootKill }, captions: { kill: captionsKill } };
const reloadPreview = vi.fn();
await finishClipTimingFallback({
...clipFallbackInput({ reloadPreview, recordEdit: vi.fn(async () => {}) }),
iframe,
domId: undefined,
});
expect(reloadPreview).not.toHaveBeenCalled();
expect(appendedScripts).toHaveLength(0);
expect(container.contains(scriptEls[0]!)).toBe(true);
expect(container.contains(scriptEls[1]!)).toBe(true);
// The still-valid timelines are NOT killed — nothing re-registers them.
expect(rootKill).not.toHaveBeenCalled();
expect(captionsKill).not.toHaveBeenCalled();
expect(contentWindow.__timelines.root).toBeDefined();
expect(contentWindow.__timelines.captions).toBeDefined();
// One finalization: one seek, one rebind.
expect(contentWindow.__player.seek).toHaveBeenCalledTimes(1);
expect(contentWindow.__hfForceTimelineRebind).toHaveBeenCalledTimes(1);
});
it("server-confirmed no-op with an unchanged script rebinds without executing any script", async () => {
stubFetch([], {
mutated: false,
scriptText: LIVE_SCRIPT,
before: "<same>",
after: "<same>",
});
const { iframe, contentWindow, container, scriptEls, appendedScripts } = buildLivePreviewIframe(
[LIVE_SCRIPT, LIVE_CAPTION_SCRIPT],
);
const reloadPreview = vi.fn();
await finishClipTimingFallback({
...clipFallbackInput({ reloadPreview, recordEdit: vi.fn(async () => {}) }),
iframe,
});
expect(reloadPreview).not.toHaveBeenCalled();
expect(appendedScripts).toHaveLength(0);
expect(scriptEls.every((script) => container.contains(script))).toBe(true);
expect(contentWindow.__hfForceTimelineRebind).toHaveBeenCalledTimes(1);
});
it("comp with ZERO GSAP scripts also rebinds in place (previously full-reloaded)", async () => {
// The rebind hook is installed by the runtime unconditionally — it does not
// depend on GSAP — so a script-less comp gets the flashless path too.
const { iframe, contentWindow, appendedScripts } = buildLivePreviewIframe([]);
const reloadPreview = vi.fn();
await finishClipTimingFallback({
...clipFallbackInput({ reloadPreview, recordEdit: vi.fn(async () => {}) }),
iframe,
domId: undefined,
});
expect(reloadPreview).not.toHaveBeenCalled();
expect(contentWindow.__hfForceTimelineRebind).toHaveBeenCalledTimes(1);
expect(contentWindow.__player.seek).toHaveBeenCalledTimes(1);
expect(appendedScripts).toHaveLength(0);
});
it("full-reloads when the runtime rebind hook is unavailable", async () => {
const { iframe, contentWindow, appendedScripts } = buildLivePreviewIframe();
contentWindow.__hfForceTimelineRebind = undefined;
const reloadPreview = vi.fn();
await finishClipTimingFallback({
...clipFallbackInput({ reloadPreview, recordEdit: vi.fn(async () => {}) }),
iframe,
domId: undefined,
});
expect(reloadPreview).toHaveBeenCalledTimes(1);
expect(appendedScripts).toHaveLength(0);
});
it("still full-reloads when the server MUTATED the file but returned no script", async () => {
// mutated:true with scriptText:null (older server) means the live script is
// now STALE relative to disk — a rebind against it would show wrong
// positions.
stubFetch(["<before>", "<before>", "<after>"], {
mutated: true,
scriptText: null,
before: "<before>",
after: "<after>",
});
const { iframe, contentWindow, appendedScripts } = buildLivePreviewIframe();
const reloadPreview = vi.fn();
await finishClipTimingFallback({
...clipFallbackInput({ reloadPreview, recordEdit: vi.fn(async () => {}) }),
iframe,
});
expect(reloadPreview).toHaveBeenCalledTimes(1);
expect(contentWindow.__hfForceTimelineRebind).not.toHaveBeenCalled();
expect(appendedScripts).toHaveLength(0);
});
it("mutated WITH a rewritten script keeps the script-swap soft path (not rebind-only)", async () => {
// A genuine rewrite must re-run the REWRITTEN script — the rebind-only
// shortcut is reserved for the no-op case where every script is unchanged.
stubFetch(["<before>", "<before>", "<after>"], {
mutated: true,
scriptText: 'window.__timelines["root"] = tl2;',
before: "<before>",
after: "<after>",
});
const { iframe, contentWindow, appendedScripts } = buildLivePreviewIframe();
const reloadPreview = vi.fn();
await finishClipTimingFallback({
...clipFallbackInput({ reloadPreview, recordEdit: vi.fn(async () => {}) }),
iframe,
});
expect(reloadPreview).not.toHaveBeenCalled();
expect(appendedScripts).toHaveLength(1);
expect(appendedScripts[0]).toContain('__timelines["root"] = tl2;');
expect(contentWindow.__hfForceTimelineRebind).toHaveBeenCalledTimes(1);
});
it("group batch where every change had nothing to rewrite (gap close over no-domId clips) rebinds in place", async () => {
stubFetch(["<html>"], { mutated: false, scriptText: null });
const { iframe, contentWindow, container, scriptEls, appendedScripts } =
buildLivePreviewIframe();
const reloadPreview = vi.fn();
const element = { sourceFile: "index.html" } as TimelineElement;
await finishGroupTimingGsapFallback({
writeProjectFile,
projectId: "p1",
iframe,
reloadPreview,
label: "Move timeline clips",
errorLabel: "Failed to shift GSAP positions",
recordEdit: vi.fn(async () => {}) as never,
activeCompPath: "index.html",
changes: [{ element }, { element }],
resolveChangePath: () => "index.html",
// No domId → nothing to rewrite for ANY change (the gap-close blink path).
mutationFor: () => null,
});
expect(reloadPreview).not.toHaveBeenCalled();
expect(contentWindow.__hfForceTimelineRebind).toHaveBeenCalledTimes(1);
expect(contentWindow.__player.seek).toHaveBeenCalledTimes(1);
// No script executed, the live script element untouched.
expect(appendedScripts).toHaveLength(0);
expect(container.contains(scriptEls[0]!)).toBe(true);
});
it("group batch touching ANOTHER file still full-reloads even when nothing was rewritten", async () => {
stubFetch(["<html>"], { mutated: false, scriptText: null });
const { iframe, contentWindow, appendedScripts } = buildLivePreviewIframe();
const reloadPreview = vi.fn();
await finishGroupTimingGsapFallback({
writeProjectFile,
projectId: "p1",
iframe,
reloadPreview,
label: "Move timeline clips",
errorLabel: "Failed to shift GSAP positions",
recordEdit: vi.fn(async () => {}) as never,
activeCompPath: "index.html",
changes: [
{ element: { sourceFile: "index.html" } as TimelineElement },
{ element: { sourceFile: "scenes/intro.html" } as TimelineElement },
],
resolveChangePath: (el) => el.sourceFile ?? "index.html",
mutationFor: () => null,
});
expect(reloadPreview).toHaveBeenCalledTimes(1);
expect(contentWindow.__hfForceTimelineRebind).not.toHaveBeenCalled();
expect(appendedScripts).toHaveLength(0);
});
});
describe("a timing edit's soft reload restores what GSAP wrote from the files", () => {
const script = (at: number) =>
`var tl = gsap.timeline({ paused: true }); tl.to("#wt", { width: 450 }, ${at}); tl.to("#nwid", { width: 400 }, ${at}); window.__timelines["root"] = tl;`;
const SUB = `<template><div data-composition-id="sub"><div id="nwid" data-hf-id="hf-n" style="left: 40px"></div></div></template>`;
// The live preview: the top-level timeline tweened a root element's and a nested element's width inline.
async function shift(fileOk: boolean) {
const doc = document.implementation.createHTMLDocument("");
doc.body.innerHTML =
`<div id="root" data-composition-id="root"><div id="wt" data-hf-id="hf-w" style="left: 700px; width: 366px"></div>` +
`<div data-composition-file="compositions/sub.html"><div id="nwid" data-hf-id="hf-n" style="left: 40px; width: 288px"></div></div></div>` +
`<script>${script(0)}</script>`;
const [wt, nwid] = [doc.getElementById("wt")!, doc.getElementById("nwid")!];
const contentWindow = {
gsap: { timeline: vi.fn(), set: vi.fn() },
__hfForceTimelineRebind: vi.fn(),
__timelines: {
root: {
kill: vi.fn(),
getChildren: () => [{ targets: () => [wt, nwid], vars: { width: 450 } }],
},
} as Record<string, unknown>,
__player: { getTime: () => 1, seek: vi.fn() },
};
const iframe = { contentWindow, contentDocument: doc } as unknown as HTMLIFrameElement;
const fetchMock = vi.fn(async () =>
fileOk ? jsonResponse({ content: SUB }) : new Response("{}", { status: 404 }),
);
vi.stubGlobal("fetch", fetchMock);
const after = `<html><body><div id="root" data-composition-id="root"><div id="wt" data-hf-id="hf-w" style="left: 700px"></div></div><script>${script(1)}</script></body></html>`;
const reloadPreview = vi.fn();
await finishClipTimingFallback({
...clipFallbackInput({ reloadPreview, recordEdit: vi.fn(async () => {}) }),
iframe,
sdkGsap: { mutated: true, scriptText: script(1), after },
});
return { wt, nwid, reloadPreview, fetchMock };
}
it("puts back the root element from the file it wrote and the nested one from its own file", async () => {
const { wt, nwid, reloadPreview, fetchMock } = await shift(true);
expect(fetchMock).toHaveBeenCalledWith(
expect.stringContaining("/files/compositions%2Fsub.html"),
{ credentials: "omit" },
);
expect(reloadPreview).not.toHaveBeenCalled();
expect(wt.getAttribute("style")).toBe("left: 700px;");
expect(nwid.getAttribute("style")).toBe("left: 40px;");
});
it("reloads the preview in full when the nested file cannot be read", async () => {
const { nwid, reloadPreview } = await shift(false);
expect(reloadPreview).toHaveBeenCalledTimes(1);
expect(nwid.getAttribute("style")).toBe("left: 40px; width: 288px");
});
});
function installOwnedFileServer(
contents: Map<string, string>,
options: {
failReadAt?: number;
failRollback?: boolean;
beforeRollback?: (path: string) => void;
} = {},
) {
let reads = 0;
const rollbacks: Array<{ path: string; expected: string; restore: string; conflict: boolean }> =
[];
vi.stubGlobal(
"fetch",
// One in-memory server fixture owns capability, file, and CAS rollback
// routes so each transaction test observes a coherent content map.
// fallow-ignore-next-line complexity
vi.fn(async (input: Parameters<typeof fetch>[0], init?: RequestInit) => {
const url = requestUrl(input);
if (url.includes("/gsap-mutation-capabilities")) {
return jsonResponse({ atomicOwnershipPairs: true });
}
if (url.includes("/files/")) {
reads += 1;
if (reads === options.failReadAt) throw new Error("verification read failed");
const path = decodeURIComponent(url.split("/files/")[1] ?? "");
return jsonResponse({ content: contents.get(path) ?? "" });
}
if (url.includes("/gsap-mutation-rollback/")) {
const path = decodeURIComponent(url.split("/gsap-mutation-rollback/")[1] ?? "");
const body = JSON.parse(String(init?.body)) as { expected: string; restore: string };
if (options.failRollback) {
return new Response(JSON.stringify({ error: "rollback unavailable" }), { status: 503 });
}
options.beforeRollback?.(path);
const conflict = contents.get(path) !== body.expected;
if (!conflict) contents.set(path, body.restore);
rollbacks.push({ path, ...body, conflict });
return jsonResponse({ ok: true, restored: !conflict, conflict });
}
throw new Error(`Unexpected fetch: ${url}`);
}),
);
return { rollbacks, readCount: () => reads };
}
function ownedMutation(contents: Map<string, string>, path: string, before: string, after: string) {
contents.set(path, after);
return { mutated: true, scriptText: null, before, after };
}
type OwnedStep = () => Promise<ReturnType<typeof ownedMutation>>;
/** Runs `steps` as one owned same-file transaction, wired the way a group edit wires it. */
function runOwnedChain(
steps: readonly OwnedStep[],
options: {
reloadPreview?: () => void;
recordEdit?: (edit: never) => Promise<void>;
} = {},
) {
const onGsapError = (err: unknown) =>
console.error("[Timeline] Failed to shift GSAP positions", err);
return finishTimelineTimingFallback({
iframe: buildLivePreviewIframe().iframe,
projectId: "p1",
reloadPreview: options.reloadPreview ?? vi.fn(),
gsapMutation: () =>
foldGsapMutationIntoHistory({
writeFile: writeProjectFile,
paths: ["index.html"],
projectId: "p1",
label: "Move timeline clips",
recordEdit: (options.recordEdit ?? vi.fn(async () => {})) as never,
gsapMutation: async (runOwnedMutation) => {
let status = { mutated: false, scriptText: null } as Awaited<ReturnType<OwnedStep>>;
for (const step of steps) status = await runOwnedMutation("index.html", step);
return status;
},
onRollbackError: onGsapError,
}),
onGsapError,
rebindWhenUnmutated: true,
});
}
describe("foldGsapMutationIntoHistory — owned GSAP transaction", () => {
it("reverse-rolls back every successful same-file step after a late failure", async () => {
const contents = new Map<string, string>([["index.html", "ORIGINAL"]]);
const server = installOwnedFileServer(contents);
await runOwnedChain([
async () => ownedMutation(contents, "index.html", "ORIGINAL", "STEP-1"),
async () => ownedMutation(contents, "index.html", "STEP-1", "STEP-2"),
async () => {
throw new Error("late failure");
},
]);
expect(server.rollbacks).toEqual([
{ path: "index.html", expected: "STEP-2", restore: "STEP-1", conflict: false },
{ path: "index.html", expected: "STEP-1", restore: "ORIGINAL", conflict: false },
]);
expect(contents.get("index.html")).toBe("ORIGINAL");
});
it("uses the endpoint's atomic before when a foreign write precedes mutation", async () => {
const contents = new Map<string, string>([["index.html", "FOREIGN"]]);
const server = installOwnedFileServer(contents);
await runOwnedChain([
async () => ownedMutation(contents, "index.html", "FOREIGN", "FOREIGN+OWNED"),
async () => {
throw new Error("late failure");
},
]);
expect(server.readCount()).toBe(0);
expect(server.rollbacks[0]).toEqual({
path: "index.html",
expected: "FOREIGN+OWNED",
restore: "FOREIGN",
conflict: false,
});
expect(contents.get("index.html")).toBe("FOREIGN");
});
it("server CAS preserves a successor that arrives as rollback starts", async () => {
const contents = new Map<string, string>([["index.html", "ORIGINAL"]]);
const server = installOwnedFileServer(contents, {
beforeRollback: () => contents.set("index.html", "SUCCESSOR"),
});
const reloadPreview = vi.fn();
await runOwnedChain(
[
async () => ownedMutation(contents, "index.html", "ORIGINAL", "OWNED"),
async () => {
throw new Error("late failure");
},
],
{ reloadPreview },
);
expect(server.rollbacks[0]?.conflict).toBe(true);
expect(contents.get("index.html")).toBe("SUCCESSOR");
expect(reloadPreview).toHaveBeenCalledTimes(1);
});
it("reloads when a failed rollback request leaves owned bytes without history", async () => {
const contents = new Map<string, string>([["index.html", "ORIGINAL"]]);
installOwnedFileServer(contents, { failRollback: true });
const reloadPreview = vi.fn();
const consoleError = vi.spyOn(console, "error").mockImplementation(() => {});
await runOwnedChain(
[
async () => ownedMutation(contents, "index.html", "ORIGINAL", "OWNED"),
async () => {
throw new Error("late failure");
},
],
{ reloadPreview },
);
expect(contents.get("index.html")).toBe("OWNED");
expect(reloadPreview).toHaveBeenCalledTimes(1);
expect(consoleError).toHaveBeenCalledWith(
expect.stringContaining("GSAP"),
expect.objectContaining({ message: "Failed to restore index.html" }),
);
});
it("records first owned before and last owned after without a client snapshot", async () => {
const contents = new Map<string, string>([["index.html", "FOREIGN"]]);
const server = installOwnedFileServer(contents);
const recordEdit = vi.fn(async () => {});
await runOwnedChain(
[
async () => ownedMutation(contents, "index.html", "FOREIGN", "FOREIGN+ONE"),
async () => ownedMutation(contents, "index.html", "FOREIGN+ONE", "FOREIGN+ONE+TWO"),
],
{ recordEdit },
);
expect(server.readCount()).toBe(1); // final ownership verification only
expect(recordEdit).toHaveBeenCalledWith(
expect.objectContaining({
files: {
"index.html": { before: "FOREIGN", after: "FOREIGN+ONE+TWO" },
},
}),
);
});
it("rejects a discontinuous same-file chain without claiming foreign bytes", async () => {
const contents = new Map<string, string>([["index.html", "ORIGINAL"]]);
const server = installOwnedFileServer(contents);
const recordEdit = vi.fn(async () => {});
const reloadPreview = vi.fn();
await runOwnedChain(
[
async () => ownedMutation(contents, "index.html", "ORIGINAL", "STEP-1"),
async () => ownedMutation(contents, "index.html", "FOREIGN", "FOREIGN+STEP-2"),
],
{ recordEdit, reloadPreview },
);
expect(recordEdit).not.toHaveBeenCalled();
expect(server.rollbacks).toEqual([
{
path: "index.html",
expected: "FOREIGN+STEP-2",
restore: "FOREIGN",
conflict: false,
},
{ path: "index.html", expected: "STEP-1", restore: "ORIGINAL", conflict: true },
]);
expect(contents.get("index.html")).toBe("FOREIGN");
expect(reloadPreview).toHaveBeenCalledTimes(1);
});
it("rolls back the owned output when the history verification reread fails", async () => {
const contents = new Map<string, string>([["index.html", "ORIGINAL"]]);
const server = installOwnedFileServer(contents, { failReadAt: 1 });
await runOwnedChain([async () => ownedMutation(contents, "index.html", "ORIGINAL", "OWNED")]);
expect(server.rollbacks[0]).toEqual({
path: "index.html",
expected: "OWNED",
restore: "ORIGINAL",
conflict: false,
});
expect(contents.get("index.html")).toBe("ORIGINAL");
});
});