@hyperframes/studio 0.8.75 → 0.8.76

package/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<void>;
 
 interface Harness {
   disk: Record<string, string>;
-  store: ReturnType<typeof createPersistentEditHistoryStore>;
+  // 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<typeof mountProbe>;
   expected: string;
@@ -53,18 +50,7 @@ function mountRazorSplit(opts: { gsap?: boolean; previewStamp?: boolean } = {}):
   const disk: Record<string, string> = { "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<Harness, "disk" | "store">) {
-  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,16 @@ 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",
+        });
+        expect(harness.records[0]!.files["index.html"]).toEqual({
+          before: ORIGINAL,
+          after: harness.expected,
+        });
       });
     });
   }
@@ -222,20 +203,14 @@ const batchElements: TimelineElement[] = [
 
 interface SplitAllHarness {
   disk: Record<string, string>;
-  store: ReturnType<typeof createPersistentEditHistoryStore>;
+  records: RecordEditInput[];
   splitAllRef: { current: SplitAll | undefined };
   root: ReturnType<typeof mountProbe>;
 }
 
 function mountRazorSplitAll(failOnSplit?: number): SplitAllHarness {
   const disk: Record<string, string> = { ...BATCH_ORIGINALS };
-  const store = createPersistentEditHistoryStore({
-    projectId: "p1",
-    storage: createMemoryEditHistoryStorage(),
-    initialState: createEmptyEditHistory(),
-    now: () => 1000,
-    onChange: () => {},
-  });
+  const records: RecordEditInput[] = [];
   let splitCount = 0;
 
   vi.stubGlobal(
@@ -255,7 +230,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 +241,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 +257,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());
   });
 });

package/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<string, string>();
-  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<string, string>;
-  store: ReturnType<typeof createPersistentEditHistoryStore>;
+  // 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<typeof vi.fn>;
   root: ReturnType<typeof mountProbe>;
 }
@@ -186,13 +178,7 @@ function mountRazorSplitWithHistory(): UndoHarness {
   const disk: Record<string, string> = {
     [ROOT_FILE]: `<div class="clip" id="root-clip" data-start="0" data-duration="10"></div>`,
   };
-  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 () => {
-    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("<!--split-->");
-  });
-
-  it("still trips the guard when the file is edited externally after a split", 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);
     });
-    // Simulate the user editing the file in their own editor after the split.
-    h.disk[ROOT_FILE] = `${h.disk[ROOT_FILE]}<!--hand-edit-->`;
-    const result = await h.store.undo(readFile());
-    expect(result.ok).toBe(false);
-    expect(result.reason).toBe("content-mismatch");
+    expect(h.disk[ROOT_FILE]).toContain("<!--split-->");
+    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] });
   });
 });

package/src/hooks/useRenderClipContent.test.ts

@@ -7,6 +7,8 @@ import { CompositionThumbnail, VideoThumbnail } from "../player";
 import { AudioWaveform } from "../player/components/AudioWaveform";
 import type { TimelineClipRenderContext } from "../player/components/TimelineTypes";
 import { usePlayerStore, type TimelineElement } from "../player/store/playerStore";
+import { buildCompositionThumbnailUrl } from "../player/components/CompositionThumbnail";
+import { compositionCardThumbnailUrl } from "../components/sidebar/CompositionsTab";
 import { normalizeCompositionSrc } from "./useRenderClipContent";
 import { useRenderClipContent } from "./useRenderClipContent";
 
@@ -316,4 +318,31 @@ describe("useRenderClipContent", () => {
       });
     }
   });
+
+  it.each(["compositions/scene-0.html", "compositions/scene [v2].html", "compositions/100%.html"])(
+    "asks for the same thumbnail as the card of %s, so one render serves both",
+    (compositionSrc) => {
+      usePlayerStore.setState({
+        thumbnailMode: "adaptive",
+        thumbnailRevisions: { [compositionSrc]: 3 },
+      });
+
+      const content = renderClipContent({
+        id: "scene-0",
+        tag: "div",
+        start: 10,
+        duration: 5,
+        track: 0,
+        compositionSrc,
+      });
+
+      expect(isValidElement(content)).toBe(true);
+      if (!isValidElement(content)) return;
+      const clipUrl = buildCompositionThumbnailUrl({
+        ...(content.props as Parameters<typeof buildCompositionThumbnailUrl>[0]),
+        origin: window.location.origin,
+      });
+      expect(clipUrl).toBe(compositionCardThumbnailUrl("my-project", compositionSrc, 3));
+    },
+  );
 });

