Skip to content

Write HTML. Render video. Built for agents.

fix(studio): clips inside nested compositions sit at their master time (#4681)

Miguel Ángel3dc3a9ca1a48
diff --git a/packages/core/src/mediaTiming.ts b/packages/core/src/mediaTiming.ts
index 3c24c17bb1..db129fe170 100644
--- a/packages/core/src/mediaTiming.ts
+++ b/packages/core/src/mediaTiming.ts
@@ -22,19 +22,31 @@ export function resolveAbsoluteMediaStartSeconds(input: {
/** The one rule for a media element's root-timeline start; the runtime and the CLI both call it.
* With no literal start, an auto-injected start, or a host at t<=0 there is nothing for the basis
* to disambiguate, so the ordinary start resolution applies. */
-export function resolveMediaStartSeconds(input: {
- authoredStart: number | null;
- hostStart: number;
- hasAutoStart: boolean;
- basis?: string | null;
- ordinaryStart: () => number;
-}): number {
- if (input.hasAutoStart || input.authoredStart == null || input.hostStart <= 0) {
- return input.ordinaryStart();
- }
+export function resolveMediaStartSeconds(
+ input: MediaStartInput & { ordinaryStart: () => number },
+): number {
+ if (!hasLiteralNestedStart(input)) return input.ordinaryStart();
return resolveAbsoluteMediaStartSeconds({
authoredStart: input.authoredStart,
hostStart: input.hostStart,
basis: input.basis,
});
}
+
+/** True when the authored start is already root time, so no host offset applies. */
+export function isRootGlobalMediaStart(input: MediaStartInput): boolean {
+ return hasLiteralNestedStart(input) && readMediaStartBasis(input.basis) === "global";
+}
+
+export interface MediaStartInput {
+ authoredStart: number | null;
+ hostStart: number;
+ hasAutoStart: boolean;
+ basis?: string | null;
+}
+
+function hasLiteralNestedStart(
+ input: MediaStartInput,
+): input is MediaStartInput & { authoredStart: number } {
+ return !input.hasAutoStart && input.authoredStart != null && input.hostStart > 0;
+}
diff --git a/packages/core/src/runtime/startResolver.ts b/packages/core/src/runtime/startResolver.ts
index 3c9395404a..f331d65990 100644
--- a/packages/core/src/runtime/startResolver.ts
+++ b/packages/core/src/runtime/startResolver.ts
@@ -11,10 +11,15 @@ import {
} from "./playbackRate";
import { isMediaElement } from "./domRealm";
import { parseStartExpression } from "./startExpression";
-import { MEDIA_START_BASIS_ATTR, resolveMediaStartSeconds } from "../mediaTiming";
+import {
+ isRootGlobalMediaStart,
+ MEDIA_START_BASIS_ATTR,
+ resolveMediaStartSeconds,
+ type MediaStartInput,
+} from "../mediaTiming";
export function createRuntimeStartTimeResolver(params: {
- timelineRegistry?: Record<string, RuntimeTimelineLike | undefined>;
+ timelineRegistry?: Record<string, Pick<RuntimeTimelineLike, "duration"> | undefined>;
includeAuthoredTimingAttrs?: boolean;
/**
* The document that reference lookups (`data-start="intro + 2"`) resolve
@@ -27,6 +32,8 @@ export function createRuntimeStartTimeResolver(params: {
resolveStartForElement: (element: Element, fallback?: number) => number;
resolveDurationForElement: (element: Element) => number | null;
resolveMediaStartForElement: (element: Element) => number;
+ resolveHostStartForElement: (element: Element) => number;
+ isRootGlobalMediaStartForElement: (element: Element) => boolean;
} {
const timelineRegistry = params.timelineRegistry ?? {};
const includeAuthoredTimingAttrs = params.includeAuthoredTimingAttrs ?? false;
@@ -185,23 +192,34 @@ export function createRuntimeStartTimeResolver(params: {
* cache, WebAudio scheduling — must come through here, or the timeline the
* editor draws stops matching the timeline that plays.
*/
- const resolveMediaStartForElement = (element: Element): number => {
+ const mediaStartInput = (element: Element): MediaStartInput => {
const compositionRoot = element.closest("[data-composition-id]");
- const hostStart = compositionRoot ? resolveStartForElementInternal(compositionRoot, 0) : 0;
- return resolveMediaStartSeconds({
+ return {
authoredStart: parseStrictFiniteTimingNumber(element.getAttribute("data-start")),
- hostStart,
+ hostStart: compositionRoot ? resolveStartForElementInternal(compositionRoot, 0) : 0,
hasAutoStart: element.hasAttribute("data-hf-auto-start"),
basis: element.getAttribute(MEDIA_START_BASIS_ATTR),
- ordinaryStart: () => resolveStartForElementInternal(element, hostStart),
+ };
+ };
+
+ const resolveMediaStartForElement = (element: Element): number => {
+ const input = mediaStartInput(element);
+ return resolveMediaStartSeconds({
+ ...input,
+ ordinaryStart: () => resolveStartForElementInternal(element, input.hostStart),
});
};
+ const isRootGlobalMediaStartForElement = (element: Element): boolean =>
+ isMediaElement(element) && isRootGlobalMediaStart(mediaStartInput(element));
+
return {
resolveStartForElement: (element: Element, fallback = 0) =>
resolveStartForElementInternal(element, Math.max(0, fallback)),
resolveDurationForElement: (element: Element) => resolveDurationForElement(element),
resolveMediaStartForElement,
+ resolveHostStartForElement: (element: Element) => resolveHostOffsetForElement(element, 0),
+ isRootGlobalMediaStartForElement,
};
}
diff --git a/packages/studio/src/components/nle/useTimelineEditCallbacks.test.tsx b/packages/studio/src/components/nle/useTimelineEditCallbacks.test.tsx
index cad2298a21..06e599ea0c 100644
--- a/packages/studio/src/components/nle/useTimelineEditCallbacks.test.tsx
+++ b/packages/studio/src/components/nle/useTimelineEditCallbacks.test.tsx
@@ -149,6 +149,59 @@ function arrangeClickedCircle(): {
return { circle, selection: selectionForElement(circle) };
}
+// main 0 > intro 2 > logo 3 > badge 1: rows are master time, tweens are local.
+function nestedKeyframedRow(id: string, start: number, duration: number, host: number) {
+ const row: TimelineElement = {
+ id,
+ key: `compositions/${id}-parent.html#${id}`,
+ domId: id,
+ tag: "div",
+ start,
+ duration,
+ track: 0,
+ sourceFile: `compositions/${id}-parent.html`,
+ parentCompositionStart: host,
+ };
+ const anim: GsapAnimation = {
+ ...authoredInteriorAnimation(),
+ id: `${id}-to-position`,
+ targetSelector: `#${id}`,
+ position: start - host,
+ resolvedStart: start - host,
+ duration,
+ };
+ usePlayerStore.setState({
+ elements: [row],
+ gsapAnimations: new Map([[row.key!, [anim]]]),
+ });
+ return { row, anim };
+}
+
+describe("keyframe drags on nested rows", () => {
+ it.each([
+ ["logo", 5, 5, 2, 60],
+ ["badge", 6, 2, 5, 75],
+ ])("re-keys %s's middle keyframe inside its local tween", async (id, start, dur, host, pct) => {
+ const { row, anim } = nestedKeyframedRow(id, start, dur, host);
+ const view = renderCallbacks();
+ await act(async () => {
+ await view.callbacks.onMoveKeyframe?.(
+ row.key!,
+ { percentage: 50, propertyGroup: "position", tweenPercentage: 50, animationId: anim.id },
+ pct,
+ );
+ });
+ expect(mocks.actions.handleGsapMoveKeyframe).toHaveBeenCalledWith(
+ anim.id,
+ 50,
+ pct,
+ selectionForElement(row),
+ );
+ expect(mocks.actions.handleGsapResizeKeyframedTween).not.toHaveBeenCalled();
+ view.unmount();
+ });
+});
+
beforeEach(() => {
vi.clearAllMocks();
mocks.animations = [flatAnimation];
diff --git a/packages/studio/src/hooks/gsapShared.test.ts b/packages/studio/src/hooks/gsapShared.test.ts
index 9df0b2f65c..b2180889fc 100644
--- a/packages/studio/src/hooks/gsapShared.test.ts
+++ b/packages/studio/src/hooks/gsapShared.test.ts
@@ -195,7 +195,7 @@ describe("resolveClipTimingBasis", () => {
it("rebases an expanded sub-comp child by its host mount", () => {
// Expanded children carry host-ABSOLUTE display starts; the tweens they own are
// still composition-local, so the basis is the child's local start.
- const pill = { id: "pill", domId: "pill", start: 8, duration: 4, expandedParentStart: 6 };
+ const pill = { id: "pill", domId: "pill", start: 8, duration: 4, parentCompositionStart: 6 };
expect(resolveClipTimingBasis("pill", "scene.html", [pill], [])).toEqual({
elStart: 2,
elDuration: 4,
diff --git a/packages/studio/src/hooks/gsapShared.ts b/packages/studio/src/hooks/gsapShared.ts
index a0ce6317c6..34a7ec5859 100644
--- a/packages/studio/src/hooks/gsapShared.ts
+++ b/packages/studio/src/hooks/gsapShared.ts
@@ -10,6 +10,7 @@ import {
resolveTweenStart,
resolveTweenDuration,
} from "../utils/globalTimeCompiler";
+import { toCompositionTime } from "../player/store/timelineElement";
// ── Types ─────────────────────────────────────────────────────────────────────
@@ -165,14 +166,16 @@ export function resolveSelectorElementIds(
}
/**
- * The clip start in the frame the element's OWN tweens are measured in. An
- * expanded sub-composition child sits on the master timeline at a host-absolute
- * `start`, but its tweens are parsed from its own source file and are local to
- * it, so the two must be brought into one frame before any clip-% math — or
- * every keyframe rebases to a percentage far outside the clip.
+ * The clip start in the frame the element's OWN tweens are measured in. A nested
+ * row sits on the master timeline at a master `start`, but its tweens are local
+ * to its composition, so the two must be brought into one frame before any clip-%
+ * math — or every keyframe rebases to a percentage far outside the clip.
*/
-export function clipTimingStart(element: { start: number; expandedParentStart?: number }): number {
- return element.start - (element.expandedParentStart ?? 0);
+export function clipTimingStart(element: {
+ start: number;
+ parentCompositionStart?: number;
+}): number {
+ return toCompositionTime(element, element.start);
}
export function selectorFromSelection(selection: DomEditSelection): string | null {
@@ -476,8 +479,8 @@ export function toAbsoluteTime(tweenPos: number, tweenDur: number, percentage: n
* timeline element's start is main-timeline absolute, so passing the raw element
* start subtracted two different frames from each other: a host mounted at 1.5s
* cached its 0s tween at -12%, and a clip-relative percentage can never be
- * negative. The composition's mount is `expandedParentStart` for an expanded
- * child, the parent composition clip's start otherwise, and 0 for a
+ * negative. The composition's mount is the row's `parentCompositionStart` when
+ * set, the parent composition clip's start otherwise, and 0 for a
* root-composition element, whose start already IS the tween frame.
*/
export function resolveClipTimingBasis(
@@ -489,7 +492,7 @@ export function resolveClipTimingBasis(
id: string;
start: number;
duration: number;
- expandedParentStart?: number;
+ parentCompositionStart?: number;
parentCompositionId?: string | null;
}>,
domClipChildren: ReadonlyArray<{ id: string; hostId: string }>,
@@ -502,8 +505,9 @@ export function resolveClipTimingBasis(
const parent = parentId
? elements.find((el) => el.domId === parentId || el.id === parentId)
: undefined;
- const mount = direct.expandedParentStart ?? parent?.start;
- if (mount !== undefined) return { elStart: direct.start - mount, elDuration: direct.duration };
+ if (direct.parentCompositionStart !== undefined)
+ return { elStart: clipTimingStart(direct), elDuration: direct.duration };
+ if (parent) return { elStart: direct.start - parent.start, elDuration: direct.duration };
// No parent composition named, so this IS a main-timeline clip and its own
// start is already the basis.
if (!parentId) return { elStart: direct.start, elDuration: direct.duration };
diff --git a/packages/studio/src/hooks/timelineEditingHelpers.ts b/packages/studio/src/hooks/timelineEditingHelpers.ts
index 58091e552a..b563f0f663 100644
--- a/packages/studio/src/hooks/timelineEditingHelpers.ts
+++ b/packages/studio/src/hooks/timelineEditingHelpers.ts
@@ -1,4 +1,5 @@
import { type TimelineElement, usePlayerStore } from "../player/store/playerStore";
+import { toAuthoredStart } from "../player/store/timelineElement";
import {
applyPatchByTarget,
findTagByTarget,
@@ -274,7 +275,7 @@ export function buildTimelineResizeTimingPatch(
let patched = applyPatchByTarget(original, target, {
type: "attribute",
property: "start",
- value: formatTimelineAttributeNumber(updates.start),
+ value: formatTimelineAttributeNumber(toAuthoredStart(element, updates.start)),
});
patched = applyPatchByTarget(patched, target, {
type: "attribute",
diff --git a/packages/studio/src/hooks/useClipboard.source.test.ts b/packages/studio/src/hooks/useClipboard.source.test.ts
index da22bd1d1b..88e97342e7 100644
--- a/packages/studio/src/hooks/useClipboard.source.test.ts
+++ b/packages/studio/src/hooks/useClipboard.source.test.ts
@@ -336,6 +336,64 @@ describe("copy order", () => {
});
});
+describe("duplicate of a clip inside a sub-composition", () => {
+ it("writes the copy at local time right after the original", async () => {
+ // Host at 2 s, so the clip's local 1-3 s shows as a 3-5 s master row.
+ const sub: TimelineElement = {
+ id: SUB_HF_ID,
+ hfId: SUB_HF_ID,
+ tag: "h2",
+ start: 3,
+ duration: 2,
+ track: 0,
+ authoredTrack: 0,
+ sourceFile: "compositions/sub.html",
+ parentCompositionStart: 2,
+ };
+ usePlayerStore.setState({
+ elements: [TITLE, sub],
+ selectedElementId: sub.id,
+ selectedElementIds: new Set([sub.id]),
+ });
+ const { clipboard, writes } = mountClipboard(null, SUB, (host) =>
+ host.setAttribute("data-start", "2"),
+ );
+ await clipboard().handleDuplicate();
+ const starts = [...(writes[0] ?? "").matchAll(/<h2[^>]*data-start="([^"]+)"/g)].map(
+ (m) => m[1],
+ );
+ expect(starts.sort()).toEqual(["1", "3"]);
+ });
+
+ it("moves the copy off a lane its own file already fills right after the original", async () => {
+ // Host at 10 s: the clip is local 1-3 (master 11-13); its neighbour is local 3-5,
+ // exactly where the copy lands, so the lane check must compare in local time.
+ const sub: TimelineElement = {
+ id: SUB_HF_ID,
+ hfId: SUB_HF_ID,
+ tag: "h2",
+ start: 11,
+ duration: 2,
+ track: 0,
+ authoredTrack: 0,
+ sourceFile: "compositions/sub.html",
+ parentCompositionStart: 10,
+ };
+ const neighbour: TimelineElement = { ...sub, id: "next", hfId: "next", start: 13 };
+ usePlayerStore.setState({
+ elements: [TITLE, sub, neighbour],
+ selectedElementId: sub.id,
+ selectedElementIds: new Set([sub.id]),
+ });
+ const { clipboard, writes } = mountClipboard(null, SUB, (host) =>
+ host.setAttribute("data-start", "10"),
+ );
+ await clipboard().handleDuplicate();
+ const copy = /<h2[^>]*data-start="3"[^>]*>/.exec(writes[0] ?? "")?.[0] ?? "";
+ expect(copy).toContain('data-track-index="1"');
+ });
+});
+
describe("a copy that fails", () => {
it("leaves the previous copy on the clipboard", async () => {
selectTitle();
diff --git a/packages/studio/src/hooks/useClipboard.ts b/packages/studio/src/hooks/useClipboard.ts
index c647b24a85..02a1d2e1f5 100644
--- a/packages/studio/src/hooks/useClipboard.ts
+++ b/packages/studio/src/hooks/useClipboard.ts
@@ -2,6 +2,7 @@ import { useCallback, useRef } from "react";
import { EXCLUDED_TAGS, mintHfId, walkCompositionDescendants } from "@hyperframes/parsers/hf-ids";
import type { TimelineElement } from "../player";
import { usePlayerStore } from "../player";
+import { toAuthoredStart } from "../player/store/timelineElement";
import type { DomEditSelection } from "../components/editor/domEditing";
import {
type ClipboardPayload,
@@ -416,14 +417,22 @@ export function useClipboard({
if (!pid) return false;
const { elements } = targets;
- const targetPath = elements[0]?.sourceFile || activeCompPath || "index.html";
- const anchorTime = Math.max(...elements.map((el) => el.start + el.duration));
+ const pathOf = (el: TimelineElement) => el.sourceFile || activeCompPath || "index.html";
+ const targetPath = pathOf(elements[0]!);
+ // The copy lands in targetPath's own clock, so anchor and lane check are local to it.
+ const anchorTime = toAuthoredStart(
+ elements[0]!,
+ Math.max(...elements.map((el) => el.start + el.duration)),
+ );
try {
const clips = await readClips(targets);
let ids: string[] = [];
const duplicate = (originalContent: string) => {
- const liveElements = usePlayerStore.getState().elements;
+ const liveElements = usePlayerStore
+ .getState()
+ .elements.filter((el) => pathOf(el) === targetPath)
+ .map((el) => ({ ...el, start: toAuthoredStart(el, el.start) }));
const pasted = pasteTimelineClips(originalContent, clips, anchorTime, liveElements);
ids = pasted.ids;
return extendRootDurationInSource(pasted.content, pasted.requiredEnd);
diff --git a/packages/studio/src/hooks/useRazorSplit.test.ts b/packages/studio/src/hooks/useRazorSplit.test.ts
index 09eca846f4..740a2e27ca 100644
--- a/packages/studio/src/hooks/useRazorSplit.test.ts
+++ b/packages/studio/src/hooks/useRazorSplit.test.ts
@@ -25,7 +25,7 @@ const rootElement: TimelineElement = {
};
// An expanded sub-comp child: `start` is in MASTER coordinates (offset by the
-// host's master start), `sourceFile` is the sub-comp, and `expandedParentStart`
+// host's master start), `sourceFile` is the sub-comp, and `parentCompositionStart`
// is that host master start. Its authored time in the file is start - basis.
const expandedChild: TimelineElement = {
id: "child-clip",
@@ -35,7 +35,7 @@ const expandedChild: TimelineElement = {
track: 1,
domId: "child-clip",
sourceFile: SUBCOMP_FILE,
- expandedParentStart: 2,
+ parentCompositionStart: 2,
};
interface SplitRequest {
@@ -119,13 +119,13 @@ describe("useRazorSplit — sub-comp coordinate rebasing", () => {
expect(harness.splitRequests).toHaveLength(1);
const req = harness.splitRequests[0];
expect(req.path).toBe(SUBCOMP_FILE);
- expect(req.splitTime).toBe(3); // 5 - expandedParentStart(2), NOT 5
+ expect(req.splitTime).toBe(3); // 5 - parentCompositionStart(2), NOT 5
expect(req.elementStart).toBe(0); // 2 - 2, NOT the master start 2
expect(req.elementDuration).toBe(6);
});
it("leaves a root-level clip's coordinates unchanged", async () => {
- // Master split time T = 4; no expandedParentStart, so nothing is rebased.
+ // Master split time T = 4; no parentCompositionStart, so nothing is rebased.
await act(async () => {
await harness.singleRef.current!(rootElement, 4);
});
@@ -154,7 +154,7 @@ describe("useRazorSplit — sub-comp coordinate rebasing", () => {
expect(rootReq.splitTime).toBe(3);
expect(rootReq.elementStart).toBe(0);
- // Expanded child: rebased by its OWN expandedParentStart, not the root's.
+ // Expanded child: rebased by its OWN parentCompositionStart, not the root's.
expect(childReq.splitTime).toBe(1); // 3 - 2
expect(childReq.elementStart).toBe(0); // 2 - 2
});
diff --git a/packages/studio/src/hooks/useTimelineEditing.test.tsx b/packages/studio/src/hooks/useTimelineEditing.test.tsx
index df477e94f9..fc7b07f7c4 100644
--- a/packages/studio/src/hooks/useTimelineEditing.test.tsx
+++ b/packages/studio/src/hooks/useTimelineEditing.test.tsx
@@ -9,6 +9,18 @@ import { usePlayerStore, type TimelineElement } from "../player";
import { jsonResponse, requestUrl } from "./fetchStubTestUtils";
import { useElementLifecycleOps } from "./useElementLifecycleOps";
import { useTimelineEditing } from "./useTimelineEditing";
+import {
+ buildMissingCompositionElements,
+ createTimelineElementFromManifestClip,
+ parseTimelineFromDOM,
+} from "../player/lib/timelineDOM";
+import type { ClipManifestClip, IframeWindow } from "../player/lib/playbackTypes";
+import { computeResizePreview } from "../player/components/timelineClipDragPreview";
+import {
+ buildTimelineGroupResizeMembers,
+ resolveTimelineGroupResizeChanges,
+} from "../player/components/timelineGroupEditing";
+import { createRuntimeStartTimeResolver } from "@hyperframes/core/runtime/start-resolver";
vi.mock("../components/editor/manualEditingAvailability", async (importOriginal) => {
const actual =
@@ -1969,3 +1981,375 @@ describe("useTimelineEditing effect saves report what happened", () => {
unmount();
});
});
+
+// main 0 > intro 2 > logo 3 > badge 1: rows are master time, files are local.
+const NESTED_PREVIEW = `
+ <div data-composition-id="main" data-start="0" data-duration="20">
+ <div id="intro" data-hf-id="hf-intro" data-composition-id="intro" data-start="2" data-duration="10">
+ <div data-composition-id="intro" data-composition-file="compositions/intro.html">
+ <video id="vo" data-start="7" data-duration="2" data-hf-media-start-basis="global"></video>
+ <div id="logo" data-hf-id="hf-logo" data-composition-id="logo" data-start="3" data-duration="5">
+ <div data-composition-id="logo" data-composition-file="compositions/logo.html">
+ <div id="badge" data-hf-id="hf-badge" class="clip" data-start="1" data-duration="2"></div>
+ <div id="star" data-hf-id="hf-star" data-composition-id="star" data-start="1.5" data-duration="2">
+ <div data-composition-id="star" data-composition-file="compositions/star.html"></div>
+ </div>
+ </div>
+ </div>
+ </div>
+ </div>
+ </div>`;
+const NESTED_FILES: Record<string, string> = {
+ "index.html": [
+ `<div data-composition-id="main" data-duration="20">`,
+ ` <div id="intro" data-composition-id="intro" data-composition-src="compositions/intro.html" data-start="2" data-duration="10"></div>`,
+ `</div>`,
+ ].join("\n"),
+ "compositions/intro.html": [
+ `<div data-composition-id="intro" data-duration="10">`,
+ ` <div id="intro-bg" class="clip" data-start="0" data-duration="10"></div>`,
+ ` <video id="vo" data-start="7" data-duration="2" data-hf-media-start-basis="global"></video>`,
+ ` <div id="logo" data-composition-id="logo" data-composition-src="compositions/logo.html" data-start="3" data-duration="5"></div>`,
+ `</div>`,
+ ].join("\n"),
+ "compositions/logo.html": [
+ `<div data-composition-id="logo" data-duration="5">`,
+ ` <div id="logo-bg" class="clip" data-start="0" data-duration="5"></div>`,
+ ` <div id="badge" class="clip" data-start="1" data-duration="2"></div>`,
+ ` <div id="star" data-composition-id="star" data-composition-src="compositions/star.html" data-start="1.5" data-duration="2"></div>`,
+ `</div>`,
+ ].join("\n"),
+};
+
+function setupNestedHarness() {
+ const iframe = document.createElement("iframe");
+ document.body.append(iframe);
+ const doc = iframe.contentDocument!;
+ doc.body.innerHTML = NESTED_PREVIEW;
+ const row = (domId: string) => parseTimelineFromDOM(doc, 20).find((e) => e.domId === domId)!;
+ // The app's path: the runtime manifest's root clips, then the missing-host pass.
+ const manifestRow = (domId: string) => {
+ const intro = { id: "intro", start: 2, duration: 10, track: 0, kind: "composition" };
+ const clip = { ...intro, tagName: "div", compositionId: "intro" } as ClipManifestClip;
+ const hostEl = doc.getElementById("intro");
+ const roots = [createTimelineElementFromManifestClip({ clip, fallbackIndex: 0, doc, hostEl })];
+ const win = iframe.contentWindow as IframeWindow;
+ return buildMissingCompositionElements(doc, win, roots, 20).missing.find(
+ (e) => e.domId === domId,
+ )!;
+ };
+ const playsAt = (domId: string) => {
+ const resolver = createRuntimeStartTimeResolver({
+ includeAuthoredTimingAttrs: true,
+ documentRef: doc,
+ });
+ const el = doc.getElementById(domId)!;
+ return el.tagName === "VIDEO"
+ ? resolver.resolveMediaStartForElement(el)
+ : resolver.resolveStartForElement(el);
+ };
+ const writeProjectFile = vi.fn<(path: string, content: string) => Promise<void>>(async () => {});
+ const written = (path: string, domId: string, attr: string) => {
+ const call = writeProjectFile.mock.calls.find(([p]) => p === path);
+ if (!call) throw new Error(`nothing written to ${path}`);
+ const el = new DOMParser().parseFromString(call[1], "text/html").getElementById(domId);
+ return el?.getAttribute(attr);
+ };
+ const writtenRootDuration = (path: string) => {
+ const call = writeProjectFile.mock.calls.find(([p]) => p === path)!;
+ return new DOMParser()
+ .parseFromString(call[1], "text/html")
+ .querySelector("[data-composition-id]")
+ ?.getAttribute("data-duration");
+ };
+ const fetchMock = stubProjectFetch(NESTED_FILES);
+ const scaleCalls = () =>
+ fetchMock.mock.calls
+ .filter((call) => requestUrl(call[0]).includes("/gsap-mutations/"))
+ .map((call) => JSON.parse(String((call[1] as RequestInit).body)))
+ .filter((body) => body.type === "scale-positions");
+ usePlayerStore.getState().setDuration(20);
+ const hook = renderTimelineEditingHook({
+ timelineElements: parseTimelineFromDOM(doc, 20),
+ iframe,
+ onZIndexCommit: vi.fn().mockResolvedValue(undefined),
+ projectId: "p1",
+ writeProjectFile,
+ recordEdit: vi.fn(async () => {}),
+ });
+ return {
+ doc,
+ row,
+ manifestRow,
+ playsAt,
+ written,
+ writtenRootDuration,
+ writeProjectFile,
+ scaleCalls,
+ ...hook,
+ };
+}
+
+describe("useTimelineEditing: nested rows write composition-local starts", () => {
+ it("round-trips a depth-2 drag: drawn and played at the drop point, written local", async () => {
+ const h = setupNestedHarness();
+ const logo = h.row("logo");
+ expect(logo.start).toBe(5);
+
+ await act(async () => {
+ await h.move(logo, { start: 6, track: logo.track });
+ });
+
+ expect(h.written("compositions/intro.html", "logo", "data-start")).toBe("4");
+ expect(h.doc.getElementById("logo")?.getAttribute("data-start")).toBe("4");
+ expect(h.row("logo").start).toBe(6);
+ expect(h.playsAt("logo")).toBe(6);
+ expect(h.writtenRootDuration("compositions/intro.html")).toBe("10");
+ h.unmount();
+ });
+
+ it("round-trips a depth-3 drag through two enclosing hosts", async () => {
+ const h = setupNestedHarness();
+ const badge = h.row("badge");
+ expect(badge.start).toBe(6);
+
+ await act(async () => {
+ await h.move(badge, { start: 7, track: badge.track });
+ });
+
+ expect(h.written("compositions/logo.html", "badge", "data-start")).toBe("2");
+ expect(h.row("badge").start).toBe(7);
+ expect(h.playsAt("badge")).toBe(7);
+ expect(h.writtenRootDuration("compositions/logo.html")).toBe("5");
+ h.unmount();
+ });
+
+ it("round-trips a legacy root-time video inside a sub-composition, writing master time", async () => {
+ const h = setupNestedHarness();
+ const vo = h.row("vo");
+ expect(vo.start).toBe(7);
+
+ await act(async () => {
+ await h.move(vo, { start: 8, track: vo.track });
+ });
+
+ expect(h.written("compositions/intro.html", "vo", "data-start")).toBe("8");
+ expect(h.row("vo").start).toBe(8);
+ expect(h.playsAt("vo")).toBe(8);
+ h.unmount();
+ });
+
+ it("writes a local start on a head trim and leaves a tail trim's start alone", async () => {
+ const h = setupNestedHarness();
+ await act(async () => {
+ await h.resize(h.row("logo"), { start: 5.5, duration: 4.5, playbackStart: undefined });
+ });
+ expect(h.written("compositions/intro.html", "logo", "data-start")).toBe("3.5");
+ expect(h.written("compositions/intro.html", "logo", "data-duration")).toBe("4.5");
+ expect(h.row("logo")).toMatchObject({ start: 5.5, duration: 4.5 });
+
+ h.writeProjectFile.mockClear();
+ await act(async () => {
+ await h.resize(h.row("logo"), { start: 5.5, duration: 3, playbackStart: undefined });
+ });
+ expect(h.doc.getElementById("logo")?.getAttribute("data-start")).toBe("3.5");
+ expect(h.doc.getElementById("logo")?.getAttribute("data-duration")).toBe("3");
+ h.unmount();
+ });
+
+ it("scales a head-trimmed nested row's tweens over its local window", async () => {
+ const h = setupNestedHarness();
+ await act(async () => {
+ await h.resize(h.row("logo"), { start: 5.5, duration: 4.5, playbackStart: undefined });
+ });
+ expect(h.scaleCalls()).toEqual([
+ expect.objectContaining({ oldStart: 3, oldDuration: 5, newStart: 3.5, newDuration: 4.5 }),
+ ]);
+ h.unmount();
+ });
+
+ it("writes local starts and a local scale window for a nested group resize", async () => {
+ const h = setupNestedHarness();
+ await act(async () => {
+ await h.groupResize([{ element: h.row("logo"), start: 5.5, duration: 4.5 }]);
+ });
+ expect(h.written("compositions/intro.html", "logo", "data-start")).toBe("3.5");
+ expect(h.scaleCalls()).toEqual([
+ expect.objectContaining({ oldStart: 3, oldDuration: 5, newStart: 3.5, newDuration: 4.5 }),
+ ]);
+ h.unmount();
+ });
+
+ it("scales a legacy root-time video's tweens on its host's clock, single and group", async () => {
+ const window = { oldStart: 5, oldDuration: 2, newStart: 5.5, newDuration: 1.5 };
+ for (const group of [false, true]) {
+ const h = setupNestedHarness();
+ const vo = h.row("vo");
+ await act(async () => {
+ if (group) await h.groupResize([{ element: vo, start: 7.5, duration: 1.5 }]);
+ else await h.resize(vo, { start: 7.5, duration: 1.5, playbackStart: undefined });
+ });
+ expect(h.scaleCalls()).toEqual([expect.objectContaining(window)]);
+ h.unmount();
+ vi.unstubAllGlobals();
+ }
+ });
+
+ it("stops a head trim past the host's start at the host's start, end held", async () => {
+ const h = setupNestedHarness();
+ const logo = h.manifestRow("logo");
+ expect(logo).toMatchObject({ start: 5, duration: 5, parentCompositionStart: 2 });
+ const pps = 100;
+ const preview = computeResizePreview(
+ {
+ element: logo,
+ edge: "start",
+ originClientX: 0,
+ previewStart: 5,
+ previewDuration: 5,
+ started: true,
+ pointerId: 1,
+ },
+ -4 * pps,
+ { scroll: null, pps, buildSnapTargets: () => [] },
+ );
+ expect(preview).toMatchObject({ previewStart: 2, previewDuration: 8 });
+
+ await act(async () => {
+ await h.resize(logo, {
+ start: preview.previewStart,
+ duration: preview.previewDuration,
+ playbackStart: undefined,
+ });
+ });
+ expect(h.written("compositions/intro.html", "logo", "data-start")).toBe("0");
+ expect(h.written("compositions/intro.html", "logo", "data-duration")).toBe("8");
+ expect(h.row("logo")).toMatchObject({ start: 2, duration: 8 });
+ expect(h.scaleCalls()).toEqual([
+ expect.objectContaining({ oldStart: 3, oldDuration: 5, newStart: 0, newDuration: 8 }),
+ ]);
+ h.unmount();
+ });
+
+ it("stops a group head trim at the nested member's host start", async () => {
+ const h = setupNestedHarness();
+ const logo = h.manifestRow("logo");
+ const outro: TimelineElement = {
+ ...logo,
+ id: "outro",
+ key: "outro",
+ domId: undefined,
+ start: 12,
+ parentCompositionStart: 0,
+ };
+ const members = buildTimelineGroupResizeMembers(
+ [logo, outro],
+ new Set([logo.key ?? logo.id, "outro"]),
+ logo.key ?? logo.id,
+ "start",
+ )!;
+ const changes = resolveTimelineGroupResizeChanges(members, "start", -4);
+ const logoChange = changes.find((c) => c.key === (logo.key ?? logo.id))!;
+ expect(logoChange).toMatchObject({ start: 2, duration: 8 });
+
+ await act(async () => {
+ await h.groupResize([
+ { element: logo, start: logoChange.start, duration: logoChange.duration },
+ ]);
+ });
+ expect(h.written("compositions/intro.html", "logo", "data-start")).toBe("0");
+ expect(h.written("compositions/intro.html", "logo", "data-duration")).toBe("8");
+ expect(h.scaleCalls()).toEqual([
+ expect.objectContaining({ oldStart: 3, oldDuration: 5, newStart: 0, newDuration: 8 }),
+ ]);
+ h.unmount();
+ });
+
+ it("round-trips a depth-3 host from the manifest path", async () => {
+ const h = setupNestedHarness();
+ const star = h.manifestRow("star");
+ expect(star).toMatchObject({ start: 6.5, parentCompositionStart: 5 });
+
+ await act(async () => {
+ await h.move(star, { start: 7.5, track: star.track });
+ });
+
+ expect(h.written("compositions/logo.html", "star", "data-start")).toBe("2.5");
+ expect(h.playsAt("star")).toBe(7.5);
+ expect(h.manifestRow("star").start).toBe(7.5);
+ h.unmount();
+ });
+
+ it("clamps a nested row dropped before its host's start to the host's start", async () => {
+ const h = setupNestedHarness();
+ const logo = h.row("logo");
+ await act(async () => {
+ await h.move(logo, { start: 1, track: logo.track });
+ });
+ expect(h.written("compositions/intro.html", "logo", "data-start")).toBe("0");
+ expect(h.row("logo").start).toBe(2);
+ h.unmount();
+ });
+
+ it("writes local starts for nested rows in a group move", async () => {
+ const h = setupNestedHarness();
+ await act(async () => {
+ await h.groupMove([{ element: h.row("logo"), start: 6 }]);
+ });
+ expect(h.written("compositions/intro.html", "logo", "data-start")).toBe("4");
+ expect(h.row("logo").start).toBe(6);
+ h.unmount();
+ });
+
+ it("leaves a top-level row's start as written", async () => {
+ const h = setupNestedHarness();
+ const intro = h.row("intro");
+ expect(intro.parentCompositionStart).toBe(0);
+
+ await act(async () => {
+ await h.move(intro, { start: 3, track: intro.track });
+ });
+
+ expect(h.written("index.html", "intro", "data-start")).toBe("3");
+ expect(h.row("intro").start).toBe(3);
+ h.unmount();
+ });
+
+ it("hands the SDK a local start for a nested clip in the open file", async () => {
+ const source = [
+ `<div data-hf-id="hf-main" data-hf-root data-composition-id="main" data-duration="20">`,
+ ` <div id="intro" data-hf-id="hf-intro" data-composition-id="intro" data-start="2" data-duration="10">`,
+ ` <div id="clip" data-hf-id="hf-clip" data-start="1" data-duration="2"></div>`,
+ ` </div>`,
+ `</div>`,
+ ].join("\n");
+ const iframe = document.createElement("iframe");
+ document.body.append(iframe);
+ iframe.contentDocument!.body.innerHTML = source;
+ const clip = parseTimelineFromDOM(iframe.contentDocument!, 20).find((e) => e.domId === "clip")!;
+ expect(clip.start).toBe(3);
+ const sdkSession = await openComposition(source);
+ const writeProjectFile = vi.fn<(...args: unknown[]) => Promise<void>>(async () => {});
+ stubProjectFetch(source);
+ usePlayerStore.getState().setDuration(20);
+ const hook = renderTimelineEditingHook({
+ timelineElements: [clip],
+ iframe,
+ onZIndexCommit: vi.fn().mockResolvedValue(undefined),
+ projectId: "p1",
+ writeProjectFile,
+ recordEdit: vi.fn(async () => {}),
+ sdkSession,
+ publishSdkSession: vi.fn<TimelinePublishSdkSession>(() => "published"),
+ });
+
+ await act(async () => {
+ await hook.move(clip, { start: 4, track: clip.track });
+ });
+
+ expect(writeProjectFile.mock.calls[0]?.[1]).toContain(
+ 'id="clip" data-hf-id="hf-clip" data-start="2"',
+ );
+ hook.unmount();
+ });
+});
diff --git a/packages/studio/src/hooks/useTimelineEditing.ts b/packages/studio/src/hooks/useTimelineEditing.ts
index a92e6d219c..3f7d11eac7 100644
--- a/packages/studio/src/hooks/useTimelineEditing.ts
+++ b/packages/studio/src/hooks/useTimelineEditing.ts
@@ -1,7 +1,7 @@
// fallow-ignore-file complexity
import { useCallback, useRef } from "react";
-import type { TimelineElement } from "../player";
-import { usePlayerStore } from "../player";
+import { usePlayerStore, type TimelineElement } from "../player";
+import { toAuthoredStart, toCompositionTime } from "../player/store/timelineElement";
import { useRazorSplit } from "./useRazorSplit";
import { selectSplittableElements } from "../utils/timelineElementSplit";
import { useTimelineAssetDropOps } from "./useTimelineAssetDropOps";
@@ -187,12 +187,11 @@ export function useTimelineEditing({
// other move — early-returning on !startChanged alone silently dropped
// the file write, so the lane snapped back on reload.
const trackChanged = updates.track !== element.track;
-
+ const authoredStart = toAuthoredStart(element, updates.start);
if (startChanged || trackChanged) {
const liveAttrs: Array<[string, string]> = [];
- if (startChanged) {
- liveAttrs.push(["data-start", formatTimelineAttributeNumber(updates.start)]);
- }
+ if (startChanged)
+ liveAttrs.push(["data-start", formatTimelineAttributeNumber(authoredStart)]);
if (trackChanged) {
liveAttrs.push(["data-track-index", formatTimelineAttributeNumber(updates.track)]);
}
@@ -224,7 +223,7 @@ export function useTimelineEditing({
return buildTimelineMoveTimingPatch(
original,
target,
- updates.start,
+ authoredStart,
element.duration,
track,
);
@@ -258,7 +257,7 @@ export function useTimelineEditing({
return sdkTimingPersist(
element.hfId,
targetPath,
- { start: updates.start },
+ { start: authoredStart },
sdkSession,
{
editHistory: { recordEdit },
@@ -309,8 +308,9 @@ export function useTimelineEditing({
element: TimelineElement,
updates: Pick<TimelineElement, "start" | "duration" | "playbackStart">,
) => {
+ const authoredStart = toAuthoredStart(element, updates.start);
const liveAttrs: Array<[string, string]> = [
- ["data-start", formatTimelineAttributeNumber(updates.start)],
+ ["data-start", formatTimelineAttributeNumber(authoredStart)],
["data-duration", formatTimelineAttributeNumber(updates.duration)],
];
if (updates.playbackStart != null) {
@@ -350,8 +350,8 @@ export function useTimelineEditing({
writeProjectFile,
edit: {
kind: "scale",
- from: { start: element.start, duration: element.duration },
- to: { start: updates.start, duration: updates.duration },
+ from: { start: toCompositionTime(element, element.start), duration: element.duration },
+ to: { start: toCompositionTime(element, updates.start), duration: updates.duration },
},
}).finally(() => invalidateGsapCache?.());
const resizeFallback = () =>
@@ -363,7 +363,7 @@ export function useTimelineEditing({
? sdkTimingPersist(
element.hfId,
targetPath,
- { start: updates.start, duration: updates.duration },
+ { start: authoredStart, duration: updates.duration },
sdkSession,
{
editHistory: { recordEdit },
diff --git a/packages/studio/src/hooks/useTimelineGroupEditing.ts b/packages/studio/src/hooks/useTimelineGroupEditing.ts
index b05ccfcda9..4963cee7b2 100644
--- a/packages/studio/src/hooks/useTimelineGroupEditing.ts
+++ b/packages/studio/src/hooks/useTimelineGroupEditing.ts
@@ -3,6 +3,7 @@
import { useCallback, type MutableRefObject, type RefObject } from "react";
import type { Composition } from "@hyperframes/sdk";
import type { TimelineElement } from "../player";
+import { toAuthoredStart, toCompositionTime } from "../player/store/timelineElement";
import {
cutoverCommittedOrThrow,
sdkTimingBatchPersist,
@@ -244,7 +245,10 @@ export function useTimelineGroupEditing({
if (changes.length === 0) return Promise.resolve();
for (const change of changes) {
const attrs: Array<[string, string]> = [
- ["data-start", formatTimelineAttributeNumber(change.start)],
+ [
+ "data-start",
+ formatTimelineAttributeNumber(toAuthoredStart(change.element, change.start)),
+ ],
];
if (change.track != null) {
attrs.push(["data-track-index", formatTimelineAttributeNumber(change.track)]);
@@ -287,7 +291,9 @@ export function useTimelineGroupEditing({
await options?.beforeTiming;
const handledBySdk = await trySdkBatchPersist({
changes,
- sdkChanges: toSdkTimingChanges(changes, (change) => ({ start: change.start })),
+ sdkChanges: toSdkTimingChanges(changes, (change) => ({
+ start: toAuthoredStart(change.element, change.start),
+ })),
eligible: changes.every((change) => change.track == null),
needsExtension,
label,
@@ -304,7 +310,7 @@ export function useTimelineGroupEditing({
buildTimelineMoveTimingPatch(
original,
target,
- change.start,
+ toAuthoredStart(change.element, change.start),
change.element.duration,
change.track,
),
@@ -375,7 +381,10 @@ export function useTimelineGroupEditing({
if (changes.length === 0) return Promise.resolve();
for (const change of changes) {
const liveAttrs: Array<[string, string]> = [
- ["data-start", formatTimelineAttributeNumber(change.start)],
+ [
+ "data-start",
+ formatTimelineAttributeNumber(toAuthoredStart(change.element, change.start)),
+ ],
["data-duration", formatTimelineAttributeNumber(change.duration)],
];
if (change.playbackStart != null) {
@@ -402,7 +411,7 @@ export function useTimelineGroupEditing({
const handledBySdk = await trySdkBatchPersist({
changes,
sdkChanges: toSdkTimingChanges(changes, (change) => ({
- start: change.start,
+ start: toAuthoredStart(change.element, change.start),
duration: change.duration,
})),
eligible: changes.every((change) => !resizeHasPlaybackStartAdjustment(change)),
@@ -453,9 +462,9 @@ export function useTimelineGroupEditing({
projectId,
changePath,
domId,
- change.element.start,
+ toCompositionTime(change.element, change.element.start),
change.element.duration,
- change.start,
+ toCompositionTime(change.element, change.start),
change.duration,
);
},
diff --git a/packages/studio/src/player/components/TimelinePropertyLanes.test.tsx b/packages/studio/src/player/components/TimelinePropertyLanes.test.tsx
index 9f44822e86..94a1f6b632 100644
--- a/packages/studio/src/player/components/TimelinePropertyLanes.test.tsx
+++ b/packages/studio/src/player/components/TimelinePropertyLanes.test.tsx
@@ -189,7 +189,7 @@ describe("TimelinePropertyLanes", () => {
// host-absolute start while its tweens are parsed from its own file and are
// local to it. clipTimingStart is what brings the two into one frame.
it("keeps an expanded sub-comp child's lane percentages inside the clip", () => {
- const child = { start: 16.5, duration: 2, expandedParentStart: 16 };
+ const child = { start: 16.5, duration: 2, parentCompositionStart: 16 };
const local = animation("pill-tween", "position", [
{ percentage: 0, properties: { x: 0 } },
{ percentage: 100, properties: { x: 100 } },
diff --git a/packages/studio/src/player/components/TimelineTrackHeader.test.tsx b/packages/studio/src/player/components/TimelineTrackHeader.test.tsx
index e2561a9798..8246bf8785 100644
--- a/packages/studio/src/player/components/TimelineTrackHeader.test.tsx
+++ b/packages/studio/src/player/components/TimelineTrackHeader.test.tsx
@@ -209,7 +209,7 @@ describe("TimelineTrackHeader", () => {
start: 16.5,
duration: 2,
track: 0,
- expandedParentStart: 16,
+ parentCompositionStart: 16,
sourceFile: "scene.html",
};
const local: GsapAnimation = {
diff --git a/packages/studio/src/player/components/timelineClipDragCommit.test.ts b/packages/studio/src/player/components/timelineClipDragCommit.test.ts
index 666a729722..80cbea0524 100644
--- a/packages/studio/src/player/components/timelineClipDragCommit.test.ts
+++ b/packages/studio/src/player/components/timelineClipDragCommit.test.ts
@@ -315,7 +315,6 @@ describe("commitDraggedClipMove", () => {
const child = {
...el("scene.html#title", 0.25, 12, 2),
sourceFile: "scene.html",
- expandedParentStart: 10,
expandedHostKey: "host",
};
const { updateElement, onMoveElement, onMoveElements } = runClipMove(
@@ -338,7 +337,6 @@ describe("commitDraggedClipMove", () => {
const child = {
...el("scene.html#title", 0.25, 12, 2),
sourceFile: "scene.html",
- expandedParentStart: 10,
expandedHostKey: "host",
};
const { onMoveElement, onMoveElements } = runClipMove(
@@ -360,7 +358,6 @@ describe("commitDraggedClipMove", () => {
const child = {
...el("scene.html#title", 0.25, 12, 2),
sourceFile: "scene.html",
- expandedParentStart: 10,
expandedHostKey: "host",
};
const { onMoveElement, onMoveElements } = runClipMove(
@@ -382,7 +379,6 @@ describe("commitDraggedClipMove", () => {
const child = {
...el("scene.html#title", 0.25, 12, 2),
sourceFile: "scene.html",
- expandedParentStart: 10,
expandedHostKey: "host",
};
const { onMoveElement, onMoveElements } = runClipMove(
@@ -406,7 +402,6 @@ describe("commitDraggedClipMove", () => {
const child = {
...el("scene.html#title", 0.25, 12, 2),
sourceFile: "scene.html",
- expandedParentStart: 10,
expandedHostKey: "host",
};
const { onMoveElement, onMoveElements } = runClipMove(
@@ -1279,7 +1274,6 @@ describe("commitDraggedClipMove", () => {
const child: TimelineElement = {
...el("child", 2, childStart, 4),
expandedHostKey: "host",
- expandedParentStart: hostStart,
};
const { onMoveElements } = runClipMove(
drag(child, { previewStart: childStart, previewTrack: 0 }),
@@ -1399,12 +1393,10 @@ describe("commitZMirrorLaneMove", () => {
const child1 = {
...el("child-1", 0.25, 0, 5),
sourceFile: "scene.html",
- expandedParentStart: 0,
};
const child2 = {
...el("child-2", 0.5, 0, 5),
sourceFile: "scene.html",
- expandedParentStart: 0,
};
const b = { ...el("b", 1, 0, 5), sourceFile: "index.html" };
const t = { ...el("t", 2, 0, 5), sourceFile: "index.html" };
@@ -1516,6 +1508,24 @@ describe("commitZMirrorLaneMove", () => {
});
});
+describe("persistMoveEdits: a nested row dropped before its host", () => {
+ it("lands at the host's start in the store and in the persist", async () => {
+ const logo = { ...el("logo", 0, 5, 5, "div"), parentCompositionStart: 2 };
+ const updateElement = vi.fn();
+ const onMoveElements = vi.fn(async (_edits: TimelineMoveEdit[]) => {});
+ await persistMoveEdits([{ element: logo, updates: { start: 1, track: 0 } }], {
+ elements: [logo],
+ trackOrder: [0],
+ updateElement,
+ onMoveElements,
+ });
+ expect(updateElement).toHaveBeenCalledWith("logo", { start: 2, track: 0 });
+ expect(onMoveElements.mock.calls[0]?.[0]).toEqual([
+ { element: logo, updates: { start: 2, track: 0 } },
+ ]);
+ });
+});
+
describe("persistMoveEdits convergence", () => {
it("reasserts a saved lane after a stale runtime sync", async () => {
const clip = { ...el("headline", 2, 0.5, 4.9), authoredTrack: 2 };
diff --git a/packages/studio/src/player/components/timelineClipDragCommit.ts b/packages/studio/src/player/components/timelineClipDragCommit.ts
index e8bcc409f3..385834891b 100644
--- a/packages/studio/src/player/components/timelineClipDragCommit.ts
+++ b/packages/studio/src/player/components/timelineClipDragCommit.ts
@@ -1,4 +1,5 @@
import type { TimelineElement } from "../store/playerStore";
+import { clampToHostStart } from "../store/timelineElement";
import type { DraggedClipState } from "./useTimelineClipDrag";
// Type-only: erased at runtime, so the timelineZMirror → timelineClipDragCommit
// value-import edge stays acyclic.
@@ -107,6 +108,10 @@ export function persistMoveEdits(
coalesceMs?: number,
): Promise<boolean> {
if (edits.length === 0) return Promise.resolve(true);
+ edits = edits.map((e) => {
+ const start = clampToHostStart(e.element, e.updates.start);
+ return start === e.updates.start ? e : { ...e, updates: { ...e.updates, start } };
+ });
const { updateElement, onMoveElement, onMoveElements } = deps;
if (!onMoveElements) {
console.warn(
diff --git a/packages/studio/src/player/components/timelineClipDragPreview.test.ts b/packages/studio/src/player/components/timelineClipDragPreview.test.ts
index 6285510c3a..676add9245 100644
--- a/packages/studio/src/player/components/timelineClipDragPreview.test.ts
+++ b/packages/studio/src/player/components/timelineClipDragPreview.test.ts
@@ -7,7 +7,7 @@ import {
type DragPreviewContext,
} from "./timelineClipDragPreview";
import type { DraggedClipState } from "./timelineClipDragTypes";
-import { commitDraggedClipMove } from "./timelineClipDragCommit";
+import { commitDraggedClipMove, persistMoveEdits } from "./timelineClipDragCommit";
import { LANE_H, RULER_H, TRACKS_TOP_PAD, TRACK_H } from "./timelineLayout";
// ─────────────────────────────────────────────────────────────────────────────
@@ -456,7 +456,6 @@ describe("computeDragPreview — the ghost start is the committed start", () =>
const child: TimelineElement = {
...clip("child", 2, childStart, 4, 5),
expandedHostKey: "host",
- expandedParentStart: hostStart,
};
const elements = [host, child];
const keys = new Set(["host", "child"]);
@@ -467,3 +466,72 @@ describe("computeDragPreview — the ghost start is the committed start", () =>
}
});
});
+
+describe("a nested clip's drop stops at its host's start in the preview", () => {
+ // Host at 2 s: the clip may not start before 2 unless it was authored there.
+ const logo: TimelineElement = { ...clip("logo", 0, 5, 5, 0, "div"), parentCompositionStart: 2 };
+ const saved = async (element: TimelineElement, start: number) => {
+ const updateElement = vi.fn();
+ await persistMoveEdits([{ element, updates: { start, track: element.track } }], {
+ elements: [element],
+ trackOrder: [0, 1, 2],
+ updateElement,
+ onMoveElements: vi.fn(async () => {}),
+ });
+ return updateElement.mock.calls[0]?.[1]?.start;
+ };
+
+ it("holds a drop that snapping would put before the host, and saves the same start", async () => {
+ const { drag, clientX, clientY } = horizontalDrag(logo, 0.5, -3.9);
+ const next = computeDragPreview(drag, clientX, clientY, {
+ ...ctx(undefined, [logo]),
+ buildSnapTargets: () => [{ time: 1.9, type: "beat" }],
+ });
+ expect(next.previewStart).toBe(2);
+ expect(next.snapTime).toBeNull();
+ expect(await saved(logo, next.previewStart)).toBe(2);
+ });
+
+ it("snaps from the floor, so an edge just past the host's start still catches", () => {
+ const { drag, clientX, clientY } = horizontalDrag(logo, 0.5, -3.9);
+ const next = computeDragPreview(drag, clientX, clientY, {
+ ...ctx(undefined, [logo]),
+ buildSnapTargets: () => [{ time: 2.1, type: "beat" }],
+ });
+ expect(next).toMatchObject({ previewStart: 2.1, snapTime: 2.1 });
+ });
+
+ it("keeps a mixed group's spacing when the nested member meets its floor", () => {
+ // Grab the top-level member: only the group clamp knows the nested one's floor.
+ const outro = clip("outro", 1, 8, 2, 0, "div");
+ const { drag, clientX, clientY } = horizontalDrag(outro, 1.5, -7);
+ const next = computeDragPreview(drag, clientX, clientY, {
+ ...ctx(undefined, [logo, outro]),
+ selectedKeys: new Set(["logo", "outro"]),
+ });
+ expect(next.previewStart).toBe(5);
+ });
+
+ it("leaves a clip authored before its host's start in place when grabbed", async () => {
+ const early: TimelineElement = { ...logo, id: "early", key: "early", domId: "early", start: 1 };
+ const { drag, clientX, clientY } = horizontalDrag(early, 0.5, 0);
+ expect(computeDragPreview(drag, clientX, clientY, ctx(undefined, [early])).previewStart).toBe(
+ 1,
+ );
+ const trim = computeResizePreview(
+ {
+ element: early,
+ edge: "start",
+ originClientX: 0,
+ previewStart: 1,
+ previewDuration: 5,
+ started: true,
+ pointerId: 0,
+ },
+ 0,
+ { scroll: fakeScroll(), pps: PPS, buildSnapTargets: () => [] },
+ );
+ expect(trim).toMatchObject({ previewStart: 1, previewDuration: 5 });
+ expect(await saved(early, 1)).toBe(1);
+ });
+});
diff --git a/packages/studio/src/player/components/timelineClipDragPreview.ts b/packages/studio/src/player/components/timelineClipDragPreview.ts
index 61a7dd85fd..c3a52999a0 100644
--- a/packages/studio/src/player/components/timelineClipDragPreview.ts
+++ b/packages/studio/src/player/components/timelineClipDragPreview.ts
@@ -5,6 +5,7 @@ import {
resolveTimelineMinDuration,
} from "./timelineGroupEditing";
import type { TimelineElement } from "../store/playerStore";
+import { clampToHostStart } from "../store/timelineElement";
import {
getTimelineInsertBoundaryBand,
getTimelineRowFromY,
@@ -80,10 +81,10 @@ function resolveDragMaxStart(scroll: HTMLDivElement | null, pps: number, duratio
/**
* Rigid group move: when the grabbed clip is part of a multi-selection, the
* WHOLE formation shifts by its delta on commit (see timelineClipDragCommit).
- * Clamp that delta here — against every selected member's start — so the
- * grabbed clip can't out-run the group: it STOPS the instant any member would
- * cross 0, exactly as it lands on commit. Lane changes still apply to the
- * grabbed clip only, so only the start (x) is constrained.
+ * Clamp that delta here, and a lone clip's as a group of one, so the grabbed
+ * clip STOPS the instant any member would cross its floor (clampToHostStart),
+ * exactly as it lands on commit. Lane changes still apply to the grabbed clip
+ * only, so only the start (x) is constrained.
*/
function resolveGroupClampedStart(
snapStart: number,
@@ -92,10 +93,10 @@ function resolveGroupClampedStart(
elements: TimelineElement[],
selectedKeys: ReadonlySet<string>,
): number {
- if (selectedKeys.size <= 1 || !selectedKeys.has(dragKey)) return snapStart;
- const memberStarts = elements.filter((e) => selectedKeys.has(e.key ?? e.id)).map((e) => e.start);
- const clampedDelta = clampGroupMoveDelta(snapStart - element.start, memberStarts);
- return element.start + clampedDelta;
+ const inGroup = selectedKeys.size > 1 && selectedKeys.has(dragKey);
+ const members = inGroup ? elements.filter((e) => selectedKeys.has(e.key ?? e.id)) : [element];
+ const floors = members.map((e) => ({ start: e.start, minStart: clampToHostStart(e, 0) }));
+ return element.start + clampGroupMoveDelta(snapStart - element.start, floors);
}
/**
@@ -173,6 +174,7 @@ export function computeDragPreview(
originScrollLeft: drag.originScrollLeft,
currentScrollLeft: scroll?.scrollLeft ?? drag.originScrollLeft,
pixelsPerSecond: pps,
+ minStart: clampToHostStart(drag.element, 0),
maxStart: dragMaxStart,
trackOrder,
},
@@ -226,8 +228,8 @@ export function computeDragPreview(
// deliberate vertical lane change from a horizontal drag merely bumped sideways.
desiredTrack: nextMove.track,
insertRow,
- snapTime: snap.snapTime,
- snapType: snap.snapType,
+ snapTime: previewStart === snap.start ? snap.snapTime : null,
+ snapType: previewStart === snap.start ? snap.snapType : null,
};
}
@@ -293,7 +295,7 @@ export function computeResizePreview(
duration: resize.element.duration,
originClientX: resize.originClientX,
pixelsPerSecond: pps,
- minStart: 0,
+ minStart: clampToHostStart(resize.element, 0),
maxEnd,
playbackStart:
resize.edge === "start" && canSeedPlaybackStart
@@ -336,7 +338,8 @@ export function computeResizePreview(
const { time: snapped, target } = snapTimelineTime(nextResize.start, trimTargets, snapSecs);
const clip = { ...nextResize, playbackRate: resize.element.playbackRate };
const delta = snapped - nextResize.start;
- const bounds = clipStartTrimDeltaBounds(clip, 0, resolveTimelineMinDuration());
+ const floor = clampToHostStart(resize.element, 0);
+ const bounds = clipStartTrimDeltaBounds(clip, floor, resolveTimelineMinDuration());
if (target && delta >= bounds.minDelta - 1e-6 && delta <= bounds.maxDelta + 1e-6) {
if (snapped !== nextResize.start) nextResize = applyClipStartTrimDelta(clip, delta);
snap = target;
diff --git a/packages/studio/src/player/components/timelineEditing.ts b/packages/studio/src/player/components/timelineEditing.ts
index b46dfca590..c5d471db0c 100644
--- a/packages/studio/src/player/components/timelineEditing.ts
+++ b/packages/studio/src/player/components/timelineEditing.ts
@@ -51,6 +51,7 @@ export interface TimelineMoveInput {
originScrollLeft?: number;
currentScrollLeft?: number;
pixelsPerSecond: number;
+ minStart?: number;
maxStart: number;
trackOrder: number[];
layerOrder?: TimelineLayerId[];
@@ -127,7 +128,7 @@ export function resolveTimelineMove(
const deltaTrack = Math.round(trackDeltaRaw);
const nextStart = clamp(
roundToCentiseconds(input.start + deltaTime),
- 0,
+ input.minStart ?? 0,
Math.max(0, input.maxStart),
);
diff --git a/packages/studio/src/player/components/timelineGroupEditing.ts b/packages/studio/src/player/components/timelineGroupEditing.ts
index 74a784e239..d303d5fd25 100644
--- a/packages/studio/src/player/components/timelineGroupEditing.ts
+++ b/packages/studio/src/player/components/timelineGroupEditing.ts
@@ -1,6 +1,7 @@
import { clampPlaybackRate } from "@hyperframes/parsers/media-duration";
import { roundToCenti } from "../../utils/rounding";
import type { TimelineElement } from "../store/playerStore";
+import { clampToHostStart } from "../store/timelineElement";
import { getTimelineEditCapabilities } from "./timelineEditCapabilities";
const DEFAULT_TIMELINE_MIN_DURATION = 0.1;
@@ -88,6 +89,7 @@ export interface TimelineGroupTimingMember {
duration: number;
playbackStart?: number;
playbackRate?: number;
+ minStart?: number;
}
export type TimelineGroupResizeEdge = "start" | "end";
@@ -107,7 +109,7 @@ function clampTimelineGroupMoveDelta(
members: readonly TimelineGroupTimingMember[],
): number {
if (members.length === 0) return 0;
- const minDelta = Math.max(...members.map((member) => -member.start));
+ const minDelta = Math.max(...members.map((member) => -(member.start - (member.minStart ?? 0))));
return roundTimelineTime(Math.max(rawDelta, minDelta));
}
@@ -139,7 +141,9 @@ 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 bounds = members.map((member) =>
+ clipStartTrimDeltaBounds(member, member.minStart ?? 0, minDuration),
+ );
const minDelta = ceilTimelineTime(Math.max(...bounds.map((b) => b.minDelta)));
const maxDelta = Math.min(...bounds.map((b) => b.maxDelta));
const delta = roundTimelineTime(clamp(rawDelta, minDelta, maxDelta));
@@ -243,6 +247,7 @@ export function buildTimelineGroupResizeMembers(
? (element.playbackStart ?? 0)
: element.playbackStart,
playbackRate: element.playbackRate,
+ minStart: clampToHostStart(element, 0),
}));
}
diff --git a/packages/studio/src/player/components/timelineMultiDragPreview.test.ts b/packages/studio/src/player/components/timelineMultiDragPreview.test.ts
index 6d7791991e..d76d553962 100644
--- a/packages/studio/src/player/components/timelineMultiDragPreview.test.ts
+++ b/packages/studio/src/player/components/timelineMultiDragPreview.test.ts
@@ -17,6 +17,8 @@ const base = (over: Partial<MultiDragPreviewInput> = {}): MultiDragPreviewInput
...over,
});
+const starts = (...values: number[]) => values.map((start) => ({ start }));
+
describe("isMultiDragActive", () => {
it("is active when a started drag's clip is part of a 2+ selection", () => {
expect(isMultiDragActive(base())).toBe(true);
@@ -94,34 +96,34 @@ describe("multiDragPassengerOffsetPx (rigid: every passenger shares the delta)",
describe("clampGroupMoveDelta (rigid group move)", () => {
it("passes a rightward delta through unchanged (no right wall)", () => {
- expect(clampGroupMoveDelta(3, [2, 5, 9])).toBe(3);
- expect(clampGroupMoveDelta(1000, [0, 4])).toBe(1000);
+ expect(clampGroupMoveDelta(3, starts(2, 5, 9))).toBe(3);
+ expect(clampGroupMoveDelta(1000, starts(0, 4))).toBe(1000);
});
it("passes a leftward delta through when no member would cross 0", () => {
// Leftmost member at 5, moving left by 3 → 2 ≥ 0, so unclamped.
- expect(clampGroupMoveDelta(-3, [5, 8, 12])).toBe(-3);
+ expect(clampGroupMoveDelta(-3, starts(5, 8, 12))).toBe(-3);
});
it("clamps a leftward delta so the leftmost member stops exactly at 0", () => {
// Leftmost at 2 → the furthest left the group can move is -2 (that member → 0).
// A pointer asking for -5 is clamped to -2: the grabbed clip stops with the
// formation instead of out-running it.
- expect(clampGroupMoveDelta(-5, [2, 6, 10])).toBe(-2);
+ expect(clampGroupMoveDelta(-5, starts(2, 6, 10))).toBe(-2);
});
it("is bounded by the MOST-constrained (leftmost) member, not the grabbed one", () => {
// Grabbed clip is at 10; a passenger at 1 is the constraint. Max left = -1.
- expect(clampGroupMoveDelta(-8, [10, 1, 4])).toBe(-1);
+ expect(clampGroupMoveDelta(-8, starts(10, 1, 4))).toBe(-1);
});
it("already-at-0 member forbids any leftward move", () => {
- expect(clampGroupMoveDelta(-4, [0, 3, 7])).toBe(0);
+ expect(clampGroupMoveDelta(-4, starts(0, 3, 7))).toBe(0);
// rightward still allowed
- expect(clampGroupMoveDelta(2, [0, 3, 7])).toBe(2);
+ expect(clampGroupMoveDelta(2, starts(0, 3, 7))).toBe(2);
});
it("returns the raw delta for an empty formation", () => {
- expect(clampGroupMoveDelta(-9, [])).toBe(-9);
+ expect(clampGroupMoveDelta(-9, starts())).toBe(-9);
});
});
diff --git a/packages/studio/src/player/components/timelineMultiDragPreview.ts b/packages/studio/src/player/components/timelineMultiDragPreview.ts
index 6b85466322..43fa740981 100644
--- a/packages/studio/src/player/components/timelineMultiDragPreview.ts
+++ b/packages/studio/src/player/components/timelineMultiDragPreview.ts
@@ -97,10 +97,13 @@ export function multiDragPassengerOffsetPx(
* included). Only the lower bound (start ≥ 0) constrains a move; the timeline has
* no fixed right wall (the composition grows on commit).
*/
-export function clampGroupMoveDelta(rawDelta: number, memberStarts: readonly number[]): number {
- if (memberStarts.length === 0) return rawDelta;
- // Leftmost member sets the floor: delta ≥ -min(start) keeps every start ≥ 0.
- const minStart = Math.min(...memberStarts);
- const minDelta = minStart === 0 ? 0 : -minStart; // avoid -0
+export function clampGroupMoveDelta(
+ rawDelta: number,
+ members: readonly { start: number; minStart?: number }[],
+): number {
+ if (members.length === 0) return rawDelta;
+ // The member nearest its own floor bounds the move: delta ≥ -(start - minStart) for each.
+ const room = Math.min(...members.map((m) => m.start - (m.minStart ?? 0)));
+ const minDelta = room === 0 ? 0 : -room; // avoid -0
return rawDelta < minDelta ? minDelta : rawDelta;
}
diff --git a/packages/studio/src/player/components/timelineZMirror.test.ts b/packages/studio/src/player/components/timelineZMirror.test.ts
index 68fe1d6d60..7f6107a8b3 100644
--- a/packages/studio/src/player/components/timelineZMirror.test.ts
+++ b/packages/studio/src/player/components/timelineZMirror.test.ts
@@ -622,7 +622,7 @@ describe("expanded sub-comp children — lane scoping", () => {
const child = (id: string, track: number, start: number, duration: number) =>
el(id, track, start, duration, {
sourceFile: "scene.html",
- expandedParentStart: 5,
+ expandedHostKey: "host",
});
it("a child mirrors onto a SIBLING's lane and persists the sibling's AUTHORED track", () => {
@@ -630,7 +630,7 @@ describe("expanded sub-comp children — lane scoping", () => {
// file) but sits elsewhere in time → its lane is free over t's span.
const c1 = el("c1", 0.25, 20, 3, {
sourceFile: "scene.html",
- expandedParentStart: 5,
+ expandedHostKey: "host",
authoredTrack: 2,
});
const c2 = child("c2", 0.5, 5, 5);
diff --git a/packages/studio/src/player/components/timelineZMirror.ts b/packages/studio/src/player/components/timelineZMirror.ts
index 1596024dcb..76f81e0337 100644
--- a/packages/studio/src/player/components/timelineZMirror.ts
+++ b/packages/studio/src/player/components/timelineZMirror.ts
@@ -102,7 +102,7 @@ function expandedChildAllowedLanes(
element: TimelineElement,
elements: TimelineElement[],
): ReadonlySet<number> | null {
- if (element.expandedParentStart == null) return null;
+ if (element.expandedHostKey == null) return null;
const selfKey = keyOf(element);
return new Set(
elements
diff --git a/packages/studio/src/player/lib/timelineDOM.test.ts b/packages/studio/src/player/lib/timelineDOM.test.ts
index 63e40112c5..9e2ad14893 100644
--- a/packages/studio/src/player/lib/timelineDOM.test.ts
+++ b/packages/studio/src/player/lib/timelineDOM.test.ts
@@ -7,6 +7,8 @@ import {
mergeTimelineElementsPreservingDowngrades,
} from "./timelineDOM";
import { isTimelineIgnoredElement } from "./timelineElementHelpers";
+import { clipTimingStart, resolveClipTimingBasis } from "../../hooks/gsapShared";
+import { toAuthoredStart } from "../store/timelineElement";
import { computeResizePreview } from "../components/timelineClipDragPreview";
import type { TimelineElement } from "../store/playerStore";
import {
@@ -25,6 +27,83 @@ function makeDoc(html: string): Document {
return d;
}
+describe("parseTimelineFromDOM — nested master time", () => {
+ it("adds every enclosing host's start to a clip inside a sub-composition", () => {
+ const doc = makeDoc(`
+ <div data-composition-id="main" data-start="0" data-duration="20">
+ <div id="intro" data-composition-id="intro" data-start="2" data-duration="10">
+ <div data-composition-id="intro">
+ <div id="logo" data-composition-id="logo" data-start="3" data-duration="5">
+ <div data-composition-id="logo">
+ <div id="badge" class="clip" data-start="1" data-duration="2"></div>
+ </div>
+ </div>
+ </div>
+ </div>
+ </div>
+ `);
+ const starts = parseTimelineFromDOM(doc, 20).map((e) => [
+ e.domId,
+ e.start,
+ e.parentCompositionStart,
+ ]);
+ expect(starts).toEqual([
+ ["intro", 2, 0],
+ ["logo", 5, 2],
+ ["badge", 6, 5],
+ ]);
+ });
+
+ it("places a clip inside a referenced scene after the scene's authored length", () => {
+ const doc = makeDoc(`
+ <div data-composition-id="main" data-start="0" data-duration="20">
+ <div id="s1" data-composition-id="s1" data-start="0" data-hf-authored-duration="8"></div>
+ <div id="s2" data-composition-id="s2" data-start="s1 + 1" data-duration="6">
+ <div data-composition-id="s2">
+ <div id="c" class="clip" data-start="1" data-duration="2"></div>
+ </div>
+ </div>
+ </div>
+ `);
+ const timelines = { s1: { duration: () => 6 } } as never;
+ const c = parseTimelineFromDOM(doc, 20, timelines).find((e) => e.domId === "c");
+ expect(c?.start).toBe(10);
+ });
+});
+
+describe("parseTimelineFromDOM — nested rows' keyframe basis", () => {
+ const doc = () =>
+ makeDoc(`
+ <div data-composition-id="main" data-start="0" data-duration="20">
+ <div id="intro" data-composition-id="intro" data-start="2" data-duration="10">
+ <div data-composition-id="intro">
+ <video id="vo" data-start="7" data-duration="2" data-hf-media-start-basis="global"></video>
+ <div id="logo" data-composition-id="logo" data-start="3" data-duration="5">
+ <div data-composition-id="logo">
+ <div id="badge" class="clip" data-start="1" data-duration="2"></div>
+ </div>
+ </div>
+ </div>
+ </div>
+ </div>
+ `);
+
+ it("measures diamonds and keyframe percentages against the local tween clock", () => {
+ const rows = parseTimelineFromDOM(doc(), 20);
+ const basis = (id: string) => resolveClipTimingBasis(id, "index.html", rows, []).elStart;
+ const at = (id: string) => rows.find((e) => e.domId === id)!;
+ expect([clipTimingStart(at("logo")), basis("logo")]).toEqual([3, 3]);
+ expect([clipTimingStart(at("badge")), basis("badge")]).toEqual([1, 1]);
+ });
+
+ it("keys a legacy root-time video on its host's clock but writes its start as master time", () => {
+ const vo = parseTimelineFromDOM(doc(), 20).find((e) => e.domId === "vo")!;
+ expect(vo.start).toBe(7);
+ expect(clipTimingStart(vo)).toBe(5);
+ expect(toAuthoredStart(vo, 8)).toBe(8);
+ });
+});
+
describe("parseTimelineFromDOM — media in-point", () => {
it("reads a negative in-point as 0, as the runtime does, so a head trim keeps the clip", () => {
const doc = makeDoc(`
diff --git a/packages/studio/src/player/lib/timelineDOM.ts b/packages/studio/src/player/lib/timelineDOM.ts
index ff095c956c..b016ea7839 100644
--- a/packages/studio/src/player/lib/timelineDOM.ts
+++ b/packages/studio/src/player/lib/timelineDOM.ts
@@ -12,6 +12,7 @@ import type { TimelineElement } from "../store/playerStore";
import type { ClipManifestClip, IframeWindow, TimelineLike } from "./playbackTypes";
import { resolveCssStackingContextId } from "@hyperframes/core/runtime/stacking-context";
import { readClipTiming } from "@hyperframes/core/composition-contract";
+import { createRuntimeStartTimeResolver } from "@hyperframes/core/runtime/start-resolver";
import { groupInfoFor } from "./timelineGroupInfo";
import { transitionLabelsForDocument } from "./timelineTransitionMetadata";
import {
@@ -228,10 +229,13 @@ export function parseTimelineFromDOM(
const nodes = doc.querySelectorAll("[data-start]");
const els: TimelineElement[] = [];
let trackCounter = 0;
- const transitionLabels = transitionLabelsForDocument(
- doc,
- timelines ?? (doc.defaultView as IframeWindow | null)?.__timelines,
- );
+ const timelineRegistry = timelines ?? (doc.defaultView as IframeWindow | null)?.__timelines;
+ const transitionLabels = transitionLabelsForDocument(doc, timelineRegistry);
+ const masterStart = createRuntimeStartTimeResolver({
+ timelineRegistry,
+ includeAuthoredTimingAttrs: true,
+ documentRef: doc,
+ });
// fallow-ignore-next-line complexity
nodes.forEach((node) => {
@@ -239,11 +243,14 @@ export function parseTimelineFromDOM(
if (isTimelineIgnoredElement(node)) return;
const el = node as HTMLElement;
const timing = readClipTiming(el);
- const start = timing.start;
- if (start == null) return;
+ if (timing.start == null) return;
+ const tagLower = el.tagName.toLowerCase();
+ const start =
+ tagLower === "video" || tagLower === "audio"
+ ? masterStart.resolveMediaStartForElement(el)
+ : masterStart.resolveStartForElement(el);
if (Number.isFinite(rootDuration) && rootDuration > 0 && start >= rootDuration) return;
- const tagLower = el.tagName.toLowerCase();
let dur = timing.duration ?? 0;
if (dur <= 0) dur = Math.max(0, rootDuration - start);
if (Number.isFinite(rootDuration) && rootDuration > 0) {
@@ -287,6 +294,8 @@ export function parseTimelineFromDOM(
: "element",
tag: tagLower,
start,
+ parentCompositionStart: masterStart.resolveHostStartForElement(el),
+ ...(masterStart.isRootGlobalMediaStartForElement(el) && { authoredStartIsMasterTime: true }),
duration: dur,
track,
domId: el.id || undefined,
diff --git a/packages/studio/src/player/lib/timelineIframeHelpers.test.ts b/packages/studio/src/player/lib/timelineIframeHelpers.test.ts
index 8fa3408097..f58ca00dbc 100644
--- a/packages/studio/src/player/lib/timelineIframeHelpers.test.ts
+++ b/packages/studio/src/player/lib/timelineIframeHelpers.test.ts
@@ -103,6 +103,42 @@ describe("buildMissingCompositionElements — hfId (R7)", () => {
});
});
+describe("buildMissingCompositionElements — nested master time", () => {
+ it("places hosts two and three levels deep at their master time", () => {
+ const doc = makeDoc(`
+ <div data-composition-id="main" data-start="0" data-duration="20">
+ <div id="intro" data-composition-id="intro" data-start="2" data-duration="10">
+ <div data-composition-id="intro">
+ <div id="logo" data-composition-id="logo" data-start="3" data-duration="5">
+ <div data-composition-id="logo">
+ <div id="badge" data-composition-id="badge" data-start="1" data-duration="2"></div>
+ </div>
+ </div>
+ </div>
+ </div>
+ </div>
+ `);
+ const { missing } = buildMissingCompositionElements(doc, window as IframeWindow, [], 20);
+ expect(missing.map((e) => [e.domId, e.start, e.duration, e.parentCompositionStart])).toEqual([
+ ["intro", 2, 10, 0],
+ ["logo", 5, 5, 2],
+ ["badge", 6, 2, 5],
+ ]);
+ });
+
+ it("starts a host after a referenced scene's authored length", () => {
+ const doc = makeDoc(`
+ <div data-composition-id="main" data-start="0" data-duration="20">
+ <div id="s1" data-composition-id="s1" data-start="0" data-hf-authored-duration="8"></div>
+ <div id="s2" data-composition-id="s2" data-start="s1 + 1" data-duration="4"></div>
+ </div>
+ `);
+ const win = { __timelines: { s1: { duration: () => 6 } } } as unknown as IframeWindow;
+ const { missing } = buildMissingCompositionElements(doc, win, [], 20);
+ expect(missing.find((e) => e.domId === "s2")?.start).toBe(9);
+ });
+});
+
describe("setPreviewMediaVolume", () => {
it("sends a clamped runtime volume to a direct preview iframe", () => {
const iframe = document.createElement("iframe");
diff --git a/packages/studio/src/player/lib/timelineIframeHelpers.ts b/packages/studio/src/player/lib/timelineIframeHelpers.ts
index 75fec43136..e0dca7cdaa 100644
--- a/packages/studio/src/player/lib/timelineIframeHelpers.ts
+++ b/packages/studio/src/player/lib/timelineIframeHelpers.ts
@@ -13,6 +13,7 @@
import type { TimelineElement } from "../store/playerStore";
import type { IframeWindow } from "./playbackTypes";
import { readClipTiming } from "@hyperframes/core/composition-contract";
+import { createRuntimeStartTimeResolver } from "@hyperframes/core/runtime/start-resolver";
import {
getTimelineElementSelector,
getTimelineElementSourceFile,
@@ -414,15 +415,16 @@ function buildMissingCompositionEntry(params: {
rootDuration: number;
fallbackIndex: number;
resolveEnd: (refId: string, visiting: ReadonlySet<string>) => number | null;
+ masterTime: ReturnType<typeof createRuntimeStartTimeResolver>;
}): TimelineElement | null {
- const { doc, iframeWin, element, compositionId, rootDuration, fallbackIndex, resolveEnd } =
- params;
+ const { doc, iframeWin, element, compositionId, rootDuration, fallbackIndex } = params;
+ const { resolveEnd, masterTime } = params;
const transitionLabels = transitionLabelsForDocument(doc, iframeWin.__timelines);
const timing = readClipTiming(element, {
resolveReferenceEnd: (refId) => resolveEnd(refId, new Set([compositionId])),
});
const window = clampCompositionWindow(
- timing.start ?? 0,
+ masterTime.resolveStartForElement(element),
timing.duration ?? timelineDuration(iframeWin, compositionId),
rootDuration,
);
@@ -456,6 +458,7 @@ function buildMissingCompositionEntry(params: {
key: identity.key,
tag: element.tagName.toLowerCase(),
start: window.start,
+ parentCompositionStart: masterTime.resolveHostStartForElement(element),
duration: window.duration,
track: timing.trackIndex,
authoredTrack: timing.trackIndex,
@@ -494,6 +497,11 @@ export function buildMissingCompositionElements(
const missing: TimelineElement[] = [];
const resolveEnd = createReferenceEndResolver(createTimedElementLookup(doc), iframeWin);
+ const masterTime = createRuntimeStartTimeResolver({
+ timelineRegistry: iframeWin.__timelines,
+ includeAuthoredTimingAttrs: true,
+ documentRef: doc,
+ });
for (const host of hosts) {
const el = host as HTMLElement;
@@ -508,6 +516,7 @@ export function buildMissingCompositionElements(
rootDuration,
fallbackIndex: missing.length,
resolveEnd,
+ masterTime,
});
if (entry) missing.push(entry);
}
diff --git a/packages/studio/src/player/store/timelineElement.ts b/packages/studio/src/player/store/timelineElement.ts
index 40d66e23ab..436391d791 100644
--- a/packages/studio/src/player/store/timelineElement.ts
+++ b/packages/studio/src/player/store/timelineElement.ts
@@ -84,13 +84,38 @@ export interface TimelineElement {
audioGroupFxChain?: string;
audioGroupAutomation?: string;
/**
- * Legacy source-coordinate marker for an inline sub-composition child. The
- * current timeline keeps sub-compositions as single rows.
+ * Master start of the composition this row runs in, which its tweens and its
+ * `data-start` are local to; 0 at the root. Writes go through toAuthoredStart.
*/
- expandedParentStart?: number;
+ parentCompositionStart?: number;
+ /** A legacy root-global media start: its `data-start` is already master time. */
+ authoredStartIsMasterTime?: boolean;
+ /** Legacy marker for an inline sub-composition child; current rows never set it. */
expandedHostKey?: string;
}
+type RowClock = Pick<
+ TimelineElement,
+ "start" | "parentCompositionStart" | "authoredStartIsMasterTime"
+>;
+const authoredOffset = (element: RowClock) =>
+ element.authoredStartIsMasterTime ? 0 : (element.parentCompositionStart ?? 0);
+
+/** The earliest master start this row can take: its host's start, or its own if already earlier. */
+export function clampToHostStart(element: RowClock, masterTime: number): number {
+ return Math.max(Math.min(authoredOffset(element), element.start), masterTime);
+}
+
+/** A master-time position on this row, as the `data-start` its source file stores. */
+export function toAuthoredStart(element: RowClock, masterTime: number): number {
+ return Math.max(0, clampToHostStart(element, masterTime) - authoredOffset(element));
+}
+
+/** A master-time position on the clock this row's tweens run on. */
+export function toCompositionTime(element: RowClock, masterTime: number): number {
+ return masterTime - (element.parentCompositionStart ?? 0);
+}
+
/**
* The fields `updateElement` may write.
*
diff --git a/packages/studio/src/utils/razorSplitTransaction.test.ts b/packages/studio/src/utils/razorSplitTransaction.test.ts
index 6b1cd0a2cb..464b74a4f8 100644
--- a/packages/studio/src/utils/razorSplitTransaction.test.ts
+++ b/packages/studio/src/utils/razorSplitTransaction.test.ts
@@ -48,7 +48,7 @@ describe("buildAtomicCutIntents", () => {
it("rebases each nested target into its own source-file coordinates", () => {
const intents = buildAtomicCutIntents(
- [element({ start: 8, duration: 4, expandedParentStart: 6, sourceFile: "scene.html" })],
+ [element({ start: 8, duration: 4, parentCompositionStart: 6, sourceFile: "scene.html" })],
10,
"index.html",
);
diff --git a/packages/studio/src/utils/razorSplitTransaction.ts b/packages/studio/src/utils/razorSplitTransaction.ts
index ca679c318f..c3e3a395e7 100644
--- a/packages/studio/src/utils/razorSplitTransaction.ts
+++ b/packages/studio/src/utils/razorSplitTransaction.ts
@@ -1,4 +1,5 @@
import type { TimelineElement } from "../player";
+import { toAuthoredStart } from "../player/store/timelineElement";
import type { RecordEditInput } from "../hooks/timelineEditingHelpers";
import { buildPatchTarget } from "./timelineElementSplit";
import { serializeStudioFileMutations } from "./studioFileMutationCoordinator";
@@ -61,12 +62,11 @@ function buildCutTarget(
target: CutTarget["target"],
splitTime: number,
): CutTarget {
- const basis = element.expandedParentStart;
return {
target,
...(element.domId ? { originalId: element.domId } : {}),
- splitTime: basis === undefined ? splitTime : Math.max(0, splitTime - basis),
- elementStart: basis === undefined ? element.start : element.start - basis,
+ splitTime: Math.max(0, toAuthoredStart(element, splitTime)),
+ elementStart: toAuthoredStart(element, element.start),
elementDuration: element.duration,
...(element.playbackStart != null ? { playbackStart: element.playbackStart } : {}),
...(element.playbackRate != null ? { playbackRate: element.playbackRate } : {}),