fix(studio): an undo that lands mid-drag keeps the box under the pointer

[miguel-heygen]

What changes

Dragging a layer right after Cmd+Z no longer flashes it back to where the undo put it. The box stays under the pointer through the moment the undo lands, and the drop saves where you let go, on top of the undone file.

Before, if the previous edit's save was still pending when you pressed Cmd+Z, the undo only showed up once that save and the server's history step finished. If you had grabbed the layer by then, the undo copied every attribute of the restored file onto it, which wiped the translate the drag was drawing. For a frame, or for as long as the pointer stayed still, the box sat where the undo put it, the undone move's distance away from the pointer.

How

syncElementAttributes (gsapUndoRestore.ts) is how every in-place restore writes a restored element onto the live one. It now also takes the element as the file being replaced had it. When the live element carries the manual-edit gesture mark (data-hf-studio-manual-edit-gesture), the merge keeps:

• the inline-style properties that gesture draws, whatever their value, so a press that hasn't moved yet keeps its spot;
• every other attribute and inline-style property whose live value differs from the replaced file, which the gesture changed since;
• for a move or resize, the record of the author's translate (data-hf-studio-original-inline-translate), so the drag's next write doesn't record its own draft as the author's.

Everything else restores as before, and a layer without the gesture mark is restored exactly as before.

What each gesture draws has one owner, next to the gesture mark in manualEditsDom.ts:

• a move draws translate and the offset variables;

• a resize draws those plus the box-size properties (BOX_SIZE_STYLE_PROPS);

• a rotate draws rotate, transform, transform-origin, display and the rotation variable.

• an edit (the inline text edit) draws nothing, so under its mark only what changed since the replaced file stays.

beginStudioManualEditGesture requires the kind, so a new caller has to say what it draws. The mark's value carries the kind.

Every live copy in the restore goes through the merge:

• applyUndoRestoreToPreview;
• showRestoreInPlace, and its put-back, which uses the restore it showed as the base;
• the edit-mark sync after a GSAP script re-run (syncStaleEditMarks).

This removes the jump once the undo lands. Painting the undo at once while the previous save is still pending is a separate change.

Tests

gsapUndoRestore.test.ts, "an undo that lands while the layer is being dragged". Each fails with its piece of the fix reverted:

• "keeps the translate the drag is drawing and reverts the rest": the drag's translate and gesture mark stay; the undone width and data-start go back. It fails without the merge.
• "keeps the box where it is when the press has not moved it yet": it fails when only values that differ from the file are kept, as at this PR's first head.
• "keeps the drag's translate when the undo is shown in place", and "keeps a drag that started after the undo was shown when the undo is put back": each fails without its base.
• "keeps the drag's translate when the undo re-runs a GSAP script": it fails if the edit-mark sync copies without the base.
• "saves the drop onto the undone file, the same bytes as dragging the undone layer": the final file after the drop. It fails without keeping the author's-translate record.
• "reverts the translate under a gesture that draws nothing, such as a text edit": it fails if the edit kind keeps the move's channels.
• "restores a layer no gesture is drawing exactly as before": this test, and the existing "drops the size marks a resize left on the live element", fail if the merge also applies without the gesture mark.

Edit accuracy rows

The 6 drag, undo, drag cases (sequndo, gsap none) from the edit accuracy bench in #4801, 3 runs each, at this PR's first head. Both builds use the same bench, 2 jobs. Each row shows the worst teleport, in px.

case	main, run 1 / 2 / 3	this branch, run 1 / 2 / 3
px root	312.4 / 312.4 / 0	0 / 0 / 0
px nested	304.4 / 304.4 / 0	0 / 0 / 0
pct root	0 / 0 / 0	0 / 0 / 0
pct nested	304.4 / 0 / 0	0 / 0 / 0
center root	0 / 0 / 301.2	0 / 0 / 0
center nested	0 / 304.4 / 0	0 / 0 / 0
failing	6 of 18	0 of 18

The PR also takes 5 of the 6 cases out of the bench's QUARANTINED list (ratchet.mjs), where #4801 parked them for this fix, and banks them from this branch's CI gate artifact, byte for byte. In that gate, all 5 pass with no case unstable; 3 were newly passing, and the other 2 were already banked as passing on main, because the race only failed some runs.

sequndo-none-px-r0-root-z100 stays quarantined, under the change that paints an undo at once (stacked on #4807). In one CI gate it passed 2 of 3 runs; the third had a press jump of 312.36 px. That matches the undo landing between the bench's read of the box and its press, which only painting the undo at once removes.

Before

Main. A layer dragged, Cmd+Z right away, then pressed and held where it still shows; the move's save is slowed by 1.5 s so the undo lands while it is held. When the undo lands, the layer drops back to where the undo put it, about 100 screen px from the pointer (the ring), and stays there while the pointer holds still.

After

The same steps on this branch. The undo lands ("Undid: Move layer") and the layer stays under the pointer. The drop saves translate: 202.139px 216.578px on top of the undone file, as on main.

[github-actions]

Edit accuracy: 846 passing here, 843 on the base branch

The gate passes.
Smoothness is reported in the artifact, not gated. A case fails only if it fails 2 of 3 runs.

Newly passing (3)

• sequndo-none-pct-r0-root-z100
• sequndo-none-pct-r0-nested-z100
• sequndo-none-center-r0-nested-z100

Quarantined, measured but not gated (2)

• sequndo-none-px-r0-root-z100 (fixed by part C (fix(studio): undo right after an edit undoes that edit, even before its save lands #4807 stack)): pass / pass / pass, passes
• seqrepeat-none-px-r0-nested-z100 (fixed by part C (fix(studio): undo right after an edit undoes that edit, even before its save lands #4807 stack)): pass / pass / pass, passes