@hyperframes/studio 0.8.56 → 0.8.57

package/src/player/components/TimelineOverlays.test.ts

@@ -1,19 +1,22 @@
 // @vitest-environment happy-dom
 import { act, createElement } from "react";
-import { createRoot, type Root } from "react-dom/client";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import type { TimelineElement } from "../store/playerStore";
 import { usePlayerStore } from "../store/playerStore";
 import { type KeyframeDiamondContextMenuState } from "./KeyframeDiamondContextMenu";
 import { TimelineOverlays, resolveTimelineContextElement } from "./TimelineOverlays";
+import {
+  TimelineContextProvider,
+  type TimelineContextValue,
+  type TimelineOverlaysState,
+} from "./TimelineProvider";
 import { defaultTimelineTheme } from "./timelineTheme";
+import { createHappyDomRootHarness } from "./testRootHarness";
 
 (globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
 
-const roots: Root[] = [];
+const { mount } = createHappyDomRootHarness();
 afterEach(() => {
-  for (const root of roots.splice(0)) act(() => root.unmount());
-  document.body.innerHTML = "";
   usePlayerStore.setState({ selectedElementId: null, timelineSessionEpoch: 0 });
 });
 
@@ -76,8 +79,7 @@ function renderKeyframeOverlay(options: {
 }) {
   const container = document.createElement("div");
   document.body.appendChild(container);
-  const root = createRoot(container);
-  roots.push(root);
+  const root = mount(container);
   const elements = [options.currentElement];
   const setKfContextMenu = options.setKfContextMenu ?? vi.fn();
   const onDeleteAllKeyframes = options.onDeleteAllKeyframes ?? vi.fn();
@@ -90,6 +92,64 @@ function renderKeyframeOverlay(options: {
     percentage: 50,
     animationId: "child-position",
   };
+  const overlays = {
+    elements,
+    elementsRef: { current: elements },
+    theme: defaultTimelineTheme,
+    showShortcutHint: false,
+    showPopover: false,
+    rangeSelection: null,
+    setShowPopover: vi.fn(),
+    setRangeSelection: vi.fn(),
+    kfContextMenu: menu,
+    setKfContextMenu,
+    onDeleteKeyframe: vi.fn(),
+    onDeleteAllKeyframes,
+    onMoveKeyframeToPlayhead: vi.fn(),
+    clipContextMenu: null,
+    setClipContextMenu: vi.fn(),
+    currentTime: 0,
+    onSplitElement: vi.fn(),
+    pinZoomBeforeEdit: vi.fn(),
+    onDeleteElement: vi.fn(),
+    gapContextMenu: null,
+    onDismissGapContextMenu: vi.fn(),
+    onCloseTrackGap: vi.fn(),
+    onCloseAllTrackGaps: vi.fn(),
+    onHoverGapAction: vi.fn(),
+  } satisfies TimelineOverlaysState;
+  const contextValue = {
+    state: {
+      timelineReady: true,
+      elements,
+      selectedElementId: null,
+      sessionEpoch: 0,
+      keyframeCache: new Map(),
+      canvas: {} as TimelineContextValue["state"]["canvas"],
+      overlays,
+    },
+    actions: {
+      renderClipContent: undefined,
+      renderClipOverlay: undefined,
+      setFocusedEaseSegment: vi.fn(),
+    },
+    meta: {} as TimelineContextValue["meta"],
+  } satisfies TimelineContextValue;
+
+  function TestTimelineContext({ value }: { value: TimelineContextValue }) {
+    const selectedElementId = usePlayerStore((state) => state.selectedElementId);
+    const sessionEpoch = usePlayerStore((state) => state.timelineSessionEpoch);
+    return createElement(
+      TimelineContextProvider,
+      {
+        value: {
+          ...value,
+          state: { ...value.state, selectedElementId, sessionEpoch },
+        },
+      },
+      createElement(TimelineOverlays),
+    );
+  }
 
   act(() => {
     usePlayerStore.setState({
@@ -97,32 +157,7 @@ function renderKeyframeOverlay(options: {
       timelineSessionEpoch: 2,
     });
     root.render(
-      createElement(TimelineOverlays, {
-        elements,
-        elementsRef: { current: elements },
-        theme: defaultTimelineTheme,
-        showShortcutHint: false,
-        showPopover: false,
-        rangeSelection: null,
-        setShowPopover: vi.fn(),
-        setRangeSelection: vi.fn(),
-        kfContextMenu: menu,
-        setKfContextMenu,
-        onDeleteKeyframe: vi.fn(),
-        onDeleteAllKeyframes,
-        onMoveKeyframeToPlayhead: vi.fn(),
-        clipContextMenu: null,
-        setClipContextMenu: vi.fn(),
-        currentTime: 0,
-        onSplitElement: vi.fn(),
-        pinZoomBeforeEdit: vi.fn(),
-        onDeleteElement: vi.fn(),
-        gapContextMenu: null,
-        onDismissGapContextMenu: vi.fn(),
-        onCloseTrackGap: vi.fn(),
-        onCloseAllTrackGaps: vi.fn(),
-        onHoverGapAction: vi.fn(),
-      }),
+      createElement(TestTimelineContext, { value: contextValue }, createElement(TimelineOverlays)),
     );
   });
   return { setKfContextMenu, onDeleteAllKeyframes };

package/src/player/components/TimelineOverlays.tsx

@@ -1,67 +1,13 @@
-import { useEffect, type MutableRefObject } from "react";
+import { useEffect } from "react";
 import type { TimelineElement } from "../store/playerStore";
-import { usePlayerStore } from "../store/playerStore";
-import type { TimelineTheme } from "./timelineTheme";
-import type { TimelineRangeSelection } from "./timelineEditing";
-import type { TimelineEditCallbacks } from "./timelineCallbacks";
 import { EditPopover } from "./EditModal";
-import {
-  KeyframeDiamondContextMenu,
-  type KeyframeDiamondContextMenuState,
-} from "./KeyframeDiamondContextMenu";
+import { KeyframeDiamondContextMenu } from "./KeyframeDiamondContextMenu";
 import { ClipContextMenu } from "./ClipContextMenu";
 import { TrackGapContextMenu } from "./TrackGapContextMenu";
 import { TimelineShortcutHint } from "./TimelineShortcutHint";
 import { copyTextToClipboard } from "../../utils/clipboard";
 import { trackStudioSegmentEaseEdit } from "../../telemetry/events";
-
-export interface ClipContextMenuState {
-  x: number;
-  y: number;
-  element: TimelineElement;
-  sessionEpoch: number;
-}
-
-/** Resolved model for the empty-lane-space (track gap) context menu. */
-interface TrackGapContextMenuState {
-  x: number;
-  y: number;
-  gapWidth: number | null;
-  canCloseGap: boolean;
-  canCloseAllGaps: boolean;
-  hasAnyGaps: boolean;
-}
-
-interface TimelineOverlaysProps {
-  elements: readonly TimelineElement[];
-  elementsRef: MutableRefObject<readonly TimelineElement[]>;
-  theme: TimelineTheme;
-  showShortcutHint: boolean;
-  showPopover: boolean;
-  rangeSelection: TimelineRangeSelection | null;
-  setShowPopover: (value: boolean) => void;
-  setRangeSelection: (value: TimelineRangeSelection | null) => void;
-  kfContextMenu: KeyframeDiamondContextMenuState | null;
-  setKfContextMenu: (value: KeyframeDiamondContextMenuState | null) => void;
-  onDeleteKeyframe: TimelineEditCallbacks["onDeleteKeyframe"];
-  onDeleteAllKeyframes: TimelineEditCallbacks["onDeleteAllKeyframes"];
-  onMoveKeyframeToPlayhead: TimelineEditCallbacks["onMoveKeyframeToPlayhead"];
-  clipContextMenu: ClipContextMenuState | null;
-  setClipContextMenu: (value: ClipContextMenuState | null) => void;
-  currentTime: number;
-  onSplitElement: TimelineEditCallbacks["onSplitElement"];
-  pinZoomBeforeEdit: () => void;
-  onDeleteElement?: (element: TimelineElement) => Promise<void> | void;
-  onCopyClip?: () => boolean;
-  onPasteClip?: () => Promise<void>;
-  onDuplicateClip?: () => Promise<boolean>;
-  canPasteClip?: () => boolean;
-  gapContextMenu: TrackGapContextMenuState | null;
-  onDismissGapContextMenu: () => void;
-  onCloseTrackGap: () => void;
-  onCloseAllTrackGaps: () => void;
-  onHoverGapAction: (action: "close-gap" | "close-all" | null) => void;
-}
+import { useTimelineContext } from "./TimelineProvider";
 
 interface TimelineContextTargetInput {
   capturedElement: TimelineElement;
@@ -85,56 +31,43 @@ export function resolveTimelineContextElement({
   return elements.find((element) => (element.key ?? element.id) === identity) ?? null;
 }
 
-function readTimelineContextElement(
-  capturedElement: TimelineElement,
-  targetSessionEpoch: number | undefined,
-  elements: readonly TimelineElement[],
-): TimelineElement | null {
-  const state = usePlayerStore.getState();
-  return resolveTimelineContextElement({
-    capturedElement,
-    targetSessionEpoch,
-    sessionEpoch: state.timelineSessionEpoch,
-    selectedElementId: state.selectedElementId,
-    elements,
-  });
-}
-
 // The timeline's floating overlays, rendered as siblings above the scroll area:
 // the shortcut hint, the range-edit popover, the keyframe-diamond context menu,
 // and the clip context menu.
-export function TimelineOverlays({
-  elements,
-  elementsRef,
-  theme,
-  showShortcutHint,
-  showPopover,
-  rangeSelection,
-  setShowPopover,
-  setRangeSelection,
-  kfContextMenu,
-  setKfContextMenu,
-  onDeleteKeyframe,
-  onDeleteAllKeyframes,
-  onMoveKeyframeToPlayhead,
-  clipContextMenu,
-  setClipContextMenu,
-  currentTime,
-  onSplitElement,
-  pinZoomBeforeEdit,
-  onDeleteElement,
-  onCopyClip,
-  onPasteClip,
-  onDuplicateClip,
-  canPasteClip,
-  gapContextMenu,
-  onDismissGapContextMenu,
-  onCloseTrackGap,
-  onCloseAllTrackGaps,
-  onHoverGapAction,
-}: TimelineOverlaysProps) {
-  const selectedElementId = usePlayerStore((state) => state.selectedElementId);
-  const sessionEpoch = usePlayerStore((state) => state.timelineSessionEpoch);
+export function TimelineOverlays() {
+  const { state, actions } = useTimelineContext();
+  const overlayProps = state.overlays;
+  const {
+    elements,
+    elementsRef,
+    theme,
+    showShortcutHint,
+    showPopover,
+    rangeSelection,
+    setShowPopover,
+    setRangeSelection,
+    kfContextMenu,
+    setKfContextMenu,
+    onDeleteKeyframe,
+    onDeleteAllKeyframes,
+    onMoveKeyframeToPlayhead,
+    clipContextMenu,
+    setClipContextMenu,
+    currentTime,
+    onSplitElement,
+    pinZoomBeforeEdit,
+    onDeleteElement,
+    onCopyClip,
+    onPasteClip,
+    onDuplicateClip,
+    canPasteClip,
+    gapContextMenu,
+    onDismissGapContextMenu,
+    onCloseTrackGap,
+    onCloseAllTrackGaps,
+    onHoverGapAction,
+  } = overlayProps;
+  const { selectedElementId, sessionEpoch, keyframeCache } = state;
   const kfTargetSessionEpoch = kfContextMenu?.sessionEpoch;
   const clipTargetSessionEpoch = clipContextMenu?.sessionEpoch;
   const keyframeElement = kfContextMenu
@@ -156,7 +89,13 @@ export function TimelineOverlays({
       })
     : null;
   const readCurrentElement = (element: TimelineElement, targetSessionEpoch: number | undefined) =>
-    readTimelineContextElement(element, targetSessionEpoch, elementsRef.current);
+    resolveTimelineContextElement({
+      capturedElement: element,
+      targetSessionEpoch,
+      sessionEpoch,
+      selectedElementId,
+      elements: elementsRef.current,
+    });
 
   useEffect(() => {
     if (kfContextMenu && !keyframeElement) setKfContextMenu(null);
@@ -217,7 +156,7 @@ export function TimelineOverlays({
                   ) {
                     return;
                   }
-                  usePlayerStore.getState().setFocusedEaseSegment({
+                  actions.setFocusedEaseSegment({
                     animationId: keyframe.animationId,
                     collidingAnimationTargets: keyframe.collidingAnimationTargets,
                     tweenPercentage: keyframe.tweenPercentage,
@@ -228,7 +167,7 @@ export function TimelineOverlays({
               : undefined
           }
           onCopyProperties={(elementId, keyframe) => {
-            const entry = usePlayerStore.getState().keyframeCache.get(elementId);
+            const entry = keyframeCache.get(elementId);
             // Tolerance match on clip-%, the same basis the cache is keyed on —
             // an exact float compare misses a keyframe the menu just opened over.
             const kf = entry?.keyframes.find(

package/src/player/components/TimelineProvider.tsx

@@ -0,0 +1,191 @@
+import {
+  createContext,
+  useContext,
+  type ComponentProps,
+  type CSSProperties,
+  type MouseEvent,
+  type PointerEvent,
+  type ReactNode,
+  type RefCallback,
+  type UIEvent,
+} from "react";
+import type { TimelineEmptyState } from "./TimelineEmptyState";
+import type { TimelineProps } from "./TimelineTypes";
+import type { TimelineRangeSelection } from "./timelineEditing";
+import type { TimelineDropPlacement } from "./timelineCallbacks";
+import type { Rect } from "../../utils/marqueeGeometry";
+import type { ResizingClipState } from "./useTimelineClipDrag";
+import type { TimelineLaneBaseProps } from "./timelineLaneProps";
+import type { TimelineLaneGapStrips } from "./useTimelineGapHighlights";
+import type { TimelineElement } from "../store/playerStore";
+import type { KeyframeCacheEntry } from "../store/keyframeSlice";
+import type { AnimationKeyframeTarget } from "../../hooks/gsapTweenSynth";
+import type { TimelineTheme } from "./timelineTheme";
+import type { TimelineEditCallbacks } from "./timelineCallbacks";
+import type { KeyframeDiamondContextMenuState } from "./KeyframeDiamondContextMenu";
+import { useTimelineProviderState } from "./useTimelineProviderState";
+
+export type TimelineCanvasState = Omit<
+  TimelineLaneBaseProps,
+  | "setRangeSelection"
+  | "setResizingClip"
+  | "setDraggedClip"
+  | "renderClipContent"
+  | "renderClipOverlay"
+> & {
+  major: number[];
+  minor: number[];
+  totalH: number;
+  effectiveDuration: number;
+  majorTickInterval: number;
+  rangeSelection: TimelineRangeSelection | null;
+  marqueeRect: Rect | null;
+  resizingClip: ResizingClipState | null;
+  isScrubbing: boolean;
+  playheadRef: React.RefObject<HTMLDivElement | null>;
+  laneGapStrips: TimelineLaneGapStrips[];
+  dropPreview: TimelineDropPlacement | null;
+  setRangeSelection: (value: TimelineRangeSelection | null) => void;
+  setResizingClip: (value: ResizingClipState | null) => void;
+  setDraggedClip: (value: TimelineLaneBaseProps["draggedClip"]) => void;
+  beatDragging: boolean;
+  onResizeElement: TimelineEditCallbacks["onResizeElement"];
+  onMoveElement: TimelineEditCallbacks["onMoveElement"];
+};
+
+export interface ClipContextMenuState {
+  x: number;
+  y: number;
+  element: TimelineElement;
+  sessionEpoch: number;
+}
+
+export interface TrackGapContextMenuState {
+  x: number;
+  y: number;
+  gapWidth: number | null;
+  canCloseGap: boolean;
+  canCloseAllGaps: boolean;
+  hasAnyGaps: boolean;
+}
+
+export interface TimelineOverlaysState {
+  elements: readonly TimelineElement[];
+  elementsRef: { current: readonly TimelineElement[] };
+  theme: TimelineTheme;
+  showShortcutHint: boolean;
+  showPopover: boolean;
+  rangeSelection: TimelineRangeSelection | null;
+  setShowPopover: (value: boolean) => void;
+  setRangeSelection: (value: TimelineRangeSelection | null) => void;
+  kfContextMenu: KeyframeDiamondContextMenuState | null;
+  setKfContextMenu: (value: KeyframeDiamondContextMenuState | null) => void;
+  onDeleteKeyframe: TimelineEditCallbacks["onDeleteKeyframe"];
+  onDeleteAllKeyframes: TimelineEditCallbacks["onDeleteAllKeyframes"];
+  onMoveKeyframeToPlayhead: TimelineEditCallbacks["onMoveKeyframeToPlayhead"];
+  clipContextMenu: ClipContextMenuState | null;
+  setClipContextMenu: (value: ClipContextMenuState | null) => void;
+  currentTime: number;
+  onSplitElement: TimelineEditCallbacks["onSplitElement"];
+  pinZoomBeforeEdit: () => void;
+  onDeleteElement?: (element: TimelineElement) => Promise<void> | void;
+  onCopyClip?: () => boolean;
+  onPasteClip?: () => Promise<void>;
+  onDuplicateClip?: () => Promise<boolean>;
+  canPasteClip?: () => boolean;
+  gapContextMenu: TrackGapContextMenuState | null;
+  onDismissGapContextMenu: () => void;
+  onCloseTrackGap: () => void;
+  onCloseAllTrackGaps: () => void;
+  onHoverGapAction: (action: "close-gap" | "close-all" | null) => void;
+}
+
+export interface TimelineContainerProps {
+  ref: RefCallback<HTMLDivElement>;
+  "aria-label": string;
+  "data-timeline-element-count": number;
+  className: string;
+  onMouseMove: (event: MouseEvent<HTMLDivElement>) => void;
+  onMouseLeave: () => void;
+  style: CSSProperties;
+}
+
+export interface TimelineViewportProps {
+  ref: RefCallback<HTMLDivElement>;
+  "data-timeline-scroll-viewport": boolean;
+  "data-timeline-auto-scroll-left-inset": number;
+  tabIndex: number;
+  className: string;
+  onScroll: (event: UIEvent<HTMLDivElement>) => void;
+  onFocus: (event: React.FocusEvent<HTMLDivElement>) => void;
+  onBlur: (event: React.FocusEvent<HTMLDivElement>) => void;
+  onDragOver: (event: React.DragEvent<HTMLDivElement>) => void;
+  onDragLeave: (event: React.DragEvent<HTMLDivElement>) => void;
+  onDrop: (event: React.DragEvent<HTMLDivElement>) => void;
+  onPointerDown: (event: PointerEvent<HTMLDivElement>) => void;
+  onPointerMove: (event: PointerEvent<HTMLDivElement>) => void;
+  onPointerUp: (event: PointerEvent<HTMLDivElement>) => void;
+  onPointerCancel: (event: PointerEvent<HTMLDivElement>) => void;
+  onLostPointerCapture: (event: PointerEvent<HTMLDivElement>) => void;
+}
+
+export interface TimelineState {
+  timelineReady: boolean;
+  elements: readonly TimelineElement[];
+  selectedElementId: string | null;
+  sessionEpoch: number;
+  keyframeCache: Map<string, KeyframeCacheEntry>;
+  canvas: TimelineCanvasState;
+  overlays: TimelineOverlaysState;
+}
+
+export interface TimelineActions {
+  renderClipContent: TimelineLaneBaseProps["renderClipContent"];
+  renderClipOverlay: TimelineLaneBaseProps["renderClipOverlay"];
+  setFocusedEaseSegment: (target: {
+    animationId: string;
+    collidingAnimationTargets?: AnimationKeyframeTarget[];
+    tweenPercentage: number;
+    elementId: string;
+  }) => void;
+}
+
+export interface TimelineMeta {
+  emptyState: ComponentProps<typeof TimelineEmptyState>;
+  containerProps: TimelineContainerProps;
+  viewportProps: TimelineViewportProps;
+  razorGuide: ReactNode;
+}
+
+export interface TimelineContextValue {
+  state: TimelineState;
+  actions: TimelineActions;
+  meta: TimelineMeta;
+}
+
+const TimelineContext = createContext<TimelineContextValue | null>(null);
+
+export function TimelineProvider({ children, ...props }: TimelineProps & { children: ReactNode }) {
+  const value = useTimelineProviderState(props);
+  return <TimelineContext.Provider value={value}>{children}</TimelineContext.Provider>;
+}
+
+export function TimelineContextProvider({
+  value,
+  children,
+}: {
+  value: TimelineContextValue;
+  children: ReactNode;
+}) {
+  return <TimelineContext.Provider value={value}>{children}</TimelineContext.Provider>;
+}
+
+export function useTimelineContext(): TimelineContextValue {
+  const value = useTimelineContextOptional();
+  if (value === null) throw new Error("useTimelineContext must be used inside TimelineProvider");
+  return value;
+}
+
+function useTimelineContextOptional(): TimelineContextValue | null {
+  return useContext(TimelineContext);
+}

package/src/player/components/testRootHarness.ts

@@ -0,0 +1,18 @@
+import { act } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach } from "vitest";
+
+export function createHappyDomRootHarness() {
+  const roots: Root[] = [];
+  afterEach(() => {
+    for (const root of roots.splice(0)) act(() => root.unmount());
+    document.body.innerHTML = "";
+  });
+  return {
+    mount(host: HTMLElement) {
+      const root = createRoot(host);
+      roots.push(root);
+      return root;
+    },
+  };
+}

package/src/player/components/timelineProviderStateBuilders.test.ts

@@ -0,0 +1,109 @@
+// @vitest-environment happy-dom
+
+import { describe, expect, it, vi } from "vitest";
+import {
+  buildTimelineMeta,
+  resolveRenderClipContent,
+  resolveResizingElementIds,
+  shouldIgnoreTimelinePointerDown,
+  type TimelineMetaBuilderInputs,
+} from "./timelineProviderStateBuilders";
+
+function inputs(overrides: Partial<TimelineMetaBuilderInputs> = {}): TimelineMetaBuilderInputs {
+  return {
+    emptyState: {} as TimelineMetaBuilderInputs["emptyState"],
+    container: {
+      ref: vi.fn(),
+      "aria-label": "Timeline track view",
+      "data-timeline-element-count": 2,
+      isDragOver: false,
+      activeTool: "select",
+      shiftHeld: false,
+      accentClass: "ring",
+      onMouseMove: vi.fn(),
+      onMouseLeave: vi.fn(),
+      style: {},
+    },
+    viewport: {
+      ref: vi.fn(),
+      tabIndex: -1,
+      labelMode: false,
+      zoomMode: "fit",
+      onScroll: vi.fn(),
+      onFocus: vi.fn(),
+      onBlur: vi.fn(),
+      onDragOver: vi.fn(),
+      onDragLeave: vi.fn(),
+      onDrop: vi.fn(),
+      onPointerDown: vi.fn(),
+      onPointerMove: vi.fn(),
+      onPointerUp: vi.fn(),
+      onPointerCancel: vi.fn(),
+      onLostPointerCapture: vi.fn(),
+    },
+    elementCount: 2,
+    labelColumnWidth: 120,
+    razorGuide: null,
+    ...overrides,
+  };
+}
+
+describe("buildTimelineMeta", () => {
+  it("uses the razor branch for the container class", () => {
+    const meta = buildTimelineMeta(
+      inputs({
+        container: {
+          ...inputs().container,
+          activeTool: "razor",
+        },
+      }),
+    );
+    expect(meta.containerProps.className).toContain("cursor-crosshair");
+  });
+
+  it("uses the shift branch for the container class", () => {
+    const meta = buildTimelineMeta(
+      inputs({ container: { ...inputs().container, shiftHeld: true } }),
+    );
+    expect(meta.containerProps.className).toContain("cursor-crosshair");
+  });
+
+  it("uses the default container class without an accent", () => {
+    const meta = buildTimelineMeta(inputs());
+    expect(meta.containerProps.className).toContain("cursor-default");
+    expect(meta.containerProps.className).not.toContain("ring");
+  });
+
+  it("uses the label-column inset only in label mode", () => {
+    const fit = buildTimelineMeta(inputs());
+    const labels = buildTimelineMeta(
+      inputs({ viewport: { ...inputs().viewport, labelMode: true } }),
+    );
+    expect(fit.viewportProps["data-timeline-auto-scroll-left-inset"]).toBe(0);
+    expect(labels.viewportProps["data-timeline-auto-scroll-left-inset"]).toBe(120);
+  });
+});
+
+describe("timeline provider branch helpers", () => {
+  it("resolves virtualized clip content", () => {
+    const render = () => null;
+    expect(resolveRenderClipContent(true, true, render)).toBeUndefined();
+    expect(resolveRenderClipContent(false, true, render)).toBe(render);
+  });
+
+  it("resolves resizing element ids", () => {
+    expect(resolveResizingElementIds(null)).toBeUndefined();
+    expect(resolveResizingElementIds({ element: { id: "clip" } } as never)).toEqual(["clip"]);
+    expect(resolveResizingElementIds({ groupPreview: [{ key: "group::clip" }] } as never)).toEqual([
+      "group::clip",
+    ]);
+  });
+
+  it("ignores pointer downs on interactive descendants only", () => {
+    const button = document.createElement("button");
+    const div = document.createElement("div");
+    expect(shouldIgnoreTimelinePointerDown(button)).toBe(true);
+    expect(shouldIgnoreTimelinePointerDown(div)).toBe(false);
+    expect(shouldIgnoreTimelinePointerDown(null)).toBe(false);
+  });
+});