mirror of
https://github.com/heygen-com/hyperframes.git
synced 2026-11-18 16:08:56 +00:00
* 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
851 lines
32 KiB
TypeScript
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");
|
|
});
|
|
});
|