diff --git a/packages/studio/src/components/nle/useCanvasZOrderTimelineMirror.test.tsx b/packages/studio/src/components/nle/useCanvasZOrderTimelineMirror.test.tsx index 51b87b6f43..6f42b84148 100644 --- a/packages/studio/src/components/nle/useCanvasZOrderTimelineMirror.test.tsx +++ b/packages/studio/src/components/nle/useCanvasZOrderTimelineMirror.test.tsx @@ -12,12 +12,6 @@ import { } from "./useCanvasZOrderTimelineMirror"; import { makeLifecycleOpsParams } from "../../hooks/elementLifecycleOpsTestUtils"; import { mountReactHarness } from "../../hooks/domSelectionTestHarness"; -import { - buildEditHistoryEntry, - createEmptyEditHistory, - pushEditHistoryEntry, - type EditHistoryState, -} from "../../utils/editHistory"; (globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT: boolean }).IS_REACT_ACT_ENVIRONMENT = true; @@ -61,45 +55,40 @@ interface HarnessApi { mirror: (input: MirrorZOrderInput) => Promise; } +interface RecordedWrite { + label: string; + kind: "manual" | "timeline"; + coalesceKey: string; + after: string; +} + /** * Mount the REAL wiring pair PreviewOverlays composes — handleDomZIndexReorderCommit - * (z persist) + useCanvasZOrderTimelineMirror (lane mirror) — over a shared, - * real editHistory reducer so the undo-fold assertion exercises the actual - * pushEditHistoryEntry coalescing: + * (z persist) + useCanvasZOrderTimelineMirror (lane mirror). The server (not this + * test) owns folding two records that share a coalesceKey into one undo entry + * (projectHistory.ts, "claim: a writer that records after writing"), so this harness + * only captures what Studio sends on each write: * * - the z sink mimics commitDomEditPatchBatches' recordEdit call verbatim * (kind "manual", options.coalesceKey — see useDomEditCommits.ts), and * - the move sink mimics persistTimelineBatchEdit → saveProjectFilesWithHistory * (kind "timeline", the coalesceKey forwarded through onMoveElements — see - * timelineEditingHelpers.ts / studioFileHistory.ts), - * - * with a deterministic clock inside the reducer's 300ms coalesce window. + * timelineEditingHelpers.ts / studioFileHistory.ts). */ function mountMirrorHarness(history: { - state: EditHistoryState; - now: () => number; fileContent: { current: string }; moveCoalesceKeys: string[]; + records: RecordedWrite[]; }) { const record = ( label: string, kind: "manual" | "timeline", coalesceKey: string, - coalesceMs: number | undefined, + _coalesceMs: number | undefined, after: string, ) => { - const entry = buildEditHistoryEntry({ - id: `e-${history.now()}`, - projectId: "p", - label, - kind, - coalesceKey, - coalesceMs, - now: history.now(), - files: { "index.html": { before: history.fileContent.current, after } }, - }); + history.records.push({ label, kind, coalesceKey, after }); history.fileContent.current = after; - history.state = pushEditHistoryEntry(history.state, entry); }; const onMoveElements: TimelineEditCallbacks["onMoveElements"] = ( @@ -135,17 +124,10 @@ function mountMirrorHarness(history: { } function makeHistory() { - let tick = 1000; return { - state: createEmptyEditHistory(), - // Deterministic clock: consecutive records land 400ms apart — PAST the - // reducer's default 300ms coalesce window, as in the live flow where the - // mirror is dispatched only after the z persist's server round-trip - // resolves (real network latency exceeds 300ms). The fold must therefore - // ride the gesture's explicit coalesceMs window, not the default. - now: () => (tick += 400), fileContent: { current: "A-original" }, moveCoalesceKeys: [] as string[], + records: [] as RecordedWrite[], }; } @@ -208,13 +190,12 @@ describe("useCanvasZOrderTimelineMirror", () => { // The move persist received the EXACT z coalesce key… expect(history.moveCoalesceKeys).toEqual([coalesceKey]); - // …and the real reducer folded the two records into one undo entry spanning - // pre-z "before" → post-move "after". One Cmd+Z reverts both writes. - expect(history.state.undo).toHaveLength(1); - expect(history.state.undo[0].files["index.html"]).toMatchObject({ - before: "A-original", - after: "C-move", - }); + // …and both writes carry that SAME non-empty coalesceKey: that is what lets + // the server (projectHistory.ts) fold them into one undo entry. One Cmd+Z + // then reverts both writes. + expect(history.records.map((r) => r.coalesceKey)).toEqual([coalesceKey, coalesceKey]); + expect(history.records[0]?.after).toBe("B-z"); + expect(history.records[1]?.after).toBe("C-move"); // Timeline UI reflects the lane change without a reload: optimistic store update. const t = usePlayerStore.getState().elements.find((e) => e.key === "index.html#t"); expect(t?.track).toBe(0); @@ -265,8 +246,10 @@ describe("useCanvasZOrderTimelineMirror", () => { } expect(keys[0]).not.toBe(keys[1]); // fresh key per gesture - // Each gesture folded its own z+move pair, but the two gestures stayed apart. - expect(history.state.undo).toHaveLength(2); + // Each gesture's z+move pair shares that gesture's own key, so the server folds + // each pair on its own — but the two gestures never share a key, so they stay apart. + expect(history.records).toHaveLength(4); + expect(history.records.map((r) => r.coalesceKey)).toEqual([keys[0], keys[0], keys[1], keys[1]]); expect(history.moveCoalesceKeys).toEqual(keys); }); @@ -299,7 +282,7 @@ describe("useCanvasZOrderTimelineMirror", () => { }); expect(history.moveCoalesceKeys).toEqual([]); // no lane persist dispatched - expect(history.state.undo).toHaveLength(1); // just the z entry + expect(history.records).toHaveLength(1); // just the z write const t = usePlayerStore.getState().elements.find((e) => e.key === "index.html#t"); expect(t?.track).toBe(1); // lane unchanged }); diff --git a/packages/studio/src/hooks/useEditHistoryActions.test.tsx b/packages/studio/src/hooks/useEditHistoryActions.test.tsx index 104d3471c8..6d9080aeee 100644 --- a/packages/studio/src/hooks/useEditHistoryActions.test.tsx +++ b/packages/studio/src/hooks/useEditHistoryActions.test.tsx @@ -13,10 +13,7 @@ afterEach(() => act(() => root?.unmount())); function mount(result: { ok: boolean; reason?: string; label?: string; paths?: string[] }) { const editHistory = { - undo: vi.fn(async (cb) => { - if (result.ok) await cb.writeFile("index.html", "before"); - return result; - }), + undo: vi.fn(async () => result), redo: vi.fn(async () => result), }; const deps = { @@ -42,22 +39,25 @@ function mount(result: { ok: boolean; reason?: string; label?: string; paths?: s } describe("useEditHistoryActions", () => { - it("undo writes through the host writer, resyncs the preview and toasts the label", async () => { - const { deps, actions } = mount({ ok: true, label: "Move clip", paths: ["index.html"] }); + it("undo resyncs the preview and toasts the step as the history names it", async () => { + const { deps, actions } = mount({ ok: true, label: "Undid: Move clip", paths: ["index.html"] }); await act(() => actions.undo()); expect(deps.waitForPendingDomEditSaves).toHaveBeenCalled(); - expect(deps.writeProjectFile).toHaveBeenCalledWith("index.html", "before"); expect(deps.onAfterUndoRedo).toHaveBeenCalled(); expect(deps.forceReloadSdkSession).toHaveBeenCalled(); expect(deps.syncHistoryPreviewAfterApply).toHaveBeenCalled(); - expect(deps.showToast).toHaveBeenCalledWith("Undid Move clip", "info"); + expect(deps.showToast).toHaveBeenCalledWith("Undid: Move clip", "info"); }); it("redo reports the redone label and skips the SDK reload for other files", async () => { - const { deps, actions } = mount({ ok: true, label: "Split clip", paths: ["other.html"] }); + const { deps, actions } = mount({ + ok: true, + label: "Redid: Split clip", + paths: ["other.html"], + }); await act(() => actions.redo()); expect(deps.forceReloadSdkSession).not.toHaveBeenCalled(); - expect(deps.showToast).toHaveBeenCalledWith("Redid Split clip", "info"); + expect(deps.showToast).toHaveBeenCalledWith("Redid: Split clip", "info"); }); it("explains a refused undo when the file changed on disk", async () => { diff --git a/packages/studio/src/hooks/useEditHistoryActions.ts b/packages/studio/src/hooks/useEditHistoryActions.ts index 26efd28c95..0be7b8bcae 100644 --- a/packages/studio/src/hooks/useEditHistoryActions.ts +++ b/packages/studio/src/hooks/useEditHistoryActions.ts @@ -13,7 +13,6 @@ interface HistoryResult { } interface HistoryFileCallbacks { readFile: (path: string) => Promise; - writeFile: (path: string, content: string) => Promise; serialize?: (paths: readonly string[], task: () => Promise) => Promise; } export interface EditHistoryHandle { @@ -40,7 +39,7 @@ export interface UseEditHistoryActionsOptions { forceReloadSdkSession?: () => void; } -/** Applies one persisted file-history step: the single owner of undo/redo over project files. */ +/** Takes one step of the project's history: the single owner of undo/redo over project files. */ export function useEditHistoryActions({ editHistory, readOptionalProjectFile, @@ -66,11 +65,10 @@ export function useEditHistoryActions({ const apply = useCallback( async (direction: "undo" | "redo") => { - const [noun, verb] = direction === "undo" ? ["Undo", "Undid"] : ["Redo", "Redid"]; + const noun = direction === "undo" ? "Undo" : "Redo"; await waitForPendingDomEditSaves(); const result = await editHistory[direction]({ readFile: readHistoryFile, - writeFile: writeProjectFile, serialize: serializeHistoryFiles, }); if (!result.ok && result.reason === "content-mismatch") { @@ -83,7 +81,8 @@ export function useEditHistoryActions({ forceReloadSdkSession?.(); } await syncHistoryPreviewAfterApply({ paths: result.paths, files: result.files }); - showToast(`${verb} ${result.label}`, "info"); + // The history names the step itself ("Undid: Moved Title"). + showToast(result.label, "info"); } }, [ @@ -92,7 +91,6 @@ export function useEditHistoryActions({ showToast, syncHistoryPreviewAfterApply, waitForPendingDomEditSaves, - writeProjectFile, serializeHistoryFiles, onAfterUndoRedo, activeCompPath, diff --git a/packages/studio/src/hooks/usePersistentEditHistory.projectOwnership.test.tsx b/packages/studio/src/hooks/usePersistentEditHistory.projectOwnership.test.tsx deleted file mode 100644 index 3491be5a5b..0000000000 --- a/packages/studio/src/hooks/usePersistentEditHistory.projectOwnership.test.tsx +++ /dev/null @@ -1,60 +0,0 @@ -// @vitest-environment happy-dom -import { act } from "react"; -import { createRoot } from "react-dom/client"; -import { describe, expect, it } from "vitest"; -import { createMemoryEditHistoryStorage } from "../utils/editHistoryStorage"; -import { usePersistentEditHistory } from "./usePersistentEditHistory"; - -(globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT: boolean }).IS_REACT_ACT_ENVIRONMENT = true; - -async function flushAsyncEffects(): Promise { - await act(async () => { - await new Promise((resolve) => setTimeout(resolve, 0)); - }); -} - -describe("usePersistentEditHistory project ownership", () => { - it("rejects a delayed project A recorder after project B becomes active", async () => { - const storage = createMemoryEditHistoryStorage(); - const now = () => 100; - const captured: { history: ReturnType | null } = { - history: null, - }; - - function Probe({ projectId }: { projectId: string }) { - captured.history = usePersistentEditHistory({ projectId, storage, now }); - return null; - } - - const root = createRoot(document.createElement("div")); - await act(async () => root.render()); - await flushAsyncEffects(); - const recordProjectA = captured.history?.recordEdit; - if (!recordProjectA) throw new Error("project A history did not load"); - - await act(async () => root.render()); - await expect( - recordProjectA({ - label: "Delayed A edit", - kind: "manual", - files: { "index.html": { before: "A", after: "A2" } }, - }), - ).rejects.toThrow("inactive project project-a"); - await flushAsyncEffects(); - - const recordProjectB = captured.history?.recordEdit; - if (!recordProjectB) throw new Error("project B history did not load"); - await act(async () => { - await recordProjectB({ - label: "B edit", - kind: "manual", - files: { "index.html": { before: "B", after: "B2" } }, - }); - }); - - expect(await storage.get("project-a")).toBeNull(); - expect((await storage.get("project-b"))?.undo.map((entry) => entry.label)).toEqual(["B edit"]); - - await act(async () => root.unmount()); - }); -}); diff --git a/packages/studio/src/hooks/usePersistentEditHistory.test.ts b/packages/studio/src/hooks/usePersistentEditHistory.test.ts index 76c9a8b549..38d92aa7fb 100644 --- a/packages/studio/src/hooks/usePersistentEditHistory.test.ts +++ b/packages/studio/src/hooks/usePersistentEditHistory.test.ts @@ -1,337 +1,141 @@ -import { describe, expect, it, vi } from "vitest"; -import { createEmptyEditHistory } from "../utils/editHistory"; -import type { EditHistoryStorageAdapter } from "../utils/editHistoryStorage"; -import { createMemoryEditHistoryStorage } from "../utils/editHistoryStorage"; +// @vitest-environment happy-dom +import { act, createElement } from "react"; +import { createRoot } from "react-dom/client"; +import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { afterEach, expect, it, vi } from "vitest"; import { - serializeStudioFileMutation, - serializeStudioFileMutations, -} from "../utils/studioFileMutationCoordinator"; -import { - createPersistentEditHistoryController, - createPersistentEditHistoryStore, -} from "./usePersistentEditHistory"; + createStudioApi, + fileContentVersion, + identifyFileWrite, + openProjectHistory, + type StudioApiAdapter, +} from "@hyperframes/studio-server"; +import { consumeStudioWriteToken } from "../utils/studioFileVersion"; +import { usePersistentEditHistory } from "./usePersistentEditHistory"; -describe("createPersistentEditHistoryController", () => { - it("records history and reloads it for the same project", async () => { - const storage = createMemoryEditHistoryStorage(); - const first = await createPersistentEditHistoryController({ - projectId: "project-1", - storage, - now: () => 100, - onChange: () => {}, - }); +const cleanup: Array<() => unknown> = []; - await first.recordEdit({ - label: "Move layer", - kind: "manual", - files: { "index.html": { before: "a", after: "b" } }, - }); - - const second = await createPersistentEditHistoryController({ - projectId: "project-1", - storage, - now: () => 200, - onChange: () => {}, - }); - - expect(second.snapshot().canUndo).toBe(true); - expect(second.snapshot().undoLabel).toBe("Move layer"); - expect(second.snapshot().undoPaths).toEqual(["index.html"]); +afterEach(async () => { + for (const step of cleanup.splice(0).reverse()) await step(); + vi.unstubAllGlobals(); +}); + +function tempDir(prefix: string): string { + const dir = mkdtempSync(join(tmpdir(), prefix)); + cleanup.push(() => rmSync(dir, { recursive: true, force: true })); + return dir; +} + +/** The hook over the real history routes and engine, on a project whose index.html reads "A". */ +async function studio({ withHistory = true } = {}) { + vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true); + const dir = tempDir("hf-studio-history-"); + writeFileSync(join(dir, "index.html"), "A"); + const history = await openProjectHistory({ + projectDir: dir, + historyRoot: tempDir("hf-studio-history-root-"), }); - - it("undo applies files through the provided callback and persists redo state", async () => { - const storage = createMemoryEditHistoryStorage(); - const controller = await createPersistentEditHistoryController({ - projectId: "project-1", - storage, - now: () => 100, - onChange: () => {}, - }); - await controller.recordEdit({ - label: "Move layer", + cleanup.push(() => history.close()); + const api = createStudioApi({ + listProjects: () => [], + resolveProject: (id: string) => (id === "demo" ? { id, dir } : null), + ...(withHistory && { history: () => history }), + } as unknown as StudioApiAdapter); + vi.stubGlobal("fetch", (url: string, init?: RequestInit) => + api.request(url.replace(/^\/api/, ""), init), + ); + let hook!: ReturnType; + function Harness() { + hook = usePersistentEditHistory({ projectId: "demo" }); + return null; + } + const root = createRoot(document.createElement("div")); + await act(async () => root.render(createElement(Harness))); + cleanup.push(() => act(() => root.unmount())); + const file = () => readFileSync(join(dir, "index.html"), "utf8"); + const save = (content: string) => writeFileSync(join(dir, "index.html"), content); + const readFile = async (path: string) => readFileSync(join(dir, path), "utf8"); + return { dir, hook: () => hook, file, save, readFile }; +} + +it("an edit Studio saved is undone and redone by the project's history, with the preview's before and after", async () => { + const { hook, file, save, readFile } = await studio(); + save("B"); + await act(() => + hook().recordEdit({ + label: "Moved Title", kind: "manual", - files: { "index.html": { before: "a", after: "b" } }, - }); - - const result = await controller.undo({ - readFile: async (path) => { - expect(path).toBe("index.html"); - return "b"; - }, - writeFile: async (path, content) => { - expect(path).toBe("index.html"); - expect(content).toBe("a"); - }, - }); - expect(result.ok).toBe(true); - expect(result.paths).toEqual(["index.html"]); - - expect(controller.snapshot().canUndo).toBe(false); - expect(controller.snapshot().canRedo).toBe(true); - expect(controller.snapshot().redoPaths).toEqual(["index.html"]); - }); - - it("keeps in-memory history when storage saves fail", async () => { - const storage: EditHistoryStorageAdapter = { - async get() { - return null; - }, - async set() { - throw new Error("IndexedDB unavailable"); - }, - async delete() {}, - }; - const controller = await createPersistentEditHistoryController({ - projectId: "project-1", - storage, - now: () => 100, - onChange: () => {}, - }); - - await expect( - controller.recordEdit({ - label: "Move layer", - kind: "manual", - files: { "index.html": { before: "a", after: "b" } }, - }), - ).resolves.toBeUndefined(); - - expect(controller.snapshot().canUndo).toBe(true); + files: { "index.html": { before: "A", after: "B" } }, + }), + ); + await vi.waitFor(() => expect(hook().undoLabel).toBe("Moved Title")); + + const undone = await act(() => hook().undo({ readFile })); + expect(undone).toEqual({ + ok: true, + label: "Undid: Moved Title", + paths: ["index.html"], + files: { "index.html": { previous: "B", restored: "A" } }, }); - - it("serializes concurrent record edits against the latest state", async () => { - const storage = createMemoryEditHistoryStorage(); - let timestamp = 100; - const store = createPersistentEditHistoryStore({ - projectId: "project-1", - storage, - initialState: createEmptyEditHistory(), - now: () => timestamp++, - onChange: () => {}, - }); - - await Promise.all([ - store.recordEdit({ - label: "Move layer", + expect(file()).toBe("A"); + + await vi.waitFor(() => expect(hook().canRedo).toBe(true)); + const redone = await act(() => hook().redo({ readFile })); + expect(redone).toMatchObject({ ok: true, label: "Redid: Moved Title" }); + expect(file()).toBe("B"); +}); + +it("a drag's edits under one key undo as one step, even before the drag goes idle", async () => { + const { hook, file, save, readFile } = await studio(); + for (const content of ["B", "C"]) { + save(content); + await act(() => + hook().recordEdit({ + label: "Dragged Title", kind: "manual", - files: { "index.html": { before: "a", after: "b" } }, + coalesceKey: "drag", + coalesceMs: 60_000, + files: { "index.html": { before: "A", after: content } }, }), - store.recordEdit({ - label: "Resize layer", - kind: "manual", - files: { "index.html": { before: "b", after: "c" } }, - }), - ]); - - expect(store.snapshot().state.undo.map((entry) => entry.label)).toEqual([ - "Move layer", - "Resize layer", - ]); + ); + } + const undone = await act(() => hook().undo({ readFile })); + expect(undone).toMatchObject({ + ok: true, + label: "Undid: Dragged Title", + files: { "index.html": { previous: "C", restored: "A" } }, }); - - it("still coalesces concurrent source edits that share a coalesce key", async () => { - const storage = createMemoryEditHistoryStorage(); - let timestamp = 100; - const store = createPersistentEditHistoryStore({ - projectId: "project-1", - storage, - initialState: createEmptyEditHistory(), - now: () => timestamp++, - onChange: () => {}, - }); - - await Promise.all([ - store.recordEdit({ - label: "Edit source", - kind: "source", - coalesceKey: "source:index.html", - files: { "index.html": { before: "a", after: "b" } }, - }), - store.recordEdit({ - label: "Edit source", - kind: "source", - coalesceKey: "source:index.html", - files: { "index.html": { before: "b", after: "c" } }, - }), - ]); - - expect(store.snapshot().state.undo).toHaveLength(1); - expect(store.snapshot().state.undo[0].files["index.html"].before).toBe("a"); - expect(store.snapshot().state.undo[0].files["index.html"].after).toBe("c"); - }); - - it("reads undo hashes from the live top entry during queued undo calls", async () => { - const storage = createMemoryEditHistoryStorage(); - let timestamp = 100; - const store = createPersistentEditHistoryStore({ - projectId: "project-1", - storage, - initialState: createEmptyEditHistory(), - now: () => timestamp++, - onChange: () => {}, - }); - await store.recordEdit({ - label: "Edit first file", + expect(file()).toBe("A"); +}); + +it("an undo's writes carry the write token Studio marked, so their echo is not read as an outside edit", async () => { + const { dir, hook, save, readFile } = await studio(); + save("B"); + await act(() => + hook().recordEdit({ + label: "Moved Title", kind: "manual", - files: { "first.html": { before: "first-before", after: "first-after" } }, - }); - await store.recordEdit({ - label: "Edit second file", + files: { "index.html": { before: "A", after: "B" } }, + }), + ); + await act(() => hook().undo({ readFile })); + const receipt = identifyFileWrite(join(dir, "index.html"), fileContentVersion("A")); + expect(consumeStudioWriteToken(receipt?.writeToken ?? null)).toBe(true); +}); + +it("without a history on the server an edit still saves, and there is nothing to undo", async () => { + const { hook, file, save, readFile } = await studio({ withHistory: false }); + save("B"); + await act(() => + hook().recordEdit({ + label: "Moved Title", kind: "manual", - files: { "second.html": { before: "second-before", after: "second-after" } }, - }); - - const files: Record = { - "first.html": "first-after", - "second.html": "second-after", - }; - const readPaths: string[] = []; - - await Promise.all([ - store.undo({ - readFile: async (path) => { - readPaths.push(path); - return files[path]; - }, - writeFile: async (path, content) => { - files[path] = content; - }, - }), - store.undo({ - readFile: async (path) => { - readPaths.push(path); - return files[path]; - }, - writeFile: async (path, content) => { - files[path] = content; - }, - }), - ]); - - expect(readPaths).toEqual(["second.html", "first.html"]); - expect(files).toEqual({ - "first.html": "first-before", - "second.html": "second-before", - }); - expect(store.snapshot().canUndo).toBe(false); - expect(store.snapshot().canRedo).toBe(true); - }); - - it("waits for same-file mutations before checking an undo hash", async () => { - const storage = createMemoryEditHistoryStorage(); - const store = createPersistentEditHistoryStore({ - projectId: "project-1", - storage, - initialState: createEmptyEditHistory(), - now: () => 100, - onChange: () => {}, - }); - await store.recordEdit({ - label: "Edit source", - kind: "source", - files: { "index.html": { before: "before", after: "after" } }, - }); - - let disk = "after"; - let release!: () => void; - const blocked = new Promise((resolve) => { - release = resolve; - }); - const writeFile = vi.fn(async (_path: string, content: string) => { - disk = content; - }); - const priorMutation = serializeStudioFileMutation(writeFile, "index.html", async () => { - await blocked; - disk = "newer-edit"; - }); - const readFile = vi.fn(async () => disk); - const undo = store.undo({ - readFile, - writeFile, - serialize: (paths, task) => serializeStudioFileMutations(writeFile, paths, task), - }); - - await Promise.resolve(); - expect(readFile).not.toHaveBeenCalled(); - release(); - await priorMutation; - await expect(undo).resolves.toMatchObject({ ok: false, reason: "content-mismatch" }); - expect(disk).toBe("newer-edit"); - expect(writeFile).not.toHaveBeenCalled(); - expect(store.snapshot().canUndo).toBe(true); - }); - - it("returns per-file restored/previous content so the preview can soft-apply", async () => { - const storage = createMemoryEditHistoryStorage(); - const store = createPersistentEditHistoryStore({ - projectId: "project-1", - storage, - initialState: createEmptyEditHistory(), - now: () => 100, - onChange: () => {}, - }); - await store.recordEdit({ - label: "Move layer", - kind: "manual", - files: { "index.html": { before: "OLD", after: "NEW" } }, - }); - const disk: Record = { "index.html": "NEW" }; - const undo = await store.undo({ - readFile: async (p) => disk[p], - writeFile: async (p, c) => { - disk[p] = c; - }, - }); - // `restored` = bytes written (the undo target), `previous` = the current live bytes. - expect(undo.files).toEqual({ "index.html": { previous: "NEW", restored: "OLD" } }); - - const redo = await store.redo({ - readFile: async (p) => disk[p], - writeFile: async (p, c) => { - disk[p] = c; - }, - }); - expect(redo.files).toEqual({ "index.html": { previous: "OLD", restored: "NEW" } }); - }); - - it("rolls back files when an undo write fails partway through", async () => { - const storage = createMemoryEditHistoryStorage(); - const store = createPersistentEditHistoryStore({ - projectId: "project-1", - storage, - initialState: createEmptyEditHistory(), - now: () => 100, - onChange: () => {}, - }); - await store.recordEdit({ - label: "Edit files", - kind: "manual", - files: { - "first.html": { before: "first-before", after: "first-after" }, - "second.html": { before: "second-before", after: "second-after" }, - }, - }); - - const files: Record = { - "first.html": "first-after", - "second.html": "second-after", - }; - const result = store.undo({ - readFile: async (path) => files[path], - writeFile: async (path, content) => { - if (path === "second.html" && content === "second-before") { - throw new Error("write failed"); - } - files[path] = content; - }, - }); - - await expect(result).rejects.toThrow("write failed"); - expect(files).toEqual({ - "first.html": "first-after", - "second.html": "second-after", - }); - expect(store.snapshot().undoLabel).toBe("Edit files"); - expect(store.snapshot().canRedo).toBe(false); - }); + files: { "index.html": { before: "A", after: "B" } }, + }), + ); + expect(hook().canUndo).toBe(false); + expect(await act(() => hook().undo({ readFile }))).toEqual({ ok: false, reason: "empty" }); + expect(file()).toBe("B"); }); diff --git a/packages/studio/src/hooks/usePersistentEditHistory.ts b/packages/studio/src/hooks/usePersistentEditHistory.ts index 40d6b893ac..a8b31039a0 100644 --- a/packages/studio/src/hooks/usePersistentEditHistory.ts +++ b/packages/studio/src/hooks/usePersistentEditHistory.ts @@ -1,51 +1,26 @@ import { useCallback, useEffect, useMemo, useRef, useState } from "react"; -import { - buildEditHistoryEntry, - createEmptyEditHistory, - hashEditHistoryContent, - pushEditHistoryEntry, - redoEditHistory, - undoEditHistory, - type BuildEditHistoryEntryInput, - type EditHistoryEntry, - type EditHistoryKind, - type EditHistoryState, - type EditHistoryTransitionResult, -} from "../utils/editHistory"; -import { - createIndexedDbEditHistoryStorage, - loadEditHistoryState, - saveEditHistoryState, - type EditHistoryStorageAdapter, -} from "../utils/editHistoryStorage"; +import type { HistoryListItem, HistoryResult } from "@hyperframes/studio-server"; +import type { EditHistoryKind } from "../utils/editHistory"; +import { studioWriteHeaders } from "../utils/studioFileVersion"; interface RecordEditInput { label: string; kind: EditHistoryKind; coalesceKey?: string; coalesceMs?: number; - files: BuildEditHistoryEntryInput["files"]; + files: Record; } interface ApplyCallbacks { readFile: (path: string) => Promise; - writeFile: (path: string, content: string) => Promise; serialize?: (paths: readonly string[], task: () => Promise) => Promise; } export interface UsePersistentEditHistoryOptions { projectId: string | null; - storage?: EditHistoryStorageAdapter; - now?: () => number; } -/** - * Per-file content the restore just applied. `restored` is the bytes written to - * disk (the undo/redo target); `previous` is what was on disk immediately before - * (the current live preview state). The undo preview-sync diffs these to decide - * whether the restore is soft-reloadable (attributes/style/GSAP-script only) or - * needs a full iframe reload. - */ +/** `restored` is what the step wrote; `previous` what was on disk before it, so the preview can patch in place. */ interface ApplyRestoredFile { previous: string; restored: string; @@ -59,351 +34,165 @@ interface ApplyResult { files?: Record; } -interface PersistentEditHistoryStoreOptions { - projectId: string; - storage: EditHistoryStorageAdapter; - initialState: EditHistoryState; - now?: () => number; - onChange: (state: EditHistoryState) => void; +interface NextStep { + id: string; + label: string; + endedAt: number; + paths: string[]; } -type EditHistoryMutation = (state: EditHistoryState) => Promise<{ - state: EditHistoryState; - result: T; -}>; - -/** Pair the just-written (`restored`) bytes with the pre-write (`previous`) bytes per path. */ -function restoredFilesMap( - filesToWrite: Record, - currentFiles: Record, -): Record { - const out: Record = {}; - for (const [path, restored] of Object.entries(filesToWrite)) { - out[path] = { previous: currentFiles[path] ?? "", restored }; - } - return out; +/** GET /projects/:id/history: every entry, and what Cmd+Z and Cmd+Shift+Z would revert next. */ +interface HistoryView { + entries: HistoryListItem[]; + back: NextStep | null; + forward: NextStep | null; } -function createEntryId(now: number): string { - return `edit-${now.toString(36)}-${Math.random().toString(36).slice(2, 10)}`; +const EMPTY: HistoryView = { entries: [], back: null, forward: null }; +/** How long a drag's edits keep merging into one undo step when the edit names no window. */ +const DEFAULT_COALESCE_MS = 300; + +function historyUrl(projectId: string, path = ""): string { + return `/api/projects/${encodeURIComponent(projectId)}/history${path}`; } -function snapshotEditHistoryState(state: EditHistoryState) { - const undoEntry = state.undo[state.undo.length - 1] ?? null; - const redoEntry = state.redo[state.redo.length - 1] ?? null; - return { - canUndo: Boolean(undoEntry), - canRedo: Boolean(redoEntry), - undoLabel: undoEntry?.label ?? null, - redoLabel: redoEntry?.label ?? null, - undoPaths: undoEntry ? Object.keys(undoEntry.files) : [], - redoPaths: redoEntry ? Object.keys(redoEntry.files) : [], - state, - }; +async function post(url: string, body: object, headers: Record = {}) { + const response = await fetch(url, { + method: "POST", + headers: { "Content-Type": "application/json", ...headers }, + body: JSON.stringify(body), + }); + return response.ok ? response.json() : null; } -async function readCurrentFileHashes( - paths: string[], +/** Reads every path, or null when one cannot be read (a file the step creates or deletes). */ +async function readAll( + paths: readonly string[], readFile: (path: string) => Promise, -): Promise<{ - currentFiles: Record; - currentHashes: Record; -}> { - const currentFiles: Record = {}; - const currentHashes: Record = {}; +): Promise | null> { + const contents: Record = {}; for (const path of paths) { - const content = await readFile(path); - currentFiles[path] = content; - currentHashes[path] = hashEditHistoryContent(content); + const content = await readFile(path).catch(() => null); + if (content === null) return null; + contents[path] = content; } - return { currentFiles, currentHashes }; + return contents; } -async function writeFilesWithRollback({ - files, - rollbackFiles, - writeFile, -}: { - files: Record; - rollbackFiles: Record; - writeFile: (path: string, content: string) => Promise; -}): Promise { - const writtenPaths: string[] = []; - try { - for (const [path, content] of Object.entries(files)) { - await writeFile(path, content); - writtenPaths.push(path); - } - } catch (error) { - try { - for (const path of writtenPaths.reverse()) { - await writeFile(path, rollbackFiles[path]); - } - } catch (rollbackError) { - throw new AggregateError( - [error, rollbackError], - "Failed to apply edit history and rollback did not complete", - ); - } - throw error; - } +/** Each changed file's before and after, or undefined when one is unknown: the preview then reloads. */ +async function restoredFiles( + paths: readonly string[], + previous: Record | null, + readFile: (path: string) => Promise, +): Promise | undefined> { + if (!previous || paths.some((path) => !(path in previous))) return undefined; + const restored = await readAll(paths, readFile); + if (!restored) return undefined; + return Object.fromEntries( + paths.map((path) => [path, { previous: previous[path]!, restored: restored[path]! }]), + ); +} + +/** When the edit Cmd+Shift+Z would redo was made: the entry its undo reverted. */ +function redoneAt(view: HistoryView): number | null { + const undo = view.entries.find((entry) => entry.id === view.forward?.id); + return view.entries.find((entry) => entry.id === undo?.undoes)?.endedAt ?? null; } /** - * Apply one undo/redo step: read current on-disk hashes, run the direction's - * transition, write the restored files with rollback, and shape the ApplyResult. - * `entry` is the stack top used to know which paths to hash before applying. + * Studio's undo and redo over the project's history on the server: an edit claims the files it just wrote, and + * Cmd+Z / Cmd+Shift+Z step through every writer's changes by time. Without a history on the server (404) edits + * still save; they just cannot be undone. */ -async function applyHistoryStep( - currentState: EditHistoryState, - entry: EditHistoryEntry | undefined, - transition: ( - state: EditHistoryState, - currentHashes: Record, - now: number, - ) => EditHistoryTransitionResult, - now: () => number, - callbacks: ApplyCallbacks, -): Promise<{ state: EditHistoryState; result: ApplyResult }> { - if (!entry) { - return { state: currentState, result: { ok: false, reason: "empty" } }; - } - const paths = Object.keys(entry.files); - const apply = async (): Promise<{ state: EditHistoryState; result: ApplyResult }> => { - const { currentFiles, currentHashes } = await readCurrentFileHashes(paths, callbacks.readFile); - const result = transition(currentState, currentHashes, now()); - if (!result.ok) { - return { - state: currentState, - result: { ok: false, reason: result.reason }, - }; - } - await writeFilesWithRollback({ - files: result.filesToWrite, - rollbackFiles: currentFiles, - writeFile: callbacks.writeFile, - }); - return { - state: result.state, - result: { - ok: true, - label: result.entry.label, - paths: Object.keys(result.entry.files), - files: restoredFilesMap(result.filesToWrite, currentFiles), - }, - }; - }; - return callbacks.serialize ? callbacks.serialize(paths, apply) : apply(); -} - -export function createPersistentEditHistoryStore({ - projectId, - storage, - initialState, - now = Date.now, - onChange, -}: PersistentEditHistoryStoreOptions) { - let state = initialState; - let queue = Promise.resolve(); - - const save = async (nextState: EditHistoryState) => { - state = nextState; - onChange(nextState); - try { - await saveEditHistoryState(storage, projectId, nextState); - } catch { - // Keep in-memory history usable when IndexedDB is unavailable. - } - }; - - const mutate = async (mutation: EditHistoryMutation): Promise => { - const run = queue.then(async () => { - const { state: nextState, result } = await mutation(state); - if (nextState !== state) await save(nextState); - return result; - }); - queue = run.then( - () => undefined, - () => undefined, - ); - return run; - }; - - return { - snapshot: () => snapshotEditHistoryState(state), - async recordEdit(input: RecordEditInput) { - await mutate(async (currentState) => { - const timestamp = now(); - const entry = buildEditHistoryEntry({ - ...input, - id: createEntryId(timestamp), - projectId, - now: timestamp, - }); - return { - state: pushEditHistoryEntry(currentState, entry), - result: undefined, - }; - }); - }, - async undo(callbacks: ApplyCallbacks): Promise { - return mutate((currentState) => - applyHistoryStep( - currentState, - currentState.undo[currentState.undo.length - 1], - undoEditHistory, - now, - callbacks, - ), - ); - }, - async redo(callbacks: ApplyCallbacks): Promise { - return mutate((currentState) => - applyHistoryStep( - currentState, - currentState.redo[currentState.redo.length - 1], - redoEditHistory, - now, - callbacks, - ), - ); - }, - }; -} - -export async function createPersistentEditHistoryController({ - projectId, - storage, - now = Date.now, - onChange, -}: { - projectId: string; - storage: EditHistoryStorageAdapter; - now?: () => number; - onChange: (state: EditHistoryState) => void; -}) { - let state = await loadEditHistoryState(storage, projectId); - const store = createPersistentEditHistoryStore({ - projectId, - storage, - initialState: state, - now, - onChange: (nextState) => { - state = nextState; - onChange(nextState); - }, - }); - - return store; -} - -export function usePersistentEditHistory(options: UsePersistentEditHistoryOptions) { - const storage = useMemo( - () => options.storage ?? createIndexedDbEditHistoryStorage(), - [options.storage], - ); - const now = options.now ?? Date.now; - const [state, setState] = useState(() => createEmptyEditHistory()); +export function usePersistentEditHistory({ projectId }: UsePersistentEditHistoryOptions) { + const [view, setView] = useState(EMPTY); const [loaded, setLoaded] = useState(false); - const projectId = options.projectId; - const storeRef = useRef | null>(null); - const storeProjectIdRef = useRef(null); - const activeProjectIdRef = useRef(projectId); - activeProjectIdRef.current = projectId; + // A coalescing claim stays on the server until its drag goes idle, so it is not in `view` yet. + const heldClaimRef = useRef<{ paths: string[]; at: number } | null>(null); + const projectIdRef = useRef(projectId); + projectIdRef.current = projectId; + + const refresh = useCallback(async () => { + if (!projectId) return; + const response = await fetch(historyUrl(projectId)).catch(() => null); + const next = response?.ok ? ((await response.json()) as HistoryView) : EMPTY; + if (projectIdRef.current === projectId) setView(next); + }, [projectId]); useEffect(() => { - let cancelled = false; - const emptyState = createEmptyEditHistory(); - storeRef.current = null; - storeProjectIdRef.current = null; - setState(emptyState); + setView(EMPTY); setLoaded(false); - if (!projectId) { - setLoaded(true); - return; - } - - loadEditHistoryState(storage, projectId) - .then((loadedState) => { - if (cancelled) return; - storeRef.current = createPersistentEditHistoryStore({ - projectId, - storage, - initialState: loadedState, - now, - onChange: setState, - }); - storeProjectIdRef.current = projectId; - setState(loadedState); - }) - .catch(() => { - if (cancelled) return; - storeRef.current = createPersistentEditHistoryStore({ - projectId, - storage, - initialState: emptyState, - now, - onChange: setState, - }); - storeProjectIdRef.current = projectId; - setState(emptyState); - }) - .finally(() => { - if (!cancelled) setLoaded(true); - }); - - return () => { - cancelled = true; - }; - }, [now, projectId, storage]); + heldClaimRef.current = null; + void refresh().finally(() => setLoaded(true)); + }, [refresh]); const recordEdit = useCallback( - async (input: RecordEditInput) => { + async ({ label, coalesceKey, coalesceMs, files }: RecordEditInput) => { if (!projectId) return; - if (activeProjectIdRef.current !== projectId) { - throw new Error(`Cannot record an edit for inactive project ${projectId}`); - } - const store = storeRef.current; - if (!store) return; - if (storeProjectIdRef.current !== projectId) { - throw new Error(`Edit history store does not belong to project ${projectId}`); - } - await store.recordEdit(input); + const paths = Object.keys(files); + const reply = await post(historyUrl(projectId, "/claim"), { + label, + paths, + ...(coalesceKey && { coalesceKey, idleMs: coalesceMs ?? DEFAULT_COALESCE_MS }), + }).catch(() => null); + heldClaimRef.current = coalesceKey && reply?.claimed ? { paths, at: Date.now() } : null; + void refresh(); }, - [projectId], + [projectId, refresh], ); - const undo = useCallback( - async (callbacks: ApplyCallbacks): Promise => { - if ( - !projectId || - activeProjectIdRef.current !== projectId || - storeProjectIdRef.current !== projectId - ) { - return { ok: false, reason: "empty" }; - } - return storeRef.current?.undo(callbacks) ?? { ok: false, reason: "empty" }; + const step = useCallback( + async (direction: "undo" | "redo", callbacks: ApplyCallbacks): Promise => { + if (!projectId) return { ok: false, reason: "empty" }; + const next = direction === "undo" ? view.back : view.forward; + const paths = [...new Set([...(next?.paths ?? []), ...(heldClaimRef.current?.paths ?? [])])]; + const run = async (): Promise => { + const previous = await readAll(paths, callbacks.readFile); + const reply = (await post( + historyUrl(projectId, "/step"), + { direction: direction === "undo" ? "back" : "forward" }, + studioWriteHeaders(), + ).catch(() => null)) as HistoryResult | null; + heldClaimRef.current = null; + void refresh(); + if (!reply) return { ok: false, reason: "empty" }; + if (!reply.ok) return { ok: false, reason: "content-mismatch" }; + if (!reply.entry) return { ok: false, reason: "empty" }; + const changed = reply.entry.files.map((file) => file.path); + return { + ok: true, + label: reply.entry.label, + paths: changed, + files: await restoredFiles(changed, previous, callbacks.readFile), + }; + }; + return callbacks.serialize ? callbacks.serialize(paths, run) : run(); }, - [projectId], + [projectId, view, refresh], ); - const redo = useCallback( - async (callbacks: ApplyCallbacks): Promise => { - if ( - !projectId || - activeProjectIdRef.current !== projectId || - storeProjectIdRef.current !== projectId - ) { - return { ok: false, reason: "empty" }; - } - return storeRef.current?.redo(callbacks) ?? { ok: false, reason: "empty" }; - }, - [projectId], - ); + const undo = useCallback((callbacks: ApplyCallbacks) => step("undo", callbacks), [step]); + const redo = useCallback((callbacks: ApplyCallbacks) => step("redo", callbacks), [step]); + + // Beat edits interleave with these by edit time (useAppHotkeys): the top of each stack. + const state = useMemo(() => { + const backAt = Math.max(view.back?.endedAt ?? 0, heldClaimRef.current?.at ?? 0); + const redoAt = redoneAt(view); + return { + undo: backAt ? [{ createdAt: backAt }] : [], + redo: redoAt === null ? [] : [{ createdAt: redoAt }], + }; + }, [view]); return { loaded, - ...snapshotEditHistoryState(state), + canUndo: Boolean(view.back), + canRedo: Boolean(view.forward), + undoLabel: view.back?.label, + redoLabel: view.forward?.label, + undoPaths: view.back?.paths ?? [], + redoPaths: view.forward?.paths ?? [], + state, recordEdit, undo, redo, diff --git a/packages/studio/src/hooks/useRazorSplit.history.test.tsx b/packages/studio/src/hooks/useRazorSplit.history.test.tsx index 2665f14bef..548ba01ec8 100644 --- a/packages/studio/src/hooks/useRazorSplit.history.test.tsx +++ b/packages/studio/src/hooks/useRazorSplit.history.test.tsx @@ -7,13 +7,7 @@ import { splitElementInHtml } from "@hyperframes/studio-server/source-mutation"; import type { TimelineElement } from "../player"; import { usePlayerStore } from "../player"; import { useRazorSplit } from "./useRazorSplit"; -import { createPersistentEditHistoryStore } from "./usePersistentEditHistory"; -import { createMemoryEditHistoryStorage } from "../utils/editHistoryStorage"; -import { - createEmptyEditHistory, - hashEditHistoryContent, - undoEditHistory, -} from "../utils/editHistory"; +import type { RecordEditInput } from "./timelineEditingHelpers"; import { createSplitFetchMock, mountProbe } from "./useRazorSplit.testHelpers"; (globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT: boolean }).IS_REACT_ACT_ENVIRONMENT = true; @@ -36,7 +30,10 @@ type SplitAll = (splitTime: number) => Promise; interface Harness { disk: Record; - store: ReturnType; + // What the split recorded — folding, undo and undo mismatch guards are the + // server's own tested behaviour (projectHistory.ts / projectHistory.test.ts, + // usePersistentEditHistory.test.ts), not re-proven here via a reducer. + records: RecordEditInput[]; splitRef: { current: Split | undefined }; root: ReturnType; expected: string; @@ -53,18 +50,7 @@ function mountRazorSplit(opts: { gsap?: boolean; previewStamp?: boolean } = {}): const disk: Record = { "index.html": ORIGINAL }; const finalContent = opts.gsap ? SPLIT_GSAP : SPLIT; const previewWrites: string[] = []; - - const storage = createMemoryEditHistoryStorage(); - const store = createPersistentEditHistoryStore({ - projectId: "p1", - storage, - initialState: createEmptyEditHistory(), - now: (() => { - let t = 1000; - return () => (t += 10); - })(), - onChange: () => {}, - }); + const records: RecordEditInput[] = []; // Faithful stand-in for the atomic server cut: one forward file write and one // response carrying the canonical history snapshots. @@ -115,7 +101,9 @@ function mountRazorSplit(opts: { gsap?: boolean; previewStamp?: boolean } = {}): writeProjectFile: async (path, content) => { disk[path] = content; }, - recordEdit: store.recordEdit, + recordEdit: async (input) => { + records.push(input); + }, reloadPreview: () => { if (!opts.previewStamp) return; const stamped = ensureHfIds(disk["index.html"]); @@ -134,16 +122,7 @@ function mountRazorSplit(opts: { gsap?: boolean; previewStamp?: boolean } = {}): const root = mountProbe(Component); - return { disk, store, splitRef, root, expected: finalContent, previewWrites }; -} - -async function undoViaDisk(harness: Pick) { - return harness.store.undo({ - readFile: async (path) => harness.disk[path], - writeFile: async (path, content) => { - harness.disk[path] = content; - }, - }); + return { disk, records, splitRef, root, expected: finalContent, previewWrites }; } afterEach(() => { @@ -159,15 +138,16 @@ describe("useRazorSplit — split is undoable via edit history", () => { await harness.splitRef.current!(element, 2); }); - const snapshot = harness.store.snapshot().state; - const entry = snapshot.undo.at(-1)!; - const currentHash = hashEditHistoryContent(harness.disk["index.html"]); - expect(entry.files["index.html"].afterHash).toBe(currentHash); - - const undo = undoEditHistory(snapshot, { "index.html": currentHash }, 2000); - expect(undo.ok).toBe(true); - expect(undo.filesToWrite).toEqual({ "index.html": ORIGINAL }); + // The preview reload found every id already stamped, so it never made a + // second, unrecorded write that would leave the recorded entry stale... expect(harness.previewWrites).toHaveLength(0); + // ...meaning the split's own recorded "after" IS the disk's final content, + // and undoing it (server-side) would restore exactly the pre-split bytes. + expect(harness.records).toHaveLength(1); + expect(harness.records[0]!.files["index.html"]).toEqual({ + before: ORIGINAL, + after: harness.disk["index.html"], + }); act(() => harness.root.unmount()); }); @@ -182,7 +162,7 @@ describe("useRazorSplit — split is undoable via edit history", () => { act(() => harness.root.unmount()); }); - it("records a single 'Split timeline clip' history entry that undo restores", async () => { + it("records a single 'Split timeline clip' entry with the exact bytes undo restores", async () => { await act(async () => { await harness.splitRef.current!(element, 2); }); @@ -190,15 +170,17 @@ describe("useRazorSplit — split is undoable via edit history", () => { // The split reached disk. expect(harness.disk["index.html"]).toBe(harness.expected); - // The split must be the top of the undo stack — not a prior/other entry. - expect(harness.store.snapshot().canUndo).toBe(true); - expect(harness.store.snapshot().undoLabel).toBe("Split timeline clip"); - - // Undo restores the exact pre-split file. - const result = await undoViaDisk(harness); - expect(result.ok).toBe(true); - expect(result.label).toBe("Split timeline clip"); - expect(harness.disk["index.html"]).toBe(ORIGINAL); + // Exactly one entry, correctly labeled, carrying the pre/post-split bytes — + // what a real undo (server-side, projectHistory.ts) restores from. + expect(harness.records).toHaveLength(1); + expect(harness.records[0]).toMatchObject({ + label: "Split timeline clip", + kind: "timeline", + }); + expect(harness.records[0]!.files["index.html"]).toEqual({ + before: ORIGINAL, + after: harness.expected, + }); }); }); } @@ -222,20 +204,14 @@ const batchElements: TimelineElement[] = [ interface SplitAllHarness { disk: Record; - store: ReturnType; + records: RecordEditInput[]; splitAllRef: { current: SplitAll | undefined }; root: ReturnType; } function mountRazorSplitAll(failOnSplit?: number): SplitAllHarness { const disk: Record = { ...BATCH_ORIGINALS }; - const store = createPersistentEditHistoryStore({ - projectId: "p1", - storage: createMemoryEditHistoryStorage(), - initialState: createEmptyEditHistory(), - now: () => 1000, - onChange: () => {}, - }); + const records: RecordEditInput[] = []; let splitCount = 0; vi.stubGlobal( @@ -255,7 +231,9 @@ function mountRazorSplitAll(failOnSplit?: number): SplitAllHarness { writeProjectFile: async (path, content) => { disk[path] = content; }, - recordEdit: store.recordEdit, + recordEdit: async (input) => { + records.push(input); + }, reloadPreview: () => {}, }); splitAllRef.current = handleRazorSplitAll; @@ -264,7 +242,7 @@ function mountRazorSplitAll(failOnSplit?: number): SplitAllHarness { const root = mountProbe(Component); usePlayerStore.setState({ elements: batchElements }); - return { disk, store, splitAllRef, root }; + return { disk, records, splitAllRef, root }; } describe("useRazorSplit — split-all batch history", () => { @@ -280,22 +258,24 @@ describe("useRazorSplit — split-all batch history", () => { return harness; } - it("records one undo entry that restores every split file", async () => { + it("records one entry whose files cover every split file (one undo restores all of them)", async () => { const harness = await runSplitAll(); - expect(harness.store.snapshot().canUndo).toBe(true); - const result = await undoViaDisk(harness); - expect(result.ok).toBe(true); - expect(harness.disk).toEqual(BATCH_ORIGINALS); - expect(harness.store.snapshot().canUndo).toBe(false); + expect(harness.records).toHaveLength(1); + const files = harness.records[0]!.files; + expect(Object.keys(files).sort()).toEqual(Object.keys(BATCH_ORIGINALS).sort()); + for (const path of Object.keys(BATCH_ORIGINALS) as (keyof typeof BATCH_ORIGINALS)[]) { + expect(files[path]?.before).toBe(BATCH_ORIGINALS[path]); + expect(files[path]?.after).toBe(harness.disk[path]); + } act(() => harness.root.unmount()); }); - it("restores completed writes and records no undo when a later split fails", async () => { + it("restores completed writes and records no entry when a later split fails", async () => { const harness = await runSplitAll(2); expect(harness.disk).toEqual(BATCH_ORIGINALS); - expect(harness.store.snapshot().canUndo).toBe(false); + expect(harness.records).toHaveLength(0); act(() => harness.root.unmount()); }); }); diff --git a/packages/studio/src/hooks/useRazorSplit.test.ts b/packages/studio/src/hooks/useRazorSplit.test.ts index 5d230fabb2..09eca846f4 100644 --- a/packages/studio/src/hooks/useRazorSplit.test.ts +++ b/packages/studio/src/hooks/useRazorSplit.test.ts @@ -5,9 +5,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"; import type { TimelineElement } from "../player"; import { usePlayerStore } from "../player"; import { useRazorSplit } from "./useRazorSplit"; -import { createPersistentEditHistoryStore } from "./usePersistentEditHistory"; -import { createEmptyEditHistory } from "../utils/editHistory"; -import type { EditHistoryStorageAdapter } from "../utils/editHistoryStorage"; +import type { RecordEditInput } from "./timelineEditingHelpers"; import { createSplitFetchMock, mountProbe } from "./useRazorSplit.testHelpers"; (globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT: boolean }).IS_REACT_ACT_ENVIRONMENT = true; @@ -164,20 +162,14 @@ describe("useRazorSplit — sub-comp coordinate rebasing", () => { // ── Bug 1: split must resync the SDK session so undo isn't refused ──────────── -const memoryStorage = (): EditHistoryStorageAdapter => { - const store = new Map(); - return { - load: async (k) => store.get(k) ?? null, - save: async (k, v) => { - store.set(k, v); - }, - } as unknown as EditHistoryStorageAdapter; -}; - interface UndoHarness { singleRef: { current: SingleSplit | undefined }; disk: Record; - store: ReturnType; + // What the split recorded, so the server (projectHistory.ts) could fold and + // later undo it — recording, folding and undo mismatch guards are the + // server's own tested behaviour (projectHistory.test.ts, + // usePersistentEditHistory.test.ts), not re-proven here via a reducer. + records: RecordEditInput[]; forceReloadSdkSession: ReturnType; root: ReturnType; } @@ -186,13 +178,7 @@ function mountRazorSplitWithHistory(): UndoHarness { const disk: Record = { [ROOT_FILE]: `
`, }; - const store = createPersistentEditHistoryStore({ - projectId: "p1", - storage: memoryStorage(), - initialState: createEmptyEditHistory(), - now: () => Date.now(), - onChange: () => {}, - }); + const records: RecordEditInput[] = []; const forceReloadSdkSession = vi.fn(); const fetchMock = createSplitFetchMock(disk); @@ -207,7 +193,9 @@ function mountRazorSplitWithHistory(): UndoHarness { writeProjectFile: async (path, content) => { disk[path] = content; }, - recordEdit: (input) => store.recordEdit(input), + recordEdit: async (input) => { + records.push(input); + }, reloadPreview: () => {}, forceReloadSdkSession, }); @@ -215,7 +203,7 @@ function mountRazorSplitWithHistory(): UndoHarness { return null; } const root = mountProbe(Component); - return { singleRef, disk, store, forceReloadSdkSession, root }; + return { singleRef, disk, records, forceReloadSdkSession, root }; } describe("useRazorSplit — undo integrity after split (Bug 1)", () => { @@ -227,13 +215,6 @@ describe("useRazorSplit — undo integrity after split (Bug 1)", () => { act(() => h.root.unmount()); }); - const readFile = () => ({ - readFile: async (p: string) => h.disk[p], - writeFile: async (p: string, c: string) => { - h.disk[p] = c; - }, - }); - it("resyncs the SDK session after a split (matches every other server-write path)", async () => { await act(async () => { await h.singleRef.current!(rootElement, 4); @@ -241,25 +222,14 @@ describe("useRazorSplit — undo integrity after split (Bug 1)", () => { expect(h.forceReloadSdkSession).toHaveBeenCalledTimes(1); }); - it("applies undo after a split without an external-change refusal", async () => { + it("records the split as one entry whose file carries the exact pre/post-split bytes a real undo restores", async () => { + const before = h.disk[ROOT_FILE]; await act(async () => { await h.singleRef.current!(rootElement, 4); }); - const result = await h.store.undo(readFile()); - expect(result.ok).toBe(true); - expect(result.reason).toBeUndefined(); - // The file is restored to its pre-split bytes. - expect(h.disk[ROOT_FILE]).not.toContain(""); - }); - - it("still trips the guard when the file is edited externally after a split", async () => { - await act(async () => { - await h.singleRef.current!(rootElement, 4); - }); - // Simulate the user editing the file in their own editor after the split. - h.disk[ROOT_FILE] = `${h.disk[ROOT_FILE]}`; - const result = await h.store.undo(readFile()); - expect(result.ok).toBe(false); - expect(result.reason).toBe("content-mismatch"); + expect(h.disk[ROOT_FILE]).toContain(""); + expect(h.records).toHaveLength(1); + expect(h.records[0]).toMatchObject({ label: "Split timeline clip" }); + expect(h.records[0]!.files[ROOT_FILE]).toEqual({ before, after: h.disk[ROOT_FILE] }); }); }); diff --git a/packages/studio/src/hooks/useStudioContextValue.ts b/packages/studio/src/hooks/useStudioContextValue.ts index 783c51d22c..67fd368ef6 100644 --- a/packages/studio/src/hooks/useStudioContextValue.ts +++ b/packages/studio/src/hooks/useStudioContextValue.ts @@ -17,7 +17,12 @@ interface StudioContextInput { setRefreshKey: React.Dispatch>; timelineElements: StudioContextValue["timelineElements"]; isPlaying: boolean; - editHistory: { canUndo: boolean; canRedo: boolean; undoLabel: string; redoLabel: string }; + editHistory: { + canUndo: boolean; + canRedo: boolean; + undoLabel: string | undefined; + redoLabel: string | undefined; + }; handleUndo: StudioContextValue["handleUndo"]; handleRedo: StudioContextValue["handleRedo"]; // Was a second copy of the same shape, which meant every field added to the diff --git a/packages/studio/src/hostMount.test.tsx b/packages/studio/src/hostMount.test.tsx index 77592f075d..2697d3b593 100644 --- a/packages/studio/src/hostMount.test.tsx +++ b/packages/studio/src/hostMount.test.tsx @@ -8,8 +8,15 @@ import { createRoot, type Root } from "react-dom/client"; import { afterEach, describe, expect, it, vi } from "vitest"; // Backend/storage mocking only, standing in for a host's own server and // persistence — not part of the host's integration code under test. +import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { + createStudioApi, + openProjectHistory, + type StudioApiAdapter, +} from "@hyperframes/studio-server"; import { studioFileContentVersion } from "./utils/studioFileVersion"; -import { createMemoryEditHistoryStorage } from "./utils/editHistoryStorage"; import { flushStudioPendingEdits, useTimelineEditing, @@ -27,45 +34,66 @@ import { const ORIGINAL_HTML = '
'; let root: Root | null = null; -afterEach(() => { +const cleanups: Array<() => unknown> = []; +afterEach(async () => { act(() => root?.unmount()); document.body.innerHTML = ""; vi.unstubAllGlobals(); + for (const step of cleanups.splice(0).reverse()) await step(); }); -/** A minimal disk with etag-guarded PUT, faithful enough to exercise a real - * conflict: a stale If-Match gets a 409 with the current version + content. */ -function stubHostProjectDisk( +function tempDir(prefix: string): string { + const dir = mkdtempSync(join(tmpdir(), prefix)); + cleanups.push(() => rmSync(dir, { recursive: true, force: true })); + return dir; +} + +/** A project folder with etag-guarded PUT, faithful enough to exercise a real + * conflict: a stale If-Match gets a 409 with the current version + content. + * History requests go to the real history routes over the real engine. */ +async function stubHostProjectDisk( initial: Record, options?: { editElsewhereAfterFirstRead?: boolean }, ) { - const content = { ...initial }; + const dir = tempDir("hf-host-mount-"); + for (const [path, text] of Object.entries(initial)) writeFileSync(join(dir, path), text); + const history = await openProjectHistory({ + projectDir: dir, + historyRoot: tempDir("hf-host-mount-history-"), + }); + cleanups.push(() => history.close()); + const api = createStudioApi({ + listProjects: () => [], + resolveProject: (id: string) => (id === "p1" ? { id, dir } : null), + history: () => history, + } as unknown as StudioApiAdapter); const readsSeen = new Set(); + const read = (path: string) => readFileSync(join(dir, path), "utf8"); // The real backend's etag is a content hash (useProjectFileWriter derives // If-Match the same way) — an arbitrary counter here would make every // write from a host that hasn't just read the file look stale. - const versionOf = (path: string) => studioFileContentVersion(content[path]); + const versionOf = (path: string) => studioFileContentVersion(read(path)); async function handlePut(path: string, init: RequestInit | undefined) { const ifMatch = new Headers(init?.headers).get("If-Match"); const currentVersion = await versionOf(path); if (ifMatch && ifMatch !== currentVersion) { - return new Response(JSON.stringify({ currentVersion, currentContent: content[path] }), { + return new Response(JSON.stringify({ currentVersion, currentContent: read(path) }), { status: 409, }); } - content[path] = String(init?.body ?? ""); + writeFileSync(join(dir, path), String(init?.body ?? "")); return new Response(JSON.stringify({ version: await versionOf(path) }), { status: 200 }); } async function handleGet(path: string) { - const served = content[path]; + const served = read(path); // Simulates another writer landing between this read and the caller's // own write: content moves on right after being served once, so the // caller's hash of what it just read no longer matches disk. if (options?.editElsewhereAfterFirstRead && !readsSeen.has(path)) { readsSeen.add(path); - content[path] = `${served} `; + writeFileSync(join(dir, path), `${served} `); } return new Response( JSON.stringify({ content: served, version: await studioFileContentVersion(served) }), @@ -74,12 +102,15 @@ function stubHostProjectDisk( } const fetchMock = vi.fn(async (input: RequestInfo | URL, init?: RequestInit) => { - const match = String(input).match(/\/files\/([^?]+)/); - const path = match ? decodeURIComponent(match[1]) : ""; + const url = String(input); + if (url.includes("/history")) return api.request(url.replace(/^\/api/, ""), init); + const match = url.match(/\/files\/([^?]+)/); + if (!match) return new Response("{}", { status: 404 }); + const path = decodeURIComponent(match[1]); return (init?.method ?? "GET") === "PUT" ? handlePut(path, init) : handleGet(path); }); vi.stubGlobal("fetch", fetchMock); - return { content, fetchMock }; + return { read, fetchMock }; } type TimelineEditingHandle = { @@ -108,13 +139,10 @@ function mountHost( const bannerHost = document.createElement("div"); document.body.append(bannerHost); const bannerRoot = createRoot(bannerHost); - // Created once: a fresh storage object on every render would change - // usePersistentEditHistory's effect deps each time and loop forever. - const storage = createMemoryEditHistoryStorage(); function Harness() { const writer = useProjectFileWriter({ projectId: "p1" }); - const editHistory = usePersistentEditHistory({ projectId: "p1", storage }); + const editHistory = usePersistentEditHistory({ projectId: "p1" }); const historyActions = useEditHistoryActions({ editHistory, readOptionalProjectFile: writer.readOptionalProjectFile, @@ -170,7 +198,7 @@ function mountHost( describe("public export surface: a host mounting hand editing outside EditorShell", () => { it("writes a move through the history path and undo restores it", async () => { - const disk = stubHostProjectDisk({ "index.html": ORIGINAL_HTML }); + const disk = await stubHostProjectDisk({ "index.html": ORIGINAL_HTML }); const iframe = document.createElement("iframe"); document.body.append(iframe); iframe.contentDocument!.body.innerHTML = ORIGINAL_HTML; @@ -187,16 +215,19 @@ describe("public export surface: a host mounting hand editing outside EditorShel await act(async () => { await timelineEditing.handleTimelineElementMove(clip, { start: 5, track: 0 }); }); - expect(disk.content["index.html"]).toContain('data-start="5"'); + expect(disk.read("index.html")).toContain('data-start="5"'); await act(async () => { await undo(); }); - expect(disk.content["index.html"]).toContain('data-start="0"'); + expect(disk.read("index.html")).toContain('data-start="0"'); }); it("surfaces the conflict banner on a 409", async () => { - stubHostProjectDisk({ "index.html": ORIGINAL_HTML }, { editElsewhereAfterFirstRead: true }); + await stubHostProjectDisk( + { "index.html": ORIGINAL_HTML }, + { editElsewhereAfterFirstRead: true }, + ); const iframe = document.createElement("iframe"); document.body.append(iframe); iframe.contentDocument!.body.innerHTML = ORIGINAL_HTML; diff --git a/packages/studio/src/player/components/timelineClipDragCommit.test.ts b/packages/studio/src/player/components/timelineClipDragCommit.test.ts index eb87017be5..666a729722 100644 --- a/packages/studio/src/player/components/timelineClipDragCommit.test.ts +++ b/packages/studio/src/player/components/timelineClipDragCommit.test.ts @@ -8,11 +8,6 @@ import { type DragCommitDeps, type TimelineMoveEdit, } from "./timelineClipDragCommit"; -import { - buildEditHistoryEntry, - createEmptyEditHistory, - pushEditHistoryEntry, -} from "../../utils/editHistory"; import { normalizeToZones } from "./timelineZones"; import { resolveZMirrorLaneMove } from "./timelineZMirror"; import type { StackingPatch } from "./timelineStackingSync"; @@ -1151,48 +1146,21 @@ describe("commitDraggedClipMove", () => { return { onMoveElements, onStackingPatches }; }; - it("threads ONE shared coalesceKey to both the move persist and the z-sync, so the two records merge into a single undo entry", async () => { + it("threads ONE shared coalesceKey to both the move persist and the z-sync, so the server can fold them into a single undo entry", async () => { const { onMoveElements, onStackingPatches } = commitLaneChange(overlapping()); await flushMicrotasks(); - // Both sides receive the SAME non-empty gesture key (second arg). + // Both sides receive the SAME non-empty gesture key (second arg). That + // shared, non-empty coalesceKey is what lets the server + // (projectHistory.ts, "claim: a writer that records after writing") + // fold the "Move timeline clips" write and the "Reorder layers" z patch, + // both to the same file, into one undo entry — folding itself is the + // server's own tested behaviour, not re-proven here via a reducer. const moveKey = onMoveElements.mock.calls[0][1]; const zKey = onStackingPatches.mock.calls[0][1]; expect(typeof moveKey).toBe("string"); expect(moveKey).not.toBe(""); expect(zKey).toBe(moveKey); - - // With that shared key, editHistory folds the two consecutive records (the - // "Move timeline clips" write + the "Reorder layers" z patch, same file, - // inside the coalesce window) into ONE undo entry spanning before→after. - const now = 1_000; - const moveEntry = buildEditHistoryEntry({ - id: "m", - projectId: "p", - label: "Move timeline clips", - kind: "timeline", - coalesceKey: moveKey, - now, - files: { "index.html": { before: "", after: "" } }, - }); - const zEntry = buildEditHistoryEntry({ - id: "z", - projectId: "p", - label: "Reorder layers", - kind: "timeline", - coalesceKey: zKey, - now: now + 50, - files: { "index.html": { before: "", after: "" } }, - }); - const state = pushEditHistoryEntry( - pushEditHistoryEntry(createEmptyEditHistory(), moveEntry), - zEntry, - ); - expect(state.undo).toHaveLength(1); - expect(state.undo[0].files["index.html"]).toMatchObject({ - before: "", - after: "", - }); }); it("distinct gestures get distinct keys (independent moves never cross-merge)", async () => { diff --git a/packages/studio/src/utils/editHistory.test.ts b/packages/studio/src/utils/editHistory.test.ts deleted file mode 100644 index cfd1d1f48d..0000000000 --- a/packages/studio/src/utils/editHistory.test.ts +++ /dev/null @@ -1,534 +0,0 @@ -import { describe, expect, it } from "vitest"; -import { - buildEditHistoryEntry, - canApplyEditHistoryEntry, - createEmptyEditHistory, - hashEditHistoryContent, - pushEditHistoryEntry, - redoEditHistory, - undoEditHistory, -} from "./editHistory"; - -describe("edit history", () => { - it("pushes changed file snapshots onto undo and clears redo", () => { - const state = createEmptyEditHistory(); - const entry = buildEditHistoryEntry({ - projectId: "project-1", - label: "Move layer", - files: { - "index.html": { - before: '
', - after: '
', - }, - }, - now: 100, - id: "entry-1", - }); - - const withUndo = pushEditHistoryEntry(state, entry); - const redoEntry = buildEditHistoryEntry({ - projectId: "project-1", - label: "Redoable edit", - files: { - "index.html": { - before: '
', - after: '
', - }, - }, - now: 200, - id: "redo-entry", - }); - - const next = pushEditHistoryEntry( - { - ...withUndo, - redo: [redoEntry], - }, - { - ...entry, - id: "entry-2", - label: "Resize layer", - createdAt: 300, - }, - ); - - expect(withUndo.undo).toHaveLength(1); - expect(withUndo.redo).toHaveLength(0); - expect(next.undo.map((item) => item.label)).toEqual(["Move layer", "Resize layer"]); - expect(next.redo).toHaveLength(0); - }); - - it("undo returns before contents and moves entry to redo", () => { - const entry = buildEditHistoryEntry({ - projectId: "project-1", - label: "Move layer", - files: { - "index.html": { before: "before", after: "after" }, - }, - now: 100, - id: "entry-1", - }); - const state = pushEditHistoryEntry(createEmptyEditHistory(), entry); - - const result = undoEditHistory(state, { "index.html": hashEditHistoryContent("after") }, 200); - - expect(result.ok).toBe(true); - expect(result.filesToWrite).toEqual({ "index.html": "before" }); - expect(result.state.undo).toHaveLength(0); - expect(result.state.redo.map((item) => item.id)).toEqual(["entry-1"]); - }); - - it("redo returns after contents and moves entry to undo", () => { - const entry = buildEditHistoryEntry({ - projectId: "project-1", - label: "Move layer", - files: { - "index.html": { before: "before", after: "after" }, - }, - now: 100, - id: "entry-1", - }); - const undone = undoEditHistory( - pushEditHistoryEntry(createEmptyEditHistory(), entry), - { "index.html": hashEditHistoryContent("after") }, - 200, - ).state; - - const result = redoEditHistory(undone, { "index.html": hashEditHistoryContent("before") }, 300); - - expect(result.ok).toBe(true); - expect(result.filesToWrite).toEqual({ "index.html": "after" }); - expect(result.state.undo.map((item) => item.id)).toEqual(["entry-1"]); - expect(result.state.redo).toHaveLength(0); - }); - - it("blocks undo when current content hash does not match the recorded after hash", () => { - const entry = buildEditHistoryEntry({ - projectId: "project-1", - label: "Move layer", - files: { - "index.html": { before: "before", after: "after" }, - }, - now: 100, - id: "entry-1", - }); - const state = pushEditHistoryEntry(createEmptyEditHistory(), entry); - - const result = undoEditHistory( - state, - { "index.html": hashEditHistoryContent("external") }, - 200, - ); - - expect(result.ok).toBe(false); - expect(result.reason).toBe("content-mismatch"); - expect(result.state).toBe(state); - expect(result.filesToWrite).toEqual({}); - }); - - it("can validate all files in a multi-file entry before applying", () => { - const entry = buildEditHistoryEntry({ - projectId: "project-1", - label: "Update files", - files: { - "index.html": { before: "a", after: "b" }, - "compositions/title.html": { before: "c", after: "d" }, - }, - now: 100, - id: "entry-1", - }); - - expect( - canApplyEditHistoryEntry(entry, "undo", { - "index.html": hashEditHistoryContent("b"), - "compositions/title.html": hashEditHistoryContent("d"), - }), - ).toEqual({ ok: true }); - expect( - canApplyEditHistoryEntry(entry, "undo", { - "index.html": hashEditHistoryContent("b"), - "compositions/title.html": hashEditHistoryContent("external"), - }), - ).toEqual({ ok: false, reason: "content-mismatch", path: "compositions/title.html" }); - }); - - it("prunes oldest undo entries when the limit is exceeded", () => { - let state = createEmptyEditHistory({ maxEntries: 2 }); - for (let index = 1; index <= 3; index += 1) { - state = pushEditHistoryEntry( - state, - buildEditHistoryEntry({ - projectId: "project-1", - label: `Edit ${index}`, - files: { - "index.html": { before: `${index - 1}`, after: `${index}` }, - }, - now: index, - id: `entry-${index}`, - }), - { maxEntries: 2 }, - ); - } - - expect(state.undo.map((entry) => entry.id)).toEqual(["entry-2", "entry-3"]); - }); - - it("coalesces source editor edits for the same file inside the coalesce window", () => { - const first = buildEditHistoryEntry({ - projectId: "project-1", - label: "Edit source", - kind: "source", - coalesceKey: "source:index.html", - files: { - "index.html": { before: "a", after: "b" }, - }, - now: 100, - id: "entry-1", - }); - const second = buildEditHistoryEntry({ - projectId: "project-1", - label: "Edit source", - kind: "source", - coalesceKey: "source:index.html", - files: { - "index.html": { before: "b", after: "c" }, - }, - now: 300, - id: "entry-2", - }); - - const state = pushEditHistoryEntry( - pushEditHistoryEntry(createEmptyEditHistory(), first), - second, - { coalesceMs: 1000 }, - ); - - expect(state.undo).toHaveLength(1); - expect(state.undo[0].id).toBe("entry-2"); - expect(state.undo[0].files["index.html"].before).toBe("a"); - expect(state.undo[0].files["index.html"].after).toBe("c"); - }); - - it("merges a lane-change move with its z-reorder past the default window via entry coalesceMs", () => { - // The z entry records only after the move persist's round-trip — often >300ms. - // Both sides pass coalesceMs: 5000 with the shared gesture key so the pair - // still folds into ONE undo step. - const move = buildEditHistoryEntry({ - projectId: "project-1", - label: "Move timeline clips", - kind: "timeline", - coalesceKey: "clip-lane-move:1", - coalesceMs: 5000, - files: { "index.html": { before: "a", after: "b" } }, - now: 100, - id: "move-entry", - }); - const zReorder = buildEditHistoryEntry({ - projectId: "project-1", - label: "Reorder layers", - kind: "manual", - coalesceKey: "clip-lane-move:1", - coalesceMs: 5000, - files: { "index.html": { before: "b", after: "c" } }, - now: 500, - id: "z-entry", - }); - - const state = pushEditHistoryEntry( - pushEditHistoryEntry(createEmptyEditHistory(), move), - zReorder, - ); - - expect(state.undo).toHaveLength(1); - expect(state.undo[0].files["index.html"].before).toBe("a"); - expect(state.undo[0].files["index.html"].after).toBe("c"); - }); - - it("folds a slow GSAP follow-up into the timing edit via a per-entry coalesceMs override", () => { - const timing = buildEditHistoryEntry({ - projectId: "project-1", - label: "Resize timeline clip", - kind: "timeline", - coalesceKey: "timeline-resize:clip", - files: { "index.html": { before: "orig", after: "timing" } }, - now: 0, - id: "timing", - }); - // The server GSAP rewrite lands ~2s later, past the 300ms default window, but the - // follow-up carries a large coalesceMs so undo still collapses to a single step. - const gsap = buildEditHistoryEntry({ - projectId: "project-1", - label: "Resize timeline clip", - kind: "timeline", - coalesceKey: "timeline-resize:clip", - coalesceMs: 10_000, - files: { "index.html": { before: "timing", after: "timing+gsap" } }, - now: 2000, - id: "gsap", - }); - - const state = pushEditHistoryEntry( - pushEditHistoryEntry(createEmptyEditHistory(), timing), - gsap, - ); - - expect(state.undo).toHaveLength(1); - expect(state.undo[0].files["index.html"].before).toBe("orig"); - expect(state.undo[0].files["index.html"].after).toBe("timing+gsap"); - }); - - it("keeps timing-only files when a multi-file GSAP follow-up touches one path", () => { - const timing = buildEditHistoryEntry({ - projectId: "project-1", - label: "Move timeline clips", - kind: "timeline", - coalesceKey: "timeline-group-move:a,b", - files: { - "index.html": { before: "index-before", after: "index-timing" }, - "scene.html": { before: "scene-before", after: "scene-timing" }, - }, - now: 0, - id: "timing", - }); - const gsap = buildEditHistoryEntry({ - projectId: "project-1", - label: "Move timeline clips", - kind: "timeline", - coalesceKey: "timeline-group-move:a,b", - coalesceMs: 10_000, - files: { - "index.html": { before: "index-timing", after: "index-timing+gsap" }, - }, - now: 2000, - id: "gsap", - }); - - const state = pushEditHistoryEntry( - pushEditHistoryEntry(createEmptyEditHistory(), timing), - gsap, - ); - - expect(state.undo).toHaveLength(1); - expect(Object.keys(state.undo[0].files)).toEqual(["index.html", "scene.html"]); - expect(state.undo[0].files).toMatchObject({ - "index.html": { before: "index-before", after: "index-timing+gsap" }, - "scene.html": { before: "scene-before", after: "scene-timing" }, - }); - }); - - it("keeps a discontinuous GSAP follow-up separate and preserves foreign bytes on undo", () => { - const timing = buildEditHistoryEntry({ - projectId: "project-1", - label: "Move timeline clip", - kind: "timeline", - coalesceKey: "timeline-move:clip", - files: { "index.html": { before: "A", after: "B" } }, - now: 0, - id: "timing", - }); - const gsapAfterForeignWrite = buildEditHistoryEntry({ - projectId: "project-1", - label: "Move timeline clip", - kind: "timeline", - coalesceKey: "timeline-move:clip", - coalesceMs: 10_000, - files: { "index.html": { before: "F", after: "G" } }, - now: 2000, - id: "gsap", - }); - - const state = pushEditHistoryEntry( - pushEditHistoryEntry(createEmptyEditHistory(), timing), - gsapAfterForeignWrite, - ); - - expect(state.undo.map((entry) => entry.id)).toEqual(["timing", "gsap"]); - const undoGsap = undoEditHistory(state, { "index.html": hashEditHistoryContent("G") }, 3000); - expect(undoGsap.ok).toBe(true); - expect(undoGsap.filesToWrite).toEqual({ "index.html": "F" }); - - const undoTiming = undoEditHistory( - undoGsap.state, - { "index.html": hashEditHistoryContent("F") }, - 4000, - ); - expect(undoTiming).toMatchObject({ - ok: false, - reason: "content-mismatch", - filesToWrite: {}, - }); - }); - - it("does not merge a slow follow-up without the coalesceMs override", () => { - const timing = buildEditHistoryEntry({ - projectId: "project-1", - label: "Resize timeline clip", - kind: "timeline", - coalesceKey: "timeline-resize:clip", - files: { "index.html": { before: "orig", after: "timing" } }, - now: 0, - id: "timing", - }); - const late = buildEditHistoryEntry({ - projectId: "project-1", - label: "Resize timeline clip", - kind: "timeline", - coalesceKey: "timeline-resize:clip", - files: { "index.html": { before: "timing", after: "timing+gsap" } }, - now: 2000, - id: "late", - }); - - const state = pushEditHistoryEntry( - pushEditHistoryEntry(createEmptyEditHistory(), timing), - late, - ); - - expect(state.undo).toHaveLength(2); - }); - - it("coalesces entries with the same coalesceKey within the window (prop: format)", () => { - const first = buildEditHistoryEntry({ - projectId: "project-1", - label: "Edit title color", - kind: "source", - coalesceKey: "prop:title.color", - files: { - "index.html": { before: "a", after: "b" }, - }, - now: 100, - id: "entry-1", - }); - const second = buildEditHistoryEntry({ - projectId: "project-1", - label: "Edit title color", - kind: "source", - coalesceKey: "prop:title.color", - files: { - "index.html": { before: "b", after: "c" }, - }, - now: 200, - id: "entry-2", - }); - - const state = pushEditHistoryEntry( - pushEditHistoryEntry(createEmptyEditHistory(), first), - second, - { coalesceMs: 1000 }, - ); - - expect(state.undo).toHaveLength(1); - expect(state.undo[0].id).toBe("entry-2"); - expect(state.undo[0].files["index.html"].before).toBe("a"); - expect(state.undo[0].files["index.html"].after).toBe("c"); - }); - - it("does not coalesce entries with different coalesceKeys (cross-prop separation)", () => { - const titleEdit = buildEditHistoryEntry({ - projectId: "project-1", - label: "Edit title color", - kind: "source", - coalesceKey: "prop:title.color", - files: { - "index.html": { before: "a", after: "b" }, - }, - now: 100, - id: "entry-title", - }); - const bodyEdit = buildEditHistoryEntry({ - projectId: "project-1", - label: "Edit body color", - kind: "source", - coalesceKey: "prop:body.color", - files: { - "index.html": { before: "b", after: "c" }, - }, - now: 200, - id: "entry-body", - }); - - const state = pushEditHistoryEntry( - pushEditHistoryEntry(createEmptyEditHistory(), titleEdit), - bodyEdit, - { coalesceMs: 1000 }, - ); - - expect(state.undo.map((e) => e.id)).toEqual(["entry-title", "entry-body"]); - }); - - it("does not coalesce source editor edits outside the coalesce window", () => { - const first = buildEditHistoryEntry({ - projectId: "project-1", - label: "Edit source", - kind: "source", - coalesceKey: "source:index.html", - files: { - "index.html": { before: "a", after: "b" }, - }, - now: 100, - id: "entry-1", - }); - const second = buildEditHistoryEntry({ - projectId: "project-1", - label: "Edit source", - kind: "source", - coalesceKey: "source:index.html", - files: { - "index.html": { before: "b", after: "c" }, - }, - now: 5000, - id: "entry-2", - }); - - const state = pushEditHistoryEntry( - pushEditHistoryEntry(createEmptyEditHistory(), first), - second, - { coalesceMs: 1000 }, - ); - - expect(state.undo.map((entry) => entry.id)).toEqual(["entry-1", "entry-2"]); - }); - - it("coalesces entries exactly at the coalesce boundary (delta === coalesceMs is inclusive)", () => { - const first = buildEditHistoryEntry({ - projectId: "project-1", - label: "Edit source", - kind: "source", - coalesceKey: "source:index.html", - files: { - "index.html": { before: "a", after: "b" }, - }, - now: 100, - id: "entry-1", - }); - const second = buildEditHistoryEntry({ - projectId: "project-1", - label: "Edit source", - kind: "source", - coalesceKey: "source:index.html", - files: { - "index.html": { before: "b", after: "c" }, - }, - now: 1100, // exactly coalesceMs=1000ms after first - id: "entry-2", - }); - - const state = pushEditHistoryEntry( - pushEditHistoryEntry(createEmptyEditHistory(), first), - second, - { coalesceMs: 1000 }, - ); - - // Boundary is <=: delta of exactly 1000ms coalesces into one entry. - expect(state.undo).toHaveLength(1); - expect(state.undo[0].id).toBe("entry-2"); - expect(state.undo[0].files["index.html"].before).toBe("a"); - expect(state.undo[0].files["index.html"].after).toBe("c"); - }); - - it.todo("gesture-start/commit collapses intermediate drag steps into one undo entry"); - - it.todo( - "origin:applyPatches edits are excluded from undo stack to prevent undo loops (requires SDK session)", - ); -}); diff --git a/packages/studio/src/utils/editHistory.ts b/packages/studio/src/utils/editHistory.ts index 85a42f8b7b..6cd41125da 100644 --- a/packages/studio/src/utils/editHistory.ts +++ b/packages/studio/src/utils/editHistory.ts @@ -1,236 +1 @@ export type EditHistoryKind = "manual" | "motion" | "timeline" | "source"; - -export interface EditHistoryFileSnapshot { - before: string; - after: string; - beforeHash: string; - afterHash: string; -} - -export interface EditHistoryEntry { - id: string; - projectId: string; - label: string; - kind: EditHistoryKind; - coalesceKey?: string; - /** Per-entry coalesce window override (ms). Falls back to the reducer default. */ - coalesceMs?: number; - createdAt: number; - files: Record; -} - -export interface EditHistoryState { - version: 1; - updatedAt: number; - undo: EditHistoryEntry[]; - redo: EditHistoryEntry[]; -} - -export interface EditHistoryOptions { - maxEntries?: number; - coalesceMs?: number; -} - -export interface BuildEditHistoryEntryInput { - id: string; - projectId: string; - label: string; - kind?: EditHistoryKind; - coalesceKey?: string; - coalesceMs?: number; - now: number; - files: Record; -} - -export type EditHistoryDirection = "undo" | "redo"; - -export type EditHistoryApplyCheck = - | { ok: true } - | { ok: false; reason: "content-mismatch"; path: string }; - -export type EditHistoryTransitionResult = - | { - ok: true; - state: EditHistoryState; - entry: EditHistoryEntry; - filesToWrite: Record; - } - | { - ok: false; - reason: "empty" | "content-mismatch"; - state: EditHistoryState; - filesToWrite: Record; - path?: string; - }; - -const DEFAULT_MAX_ENTRIES = 100; -const DEFAULT_COALESCE_MS = 300; - -export function hashEditHistoryContent(content: string): string { - let hash = 2166136261; - for (let index = 0; index < content.length; index += 1) { - hash ^= content.charCodeAt(index); - hash = Math.imul(hash, 16777619); - } - return (hash >>> 0).toString(16).padStart(8, "0"); -} - -export function createEmptyEditHistory(_options?: EditHistoryOptions): EditHistoryState { - return { - version: 1, - updatedAt: 0, - undo: [], - redo: [], - }; -} - -export function buildEditHistoryEntry(input: BuildEditHistoryEntryInput): EditHistoryEntry { - const files: Record = {}; - for (const [path, snapshot] of Object.entries(input.files)) { - if (snapshot.before === snapshot.after) continue; - files[path] = { - before: snapshot.before, - after: snapshot.after, - beforeHash: hashEditHistoryContent(snapshot.before), - afterHash: hashEditHistoryContent(snapshot.after), - }; - } - - return { - id: input.id, - projectId: input.projectId, - label: input.label, - kind: input.kind ?? "manual", - coalesceKey: input.coalesceKey, - coalesceMs: input.coalesceMs, - createdAt: input.now, - files, - }; -} - -export function pushEditHistoryEntry( - state: EditHistoryState, - entry: EditHistoryEntry, - options?: EditHistoryOptions, -): EditHistoryState { - if (Object.keys(entry.files).length === 0) return state; - - // The incoming entry's own window wins so a caller can guarantee a merge even when a - // slow async step (e.g. a server GSAP rewrite) sits between the two records. - const coalesceMs = entry.coalesceMs ?? options?.coalesceMs ?? DEFAULT_COALESCE_MS; - const maxEntries = options?.maxEntries ?? DEFAULT_MAX_ENTRIES; - const previous = state.undo[state.undo.length - 1]; - let undo = state.undo; - - if ( - previous && - previous.coalesceKey && - previous.coalesceKey === entry.coalesceKey && - entry.createdAt - previous.createdAt <= coalesceMs && - // A shared key/window is not enough: bytes from an external writer may - // have landed between the two Studio-owned edits. Only fold a path when - // the follow-up starts from the exact output the previous entry recorded. - // Otherwise keep both entries so undo restores the foreign bytes first and - // the older entry's content check safely blocks at that ownership boundary. - Object.entries(entry.files).every(([path, snapshot]) => { - const previousSnapshot = previous.files[path]; - return !previousSnapshot || previousSnapshot.after === snapshot.before; - }) - ) { - // A follow-up may touch only a subset of the files in the original edit - // (for example, only one file in a multi-file timing move has GSAP). Keep - // previous-only paths in the single coalesced undo entry. - const files: Record = { ...previous.files }; - for (const [path, snapshot] of Object.entries(entry.files)) { - const previousSnapshot = previous.files[path]; - files[path] = previousSnapshot - ? { - before: previousSnapshot.before, - after: snapshot.after, - beforeHash: previousSnapshot.beforeHash, - afterHash: snapshot.afterHash, - } - : snapshot; - } - undo = [...state.undo.slice(0, -1), { ...entry, files }]; - } else { - undo = [...state.undo, entry]; - } - - return { - version: 1, - updatedAt: entry.createdAt, - undo: undo.slice(Math.max(0, undo.length - maxEntries)), - redo: [], - }; -} - -export function canApplyEditHistoryEntry( - entry: EditHistoryEntry, - direction: EditHistoryDirection, - currentHashes: Record, -): EditHistoryApplyCheck { - for (const [path, snapshot] of Object.entries(entry.files)) { - const expected = direction === "undo" ? snapshot.afterHash : snapshot.beforeHash; - if (currentHashes[path] !== expected) { - return { ok: false, reason: "content-mismatch", path }; - } - } - return { ok: true }; -} - -export function undoEditHistory( - state: EditHistoryState, - currentHashes: Record, - now: number, -): EditHistoryTransitionResult { - const entry = state.undo[state.undo.length - 1]; - if (!entry) return { ok: false, reason: "empty", state, filesToWrite: {} }; - - const check = canApplyEditHistoryEntry(entry, "undo", currentHashes); - if (!check.ok) { - return { ok: false, reason: check.reason, path: check.path, state, filesToWrite: {} }; - } - - return { - ok: true, - entry, - filesToWrite: Object.fromEntries( - Object.entries(entry.files).map(([path, snapshot]) => [path, snapshot.before]), - ), - state: { - version: 1, - updatedAt: now, - undo: state.undo.slice(0, -1), - redo: [...state.redo, entry], - }, - }; -} - -export function redoEditHistory( - state: EditHistoryState, - currentHashes: Record, - now: number, -): EditHistoryTransitionResult { - const entry = state.redo[state.redo.length - 1]; - if (!entry) return { ok: false, reason: "empty", state, filesToWrite: {} }; - - const check = canApplyEditHistoryEntry(entry, "redo", currentHashes); - if (!check.ok) { - return { ok: false, reason: check.reason, path: check.path, state, filesToWrite: {} }; - } - - return { - ok: true, - entry, - filesToWrite: Object.fromEntries( - Object.entries(entry.files).map(([path, snapshot]) => [path, snapshot.after]), - ), - state: { - version: 1, - updatedAt: now, - undo: [...state.undo, entry], - redo: state.redo.slice(0, -1), - }, - }; -} diff --git a/packages/studio/src/utils/editHistoryStorage.test.ts b/packages/studio/src/utils/editHistoryStorage.test.ts deleted file mode 100644 index be5e3a6f98..0000000000 --- a/packages/studio/src/utils/editHistoryStorage.test.ts +++ /dev/null @@ -1,37 +0,0 @@ -import { beforeEach, describe, expect, it } from "vitest"; -import { buildEditHistoryEntry, createEmptyEditHistory, pushEditHistoryEntry } from "./editHistory"; -import { - createMemoryEditHistoryStorage, - loadEditHistoryState, - saveEditHistoryState, -} from "./editHistoryStorage"; - -describe("edit history storage", () => { - let storage: ReturnType; - - beforeEach(() => { - storage = createMemoryEditHistoryStorage(); - }); - - it("returns empty history for projects without persisted state", async () => { - const state = await loadEditHistoryState(storage, "project-1"); - - expect(state).toEqual(createEmptyEditHistory()); - }); - - it("saves and loads history per project", async () => { - const entry = buildEditHistoryEntry({ - id: "entry-1", - projectId: "project-1", - label: "Move layer", - files: { "index.html": { before: "a", after: "b" } }, - now: 100, - }); - const state = pushEditHistoryEntry(createEmptyEditHistory(), entry); - - await saveEditHistoryState(storage, "project-1", state); - - expect(await loadEditHistoryState(storage, "project-1")).toEqual(state); - expect(await loadEditHistoryState(storage, "project-2")).toEqual(createEmptyEditHistory()); - }); -}); diff --git a/packages/studio/src/utils/editHistoryStorage.ts b/packages/studio/src/utils/editHistoryStorage.ts deleted file mode 100644 index 1266c9a8dd..0000000000 --- a/packages/studio/src/utils/editHistoryStorage.ts +++ /dev/null @@ -1,99 +0,0 @@ -import { createEmptyEditHistory, type EditHistoryState } from "./editHistory"; - -export interface EditHistoryStorageAdapter { - get(projectId: string): Promise; - set(projectId: string, state: EditHistoryState): Promise; - delete(projectId: string): Promise; -} - -const DB_NAME = "hyperframes-studio-edit-history"; -const DB_VERSION = 1; -const STORE_NAME = "project-history"; - -export function createMemoryEditHistoryStorage(): EditHistoryStorageAdapter { - const states = new Map(); - return { - async get(projectId) { - return states.get(projectId) ?? null; - }, - async set(projectId, state) { - states.set(projectId, structuredClone(state)); - }, - async delete(projectId) { - states.delete(projectId); - }, - }; -} - -function openEditHistoryDb(): Promise { - return new Promise((resolve, reject) => { - if (!globalThis.indexedDB) { - reject(new Error("IndexedDB is not available")); - return; - } - - const request = globalThis.indexedDB.open(DB_NAME, DB_VERSION); - request.onupgradeneeded = () => { - const db = request.result; - if (!db.objectStoreNames.contains(STORE_NAME)) { - db.createObjectStore(STORE_NAME); - } - }; - request.onerror = () => reject(request.error ?? new Error("Failed to open edit history db")); - request.onsuccess = () => resolve(request.result); - }); -} - -function withStore( - mode: IDBTransactionMode, - callback: (store: IDBObjectStore) => IDBRequest, -): Promise { - return openEditHistoryDb().then( - (db) => - new Promise((resolve, reject) => { - const tx = db.transaction(STORE_NAME, mode); - const request = callback(tx.objectStore(STORE_NAME)); - request.onerror = () => reject(request.error ?? new Error("IndexedDB request failed")); - request.onsuccess = () => resolve(request.result); - tx.oncomplete = () => db.close(); - tx.onerror = () => { - db.close(); - reject(tx.error ?? new Error("IndexedDB transaction failed")); - }; - }), - ); -} - -export function createIndexedDbEditHistoryStorage(): EditHistoryStorageAdapter { - return { - async get(projectId) { - return ( - (await withStore("readonly", (store) => - store.get(projectId), - )) ?? null - ); - }, - async set(projectId, state) { - await withStore("readwrite", (store) => store.put(state, projectId)); - }, - async delete(projectId) { - await withStore("readwrite", (store) => store.delete(projectId)); - }, - }; -} - -export async function loadEditHistoryState( - storage: EditHistoryStorageAdapter, - projectId: string, -): Promise { - const state = await storage.get(projectId); - return state ?? createEmptyEditHistory(); -} - -export async function saveEditHistoryState( - storage: EditHistoryStorageAdapter, - projectId: string, - state: EditHistoryState, -): Promise { - await storage.set(projectId, state); -}