package/src/hooks/useRenderClipContent.ts

@@ -2,7 +2,10 @@ import { buildProjectApiPath } from "../utils/projectRouting";
 import { useCallback, type ReactNode } from "react";
 import { createElement } from "react";
 import { CompositionThumbnail, VideoThumbnail } from "../player";
-import { compositionPathOfPreviewUrl } from "../player/components/CompositionThumbnail";
+import {
+  compositionPathOfPreviewUrl,
+  resolveThumbnailSeekTime,
+} from "../player/components/CompositionThumbnail";
 import type { TimelineElement } from "../player";
 import type { TimelineClipRenderContext } from "../player/components/TimelineTypes";
 import { audioPillFlags } from "../player/components/audioClipLink";
@@ -157,8 +160,8 @@ export function useRenderClipContent({
           label: "",
           labelColor: style.label,
 
-          seekTime: 0,
-          duration: el.duration,
+          seekTime: resolveThumbnailSeekTime(el.duration),
+          duration: 0,
           projectId: pid,
           sessionEpoch,
           contentRevision: thumbnailRevisionOf(thumbnailRevisions, compSrc),

package/src/hooks/useSdkSession.lifecycle.test.tsx

@@ -12,6 +12,7 @@ vi.mock("@hyperframes/sdk", () => ({
 
 import type { Composition } from "@hyperframes/sdk";
 import { useSdkSession, type SdkSessionHandle } from "./useSdkSession";
+import { usePlayerStore } from "../player/store/playerStore";
 
 vi.mock("../utils/studioTelemetry", () => ({ trackStudioEvent: vi.fn() }));
 
@@ -19,6 +20,10 @@ import { trackStudioEvent } from "../utils/studioTelemetry";
 
 const trackMock = vi.mocked(trackStudioEvent);
 
+beforeEach(() => {
+  usePlayerStore.setState({ timelineProjectId: "project-a", previewBooted: true });
+});
+
 function Probe({ projectId }: { projectId: string }) {
   useSdkSession(projectId, "index.html");
   return null;
@@ -54,6 +59,24 @@ describe("useSdkSession ownership", () => {
     vi.unstubAllGlobals();
   });
 
+  it("does not read or parse the composition until the live preview has booted", async () => {
+    usePlayerStore.setState({ previewBooted: false });
+    const fetchStub = vi.fn(async () => response("PROJECT_A"));
+    vi.stubGlobal("fetch", fetchStub);
+    openComposition.mockImplementation(async () => fakeSession());
+
+    const root = createRoot(document.createElement("div"));
+    await act(async () => root.render(<Probe projectId="project-a" />));
+    await flushAsyncEffects();
+    expect(fetchStub).not.toHaveBeenCalled();
+    expect(openComposition).not.toHaveBeenCalled();
+
+    await act(async () => usePlayerStore.getState().markPreviewBooted());
+    await flushAsyncEffects();
+    expect(openComposition).toHaveBeenCalledWith("PROJECT_A", { history: false });
+    act(() => root.unmount());
+  });
+
   it("hides project A immediately while project B with the same path is still opening", async () => {
     const sessionA = fakeSession();
     const publishedA = fakeSession();
@@ -94,7 +117,11 @@ describe("useSdkSession ownership", () => {
     expect(publication).toBe("published");
     expect(captured.handle?.session).toBe(publishedA);
 
-    await act(async () => root.render(<Probe projectId="project-b" />));
+    await act(async () => {
+      usePlayerStore.getState().beginTimelineSession("project-b");
+      usePlayerStore.getState().markPreviewBooted();
+      root.render(<Probe projectId="project-b" />);
+    });
     expect(captured.handle?.session).toBeNull();
     expect(publishedA.dispose).toHaveBeenCalledOnce();
     expect(
@@ -164,6 +191,7 @@ describe("useSdkSession unreachable project", () => {
   });
 
   function probeHandle(projectId: string) {
+    usePlayerStore.setState({ timelineProjectId: projectId });
     const captured: { handle: SdkSessionHandle | null } = { handle: null };
     function HandleProbe() {
       captured.handle = useSdkSession(projectId, "index.html");
@@ -684,11 +712,13 @@ describe("useSdkSession unavailable telemetry", () => {
         ),
       );
       await flushAsyncEffects();
-      await act(async () =>
+      await act(async () => {
+        usePlayerStore.getState().beginTimelineSession("project-b");
+        usePlayerStore.getState().markPreviewBooted();
         root.render(
           <HandleProbe projectId="project-b" path="index.html" onAbsentRead={onAbsentRead} />,
-        ),
-      );
+        );
+      });
       await flushAsyncEffects();
 
       expect(onAbsentRead).toHaveBeenCalledTimes(2);

package/src/hooks/useSdkSession.ts

@@ -5,6 +5,7 @@ import { isSelfWriteEcho } from "./sdkSelfWriteRegistry";
 import { trackStudioEvent } from "../utils/studioTelemetry";
 import type { PublishSdkSession } from "../utils/sdkCutover";
 import { addExternalFileReloadListener } from "./externalFileReloadBus";
+import { whenPreviewBooted } from "../player/store/playerStore";
 
 /**
  * Why an optional project-file read produced no usable content. `stage: "read"`
@@ -439,9 +440,14 @@ export function useSdkSession(
       generation,
     };
 
-    readProjectFileOptional(projectId, activeCompPath)
+    // Parsing the source for editing takes the main thread for hundreds of ms on a large film;
+    // the first frame and play do not need it, so it waits for the live preview to boot.
+    whenPreviewBooted(projectId)
+      .then((booted) =>
+        cancelled || !booted ? null : readProjectFileOptional(projectId, activeCompPath),
+      )
       .then(async (read) => {
-        if (cancelled) return;
+        if (!read || cancelled) return;
         if (!read.ok) {
           handleReadFailure(read, projectId, activeCompPath);
           return;

package/src/hooks/useSlideshowPersist.ts

@@ -1,7 +1,6 @@
 import { useCallback } from "react";
 import type { Composition } from "@hyperframes/sdk";
 import type { SlideshowManifest } from "@hyperframes/core/slideshow";
-import type { EditHistoryKind } from "../utils/editHistory";
 import type { PublishSdkSession } from "../utils/sdkCutover";
 import { persistSlideshowManifest } from "../utils/setSlideshowManifest";
 
@@ -12,7 +11,6 @@ export interface UseSlideshowPersistParams {
   writeProjectFile: (path: string, content: string) => Promise<void>;
   recordEdit: (entry: {
     label: string;
-    kind: EditHistoryKind;
     files: Record<string, { before: string; after: string }>;
   }) => Promise<void>;
   reloadPreview: () => void;

package/src/hooks/useStudioContextValue.ts

@@ -17,7 +17,12 @@ interface StudioContextInput {
   setRefreshKey: React.Dispatch<React.SetStateAction<number>>;
   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

package/src/hooks/useTimelineAssetDropOps.ts

@@ -166,7 +166,6 @@ export function useTimelineAssetDropOps({
         await saveProjectFilesWithHistory({
           projectId: pid,
           label: "Add timeline asset",
-          kind: "timeline",
           files: { [targetPath]: patchedContent },
           readFile: async () => originalContent,
           writeFile: writeProjectFile,

package/src/hooks/useTimelineDeleteOps.ts

@@ -157,7 +157,6 @@ export function useTimelineDeleteOps({
           await saveProjectFilesWithHistory({
             projectId: pid,
             label: deleteHistoryLabel,
-            kind: "timeline",
             coalesceKey,
             files: { [targetPath]: patchedContent },
             readFile: async () => originalContent,

package/src/hooks/useTimelineEditing.test.tsx

@@ -112,7 +112,6 @@ function renderTimelineEditingHook(input: {
   writeProjectFile?: (path: string, content: string) => Promise<void>;
   recordEdit?: (input: {
     label: string;
-    kind: string;
     coalesceKey?: string;
     files: Record<string, { before: string; after: string }>;
   }) => Promise<void>;

package/src/hooks/useTimelineEditingTypes.ts

@@ -2,13 +2,11 @@ import type { MutableRefObject, RefObject } from "react";
 import type { Composition } from "@hyperframes/sdk";
 import type { TimelineElement } from "../player";
 import type { TimelineStackingReorderIntent } from "../player/components/timelineEditing";
-import type { EditHistoryKind } from "../utils/editHistory";
 import type { PublishSdkSession } from "../utils/sdkCutover";
 import type { CanEditTimelineElement } from "./timelineEditPermission";
 
 interface RecordEditInput {
   label: string;
-  kind: EditHistoryKind;
   coalesceKey?: string;
   files: Record<string, { before: string; after: string }>;
 }