fix(studio): shift-click adds the element under the pointer, not the last one hovered

Shift-click read the hover cache and used it without checking what it described.
That cache is filled asynchronously as the pointer moves, so passing over one
element on the way to another leaves it naming the element you left. The
shift-click then added THAT element, and because the same branch prevented the
default and set the suppression flags, the mousedown path that would have
resolved the point correctly never ran. Multi-select looked like it grabbed
things at random, or like it did nothing.

Reproduced on the canvas with a trace: hover #card, shift-click #dot-b, and the
group gained #card. Same gesture after: the guard rejects the cache, the
mousedown path resolves the point, and the group gains #dot-b.

The cache is still used when it is provably about the point clicked, including
when it names a clip ancestor of the element there, so the fast path survives for
the common case of clicking straight at something.

Adds `hf-select-debug` (localStorage, off by default) recording which selection
branch ran and what it decided, and pulls the flag/format shared with
`hf-reload-debug` into one place rather than copying it.
This commit is contained in:
Miguel Angel Simon Sierra
2026-08-07 19:38:12 -07:00
parent 3d8216816a
commit 1b5f50d579
7 changed files with 143 additions and 21 deletions
@@ -14,7 +14,10 @@ import {
resolveDomEditRotationGesture,
} from "./DomEditOverlay";
import type { DomEditSelection } from "./domEditing";
import { resolveResizeCenterAnchorOffset } from "./domEditOverlayGestures";
import {
hoverCacheDescribesPoint,
resolveResizeCenterAnchorOffset,
} from "./domEditOverlayGestures";
// React 19 warns unless the test environment opts into act().
globalThis.IS_REACT_ACT_ENVIRONMENT = true;
@@ -628,6 +631,50 @@ describe("resolveDomEditRotationGesture", () => {
});
});
/**
* Shift-click reads the hover cache instead of hit-testing, and the cache is
* filled asynchronously as the pointer moves. Pass over one element on the way to
* another and the cache still names the one you left, so the shift-click added
* THAT element and the click looked like it selected something at random. The
* guard is what makes the cache usable only when it is about the point clicked.
*/
describe("hoverCacheDescribesPoint", () => {
const doc = new Window().document;
it("rejects a cache left behind by an element the pointer passed over", () => {
const passedOver = doc.createElement("div");
const clicked = doc.createElement("div");
doc.body.append(passedOver, clicked);
expect(hoverCacheDescribesPoint(passedOver, clicked)).toBe(false);
});
it("accepts the cache when it names the element at the point", () => {
const clicked = doc.createElement("div");
doc.body.append(clicked);
expect(hoverCacheDescribesPoint(clicked, clicked)).toBe(true);
});
// The resolver is allowed to hand back a clip ancestor of the raw target, which
// still describes the same click — rejecting it would drop the fast path on
// every element that has children.
it("accepts an ancestor of the element at the point", () => {
const clip = doc.createElement("div");
const child = doc.createElement("span");
clip.append(child);
doc.body.append(clip);
expect(hoverCacheDescribesPoint(clip, child)).toBe(true);
});
it("rejects a missing cache or an empty point", () => {
const el = doc.createElement("div");
expect(hoverCacheDescribesPoint(null, el)).toBe(false);
expect(hoverCacheDescribesPoint(el, null)).toBe(false);
});
});
// resolveResizeCenterAnchorOffset is the UNROTATED (AABB) fallback used only when
// the element's real transformed corners can't be measured. Center-anchored: a
// width/height change grows the box from its top-left, drifting the center by half
@@ -13,6 +13,7 @@ import {
type GestureState,
type GroupGestureState,
focusDomEditOverlayElement,
hoverCacheDescribesPoint,
} from "./domEditOverlayGestures";
import { useDomEditOverlayRects } from "./useDomEditOverlayRects";
import { ChildRectOutlines, OffCanvasIndicators, type OffCanvasRect } from "./OffCanvasIndicators";
@@ -44,6 +45,7 @@ export {
hasDomEditRotationChanged,
resolveDomEditRotationGesture,
} from "./domEditOverlayGestures";
import { logSelect } from "../../utils/selectDebug";
export type { DomEditGroupPathOffsetCommit } from "./domEditOverlayGestures";
interface DomEditOverlayProps {
@@ -322,6 +324,7 @@ export const DomEditOverlay = memo(function DomEditOverlay({
const handleOverlayMouseDown = (event: React.MouseEvent<HTMLDivElement>) => {
if (!allowCanvasMovement) return;
if (suppressNextOverlayMouseDownRef.current) {
logSelect("mousedown-suppressed", { shift: event.shiftKey });
suppressNextOverlayMouseDownRef.current = false;
suppressNextBoxMouseDownRef.current = false;
suppressNextBoxClickRef.current = false;
@@ -330,6 +333,10 @@ export const DomEditOverlay = memo(function DomEditOverlay({
return;
}
const target = event.target as HTMLElement | null;
logSelect("mousedown", {
shift: event.shiftKey,
onBox: Boolean(target?.closest('[data-dom-edit-selection-box="true"]')),
});
if (target?.closest('[data-dom-edit-selection-box="true"]')) return;
// Allow clicks anywhere on the overlay — GSAP-translated elements can
// extend beyond the composition rect into the gray zone, and users need
@@ -345,9 +352,31 @@ export const DomEditOverlay = memo(function DomEditOverlay({
const handleOverlayPointerDown = (event: React.PointerEvent<HTMLDivElement>) => {
if (!allowCanvasMovement || event.button !== 0) return;
if (event.shiftKey) {
// Use the already-updated hover selection rather than re-resolving async
// The hover selection is an ASYNC cache, so it can still describe whatever the
// pointer passed over on its way here. Reading it without checking is safe for
// a hover outline and wrong for a shift-click: the click silently adds THAT
// element instead of the one under the pointer, which reads as multi-select
// picking things at random. Confirm the cache is about this point with a
// synchronous hit-test; when it isn't, fall through untouched — no
// preventDefault, no suppression — so the mousedown path below resolves the
// point properly instead of this one guessing.
const candidate = hoverSelectionRef.current;
if (!candidate) return;
const shiftIframe = iframeRef.current;
const pointTarget = shiftIframe
? getPreviewTargetFromPointer(
shiftIframe,
event.clientX,
event.clientY,
activeCompositionPathRef.current,
)
: null;
const cacheIsAboutThisPoint = hoverCacheDescribesPoint(candidate?.element, pointTarget);
logSelect("shift-pointerdown", {
candidate: candidate?.selector ?? candidate?.id ?? null,
pointTarget: pointTarget?.id ?? pointTarget?.tagName ?? null,
cacheIsAboutThisPoint,
});
if (!candidate || !cacheIsAboutThisPoint) return;
event.preventDefault();
event.stopPropagation();
suppressNextOverlayMouseDownRef.current = true;
@@ -120,6 +120,25 @@ export function focusDomEditOverlayElement(element: FocusableDomEditOverlay | nu
* when the element's real transformed corners can't be measured — the primary path
* pins the measured center (rotation-safe) in useDomEditOverlayGestures.
*/
/**
* Whether the hover cache may stand in for a hit-test at this point.
*
* The cache is filled asynchronously as the pointer moves, so it can describe an
* element the pointer has already left. That is harmless for drawing a hover
* outline and wrong for a shift-click, which would add the stale element to the
* selection instead of the one under the pointer. True only when the cached
* element IS the element at the point, or contains it — the resolver is allowed
* to hand back a clip ancestor of the raw target, and that still describes the
* same click.
*/
export function hoverCacheDescribesPoint(
cachedElement: Element | null | undefined,
elementAtPoint: Element | null | undefined,
): boolean {
if (!cachedElement || !elementAtPoint) return false;
return cachedElement === elementAtPoint || cachedElement.contains(elementAtPoint);
}
export function resolveResizeCenterAnchorOffset(input: {
originWidth: number;
originHeight: number;
@@ -24,6 +24,7 @@ import {
} from "../components/editor/domEditing";
import { reapplyPositionEditsAfterSeek } from "../components/editor/manualEdits";
import { useStudioTestHooks } from "./useStudioTestHooks";
import { logSelect } from "../utils/selectDebug";
// ── Types ──
@@ -186,6 +187,13 @@ export function useDomSelection({
: (nextGroup[0] ?? null)
: selection;
logSelect("apply", {
additive: isAdditiveSelection,
target: selection.selector ?? selection.id ?? null,
wasInGroup,
prevGroup: previousGroup.length,
nextGroup: nextGroup.length,
});
domEditSelectionRef.current = nextSelection;
domEditGroupSelectionsRef.current = nextGroup;
setDomEditSelection(nextSelection);
+2 -18
View File
@@ -5,22 +5,6 @@
// ask for reads as a flash. These lines answer the only question that matters
// when one appears: who asked for it, and why the write that triggered it was
// not recognised as Studio's own.
let enabled: boolean | null = null;
import { makeStudioDebugLogger } from "./studioDebug";
function isEnabled(): boolean {
if (enabled === null) {
try {
enabled = localStorage.getItem("hf-reload-debug") === "1";
} catch {
enabled = false;
}
}
return enabled;
}
export function logReload(stage: string, data: Record<string, unknown> = {}): void {
if (!isEnabled()) return;
console.log(
`[hf-reload] ${JSON.stringify({ stage, t: Math.round(performance.now()), ...data })}`,
);
}
export const logReload = makeStudioDebugLogger("reload");
+9
View File
@@ -0,0 +1,9 @@
// Canvas selection diagnostics — grep [hf-select]. Off by default; opt in with
// `localStorage.setItem("hf-select-debug", "1")` (then reload).
//
// Selection failures are silent by nature: a handler returns early and nothing
// happens, which looks identical to a click that never landed. These lines say
// which branch ran and what it decided.
import { makeStudioDebugLogger } from "./studioDebug";
export const logSelect = makeStudioDebugLogger("select");
+26
View File
@@ -0,0 +1,26 @@
// Opt-in diagnostic channels — one per question worth tracing, all off by
// default. Turn one on for the session with `localStorage.setItem("hf-<name>-debug",
// "1")` and reload, then grep the console for `[hf-<name>]`.
//
// These exist because the interesting failures here are decisions, not crashes:
// a preview that reloads when it should not, a shift-click that selects nothing.
// Nothing is thrown and nothing is logged by default, so without a trace of the
// decision the only way to find the cause is to guess.
type DebugLogger = (stage: string, data?: Record<string, unknown>) => void;
export function makeStudioDebugLogger(name: string): DebugLogger {
let enabled: boolean | null = null;
return (stage, data = {}) => {
if (enabled === null) {
try {
enabled = localStorage.getItem(`hf-${name}-debug`) === "1";
} catch {
enabled = false;
}
}
if (!enabled) return;
console.log(
`[hf-${name}] ${JSON.stringify({ stage, t: Math.round(performance.now()), ...data })}`,
);
};
}