@hyperframes/studio 0.8.79 → 0.8.80

package/src/player/components/timelineGroupEditing.ts

@@ -13,6 +13,12 @@ function roundTimelineTime(value: number): number {
   return roundToCenti(value);
 }
 
+const SAVED_MEDIA_OFFSET_TOLERANCE = 1e-5;
+
+function ceilTimelineTime(value: number): number {
+  return Math.ceil((value - SAVED_MEDIA_OFFSET_TOLERANCE) * 100) / 100;
+}
+
 export function resolveTimelineMinDuration(minDuration?: number): number {
   return Math.max(ABSOLUTE_TIMELINE_MIN_DURATION, minDuration ?? DEFAULT_TIMELINE_MIN_DURATION);
 }
@@ -33,7 +39,7 @@ interface TimelineStartTrimClip {
  * Delta bounds for trimming a clip's START edge (shared by single-clip and group
  * resize). Left-bounded by how far the start can move toward `minStart` and by the
  * media in-point (`playbackStart / playbackRate`); right-bounded by `minDuration`.
- * Returned deltas are unrounded — callers round with their own centisecond helper.
+ * Returned deltas are unrounded; applyClipStartTrimDelta does the rounding.
  */
 export function clipStartTrimDeltaBounds(
   clip: TimelineStartTrimClip,
@@ -50,21 +56,24 @@ export function clipStartTrimDeltaBounds(
 }
 
 /**
- * Apply a start-edge delta to one clip (unrounded): moves the start, shrinks the
- * duration by the same amount, and shifts the media in-point by the delta scaled to
- * the playback rate (clamped at 0).
+ * Apply a start-edge delta to one clip: rounds the start once, keeps the end fixed,
+ * and derives the media in-point from the rounded start (clamped at 0), so the media
+ * clock `start - playbackStart / playbackRate` survives any number of head trims.
  */
 export function applyClipStartTrimDelta(
   clip: TimelineStartTrimClip,
   delta: number,
 ): { start: number; duration: number; playbackStart?: number } {
   const playbackRate = resolveTimelinePlaybackRate(clip.playbackRate);
+  const mediaZero =
+    clip.playbackStart != null ? clip.start - clip.playbackStart / playbackRate : -Infinity;
+  const start = Math.max(roundTimelineTime(clip.start + delta), ceilTimelineTime(mediaZero));
   return {
-    start: clip.start + delta,
-    duration: clip.duration - delta,
+    start,
+    duration: roundTimelineTime(clip.start + clip.duration - start),
     playbackStart:
       clip.playbackStart != null
-        ? Math.max(0, clip.playbackStart + delta * playbackRate)
+        ? Math.max(0, clip.playbackStart + (start - clip.start) * playbackRate)
         : undefined,
   };
 }
@@ -126,7 +135,7 @@ export function clampTimelineGroupResizeDelta(
 
   // Rigid group: the applied delta is bounded by the most-constrained member.
   const bounds = members.map((member) => clipStartTrimDeltaBounds(member, 0, minDuration));
-  const minDelta = Math.max(...bounds.map((b) => b.minDelta));
+  const minDelta = ceilTimelineTime(Math.max(...bounds.map((b) => b.minDelta)));
   const maxDelta = Math.min(...bounds.map((b) => b.maxDelta));
   return roundTimelineTime(clamp(rawDelta, minDelta, maxDelta));
 }
@@ -149,13 +158,7 @@ export function resolveTimelineGroupResize(
         };
       }
 
-      const trimmed = applyClipStartTrimDelta(member, delta);
-      return {
-        start: roundTimelineTime(trimmed.start),
-        duration: roundTimelineTime(trimmed.duration),
-        playbackStart:
-          trimmed.playbackStart != null ? roundTimelineTime(trimmed.playbackStart) : undefined,
-      };
+      return applyClipStartTrimDelta(member, delta);
     }),
   };
 }

package/src/player/components/timelineStackingSync.ts

@@ -17,6 +17,8 @@
  * style) and apply the returned `StackingPatch[]` however they persist styles.
  */
 
