wip2

wip
2026-04-28 12:21:56 +02:00 · 2026-04-28 12:18:18 +02:00
21 changed files with 788 additions and 1670 deletions
@@ -250,9 +250,6 @@ export const duplicateElements = (
    elementsWithDuplicates.splice(index + 1, 0, ...castArray(elements));
  };

-  // main
-  // ---------------------------------------------------------------------------
-
  const frameIdsToDuplicate = new Set(
    elements
      .filter(
@@ -19,7 +19,6 @@ import {
  getElementAbsoluteCoords,
  doBoundsIntersect,
  getElementBounds,
-  boundsContainBounds,
 } from "./bounds";
 import { mutateElement } from "./mutateElement";
 import { getBoundTextElement, getContainerElement } from "./textElement";
@@ -102,9 +101,8 @@ export const isElementContainingFrame = (
  frame: ExcalidrawFrameLikeElement,
  elementsMap: ElementsMap,
 ) => {
-  return boundsContainBounds(
-    getElementBounds(element, elementsMap),
-    getElementBounds(frame, elementsMap),
+  return getElementsWithinSelection([frame], element, elementsMap).some(
+    (e) => e.id === frame.id,
  );
 };

@@ -34,6 +34,7 @@ import {
  elementOverlapsWithFrame,
  getContainingFrame,
  getFrameChildren,
+  isElementIntersectingFrame,
 } from "./frame";

 import { LinearElementEditor } from "./linearElementEditor";
@@ -169,7 +170,7 @@ export const getElementsWithinSelection = (
    const associatedFrame = getContainingFrame(element, elementsMap);
    if (
      associatedFrame &&
-      elementOverlapsWithFrame(element, associatedFrame, elementsMap)
+      isElementIntersectingFrame(element, associatedFrame, elementsMap)
    ) {
      const frameAABB = getElementBounds(associatedFrame, elementsMap);
      elementAABB = [
@@ -208,9 +209,10 @@ export const getElementsWithinSelection = (
    if (boundsContainBounds(selectionBounds, commonAABB)) {
      if (framesInSelection && isFrameLikeElement(element)) {
        framesInSelection.add(element.id);
+      } else {
+        elementsInSelection.push(element);
+        continue;
      }
-      elementsInSelection.push(element);
-      continue;
    }

    // 2. Handle the case where the label is overlapped by the selection box
@@ -1,56 +1,59 @@
-import { arrayToMap } from "@excalidraw/common";
+import { arrayToMapWithIndex } from "@excalidraw/common";

 import type { ExcalidrawElement } from "./types";

-const defragmentGroups = (elements: readonly ExcalidrawElement[]) => {
-  const groupIdAtLevel = (element: ExcalidrawElement, level: number) => {
-    return element.groupIds[element.groupIds.length - level - 1];
-  };
+const normalizeGroupElementOrder = (elements: readonly ExcalidrawElement[]) => {
+  const origElements: ExcalidrawElement[] = elements.slice();
+  const sortedElements = new Set<ExcalidrawElement>();

-  const orderLevel = (
-    levelElements: readonly ExcalidrawElement[],
-    level: number,
+  const orderInnerGroups = (
+    elements: readonly ExcalidrawElement[],
  ): ExcalidrawElement[] => {
-    const buckets = new Map<string, ExcalidrawElement[]>();
-    // Slots preserve first-occurrence order: a groupId reserves its slot
-    // the first time one of its members is seen; loose elements occupy
-    // their own slot. Groups are then expanded (and recursed into) in place.
-    const slots: (ExcalidrawElement | string)[] = [];
-
-    for (const element of levelElements) {
-      const groupId = groupIdAtLevel(element, level);
-      if (groupId === undefined) {
-        slots.push(element);
-        continue;
+    const firstGroupSig = elements[0]?.groupIds?.join("");
+    const aGroup: ExcalidrawElement[] = [elements[0]];
+    const bGroup: ExcalidrawElement[] = [];
+    for (const element of elements.slice(1)) {
+      if (element.groupIds?.join("") === firstGroupSig) {
+        aGroup.push(element);
+      } else {
+        bGroup.push(element);
      }
-      let bucket = buckets.get(groupId);
-      if (!bucket) {
-        bucket = [];
-        buckets.set(groupId, bucket);
-        slots.push(groupId);
-      }
-      bucket.push(element);
    }
-
-    return slots.flatMap((slot) =>
-      typeof slot === "string"
-        ? orderLevel(buckets.get(slot)!, level + 1)
-        : [slot],
-    );
+    return bGroup.length ? [...aGroup, ...orderInnerGroups(bGroup)] : aGroup;
  };

-  // `groupIds` is stored innermost-first, so the outermost group is the
-  // last entry. We recurse from level 0 (outermost) inward.
-  const sortedElements = orderLevel(elements, 0);
+  const groupHandledElements = new Map<string, true>();
+
+  origElements.forEach((element, idx) => {
+    if (groupHandledElements.has(element.id)) {
+      return;
+    }
+    if (element.groupIds?.length) {
+      const topGroup = element.groupIds[element.groupIds.length - 1];
+      const groupElements = origElements.slice(idx).filter((element) => {
+        const ret = element?.groupIds?.some((id) => id === topGroup);
+        if (ret) {
+          groupHandledElements.set(element!.id, true);
+        }
+        return ret;
+      });
+
+      for (const elem of orderInnerGroups(groupElements)) {
+        sortedElements.add(elem);
+      }
+    } else {
+      sortedElements.add(element);
+    }
+  });

  // if there's a bug which resulted in losing some of the elements, return
  // original instead as that's better than losing data
-  if (sortedElements.length !== elements.length) {
-    console.error("defragmentGroups: lost some elements... bailing!");
+  if (sortedElements.size !== elements.length) {
+    console.error("normalizeGroupElementOrder: lost some elements... bailing!");
    return elements;
  }

-  return sortedElements;
+  return [...sortedElements];
 };

 /**
@@ -65,40 +68,39 @@ const defragmentGroups = (elements: readonly ExcalidrawElement[]) => {
 const normalizeBoundElementsOrder = (
  elements: readonly ExcalidrawElement[],
 ) => {
-  const elementsMap = arrayToMap(elements);
+  const elementsMap = arrayToMapWithIndex(elements);

+  const origElements: (ExcalidrawElement | null)[] = elements.slice();
  const sortedElements = new Set<ExcalidrawElement>();

-  for (const element of elements) {
-    if (sortedElements.has(element)) {
-      continue;
+  origElements.forEach((element, idx) => {
+    if (!element) {
+      return;
    }
-
    if (element.boundElements?.length) {
      sortedElements.add(element);
-      for (const boundElement of element.boundElements) {
+      origElements[idx] = null;
+      element.boundElements.forEach((boundElement) => {
        const child = elementsMap.get(boundElement.id);
        if (child && boundElement.type === "text") {
-          sortedElements.add(child);
+          sortedElements.add(child[0]);
+          origElements[child[1]] = null;
        }
+      });
+    } else if (element.type === "text" && element.containerId) {
+      const parent = elementsMap.get(element.containerId);
+      if (!parent?.[0].boundElements?.find((x) => x.id === element.id)) {
+        sortedElements.add(element);
+        origElements[idx] = null;
+
+        // if element has a container and container lists it, skip this element
+        // as it'll be taken care of by the container
      }
-      continue;
+    } else {
+      sortedElements.add(element);
+      origElements[idx] = null;
    }
-
-    // if element has a container and container lists it, skip this element
-    // as it'll be taken care of by the container
-    if (
-      element.type === "text" &&
-      element.containerId &&
-      elementsMap
-        .get(element.containerId)
-        ?.boundElements?.some((el) => el.id === element.id)
-    ) {
-      continue;
-    }
-
-    sortedElements.add(element);
-  }
+  });

  // if there's a bug which resulted in losing some of the elements, return
  // original instead as that's better than losing data
@@ -115,5 +117,5 @@ const normalizeBoundElementsOrder = (
 export const normalizeElementOrder = (
  elements: readonly ExcalidrawElement[],
 ) => {
-  return normalizeBoundElementsOrder(defragmentGroups(elements));
+  return normalizeBoundElementsOrder(normalizeGroupElementOrder(elements));
 };
@@ -2,7 +2,6 @@ import {
  convertToExcalidrawElements,
  Excalidraw,
 } from "@excalidraw/excalidraw";
-import { arrayToMap } from "@excalidraw/common";

 import { API } from "@excalidraw/excalidraw/tests/helpers/api";
 import { Keyboard, Pointer } from "@excalidraw/excalidraw/tests/helpers/ui";
@@ -11,12 +10,7 @@ import {
  render,
 } from "@excalidraw/excalidraw/tests/test-utils";

-import { elementOverlapsWithFrame } from "../src/frame";
-
-import type {
-  ExcalidrawElement,
-  ExcalidrawFrameLikeElement,
-} from "../src/types";
+import type { ExcalidrawElement } from "../src/types";

 const { h } = window;
 const mouse = new Pointer("mouse");
@@ -131,26 +125,6 @@ describe("adding elements to frames", () => {
    });
  });

-  it("should treat an element fully containing a frame as overlapping the frame", () => {
-    const containingRect = API.createElement({
-      type: "rectangle",
-      x: -50,
-      y: -50,
-      width: 250,
-      height: 250,
-    });
-
-    API.setElements([containingRect, frame]);
-
-    expect(
-      elementOverlapsWithFrame(
-        containingRect,
-        frame as ExcalidrawFrameLikeElement,
-        arrayToMap(h.elements),
-      ),
-    ).toBe(true);
-  });
-
  const commonTestCases = async (
    func: typeof resizeFrameOverElement | typeof dragElementIntoFrame,
  ) => {
@@ -441,22 +415,6 @@ describe("adding elements to frames", () => {
  describe("dragging elements into the frame", async () => {
    await commonTestCases(dragElementIntoFrame);

-    it("should add a dragged element fully containing the frame", () => {
-      const containingRect = API.createElement({
-        type: "rectangle",
-        x: 220,
-        y: 20,
-        width: 300,
-        height: 300,
-      });
-
-      API.setElements([frame, containingRect]);
-
-      dragElementIntoFrame(frame, containingRect);
-
-      expect(API.getElement(containingRect).frameId).toBe(frame.id);
-    });
-
    it.skip("should drag element inside, duplicate it and keep it in frame", () => {
      API.setElements([frame, rect2]);

@@ -326,59 +326,19 @@ describe("normalizeElementsOrder", () => {
      ]),
      [
        "BA_rect1",
-        "CBA_rect3",
-        "CBA_rect7",
        "BA_rect5",
        "BA_rect6",
        "A_rect2",
        "A_rect5",
+        "CBA_rect3",
+        "CBA_rect7",
        "rect4",
        "X_rect8",
-        "YX_rect10",
        "X_rect11",
+        "YX_rect10",
        "rect9",
      ],
    );
-    assertOrder(
-      normalizeElementOrder([
-        API.createElement({
-          id: "A_rect1",
-          type: "rectangle",
-          groupIds: ["A"],
-        }),
-        API.createElement({
-          id: "CBA_rect2",
-          type: "rectangle",
-          groupIds: ["C", "B", "A"],
-        }),
-        API.createElement({
-          id: "A_rect3",
-          type: "rectangle",
-          groupIds: ["A"],
-        }),
-      ]),
-      ["A_rect1", "CBA_rect2", "A_rect3"],
-    );
-    assertOrder(
-      normalizeElementOrder([
-        API.createElement({
-          id: "abcT_rect1",
-          type: "rectangle",
-          groupIds: ["ab", "c", "T"],
-        }),
-        API.createElement({
-          id: "abcT_rect2",
-          type: "rectangle",
-          groupIds: ["a", "bc", "T"],
-        }),
-        API.createElement({
-          id: "abcT_rect3",
-          type: "rectangle",
-          groupIds: ["ab", "c", "T"],
-        }),
-      ]),
-      ["abcT_rect1", "abcT_rect3", "abcT_rect2"],
-    );
  });

  // TODO
@@ -329,6 +329,7 @@ export const actionFinalize = register<FormData>({
        selectionElement: null,
        multiElement: null,
        editingTextElement: null,
+        startBoundElement: null,
        suggestedBinding: null,
        selectedElementIds:
          element &&
@@ -99,6 +99,7 @@ export const getDefaultAppState = (): Omit<
      open: false,
      panels: STATS_PANELS.generalStats | STATS_PANELS.elementProperties,
    },
+    startBoundElement: null,
    suggestedBinding: null,
    frameRendering: { enabled: true, clip: true, name: true, outline: true },
    frameToHighlight: null,
@@ -230,6 +231,7 @@ const APP_STATE_STORAGE_CONF = (<
  selectionElement: { browser: false, export: false, server: false },
  shouldCacheIgnoreZoom: { browser: true, export: false, server: false },
  stats: { browser: true, export: false, server: false },
+  startBoundElement: { browser: false, export: false, server: false },
  suggestedBinding: { browser: false, export: false, server: false },
  frameRendering: { browser: false, export: false, server: false },
  frameToHighlight: { browser: false, export: false, server: false },
@@ -603,7 +603,54 @@ const YOUTUBE_VIDEO_STATES = new Map<
  ValueOf<typeof YOUTUBE_STATES>
 >();

-const MAX_EMBEDDABLE_VIEWPORT_SCALE = 4;
+const isGoogleDrivePreviewLink = (link: string | null | undefined) => {
+  if (!link) {
+    return false;
+  }
+
+  try {
+    const url = new URL(link);
+    return (
+      url.hostname === "drive.google.com" &&
+      /^\/file\/d\/[^/]+\/preview\/?$/.test(url.pathname)
+    );
+  } catch {
+    return false;
+  }
+};
+
+const isGoogleDriveEmbeddableElement = (
+  element: ExcalidrawElement | null | undefined,
+) => {
+  if (!isEmbeddableElement(element)) {
+    return false;
+  }
+
+  const embedLink = getEmbedLink(toValidURL(element.link || ""));
+  return (
+    embedLink?.type === "video" && isGoogleDrivePreviewLink(embedLink.link)
+  );
+};
+
+const EMBEDDABLE_CANVAS_GUARD_CLASS = "excalidraw__embeddable-canvas-guard";
+const EMBEDDABLE_CANVAS_GUARDS = [
+  {
+    key: "top",
+    style: { top: 0, left: 0, right: 0, height: "33.333%" },
+  },
+  {
+    key: "bottom",
+    style: { bottom: 0, left: 0, right: 0, height: "33.333%" },
+  },
+  {
+    key: "left",
+    style: { top: "33.333%", bottom: "33.333%", left: 0, width: "33.333%" },
+  },
+  {
+    key: "right",
+    style: { top: "33.333%", bottom: "33.333%", right: 0, width: "33.333%" },
+  },
+] as const;

 let IS_PLAIN_PASTE = false;
 let IS_PLAIN_PASTE_TIMER = 0;
@@ -1285,6 +1332,46 @@ class App extends React.Component<AppProps, AppState> {
    return this.iFrameRefs.get(element.id);
  }

+  private deactivateActiveEmbeddable = () => {
+    if (this.state.activeEmbeddable) {
+      flushSync(() => {
+        this.setState({ activeEmbeddable: null });
+      });
+    }
+  };
+
+  private handleEmbeddableCanvasGuardPointerDown = (
+    event: React.PointerEvent<HTMLDivElement>,
+  ) => {
+    this.deactivateActiveEmbeddable();
+    this.handleCanvasPointerDown(event);
+  };
+
+  private handleEmbeddableCanvasGuardPointerMove = (
+    event: React.PointerEvent<HTMLDivElement>,
+  ) => {
+    this.lastViewportPosition.x = event.clientX;
+    this.lastViewportPosition.y = event.clientY;
+    this.deactivateActiveEmbeddable();
+  };
+
+  private handleEmbeddableCanvasGuardTouchStart = (
+    event: React.TouchEvent<HTMLDivElement>,
+  ) => {
+    if (event.touches.length >= 2) {
+      this.deactivateActiveEmbeddable();
+    }
+  };
+
+  private handleEmbeddableCanvasGuardWheel = (
+    event: React.WheelEvent<HTMLDivElement>,
+  ) => {
+    this.lastViewportPosition.x = event.clientX;
+    this.lastViewportPosition.y = event.clientY;
+    this.deactivateActiveEmbeddable();
+    this.handleWheel(event);
+  };
+
  private handleIframeLikeElementHover = ({
    hitElement,
    scenePointer,
@@ -1307,12 +1394,25 @@ class App extends React.Component<AppProps, AppState> {
        ))
    ) {
      setCursor(this.interactiveCanvas, CURSOR_TYPE.POINTER);
+      const isDriveEmbedActivating =
+        (this.state.viewModeEnabled ||
+          this.state.activeTool.type === "selection") &&
+        isGoogleDriveEmbeddableElement(hitElement);
      this.setState({
-        activeEmbeddable: { element: hitElement, state: "hover" },
+        activeEmbeddable: {
+          element: hitElement,
+          state: isDriveEmbedActivating ? "active" : "hover",
+        },
      });
      return true;
    } else if (this.state.activeEmbeddable?.state === "hover") {
      this.setState({ activeEmbeddable: null });
+    } else if (
+      this.state.activeEmbeddable?.state === "active" &&
+      isGoogleDriveEmbeddableElement(this.state.activeEmbeddable.element) &&
+      this.state.activeEmbeddable.element !== hitElement
+    ) {
+      this.setState({ activeEmbeddable: null });
    }
    return false;
  };
@@ -1736,18 +1836,8 @@ class App extends React.Component<AppProps, AppState> {
          const isHovered =
            this.state.activeEmbeddable?.element === el &&
            this.state.activeEmbeddable?.state === "hover";
-
-          // scale video embeds based on zoom (capped) so that smaller embeds
-          // on canvas when zoomed are still of legible quality
-          // (note: for some embed types like gdrive, the quality is poor when
-          // scaling mid playback and works only when you initially start the
-          // playback at the higher zoom level)
-          const shouldScaleEmbeddableViewport = src?.type === "video";
-          const embeddableViewportScale = clamp(
-            shouldScaleEmbeddableViewport ? scale : 1,
-            0.75,
-            MAX_EMBEDDABLE_VIEWPORT_SCALE,
-          );
+          const shouldConstrainDriveInteraction =
+            isActive && isGoogleDriveEmbeddableElement(el);

          return (
            <div
@@ -1799,6 +1889,7 @@ class App extends React.Component<AppProps, AppState> {
                  width: isVisible ? `${el.width}px` : 0,
                  height: isVisible ? `${el.height}px` : 0,
                  transform: isVisible ? `rotate(${el.angle}rad)` : "none",
+                  position: "relative",
                  pointerEvents: isActive
                    ? POINTER_EVENTS.enabled
                    : POINTER_EVENTS.disabled,
@@ -1815,43 +1906,52 @@ class App extends React.Component<AppProps, AppState> {
                    padding: `${el.strokeWidth}px`,
                  }}
                >
-                  <div
-                    className="excalidraw__embeddable__content"
-                    style={{
-                      width: `${embeddableViewportScale * 100}%`,
-                      height: `${embeddableViewportScale * 100}%`,
-                      transform: `scale(${1 / embeddableViewportScale})`,
-                    }}
-                  >
-                    {(isEmbeddableElement(el)
-                      ? this.props.renderEmbeddable?.(el, this.state)
-                      : null) ?? (
-                      <iframe
-                        ref={(ref) => this.cacheEmbeddableRef(el, ref)}
-                        className="excalidraw__embeddable"
-                        srcDoc={
-                          src?.type === "document"
-                            ? src.srcdoc(this.state.theme)
-                            : undefined
-                        }
-                        src={
-                          src?.type !== "document" ? src?.link ?? "" : undefined
-                        }
-                        // https://stackoverflow.com/q/18470015
-                        scrolling="no"
-                        referrerPolicy="no-referrer-when-downgrade"
-                        title="Excalidraw Embedded Content"
-                        allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
-                        allowFullScreen={true}
-                        sandbox={`${
-                          src?.sandbox?.allowSameOrigin
-                            ? "allow-same-origin"
-                            : ""
-                        } allow-scripts allow-forms allow-popups allow-popups-to-escape-sandbox allow-presentation allow-downloads`}
-                      />
-                    )}
-                  </div>
+                  {(isEmbeddableElement(el)
+                    ? this.props.renderEmbeddable?.(el, this.state)
+                    : null) ?? (
+                    <iframe
+                      ref={(ref) => this.cacheEmbeddableRef(el, ref)}
+                      className="excalidraw__embeddable"
+                      srcDoc={
+                        src?.type === "document"
+                          ? src.srcdoc(this.state.theme)
+                          : undefined
+                      }
+                      src={
+                        src?.type !== "document" ? src?.link ?? "" : undefined
+                      }
+                      // https://stackoverflow.com/q/18470015
+                      scrolling="no"
+                      referrerPolicy="no-referrer-when-downgrade"
+                      title="Excalidraw Embedded Content"
+                      allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
+                      allowFullScreen={true}
+                      sandbox={`${
+                        src?.sandbox?.allowSameOrigin ? "allow-same-origin" : ""
+                      } allow-scripts allow-forms allow-popups allow-popups-to-escape-sandbox allow-presentation allow-downloads`}
+                    />
+                  )}
                </div>
+                {shouldConstrainDriveInteraction &&
+                  EMBEDDABLE_CANVAS_GUARDS.map(({ key, style }) => (
+                    <div
+                      key={key}
+                      className={EMBEDDABLE_CANVAS_GUARD_CLASS}
+                      onPointerDown={
+                        this.handleEmbeddableCanvasGuardPointerDown
+                      }
+                      onPointerMove={
+                        this.handleEmbeddableCanvasGuardPointerMove
+                      }
+                      onTouchStart={this.handleEmbeddableCanvasGuardTouchStart}
+                      onWheel={this.handleEmbeddableCanvasGuardWheel}
+                      style={{
+                        position: "absolute",
+                        zIndex: 2,
+                        ...style,
+                      }}
+                    />
+                  ))}
              </div>
            </div>
          );
@@ -4758,6 +4858,16 @@ class App extends React.Component<AppProps, AppState> {
        });
      }

+      if (
+        this.state.activeEmbeddable &&
+        (event.ctrlKey ||
+          event.metaKey ||
+          event.key === "Control" ||
+          event.key === "Meta")
+      ) {
+        this.setState({ activeEmbeddable: null });
+      }
+
      if (!isInputLike(event.target)) {
        if (
          (event.key === KEYS.ESCAPE || event.key === KEYS.ENTER) &&
@@ -5636,6 +5746,10 @@ class App extends React.Component<AppProps, AppState> {
        selectedElementIds: makeNextSelectedElementIds({}, this.state),
        activeEmbeddable: null,
      });
+    } else if (this.state.activeEmbeddable) {
+      this.setState({
+        activeEmbeddable: null,
+      });
    }
    gesture.initialScale = this.state.zoom.value;
  });
@@ -6947,7 +7061,7 @@ class App extends React.Component<AppProps, AppState> {
              y: scenePointerY,
            },
          });
-          this.setState({ suggestedBinding: null });
+          this.setState({ suggestedBinding: null, startBoundElement: null });
          if (!this.state.activeTool.locked) {
            resetCursor(this.interactiveCanvas);
            this.setState((prevState) => ({
@@ -7591,6 +7705,7 @@ class App extends React.Component<AppProps, AppState> {
        appState: {
          newElement: null,
          editingTextElement: null,
+          startBoundElement: null,
          suggestedBinding: null,
          selectedElementIds: makeNextSelectedElementIds(
            Object.keys(this.state.selectedElementIds)
@@ -8189,6 +8304,10 @@ class App extends React.Component<AppProps, AppState> {
      y: event.clientY,
    });

+    if (gesture.pointers.size >= 2 && this.state.activeEmbeddable) {
+      this.setState({ activeEmbeddable: null });
+    }
+
    if (gesture.pointers.size === 2) {
      gesture.lastCenter = getCenter(gesture.pointers);
      gesture.initialScale = this.state.zoom.value;
@@ -8878,8 +8997,18 @@ class App extends React.Component<AppProps, AppState> {
      };
    });

+    const boundElement = getHoveredElementForBinding(
+      pointFrom<GlobalPoint>(
+        pointerDownState.origin.x,
+        pointerDownState.origin.y,
+      ),
+      this.scene.getNonDeletedElements(),
+      this.scene.getNonDeletedElementsMap(),
+    );
+
    this.setState({
      newElement: element,
+      startBoundElement: boundElement,
      suggestedBinding: null,
    });
  };
@@ -10732,7 +10861,7 @@ class App extends React.Component<AppProps, AppState> {
              sceneCoords,
            });
          }
-          this.setState({ suggestedBinding: null });
+          this.setState({ suggestedBinding: null, startBoundElement: null });
          if (!activeTool.locked) {
            resetCursor(this.interactiveCanvas);
            this.setState((prevState) => ({
@@ -10753,9 +10882,9 @@ class App extends React.Component<AppProps, AppState> {
              ),
            }));
          } else {
-            this.setState({
+            this.setState((prevState) => ({
              newElement: null,
-            });
+            }));
          }
          // so that the scene gets rendered again to display the newly drawn linear as well
          this.scene.triggerUpdate();
@@ -12598,7 +12727,8 @@ class App extends React.Component<AppProps, AppState> {
          event.target instanceof HTMLTextAreaElement ||
          event.target instanceof HTMLIFrameElement ||
          (event.target instanceof HTMLElement &&
-            event.target.classList.contains(CLASSES.FRAME_NAME))
+            (event.target.classList.contains(CLASSES.FRAME_NAME) ||
+              event.target.classList.contains(EMBEDDABLE_CANVAS_GUARD_CLASS)))
        )
      ) {
        // prevent zooming the browser (but allow scrolling DOM)
@@ -650,7 +650,8 @@ const LayerUI = ({
 };

 const stripIrrelevantAppStateProps = (appState: AppState): UIAppState => {
-  const { cursorButton, scrollX, scrollY, ...ret } = appState;
+  const { startBoundElement, cursorButton, scrollX, scrollY, ...ret } =
+    appState;
  return ret;
 };

@@ -814,14 +814,6 @@ body.excalidraw-cursor-resize * {
  .excalidraw__embeddable__outer {
    width: 100%;
    height: 100%;
-  }
-
-  .excalidraw__embeddable__content {
-    width: 100%;
-    height: 100%;
-    transform-origin: top left;
-
-    &,
    & > * {
      border-radius: var(--embeddable-radius);
    }
@@ -19,6 +19,8 @@ export const renderSnaps = (
  }

  // in dark mode, we need to adjust the color to account for color inversion.
+  // Don't change if zen mode, because we draw only crosses, we want the
+  // colors to be more visible
  const snapColor =
    appState.theme === THEME.LIGHT || appState.zenModeEnabled
      ? SNAP_COLOR_LIGHT
@@ -39,14 +39,6 @@ import type {
 } from "./types";

 const SNAP_DISTANCE = 8;
-// Keep snap candidates with effectively identical offsets together. This needs
-// to be wider than the 6-decimal rounding quantum to absorb JS floating-point
-// noise around values like 4 and 4.000001.
-const SNAP_OFFSET_TOLERANCE = 0.00001;
-// Point snaps can come from both nearby and distant references within snap
-// distance. If their visual distances have a large break, prefer the nearest
-// cluster before comparing offsets.
-const SNAP_REFERENCE_CLUSTER_BREAK_DISTANCE = 200;

 // do not comput more gaps per axis than this limit
 // TODO increase or remove once we optimize
@@ -57,51 +49,16 @@ export const getSnapDistance = (zoomValue: number) => {
  return SNAP_DISTANCE / zoomValue;
 };

-/**
- * Keeps the cluster threshold visually stable across zoom levels.
- */
-const getSnapReferenceClusterBreakDistance = (zoomValue: number) => {
-  return SNAP_REFERENCE_CLUSTER_BREAK_DISTANCE / zoomValue;
-};
-
 type Vector2D = {
  x: number;
  y: number;
 };

 type PointPair = [GlobalPoint, GlobalPoint];
-type SnapPointType = "outer" | "center";
-type SnapSourceId = string;
-
-const SELECTION_SNAP_SOURCE_ID = "selection";
-
-// Snap source ids let us filter redundant snaplines only within one
-// selection-to-reference relationship, without mixing separate reference groups.
-// For example, "selection->rectA" may collapse to its outermost snaplines,
-// while "selection->rectB" still keeps its own independent snaplines.
-type SnapPoint = {
-  point: GlobalPoint;
-  type: SnapPointType;
-  snapSourceId: SnapSourceId;
-};
-
-const outerSnapPoint = (
-  point: GlobalPoint,
-  snapSourceId = SELECTION_SNAP_SOURCE_ID,
-): SnapPoint => ({
-  point,
-  type: "outer",
-  snapSourceId,
-});

 export type PointSnap = {
  type: "point";
  points: PointPair;
-  pointTypes: [SnapPointType, SnapPointType];
-  snapSourceIds: [SnapSourceId, SnapSourceId];
-  // Distance along the rendered snapline, used to group visually nearby
-  // references before choosing which point snaps should win.
-  visualDistance: number;
  offset: number;
 };

@@ -163,14 +120,14 @@ export type SnapLine = PointSnapLine | GapSnapLine | PointerSnapLine;
 // -----------------------------------------------------------------------------

 export class SnapCache {
-  private static referenceSnapPoints: SnapPoint[] | null = null;
+  private static referenceSnapPoints: GlobalPoint[] | null = null;

  private static visibleGaps: {
    verticalGaps: Gap[];
    horizontalGaps: Gap[];
  } | null = null;

-  public static setReferenceSnapPoints = (snapPoints: SnapPoint[] | null) => {
+  public static setReferenceSnapPoints = (snapPoints: GlobalPoint[] | null) => {
    SnapCache.referenceSnapPoints = snapPoints;
  };

@@ -238,17 +195,6 @@ export const areRoughlyEqual = (a: number, b: number, precision = 0.01) => {
  return Math.abs(a - b) <= precision;
 };

-/**
- * Keeps nearly identical snap offsets in the same winner set. This prevents
- * snapline flicker when rounded geometry differs by a tiny floating-point tail.
- */
-const isWithinSnapOffset = (offset: number, minOffset: number) => {
-  return (
-    Math.abs(offset) <= minOffset ||
-    areRoughlyEqual(Math.abs(offset), minOffset, SNAP_OFFSET_TOLERANCE)
-  );
-};
-
 export const getElementsCorners = (
  elements: ExcalidrawElement[],
  elementsMap: ElementsMap,
@@ -366,81 +312,18 @@ export const getElementsCorners = (
  return result.map((p) => pointFrom(round(p[0]), round(p[1])));
 };

-const getElementsSnapPoints = (
-  elements: ExcalidrawElement[],
-  elementsMap: ElementsMap,
-  options: Parameters<typeof getElementsCorners>[2] = {},
-  snapSourceId = SELECTION_SNAP_SOURCE_ID,
-): SnapPoint[] => {
-  const points = getElementsCorners(elements, elementsMap, options);
-  // getElementsCorners() appends the center point last unless omitCenter is set.
-  const hasCenterPoint = !options.omitCenter && points.length > 0;
-
-  return points.map((point, index) => ({
-    point,
-    type: hasCenterPoint && index === points.length - 1 ? "center" : "outer",
-    snapSourceId,
-  }));
-};
-
-/**
- * Builds a stable identity for one snap reference group. Sorting keeps grouped
- * elements represented by the same snap source id regardless of element order.
- */
-const getSnapSourceId = (elements: ExcalidrawElement[]) => {
-  return elements
-    .map((element) => element.id)
-    .sort()
-    .join(",");
-};
-
-/**
- * Finds frames that the current selection already belongs to. Their children
- * are still valid snap references; children of unrelated frames are not.
- */
-const getSelectedFrameIdsForSnapping = (
-  selectedElements: readonly ExcalidrawElement[],
-) => {
-  const selectedFrameIds = new Set<ExcalidrawElement["id"]>();
-
-  for (const element of selectedElements) {
-    if (element.frameId) {
-      selectedFrameIds.add(element.frameId);
-    }
-  }
-
-  return selectedFrameIds;
-};
-
-/**
- * Frame children are only snap references when the dragged selection is inside
- * the same frame. This avoids snapping external elements to internals of a
- * framed diagram.
- */
-const canUseElementAsSnapReference = (
-  element: NonDeletedExcalidrawElement,
-  selectedFrameIds: Set<ExcalidrawElement["id"]>,
-) => {
-  return !element.frameId || selectedFrameIds.has(element.frameId);
-};
-
 const getReferenceElements = (
  elements: readonly NonDeletedExcalidrawElement[],
  selectedElements: NonDeletedExcalidrawElement[],
  appState: AppState,
  elementsMap: ElementsMap,
-) => {
-  const selectedFrameIds = getSelectedFrameIdsForSnapping(selectedElements);
-
-  return getVisibleAndNonSelectedElements(
+) =>
+  getVisibleAndNonSelectedElements(
    elements,
    selectedElements,
    appState,
    elementsMap,
-  ).filter((element) => {
-    return canUseElementAsSnapReference(element, selectedFrameIds);
-  });
-};
+  );

 export const getVisibleGaps = (
  elements: readonly NonDeletedExcalidrawElement[],
@@ -599,10 +482,7 @@ const getGapSnaps = (
      const centerOffset = round(gapMidX - centerX);
      const gapIsLargerThanSelection = gap.length > maxX - minX;

-      if (
-        gapIsLargerThanSelection &&
-        isWithinSnapOffset(centerOffset, minOffset.x)
-      ) {
+      if (gapIsLargerThanSelection && Math.abs(centerOffset) <= minOffset.x) {
        if (Math.abs(centerOffset) < minOffset.x) {
          nearestSnapsX.length = 0;
        }
@@ -624,7 +504,7 @@ const getGapSnaps = (
      const distanceToEndElementX = minX - endMaxX;
      const sideOffsetRight = round(gap.length - distanceToEndElementX);

-      if (isWithinSnapOffset(sideOffsetRight, minOffset.x)) {
+      if (Math.abs(sideOffsetRight) <= minOffset.x) {
        if (Math.abs(sideOffsetRight) < minOffset.x) {
          nearestSnapsX.length = 0;
        }
@@ -645,7 +525,7 @@ const getGapSnaps = (
      const distanceToStartElementX = startMinX - maxX;
      const sideOffsetLeft = round(distanceToStartElementX - gap.length);

-      if (isWithinSnapOffset(sideOffsetLeft, minOffset.x)) {
+      if (Math.abs(sideOffsetLeft) <= minOffset.x) {
        if (Math.abs(sideOffsetLeft) < minOffset.x) {
          nearestSnapsX.length = 0;
        }
@@ -671,10 +551,7 @@ const getGapSnaps = (
      const centerOffset = round(gapMidY - centerY);
      const gapIsLargerThanSelection = gap.length > maxY - minY;

-      if (
-        gapIsLargerThanSelection &&
-        isWithinSnapOffset(centerOffset, minOffset.y)
-      ) {
+      if (gapIsLargerThanSelection && Math.abs(centerOffset) <= minOffset.y) {
        if (Math.abs(centerOffset) < minOffset.y) {
          nearestSnapsY.length = 0;
        }
@@ -696,7 +573,7 @@ const getGapSnaps = (
      const distanceToStartElementY = startMinY - maxY;
      const sideOffsetTop = round(distanceToStartElementY - gap.length);

-      if (isWithinSnapOffset(sideOffsetTop, minOffset.y)) {
+      if (Math.abs(sideOffsetTop) <= minOffset.y) {
        if (Math.abs(sideOffsetTop) < minOffset.y) {
          nearestSnapsY.length = 0;
        }
@@ -717,7 +594,7 @@ const getGapSnaps = (
      const distanceToEndElementY = round(minY - endMaxY);
      const sideOffsetBottom = gap.length - distanceToEndElementY;

-      if (isWithinSnapOffset(sideOffsetBottom, minOffset.y)) {
+      if (Math.abs(sideOffsetBottom) <= minOffset.y) {
        if (Math.abs(sideOffsetBottom) < minOffset.y) {
          nearestSnapsY.length = 0;
        }
@@ -736,102 +613,6 @@ const getGapSnaps = (
  }
 };

-/**
- * Narrows point snaps to the nearest visual cluster, then keeps the best offset
- * inside that cluster. If all references look continuous, this preserves the
- * old smallest-offset behavior.
- */
-const filterPointSnapsToNearestCluster = (
-  snaps: Snaps,
-  clusterBreakDistance: number,
-) => {
-  const pointSnaps = snaps.filter(
-    (snap): snap is PointSnap => snap.type === "point",
-  );
-
-  if (pointSnaps.length < 2) {
-    return;
-  }
-
-  const snapsByOffset = new Map<number, PointSnap[]>();
-
-  for (const snap of pointSnaps) {
-    const offset = round(snap.offset);
-    const offsetSnaps = snapsByOffset.get(offset) ?? [];
-    offsetSnaps.push(snap);
-    snapsByOffset.set(offset, offsetSnaps);
-  }
-
-  const keptPointSnaps = new Set<PointSnap>();
-  const offsetGroups = Array.from(snapsByOffset.entries()).map(
-    ([offset, offsetSnaps]) => ({
-      offset,
-      snaps: offsetSnaps,
-      visualDistance: Math.min(
-        ...offsetSnaps.map((snap) => snap.visualDistance),
-      ),
-    }),
-  );
-  const sortedOffsetGroups = offsetGroups
-    .slice()
-    .sort((a, b) => a.visualDistance - b.visualDistance);
-  let keepOffsetGroupsUntil = sortedOffsetGroups.length;
-
-  // Prefer a nearby reference cluster before comparing offset. If there is no
-  // clear distance break, this keeps all offsets and falls back to the old
-  // smallest-offset behavior.
-  for (let i = 1; i < sortedOffsetGroups.length; i++) {
-    const distanceGap =
-      sortedOffsetGroups[i].visualDistance -
-      sortedOffsetGroups[i - 1].visualDistance;
-
-    if (distanceGap > clusterBreakDistance) {
-      keepOffsetGroupsUntil = i;
-      break;
-    }
-  }
-
-  const nearestOffsetGroups = sortedOffsetGroups.slice(
-    0,
-    keepOffsetGroupsUntil,
-  );
-  const minOffset = Math.min(
-    ...nearestOffsetGroups.map(({ offset }) => Math.abs(offset)),
-  );
-  const selectedOffsets = nearestOffsetGroups
-    .filter(({ offset }) =>
-      areRoughlyEqual(Math.abs(offset), minOffset, SNAP_OFFSET_TOLERANCE),
-    )
-    .map(({ offset }) => offset);
-
-  for (const offsetSnaps of snapsByOffset.values()) {
-    if (
-      !selectedOffsets.some((offset) =>
-        areRoughlyEqual(
-          round(offsetSnaps[0].offset),
-          offset,
-          SNAP_OFFSET_TOLERANCE,
-        ),
-      )
-    ) {
-      continue;
-    }
-
-    offsetSnaps.forEach((snap) => keptPointSnaps.add(snap));
-  }
-
-  let writeIndex = 0;
-
-  for (const snap of snaps) {
-    if (snap.type !== "point" || keptPointSnaps.has(snap)) {
-      snaps[writeIndex] = snap;
-      writeIndex++;
-    }
-  }
-
-  snaps.length = writeIndex;
-};
-
 export const getReferenceSnapPoints = (
  elements: readonly NonDeletedExcalidrawElement[],
  selectedElements: ExcalidrawElement[],
@@ -849,24 +630,12 @@ export const getReferenceSnapPoints = (
      (elementsGroup) =>
        !(elementsGroup.length === 1 && isBoundToContainer(elementsGroup[0])),
    )
-    .flatMap((elementGroup) =>
-      getElementsSnapPoints(
-        elementGroup,
-        elementsMap,
-        {},
-        getSnapSourceId(elementGroup),
-      ),
-    );
+    .flatMap((elementGroup) => getElementsCorners(elementGroup, elementsMap));
 };

-/**
- * Collects point snaps within snap distance. Unlike gap snaps, point snaps first
- * go through visual-cluster filtering so a nearby reference can beat a slightly
- * better offset from a far-away reference.
- */
 const getPointSnaps = (
  selectedElements: ExcalidrawElement[],
-  selectionSnapPoints: SnapPoint[],
+  selectionSnapPoints: GlobalPoint[],
  app: AppClassProperties,
  event: KeyboardModifiersObject,
  nearestSnapsX: Snaps,
@@ -885,62 +654,39 @@ const getPointSnaps = (
  if (referenceSnapPoints) {
    for (const thisSnapPoint of selectionSnapPoints) {
      for (const otherSnapPoint of referenceSnapPoints) {
-        const offsetX = otherSnapPoint.point[0] - thisSnapPoint.point[0];
-        const offsetY = otherSnapPoint.point[1] - thisSnapPoint.point[1];
+        const offsetX = otherSnapPoint[0] - thisSnapPoint[0];
+        const offsetY = otherSnapPoint[1] - thisSnapPoint[1];
+
+        if (Math.abs(offsetX) <= minOffset.x) {
+          if (Math.abs(offsetX) < minOffset.x) {
+            nearestSnapsX.length = 0;
+          }

-        if (isWithinSnapOffset(offsetX, minOffset.x)) {
          nearestSnapsX.push({
            type: "point",
-            points: [thisSnapPoint.point, otherSnapPoint.point],
-            pointTypes: [thisSnapPoint.type, otherSnapPoint.type],
-            snapSourceIds: [
-              thisSnapPoint.snapSourceId,
-              otherSnapPoint.snapSourceId,
-            ],
-            visualDistance: Math.abs(
-              otherSnapPoint.point[1] - thisSnapPoint.point[1],
-            ),
+            points: [thisSnapPoint, otherSnapPoint],
            offset: offsetX,
          });
+
+          minOffset.x = Math.abs(offsetX);
        }

-        if (isWithinSnapOffset(offsetY, minOffset.y)) {
+        if (Math.abs(offsetY) <= minOffset.y) {
+          if (Math.abs(offsetY) < minOffset.y) {
+            nearestSnapsY.length = 0;
+          }
+
          nearestSnapsY.push({
            type: "point",
-            points: [thisSnapPoint.point, otherSnapPoint.point],
-            pointTypes: [thisSnapPoint.type, otherSnapPoint.type],
-            snapSourceIds: [
-              thisSnapPoint.snapSourceId,
-              otherSnapPoint.snapSourceId,
-            ],
-            visualDistance: Math.abs(
-              otherSnapPoint.point[0] - thisSnapPoint.point[0],
-            ),
+            points: [thisSnapPoint, otherSnapPoint],
            offset: offsetY,
          });
+
+          minOffset.y = Math.abs(offsetY);
        }
      }
    }
  }
-
-  const clusterBreakDistance = getSnapReferenceClusterBreakDistance(
-    app.state.zoom.value,
-  );
-
-  filterPointSnapsToNearestCluster(nearestSnapsX, clusterBreakDistance);
-  filterPointSnapsToNearestCluster(nearestSnapsY, clusterBreakDistance);
-
-  if (nearestSnapsX.length > 0) {
-    minOffset.x = Math.min(
-      ...nearestSnapsX.map((snap) => Math.abs(snap.offset)),
-    );
-  }
-
-  if (nearestSnapsY.length > 0) {
-    minOffset.y = Math.min(
-      ...nearestSnapsY.map((snap) => Math.abs(snap.offset)),
-    );
-  }
 };

 export const snapDraggedElements = (
@@ -974,7 +720,7 @@ export const snapDraggedElements = (
    y: snapDistance,
  };

-  const selectionPoints = getElementsSnapPoints(selectedElements, elementsMap, {
+  const selectionPoints = getElementsCorners(selectedElements, elementsMap, {
    dragOffset,
  });

@@ -1024,7 +770,7 @@ export const snapDraggedElements = (

  getPointSnaps(
    selectedElements,
-    getElementsSnapPoints(selectedElements, elementsMap, {
+    getElementsCorners(selectedElements, elementsMap, {
      dragOffset: newDragOffset,
    }),
    app,
@@ -1079,185 +825,12 @@ const dedupePoints = (points: GlobalPoint[]): GlobalPoint[] => {
  return Array.from(map.values());
 };

-// Point snaplines are collected from every winning point snap first. Multiple
-// snap source pairs can collapse to the same rendered line, so candidates keep
-// source-pair metadata until redundant center and inner outer lines are removed.
-type PointSnapLineSourcePair = {
-  snapSourcePairKey: string;
-  pointType: SnapPointType;
-};
-
-type PointSnapLineCandidate = PointSnapLine & {
-  sourcePairs: PointSnapLineSourcePair[];
-};
-
-type PointSnapLineBucket = {
-  points: GlobalPoint[];
-  sourcePairs: PointSnapLineSourcePair[];
-};
-
-type OuterSnapLineCoordinateRange = {
-  count: number;
-  min: number;
-  max: number;
-};
-
-/**
- * Describes which snap source pair produced a rendered point snapline, so later
- * filtering can reason about redundancy without mixing unrelated references.
- * Only center-to-center snaps count as center snaplines; a center-to-outer snap
- * still explains an outer edge or midpoint alignment.
- */
-const getPointSnapLineSourcePair = (
-  snap: PointSnap,
-): PointSnapLineSourcePair => {
-  return {
-    snapSourcePairKey: snap.snapSourceIds.join("->"),
-    pointType: snap.pointTypes.every((pointType) => pointType === "center")
-      ? "center"
-      : "outer",
-  };
-};
-
-/**
- * Builds each snap source pair's outer coordinate range. Center snaplines use
- * this range to decide whether the surrounding outer lines already explain
- * them, and outer snaplines use it to keep only the two extremes.
- */
-const getOuterCoordinateRangesBySnapSourcePairKey = (
-  snapLines: PointSnapLineCandidate[],
-  getCoordinate: (snapLine: PointSnapLine) => number,
-) => {
-  const ranges = new Map<string, OuterSnapLineCoordinateRange>();
-
-  for (const snapLine of snapLines) {
-    const coordinate = getCoordinate(snapLine);
-
-    for (const sourcePair of snapLine.sourcePairs) {
-      if (sourcePair.pointType === "center") {
-        continue;
-      }
-
-      const range = ranges.get(sourcePair.snapSourcePairKey);
-
-      ranges.set(sourcePair.snapSourcePairKey, {
-        count: (range?.count ?? 0) + 1,
-        min: range ? Math.min(range.min, coordinate) : coordinate,
-        max: range ? Math.max(range.max, coordinate) : coordinate,
-      });
-    }
-  }
-
-  return ranges;
-};
-
-/**
- * A center snapline is redundant when outer snaplines from the same snap source
- * pair exist on both sides, because the outer lines already imply center
- * alignment.
- */
-const isRedundantCenterSnapLine = (
-  coordinate: number,
-  outerCoordinateRange?: OuterSnapLineCoordinateRange,
-) => {
-  if (!outerCoordinateRange) {
-    return false;
-  }
-
-  return (
-    outerCoordinateRange.min < coordinate &&
-    outerCoordinateRange.max > coordinate
-  );
-};
-
-/**
- * When more than two outer snaplines come from the same snap source pair, the
- * inner ones are redundant; the two extremes communicate the same shape
- * alignment.
- */
-const isRedundantOuterSnapLine = (
-  coordinate: number,
-  outerCoordinateRange?: OuterSnapLineCoordinateRange,
-) => {
-  if (!outerCoordinateRange || outerCoordinateRange.count <= 2) {
-    return false;
-  }
-
-  return (
-    coordinate !== outerCoordinateRange.min &&
-    coordinate !== outerCoordinateRange.max
-  );
-};
-
-/**
- * Keeps a visual snapline if at least one snap source pair represented by the
- * line still needs it. This matters when multiple snap source pairs collapse to
- * the same rendered coordinate.
- */
-const isPointSnapLineNeededBySourcePair = (
-  sourcePair: PointSnapLineSourcePair,
-  coordinate: number,
-  outerCoordinateRangesBySnapSourcePairKey: Map<
-    string,
-    OuterSnapLineCoordinateRange
-  >,
-) => {
-  const outerCoordinateRange = outerCoordinateRangesBySnapSourcePairKey.get(
-    sourcePair.snapSourcePairKey,
-  );
-
-  if (sourcePair.pointType === "center") {
-    return !isRedundantCenterSnapLine(coordinate, outerCoordinateRange);
-  }
-
-  return !isRedundantOuterSnapLine(coordinate, outerCoordinateRange);
-};
-
-/**
- * Removes point snaplines that are visually redundant, while preserving any line
- * that is still needed by at least one snap source pair represented on that
- * line.
- */
-const filterRedundantPointSnapLines = (
-  snapLines: PointSnapLineCandidate[],
-  getCoordinate: (snapLine: PointSnapLine) => number,
-): PointSnapLine[] => {
-  if (snapLines.length < 3) {
-    return snapLines.map(({ sourcePairs, ...snapLine }) => snapLine);
-  }
-
-  // Track outer-line ranges per snap source pair. The same visual snapline can
-  // be produced by multiple snap source pairs, so a line is removed only when
-  // every pair represented by that line considers it redundant.
-  const outerCoordinateRangesBySnapSourcePairKey =
-    getOuterCoordinateRangesBySnapSourcePairKey(snapLines, getCoordinate);
-
-  return snapLines
-    .filter((snapLine) => {
-      const coordinate = getCoordinate(snapLine);
-
-      return snapLine.sourcePairs.some((sourcePair) =>
-        isPointSnapLineNeededBySourcePair(
-          sourcePair,
-          coordinate,
-          outerCoordinateRangesBySnapSourcePairKey,
-        ),
-      );
-    })
-    .map(({ sourcePairs, ...snapLine }) => snapLine);
-};
-
-/**
- * Merges point snaps that render on the same x/y coordinate, attaches their
- * snap source pair metadata, then removes redundant center and inner outer
- * lines.
- */
 const createPointSnapLines = (
  nearestSnapsX: Snaps,
  nearestSnapsY: Snaps,
 ): PointSnapLine[] => {
-  const snapsX = {} as { [key: string]: PointSnapLineBucket };
-  const snapsY = {} as { [key: string]: PointSnapLineBucket };
+  const snapsX = {} as { [key: string]: GlobalPoint[] };
+  const snapsY = {} as { [key: string]: GlobalPoint[] };

  if (nearestSnapsX.length > 0) {
    for (const snap of nearestSnapsX) {
@@ -1265,14 +838,13 @@ const createPointSnapLines = (
        // key = thisPoint.x
        const key = round(snap.points[0][0]);
        if (!snapsX[key]) {
-          snapsX[key] = { points: [], sourcePairs: [] };
+          snapsX[key] = [];
        }
-        snapsX[key].points.push(
+        snapsX[key].push(
          ...snap.points.map((p) =>
            pointFrom<GlobalPoint>(round(p[0]), round(p[1])),
          ),
        );
-        snapsX[key].sourcePairs.push(getPointSnapLineSourcePair(snap));
      }
    }
  }
@@ -1283,55 +855,44 @@ const createPointSnapLines = (
        // key = thisPoint.y
        const key = round(snap.points[0][1]);
        if (!snapsY[key]) {
-          snapsY[key] = { points: [], sourcePairs: [] };
+          snapsY[key] = [];
        }
-        snapsY[key].points.push(
+        snapsY[key].push(
          ...snap.points.map((p) =>
            pointFrom<GlobalPoint>(round(p[0]), round(p[1])),
          ),
        );
-        snapsY[key].sourcePairs.push(getPointSnapLineSourcePair(snap));
      }
    }
  }

-  const snapLinesX = Object.entries(snapsX).map(([key, snap]) => {
-    return {
-      type: "points",
-      points: dedupePoints(
-        snap.points
-          .map((p) => {
-            return pointFrom<GlobalPoint>(Number(key), p[1]);
-          })
-          .sort((a, b) => a[1] - b[1]),
-      ),
-      sourcePairs: snap.sourcePairs,
-    } as PointSnapLineCandidate;
-  });
-
-  const snapLinesY = Object.entries(snapsY).map(([key, snap]) => {
-    return {
-      type: "points",
-      points: dedupePoints(
-        snap.points
-          .map((p) => {
-            return pointFrom<GlobalPoint>(p[0], Number(key));
-          })
-          .sort((a, b) => a[0] - b[0]),
-      ),
-      sourcePairs: snap.sourcePairs,
-    } as PointSnapLineCandidate;
-  });
-
-  return filterRedundantPointSnapLines(
-    snapLinesX,
-    (snapLine) => snapLine.points[0][0],
-  ).concat(
-    filterRedundantPointSnapLines(
-      snapLinesY,
-      (snapLine) => snapLine.points[0][1],
-    ),
-  );
+  return Object.entries(snapsX)
+    .map(([key, points]) => {
+      return {
+        type: "points",
+        points: dedupePoints(
+          points
+            .map((p) => {
+              return pointFrom<GlobalPoint>(Number(key), p[1]);
+            })
+            .sort((a, b) => a[1] - b[1]),
+        ),
+      } as PointSnapLine;
+    })
+    .concat(
+      Object.entries(snapsY).map(([key, points]) => {
+        return {
+          type: "points",
+          points: dedupePoints(
+            points
+              .map((p) => {
+                return pointFrom<GlobalPoint>(p[0], Number(key));
+              })
+              .sort((a, b) => a[0] - b[0]),
+          ),
+        } as PointSnapLine;
+      }),
+    );
 };

 const dedupeGapSnapLines = (gapSnapLines: GapSnapLine[]) => {
@@ -1356,13 +917,10 @@ const createGapSnapLines = (
  dragOffset: Vector2D,
  gapSnaps: GapSnap[],
 ): GapSnapLine[] => {
-  // Use the same rounded bounds as getGapSnaps(). Otherwise a gap snap can be
-  // accepted during snapping but skipped here because the raw bounds miss the
-  // reference gap overlap by a tiny floating-point delta.
  const [minX, minY, maxX, maxY] = getDraggedElementsBounds(
    selectedElements,
    dragOffset,
-  ).map((bound) => round(bound));
+  );

  const gapSnapLines: GapSnapLine[] = [];

@@ -1585,52 +1143,40 @@ export const snapResizingElements = (
    }
  }

-  const selectionSnapPoints: SnapPoint[] = [];
+  const selectionSnapPoints: GlobalPoint[] = [];

  if (transformHandle) {
    switch (transformHandle) {
      case "e": {
-        selectionSnapPoints.push(
-          outerSnapPoint(pointFrom(maxX, minY)),
-          outerSnapPoint(pointFrom(maxX, maxY)),
-        );
+        selectionSnapPoints.push(pointFrom(maxX, minY), pointFrom(maxX, maxY));
        break;
      }
      case "w": {
-        selectionSnapPoints.push(
-          outerSnapPoint(pointFrom(minX, minY)),
-          outerSnapPoint(pointFrom(minX, maxY)),
-        );
+        selectionSnapPoints.push(pointFrom(minX, minY), pointFrom(minX, maxY));
        break;
      }
      case "n": {
-        selectionSnapPoints.push(
-          outerSnapPoint(pointFrom(minX, minY)),
-          outerSnapPoint(pointFrom(maxX, minY)),
-        );
+        selectionSnapPoints.push(pointFrom(minX, minY), pointFrom(maxX, minY));
        break;
      }
      case "s": {
-        selectionSnapPoints.push(
-          outerSnapPoint(pointFrom(minX, maxY)),
-          outerSnapPoint(pointFrom(maxX, maxY)),
-        );
+        selectionSnapPoints.push(pointFrom(minX, maxY), pointFrom(maxX, maxY));
        break;
      }
      case "ne": {
-        selectionSnapPoints.push(outerSnapPoint(pointFrom(maxX, minY)));
+        selectionSnapPoints.push(pointFrom(maxX, minY));
        break;
      }
      case "nw": {
-        selectionSnapPoints.push(outerSnapPoint(pointFrom(minX, minY)));
+        selectionSnapPoints.push(pointFrom(minX, minY));
        break;
      }
      case "se": {
-        selectionSnapPoints.push(outerSnapPoint(pointFrom(maxX, maxY)));
+        selectionSnapPoints.push(pointFrom(maxX, maxY));
        break;
      }
      case "sw": {
-        selectionSnapPoints.push(outerSnapPoint(pointFrom(minX, maxY)));
+        selectionSnapPoints.push(pointFrom(minX, maxY));
        break;
      }
    }
@@ -1672,11 +1218,11 @@ export const snapResizingElements = (
    round(bound),
  );

-  const corners: SnapPoint[] = [
-    outerSnapPoint(pointFrom(x1, y1)),
-    outerSnapPoint(pointFrom(x1, y2)),
-    outerSnapPoint(pointFrom(x2, y1)),
-    outerSnapPoint(pointFrom(x2, y2)),
+  const corners: GlobalPoint[] = [
+    pointFrom(x1, y1),
+    pointFrom(x1, y2),
+    pointFrom(x2, y1),
+    pointFrom(x2, y2),
  ];

  getPointSnaps(
@@ -1712,8 +1258,8 @@ export const snapNewElement = (
    };
  }

-  const selectionSnapPoints: SnapPoint[] = [
-    outerSnapPoint(pointFrom(origin.x + dragOffset.x, origin.y + dragOffset.y)),
+  const selectionSnapPoints: GlobalPoint[] = [
+    pointFrom(origin.x + dragOffset.x, origin.y + dragOffset.y),
  ];

  const snapDistance = getSnapDistance(app.state.zoom.value);
@@ -1746,7 +1292,7 @@ export const snapNewElement = (
  nearestSnapsX.length = 0;
  nearestSnapsY.length = 0;

-  const corners = getElementsSnapPoints([newElement], elementsMap, {
+  const corners = getElementsCorners([newElement], elementsMap, {
    boundingBoxCorners: true,
    omitCenter: true,
  });
@@ -979,6 +979,7 @@ exports[`contextMenu element > right-clicking on a group should select whole gro
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -1172,6 +1173,7 @@ exports[`contextMenu element > selecting 'Add to library' in context menu adds e
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -1386,6 +1388,7 @@ exports[`contextMenu element > selecting 'Bring forward' in context menu brings
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -1717,6 +1720,7 @@ exports[`contextMenu element > selecting 'Bring to front' in context menu brings
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -2048,6 +2052,7 @@ exports[`contextMenu element > selecting 'Copy styles' in context menu copies st
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -2260,6 +2265,7 @@ exports[`contextMenu element > selecting 'Delete' in context menu deletes elemen
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -2503,6 +2509,7 @@ exports[`contextMenu element > selecting 'Duplicate' in context menu duplicates
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -2806,6 +2813,7 @@ exports[`contextMenu element > selecting 'Group selection' in context menu group
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -3173,6 +3181,7 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -3666,6 +3675,7 @@ exports[`contextMenu element > selecting 'Send backward' in context menu sends e
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -3989,6 +3999,7 @@ exports[`contextMenu element > selecting 'Send to back' in context menu sends el
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -4315,6 +4326,7 @@ exports[`contextMenu element > selecting 'Ungroup selection' in context menu ung
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -5600,6 +5612,7 @@ exports[`contextMenu element > shows 'Group selection' in context menu for multi
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -6819,6 +6832,7 @@ exports[`contextMenu element > shows 'Ungroup selection' in context menu for gro
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -7772,6 +7786,7 @@ exports[`contextMenu element > shows context menu for canvas > [end of test] app
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -8771,6 +8786,7 @@ exports[`contextMenu element > shows context menu for element > [end of test] ap
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -9765,6 +9781,7 @@ exports[`contextMenu element > shows context menu for element > [end of test] ap
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -1293,6 +1293,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -1653,6 +1654,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -2015,6 +2017,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -2277,40 +2280,7 @@ exports[`history > multiplayer undo/redo > conflicts in arrows and their bindabl
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
-  "startBoundElement": {
-    "angle": 0,
-    "backgroundColor": "transparent",
-    "boundElements": [
-      {
-        "id": "id4",
-        "type": "arrow",
-      },
-    ],
-    "customData": undefined,
-    "fillStyle": "solid",
-    "frameId": null,
-    "groupIds": [],
-    "height": 100,
-    "id": "id0",
-    "index": "a0",
-    "isDeleted": false,
-    "link": null,
-    "locked": false,
-    "opacity": 100,
-    "roughness": 1,
-    "roundness": null,
-    "seed": 1,
-    "strokeColor": "#1e1e1e",
-    "strokeStyle": "solid",
-    "strokeWidth": 2,
-    "type": "rectangle",
-    "updated": 1,
-    "version": 3,
-    "versionNonce": 493213705,
-    "width": 100,
-    "x": -100,
-    "y": -50,
-  },
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -2765,6 +2735,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -3068,6 +3039,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -3387,6 +3359,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -3681,6 +3654,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -3967,6 +3941,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -4202,6 +4177,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -4459,6 +4435,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -4730,6 +4707,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -4959,6 +4937,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -5188,6 +5167,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -5435,6 +5415,7 @@ exports[`history > multiplayer undo/redo > conflicts in bound text elements and
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -5691,6 +5672,7 @@ exports[`history > multiplayer undo/redo > conflicts in frames and their childre
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -5948,6 +5930,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -6277,6 +6260,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -6707,6 +6691,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -7087,6 +7072,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -7681,6 +7667,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -7911,6 +7898,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -8263,6 +8251,7 @@ exports[`history > multiplayer undo/redo > should iterate through the history wh
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -8621,6 +8610,7 @@ exports[`history > multiplayer undo/redo > should not let remote changes to inte
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -9021,6 +9011,7 @@ exports[`history > multiplayer undo/redo > should not let remote changes to inte
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -9302,6 +9293,7 @@ exports[`history > multiplayer undo/redo > should not let remote changes to inte
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -9566,6 +9558,7 @@ exports[`history > multiplayer undo/redo > should not override remote changes on
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -9831,6 +9824,7 @@ exports[`history > multiplayer undo/redo > should not override remote changes on
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -10064,6 +10058,7 @@ exports[`history > multiplayer undo/redo > should override remotely added groups
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -10676,6 +10671,7 @@ exports[`history > multiplayer undo/redo > should redistribute deltas when eleme
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -10915,6 +10911,7 @@ exports[`history > multiplayer undo/redo > should redraw arrows on undo > [end o
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -11839,6 +11836,7 @@ exports[`history > multiplayer undo/redo > should update history entries after r
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -12097,6 +12095,7 @@ exports[`history > singleplayer undo/redo > remounting undo/redo buttons should
  "showHyperlinkPopup": false,
  "showWelcomeScreen": false,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -12334,6 +12333,7 @@ exports[`history > singleplayer undo/redo > should clear the redo stack on eleme
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -12569,6 +12569,7 @@ exports[`history > singleplayer undo/redo > should create entry when selecting f
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -12965,6 +12966,7 @@ exports[`history > singleplayer undo/redo > should create new history entry on e
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -13172,6 +13174,7 @@ exports[`history > singleplayer undo/redo > should create new history entry on e
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -13383,6 +13386,7 @@ exports[`history > singleplayer undo/redo > should create new history entry on i
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -13681,6 +13685,7 @@ exports[`history > singleplayer undo/redo > should create new history entry on i
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -13979,6 +13984,7 @@ exports[`history > singleplayer undo/redo > should create new history entry on s
  "showHyperlinkPopup": false,
  "showWelcomeScreen": false,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -14223,6 +14229,7 @@ exports[`history > singleplayer undo/redo > should disable undo/redo buttons whe
  "showHyperlinkPopup": false,
  "showWelcomeScreen": false,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -14460,6 +14467,7 @@ exports[`history > singleplayer undo/redo > should end up with no history entry
  "showHyperlinkPopup": false,
  "showWelcomeScreen": false,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -14697,6 +14705,7 @@ exports[`history > singleplayer undo/redo > should iterate through the history w
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -14944,6 +14953,7 @@ exports[`history > singleplayer undo/redo > should not clear the redo stack on s
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -15276,6 +15286,7 @@ exports[`history > singleplayer undo/redo > should not collapse when applying co
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -15448,6 +15459,7 @@ exports[`history > singleplayer undo/redo > should not end up with history entry
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -15730,6 +15742,7 @@ exports[`history > singleplayer undo/redo > should not end up with history entry
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -15993,6 +16006,7 @@ exports[`history > singleplayer undo/redo > should not modify anything on unrela
  "showHyperlinkPopup": false,
  "showWelcomeScreen": false,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -16147,6 +16161,7 @@ exports[`history > singleplayer undo/redo > should not override appstate changes
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -16428,6 +16443,7 @@ exports[`history > singleplayer undo/redo > should support appstate name or view
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -20154,6 +20170,7 @@ exports[`history > singleplayer undo/redo > should support changes in elements'
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -20636,6 +20653,7 @@ exports[`history > singleplayer undo/redo > should support duplication of groups
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -21142,6 +21160,7 @@ exports[`history > singleplayer undo/redo > should support element creation, del
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -106,6 +106,7 @@ exports[`given element A and group of elements B and given both are selected whe
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -534,6 +535,7 @@ exports[`given element A and group of elements B and given both are selected whe
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -941,6 +943,7 @@ exports[`regression tests > Cmd/Ctrl-click exclusively select element under poin
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -1507,6 +1510,7 @@ exports[`regression tests > Drags selected element when hitting only bounding bo
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -1719,6 +1723,7 @@ exports[`regression tests > adjusts z order when grouping > [end of test] appSta
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -2100,6 +2105,7 @@ exports[`regression tests > alt-drag duplicates an element > [end of test] appSt
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -2343,6 +2349,7 @@ exports[`regression tests > arrow keys > [end of test] appState 1`] = `
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -2525,6 +2532,7 @@ exports[`regression tests > can drag element that covers another element, while
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -2848,6 +2856,7 @@ exports[`regression tests > change the properties of a shape > [end of test] app
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -3105,6 +3114,7 @@ exports[`regression tests > click on an element and drag it > [dragged] appState
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -3346,6 +3356,7 @@ exports[`regression tests > click on an element and drag it > [end of test] appS
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -3582,6 +3593,7 @@ exports[`regression tests > click to select a shape > [end of test] appState 1`]
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -3841,6 +3853,7 @@ exports[`regression tests > click-drag to select a group > [end of test] appStat
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -4154,6 +4167,7 @@ exports[`regression tests > deleting last but one element in editing group shoul
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -4617,6 +4631,7 @@ exports[`regression tests > deselects group of selected elements on pointer down
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -4872,6 +4887,7 @@ exports[`regression tests > deselects group of selected elements on pointer up w
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -5175,6 +5191,7 @@ exports[`regression tests > deselects selected element on pointer down when poin
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -5355,6 +5372,7 @@ exports[`regression tests > deselects selected element, on pointer up, when clic
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -5555,6 +5573,7 @@ exports[`regression tests > double click to edit a group > [end of test] appStat
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -5952,6 +5971,7 @@ exports[`regression tests > drags selected elements from point inside common bou
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -7037,6 +7057,7 @@ exports[`regression tests > given a group of selected elements with an element t
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -7371,6 +7392,7 @@ exports[`regression tests > given a selected element A and a not selected elemen
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -7649,6 +7671,7 @@ exports[`regression tests > given selected element A with lower z-index than uns
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -7884,6 +7907,7 @@ exports[`regression tests > given selected element A with lower z-index than uns
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -8122,6 +8146,7 @@ exports[`regression tests > key 2 selects rectangle tool > [end of test] appStat
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -8302,6 +8327,7 @@ exports[`regression tests > key 3 selects diamond tool > [end of test] appState
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -8482,6 +8508,7 @@ exports[`regression tests > key 4 selects ellipse tool > [end of test] appState
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -9124,6 +9151,7 @@ exports[`regression tests > key 7 selects freedraw tool > [end of test] appState
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -9551,6 +9579,7 @@ exports[`regression tests > key d selects diamond tool > [end of test] appState
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -9962,6 +9991,7 @@ exports[`regression tests > key o selects ellipse tool > [end of test] appState
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -10140,6 +10170,7 @@ exports[`regression tests > key p selects freedraw tool > [end of test] appState
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -10334,6 +10365,7 @@ exports[`regression tests > key r selects rectangle tool > [end of test] appStat
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -10522,6 +10554,7 @@ exports[`regression tests > make a group and duplicate it > [end of test] appSta
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -11047,6 +11080,7 @@ exports[`regression tests > noop interaction after undo shouldn't create history
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -11323,6 +11357,7 @@ exports[`regression tests > pinch-to-zoom works > [end of test] appState 1`] = `
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -11448,6 +11483,7 @@ exports[`regression tests > shift click on selected element should deselect it o
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -11652,6 +11688,7 @@ exports[`regression tests > shift-click to multiselect, then drag > [end of test
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -11973,6 +12010,7 @@ exports[`regression tests > should group elements and ungroup them > [end of tes
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -12406,6 +12444,7 @@ exports[`regression tests > single-clicking on a subgroup of a selected group sh
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -13037,6 +13076,7 @@ exports[`regression tests > spacebar + drag scrolls the canvas > [end of test] a
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -13164,6 +13204,7 @@ exports[`regression tests > supports nested groups > [end of test] appState 1`]
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -13824,6 +13865,7 @@ exports[`regression tests > switches from group of selected elements to another
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -14162,6 +14204,7 @@ exports[`regression tests > switches selected element on pointer down > [end of
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -14394,6 +14437,7 @@ exports[`regression tests > two-finger scroll works > [end of test] appState 1`]
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -14882,6 +14926,7 @@ exports[`regression tests > updates fontSize & fontFamily appState > [end of tes
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -15008,6 +15053,7 @@ exports[`regression tests > zoom hotkeys > [end of test] appState 1`] = `
  "showHyperlinkPopup": false,
  "showWelcomeScreen": true,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
@@ -0,0 +1,315 @@
+import { Excalidraw } from "../index";
+
+import { Pointer } from "./helpers/ui";
+import { act, fireEvent, GlobalTestState, render, waitFor } from "./test-utils";
+
+import type { ExcalidrawProps } from "../types";
+
+describe("embeddable interactions", () => {
+  const h = window.h;
+  const mouse = new Pointer("mouse");
+
+  const renderGoogleDriveEmbeddable = async (
+    excalidrawProps: Partial<ExcalidrawProps> = {},
+  ) => {
+    const renderResult = await render(<Excalidraw {...excalidrawProps} />);
+    const fileId = "1AbCdEfGhIjKlMnOpQrStUvWxYz123456";
+    const src = `https://drive.google.com/file/d/${fileId}/preview`;
+    let embeddable!: NonNullable<
+      ReturnType<typeof h.app.insertEmbeddableElement>
+    >;
+
+    act(() => {
+      const insertedEmbeddable = h.app.insertEmbeddableElement({
+        sceneX: 40,
+        sceneY: 40,
+        link: `https://drive.google.com/file/d/${fileId}/view?usp=sharing`,
+      });
+
+      if (!insertedEmbeddable) {
+        throw new Error("Google Drive embeddable not inserted");
+      }
+
+      embeddable = insertedEmbeddable;
+    });
+
+    (
+      h.app as unknown as {
+        embedsValidationStatus: Map<string, boolean>;
+      }
+    ).embedsValidationStatus.set(embeddable.id, true);
+
+    act(() => {
+      h.setState({ width: 1000, height: 1000 });
+      h.app.scene.triggerUpdate();
+    });
+
+    const getIframe = () => {
+      const iframe = renderResult.container.querySelector<HTMLIFrameElement>(
+        "iframe.excalidraw__embeddable",
+      );
+
+      if (!iframe) {
+        throw new Error("Google Drive iframe not rendered");
+      }
+
+      return iframe;
+    };
+
+    await waitFor(() => {
+      expect(getIframe().src).toBe(src);
+    });
+
+    return {
+      ...renderResult,
+      embeddable,
+      getIframe,
+      src,
+    };
+  };
+
+  const renderYouTubeEmbeddable = async (
+    excalidrawProps: Partial<ExcalidrawProps> = {},
+  ) => {
+    const renderResult = await render(<Excalidraw {...excalidrawProps} />);
+    let embeddable!: NonNullable<
+      ReturnType<typeof h.app.insertEmbeddableElement>
+    >;
+
+    act(() => {
+      const insertedEmbeddable = h.app.insertEmbeddableElement({
+        sceneX: 40,
+        sceneY: 40,
+        link: "https://www.youtube.com/watch?v=gkGMXY0wekg",
+      });
+
+      if (!insertedEmbeddable) {
+        throw new Error("YouTube embeddable not inserted");
+      }
+
+      embeddable = insertedEmbeddable;
+    });
+
+    (
+      h.app as unknown as {
+        embedsValidationStatus: Map<string, boolean>;
+      }
+    ).embedsValidationStatus.set(embeddable.id, true);
+
+    act(() => {
+      h.setState({ width: 1000, height: 1000 });
+      h.app.scene.triggerUpdate();
+    });
+
+    await waitFor(() => {
+      expect(
+        renderResult.container.querySelector("iframe.excalidraw__embeddable"),
+      ).not.toBeNull();
+    });
+
+    return {
+      ...renderResult,
+      embeddable,
+    };
+  };
+
+  const setActiveEmbeddable = (
+    embeddable: NonNullable<ReturnType<typeof h.app.insertEmbeddableElement>>,
+  ) => {
+    act(() => {
+      h.setState({
+        activeEmbeddable: { element: embeddable, state: "active" },
+      });
+    });
+  };
+
+  it("lets the initial Google Drive video click land in the iframe center", async () => {
+    const { container, embeddable, getIframe, src } =
+      await renderGoogleDriveEmbeddable();
+
+    mouse.moveTo(
+      embeddable.x + embeddable.width / 2,
+      embeddable.y + embeddable.height / 2,
+    );
+
+    await waitFor(() => {
+      expect(
+        container.querySelector<HTMLElement>(
+          ".excalidraw__embeddable-container__inner",
+        )?.style.pointerEvents,
+      ).toBe("all");
+      expect(h.state.activeEmbeddable?.element.id).toBe(embeddable.id);
+      expect(h.state.activeEmbeddable?.state).toBe("active");
+      expect(
+        container.querySelectorAll(".excalidraw__embeddable-canvas-guard"),
+      ).toHaveLength(4);
+      expect(
+        container.querySelector(".excalidraw__embeddable-hint"),
+      ).toBeNull();
+      expect(getIframe().src).toBe(src);
+    });
+  });
+
+  it("returns Drive embeddable edge interactions to the canvas", async () => {
+    const { container, embeddable } = await renderGoogleDriveEmbeddable();
+
+    act(() => {
+      h.setState({
+        activeEmbeddable: { element: embeddable, state: "active" },
+      });
+    });
+
+    const guard = container.querySelector<HTMLElement>(
+      ".excalidraw__embeddable-canvas-guard",
+    );
+    expect(guard).not.toBeNull();
+
+    fireEvent.pointerMove(guard!, {
+      clientX: embeddable.x + 1,
+      clientY: embeddable.y + 1,
+    });
+
+    await waitFor(() => {
+      expect(h.state.activeEmbeddable).toBeNull();
+      expect(
+        container.querySelector<HTMLElement>(
+          ".excalidraw__embeddable-container__inner",
+        )?.style.pointerEvents,
+      ).toBe("none");
+    });
+  });
+
+  it("deactivates an interactive embeddable on Ctrl/Cmd keydown", async () => {
+    const { embeddable } = await renderGoogleDriveEmbeddable({
+      handleKeyboardGlobally: true,
+    });
+
+    mouse.moveTo(
+      embeddable.x + embeddable.width / 2,
+      embeddable.y + embeddable.height / 2,
+    );
+
+    await waitFor(() => {
+      expect(h.state.activeEmbeddable?.state).toBe("active");
+    });
+
+    fireEvent.keyDown(document, {
+      key: "Control",
+      ctrlKey: true,
+    });
+
+    await waitFor(() => {
+      expect(h.state.activeEmbeddable).toBeNull();
+    });
+  });
+
+  it("handles Ctrl/Cmd wheel on Drive embeddable guards", async () => {
+    const { container, embeddable } = await renderGoogleDriveEmbeddable();
+
+    act(() => {
+      h.setState({
+        activeEmbeddable: { element: embeddable, state: "active" },
+      });
+    });
+
+    const guard = container.querySelector<HTMLElement>(
+      ".excalidraw__embeddable-canvas-guard",
+    );
+    expect(guard).not.toBeNull();
+
+    const prevZoom = h.state.zoom.value;
+
+    fireEvent.wheel(guard!, {
+      clientX: embeddable.x + 1,
+      clientY: embeddable.y + 1,
+      ctrlKey: true,
+      deltaY: -100,
+    });
+
+    await waitFor(() => {
+      expect(h.state.activeEmbeddable).toBeNull();
+      expect(h.state.zoom.value).toBeGreaterThan(prevZoom);
+    });
+  });
+
+  it("deactivates a non-Drive interactive embeddable on Ctrl/Cmd keydown", async () => {
+    const { container, embeddable } = await renderYouTubeEmbeddable({
+      handleKeyboardGlobally: true,
+    });
+
+    setActiveEmbeddable(embeddable);
+
+    await waitFor(() => {
+      expect(
+        container.querySelector<HTMLElement>(
+          ".excalidraw__embeddable-container__inner",
+        )?.style.pointerEvents,
+      ).toBe("all");
+      expect(
+        container.querySelectorAll(".excalidraw__embeddable-canvas-guard"),
+      ).toHaveLength(0);
+    });
+
+    fireEvent.keyDown(document, {
+      key: "Control",
+      ctrlKey: true,
+    });
+
+    await waitFor(() => {
+      expect(h.state.activeEmbeddable).toBeNull();
+      expect(
+        container.querySelector<HTMLElement>(
+          ".excalidraw__embeddable-container__inner",
+        )?.style.pointerEvents,
+      ).toBe("none");
+    });
+  });
+
+  it("deactivates a non-Drive interactive embeddable on parent-observed pinch", async () => {
+    const { embeddable } = await renderYouTubeEmbeddable();
+
+    setActiveEmbeddable(embeddable);
+
+    fireEvent.pointerDown(GlobalTestState.interactiveCanvas, {
+      clientX: embeddable.x + 10,
+      clientY: embeddable.y + 10,
+      pointerId: 1,
+      pointerType: "touch",
+    });
+    fireEvent.pointerDown(GlobalTestState.interactiveCanvas, {
+      clientX: embeddable.x + 30,
+      clientY: embeddable.y + 30,
+      pointerId: 2,
+      pointerType: "touch",
+    });
+
+    await waitFor(() => {
+      expect(h.state.activeEmbeddable).toBeNull();
+    });
+
+    fireEvent.pointerUp(GlobalTestState.interactiveCanvas, {
+      pointerId: 1,
+      pointerType: "touch",
+    });
+    fireEvent.pointerUp(GlobalTestState.interactiveCanvas, {
+      pointerId: 2,
+      pointerType: "touch",
+    });
+  });
+
+  it("deactivates a non-Drive interactive embeddable on Safari gesturestart", async () => {
+    const { embeddable } = await renderYouTubeEmbeddable();
+
+    setActiveEmbeddable(embeddable);
+
+    act(() => {
+      document.dispatchEvent(
+        new Event("gesturestart", { bubbles: true, cancelable: true }),
+      );
+    });
+
+    await waitFor(() => {
+      expect(h.state.activeEmbeddable).toBeNull();
+    });
+  });
+});
@@ -615,32 +615,6 @@ describe("box-selection overlap mode", () => {

    assertSelectedElements([]);
  });
-
-  it("should not select a framed element when selection only overlaps its clipped-out outline", () => {
-    const frame = API.createElement({
-      type: "frame",
-      x: 100,
-      y: 100,
-      width: 100,
-      height: 100,
-    });
-    const rect1 = API.createElement({
-      type: "rectangle",
-      x: 50,
-      y: 50,
-      width: 200,
-      height: 200,
-      frameId: frame.id,
-      backgroundColor: "red",
-      fillStyle: "solid",
-    });
-
-    API.setElements([frame, rect1]);
-
-    boxSelect(40, 170, 70, 220);
-
-    assertSelectedElements([]);
-  });
 });

 describe("inner box-selection", () => {
@@ -1,833 +0,0 @@
-import { arrayToMap } from "@excalidraw/common";
-import {
-  pointFrom,
-  rangeInclusive,
-  type GlobalPoint,
-  type Radians,
-} from "@excalidraw/math";
-
-import type { ExcalidrawElement } from "@excalidraw/element/types";
-
-import { getDefaultAppState } from "../appState";
-import {
-  getElementsCorners,
-  getVisibleGaps,
-  getReferenceSnapPoints,
-  SnapCache,
-  snapDraggedElements,
-} from "../snapping";
-
-import { API } from "./helpers/api";
-
-import type {
-  AppClassProperties,
-  AppState,
-  NormalizedZoomValue,
-} from "../types";
-
-type ReferenceSnapPoints = NonNullable<
-  ReturnType<typeof SnapCache.getReferenceSnapPoints>
->;
-
-const NO_MODIFIER_KEYS = {
-  altKey: false,
-  ctrlKey: false,
-  metaKey: false,
-  shiftKey: false,
-};
-
-const createSnappingApp = (appState: Partial<AppState> = {}) =>
-  ({
-    props: {},
-    state: {
-      ...getDefaultAppState(),
-      objectsSnapModeEnabled: true,
-      width: 1000,
-      height: 1000,
-      offsetLeft: 0,
-      offsetTop: 0,
-      ...appState,
-    },
-  } as AppClassProperties);
-
-const getHorizontalPointSnapLineCoordinates = (
-  snapLines: ReturnType<typeof snapDraggedElements>["snapLines"],
-) => {
-  return snapLines
-    .filter((snapLine) => snapLine.type === "points")
-    .filter((snapLine) => {
-      const [firstPoint, lastPoint] = snapLine.points;
-
-      return firstPoint[1] === lastPoint[1];
-    })
-    .map((snapLine) => {
-      return snapLine.points[0][1];
-    })
-    .sort((a, b) => a - b);
-};
-
-const getVerticalPointSnapLineCoordinates = (
-  snapLines: ReturnType<typeof snapDraggedElements>["snapLines"],
-) => {
-  return snapLines
-    .filter((snapLine) => snapLine.type === "points")
-    .filter((snapLine) => {
-      const [firstPoint, lastPoint] = snapLine.points;
-
-      return firstPoint[0] === lastPoint[0];
-    })
-    .map((snapLine) => {
-      return snapLine.points[0][0];
-    })
-    .sort((a, b) => a - b);
-};
-
-const getHorizontalPointSnapLineMaxX = (
-  snapLines: ReturnType<typeof snapDraggedElements>["snapLines"],
-) => {
-  const horizontalSnapLine = snapLines
-    .filter((snapLine) => snapLine.type === "points")
-    .find((snapLine) => {
-      const [firstPoint, lastPoint] = snapLine.points;
-
-      return firstPoint[1] === lastPoint[1];
-    });
-
-  if (!horizontalSnapLine) {
-    return null;
-  }
-
-  return horizontalSnapLine.points[horizontalSnapLine.points.length - 1][0];
-};
-
-const getHorizontalPointSnapLineXRange = (
-  snapLines: ReturnType<typeof snapDraggedElements>["snapLines"],
-) => {
-  const horizontalSnapLine = snapLines
-    .filter((snapLine) => snapLine.type === "points")
-    .find((snapLine) => {
-      const [firstPoint, lastPoint] = snapLine.points;
-
-      return firstPoint[1] === lastPoint[1];
-    });
-
-  if (!horizontalSnapLine) {
-    return null;
-  }
-
-  return [
-    horizontalSnapLine.points[0][0],
-    horizontalSnapLine.points[horizontalSnapLine.points.length - 1][0],
-  ] as const;
-};
-
-const getHorizontalGapSnapLines = (
-  snapLines: ReturnType<typeof snapDraggedElements>["snapLines"],
-) => {
-  return snapLines.filter(
-    (snapLine) =>
-      snapLine.type === "gap" && snapLine.direction === "horizontal",
-  );
-};
-
-const getVerticalGapSnapLines = (
-  snapLines: ReturnType<typeof snapDraggedElements>["snapLines"],
-) => {
-  return snapLines.filter(
-    (snapLine) => snapLine.type === "gap" && snapLine.direction === "vertical",
-  );
-};
-
-const getPointKeys = (points: ReturnType<typeof getElementsCorners>) => {
-  return points.map((point) => point.join(","));
-};
-
-const getReferenceSnapPointKeys = (
-  elements: ExcalidrawElement[],
-  selectedElements: ExcalidrawElement[],
-  app: AppClassProperties,
-) => {
-  return new Set(
-    getReferenceSnapPoints(
-      elements,
-      selectedElements,
-      app.state,
-      arrayToMap(elements),
-    ).map((snapPoint) => snapPoint.point.join(",")),
-  );
-};
-
-const primeReferenceSnapPoints = (
-  elements: ExcalidrawElement[],
-  selectedElements: ExcalidrawElement[],
-) => {
-  const selectedElementIds = new Set(
-    selectedElements.map((element) => element.id),
-  );
-  const elementsMap = arrayToMap(elements);
-
-  SnapCache.setReferenceSnapPoints(
-    elements
-      .filter((element) => !selectedElementIds.has(element.id))
-      .flatMap((element) => {
-        const corners = getElementsCorners([element], elementsMap);
-
-        return corners.map((point, index) => ({
-          point,
-          type: index === corners.length - 1 ? "center" : "outer",
-          snapSourceId: element.id,
-        }));
-      }) as Parameters<typeof SnapCache.setReferenceSnapPoints>[0],
-  );
-};
-
-describe("snapping", () => {
-  afterEach(() => {
-    SnapCache.destroy();
-  });
-
-  it("does not use frame children as references when snapping outside elements", () => {
-    const frame = API.createElement({
-      type: "frame",
-      id: "frame",
-      x: 0,
-      y: 0,
-      width: 300,
-      height: 300,
-    });
-    const frameChild = API.createElement({
-      type: "rectangle",
-      id: "frameChild",
-      x: 37,
-      y: 53,
-      width: 71,
-      height: 83,
-      frameId: frame.id,
-    });
-    const selected = API.createElement({
-      type: "rectangle",
-      id: "selected",
-      x: 400,
-      y: 50,
-      width: 100,
-      height: 100,
-    });
-    const elements = [frame, frameChild, selected];
-    const app = createSnappingApp({
-      selectedElementIds: { [selected.id]: true },
-    });
-
-    const referenceSnapPointKeys = getReferenceSnapPointKeys(
-      elements,
-      [selected],
-      app,
-    );
-    const frameChildPointKeys = getPointKeys(
-      getElementsCorners([frameChild], arrayToMap(elements)),
-    );
-
-    expect(
-      frameChildPointKeys.some((pointKey) =>
-        referenceSnapPointKeys.has(pointKey),
-      ),
-    ).toBe(false);
-  });
-
-  it("uses frame siblings as references when snapping elements in the same frame", () => {
-    const frame = API.createElement({
-      type: "frame",
-      id: "frame",
-      x: 0,
-      y: 0,
-      width: 300,
-      height: 300,
-    });
-    const sibling = API.createElement({
-      type: "rectangle",
-      id: "sibling",
-      x: 37,
-      y: 53,
-      width: 71,
-      height: 83,
-      frameId: frame.id,
-    });
-    const selected = API.createElement({
-      type: "rectangle",
-      id: "selected",
-      x: 150,
-      y: 50,
-      width: 100,
-      height: 100,
-      frameId: frame.id,
-    });
-    const elements = [frame, sibling, selected];
-    const app = createSnappingApp({
-      selectedElementIds: { [selected.id]: true },
-    });
-
-    const referenceSnapPointKeys = getReferenceSnapPointKeys(
-      elements,
-      [selected],
-      app,
-    );
-    const siblingPointKeys = getPointKeys(
-      getElementsCorners([sibling], arrayToMap(elements)),
-    );
-
-    expect(
-      siblingPointKeys.some((pointKey) => referenceSnapPointKeys.has(pointKey)),
-    ).toBe(true);
-  });
-
-  it("does not use frame children as references when snapping the frame itself", () => {
-    const frame = API.createElement({
-      type: "frame",
-      id: "frame",
-      x: 0,
-      y: 0,
-      width: 300,
-      height: 300,
-    });
-    const frameChild = API.createElement({
-      type: "rectangle",
-      id: "frameChild",
-      x: 37,
-      y: 53,
-      width: 71,
-      height: 83,
-      frameId: frame.id,
-    });
-    const elements = [frame, frameChild];
-    const app = createSnappingApp({
-      selectedElementIds: { [frame.id]: true },
-    });
-
-    const referenceSnapPointKeys = getReferenceSnapPointKeys(
-      elements,
-      [frame],
-      app,
-    );
-    const frameChildPointKeys = getPointKeys(
-      getElementsCorners([frameChild], arrayToMap(elements)),
-    );
-
-    expect(
-      frameChildPointKeys.some((pointKey) =>
-        referenceSnapPointKeys.has(pointKey),
-      ),
-    ).toBe(false);
-  });
-
-  it("does not use frame children as visible gap references when snapping outside elements", () => {
-    const frame = API.createElement({
-      type: "frame",
-      id: "frame",
-      x: 0,
-      y: 0,
-      width: 500,
-      height: 300,
-    });
-    const frameChildA = API.createElement({
-      type: "rectangle",
-      id: "frameChildA",
-      x: 50,
-      y: 50,
-      width: 100,
-      height: 100,
-      frameId: frame.id,
-    });
-    const frameChildB = API.createElement({
-      type: "rectangle",
-      id: "frameChildB",
-      x: 250,
-      y: 50,
-      width: 100,
-      height: 100,
-      frameId: frame.id,
-    });
-    const selected = API.createElement({
-      type: "rectangle",
-      id: "selected",
-      x: 700,
-      y: 50,
-      width: 100,
-      height: 100,
-    });
-    const elements = [frame, frameChildA, frameChildB, selected];
-    const app = createSnappingApp({
-      selectedElementIds: { [selected.id]: true },
-    });
-
-    const visibleGaps = getVisibleGaps(
-      elements,
-      [selected],
-      app.state,
-      arrayToMap(elements),
-    );
-
-    expect(visibleGaps.horizontalGaps).toHaveLength(0);
-    expect(visibleGaps.verticalGaps).toHaveLength(0);
-  });
-
-  it("filters center and inner outer point snaplines for the same reference", () => {
-    const angle = 0.68 as Radians;
-    const reference = API.createElement({
-      type: "rectangle",
-      id: "reference",
-      x: 0,
-      y: 0,
-      width: 140,
-      height: 140,
-      angle,
-    });
-    const selected = API.createElement({
-      type: "rectangle",
-      id: "selected",
-      x: 200,
-      y: 0,
-      width: 140,
-      height: 140,
-      angle,
-    });
-    const elements = [reference, selected];
-    const app = createSnappingApp({
-      selectedElementIds: { [selected.id]: true },
-    });
-
-    primeReferenceSnapPoints(elements, [selected]);
-
-    const { snapLines } = snapDraggedElements(
-      elements,
-      { x: 0, y: 0 },
-      app,
-      NO_MODIFIER_KEYS,
-      arrayToMap(elements),
-    );
-
-    expect(getHorizontalPointSnapLineCoordinates(snapLines)).toHaveLength(2);
-  });
-
-  it("keeps a snapline that is redundant for one reference but needed for another", () => {
-    const angle = 0.68 as Radians;
-    const selected = API.createElement({
-      type: "rectangle",
-      id: "selected",
-      x: 200,
-      y: 0,
-      width: 140,
-      height: 140,
-      angle,
-    });
-    const elements = [selected];
-    const elementsMap = arrayToMap(elements);
-    const selectedSnapPoints = getElementsCorners([selected], elementsMap);
-    const outerSnapPoints = selectedSnapPoints.slice(0, -1);
-    const centerSnapPoint = selectedSnapPoints[selectedSnapPoints.length - 1];
-    const innerOuterSnapPoint = [...outerSnapPoints].sort(
-      (a, b) => a[1] - b[1],
-    )[1];
-    const app = createSnappingApp({
-      selectedElementIds: { [selected.id]: true },
-    });
-
-    const referenceSnapPoints: ReferenceSnapPoints = [
-      ...outerSnapPoints.map((point) => ({
-        point: pointFrom<GlobalPoint>(point[0] - 200, point[1]),
-        type: "outer" as const,
-        snapSourceId: "referenceA",
-      })),
-      {
-        point: pointFrom<GlobalPoint>(
-          centerSnapPoint[0] - 200,
-          centerSnapPoint[1],
-        ),
-        type: "center" as const,
-        snapSourceId: "referenceA",
-      },
-      {
-        point: pointFrom<GlobalPoint>(
-          innerOuterSnapPoint[0] - 300,
-          innerOuterSnapPoint[1],
-        ),
-        type: "outer" as const,
-        snapSourceId: "referenceB",
-      },
-    ];
-
-    SnapCache.setReferenceSnapPoints(referenceSnapPoints);
-
-    const { snapLines } = snapDraggedElements(
-      elements,
-      { x: 0, y: 0 },
-      app,
-      NO_MODIFIER_KEYS,
-      elementsMap,
-    );
-
-    expect(getHorizontalPointSnapLineCoordinates(snapLines)).toHaveLength(3);
-  });
-
-  it("keeps a center snapline when no outer snaplines imply it", () => {
-    const reference = API.createElement({
-      type: "rectangle",
-      id: "reference",
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 100,
-    });
-    const selected = API.createElement({
-      type: "rectangle",
-      id: "selected",
-      x: 200,
-      y: 25,
-      width: 50,
-      height: 50,
-    });
-    const elements = [reference, selected];
-    const app = createSnappingApp({
-      selectedElementIds: { [selected.id]: true },
-    });
-
-    primeReferenceSnapPoints(elements, [selected]);
-
-    const { snapLines } = snapDraggedElements(
-      elements,
-      { x: 0, y: 0 },
-      app,
-      NO_MODIFIER_KEYS,
-      arrayToMap(elements),
-    );
-
-    expect(getHorizontalPointSnapLineCoordinates(snapLines)).toEqual([50]);
-  });
-
-  it("filters center snaplines when matching outer offsets differ by rounding precision", () => {
-    const selected = API.createElement({
-      type: "rectangle",
-      id: "selected",
-      x: 2532.227563984471,
-      y: -1553.9657067952232,
-      width: 140.1015625,
-      height: 140.1015625,
-    });
-    const reference = API.createElement({
-      type: "rectangle",
-      id: "reference",
-      x: 2532.2275640966914,
-      y: -1299.4323092037737,
-      width: 140.1015625,
-      height: 140.1015625,
-    });
-    const elements = [reference, selected];
-    const app = createSnappingApp({
-      selectedElementIds: { [selected.id]: true },
-    });
-
-    primeReferenceSnapPoints(elements, [selected]);
-
-    const { snapLines } = snapDraggedElements(
-      elements,
-      { x: 0, y: 0 },
-      app,
-      NO_MODIFIER_KEYS,
-      arrayToMap(elements),
-    );
-
-    expect(getVerticalPointSnapLineCoordinates(snapLines)).toEqual([
-      2532.227564, 2672.329126,
-    ]);
-  });
-
-  it("keeps outer snaplines stable while dragging a snapped element through rounding-equivalent offsets", () => {
-    const referenceMiddle = API.createElement({
-      type: "rectangle",
-      id: "referenceMiddle",
-      x: 2532.22756398447,
-      y: -1553.9657067952237,
-      width: 140.1015625,
-      height: 140.1015625,
-    });
-    const referenceAbove = API.createElement({
-      type: "rectangle",
-      id: "referenceAbove",
-      x: 2532.2275637826165,
-      y: -1779.7363232531268,
-      width: 140.1015625,
-      height: 140.1015625,
-    });
-    const selected = API.createElement({
-      type: "rectangle",
-      id: "selected",
-      x: 2532.227563096691,
-      y: -1328.1950902037736,
-      width: 140.1015625,
-      height: 140.1015625,
-    });
-    const elements = [referenceAbove, referenceMiddle, selected];
-    const app = createSnappingApp({
-      selectedElementIds: { [selected.id]: true },
-    });
-
-    primeReferenceSnapPoints(elements, [selected]);
-
-    for (const dragOffsetX of [-4, -1, -0.1, 0, 0.1, 1, 4]) {
-      const { snapLines } = snapDraggedElements(
-        elements,
-        { x: dragOffsetX, y: 0 },
-        app,
-        NO_MODIFIER_KEYS,
-        arrayToMap(elements),
-      );
-      const coordinates = getVerticalPointSnapLineCoordinates(snapLines);
-
-      expect(coordinates).toHaveLength(2);
-      expect(coordinates[1] - coordinates[0]).toBeCloseTo(selected.width, 5);
-    }
-  });
-
-  it("keeps same-offset point snaps even across distant references", () => {
-    const selected = API.createElement({
-      type: "rectangle",
-      id: "selected",
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 100,
-    });
-    const elements = [selected];
-    const app = createSnappingApp({
-      selectedElementIds: { [selected.id]: true },
-    });
-
-    SnapCache.setReferenceSnapPoints([
-      {
-        point: pointFrom<GlobalPoint>(220, 50),
-        type: "center",
-        snapSourceId: "near",
-      },
-      {
-        point: pointFrom<GlobalPoint>(900, 50),
-        type: "center",
-        snapSourceId: "far",
-      },
-    ]);
-
-    const { snapLines } = snapDraggedElements(
-      elements,
-      { x: 0, y: 0 },
-      app,
-      NO_MODIFIER_KEYS,
-      arrayToMap(elements),
-    );
-
-    expect(getHorizontalPointSnapLineMaxX(snapLines)).toBe(900);
-  });
-
-  it("prefers a nearby point snap over a slightly better far offset", () => {
-    const selected = API.createElement({
-      type: "rectangle",
-      id: "selected",
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 100,
-    });
-    const elements = [selected];
-    const app = createSnappingApp({
-      selectedElementIds: { [selected.id]: true },
-    });
-
-    SnapCache.setReferenceSnapPoints([
-      {
-        point: pointFrom<GlobalPoint>(220, 54),
-        type: "center",
-        snapSourceId: "near",
-      },
-      {
-        point: pointFrom<GlobalPoint>(900, 50),
-        type: "center",
-        snapSourceId: "far",
-      },
-    ]);
-
-    const { snapOffset, snapLines } = snapDraggedElements(
-      elements,
-      { x: 0, y: 0 },
-      app,
-      NO_MODIFIER_KEYS,
-      arrayToMap(elements),
-    );
-
-    expect(snapOffset.y).toBe(4);
-    expect(getHorizontalPointSnapLineMaxX(snapLines)).toBe(220);
-  });
-
-  it("keeps same-offset point snaps when references form a continuous cluster", () => {
-    const selected = API.createElement({
-      type: "rectangle",
-      id: "selected",
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 100,
-    });
-    const elements = [selected];
-    const app = createSnappingApp({
-      selectedElementIds: { [selected.id]: true },
-    });
-
-    SnapCache.setReferenceSnapPoints([
-      {
-        point: pointFrom<GlobalPoint>(200, 50),
-        type: "center",
-        snapSourceId: "referenceA",
-      },
-      {
-        point: pointFrom<GlobalPoint>(350, 50),
-        type: "center",
-        snapSourceId: "referenceB",
-      },
-      {
-        point: pointFrom<GlobalPoint>(500, 50),
-        type: "center",
-        snapSourceId: "referenceC",
-      },
-    ]);
-
-    const { snapLines } = snapDraggedElements(
-      elements,
-      { x: 0, y: 0 },
-      app,
-      NO_MODIFIER_KEYS,
-      arrayToMap(elements),
-    );
-
-    expect(getHorizontalPointSnapLineMaxX(snapLines)).toBe(500);
-  });
-
-  it("keeps same-source same-offset point snaps across zoom-scaled cluster breaks", () => {
-    const reference = API.createElement({
-      type: "rectangle",
-      id: "reference",
-      x: 0,
-      y: 0,
-      width: 140.1015625,
-      height: 140.1015625,
-    });
-    const selected = API.createElement({
-      type: "rectangle",
-      id: "selected",
-      x: 338.608871112217,
-      y: 0,
-      width: 140.1015625,
-      height: 140.1015625,
-    });
-    const elements = [reference, selected];
-    const app = createSnappingApp({
-      selectedElementIds: { [selected.id]: true },
-      zoom: { value: 1.5 as NormalizedZoomValue },
-    });
-
-    primeReferenceSnapPoints(elements, [selected]);
-
-    const { snapLines } = snapDraggedElements(
-      elements,
-      { x: 0, y: 0 },
-      app,
-      NO_MODIFIER_KEYS,
-      arrayToMap(elements),
-    );
-
-    const range = getHorizontalPointSnapLineXRange(snapLines);
-
-    expect(range).not.toBe(null);
-    expect(range![0]).toBeCloseTo(reference.x, 6);
-    expect(range![1]).toBeCloseTo(selected.x + selected.width, 6);
-  });
-
-  it("renders gap snaplines when rounded bounds touch the reference gap overlap", () => {
-    const selected = API.createElement({
-      type: "rectangle",
-      id: "selected",
-      x: 0,
-      y: 0.0000004,
-      width: 100,
-      height: 100,
-    });
-    const elements = [selected];
-    const app = createSnappingApp({
-      selectedElementIds: { [selected.id]: true },
-    });
-
-    SnapCache.setVisibleGaps({
-      horizontalGaps: [
-        {
-          startBounds: [200, -100, 300, 0],
-          endBounds: [400, -100, 500, 0],
-          startSide: [pointFrom(300, -100), pointFrom(300, 0)],
-          endSide: [pointFrom(400, -100), pointFrom(400, 0)],
-          overlap: rangeInclusive(-100, 0),
-          length: 100,
-        },
-      ],
-      verticalGaps: [],
-    });
-
-    const { snapLines } = snapDraggedElements(
-      elements,
-      { x: 0, y: 0 },
-      app,
-      NO_MODIFIER_KEYS,
-      arrayToMap(elements),
-    );
-
-    expect(getHorizontalGapSnapLines(snapLines)).toHaveLength(2);
-  });
-
-  it("renders gap snaplines when the winning gap offset only differs by rounding precision", () => {
-    const selected = API.createElement({
-      type: "rectangle",
-      id: "selected",
-      x: 0,
-      y: 399.999999,
-      width: 100,
-      height: 100,
-    });
-    const elements = [selected];
-    const app = createSnappingApp({
-      selectedElementIds: { [selected.id]: true },
-    });
-
-    SnapCache.setReferenceSnapPoints([
-      {
-        point: pointFrom<GlobalPoint>(0, 399.999999),
-        type: "outer",
-        snapSourceId: "reference",
-      },
-    ]);
-    SnapCache.setVisibleGaps({
-      horizontalGaps: [],
-      verticalGaps: [
-        {
-          startBounds: [0, 100, 100, 200],
-          endBounds: [0, 250, 100, 350],
-          startSide: [pointFrom(0, 200), pointFrom(100, 200)],
-          endSide: [pointFrom(0, 250), pointFrom(100, 250)],
-          overlap: rangeInclusive(0, 100),
-          length: 50,
-        },
-      ],
-    });
-
-    const { snapLines } = snapDraggedElements(
-      elements,
-      { x: 0, y: 0 },
-      app,
-      NO_MODIFIER_KEYS,
-      arrayToMap(elements),
-    );
-
-    expect(getVerticalGapSnapLines(snapLines)).toHaveLength(2);
-  });
-});
@@ -315,10 +315,7 @@ export interface AppState {
  bindingPreference: "enabled" | "disabled";
  /** user preference whether arrow snap to midpoints while binding */
  isMidpointSnappingEnabled: boolean;
-  /**
-   * The bindable element the UI highlights for the user when an arrow is
-   * dragged or otherwise its endpoint being close to said element.
-   */
+  startBoundElement: NonDeleted<ExcalidrawBindableElement> | null;
  suggestedBinding: {
    element: NonDeleted<ExcalidrawBindableElement>;
    midPoint?: GlobalPoint;
@@ -350,11 +347,8 @@ export interface AppState {
    type: "selection" | "lasso";
    initialized: boolean;
  };
-
-  // Pen handling
  penMode: boolean;
  penDetected: boolean;
-
  exportBackground: boolean;
  exportEmbedScene: boolean;
  exportWithDarkMode: boolean;
@@ -478,9 +472,6 @@ export interface AppState {
  // as elements are unlocked, we remove the groupId from the elements
  // and also remove groupId from this map
  lockedMultiSelections: { [groupId: string]: true };
-  // Stores the current bind mode which is detemined at various points during
-  // a drag operation (like pointer position vs bindable element) but needed
-  // globally for calculating the binding strategy
  bindMode: BindMode;
 }

@@ -496,7 +487,10 @@ export type SearchMatch = {
  }[];
 };

-export type UIAppState = Omit<AppState, "cursorButton" | "scrollX" | "scrollY">;
+export type UIAppState = Omit<
+  AppState,
+  "startBoundElement" | "cursorButton" | "scrollX" | "scrollY"
+>;

 export type NormalizedZoomValue = number & { _brand: "normalizedZoom" };

@@ -876,13 +870,8 @@ export type PointerDownState = Readonly<{
    // Whether selected element(s) were duplicated, might change during the
    // pointer interaction
    hasBeenDuplicated: boolean;
-    // Whether the pointer is hitting the common bounding box of selected
-    // elements, which is useful for discriminating between selecitng
-    // the entire selection vs a specific element
    hasHitCommonBoundingBoxOfSelectedElements: boolean;
  };
-  // This is determined on the initial pointer down event to
-  // set various interaction modalities
  withCmdOrCtrl: boolean;
  drag: {
    // Might change during the pointer interaction
@@ -908,7 +897,6 @@ export type PointerDownState = Readonly<{
    onKeyUp: null | ((event: KeyboardEvent) => void);
  };
  boxSelection: {
-    // If the box selection tool is activated on pointer down
    hasOccurred: boolean;
  };
 }>;
@@ -98,6 +98,7 @@ exports[`exportToSvg > with default arguments 1`] = `
  "showHyperlinkPopup": false,
  "showWelcomeScreen": false,
  "snapLines": [],
+  "startBoundElement": null,
  "stats": {
    "open": false,
    "panels": 3,
Author	SHA1	Message	Date
dwelle	88dc25865b	wip2	2026-04-28 12:21:56 +02:00
dwelle	1d4e2731cf	wip	2026-04-28 12:18:18 +02:00