@@ -524,6 +524,15 @@
       "packages/studio/src/components/editor/domEditOverlayStartGesture.test.ts",
       "packages/studio/src/components/editor/anchoredResizeCommitFeedsOffset.test.ts",
       "packages/studio/src/components/editor/rotateInlineSave.test.ts",
+      // Waiting-press and drag tests: each case spells out its own press, reload and release; a shared
+      // helper would hide the sequence each one asserts.
+      "packages/studio/src/components/editor/domEditOverlayStartGesture.blocked.test.ts",
+      "packages/studio/src/components/editor/dragUndoPaint.test.ts",
+      "packages/studio/src/components/editor/manualOffsetDrag.test.ts",
+      "packages/studio/src/components/editor/gestureHoldsPreviewReload.test.tsx",
+      // Preview reload tests: each case spells out its own mount, reload and swap sequence.
+      "packages/studio/src/player/hooks/useTimelinePlayer.shadowReload.test.ts",
+      "packages/studio/src/components/nle/NLEContext.test.ts",
       "packages/studio/src/hooks/useDomGeometryCommits.test.tsx",
       // extractionCache.test.ts: pre-existing parallel describe setup and publish-case arrange/assert blocks.
       "packages/engine/src/services/extractionCache.test.ts",
 
@@ -147,7 +147,7 @@ export interface HoldScope {
 const tweenSignature = (a: GsapAnimation) =>
   JSON.stringify([a.targetSelector, a.method, a.position, a.duration, a.properties, a.keyframes]);
 
-/** The tweens an edit touched (not in `previous`; none without it), and what the script's holds already pin. */
+/** The tweens an edit touched (not in `previous`; all without it), and what the script's holds already pin. */
 export function holdScope(
   before: readonly GsapAnimation[],
   previous: readonly GsapAnimation[] | null,
@@ -160,14 +160,14 @@ export function holdScope(
     held.set(a.targetSelector, props);
   }
   return {
-    touched: (a) => previous !== null && !kept.has(tweenSignature(a)),
+    touched: (a) => previous === null || !kept.has(tweenSignature(a)),
     held: (selector) => held.get(selector) ?? new Map(),
   };
 }
 
 /**
- * What a Studio hold pins from t=0: a keyframed tween's 0% position props before a later start, and the position and
- * size of a lone key (GSAP renders none) only where this edit made it or a hold already pins it, minus earlier tweens.
+ * What a Studio hold pins from t=0, only for a tween this edit touched or a hold already pins: the 0% position props
+ * before a later start, and the position and size of a lone key (GSAP renders none), minus earlier tweens.
  */
 export function keyframeHoldForAnimation(
   animation: GsapAnimation,
@@ -196,9 +196,10 @@ export function keyframeHoldForAnimation(
   // An untouched tween keeps only the hold it made: one with its own first value.
   const kept = (property: string, value: unknown) =>
     touched ? pinned.has(property) : pinned.get(property) === value;
+  const startsLate = start > 0.001;
   const pins = (group: PropertyGroupName, property: string, value: unknown) =>
-    (group === "position" && start > 0.001) ||
-    ((group === "position" || group === "size") && ((lone && touched) || kept(property, value)));
+    (group === "position" || group === "size") &&
+    (((lone || (group === "position" && startsLate)) && touched) || kept(property, value));
   const hold: Record<string, number> = {};
   for (const [property, value] of Object.entries(atStart.properties)) {
     if (!pins(classifyPropertyGroup(property), property, value) || typeof value !== "number")
 
@@ -1787,6 +1787,15 @@ describe("keyframe mutations", () => {
       expect((out2.match(/hf-hold/g) ?? []).length).toBe(1); // still just one
     });
 
+    it.each([
+      ["recast", syncPositionHoldsBeforeKeyframes],
+      ["acorn", syncPositionHoldsBeforeKeyframesAcorn],
+    ])("%s: an edit to another element pins no position on a tween it did not touch", (_, sync) => {
+      const before = `${posTweenAt(1.2)}\ntl.to("#q", { x: 10, duration: 1 }, 0);`;
+      const after = before.replace("x: 10", "x: 40");
+      expect(sync(after, before)).toBe(after);
+    });
+
     it("adds no hold for a tween that already starts at t=0", () => {
       expect(syncPositionHoldsBeforeKeyframes(posTweenAt(0))).not.toContain("hf-hold");
     });
 
@@ -2830,6 +2830,30 @@ ${authored}
     expect(result.after).toContain("tl.to(kicker,");
   });
 
+  it.each([
+    ["#b", false],
+    ["#p", true],
+  ])("shifting %s pins #p before its first key: %s", async (targetSelector, held) => {
+    const dir = createProjectDir();
+    writeHtml(
+      dir,
+      "index.html",
+      `<!DOCTYPE html><html><body><script data-hyperframes-gsap>
+const tl = gsap.timeline({ paused: true });
+tl.to("#p", { keyframes: { "0%": { x: -150 }, "100%": { x: 0 } }, duration: 2 }, 1.2);
+tl.to("#b", { duration: 1, x: 200 }, 2);
+</script></body></html>`,
+    );
+    const app = new Hono();
+    registerFileRoutes(app, createAdapter(dir));
+    const res = await app.request("http://localhost/projects/demo/gsap-mutations/index.html", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ type: "shift-positions", targetSelector, delta: 1 }),
+    });
+    expect(((await res.json()) as { after: string }).after.includes("hf-hold")).toBe(held);
+  });
+
   it("shift-positions-batch equals sequential single shifts (atomic multi-clip)", async () => {
     const TWO_TWEENS = `<!DOCTYPE html><html><body><script data-hyperframes-gsap>
 const tl = gsap.timeline({ paused: true });
 
@@ -1527,7 +1527,7 @@ function clipRetimeOf(mutation: GsapMutationRequest): RetimeSlot | null {
 function retimeRun(script: string, run: readonly RetimeSlot[], root: ParentNode | undefined) {
   const live = run.filter((slot): slot is ClipTweenRetime => slot !== "no-op");
   const retimed = retimeClipTweensInScript(script, live, root);
-  const synced = syncPositionHoldsBeforeKeyframes(retimed.script);
+  const synced = syncPositionHoldsBeforeKeyframes(retimed.script, script);
   let next = 0;
   const changed = run.map((slot) => slot !== "no-op" && retimed.changed[next++]!);
   if (synced !== retimed.script) changed[changed.length - 1] = true;
 
@@ -1,6 +1,6 @@
 import { useOwnPreviewIframe, usePreviewIframeStore } from "./player/store/previewIframeStore";
 import { buildProjectApiPath } from "./utils/projectRouting";
-import { useState, useCallback, useRef, useMemo } from "react";
+import { useState, useCallback, useRef, useMemo, type SetStateAction } from "react";
 import { useStableHandlers } from "./hooks/useStableHandlers";
 import { useHistoryFlags, useToolbarSession } from "./hooks/useShellSlices";
 import { useDismissingTabSetter, useRightPanelIntent } from "./hooks/useRightPanelIntents";
@@ -62,6 +62,7 @@ import { useStudioSessionStart } from "./hooks/useStudioSessionStart";
 import { useTimelineAddAtPlayhead } from "./hooks/useTimelineAddAtPlayhead";
 import { readStudioUrlStateFromWindow, resolveMasterCompositionPath } from "./utils/studioUrlState";
 import { useActiveComposition } from "./hooks/useActiveComposition";
+import { requestPreviewReload } from "./player/previewReloading";
 const getTimelineSelectionSet = () => usePlayerStore.getState().selectedElementIds;
 
 export interface StudioAppProps {
@@ -79,7 +80,7 @@ export function StudioApp({ readOnlyPreview = false, readOnlyPreviewReason }: St
   const [compIdToSrc, setCompIdToSrc] = useState<Map<string, string>>(new Map());
   const previewIframe = useOwnPreviewIframe();
   const [compositionLoading, setCompositionLoading] = useState(true);
-  const [refreshKey, setRefreshKey] = useState(0);
+  const [refreshKey, setRefreshKeyState] = useState(0);
   const [previewDocumentVersion, refreshPreviewDocumentVersion] = usePreviewDocumentVersion();
   const [blockPreview, setBlockPreview] = useState<BlockPreviewInfo | null>(null);
   const previewIframeRef = useRef<HTMLIFrameElement | null>(null);
@@ -104,7 +105,11 @@ export function StudioApp({ readOnlyPreview = false, readOnlyPreviewReason }: St
   const handleDomZIndexReorderCommitRef = useRef<TimelineZIndexReorderCommit | null>(null);
   const pendingTimelineEditPathRef = useRef(new Set<string>());
   const isGestureRecordingRef = useRef(false);
-  const reloadPreview = useCallback(() => setRefreshKey((k) => k + 1), []);
+  const setRefreshKey = useCallback((next: SetStateAction<number>) => {
+    requestPreviewReload();
+    setRefreshKeyState(next);
+  }, []);
+  const reloadPreview = useCallback(() => setRefreshKey((k) => k + 1), [setRefreshKey]);
   const fileManagerResult = useFileManager({
     projectId,
     showToast,
@@ -144,7 +149,7 @@ export function StudioApp({ readOnlyPreview = false, readOnlyPreviewReason }: St
     recordEdit: editHistory.recordEdit,
     previewIframeRef,
     activeCompPathRef,
-    reloadPreview: () => setRefreshKey((k) => k + 1),
+    reloadPreview,
   });
   const previewPersistence = useStableHandlers(previewPersistenceResult, projectId);
   const externalFileChanges = useStudioExternalFileChanges({
 
@@ -10,6 +10,7 @@ import { useZOrderCrossedFlash, ZOrderCrossedFlash } from "./useZOrderCrossedFla
 import { useCanvasContextMenuState } from "./useCanvasContextMenuState";
 import {
   type BlockedMoveState,
+  type WaitingPressState,
   type DomEditGroupPathOffsetCommit,
   type FocusableDomEditOverlay,
   type MoveCommitOptions,
@@ -166,6 +167,7 @@ export const DomEditOverlay = memo(function DomEditOverlay({
   const gestureRef = useRef<GestureState | null>(null);
   const groupGestureRef = useRef<GroupGestureState | null>(null);
   const blockedMoveRef = useRef<BlockedMoveState | null>(null);
+  const waitingPressRef = useRef<WaitingPressState | null>(null);
   const suppressNextBoxClickRef = useRef(false);
   const snapGuidesRef = useRef<SnapGuidesState | null>(null);
   const rafPausedRef = useRef(false);
@@ -273,6 +275,7 @@ export const DomEditOverlay = memo(function DomEditOverlay({
   });
 
   const gestures = createDomEditOverlayGestureHandlers({
+    activeCompositionPathRef,
     overlayRef,
     iframeRef,
     boxRef,
@@ -283,6 +286,7 @@ export const DomEditOverlay = memo(function DomEditOverlay({
     gestureRef,
     groupGestureRef,
     blockedMoveRef,
+    waitingPressRef,
     rafPausedRef,
     suppressNextBoxClickRef,
     setOverlayRect,
@@ -299,17 +303,17 @@ export const DomEditOverlay = memo(function DomEditOverlay({
   });
 
   useEffect(() => {
-    if (readOnly) gestures.clearPointerState(selectionRef);
+    if (readOnly) gestures.clearPointerState(selectionRef, true);
   }, [gestures, readOnly, selectionRef]);
   // A gesture that loses its pointer, the window or the overlay is cancelled, so its mark goes too.
-  const cancelGestureRef = useRef(() => {});
-  cancelGestureRef.current = () => gestures.clearPointerState(selectionRef);
+  const cancelGestureRef = useRef((_dropQueued?: boolean) => {});
+  cancelGestureRef.current = (dropQueued) => gestures.clearPointerState(selectionRef, dropQueued);
   useMountEffect(() => {
     const cancel = () => cancelGestureRef.current();
     window.addEventListener("blur", cancel);
     return () => {
       window.removeEventListener("blur", cancel);
-      cancel();
+      cancelGestureRef.current(true);
     };
   });
 
@@ -493,7 +497,7 @@ export const DomEditOverlay = memo(function DomEditOverlay({
       onPointerLeave={() => onCanvasPointerLeaveRef.current()}
       onPointerUp={marquee.onPointerUp}
       onPointerCancel={marquee.onPointerCancel}
-      onLostPointerCapture={() => cancelGestureRef.current()}
+      onLostPointerCapture={gestures.onLostPointerCapture}
       onContextMenu={hostInput ? undefined : handleContextMenu}
     >
       {!hostInput && hoverSelection && hoverRect && compRect.width > 0 && (