+import { spansOverlap } from "@hyperframes/core/clip-facts";
+
 /** Minimal element view this module reasons over. */
 export interface StackingElement {
   /** Stable identity (TimelineElement.key ?? id). */
@@ -69,8 +71,6 @@ export interface StackingPatch {
   zIndex: number;
 }
 
-const EPS = 1e-6;
-
 /**
  * Canonical paint-scope key: leaf z-indexes are comparable only within the same
  * source document and CSS stacking context. The ONLY place this normalization
@@ -90,17 +90,17 @@ export function samePaintScope(
 /**
  * Two clips overlap in time when their half-open [start, end) intervals intersect.
  *
- * NOTE the `- EPS`: this DELIBERATELY diverges from `timeRangesOverlap`'s exact
+ * NOTE the float slack: this DELIBERATELY diverges from `timeRangesOverlap`'s exact
  * strict-`<` (timelineCollision.ts). A boolean collision decision is idempotent, so
  * exact `<` is fine there; here the result drives a VISIBLE stacking re-lane, so the
- * epsilon guards against float fuzz (e.g. 5.0000001 vs 5) spuriously overlapping two
+ * epsilon guards against float fuzz (e.g. 19.8 + 6.4 vs 26.2) spuriously overlapping two
  * abutting clips and shuffling lanes. The two are intended to differ, not align.
  */
 function overlapsInTime(
   a: Pick<StackingElement, "start" | "duration">,
   b: Pick<StackingElement, "start" | "duration">,
 ): boolean {
-  return a.start < b.start + b.duration - EPS && b.start < a.start + a.duration - EPS;
+  return spansOverlap(a.start, a.start + a.duration, b.start, b.start + b.duration);
 }
 
 /**

package/src/player/components/timelineZones.ts

@@ -1,3 +1,4 @@
+import { spansOverlap } from "@hyperframes/core/clip-facts";
 import type { TimelineElement } from "../store/playerStore";
 import { isAudioTimelineElement } from "../../utils/timelineInspector";
 import { isTransitionPair } from "./timelineTransitionSeams";
@@ -23,11 +24,9 @@ export function isMainTrackElement(el: TimelineElement): boolean {
 
 const keyOf = (el: TimelineElement) => el.key ?? el.id;
 
-const EPS = 1e-6;
-
 /** Two clips overlap when their half-open [start, end) intervals intersect. */
 function overlaps(a: TimelineElement, b: TimelineElement): boolean {
-  return a.start < b.start + b.duration - EPS && b.start < a.start + a.duration - EPS;
+  return spansOverlap(a.start, a.start + a.duration, b.start, b.start + b.duration);
 }
 
 /** Deterministic order on the stable clip id (never the mutated lane/track). */

package/src/player/components/useAutomationEdgeStretch.ts

@@ -51,7 +51,7 @@ export interface UseAutomationEdgeStretchInput {
   /** Pointer position as a clip-local time and a parameter value. */
   pointAt(clientX: number, clientY: number): { t: number; v: number };
   xOf(t: number): number;
-  commitPoints(points: HfAutomationLane["points"], persist: boolean): void;
+  commitPoints(points: HfAutomationLane["points"], persist: boolean, ended?: boolean): void;
   /** Clamp bound for the dragged edge. */
   duration: number;
   readOnly?: boolean | undefined;
@@ -252,9 +252,9 @@ export function useAutomationEdgeStretch({
     onHint(null);
     if (!crossed.current) return;
     crossed.current = false;
-    // A live write is a preview, so putting the snapshot back through the same
-    // channel is the whole revert — there is nothing persisted to undo.
-    commitPoints(points, false);
+    // Nothing was persisted: the snapshot goes back as the last live write, which
+    // also ends the lane's gesture so its before-value does not outlive it.
+    commitPoints(points, false, true);
     onRangeSelect?.(origin.t0, origin.t1, origin.v0, origin.v1);
   }, [drag, onHint, commitPoints, onRangeSelect]);
 

package/src/player/components/useAutomationLaneGestures.ts

@@ -46,7 +46,7 @@ export interface UseAutomationLaneGesturesInput {
   pointAt(clientX: number, clientY: number): { t: number; v: number };
   xOf(t: number): number;
   yOf(v: number): number;
-  commitPoints(points: HfAutomationLane["points"], persist: boolean): void;
+  commitPoints(points: HfAutomationLane["points"], persist: boolean, ended?: boolean): void;
   /** Clip-local times a dragged point snaps to, on top of its own neighbours. */
   snapTimes?: readonly number[] | undefined;
   readOnly?: boolean | undefined;