@hyperframes/studio 0.8.121 → 0.8.123

package/src/player/components/timelineClipDragPreview.ts

@@ -5,7 +5,7 @@ import {
   resolveTimelineMinDuration,
 } from "./timelineGroupEditing";
 import type { TimelineElement } from "../store/playerStore";
-import { clampToHostStart } from "../store/timelineElement";
+import { clampToHostStart, savedClipEdges } from "../store/timelineElement";
 import {
   CLIP_Y,
   TRACK_H,
@@ -34,7 +34,6 @@ import { heldAudioShiftRange, heldPartnerVideoBounds } from "./audioClipLink";
 type BuildSnapTargets = (
   excludeElementKey: string | null,
   includeBeats: boolean,
-  includePlayhead?: boolean,
 ) => TimelineSnapTarget[];
 
 export interface DragPreviewContext {
@@ -56,6 +55,8 @@ export interface DragPreviewContext {
    * on demand from `elements`, so the result is identical either way.
    */
   audioTracks?: ReadonlySet<number>;
+  /** Seconds between the ruler's lines; 0 or absent when snapping is off. */
+  gridStep?: number;
 }
 
 export function createKeyboardClipDrag(
@@ -248,6 +249,7 @@ export function computeDragPreview(
     // Relaxed clamp: allow the snapped start past the content, up to the
     // rendered extent (see dragMaxStart) — the composition grows on commit.
     dragMaxStart + drag.element.duration,
+    ctx.gridStep,
   );
   // A group moves rigidly: the grabbed clip stops where any mover would cross its host's start.
   const group = resolveGroupDrag(drag, ctx);
@@ -266,6 +268,11 @@ export function computeDragPreview(
     return { ...drag, started: true };
   }
   const { track: previewTrack, insertRow } = placement;
+  const target =
+    placement.start === snap.start && snap.snapTime !== null && snap.snapType !== null
+      ? { time: snap.snapTime, type: snap.snapType }
+      : null;
+  const guide = guideIfSaved(drag.element, { start: snap.start }, target, pps);
   return {
     ...drag,
     started: true,
@@ -277,11 +284,24 @@ export function computeDragPreview(
     // tell a deliberate vertical lane change from a horizontal drag.
     desiredTrack: nextMove.track,
     insertRow,
-    snapTime: placement.start === snap.start ? snap.snapTime : null,
-    snapType: placement.start === snap.start ? snap.snapType : null,
+    snapTime: guide?.time ?? null,
+    snapType: guide?.type ?? null,
   };
 }
 
+/** A snap's guide, kept only when the clip's edge as its file will save it is within a pixel of it. */
+export function guideIfSaved(
+  element: TimelineElement,
+  clip: { start: number; duration?: number },
+  target: TimelineSnapTarget | null,
+  pps: number,
+): TimelineSnapTarget | null {
+  if (!target) return null;
+  const saved = savedClipEdges(element, clip.start, clip.duration);
+  const off = Math.min(Math.abs(saved.start - target.time), Math.abs(saved.end - target.time));
+  return off * pps < 1 ? target : null;
+}
+
 /** One frame: the last visible frame of a clip sits just before its end time. */
 const TRIM_END_FRAME_LEAD_S = 1 / STUDIO_PREVIEW_FPS;
 
@@ -296,6 +316,8 @@ export interface ResizePreviewContext {
   buildSnapTargets: BuildSnapTargets;
   elements?: readonly TimelineElement[];
   gestureKeys?: ReadonlySet<string>;
+  /** Seconds between the ruler's lines; 0 or absent when snapping is off. */
+  gridStep?: number;
 }
 
 export interface ResizePreviewResult {
@@ -362,21 +384,19 @@ export function computeResizePreview(
     effectiveClientX,
   );
 
-  // Snap to beats and clip edges, never the playhead (the dragged edge drives
-  // its own preview seek, so that would be circular). Stay inside the same
-  // limits resolveTimelineResize enforces. The music track defines the
-  // beats, so it must not snap to them, but still snaps to clip edges.
+  // Snap within the same limits resolveTimelineResize enforces. The music
+  // track defines the beats, so it must not snap to them.
   const trimTargets = buildSnapTargets(
     resize.element.key ?? resize.element.id,
     !isMusicTrack(resize.element),
-    false,
   );
+  const gridStep = ctx.gridStep ?? 0;
   let snap: TimelineSnapTarget | null = null;
-  if (trimTargets.length > 0) {
+  if (trimTargets.length > 0 || gridStep > 0) {
     const snapSecs = TIMELINE_SNAP_PX / Math.max(pps, 1);
     if (resize.edge === "end") {
       const edgeTime = nextResize.start + nextResize.duration;
-      const { time: snapped, target } = snapTimelineTime(edgeTime, trimTargets, snapSecs);
+      const { time: snapped, target } = snapTimelineTime(edgeTime, trimTargets, snapSecs, gridStep);
       // Stay within [start+minDuration, maxEnd] so the snap can't create a
       // degenerate clip or run past the source/composition limit.
       const snappedDuration = Math.round((snapped - nextResize.start) * 1000) / 1000;
@@ -387,16 +407,21 @@ export function computeResizePreview(
       ) {
         // An edge already on the target still owns the guide; only move it when off.
         if (snapped !== edgeTime) nextResize = { ...nextResize, duration: snappedDuration };
-        snap = target;
+        snap = guideIfSaved(resize.element, nextResize, target, pps);
       }
     } else {
-      const { time: snapped, target } = snapTimelineTime(nextResize.start, trimTargets, snapSecs);
+      const { time: snapped, target } = snapTimelineTime(
+        nextResize.start,
+        trimTargets,
+        snapSecs,
+        gridStep,
+      );
       const clip = { ...nextResize, playbackRate: resize.element.playbackRate };
       const delta = snapped - nextResize.start;
       const bounds = clipStartTrimDeltaBounds(clip, minStart, resolveTimelineMinDuration());
       if (target && delta >= bounds.minDelta - 1e-6 && delta <= bounds.maxDelta + 1e-6) {
         if (snapped !== nextResize.start) nextResize = applyClipStartTrimDelta(clip, delta);
-        snap = target;
+        snap = guideIfSaved(resize.element, nextResize, target, pps);
       }
     }
   }

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

@@ -18,7 +18,11 @@ import {
   resolveTimelineAssetDrop,
   getTimelineBeatEntries,
 } from "./timelineLayout";
-import { generateTicks, getTimelineMajorTickInterval } from "./timelineRulerGeometry";
+import {
+  generateTicks,
+  getTimelineGridStep,
+  getTimelineMajorTickInterval,
+} from "./timelineRulerGeometry";
 import { resolveInsertRow } from "./timelineCollision";
 import { getTimelineRenderTimeRange } from "./timelineViewportGeometry";
 
@@ -42,6 +46,25 @@ describe("horizontal timeline window", () => {
     expect(ticks.major.length + ticks.minor.length).toBeLessThan(100);
   });
 
+  it("spaces the snap grid exactly like the ruler's drawn lines at each zoom", () => {
+    for (const [pps, fps] of [
+      [100, undefined],
+      [12, undefined],
+      [900, undefined],
+      [100, 30],
+      [3, 30],
+    ] as const) {
+      const { major, minor } = generateTicks(60, pps, fps);
+      const lines = [...major, ...minor].sort((a, b) => a - b);
+      expect(getTimelineGridStep(60, pps, fps)).toBeCloseTo(lines[1]! - lines[0]!, 6);
+    }
+  });
+
+  it("has no snap grid where the ruler draws no lines", () => {
+    expect(generateTicks(20_000, 100)).toEqual({ major: [], minor: [] });
+    expect(getTimelineGridStep(20_000, 100)).toBe(0);
+  });
+
   it("slices beat records with original strength indexes and unions a pinned beat", () => {
     expect(
       getTimelineBeatEntries(

package/src/player/components/timelineRulerGeometry.ts

@@ -1,4 +1,5 @@
-import { formatTime } from "../lib/time";
+import { formatTime, STUDIO_PREVIEW_FPS } from "../lib/time";
+import type { TimelineTimeDisplayMode } from "../../utils/studioUiPreferences";
 import type { TimelineTimeRange } from "../lib/timelineClipIndex";
 
 // fallow-ignore-next-line complexity
@@ -87,6 +88,27 @@ function appendMinorTicks(
   }
 }
 
+function tickSpacing(duration: number, pixelsPerSecond?: number, frameRate?: number) {
+  const majorInterval = getTimelineMajorTickInterval(duration, pixelsPerSecond, frameRate);
+  const subdivisions = getMinorSubdivisions(majorInterval, pixelsPerSecond, frameRate);
+  return { majorInterval, subdivisions };
+}
+
+export function rulerFrameRate(mode: TimelineTimeDisplayMode): number | undefined {
+  return mode === "frame" ? STUDIO_PREVIEW_FPS : undefined;
+}
+
+/** Seconds between neighbouring ruler lines (minor ticks when drawn, else major): the snap grid. */
+export function getTimelineGridStep(
+  duration: number,
+  pixelsPerSecond?: number,
+  frameRate?: number,
+): number {
+  if (!isSupportedTickDuration(duration)) return 0;
+  const { majorInterval, subdivisions } = tickSpacing(duration, pixelsPerSecond, frameRate);
+  return subdivisions > 0 ? majorInterval / subdivisions : majorInterval;
+}
+
 export function generateTicks(
   duration: number,
   pixelsPerSecond?: number,
@@ -94,8 +116,7 @@ export function generateTicks(
   range?: TimelineTimeRange,
 ): { major: number[]; minor: number[] } {
   if (!isSupportedTickDuration(duration)) return { major: [], minor: [] };
-  const majorInterval = getTimelineMajorTickInterval(duration, pixelsPerSecond, frameRate);
-  const subdivisions = getMinorSubdivisions(majorInterval, pixelsPerSecond, frameRate);
+  const { majorInterval, subdivisions } = tickSpacing(duration, pixelsPerSecond, frameRate);
   const minorInterval = subdivisions > 0 ? majorInterval / subdivisions : 0;
   const major: number[] = [];
   const minor: number[] = [];

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

@@ -27,18 +27,6 @@ describe("collectTimelineSnapTargets", () => {
     expect(targets).toContainEqual({ time: 0.5, type: "beat" });
   });
 
-  it("omits the playhead when includePlayhead is false, for a trim", () => {
-    const targets = collectTimelineSnapTargets({
-      elements,
-      playheadTime: 7.25,
-      beatTimes: [0.5],
-      includePlayhead: false,
-    });
-    expect(targets.some((t) => t.type === "playhead")).toBe(false);
-    expect(targets).toContainEqual({ time: 2, type: "clip-edge" });
-    expect(targets).toContainEqual({ time: 0.5, type: "beat" });
-  });
-
   it("excludes the dragged element's own edges", () => {
     const targets = collectTimelineSnapTargets({
       elements,
@@ -90,6 +78,35 @@ describe("snapTimelineTime", () => {
   it("returns input unchanged when nothing is within threshold", () => {
     expect(snapTimelineTime(6, targets, 0.1)).toEqual({ time: 6, target: null });
   });
+
+  it("snaps to the nearest ruler line when no target is in range", () => {
+    expect(snapTimelineTime(6.27, targets, 0.08, 0.25)).toEqual({
+      time: 6.25,
+      target: { time: 6.25, type: "grid" },
+    });
+    expect(snapTimelineTime(6.37, targets, 0.08, 0.25)).toEqual({ time: 6.37, target: null });
+  });
+
+  it("prefers a target in range over a nearer ruler line", () => {
+    expect(snapTimelineTime(5.24, targets, 0.08, 0.25).target).toEqual({
+      time: 5.3,
+      type: "playhead",
+    });
+  });
+
+  it("snaps a line at its saved centisecond, and not at all when that is a pixel or more off", () => {
+    // 187.5 px/s: 4.625s saves as 4.63s, under a pixel away, so the guide sits where the clip lands.
+    expect(snapTimelineTime(4.627, [], 8 / 187.5, 0.125).target).toEqual({
+      time: 4.63,
+      type: "grid",
+    });
+    // 1440 px/s: 1.025s would save 7px off its line, so the line does not snap.
+    expect(snapTimelineTime(1.026, [], 8 / 1440, 0.025)).toEqual({ time: 1.026, target: null });
+  });
+
+  it("lands on whole frames for a frame-spaced grid", () => {
+    expect(snapTimelineTime(1.01, [], 0.08, 1 / 30).time).toBe(1);
+  });
 });
 
 describe("snapMoveToTargets", () => {
@@ -120,6 +137,20 @@ describe("snapMoveToTargets", () => {
     expect(snapMoveToTargets(5.5, 2, targets, 1000, 60).snapTime).toBeNull();
   });
 
+  it("snaps a clip edge to the ruler grid when no target is near", () => {
+    expect(snapMoveToTargets(1.02, 2, [], 100, 60, 0.25)).toEqual({
+      start: 1,
+      snapTime: 1,
+      snapType: "grid",
+    });
+  });
+
+  it("prefers the edge on a real target over the other edge nearer a ruler line", () => {
+    // start 2.99 is 1px from the 3s line; the end 4.94 is 6px from the playhead at 5
+    const r = snapMoveToTargets(2.99, 1.95, targets, 100, 60, 0.25);
+    expect(r).toEqual({ start: 3.05, snapTime: 5, snapType: "playhead" });
+  });
+
   it("TIMELINE_SNAP_PX matches the historical beat-snap threshold", () => {
     expect(TIMELINE_SNAP_PX).toBe(8);
   });

package/src/player/components/timelineSnapping.ts

@@ -1,6 +1,7 @@
 import type { TimelineElement } from "../store/playerStore";
+import { roundToCenti } from "../../utils/rounding";
 
-export type TimelineSnapType = "beat" | "playhead" | "clip-edge";
+export type TimelineSnapType = "beat" | "playhead" | "clip-edge" | "grid";
 
 export interface TimelineSnapTarget {
   time: number;
@@ -24,6 +25,7 @@ const TYPE_PRIORITY: Record<TimelineSnapType, number> = {
   playhead: 0,
   "clip-edge": 1,
   beat: 2,
+  grid: 3,
 };
 
 export function collectTimelineSnapTargets(input: {
@@ -31,8 +33,6 @@ export function collectTimelineSnapTargets(input: {
   playheadTime: number | null;
   beatTimes: readonly number[];
   excludeElementKey?: string | null;
-  /** A trim excludes the playhead: the dragged edge drives it, so snapping to it is circular. */
-  includePlayhead?: boolean;
 }): TimelineSnapTarget[] {
   const byTime = new Map<number, TimelineSnapTarget>();
   const add = (time: number, type: TimelineSnapType) => {
@@ -50,16 +50,30 @@ export function collectTimelineSnapTargets(input: {
     add(el.start, "clip-edge");
     add(el.start + el.duration, "clip-edge");
   }
-  if (input.playheadTime != null && input.includePlayhead !== false)
-    add(input.playheadTime, "playhead");
+  if (input.playheadTime != null) add(input.playheadTime, "playhead");
 
   return Array.from(byTime.values()).sort((a, b) => a.time - b.time);
 }
 
+/** Nearest ruler line in range, at its saved centisecond, and only within a pixel of it. */
+function nearestGridLine(
+  time: number,
+  gridStep: number,
+  thresholdSecs: number,
+): TimelineSnapTarget | null {
+  if (!(gridStep > 0)) return null;
+  const line = Math.round(time / gridStep) * gridStep;
+  const saved = roundToCenti(line);
+  const pixelsPerSecond = TIMELINE_SNAP_PX / thresholdSecs;
+  if (Math.abs(saved - line) * pixelsPerSecond >= 1) return null;
+  return Math.abs(saved - time) < thresholdSecs ? { time: saved, type: "grid" } : null;
+}
+
 export function snapTimelineTime(
   time: number,
   targets: readonly TimelineSnapTarget[],
   thresholdSecs: number,
+  gridStep = 0,
 ): { time: number; target: TimelineSnapTarget | null } {
   let best: TimelineSnapTarget | null = null;
   let bestDist = thresholdSecs;
@@ -73,6 +87,7 @@ export function snapTimelineTime(
       best = target;
     }
   }
+  best ??= nearestGridLine(time, gridStep, thresholdSecs);
   return best ? { time: best.time, target: best } : { time, target: null };
 }
 
@@ -88,23 +103,26 @@ export function snapMoveToTargets(
   targets: readonly TimelineSnapTarget[],
   pixelsPerSecond: number,
   timelineDuration: number,
+  gridStep = 0,
 ): { start: number; snapTime: number | null; snapType: TimelineSnapType | null } {
-  if (targets.length === 0) return { start, snapTime: null, snapType: null };
+  if (targets.length === 0 && !(gridStep > 0)) return { start, snapTime: null, snapType: null };
   const thresholdSecs = TIMELINE_SNAP_PX / Math.max(pixelsPerSecond, 1);
-  const startSnap = snapTimelineTime(start, targets, thresholdSecs);
-  const endSnap = snapTimelineTime(start + duration, targets, thresholdSecs);
-  const startMoved = startSnap.target !== null;
-  const endMoved = endSnap.target !== null;
+  const startSnap = snapTimelineTime(start, targets, thresholdSecs, gridStep);
+  const endSnap = snapTimelineTime(start + duration, targets, thresholdSecs, gridStep);
+  // The nearer edge wins, but a grid line only when neither edge has a real target.
+  const rank = (snap: typeof startSnap, edgeTime: number) =>
+    snap.target === null
+      ? Infinity
+      : Math.abs(snap.time - edgeTime) + (snap.target.type === "grid" ? thresholdSecs : 0);
+  const startRank = rank(startSnap, start);
+  const endRank = rank(endSnap, start + duration);
 
   let candidate = start;
   let target: TimelineSnapTarget | null = null;
-  if (
-    startMoved &&
-    (!endMoved || Math.abs(startSnap.time - start) <= Math.abs(endSnap.time - (start + duration)))
-  ) {
+  if (startRank !== Infinity && startRank <= endRank) {
     candidate = startSnap.time;
     target = startSnap.target;
-  } else if (endMoved) {
+  } else if (endRank !== Infinity) {
     candidate = endSnap.time - duration;
     target = endSnap.target;
   }

package/src/player/components/useTimelineClipDrag.resize.test.tsx

@@ -4,6 +4,7 @@ import React, { act } from "react";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import type { TimelineElement } from "../store/playerStore";
 import { usePlayerStore } from "../store/playerStore";
+import { usePreviewFrameStore } from "../store/previewFrameStore";
 import type { BlockedClipState, DraggedClipState, ResizingClipState } from "./useTimelineClipDrag";
 import { useTimelineClipDrag } from "./useTimelineClipDrag";
 import { mountReactHarness } from "../../hooks/domSelectionTestHarness";
@@ -26,6 +27,7 @@ function el(id: string, over: Partial<TimelineElement> = {}): TimelineElement {
 afterEach(() => {
   document.body.innerHTML = "";
   usePlayerStore.getState().reset();
+  usePreviewFrameStore.setState({ time: null });
 });
 
 function renderResizeHarness(
@@ -34,7 +36,6 @@ function renderResizeHarness(
   options: {
     wireGroupResize?: boolean;
     snap?: boolean;
-    onSeek?: (time: number, seekOptions?: { keepPlaying?: boolean }) => void;
   } = {},
 ) {
   usePlayerStore.getState().setElements(elements);
@@ -65,7 +66,6 @@ function renderResizeHarness(
       onMoveElement,
       onBlockedEditAttempt,
       onResizeElements: options.wireGroupResize === false ? undefined : onResizeElements,
-      onSeek: options.onSeek,
       setShowPopover: vi.fn(),
       setRangeSelectionRef: { current: vi.fn() },
       sessionEpoch,
@@ -451,16 +451,7 @@ describe("useTimelineClipDrag — multi-select group resize (restored)", () => {
 });
 
 describe("useTimelineClipDrag — trim guide and preview frame", () => {
-  /** Playhead at 1.25s that follows preview seeks; clip a's end edge grabbed and dragged once. */
-  function trimEndWithSeekingPlayhead(state: { isPlaying?: boolean } = {}) {
-    usePlayerStore.setState({ currentTime: 1.25, ...state });
-    const onSeek = vi.fn((t: number) => usePlayerStore.setState({ currentTime: t }));
-    const a = el("a", { start: 1, duration: 2 });
-    const h = renderResizeHarness([a], [], { onSeek });
-    h.startResize(a, "end");
-    h.movePointer(50);
-    return { onSeek, h };
-  }
+  const previewFrame = () => usePreviewFrameStore.getState().time;
 
   /** Clip a (0-2s) with neighbour b starting at 5s, snapping on, a's end edge grabbed. */
   function trimAEndBesideB() {
@@ -487,45 +478,78 @@ describe("useTimelineClipDrag — trim guide and preview frame", () => {
 
   it("publishes no snap target when the trimmed edge is free", () => {
     const h = trimAEndBesideB();
-    h.movePointer(150);
+    h.movePointer(162); // 3.62s: 12px from the 3.5s ruler line, 13px from 3.75s
     expect(h.getResizingClip()).toMatchObject({ snapTime: null, snapType: null });
     h.unmount();
   });
 
-  it("never snaps a trimmed edge to the playhead — the edge drives its own seek", () => {
-    usePlayerStore.setState({ currentTime: 5 }); // no clip edge or beat nearby, only the playhead
+  it("snaps a trimmed edge to the playhead, which stays where it was", () => {
+    usePlayerStore.setState({ currentTime: 5.1 }); // off the ruler grid; no clip edge or beat nearby
     const a = el("a", { start: 0, duration: 2 });
     const h = renderResizeHarness([a], [], { snap: true });
     h.startResize(a, "end");
-    h.movePointer(296); // a's end lands at 4.96s, 4px from the playhead
+    h.movePointer(306); // a's end lands at 5.06s, 4px from the playhead
+    expect(h.getResizingClip()).toMatchObject({
+      snapTime: 5.1,
+      snapType: "playhead",
+      previewDuration: 5.1,
+    });
+    expect(usePlayerStore.getState().currentTime).toBe(5.1);
+    h.unmount();
+  });
+
+  it("snaps a trimmed edge to the ruler's grid line when no clip edge is near", () => {
+    const h = trimAEndBesideB();
+    h.movePointer(152); // 3.52s, 2px from the 3.5s line (0.25s apart at 100px/s)
     expect(h.getResizingClip()).toMatchObject({
-      snapTime: null,
-      snapType: null,
-      previewDuration: 4.96,
+      snapTime: 3.5,
+      snapType: "grid",
+      previewDuration: 3.5,
     });
     h.unmount();
   });
 
-  it("shows the frame at the dragged edge, then puts the playhead back on release", async () => {
+  it("does not snap to the grid with the magnet off", () => {
+    const a = el("a", { start: 0, duration: 2 });
+    const h = renderResizeHarness([a], []);
+    h.startResize(a, "end");
+    h.movePointer(152);
+    expect(h.getResizingClip()).toMatchObject({ snapTime: null, previewDuration: 3.52 });
+    h.unmount();
+  });
+
+  it("shows the dragged edge's frame without moving the playhead, and drops it on release", async () => {
     usePlayerStore.setState({ currentTime: 1.25 });
-    const onSeek = vi.fn();
     const a = el("a", { start: 1, duration: 2 });
-    const h = renderResizeHarness([a], [], { onSeek });
+    const h = renderResizeHarness([a], []);
     h.startResize(a, "end");
     h.movePointer(50);
-    expect(onSeek).toHaveBeenLastCalledWith(3.5 - 1 / 30, { keepPlaying: true, follow: false });
+    expect(previewFrame()).toBeCloseTo(3.5 - 1 / 30, 6);
+    h.movePointer(120);
+    expect(usePlayerStore.getState().currentTime).toBe(1.25);
     await h.dropPointer();
-    expect(onSeek).toHaveBeenLastCalledWith(1.25, { keepPlaying: true, follow: false });
+    expect(previewFrame()).toBeNull();
+    expect(usePlayerStore.getState().currentTime).toBe(1.25);
+    h.unmount();
+  });
+
+  it("drops the preview frame when the trim is cancelled", () => {
+    const a = el("a", { start: 1, duration: 2 });
+    const h = renderResizeHarness([a], []);
+    h.startResize(a, "end");
+    h.movePointer(50);
+    expect(previewFrame()).not.toBeNull();
+    h.pressEscape();
+    expect(previewFrame()).toBeNull();
     h.unmount();
   });
 
   it("previews the new in-point when the start edge is trimmed", () => {
-    const onSeek = vi.fn();
     const a = el("a", { start: 1, duration: 2 });
-    const h = renderResizeHarness([a], [], { onSeek });
+    const h = renderResizeHarness([a], []);
     h.startResize(a, "start");
     h.movePointer(50);
-    expect(onSeek).toHaveBeenLastCalledWith(1.5, { keepPlaying: true, follow: false });
+    expect(previewFrame()).toBe(1.5);
     h.unmount();
   });
 
@@ -540,41 +564,17 @@ describe("useTimelineClipDrag — trim guide and preview frame", () => {
     h.unmount();
   });
 
-  it("restores the playhead it had before the first preview seek, not a seeked time", async () => {
-    const { onSeek, h } = trimEndWithSeekingPlayhead();
-    h.movePointer(80);
-    h.movePointer(120);
-    await h.dropPointer();
-    expect(onSeek).toHaveBeenLastCalledWith(1.25, { keepPlaying: true, follow: false });
-    h.unmount();
-  });
-
-  it("leaves the playhead where playback is when a trim is released while playing", async () => {
-    const { onSeek, h } = trimEndWithSeekingPlayhead({ isPlaying: true });
-    h.movePointer(120);
-    const callsBeforeRelease = onSeek.mock.calls.length;
-    await h.dropPointer();
-    expect(onSeek).toHaveBeenCalledTimes(callsBeforeRelease);
-    expect(onSeek).not.toHaveBeenCalledWith(1.25, expect.anything());
-    usePlayerStore.setState({ isPlaying: false });
-    h.unmount();
-  });
-
-  it("draws no guide and seeks to the rendered edge when a group member clamps the trim", () => {
-    const onSeek = vi.fn();
+  it("draws no guide and previews the rendered edge when a group member clamps the trim", () => {
     const a = el("a", { start: 0, duration: 4 });
     const b = el("b", { start: 0, duration: 1 });
     const c = el("c", { start: 2, duration: 1 });
-    const h = renderResizeHarness([a, b, c], ["a", "b"], { snap: true, onSeek });
+    const h = renderResizeHarness([a, b, c], ["a", "b"], { snap: true });
     h.startResize(a, "end");
     h.movePointer(-198); // a's raw end 2.02s snaps to c at 2s; b clamps the shared delta
     const clip = h.getResizingClip()!;
     expect(clip.previewStart + clip.previewDuration).toBeCloseTo(3.1, 3);
     expect(clip).toMatchObject({ snapTime: null, snapType: null });
-    expect(onSeek).toHaveBeenLastCalledWith(expect.closeTo(3.1 - 1 / 30, 3), {
-      keepPlaying: true,
-      follow: false,
-    });
+    expect(previewFrame()).toBeCloseTo(3.1 - 1 / 30, 3);
     h.unmount();
   });
 });