Write HTML. Render video. Built for agents.
JavaScript aiai-agentsanimationclaude-codeffmpegframeworkgsaphtmlhtml-to-videomcpmotion-graphicspuppeteerrenderingtypescriptvideo-editor
fix(studio): resizing a cropped element keeps the same part of it in view (#4743)
Miguel Ángel76c634dfa5f9
diff --git a/packages/studio/src/components/editor/DomEditCropHandles.test.tsx b/packages/studio/src/components/editor/DomEditCropHandles.test.tsxindex 33ec296a83..e4c191f742 100644--- a/packages/studio/src/components/editor/DomEditCropHandles.test.tsx+++ b/packages/studio/src/components/editor/DomEditCropHandles.test.tsx@@ -5,6 +5,7 @@ import { afterEach, describe, expect, it, vi } from "vitest";import type { DomEditSelection } from "./domEditing";import type { OverlayRect } from "./domEditOverlayGeometry";import { DomEditCropHandles } from "./DomEditCropHandles";+import { isElementCropLifted } from "./domEditOverlayCrop";(globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT: boolean }).IS_REACT_ACT_ENVIRONMENT = true;@@ -55,27 +56,27 @@ function render(return { root, rerender: draw };}-// Regression: the deselect restore used a ref recomputed from RENDER state — on-// a direct A→B selection switch, state re-syncs to B before A's effect cleanup-// runs, so A used to get B's crop string (or lose its crop entirely). The-// restore value must be owned by A's own lift effect / crop gesture.-describe("DomEditCropHandles clip lift/restore", () => {- it("lifts on select and restores the inline clip verbatim on unmount", () => {+// The lift never touches the element's own clip-path: select+deselect must leave what the author+// wrote verbatim, and a direct A→B switch must drop A's lift, not B's.+describe("DomEditCropHandles clip lift", () => {+ it("lifts on select without rewriting the inline clip, and drops the lift on unmount", () => {const a = makeEl("a", "inset(16px round 12px)");const { root } = render(a);- expect(a.style.getPropertyValue("clip-path")).toBe("none");+ expect(isElementCropLifted(a)).toBe(true);+ expect(a.style.getPropertyValue("clip-path")).toBe("inset(16px round 12px)");act(() => root.unmount());+ expect(isElementCropLifted(a)).toBe(false);expect(a.style.getPropertyValue("clip-path")).toBe("inset(16px round 12px)");});- it("restores A's own clip when switching directly to B", () => {+ it("drops A's lift when switching directly to B", () => {const a = makeEl("a", "inset(16px)");const b = makeEl("b", "inset(40px 8px 4px 2px)");const { root, rerender } = render(a);rerender(b);- // A got ITS clip back, not B's (and not removed); B is now lifted.+ expect(isElementCropLifted(a)).toBe(false);+ expect(isElementCropLifted(b)).toBe(true);expect(a.style.getPropertyValue("clip-path")).toBe("inset(16px)");- expect(b.style.getPropertyValue("clip-path")).toBe("none");act(() => root.unmount());expect(b.style.getPropertyValue("clip-path")).toBe("inset(40px 8px 4px 2px)");});@@ -83,49 +84,11 @@ describe("DomEditCropHandles clip lift/restore", () => {it("never lifts an uneditable clip and leaves it untouched across select/deselect", () => {const a = makeEl("a", "circle(50% at 50% 50%)");const { root } = render(a);- expect(a.style.getPropertyValue("clip-path")).toBe("circle(50% at 50% 50%)");+ expect(isElementCropLifted(a)).toBe(false);act(() => root.unmount());expect(a.style.getPropertyValue("clip-path")).toBe("circle(50% at 50% 50%)");});- it("re-lifts synchronously after the commit path re-applies the cropped value", async () => {- const a = makeEl("a", "inset(10px)");- let resolveCommit: (() => void) | undefined;- const pendingCommit = new Promise<void>((resolve) => {- resolveCommit = resolve;- });- const onStyleCommit = vi.fn((property: string, value: string) => {- a.style.setProperty(property, value);- return pendingCommit;- });- const { root } = render(a, onStyleCommit);- const handle = document.querySelector<HTMLButtonElement>('[aria-label="Crop right"]');- expect(handle).toBeTruthy();-- act(() =>- handle!.dispatchEvent(- new PointerEvent("pointerdown", { bubbles: true, pointerId: 1, clientX: 100 }),- ),- );- act(() =>- handle!.dispatchEvent(- new PointerEvent("pointermove", { bubbles: true, pointerId: 1, clientX: 80 }),- ),- );- act(() =>- handle!.dispatchEvent(- new PointerEvent("pointerup", { bubbles: true, pointerId: 1, clientX: 80 }),- ),- );-- expect(onStyleCommit).toHaveBeenCalledWith("clip-path", "inset(10px 30px 10px 10px)");- expect(a.style.getPropertyValue("clip-path")).toBe("none");- resolveCommit?.();- await act(async () => pendingCommit);- act(() => root.unmount());- expect(a.style.getPropertyValue("clip-path")).toBe("inset(10px 30px 10px 10px)");- });-it.each([{ name: "a crop edge", clip: "inset(10px)", handle: "Crop right", dx: -20, dy: 0 },{@@ -189,33 +152,38 @@ describe("DomEditCropHandles clip lift/restore", () => {expect(a.style.getPropertyValue("clip-path")).toBe("inset(0px 20px 0px 0px)");});- it("re-lifts when the crop commit rejects", async () => {+ it("commits the dragged crop and stays lifted when the save fails", async () => {const a = makeEl("a", "inset(10px)");const onStyleCommit = vi.fn((property: string, value: string) => {a.style.setProperty(property, value);return Promise.reject(new Error("persist failed"));});const { root } = render(a, onStyleCommit);- const handle = document.querySelector<HTMLButtonElement>('[aria-label="Crop right"]');-- act(() =>- handle!.dispatchEvent(- new PointerEvent("pointerdown", { bubbles: true, pointerId: 2, clientX: 100 }),- ),- );- act(() =>- handle!.dispatchEvent(- new PointerEvent("pointermove", { bubbles: true, pointerId: 2, clientX: 80 }),- ),- );- await act(async () => {- handle!.dispatchEvent(- new PointerEvent("pointerup", { bubbles: true, pointerId: 2, clientX: 80 }),+ const handle = document.querySelector<HTMLButtonElement>('[aria-label="Crop right"]')!;+ const press = (type: string, clientX: number) =>+ act(() =>+ handle.dispatchEvent(new PointerEvent(type, { bubbles: true, pointerId: 1, clientX })),);+ press("pointerdown", 100);+ press("pointermove", 80);+ await act(async () => {+ press("pointerup", 80);await Promise.resolve();});- expect(a.style.getPropertyValue("clip-path")).toBe("none");+ expect(onStyleCommit).toHaveBeenCalledWith("clip-path", "inset(10px 30px 10px 10px)");+ expect(isElementCropLifted(a)).toBe(true);+ act(() => root.unmount());+ });++ it("draws the crop the element has now, after an undo rewrites it", () => {+ const a = makeEl("a", "inset(0px 20px 0px 0px)");+ const { root, rerender } = render(a);+ const outline = () => document.querySelector<HTMLElement>(".border-dashed")!.style.width;+ expect(outline()).toBe("180px");+ a.style.setProperty("clip-path", "inset(0px 50px 0px 0px)");+ rerender(a);+ expect(outline()).toBe("150px");act(() => root.unmount());});});diff --git a/packages/studio/src/components/editor/DomEditCropHandles.tsx b/packages/studio/src/components/editor/DomEditCropHandles.tsxindex b223d7a900..67172d83e6 100644--- a/packages/studio/src/components/editor/DomEditCropHandles.tsx+++ b/packages/studio/src/components/editor/DomEditCropHandles.tsx@@ -4,6 +4,9 @@ import { type OverlayRect, RESIZE_HANDLE_HIT_PX } from "./domEditOverlayGeometryimport {type CropEdge,cropRectFromInsets,+ dropElementCropLift,+ hasCropInsets,+ liftElementCrop,readElementCropFrame,readElementCropInsets,resolveCropInsetFromEdgeDrag,@@ -11,6 +14,7 @@ import {rotateDeltaIntoFrame,} from "./domEditOverlayCrop";import { buildInsetClipPathSides, type ClipPathInsetSides } from "./clipPathHelpers";+import { readCropFollowingResize } from "./cropResize";interface CropGestureState {edge: CropEdge | "move";@@ -19,6 +23,7 @@ interface CropGestureState {startY: number;startInsets: ClipPathInsetSides;insets: ClipPathInsetSides;+ radius: number;/** Element frame captured at gesture start: pointer deltas rotate into it. */angleDeg: number;scaleX: number;@@ -83,6 +88,7 @@ function repositionHandleSize(rect: Rect): number {}const EDGES: CropEdge[] = ["top", "right", "bottom", "left"];+const NO_CROP = { top: 0, right: 0, bottom: 0, left: 0, radius: 0 };/*** Always-on crop, integrated with the selection (no crop "mode"): while a@@ -92,7 +98,7 @@ const EDGES: CropEdge[] = ["top", "right", "bottom", "left"];* grid guides framing); release commits `clip-path: inset(...)` through the* normal style-commit path (one undo step per drag). When cropped, a center* handle pans the crop window. Corners stay free for the selection's own resize- * handle. Leaving the selection restores the committed crop. The clip-path model+ * handle. Leaving the selection drops the lift. The element's clip-path* is the source of truth — nothing here mutates layout.*/export function DomEditCropHandles({@@ -109,54 +115,29 @@ export function DomEditCropHandles({// clip with an inset (or deletes it).const cropStateFor = (element: HTMLElement) => {const parsed = readElementCropInsets(element);- const { radius, ...insets } = parsed ?? { top: 0, right: 0, bottom: 0, left: 0, radius: 0 };- return { element, croppable: parsed !== null, insets, radius };+ const { top, right, bottom, left } = parsed ?? NO_CROP;+ return { element, croppable: parsed !== null, insets: { top, right, bottom, left } };};const [state, setState] = useState(() => cropStateFor(selection.element));// Re-sync when the selection targets a different element (reselect, or an- // undo/redo that re-keys the node): read its committed crop before the lift- // effect runs. Read inside the guard so a drag's per-frame setState doesn't- // re-run getComputedStyle every frame.+ // undo/redo that re-keys the node).if (state.element !== selection.element) {setState(cropStateFor(selection.element));}- const hasCrop =- state.insets.top > 0 ||- state.insets.right > 0 ||- state.insets.bottom > 0 ||- state.insets.left > 0;+ // The element's clip-path is the crop; state only holds a crop drag's draft.+ const committed = readCropFollowingResize(selection.element) ?? NO_CROP;+ const insets = dragging ? state.insets : committed;+ const hasCrop = hasCropInsets(insets);// Lift the clip while the element is selected so the full content shows and the- // cropped-away area can be dimmed; restore on deselect. Keyed on the element so- // switching selections restores the previous one. Runs after render, so the- // state re-sync above still reads the element's real committed clip. Restore- // prefers the pre-lift inline value VERBATIM — the rebuilt inset only replaces- // it after a crop gesture actually commits, so a mere select+deselect can- // never reformat (or drop) what the author wrote. Both refs are written only- // by THIS element's lift effect and crop gestures — never derived from render- // state, which by cleanup time already describes the NEXT selection (a direct- // A→B switch re-syncs state to B before A's cleanup runs).- const liftedRef = useRef(false);- const preLiftInlineClipRef = useRef("");- // null = no crop gesture committed this selection; "" = committed a crop- // removal; anything else = the exact committed clip-path value.- const committedClipRef = useRef<string | null>(null);+ // cropped-away area can be dimmed. Keyed on the element so a direct A→B switch drops A's lift.useEffect(() => {const el = selection.element;if (readElementCropInsets(el) === null) return;- preLiftInlineClipRef.current = el.style.getPropertyValue("clip-path");- committedClipRef.current = null;- el.style.setProperty("clip-path", "none");- liftedRef.current = true;- return () => {- liftedRef.current = false;- const committed = committedClipRef.current;- const restore = committed !== null ? committed || null : preLiftInlineClipRef.current || null;- if (restore) el.style.setProperty("clip-path", restore);- else el.style.removeProperty("clip-path");- };+ liftElementCrop(el);+ return () => dropElementCropLift(el);}, [selection.element]);// The crop applies in the element's LOCAL frame (clip-path precedes the@@ -169,7 +150,7 @@ export function DomEditCropHandles({// Crop rect in FRAME-LOCAL coordinates (origin = frame top-left).const cropRect = cropRectFromInsets({ left: 0, top: 0, width: frame.width, height: frame.height },- state.insets,+ insets,frame.scaleX,frame.scaleY,);@@ -180,19 +161,23 @@ export function DomEditCropHandles({event.preventDefault();event.stopPropagation();event.currentTarget.setPointerCapture(event.pointerId);+ // Read at press: a resize may have rescaled the crop since the last render.+ const pressed = readCropFollowingResize(selection.element) ?? NO_CROP;gestureRef.current = {edge,pointerId: event.pointerId,startX: event.clientX,startY: event.clientY,- startInsets: state.insets,- insets: state.insets,+ startInsets: pressed,+ insets: pressed,+ radius: pressed.radius,angleDeg: frame.angleDeg,scaleX: frame.scaleX,scaleY: frame.scaleY,};// Clip is already lifted by the selection effect; just flag the drag so the// rule-of-thirds grid shows.+ setState((prev) => ({ ...prev, insets: pressed }));setDragging(true);};@@ -234,29 +219,12 @@ export function DomEditCropHandles({const finishCropGesture = (event: ReactPointerEvent<HTMLElement>) => {const gesture = endCropGesture(event);if (!gesture) return;- // Commit to the file. The commit path re-applies the value to the live- // element synchronously, so re-lift in the same turn to keep showing the full- // content + dim while selected. Re-lift again on rejection so a failed commit- // still restores crop-mode presentation without an unhandled rejection.- const el = selection.element;- const reLift = () => {- if (liftedRef.current) el.style.setProperty("clip-path", "none");- };- const { insets } = gesture;- const committedValue = buildInsetClipPathSides(insets, state.radius);- if (committedValue === buildInsetClipPathSides(gesture.startInsets, state.radius)) return;- const cropped = insets.top > 0 || insets.right > 0 || insets.bottom > 0 || insets.left > 0;- const commit = onStyleCommit?.("clip-path", committedValue);- // handleDomStyleCommit applies the persisted value to the live element- // synchronously before its first await. Restore the crop-mode lift in this- // same turn so the browser never paints that intermediate cropped state.- reLift();- void Promise.resolve(commit).then(() => {- // Only a landed commit makes the rebuilt inset the restore value; a- // failed one keeps restoring the pre-lift clip. Store the value itself —- // by deselect time, render state describes the next selection.- committedClipRef.current = cropped ? committedValue : "";- }, reLift);+ // The commit writes the element's clip-path (and puts it back if the save fails);+ // the lift keeps it hidden while selected. A drag that ends where it started saves nothing.+ const value = buildInsetClipPathSides(gesture.insets, gesture.radius);+ if (value === buildInsetClipPathSides(gesture.startInsets, gesture.radius)) return;+ const commit = onStyleCommit?.("clip-path", value);+ void Promise.resolve(commit).catch(() => undefined);};const cancelCropGesture = (event: ReactPointerEvent<HTMLElement>) => {diff --git a/packages/studio/src/components/editor/cropResize.test.ts b/packages/studio/src/components/editor/cropResize.test.tsnew file mode 100644index 0000000000..b77901b842--- /dev/null+++ b/packages/studio/src/components/editor/cropResize.test.ts@@ -0,0 +1,129 @@+// @vitest-environment happy-dom+import { describe, expect, it, vi } from "vitest";+import { prepareCropResize, readCropFollowingResize, saveCropResize } from "./cropResize";+import type { DomEditSelection } from "./domEditingTypes";+import {+ applyStudioBoxSizeDraft,+ captureStudioBoxSize,+ clearStudioBoxSize,+ restoreStudioBoxSize,+} from "./manualEdits";+import { withInlineLayoutBox } from "../../hooks/domSelectionTestHarness";++function sizedElement(width: number, height: number, clip: string): HTMLElement {+ const el = withInlineLayoutBox(document.createElement("div"));+ el.style.cssText = `width: ${width}px; height: ${height}px; clip-path: ${clip}`;+ return el;+}++describe("crop during a resize", () => {+ it("follows the box only while a resize draft is live", () => {+ const el = sizedElement(300, 200, "inset(10px 60px 20px 30px round 8px)");+ const before = captureStudioBoxSize(el);+ const crop = (top: number, right: number, bottom: number, left: number) => ({+ top,+ right,+ bottom,+ left,+ radius: 8,+ });+ applyStudioBoxSizeDraft(el, { width: 600, height: 400 });+ expect(readCropFollowingResize(el)).toEqual(crop(20, 120, 40, 60));+ restoreStudioBoxSize(el, before);+ // An animated width is not a resize: the crop keeps its pixels.+ el.style.width = "600px";+ expect(readCropFollowingResize(el)).toEqual(crop(10, 60, 20, 30));+ });++ it("leaves the crop alone when the box kept its size (a resize saved as scale)", () => {+ const el = sizedElement(300, 200, "inset(0px 60px 0px 0px)");+ applyStudioBoxSizeDraft(el, { width: 450, height: 300 });+ const stage = prepareCropResize(el);+ clearStudioBoxSize(el);+ el.style.width = "300px";+ el.style.height = "200px";+ expect(stage()).toBeNull();+ expect(el.style.getPropertyValue("clip-path")).toBe("inset(0px 60px 0px 0px)");+ });++ it("puts the crop back, !important and all, when its save fails", async () => {+ const el = sizedElement(300, 200, "none");+ el.style.setProperty("clip-path", "inset(0px 60px 0px 0px)", "important");+ const stage = prepareCropResize(el);+ el.style.width = "450px";+ let priorityWhileSaving = "";+ const commit = vi.fn(() => {+ priorityWhileSaving = el.style.getPropertyPriority("clip-path");+ return Promise.reject(new Error("save failed"));+ });+ const selection = { element: el } as unknown as DomEditSelection;+ await expect(saveCropResize(stage, selection, commit, "undo-key")).rejects.toThrow(+ "save failed",+ );++ const value = "inset(0px 90px 0px 0px) !important";+ expect(commit.mock.calls[0]![1]).toEqual([+ { type: "inline-style", property: "clip-path", value },+ ]);+ expect(priorityWhileSaving).toBe("important");+ expect(el.style.getPropertyValue("clip-path")).toBe("inset(0px 60px 0px 0px)");+ expect(el.style.getPropertyPriority("clip-path")).toBe("important");+ });++ it("scales the crop once: the stage ends the draft", () => {+ const el = sizedElement(300, 200, "inset(0px 60px 0px 0px)");+ applyStudioBoxSizeDraft(el, { width: 450, height: 300 });+ prepareCropResize(el)();+ expect(readCropFollowingResize(el)).toMatchObject({ right: 90 });+ });++ it("leaves a crop edited while the size saved, and a tweened crop, alone", () => {+ const edited = sizedElement(300, 200, "inset(0px 60px 0px 0px)");+ const stageEdited = prepareCropResize(edited);+ edited.style.width = "450px";+ edited.style.setProperty("clip-path", "inset(0px 100px 0px 0px)");+ expect(stageEdited()).toBeNull();++ const tweened = sizedElement(300, 200, "inset(0px 60px 0px 0px)");+ const child = { targets: () => [tweened], vars: { clipPath: "inset(0px 120px 0px 0px)" } };+ Object.assign(window, { __timelines: { main: { getChildren: () => [child] } } });+ const stageTweened = prepareCropResize(tweened);+ tweened.style.width = "450px";+ expect(stageTweened()).toBeNull();+ Object.assign(window, { __timelines: undefined });+ });++ it("decides before the write, which may add a width tween of its own", () => {+ const el = sizedElement(300, 200, "inset(0px 60px 0px 0px)");+ const stage = prepareCropResize(el);+ const tween = { targets: () => [el], vars: { width: 600 }, duration: () => 4 };+ Object.assign(window, { __timelines: { main: { getChildren: () => [tween] } } });+ el.style.width = "600px";+ expect(stage()?.patch.value).toBe("inset(0px 120px 0px 0px)");+ Object.assign(window, { __timelines: undefined });+ });++ it("follows only the axes GSAP does not tween, while dragging and once saved", () => {+ const resize = (vars: object, duration: number) => {+ const el = sizedElement(300, 200, "inset(20px 60px 20px 0px)");+ const tween = { targets: () => [el], vars, duration: () => duration };+ // The tween's timeline is not the first key, as after a soft reload.+ const timelines = { sub: { getChildren: () => [] }, main: { getChildren: () => [tween] } };+ Object.assign(window, { __timelines: timelines });+ applyStudioBoxSizeDraft(el, { width: 600, height: 400 });+ const { top, right } = readCropFollowingResize(el)!;+ const saved = prepareCropResize(el)()?.patch.value ?? null;+ Object.assign(window, { __timelines: undefined });+ return [[top, right], saved];+ };+ // A held width still scales; a height tween leaves the width free.+ expect(resize({ width: 473 }, 0)).toEqual([[40, 120], "inset(40px 120px 40px 0px)"]);+ expect(resize({ height: 300 }, 4)).toEqual([[20, 120], "inset(20px 120px 20px 0px)"]);+ // A width tween, in either keyframe form, leaves the height free.+ const widthOnly = [[40, 60], "inset(40px 60px 40px 0px)"];+ const percent = { "0%": { width: 300 }, "100%": { width: 600 } };+ expect(resize({ keyframes: percent }, 4)).toEqual(widthOnly);+ expect(resize({ keyframes: { width: [300, 600] } }, 4)).toEqual(widthOnly);+ expect(resize({ width: 600, height: 400 }, 4)).toEqual([[20, 60], null]);+ });+});diff --git a/packages/studio/src/components/editor/cropResize.ts b/packages/studio/src/components/editor/cropResize.tsnew file mode 100644index 0000000000..9d2e89e47e--- /dev/null+++ b/packages/studio/src/components/editor/cropResize.ts@@ -0,0 +1,143 @@+import type { PatchOperation } from "../../utils/sourcePatcher";+import type { CommitMutation } from "../../hooks/gsapScriptCommitTypes";+import type { DomEditSelection } from "./domEditingTypes";+import { gsapAnimatesProperty } from "./gsapAnimatesProperty";+import { elementHasNonHoldTween } from "../../hooks/gsapRuntimeKeyframes";+import { buildInsetClipPathSides, type ParsedInsetClipPathSides } from "./clipPathHelpers";+import { hasCropInsets, readElementCropInsets } from "./domEditOverlayCrop";+import { forgetStudioBoxSizeDraftBase, readStudioBoxSizeDraftBase } from "./manualEditsDom";++interface Box {+ width: number;+ height: number;+}++const boxOf = (element: HTMLElement): Box => ({+ width: element.offsetWidth,+ height: element.offsetHeight,+});++type Follows = Record<keyof Box, boolean>;++/** Per axis, whether a crop follows a resize: not when GSAP drives the clip or tweens that axis's size. */+function cropFollows(element: HTMLElement): Follows {+ const clip = gsapAnimatesProperty(element, "clipPath");+ return {+ width: !clip && !elementHasNonHoldTween(element, ["width"]),+ height: !clip && !elementHasNonHoldTween(element, ["height"]),+ };+}++function scaleCrop(+ crop: ParsedInsetClipPathSides,+ from: Box,+ to: Box,+ follows: Follows,+): ParsedInsetClipPathSides {+ const sx = follows.width && from.width > 0 ? to.width / from.width : 1;+ const sy = follows.height && from.height > 0 ? to.height / from.height : 1;+ return {+ top: crop.top * sy,+ right: crop.right * sx,+ bottom: crop.bottom * sy,+ left: crop.left * sx,+ radius: crop.radius,+ };+}++/** The element's crop as the crop UI draws it: it follows the box while a resize draft is live. */+export function readCropFollowingResize(element: HTMLElement): ParsedInsetClipPathSides | null {+ const crop = readElementCropInsets(element);+ const base = readStudioBoxSizeDraftBase(element);+ return crop && base ? scaleCrop(crop, base, boxOf(element), cropFollows(element)) : crop;+}++export interface CropResize {+ patch: PatchOperation;+ revert: () => void;+}++/** Call before a resize lands. Once the new size is live, the stage writes the crop that keeps the+ * same part of the element in view and returns its patch, or null when nothing needs rescaling. */+export function prepareCropResize(element: HTMLElement): () => CropResize | null {+ const from = readStudioBoxSizeDraftBase(element) ?? boxOf(element);+ const before = element.style.getPropertyValue("clip-path");+ const priority = element.style.getPropertyPriority("clip-path");+ // Decided before the write lands: a W edit may add a width keyframe of its own.+ const follows = cropFollows(element);+ const crop = readElementCropInsets(element);+ return () => {+ forgetStudioBoxSizeDraftBase(element);+ const to = boxOf(element);+ // A crop edited while the size saved was drawn in the new box already.+ const untouched = element.style.getPropertyValue("clip-path") === before;+ if (!crop || !hasCropInsets(crop) || !untouched || !(to.width > 0 && to.height > 0))+ return null;+ const clip = buildInsetClipPathSides(scaleCrop(crop, from, to, follows), crop.radius);+ // Unchanged when the box is (a resize saved as a `scale`) or no resized axis follows.+ if (clip === buildInsetClipPathSides(crop, crop.radius)) return null;+ element.style.setProperty("clip-path", clip, priority);+ return {+ patch: {+ type: "inline-style",+ property: "clip-path",+ value: priority ? `${clip} !important` : clip,+ },+ revert: () => {+ if (before) element.style.setProperty("clip-path", before, priority);+ else element.style.removeProperty("clip-path");+ },+ };+ };+}++type PatchCommit = (+ selection: DomEditSelection,+ patches: PatchOperation[],+ options: { label: string; coalesceKey: string; coalesceMs?: number },+) => Promise<void>;++/** Stage the crop and save it under the resize's undo key, taking it back off the element if that fails. */+export async function saveCropResize(+ stage: () => CropResize | null,+ selection: DomEditSelection,+ commit: PatchCommit,+ coalesceKey: string,+): Promise<void> {+ const crop = stage();+ if (!crop) return;+ try {+ await commit(selection, [crop.patch], {+ label: "Resize layer",+ coalesceKey,+ coalesceMs: Number.POSITIVE_INFINITY,+ });+ } catch (error) {+ crop.revert();+ throw error;+ }+}++let sizeWriteCounter = 0;++/** A property write that may size the element (a W/H field on an animated element): when it+ * does, its writes and the rescaled crop share one undo step. */+export async function writeSizeWithCrop(+ selection: DomEditSelection,+ properties: Record<string, unknown>,+ mutation: CommitMutation | null,+ commit: PatchCommit,+ write: (keyed?: CommitMutation) => Promise<void>,+): Promise<void> {+ if (!mutation || !("width" in properties || "height" in properties)) return write();+ const stage = prepareCropResize(selection.element);+ const coalesceKey = `size-write:${++sizeWriteCounter}`;+ const undoStep = { coalesceKey, coalesceMs: Number.POSITIVE_INFINITY };+ const keyed: CommitMutation = (s, m, options) => mutation(s, m, { ...options, ...undoStep });+ if (mutation.batch) {+ const batch = mutation.batch;+ keyed.batch = (calls, options) => batch(calls, { ...options, ...undoStep });+ }+ await write(keyed);+ await saveCropResize(stage, selection, commit, coalesceKey);+}diff --git a/packages/studio/src/components/editor/domEditOverlayCrop.ts b/packages/studio/src/components/editor/domEditOverlayCrop.tsindex fdd61465c4..9b16f8e932 100644--- a/packages/studio/src/components/editor/domEditOverlayCrop.ts+++ b/packages/studio/src/components/editor/domEditOverlayCrop.ts@@ -1,5 +1,9 @@import { composeElementTransform, type PlanarTransformOps } from "./domEditOverlayTransform";-import { parseInsetClipPathSides, type ClipPathInsetSides } from "./clipPathHelpers";+import {+ parseInsetClipPathSides,+ type ClipPathInsetSides,+ type ParsedInsetClipPathSides,+} from "./clipPathHelpers";export type CropEdge = "top" | "right" | "bottom" | "left";@@ -29,23 +33,69 @@ export function cropRectFromInsets(};}-/**- * Current inset crop of an element (inline first, computed fallback).- * Zeros = no clip (croppable, nothing cropped yet). `null` = the element- * carries a clip-path this tool cannot represent (circle/polygon/non-px- * inset) — croppers must not lift, edit, or restore it, or the clip gets- * silently replaced or destroyed on deselect.- */-export function readElementCropInsets(- element: HTMLElement,-): (ClipPathInsetSides & { radius: number }) | null {+// A selected croppable element shows uncropped so the crop UI can dim what is cut away. A rule keyed on its+// identity does that, so the element's own clip-path stays the one record undo, redo and panel edits rewrite.+const cropLifts = new WeakMap<HTMLElement, { rule: HTMLStyleElement; sheetClip?: string }>();++function liftSelector(element: HTMLElement): string | null {+ const quote = (value: string) => `"${value.replace(/["\\]/g, "\\$&")}"`;+ const hfId = element.getAttribute("data-hf-id");+ if (hfId) return `[data-hf-id=${quote(hfId)}]`;+ return element.id ? `[id=${quote(element.id)}]` : null;+}++export function liftElementCrop(element: HTMLElement): void {+ const selector = liftSelector(element);+ if (!selector || cropLifts.has(element)) return;+ const doc = element.ownerDocument;+ const rule = doc.createElement("style");+ rule.textContent = `${selector}{clip-path:none!important}`;+ (doc.head ?? doc.documentElement).append(rule);+ cropLifts.set(element, { rule });+}++export function dropElementCropLift(element: HTMLElement): void {+ cropLifts.get(element)?.rule.remove();+ cropLifts.delete(element);+}++export function isElementCropLifted(element: HTMLElement): boolean {+ return cropLifts.has(element);+}++const computedClipPath = (element: HTMLElement) =>+ element.ownerDocument.defaultView?.getComputedStyle(element).clipPath.trim() || "";++/** The element's clip-path, inline first, then the stylesheet's as it is without the lift. */+function readElementClipPath(element: HTMLElement): string {const inline = element.style.getPropertyValue("clip-path").trim();- const value =- inline || element.ownerDocument.defaultView?.getComputedStyle(element).clipPath.trim() || "";+ const lift = cropLifts.get(element);+ if (inline || !lift) return inline || computedClipPath(element);+ // Only inline writes happen while selected, so the stylesheet's clip is read once per lift.+ if (lift.sheetClip === undefined) {+ const { parentNode, nextSibling } = lift.rule;+ lift.rule.remove();+ lift.sheetClip = computedClipPath(element);+ parentNode?.insertBefore(lift.rule, nextSibling);+ }+ return lift.sheetClip;+}++/** Zeros = no clip yet. `null` = a clip this tool cannot represent (circle/polygon/non-px inset):+ * croppers must not lift, edit, or restore it, or deselect silently replaces or destroys it. */+function parseCropClipPath(value: string): ParsedInsetClipPathSides | null {if (!value || value === "none") return { top: 0, right: 0, bottom: 0, left: 0, radius: 0 };return parseInsetClipPathSides(value);}+export function readElementCropInsets(element: HTMLElement): ParsedInsetClipPathSides | null {+ return parseCropClipPath(readElementClipPath(element));+}++export function hasCropInsets(insets: ClipPathInsetSides): boolean {+ return insets.top > 0 || insets.right > 0 || insets.bottom > 0 || insets.left > 0;+}+export interface CropInsetDragInput {edge: CropEdge;startInsets: ClipPathInsetSides;@@ -117,8 +167,8 @@ export function hugRectForElement(rect: CropScreenRect & { editScaleX: number; editScaleY: number },element: HTMLElement,): CropScreenRect {- const insets = readElementCropInsets(element);- // Uneditable clip (null) can't be hugged — show the full element rect.+ const insets = isElementCropLifted(element) ? null : readElementCropInsets(element);+ // Uneditable or lifted clip — show the full element rect.if (!insets || (insets.top <= 0 && insets.right <= 0 && insets.bottom <= 0 && insets.left <= 0))return rect;return cropRectFromInsets(rect, insets, rect.editScaleX, rect.editScaleY);diff --git a/packages/studio/src/components/editor/domEditOverlayCropLift.test.ts b/packages/studio/src/components/editor/domEditOverlayCropLift.test.tsnew file mode 100644index 0000000000..f0c9594e2d--- /dev/null+++ b/packages/studio/src/components/editor/domEditOverlayCropLift.test.ts@@ -0,0 +1,44 @@+// @vitest-environment happy-dom+import { afterEach, describe, expect, it } from "vitest";+import {+ dropElementCropLift,+ hugRectForElement,+ liftElementCrop,+ readElementCropInsets,+} from "./domEditOverlayCrop";++afterEach(() => {+ document.head.innerHTML = "";+ document.body.innerHTML = "";+});++function cropped(style: string): HTMLElement {+ const el = document.createElement("div");+ el.setAttribute("data-hf-id", "hf-a");+ el.style.cssText = style;+ document.body.append(el);+ return el;+}++describe("crop lift", () => {+ it("shows the element uncropped over its inline clip, and drop takes the rule away", () => {+ const el = cropped("clip-path: inset(0px 60px 0px 0px)");+ liftElementCrop(el);+ expect(getComputedStyle(el).clipPath).toBe("none");+ expect(el.style.getPropertyValue("clip-path")).toBe("inset(0px 60px 0px 0px)");+ dropElementCropLift(el);+ expect(document.head.querySelectorAll("style")).toHaveLength(0);+ expect(getComputedStyle(el).clipPath).toBe("inset(0px 60px 0px 0px)");+ });++ it("still reads a stylesheet crop while lifted, and the hover hug shows the full box", () => {+ const sheet = document.createElement("style");+ sheet.textContent = '[data-hf-id="hf-a"] { clip-path: inset(0px 60px 0px 0px); }';+ document.head.append(sheet);+ const el = cropped("width: 300px");+ liftElementCrop(el);+ expect(readElementCropInsets(el)).toMatchObject({ right: 60 });+ const rect = { left: 0, top: 0, width: 300, height: 200, editScaleX: 1, editScaleY: 1 };+ expect(hugRectForElement(rect, el)).toEqual(rect);+ });+});diff --git a/packages/studio/src/components/editor/manualEditsDom.ts b/packages/studio/src/components/editor/manualEditsDom.tsindex 99b9b0eea4..a75ded7846 100644--- a/packages/studio/src/components/editor/manualEditsDom.ts+++ b/packages/studio/src/components/editor/manualEditsDom.ts@@ -457,10 +457,26 @@ export function applyStudioBoxSize(applyStudioBoxSizeDimensions(element, size);}+// The element's box before a resize draft first changed it; gone once the resize saves or is restored.+const boxSizeDraftBases = new WeakMap<HTMLElement, { width: number; height: number }>();++export function readStudioBoxSizeDraftBase(+ element: HTMLElement,+): { width: number; height: number } | null {+ return boxSizeDraftBases.get(element) ?? null;+}++export function forgetStudioBoxSizeDraftBase(element: HTMLElement): void {+ boxSizeDraftBases.delete(element);+}+export function applyStudioBoxSizeDraft(element: HTMLElement,size: { width: number; height: number },): void {+ if (!boxSizeDraftBases.has(element)) {+ boxSizeDraftBases.set(element, { width: element.offsetWidth, height: element.offsetHeight });+ }promoteInlineForTransform(element);applyStudioBoxSizeDimensions(element, size);}diff --git a/packages/studio/src/components/editor/manualEditsSnapshot.ts b/packages/studio/src/components/editor/manualEditsSnapshot.tsindex 826fb16829..1fb3569869 100644--- a/packages/studio/src/components/editor/manualEditsSnapshot.ts+++ b/packages/studio/src/components/editor/manualEditsSnapshot.ts@@ -3,6 +3,7 @@ import {styleUsesStudioSize,styleUsesStudioRotation,restoreInlineDisplay,+ forgetStudioBoxSizeDraftBase,} from "./manualEditsDom";import {STUDIO_OFFSET_X_PROP,@@ -114,6 +115,7 @@ function restoreStyleProperty(element: HTMLElement, property: string, value: str}export function restoreStudioBoxSize(element: HTMLElement, previous: StudioBoxSizeSnapshot): void {+ forgetStudioBoxSizeDraftBase(element);restoreStyleProperty(element, "width", previous.width);restoreStyleProperty(element, "height", previous.height);restoreStyleProperty(element, "min-width", previous.minWidth);@@ -290,6 +292,7 @@ export function clearStudioRotation(element: HTMLElement): void {}export function clearStudioBoxSize(element: HTMLElement): void {+ forgetStudioBoxSizeDraftBase(element);if (element.hasAttribute(STUDIO_BOX_SIZE_ATTR) ||styleUsesStudioSize(element.style.getPropertyValue("width")) ||diff --git a/packages/studio/src/hooks/domSelectionTestHarness.ts b/packages/studio/src/hooks/domSelectionTestHarness.tsindex affd703311..c2b0bc9bd3 100644--- a/packages/studio/src/hooks/domSelectionTestHarness.ts+++ b/packages/studio/src/hooks/domSelectionTestHarness.ts@@ -12,6 +12,14 @@ export function installReactActEnvironment(): void {});}+export function withInlineLayoutBox<T extends HTMLElement>(el: T): T {+ Object.defineProperties(el, {+ offsetWidth: { get: () => Number.parseFloat(el.style.width) || 0 },+ offsetHeight: { get: () => Number.parseFloat(el.style.height) || 0 },+ });+ return el;+}+/** Mount a React element into a fresh detached host and return its root. */export function mountReactHarness(node: React.ReactElement): Root {const host = document.createElement("div");diff --git a/packages/studio/src/hooks/gsapEditOutcome.ts b/packages/studio/src/hooks/gsapEditOutcome.tsindex 72a4aa362e..487ce34cc5 100644--- a/packages/studio/src/hooks/gsapEditOutcome.ts+++ b/packages/studio/src/hooks/gsapEditOutcome.ts@@ -67,6 +67,12 @@ export function assertGsapEditPersisted(outcome: GsapEditOutcome): void {if (outcome.status === "blocked") throw new GsapEditBlockedError(outcome.reason, outcome.detail);}+/** A move only a shared tween positions is saved on the element itself; a blocked one throws. */+export async function saveMove(outcome: GsapEditOutcome, saveOnElement: () => Promise<void>) {+ if (outcome.status === "element-offset") return saveOnElement();+ assertGsapEditPersisted(outcome);+}+function assertGsapAnimationDirectlyEditable(animation: GsapAnimation): void {const editability = editabilityForProvenance(animation.provenance);if (editability === "unroll") throw new GsapEditBlockedError("unroll-required");diff --git a/packages/studio/src/hooks/gsapRuntimeKeyframes.test.ts b/packages/studio/src/hooks/gsapRuntimeKeyframes.test.tsindex 85bf8749f4..b09a326148 100644--- a/packages/studio/src/hooks/gsapRuntimeKeyframes.test.ts+++ b/packages/studio/src/hooks/gsapRuntimeKeyframes.test.ts@@ -167,6 +167,13 @@ describe("hasNonHoldTweenForElement — strict live-tween existence (drag stale-expect(hasNonHoldTweenForElement(fakeIframe(el, [liveTween]), "#puck-b")).toBe(true);});+ it("true when the tween sits in a later timeline (a soft reload re-adds main last)", () => {+ const iframe = fakeIframe(el, []);+ const win = iframe.contentWindow as unknown as { __timelines: Record<string, unknown> };+ win.__timelines.main = { getChildren: () => [liveTween] };+ expect(hasNonHoldTweenForElement(iframe, "#puck-b")).toBe(true);+ });+it("false when only a zero-duration hold/set remains (post delete-all)", () => {expect(hasNonHoldTweenForElement(fakeIframe(el, [holdSet]), "#puck-b")).toBe(false);});diff --git a/packages/studio/src/hooks/gsapRuntimeKeyframes.ts b/packages/studio/src/hooks/gsapRuntimeKeyframes.tsindex bbcfea0666..9f1bc35220 100644--- a/packages/studio/src/hooks/gsapRuntimeKeyframes.ts+++ b/packages/studio/src/hooks/gsapRuntimeKeyframes.ts@@ -200,7 +200,7 @@ function varsCarryChannel(vars: Record<string, unknown> | undefined, channels: s/*** Like `varsCarryChannel` but for a keyframe tween: the channels live inside the* keyframe steps (`vars.keyframes`), not as own props of `vars`. Handles the object- * form (`{ "0%": {...} }`) and the array form (`[{...}, ...]`).+ * form (`{ "0%": {...} }`), the array form (`[{...}, ...]`) and the object-of-arrays form.*/function keyframeVarsCarryChannel(vars: Record<string, unknown> | undefined,@@ -208,6 +208,8 @@ function keyframeVarsCarryChannel(): boolean {const kf = vars?.keyframes;if (!kf || typeof kf !== "object") return false;+ if (!Array.isArray(kf) && channels.some((ch) => Object.prototype.hasOwnProperty.call(kf, ch)))+ return true;const steps = Array.isArray(kf) ? kf : Object.values(kf);return steps.some((step) =>@@ -375,8 +377,9 @@ export function readRuntimeKeyframes(}/**- * Whether the live timeline has at least one NON-HOLD tween (non-zero duration,- * not the studio position-hold `set`) targeting `selector`. Stricter than a+ * Whether any live timeline has at least one NON-HOLD tween (non-zero duration,+ * not the studio position-hold `set`) targeting `selector`. Every timeline is read:+ * a soft reload re-adds the rebuilt composition's key last. Stricter than a* truthy `readRuntimeKeyframes`: that returns a flat read for any property-bearing* tween, so it can't distinguish a real animation from a leftover hold/marker.* The drag's stale-parse guard needs this exact distinction — after a delete-all@@ -387,37 +390,47 @@ export function readRuntimeKeyframes(* rotation/scale tween doesn't make a static position hold enter the keyframe* branch.*/-// fallow-ignore-next-line complexityexport function hasNonHoldTweenForElement(iframe: HTMLIFrameElement | null,selector: string,compositionId?: string,channels?: string[],): boolean {- const timelines = timelinesOf(iframe);- if (!timelines) return false;- const tlId =- compositionId ||- Object.keys(timelines).find((k) => typeof timelines[k]?.getChildren === "function");- if (!tlId) return false;- const timeline = timelines[tlId];- if (!timeline?.getChildren) return false;-let targetEl: Element | null = null;try {targetEl = iframe?.contentDocument?.querySelector(selector) ?? null;} catch {return false;}- if (!targetEl) return false;+ return !!targetEl && hasNonHoldTween(timelinesOf(iframe), targetEl, channels, compositionId);+}- // fallow-ignore-next-line code-duplication- for (const tween of timeline.getChildren(true)) {- if (!tween.vars || !matchesElement(tween, targetEl)) continue;- const dur = typeof tween.duration === "function" ? tween.duration() : 0;- if (isZeroDurationSet(dur)) continue; // skip hold/set tweens (see isZeroDurationSet)- const read = readTween(tween.vars);- if (read && (!channels || readCarriesChannel(read, channels))) return true;+/** `hasNonHoldTweenForElement` for an element in hand, read from its own window's timelines. */+export function elementHasNonHoldTween(el: Element, channels?: string[]): boolean {+ const win = el.ownerDocument.defaultView as {+ __timelines?: Record<string, RuntimeTimeline>;+ } | null;+ return hasNonHoldTween(win?.__timelines ?? null, el, channels);+}++// fallow-ignore-next-line complexity+function hasNonHoldTween(+ timelines: Record<string, RuntimeTimeline> | null,+ targetEl: Element,+ channels?: string[],+ compositionId?: string,+): boolean {+ if (!timelines) return false;+ for (const tlId of compositionId ? [compositionId] : Object.keys(timelines)) {+ // fallow-ignore-next-line code-duplication+ for (const tween of timelines[tlId]?.getChildren?.(true) ?? []) {+ if (!tween.vars || !matchesElement(tween, targetEl)) continue;+ const dur = typeof tween.duration === "function" ? tween.duration() : 0;+ if (isZeroDurationSet(dur)) continue; // skip hold/set tweens (see isZeroDurationSet)+ if (channels && keyframeVarsCarryChannel(tween.vars, channels)) return true;+ const read = readTween(tween.vars);+ if (read && (!channels || readCarriesChannel(read, channels))) return true;+ }}return false;}diff --git a/packages/studio/src/hooks/useAnimatedPropertyCommit.test.tsx b/packages/studio/src/hooks/useAnimatedPropertyCommit.test.tsxindex e664db4900..74c9217dc0 100644--- a/packages/studio/src/hooks/useAnimatedPropertyCommit.test.tsx+++ b/packages/studio/src/hooks/useAnimatedPropertyCommit.test.tsx@@ -6,7 +6,9 @@ import type { GsapAnimation } from "@hyperframes/core/gsap-parser";import type { DomEditSelection } from "../components/editor/domEditingTypes";import { usePlayerStore } from "../player/store/playerStore";import { useAnimatedPropertyCommit } from "./useAnimatedPropertyCommit";-import { mountReactHarness } from "./domSelectionTestHarness";+import { mountReactHarness, withInlineLayoutBox } from "./domSelectionTestHarness";+import { writeSizeWithCrop } from "../components/editor/cropResize";+import type { CommitMutation } from "./gsapScriptCommitTypes";(globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT: boolean }).IS_REACT_ACT_ENVIRONMENT = true;@@ -362,3 +364,40 @@ describe("commitStaticSet group routing", () => {act(() => root.unmount());});});++describe("useAnimatedPropertyCommit — a size write and its crop are one undo step", () => {+ it.each([[{ width: 450 }], [{ x: 10, width: 450 }]])("%o on a static element", async (props) => {+ const element = withInlineLayoutBox(document.createElement("div"));+ element.id = "box";+ element.style.cssText = "width: 300px; height: 200px; clip-path: inset(0px 60px 0px 0px)";+ document.body.append(element);+ const sel = { ...selection, element } as DomEditSelection;+ const keys: unknown[] = [];+ const land = async (options: { coalesceKey?: string }) => {+ keys.push(options.coalesceKey);+ element.style.width = "450px";+ };+ const mutation: CommitMutation = (_s, _m, options) => land(options);+ mutation.batch = (_calls, options) => land(options);+ let raw!: ReturnType<typeof useAnimatedPropertyCommit>["commitAnimatedProperties"];+ function Harness() {+ raw = useAnimatedPropertyCommit({+ selectedGsapAnimations: [],+ gsapCommitMutation: mutation,+ addGsapAnimation: vi.fn(),+ convertToKeyframes: vi.fn(),+ previewIframeRef: { current: null },+ bumpGsapCache: vi.fn(),+ }).commitAnimatedProperties;+ return null;+ }+ const root = mountReactHarness(<Harness />);+ const patch = vi.fn().mockResolvedValue(undefined);+ await writeSizeWithCrop(sel, props, mutation, patch, (keyed) => raw(sel, props, keyed));++ const cropKey = patch.mock.calls[0]![2].coalesceKey;+ expect(patch.mock.calls[0]![1][0]).toMatchObject({ value: "inset(0px 90px 0px 0px)" });+ expect(keys).toEqual([cropKey]);+ act(() => root.unmount());+ });+});diff --git a/packages/studio/src/hooks/useAnimatedPropertyCommit.ts b/packages/studio/src/hooks/useAnimatedPropertyCommit.tsindex 177d8c5c5d..254474be6f 100644--- a/packages/studio/src/hooks/useAnimatedPropertyCommit.ts+++ b/packages/studio/src/hooks/useAnimatedPropertyCommit.ts@@ -431,8 +431,12 @@ export function useAnimatedPropertyCommit(deps: CommitAnimatedPropertyDeps) {const commitAnimatedProperties = useCallback(// This is the single routing boundary for set, keyframe, whole-tween, and first-group writes.// fallow-ignore-next-line complexity- async (selection: DomEditSelection, props: Record<string, number | string>): Promise<void> => {- if (!gsapCommitMutation) return;+ async (+ selection: DomEditSelection,+ props: Record<string, number | string>,+ commit: CommitMutation | null = gsapCommitMutation,+ ): Promise<void> => {+ if (!commit) return;const propEntries = Object.entries(props);if (propEntries.length === 0) return;const primaryProp = propEntries[0]![0];@@ -490,7 +494,7 @@ export function useAnimatedPropertyCommit(deps: CommitAnimatedPropertyDeps) {),pct,iframe,- { commitMutation: gsapCommitMutation },+ { commitMutation: commit },`Edit ${primaryProp} (whole animation)`,);return;@@ -503,7 +507,7 @@ export function useAnimatedPropertyCommit(deps: CommitAnimatedPropertyDeps) {primaryProp,selector,iframe,- gsapCommitMutation,+ commit,);return;}@@ -515,13 +519,7 @@ export function useAnimatedPropertyCommit(deps: CommitAnimatedPropertyDeps) {// must update the position set AND create a size set atomically rather// than contaminating the first set with a foreign property group.if (!elementHasKeyframes) {- await commitStaticSet(- selection,- propEntries,- selector,- selectedGsapAnimations,- gsapCommitMutation,- );+ await commitStaticSet(selection, propEntries, selector, selectedGsapAnimations, commit);return;}@@ -534,7 +532,7 @@ export function useAnimatedPropertyCommit(deps: CommitAnimatedPropertyDeps) {propEntries,selector,selectedGsapAnimations,- gsapCommitMutation,+ commit,);return;}@@ -566,7 +564,7 @@ export function useAnimatedPropertyCommit(deps: CommitAnimatedPropertyDeps) {{ percentage: 0, properties: { ...newProps, _auto: 1 } },{ percentage: pct, properties: newProps },];- await gsapCommitMutation(+ await commit(selection,{type: "add-with-keyframes",diff --git a/packages/studio/src/hooks/useCropOverlay.ts b/packages/studio/src/hooks/useCropOverlay.tsindex 77e5a3b266..2563b33ce5 100644--- a/packages/studio/src/hooks/useCropOverlay.ts+++ b/packages/studio/src/hooks/useCropOverlay.ts@@ -1,6 +1,9 @@import type { OverlayRect } from "../components/editor/domEditOverlayGeometry";import type { DomEditSelection } from "../components/editor/domEditing";-import { readElementCropInsets } from "../components/editor/domEditOverlayCrop";+import {+ isElementCropLifted,+ readElementCropInsets,+} from "../components/editor/domEditOverlayCrop";/** Selection-box crop hug: the outline that makes the selection box hug the* element's committed inset crop. Crop is always-on (no mode) — the draggable@@ -13,7 +16,10 @@ export function useCropOverlay(params: {}) {const { selection, overlayRect } = params;- const cropInsets = selection ? readElementCropInsets(selection.element) : null;+ const cropInsets =+ selection && !isElementCropLifted(selection.element)+ ? readElementCropInsets(selection.element)+ : null;const hasCropInsets = Boolean(cropInsets &&(cropInsets.top > 0 || cropInsets.right > 0 || cropInsets.bottom > 0 || cropInsets.left > 0),diff --git a/packages/studio/src/hooks/useDomEditCommits.ts b/packages/studio/src/hooks/useDomEditCommits.tsindex fdff1119d4..eacf065279 100644--- a/packages/studio/src/hooks/useDomEditCommits.ts+++ b/packages/studio/src/hooks/useDomEditCommits.ts@@ -314,6 +314,7 @@ export function useDomEditCommits({handleDomAddTextField,handleDomRemoveTextField,stageElementPositionOffset,+ commitPositionPatchToHtml,handleDomPathOffsetCommit,handleDomBoxSizeCommit,handleDomRotationCommit,diff --git a/packages/studio/src/hooks/useDomEditPositionPatchCommit.ts b/packages/studio/src/hooks/useDomEditPositionPatchCommit.tsindex 1b8b4aaa12..73728061df 100644--- a/packages/studio/src/hooks/useDomEditPositionPatchCommit.ts+++ b/packages/studio/src/hooks/useDomEditPositionPatchCommit.ts@@ -12,12 +12,12 @@ interface UseDomEditPositionPatchCommitParams {showToast: (message: string, tone?: "error" | "info") => void;}-interface PositionPatchOptions {+type PositionPatchOptions = {label: string;coalesceKey: string;coalesceMs?: number;skipRefresh?: boolean;-}+};export function useDomEditPositionPatchCommit({activeCompPath,diff --git a/packages/studio/src/hooks/useDomEditSession.ts b/packages/studio/src/hooks/useDomEditSession.tsindex 2d1d48ae7d..367b7566fd 100644--- a/packages/studio/src/hooks/useDomEditSession.ts+++ b/packages/studio/src/hooks/useDomEditSession.ts@@ -230,6 +230,7 @@ export function useDomEditSession({handleDomAddTextField,handleDomRemoveTextField,stageElementPositionOffset,+ commitPositionPatchToHtml,handleDomBoxSizeCommit,handleDomManualEditsReset,handleDomEditElementsDelete,@@ -490,6 +491,7 @@ export function useDomEditSession({trackGsapInteractionFailure,stageElementPositionOffset,handleDomBoxSizeCommit,+ commitPositionPatchToHtml,addGsapAnimation,convertToKeyframes,setArcPath,diff --git a/packages/studio/src/hooks/useDomGeometryCommit.ts b/packages/studio/src/hooks/useDomGeometryCommit.tsindex 39853af316..a40b36d405 100644--- a/packages/studio/src/hooks/useDomGeometryCommit.ts+++ b/packages/studio/src/hooks/useDomGeometryCommit.ts@@ -136,6 +136,7 @@ export function useDomGeometryCommit({trackGsapInteractionFailure,stageElementPositionOffset,handleDomBoxSizeCommit: noDomBoxSizeRoute,+ commitPositionPatchToHtml: commitWithFreshQueue,addGsapAnimation: gsap.addGsapAnimation,convertToKeyframes: gsap.convertToKeyframes,setArcPath: gsap.setArcPath,diff --git a/packages/studio/src/hooks/useDomGeometryCommits.test.tsx b/packages/studio/src/hooks/useDomGeometryCommits.test.tsxindex 5f5c9e6a71..9f39635ad4 100644--- a/packages/studio/src/hooks/useDomGeometryCommits.test.tsx+++ b/packages/studio/src/hooks/useDomGeometryCommits.test.tsx@@ -13,6 +13,8 @@ import {readStudioRotation,} from "../components/editor/manualEdits";import { useDomGeometryCommits, type UseDomGeometryCommitsParams } from "./useDomGeometryCommits";+import { DomEditCropHandles } from "../components/editor/DomEditCropHandles";+import { withInlineLayoutBox } from "./domSelectionTestHarness";(globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT: boolean }).IS_REACT_ACT_ENVIRONMENT = true;@@ -170,3 +172,113 @@ describe("useDomGeometryCommits element position offset", () => {unmount();});});++describe("useDomGeometryCommits resize of a cropped element", () => {+ it("saves the crop scaled per axis with the box in the resize's own commit", async () => {+ const element = withInlineLayoutBox(document.createElement("div"));+ element.id = "cropped";+ element.style.cssText = "width: 300px; height: 200px; clip-path: inset(8px 60px 16px 30px)";+ document.body.append(element);+ const selection = {+ id: "cropped",+ selector: "#cropped",+ element,+ } as unknown as DomEditSelection;+ const commitPositionPatchToHtml = vi+ .fn<UseDomGeometryCommitsParams["commitPositionPatchToHtml"]>()+ .mockResolvedValue(undefined);+ const { commits, unmount } = mountCommits(commitPositionPatchToHtml);+ const rect = { left: 0, top: 0, width: 300, height: 200, editScaleX: 1, editScaleY: 1 };+ const host = document.createElement("div");+ const crop = createRoot(host);+ act(() =>+ crop.render(+ <DomEditCropHandles selection={selection} overlayRect={rect} onStyleCommit={vi.fn()} />,+ ),+ );++ await commits().handleDomBoxSizeCommit(selection, { width: 450, height: 250 });++ const scaled = "inset(10px 90px 20px 45px)";+ expect(commitPositionPatchToHtml).toHaveBeenCalledTimes(1);+ expect(commitPositionPatchToHtml.mock.calls[0]![1]).toContainEqual({+ type: "inline-style",+ property: "clip-path",+ value: scaled,+ });+ act(() => crop.unmount());+ expect(element.style.getPropertyValue("clip-path")).toBe(scaled);+ unmount();+ });++ function mountCroppedSelection(id: string, authored: string) {+ const element = withInlineLayoutBox(document.createElement("div"));+ element.id = id;+ element.style.cssText = authored;+ document.body.append(element);+ const selection = { id, selector: `#${id}`, element } as unknown as DomEditSelection;+ const commitPositionPatchToHtml = vi+ .fn<UseDomGeometryCommitsParams["commitPositionPatchToHtml"]>()+ .mockResolvedValue(undefined);+ const mounted = mountCommits(commitPositionPatchToHtml);+ const onStyleCommit = vi.fn((property: string, value: string) => {+ element.style.setProperty(property, value);+ });+ const rect = { left: 0, top: 0, width: 300, height: 200, editScaleX: 1, editScaleY: 1 };+ const crop = createRoot(document.body.appendChild(document.createElement("div")));+ const draw = () =>+ act(() =>+ crop.render(+ <DomEditCropHandles+ selection={selection}+ overlayRect={rect}+ onStyleCommit={onStyleCommit}+ />,+ ),+ );+ draw();+ const dragRightEdge = (by: number) => {+ const handle = document.querySelector<HTMLButtonElement>('[aria-label="Crop right"]')!;+ const press = (type: string, clientX: number) =>+ act(() =>+ handle.dispatchEvent(new PointerEvent(type, { bubbles: true, pointerId: 3, clientX })),+ );+ press("pointerdown", 100);+ press("pointermove", 100 - by);+ press("pointerup", 100 - by);+ };+ const resize = () =>+ mounted.commits().handleDomBoxSizeCommit(selection, { width: 450, height: 300 });+ const done = () => {+ act(() => crop.unmount());+ mounted.unmount();+ };+ return { element, onStyleCommit, draw, dragRightEdge, resize, done };+ }++ it("after an undo while still selected, the next crop drag starts from the undone crop", async () => {+ const authored = "width: 300px; height: 200px; clip-path: inset(0px 60px 0px 0px)";+ const h = mountCroppedSelection("undone", authored);+ await h.resize();+ // Undo writes the file's style attribute back onto the same live element.+ h.element.setAttribute("style", authored);+ h.draw();+ h.dragRightEdge(20);++ expect(h.onStyleCommit).toHaveBeenCalledWith("clip-path", "inset(0px 80px 0px 0px)");+ h.done();+ expect(h.element.style.getPropertyValue("clip-path")).toBe("inset(0px 80px 0px 0px)");+ });++ it("a crop drag right after a resize, with no render between, starts from the scaled crop", async () => {+ const h = mountCroppedSelection(+ "resized",+ "width: 300px; height: 200px; clip-path: inset(0px 60px 0px 0px)",+ );+ await h.resize();+ h.dragRightEdge(20);++ expect(h.onStyleCommit).toHaveBeenCalledWith("clip-path", "inset(0px 110px 0px 0px)");+ h.done();+ });+});diff --git a/packages/studio/src/hooks/useDomGeometryCommits.ts b/packages/studio/src/hooks/useDomGeometryCommits.tsindex 8fefd3f63e..e358ddcaa6 100644--- a/packages/studio/src/hooks/useDomGeometryCommits.ts+++ b/packages/studio/src/hooks/useDomGeometryCommits.ts@@ -15,6 +15,7 @@ import {clearStudioRotation,} from "../components/editor/manualEdits";import { stageElementOffset } from "./elementOffsetStager";+import { prepareCropResize } from "../components/editor/cropResize";import {buildPathOffsetPatches,buildBoxSizePatches,@@ -103,7 +104,9 @@ export function useDomGeometryCommits({if (gsapFallback) return gsapFallback;const beforeSize = captureStudioBoxSize(selection.element);const beforeOffset = offset ? captureStudioPathOffset(selection.element) : null;+ const stageCrop = prepareCropResize(selection.element);applyStudioBoxSize(selection.element, next);+ const crop = stageCrop();// Anchored-corner resize (NW/NE/SW) also moves the element to keep the// opposite corner fixed. Apply the offset and emit BOTH patch sets in a// SINGLE commit: one persist = one undo entry, and there is no@@ -111,6 +114,7 @@ export function useDomGeometryCommits({// offset is not (that frame was the release "jump"). Both builders read// the already-mutated live element, so concatenation is safe.const patches = buildBoxSizePatches(selection.element);+ if (crop) patches.push(crop.patch);if (offset) {applyStudioPathOffset(selection.element, offset);patches.push(...buildPathOffsetPatches(selection.element));@@ -121,6 +125,7 @@ export function useDomGeometryCommits({}).catch((error) => {restoreStudioBoxSize(selection.element, beforeSize);if (beforeOffset) restoreStudioPathOffset(selection.element, beforeOffset);+ crop?.revert();throw error;});},diff --git a/packages/studio/src/hooks/useGsapAwareEditing.test.tsx b/packages/studio/src/hooks/useGsapAwareEditing.test.tsxindex 3866109387..9ac5e9fe96 100644--- a/packages/studio/src/hooks/useGsapAwareEditing.test.tsx+++ b/packages/studio/src/hooks/useGsapAwareEditing.test.tsx@@ -1,11 +1,13 @@// @vitest-environment happy-domimport React, { act } from "react";-import { afterEach, describe, expect, it, vi } from "vitest";+import { afterEach, describe, expect, it, vi, type Mock } from "vitest";import type { GsapAnimation } from "@hyperframes/core/gsap-parser";import type { DomEditSelection } from "../components/editor/domEditingTypes";import type { DomEditGroupPathOffsetCommit } from "../components/editor/DomEditOverlay";-import { mountReactHarness } from "./domSelectionTestHarness";+import { mountReactHarness, withInlineLayoutBox } from "./domSelectionTestHarness";+import { DomEditCropHandles } from "../components/editor/DomEditCropHandles";+import { applyStudioBoxSizeDraft } from "../components/editor/manualEdits";(globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT: boolean }).IS_REACT_ACT_ENVIRONMENT = true;@@ -56,6 +58,7 @@ function mountResizeHandler(const anchorRollback = vi.fn();const elementOffset = vi.fn(() => ({ save: anchorSave, rollback: anchorRollback }));const commitMutation = vi.fn().mockResolvedValue(undefined);+ const commitPatch = vi.fn().mockResolvedValue(undefined);let resize:| ((selection: DomEditSelection,@@ -64,8 +67,9 @@ function mountResizeHandler(restore?: () => void,) => Promise<void>)| null = null;+ let property: ReturnType<typeof useGsapAwareEditing>["commitAnimatedProperty"] | null = null;function Harness() {- resize = useGsapAwareEditing({+ const editing = useGsapAwareEditing({domEditSelection: selection,selectedGsapAnimations: animations,gsapCommitMutation: commitMutation,@@ -76,11 +80,14 @@ function mountResizeHandler(trackGsapInteractionFailure: vi.fn(),stageElementPositionOffset: elementOffset,handleDomBoxSizeCommit: fallback,+ commitPositionPatchToHtml: commitPatch,addGsapAnimation: vi.fn(),convertToKeyframes: vi.fn(),setArcPath: vi.fn(),updateArcSegment: vi.fn(),- }).handleGsapAwareBoxSizeCommit;+ });+ resize = editing.handleGsapAwareBoxSizeCommit;+ property = editing.commitAnimatedProperty;return null;}const root = mountReactHarness(<Harness />);@@ -91,7 +98,9 @@ function mountResizeHandler(anchorSave,anchorRollback,commitMutation,+ commitPatch,resize: resize!,+ property: property!,root,};}@@ -122,6 +131,7 @@ function mountGroupHandler({trackGsapInteractionFailure,stageElementPositionOffset,handleDomBoxSizeCommit: vi.fn(),+ commitPositionPatchToHtml: vi.fn(),addGsapAnimation: vi.fn(),convertToKeyframes: vi.fn(),setArcPath: vi.fn(),@@ -257,6 +267,92 @@ describe("useGsapAwareEditing anchored resize", () => {act(() => h.root.unmount());});+ function mountCropped() {+ const h = mountResizeHandler([]);+ const el = withInlineLayoutBox(h.selection.element);+ el.id = "clip";+ el.style.cssText = "width: 300px; height: 200px; clip-path: inset(0px 60px 0px 0px)";+ document.body.append(el);+ const rect = { left: 0, top: 0, width: 300, height: 200, editScaleX: 1, editScaleY: 1 };+ const crop = mountReactHarness(+ <DomEditCropHandles selection={h.selection} overlayRect={rect} onStyleCommit={vi.fn()} />,+ );+ return { ...h, el, crop };+ }++ function resizeLandsWhen(where: "intercept" | "dispatch", h: { commitMutation: Mock }) {+ const land = (el: HTMLElement) => {+ el.style.width = "450px";+ el.style.height = "300px";+ };+ mocks.resize.mockImplementation(async (selection, _next, _a, _i, commit) => {+ if (where === "intercept") land(selection.element);+ await commit(selection, { type: "size" }, { label: "Resize", softReload: true });+ return { status: "persisted" };+ });+ if (where === "dispatch") h.commitMutation.mockImplementation(async (s) => land(s.element));+ }++ const scaled = "inset(0px 90px 0px 0px)";++ it("saves the crop scaled with a size that lands only when saved (the W/H fields)", async () => {+ const h = mountCropped();+ resizeLandsWhen("dispatch", h);+ await act(() => h.resize(h.selection, { width: 450, height: 300 }));++ expect(h.commitPatch).toHaveBeenCalledWith(+ h.selection,+ [{ type: "inline-style", property: "clip-path", value: scaled }],+ expect.objectContaining({ coalesceKey: h.commitMutation.mock.calls[0]![2].coalesceKey }),+ );+ act(() => h.crop.unmount());+ expect(h.el.style.getPropertyValue("clip-path")).toBe(scaled);+ act(() => h.root.unmount());+ });++ it("scales from the box before a draft its caller applied (the agent tool)", async () => {+ const h = mountCropped();+ resizeLandsWhen("intercept", h);+ applyStudioBoxSizeDraft(h.el, { width: 450, height: 300 });+ await act(() => h.resize(h.selection, { width: 450, height: 300 }));++ expect(h.commitPatch.mock.calls[0]![1]).toEqual([+ { type: "inline-style", property: "clip-path", value: scaled },+ ]);+ act(() => h.crop.unmount());+ act(() => h.root.unmount());+ });++ it("a W field on an animated element saves the scaled crop in the same undo step", async () => {+ const h = mountCropped();+ mocks.commitAnimatedProperties.mockImplementation(async (selection, _props, keyed) => {+ await (keyed ?? h.commitMutation)(selection, { type: "set" }, { label: "Edit width" });+ selection.element.style.width = "450px";+ });+ await act(() => h.property(h.selection, "width", 450));++ const key = h.commitMutation.mock.calls[0]![2].coalesceKey;+ expect(key).toBeTruthy();+ expect(h.commitPatch).toHaveBeenCalledWith(+ h.selection,+ [{ type: "inline-style", property: "clip-path", value: "inset(0px 90px 0px 0px)" }],+ expect.objectContaining({ coalesceKey: key }),+ );+ act(() => h.crop.unmount());+ act(() => h.root.unmount());+ });++ it("shows the scaled crop when deselected before the save lands", async () => {+ const h = mountCropped();+ resizeLandsWhen("intercept", h);+ const saved = h.resize(h.selection, { width: 450, height: 300 });+ act(() => h.crop.unmount());+ await act(() => saved);++ expect(h.el.style.getPropertyValue("clip-path")).toBe(scaled);+ act(() => h.root.unmount());+ });+it("does not keep the anchor move when the size save fails", async () => {resizeWritesSize();const h = mountResizeHandler([]);diff --git a/packages/studio/src/hooks/useGsapAwareEditing.ts b/packages/studio/src/hooks/useGsapAwareEditing.tsindex 4f294423c5..5cbc734146 100644--- a/packages/studio/src/hooks/useGsapAwareEditing.ts+++ b/packages/studio/src/hooks/useGsapAwareEditing.ts@@ -34,14 +34,14 @@ import { logResize, logResizeSettle } from "../utils/resizeDebug";import type { DomEditGroupPathOffsetCommit } from "../components/editor/DomEditOverlay";import { runGestureTransaction } from "./gestureTransaction";import { hasNonHoldTweenForElement } from "./gsapRuntimeKeyframes";-import { assertGsapEditPersisted, type GsapEditOutcome } from "./gsapEditOutcome";+import { assertGsapEditPersisted, saveMove } from "./gsapEditOutcome";import type { GsapAnimationFetchOptions } from "./useGsapAnimationFetchFallback";--/** A move only a shared tween positions is saved on the element itself; a blocked one throws. */-async function saveMove(outcome: GsapEditOutcome, saveOnElement: () => Promise<void>) {- if (outcome.status === "element-offset") return saveOnElement();- assertGsapEditPersisted(outcome);-}+import type { ElementOffsetStagerDeps } from "./elementOffsetStager";+import {+ prepareCropResize,+ saveCropResize,+ writeSizeWithCrop,+} from "../components/editor/cropResize";// Distinct coalesceKey per group drag so consecutive group drags don't fold// into one another's undo entry (module-local counter, not Date.now()).@@ -87,6 +87,7 @@ export interface UseGsapAwareEditingParams {next: { width: number; height: number },offset?: { x: number; y: number },) => Promise<void>;+ commitPositionPatchToHtml: ElementOffsetStagerDeps["commitPositionPatchToHtml"];// GSAP script commit ops (from useGsapScriptCommits)addGsapAnimation: (sel: DomEditSelection,@@ -130,6 +131,7 @@ export function useGsapAwareEditing({trackGsapInteractionFailure,stageElementPositionOffset,handleDomBoxSizeCommit,+ commitPositionPatchToHtml,addGsapAnimation,convertToKeyframes,setArcPath,@@ -353,6 +355,8 @@ export function useGsapAwareEditing({animGroups: targetAnimations.map((a) => `${a.propertyGroup}:${a.method}`),});let anchorMove: ReturnType<typeof stageElementPositionOffset> | null = null;+ const stageCrop = prepareCropResize(selection.element);+ let cropUndoKey: string | null = null;return runGestureTransaction({element: selection.element,label: "Resize layer",@@ -381,6 +385,7 @@ export function useGsapAwareEditing({makeFetchFallback(selection),);assertGsapEditPersisted(outcome);+ cropUndoKey = coalesceKey;// What the resize actually did, not what its animations suggest// it would do. An element whose scale is an instant hold has a// scale-group tween and still commits width/height, so guessing@@ -424,7 +429,13 @@ export function useGsapAwareEditing({logResizeSettle(selection.element, "dom-route");await handleDomBoxSizeCommit(selection, next, offset);},- afterBufferedCommitsSaved: () => anchorMove?.save() ?? Promise.resolve(),+ afterBufferedCommitsSaved: async () => {+ await anchorMove?.save();+ // Only now is the size live for every caller, drag or not.+ if (cropUndoKey) {+ await saveCropResize(stageCrop, selection, commitPositionPatchToHtml, cropUndoKey);+ }+ },restore: () => {anchorMove?.rollback();restore();@@ -434,6 +445,7 @@ export function useGsapAwareEditing({},[handleDomBoxSizeCommit,+ commitPositionPatchToHtml,stageElementPositionOffset,gsapCommitMutation,previewIframeRef,@@ -481,10 +493,7 @@ export function useGsapAwareEditing({// ── Animated property commit ──- const {- commitAnimatedProperty: commitAnimatedPropertyRaw,- commitAnimatedProperties: commitAnimatedPropertiesRaw,- } = useAnimatedPropertyCommit({+ const { commitAnimatedProperties: commitAnimatedPropertiesRaw } = useAnimatedPropertyCommit({selectedGsapAnimations,gsapCommitMutation,addGsapAnimation: (sel, method, time) => addGsapAnimation(sel, method, time),@@ -496,25 +505,30 @@ export function useGsapAwareEditing({const commitAnimatedProperties = useCallback(async (selection: DomEditSelection, properties: Record<string, number | string>) => {try {- await commitAnimatedPropertiesRaw(selection, properties);+ await writeSizeWithCrop(+ selection,+ properties,+ gsapCommitMutation,+ commitPositionPatchToHtml,+ (keyed) => commitAnimatedPropertiesRaw(selection, properties, keyed),+ );} catch (error) {trackGsapInteractionFailure(error, selection, "property", "Edit animated property");throw error;}},- [commitAnimatedPropertiesRaw, trackGsapInteractionFailure],+ [+ commitAnimatedPropertiesRaw,+ commitPositionPatchToHtml,+ gsapCommitMutation,+ trackGsapInteractionFailure,+ ],);const commitAnimatedProperty = useCallback(- async (selection: DomEditSelection, property: string, value: number | string) => {- try {- await commitAnimatedPropertyRaw(selection, property, value);- } catch (error) {- trackGsapInteractionFailure(error, selection, "property", "Edit animated property");- throw error;- }- },- [commitAnimatedPropertyRaw, trackGsapInteractionFailure],+ (selection: DomEditSelection, property: string, value: number | string) =>+ commitAnimatedProperties(selection, { [property]: value }),+ [commitAnimatedProperties],);// ── Arc path wrappers ──