fix: Mobile arrow point drag broken (#9998 )

* fix: Mobile bound arrow point drag broken * fix:Check real point
fix: align MQ breakpoints and always use editor dimensions (#9991 )
2025-09-19 19:41:03 +02:00 · 2025-09-17 07:57:10 +00:00 · 2025-09-15 10:07:37 +02:00 · 2025-09-14 11:33:43 +00:00 · 2025-09-12 10:18:31 +10:00 · 2025-09-10 17:59:02 +02:00
80 changed files with 5122 additions and 1470 deletions
--- a/excalidraw-app/App.tsx
+++ b/excalidraw-app/App.tsx
@ -20,7 +20,6 @@ import {
  APP_NAME,
  EVENT,
  THEME,
-  TITLE_TIMEOUT,
  VERSION_TIMEOUT,
  debounce,
  getVersion,
@ -499,11 +498,6 @@ const ExcalidrawWrapper = () => {
      }
    };

-    const titleTimeout = setTimeout(
-      () => (document.title = APP_NAME),
-      TITLE_TIMEOUT,
-    );
-
    const syncData = debounce(() => {
      if (isTestEnv()) {
        return;
@ -594,7 +588,6 @@ const ExcalidrawWrapper = () => {
        visibilityChange,
        false,
      );
-      clearTimeout(titleTimeout);
    };
  }, [isCollabDisabled, collabAPI, excalidrawAPI, setLangCode]);

--- a/excalidraw-app/app_constants.ts
+++ b/excalidraw-app/app_constants.ts
@ -8,7 +8,8 @@ export const SYNC_BROWSER_TABS_TIMEOUT = 50;
 export const CURSOR_SYNC_TIMEOUT = 33; // ~30fps
 export const DELETED_ELEMENT_TIMEOUT = 24 * 60 * 60 * 1000; // 1 day

-export const FILE_UPLOAD_MAX_BYTES = 3 * 1024 * 1024; // 3 MiB
+// should be aligned with MAX_ALLOWED_FILE_BYTES
+export const FILE_UPLOAD_MAX_BYTES = 4 * 1024 * 1024; // 4 MiB
 // 1 year (https://stackoverflow.com/a/25201898/927631)
 export const FILE_CACHE_MAX_AGE_SEC = 31536000;

--- a/excalidraw-app/data/firebase.ts
+++ b/excalidraw-app/data/firebase.ts
@ -259,7 +259,9 @@ export const loadFromFirebase = async (
  }
  const storedScene = docSnap.data() as FirebaseStoredScene;
  const elements = getSyncableElements(
-    restoreElements(await decryptElements(storedScene, roomKey), null),
+    restoreElements(await decryptElements(storedScene, roomKey), null, {
+      deleteInvisibleElements: true,
+    }),
  );

  if (socket) {
--- a/excalidraw-app/data/index.ts
+++ b/excalidraw-app/data/index.ts
@ -258,11 +258,16 @@ export const loadScene = async (
      await importFromBackend(id, privateKey),
      localDataState?.appState,
      localDataState?.elements,
-      { repairBindings: true, refreshDimensions: false },
+      {
+        repairBindings: true,
+        refreshDimensions: false,
+        deleteInvisibleElements: true,
+      },
    );
  } else {
    data = restore(localDataState || null, null, null, {
      repairBindings: true,
+      deleteInvisibleElements: true,
    });
  }

--- a/excalidraw-app/index.html
+++ b/excalidraw-app/index.html
@ -2,9 +2,7 @@
 <html lang="en">
  <head>
    <meta charset="utf-8" />
-    <title>
-      Free, collaborative whiteboard • Hand-drawn look & feel | Excalidraw
-    </title>
+    <title>Excalidraw Whiteboard</title>
    <meta
      name="viewport"
      content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no, viewport-fit=cover, shrink-to-fit=no"
--- a/excalidraw-app/tests/MobileMenu.test.tsx
+++ b/excalidraw-app/tests/MobileMenu.test.tsx
@ -36,7 +36,7 @@ describe("Test MobileMenu", () => {
        },
        "isTouchScreen": false,
        "viewport": {
-          "isLandscape": false,
+          "isLandscape": true,
          "isMobile": true,
        },
      }
--- a/packages/common/src/constants.ts
+++ b/packages/common/src/constants.ts
@ -18,13 +18,20 @@ export const isChrome = navigator.userAgent.indexOf("Chrome") !== -1;
 export const isSafari =
  !isChrome && navigator.userAgent.indexOf("Safari") !== -1;
 export const isIOS =
-  /iPad|iPhone/.test(navigator.platform) ||
+  /iPad|iPhone/i.test(navigator.platform) ||
  // iPadOS 13+
  (navigator.userAgent.includes("Mac") && "ontouchend" in document);
 // keeping function so it can be mocked in test
 export const isBrave = () =>
  (navigator as any).brave?.isBrave?.name === "isBrave";

+export const isMobile =
+  isIOS ||
+  /android|webos|ipod|blackberry|iemobile|opera mini/i.test(
+    navigator.userAgent,
+  ) ||
+  /android|ios|ipod|blackberry|windows phone/i.test(navigator.platform);
+
 export const supportsResizeObserver =
  typeof window !== "undefined" && "ResizeObserver" in window;

@ -122,6 +129,7 @@ export const CLASSES = {
  ZOOM_ACTIONS: "zoom-actions",
  SEARCH_MENU_INPUT_WRAPPER: "layer-ui__search-inputWrapper",
  CONVERT_ELEMENT_TYPE_POPUP: "ConvertElementTypePopup",
+  SHAPE_ACTIONS_THEME_SCOPE: "shape-actions-theme-scope",
 };

 export const CJK_HAND_DRAWN_FALLBACK_FONT = "Xiaolai";
@ -252,13 +260,17 @@ export const IMAGE_MIME_TYPES = {
  jfif: "image/jfif",
 } as const;

-export const MIME_TYPES = {
+export const STRING_MIME_TYPES = {
  text: "text/plain",
  html: "text/html",
  json: "application/json",
  // excalidraw data
  excalidraw: "application/vnd.excalidraw+json",
  excalidrawlib: "application/vnd.excalidrawlib+json",
+} as const;
+
+export const MIME_TYPES = {
+  ...STRING_MIME_TYPES,
  // image-encoded excalidraw data
  "excalidraw.svg": "image/svg+xml",
  "excalidraw.png": "image/png",
@ -335,10 +347,17 @@ export const DEFAULT_UI_OPTIONS: AppProps["UIOptions"] = {

 // breakpoints
 // -----------------------------------------------------------------------------
-// md screen
-export const MQ_MAX_WIDTH_PORTRAIT = 730;
-export const MQ_MAX_WIDTH_LANDSCAPE = 1000;
-export const MQ_MAX_HEIGHT_LANDSCAPE = 500;
+
+// mobile: up to 699px
+export const MQ_MAX_MOBILE = 599;
+
+// tablets
+export const MQ_MIN_TABLET = MQ_MAX_MOBILE + 1; // lower bound (excludes phones)
+export const MQ_MAX_TABLET = 1400; // upper bound (excludes laptops/desktops)
+
+// desktop/laptop
+export const MQ_MIN_WIDTH_DESKTOP = 1440;
+
 // sidebar
 export const MQ_RIGHT_SIDEBAR_MIN_WIDTH = 1229;
 // -----------------------------------------------------------------------------
@ -515,3 +534,5 @@ export enum UserIdleState {
 * the start and end points)
 */
 export const LINE_POLYGON_POINT_MERGE_DISTANCE = 20;
+
+export const DOUBLE_TAP_POSITION_THRESHOLD = 35;
--- a/packages/common/src/utils.ts
+++ b/packages/common/src/utils.ts
@ -21,6 +21,8 @@ import {
  FONT_FAMILY,
  getFontFamilyFallbacks,
  isDarwin,
+  isAndroid,
+  isIOS,
  WINDOWS_EMOJI_FALLBACK_FONT,
 } from "./constants";

@ -1278,3 +1280,59 @@ export const reduceToCommonValue = <T, R = T>(

  return commonValue;
 };
+
+export const isMobileOrTablet = (): boolean => {
+  const ua = navigator.userAgent || "";
+  const platform = navigator.platform || "";
+  const uaData = (navigator as any).userAgentData as
+    | { mobile?: boolean; platform?: string }
+    | undefined;
+
+  // --- 1) chromium: prefer ua client hints -------------------------------
+  if (uaData) {
+    const plat = (uaData.platform || "").toLowerCase();
+    const isDesktopOS =
+      plat === "windows" ||
+      plat === "macos" ||
+      plat === "linux" ||
+      plat === "chrome os";
+    if (uaData.mobile === true) {
+      return true;
+    }
+    if (uaData.mobile === false && plat === "android") {
+      const looksTouchTablet =
+        matchMedia?.("(hover: none)").matches &&
+        matchMedia?.("(pointer: coarse)").matches;
+      return looksTouchTablet;
+    }
+    if (isDesktopOS) {
+      return false;
+    }
+  }
+
+  // --- 2) ios (includes ipad) --------------------------------------------
+  if (isIOS) {
+    return true;
+  }
+
+  // --- 3) android legacy ua fallback -------------------------------------
+  if (isAndroid) {
+    const isAndroidPhone = /Mobile/i.test(ua);
+    const isAndroidTablet = !isAndroidPhone;
+    if (isAndroidPhone || isAndroidTablet) {
+      const looksTouchTablet =
+        matchMedia?.("(hover: none)").matches &&
+        matchMedia?.("(pointer: coarse)").matches;
+      return looksTouchTablet;
+    }
+  }
+
+  // --- 4) last resort desktop exclusion ----------------------------------
+  const looksDesktopPlatform =
+    /Win|Linux|CrOS|Mac/.test(platform) ||
+    /Windows NT|X11|CrOS|Macintosh/.test(ua);
+  if (looksDesktopPlatform) {
+    return false;
+  }
+  return false;
+};
--- a/packages/element/src/Scene.ts
+++ b/packages/element/src/Scene.ts
@ -164,9 +164,14 @@ export class Scene {
    return this.frames;
  }

-  constructor(elements: ElementsMapOrArray | null = null) {
+  constructor(
+    elements: ElementsMapOrArray | null = null,
+    options?: {
+      skipValidation?: true;
+    },
+  ) {
    if (elements) {
-      this.replaceAllElements(elements);
+      this.replaceAllElements(elements, options);
    }
  }

@ -263,12 +268,19 @@ export class Scene {
    return didChange;
  }

-  replaceAllElements(nextElements: ElementsMapOrArray) {
+  replaceAllElements(
+    nextElements: ElementsMapOrArray,
+    options?: {
+      skipValidation?: true;
+    },
+  ) {
    // we do trust the insertion order on the map, though maybe we shouldn't and should prefer order defined by fractional indices
    const _nextElements = toArray(nextElements);
    const nextFrameLikes: ExcalidrawFrameLikeElement[] = [];

-    validateIndicesThrottled(_nextElements);
+    if (!options?.skipValidation) {
+      validateIndicesThrottled(_nextElements);
+    }

    this.elements = syncInvalidIndices(_nextElements);
    this.elementsMap.clear();
--- a/packages/element/src/bounds.ts
+++ b/packages/element/src/bounds.ts
@ -1126,7 +1126,9 @@ export interface BoundingBox {
 }

 export const getCommonBoundingBox = (
-  elements: ExcalidrawElement[] | readonly NonDeleted<ExcalidrawElement>[],
+  elements:
+    | readonly ExcalidrawElement[]
+    | readonly NonDeleted<ExcalidrawElement>[],
 ): BoundingBox => {
  const [minX, minY, maxX, maxY] = getCommonBounds(elements);
  return {
--- a/packages/element/src/delta.ts
+++ b/packages/element/src/delta.ts
@ -2,7 +2,6 @@ import {
  arrayToMap,
  arrayToObject,
  assertNever,
-  invariant,
  isDevEnv,
  isShallowEqual,
  isTestEnv,
@ -56,10 +55,10 @@ import { getNonDeletedGroupIds } from "./groups";

 import { orderByFractionalIndex, syncMovedIndices } from "./fractionalIndex";

-import { Scene } from "./Scene";
-
 import { StoreSnapshot } from "./store";

+import { Scene } from "./Scene";
+
 import type { BindableProp, BindingProp } from "./binding";

 import type { ElementUpdate } from "./mutateElement";
@ -154,10 +153,14 @@ export class Delta<T> {
  /**
   * Merges two deltas into a new one.
   */
-  public static merge<T>(delta1: Delta<T>, delta2: Delta<T>) {
+  public static merge<T>(
+    delta1: Delta<T>,
+    delta2: Delta<T>,
+    delta3: Delta<T> = Delta.empty(),
+  ) {
    return Delta.create(
-      { ...delta1.deleted, ...delta2.deleted },
-      { ...delta1.inserted, ...delta2.inserted },
+      { ...delta1.deleted, ...delta2.deleted, ...delta3.deleted },
+      { ...delta1.inserted, ...delta2.inserted, ...delta3.inserted },
    );
  }

@ -167,7 +170,7 @@ export class Delta<T> {
  public static mergeObjects<T extends { [key: string]: unknown }>(
    prev: T,
    added: T,
-    removed: T,
+    removed: T = {} as T,
  ) {
    const cloned = { ...prev };

@ -521,6 +524,10 @@ export interface DeltaContainer<T> {
 export class AppStateDelta implements DeltaContainer<AppState> {
  private constructor(public delta: Delta<ObservedAppState>) {}

+  public static create(delta: Delta<ObservedAppState>): AppStateDelta {
+    return new AppStateDelta(delta);
+  }
+
  public static calculate<T extends ObservedAppState>(
    prevAppState: T,
    nextAppState: T,
@ -551,7 +558,74 @@ export class AppStateDelta implements DeltaContainer<AppState> {
  }

  public squash(delta: AppStateDelta): this {
-    this.delta = Delta.merge(this.delta, delta.delta);
+    if (delta.isEmpty()) {
+      return this;
+    }
+
+    const mergedDeletedSelectedElementIds = Delta.mergeObjects(
+      this.delta.deleted.selectedElementIds ?? {},
+      delta.delta.deleted.selectedElementIds ?? {},
+    );
+
+    const mergedInsertedSelectedElementIds = Delta.mergeObjects(
+      this.delta.inserted.selectedElementIds ?? {},
+      delta.delta.inserted.selectedElementIds ?? {},
+    );
+
+    const mergedDeletedSelectedGroupIds = Delta.mergeObjects(
+      this.delta.deleted.selectedGroupIds ?? {},
+      delta.delta.deleted.selectedGroupIds ?? {},
+    );
+
+    const mergedInsertedSelectedGroupIds = Delta.mergeObjects(
+      this.delta.inserted.selectedGroupIds ?? {},
+      delta.delta.inserted.selectedGroupIds ?? {},
+    );
+
+    const mergedDeletedLockedMultiSelections = Delta.mergeObjects(
+      this.delta.deleted.lockedMultiSelections ?? {},
+      delta.delta.deleted.lockedMultiSelections ?? {},
+    );
+
+    const mergedInsertedLockedMultiSelections = Delta.mergeObjects(
+      this.delta.inserted.lockedMultiSelections ?? {},
+      delta.delta.inserted.lockedMultiSelections ?? {},
+    );
+
+    const mergedInserted: Partial<ObservedAppState> = {};
+    const mergedDeleted: Partial<ObservedAppState> = {};
+
+    if (
+      Object.keys(mergedDeletedSelectedElementIds).length ||
+      Object.keys(mergedInsertedSelectedElementIds).length
+    ) {
+      mergedDeleted.selectedElementIds = mergedDeletedSelectedElementIds;
+      mergedInserted.selectedElementIds = mergedInsertedSelectedElementIds;
+    }
+
+    if (
+      Object.keys(mergedDeletedSelectedGroupIds).length ||
+      Object.keys(mergedInsertedSelectedGroupIds).length
+    ) {
+      mergedDeleted.selectedGroupIds = mergedDeletedSelectedGroupIds;
+      mergedInserted.selectedGroupIds = mergedInsertedSelectedGroupIds;
+    }
+
+    if (
+      Object.keys(mergedDeletedLockedMultiSelections).length ||
+      Object.keys(mergedInsertedLockedMultiSelections).length
+    ) {
+      mergedDeleted.lockedMultiSelections = mergedDeletedLockedMultiSelections;
+      mergedInserted.lockedMultiSelections =
+        mergedInsertedLockedMultiSelections;
+    }
+
+    this.delta = Delta.merge(
+      this.delta,
+      delta.delta,
+      Delta.create(mergedDeleted, mergedInserted),
+    );
+
    return this;
  }

@ -561,70 +635,59 @@ export class AppStateDelta implements DeltaContainer<AppState> {
  ): [AppState, boolean] {
    try {
      const {
-        selectedElementIds: removedSelectedElementIds = {},
-        selectedGroupIds: removedSelectedGroupIds = {},
+        selectedElementIds: deletedSelectedElementIds = {},
+        selectedGroupIds: deletedSelectedGroupIds = {},
+        lockedMultiSelections: deletedLockedMultiSelections = {},
      } = this.delta.deleted;

      const {
-        selectedElementIds: addedSelectedElementIds = {},
-        selectedGroupIds: addedSelectedGroupIds = {},
-        selectedLinearElementId,
-        selectedLinearElementIsEditing,
+        selectedElementIds: insertedSelectedElementIds = {},
+        selectedGroupIds: insertedSelectedGroupIds = {},
+        lockedMultiSelections: insertedLockedMultiSelections = {},
+        selectedLinearElement: insertedSelectedLinearElement,
        ...directlyApplicablePartial
      } = this.delta.inserted;

      const mergedSelectedElementIds = Delta.mergeObjects(
        appState.selectedElementIds,
-        addedSelectedElementIds,
-        removedSelectedElementIds,
+        insertedSelectedElementIds,
+        deletedSelectedElementIds,
      );

      const mergedSelectedGroupIds = Delta.mergeObjects(
        appState.selectedGroupIds,
-        addedSelectedGroupIds,
-        removedSelectedGroupIds,
+        insertedSelectedGroupIds,
+        deletedSelectedGroupIds,
      );

-      let selectedLinearElement = appState.selectedLinearElement;
+      const mergedLockedMultiSelections = Delta.mergeObjects(
+        appState.lockedMultiSelections,
+        insertedLockedMultiSelections,
+        deletedLockedMultiSelections,
+      );

-      if (selectedLinearElementId === null) {
-        // Unselect linear element (visible change)
-        selectedLinearElement = null;
-      } else if (
-        selectedLinearElementId &&
-        nextElements.has(selectedLinearElementId)
-      ) {
-        selectedLinearElement = new LinearElementEditor(
-          nextElements.get(
-            selectedLinearElementId,
-          ) as NonDeleted<ExcalidrawLinearElement>,
-          nextElements,
-          selectedLinearElementIsEditing === true, // Can be unknown which is defaulted to false
-        );
-      }
-
-      if (
-        // Value being 'null' is equivaluent to unknown in this case because it only gets set
-        // to null when 'selectedLinearElementId' is set to null
-        selectedLinearElementIsEditing != null
-      ) {
-        invariant(
-          selectedLinearElement,
-          `selectedLinearElement is null when selectedLinearElementIsEditing is set to ${selectedLinearElementIsEditing}`,
-        );
-
-        selectedLinearElement = {
-          ...selectedLinearElement,
-          isEditing: selectedLinearElementIsEditing,
-        };
-      }
+      const selectedLinearElement =
+        insertedSelectedLinearElement &&
+        nextElements.has(insertedSelectedLinearElement.elementId)
+          ? new LinearElementEditor(
+              nextElements.get(
+                insertedSelectedLinearElement.elementId,
+              ) as NonDeleted<ExcalidrawLinearElement>,
+              nextElements,
+              insertedSelectedLinearElement.isEditing,
+            )
+          : null;

      const nextAppState = {
        ...appState,
        ...directlyApplicablePartial,
        selectedElementIds: mergedSelectedElementIds,
        selectedGroupIds: mergedSelectedGroupIds,
-        selectedLinearElement,
+        lockedMultiSelections: mergedLockedMultiSelections,
+        selectedLinearElement:
+          typeof insertedSelectedLinearElement !== "undefined"
+            ? selectedLinearElement
+            : appState.selectedLinearElement,
      };

      const constainsVisibleChanges = this.filterInvisibleChanges(
@ -753,64 +816,53 @@ export class AppStateDelta implements DeltaContainer<AppState> {
            }

            break;
-          case "selectedLinearElementId": {
-            const appStateKey = AppStateDelta.convertToAppStateKey(key);
-            const linearElement = nextAppState[appStateKey];
+          case "selectedLinearElement":
+            const nextLinearElement = nextAppState[key];

-            if (!linearElement) {
+            if (!nextLinearElement) {
              // previously there was a linear element (assuming visible), now there is none
              visibleDifferenceFlag.value = true;
            } else {
-              const element = nextElements.get(linearElement.elementId);
+              const element = nextElements.get(nextLinearElement.elementId);

              if (element && !element.isDeleted) {
                // previously there wasn't a linear element, now there is one which is visible
                visibleDifferenceFlag.value = true;
              } else {
                // there was assigned a linear element now, but it's deleted
-                nextAppState[appStateKey] = null;
+                nextAppState[key] = null;
              }
            }

            break;
-          }
-          case "selectedLinearElementIsEditing": {
-            // Changes in editing state are always visible
-            const prevIsEditing =
-              prevAppState.selectedLinearElement?.isEditing ?? false;
-            const nextIsEditing =
-              nextAppState.selectedLinearElement?.isEditing ?? false;
-
-            if (prevIsEditing !== nextIsEditing) {
-              visibleDifferenceFlag.value = true;
-            }
-            break;
-          }
-          case "lockedMultiSelections": {
+          case "lockedMultiSelections":
            const prevLockedUnits = prevAppState[key] || {};
            const nextLockedUnits = nextAppState[key] || {};

+            // TODO: this seems wrong, we are already doing this comparison generically above,
+            // hence instead we should check whether elements are actually visible,
+            // so that once these changes are applied they actually result in a visible change to the user
            if (!isShallowEqual(prevLockedUnits, nextLockedUnits)) {
              visibleDifferenceFlag.value = true;
            }
            break;
-          }
-          case "activeLockedId": {
+          case "activeLockedId":
            const prevHitLockedId = prevAppState[key] || null;
            const nextHitLockedId = nextAppState[key] || null;

+            // TODO: this seems wrong, we are already doing this comparison generically above,
+            // hence instead we should check whether elements are actually visible,
+            // so that once these changes are applied they actually result in a visible change to the user
            if (prevHitLockedId !== nextHitLockedId) {
              visibleDifferenceFlag.value = true;
            }
            break;
-          }
-          default: {
+          default:
            assertNever(
              key,
              `Unknown ObservedElementsAppState's key "${key}"`,
              true,
            );
-          }
        }
      }
    }
@ -818,15 +870,6 @@ export class AppStateDelta implements DeltaContainer<AppState> {
    return visibleDifferenceFlag.value;
  }

-  private static convertToAppStateKey(
-    key: keyof Pick<ObservedElementsAppState, "selectedLinearElementId">,
-  ): keyof Pick<AppState, "selectedLinearElement"> {
-    switch (key) {
-      case "selectedLinearElementId":
-        return "selectedLinearElement";
-    }
-  }
-
  private static filterSelectedElements(
    selectedElementIds: AppState["selectedElementIds"],
    elements: SceneElementsMap,
@ -891,8 +934,7 @@ export class AppStateDelta implements DeltaContainer<AppState> {
      editingGroupId,
      selectedGroupIds,
      selectedElementIds,
-      selectedLinearElementId,
-      selectedLinearElementIsEditing,
+      selectedLinearElement,
      croppingElementId,
      lockedMultiSelections,
      activeLockedId,
@ -946,12 +988,6 @@ export class AppStateDelta implements DeltaContainer<AppState> {
        "lockedMultiSelections",
        (prevValue) => (prevValue ?? {}) as ValueOf<T["lockedMultiSelections"]>,
      );
-      Delta.diffObjects(
-        deleted,
-        inserted,
-        "activeLockedId",
-        (prevValue) => (prevValue ?? null) as ValueOf<T["activeLockedId"]>,
-      );
    } catch (e) {
      // if postprocessing fails it does not make sense to bubble up, but let's make sure we know about it
      console.error(`Couldn't postprocess appstate change deltas.`);
@ -980,12 +1016,13 @@ type ElementPartial<TElement extends ExcalidrawElement = ExcalidrawElement> =
  Omit<Partial<Ordered<TElement>>, "id" | "updated" | "seed">;

 export type ApplyToOptions = {
-  excludedProperties: Set<keyof ElementPartial>;
+  excludedProperties?: Set<keyof ElementPartial>;
 };

 type ApplyToFlags = {
  containsVisibleDifference: boolean;
  containsZindexDifference: boolean;
+  applyDirection: "forward" | "backward" | undefined;
 };

 /**
@ -1074,18 +1111,27 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
    inserted,
  }: Delta<ElementPartial>) =>
    !!(
-      deleted.version &&
-      inserted.version &&
      // versions are required integers
-      Number.isInteger(deleted.version) &&
-      Number.isInteger(inserted.version) &&
-      // versions should be positive, zero included
-      deleted.version >= 0 &&
-      inserted.version >= 0 &&
-      // versions should never be the same
-      deleted.version !== inserted.version
+      (
+        Number.isInteger(deleted.version) &&
+        Number.isInteger(inserted.version) &&
+        // versions should be positive, zero included
+        deleted.version! >= 0 &&
+        inserted.version! >= 0 &&
+        // versions should never be the same
+        deleted.version !== inserted.version
+      )
    );

+  private static satisfiesUniqueInvariants = (
+    elementsDelta: ElementsDelta,
+    id: string,
+  ) => {
+    const { added, removed, updated } = elementsDelta;
+    // it's required that there is only one unique delta type per element
+    return [added[id], removed[id], updated[id]].filter(Boolean).length === 1;
+  };
+
  private static validate(
    elementsDelta: ElementsDelta,
    type: "added" | "removed" | "updated",
@ -1094,6 +1140,7 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
    for (const [id, delta] of Object.entries(elementsDelta[type])) {
      if (
        !this.satisfiesCommmonInvariants(delta) ||
+        !this.satisfiesUniqueInvariants(elementsDelta, id) ||
        !satifiesSpecialInvariants(delta)
      ) {
        console.error(
@ -1130,7 +1177,7 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
      const nextElement = nextElements.get(prevElement.id);

      if (!nextElement) {
-        const deleted = { ...prevElement, isDeleted: false } as ElementPartial;
+        const deleted = { ...prevElement } as ElementPartial;

        const inserted = {
          isDeleted: true,
@ -1144,7 +1191,11 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
          ElementsDelta.stripIrrelevantProps,
        );

-        removed[prevElement.id] = delta;
+        if (!prevElement.isDeleted) {
+          removed[prevElement.id] = delta;
+        } else {
+          updated[prevElement.id] = delta;
+        }
      }
    }

@ -1160,7 +1211,6 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {

        const inserted = {
          ...nextElement,
-          isDeleted: false,
        } as ElementPartial;

        const delta = Delta.create(
@ -1169,7 +1219,12 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
          ElementsDelta.stripIrrelevantProps,
        );

-        added[nextElement.id] = delta;
+        // ignore updates which would "delete" already deleted element
+        if (!nextElement.isDeleted) {
+          added[nextElement.id] = delta;
+        } else {
+          updated[nextElement.id] = delta;
+        }

        continue;
      }
@ -1198,10 +1253,7 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
          continue;
        }

-        // making sure there are at least some changes
-        if (!Delta.isEmpty(delta)) {
-          updated[nextElement.id] = delta;
-        }
+        updated[nextElement.id] = delta;
      }
    }

@ -1336,9 +1388,7 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
  public applyTo(
    elements: SceneElementsMap,
    snapshot: StoreSnapshot["elements"] = StoreSnapshot.empty().elements,
-    options: ApplyToOptions = {
-      excludedProperties: new Set(),
-    },
+    options?: ApplyToOptions,
  ): [SceneElementsMap, boolean] {
    let nextElements = new Map(elements) as SceneElementsMap;
    let changedElements: Map<string, OrderedExcalidrawElement>;
@ -1346,22 +1396,28 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
    const flags: ApplyToFlags = {
      containsVisibleDifference: false,
      containsZindexDifference: false,
+      applyDirection: undefined,
    };

    // mimic a transaction by applying deltas into `nextElements` (always new instance, no mutation)
    try {
      const applyDeltas = ElementsDelta.createApplier(
+        elements,
        nextElements,
        snapshot,
-        options,
        flags,
+        options,
      );

      const addedElements = applyDeltas(this.added);
      const removedElements = applyDeltas(this.removed);
      const updatedElements = applyDeltas(this.updated);

-      const affectedElements = this.resolveConflicts(elements, nextElements);
+      const affectedElements = this.resolveConflicts(
+        elements,
+        nextElements,
+        flags.applyDirection,
+      );

      // TODO: #7348 validate elements semantically and syntactically the changed elements, in case they would result data integrity issues
      changedElements = new Map([
@ -1385,22 +1441,15 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
    }

    try {
-      // the following reorder performs also mutations, but only on new instances of changed elements
-      // (unless something goes really bad and it fallbacks to fixing all invalid indices)
+      // the following reorder performs mutations, but only on new instances of changed elements,
+      // unless something goes really bad and it fallbacks to fixing all invalid indices
      nextElements = ElementsDelta.reorderElements(
        nextElements,
        changedElements,
        flags,
      );

-      // we don't have an up-to-date scene, as we can be just in the middle of applying history entry
-      // we also don't have a scene on the server
-      // so we are creating a temp scene just to query and mutate elements
-      const tempScene = new Scene(nextElements);
-
-      ElementsDelta.redrawTextBoundingBoxes(tempScene, changedElements);
-      // Need ordered nextElements to avoid z-index binding issues
-      ElementsDelta.redrawBoundArrows(tempScene, changedElements);
+      ElementsDelta.redrawElements(nextElements, changedElements);
    } catch (e) {
      console.error(
        `Couldn't mutate elements after applying elements change`,
@ -1416,47 +1465,112 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
  }

  public squash(delta: ElementsDelta): this {
+    if (delta.isEmpty()) {
+      return this;
+    }
+
    const { added, removed, updated } = delta;

+    const mergeBoundElements = (
+      prevDelta: Delta<ElementPartial>,
+      nextDelta: Delta<ElementPartial>,
+    ) => {
+      const mergedDeletedBoundElements =
+        Delta.mergeArrays(
+          prevDelta.deleted.boundElements ?? [],
+          nextDelta.deleted.boundElements ?? [],
+          undefined,
+          (x) => x.id,
+        ) ?? [];
+
+      const mergedInsertedBoundElements =
+        Delta.mergeArrays(
+          prevDelta.inserted.boundElements ?? [],
+          nextDelta.inserted.boundElements ?? [],
+          undefined,
+          (x) => x.id,
+        ) ?? [];
+
+      if (
+        !mergedDeletedBoundElements.length &&
+        !mergedInsertedBoundElements.length
+      ) {
+        return;
+      }
+
+      return Delta.create(
+        {
+          boundElements: mergedDeletedBoundElements,
+        },
+        {
+          boundElements: mergedInsertedBoundElements,
+        },
+      );
+    };
+
    for (const [id, nextDelta] of Object.entries(added)) {
-      const prevDelta = this.added[id];
+      const prevDelta = this.added[id] ?? this.removed[id] ?? this.updated[id];

      if (!prevDelta) {
        this.added[id] = nextDelta;
      } else {
-        this.added[id] = Delta.merge(prevDelta, nextDelta);
+        const mergedDelta = mergeBoundElements(prevDelta, nextDelta);
+        delete this.removed[id];
+        delete this.updated[id];
+
+        this.added[id] = Delta.merge(prevDelta, nextDelta, mergedDelta);
      }
    }

    for (const [id, nextDelta] of Object.entries(removed)) {
-      const prevDelta = this.removed[id];
+      const prevDelta = this.added[id] ?? this.removed[id] ?? this.updated[id];

      if (!prevDelta) {
        this.removed[id] = nextDelta;
      } else {
-        this.removed[id] = Delta.merge(prevDelta, nextDelta);
+        const mergedDelta = mergeBoundElements(prevDelta, nextDelta);
+        delete this.added[id];
+        delete this.updated[id];
+
+        this.removed[id] = Delta.merge(prevDelta, nextDelta, mergedDelta);
      }
    }

    for (const [id, nextDelta] of Object.entries(updated)) {
-      const prevDelta = this.updated[id];
+      const prevDelta = this.added[id] ?? this.removed[id] ?? this.updated[id];

      if (!prevDelta) {
        this.updated[id] = nextDelta;
      } else {
-        this.updated[id] = Delta.merge(prevDelta, nextDelta);
+        const mergedDelta = mergeBoundElements(prevDelta, nextDelta);
+        const updatedDelta = Delta.merge(prevDelta, nextDelta, mergedDelta);
+
+        if (prevDelta === this.added[id]) {
+          this.added[id] = updatedDelta;
+        } else if (prevDelta === this.removed[id]) {
+          this.removed[id] = updatedDelta;
+        } else {
+          this.updated[id] = updatedDelta;
+        }
      }
    }

+    if (isTestEnv() || isDevEnv()) {
+      ElementsDelta.validate(this, "added", ElementsDelta.satisfiesAddition);
+      ElementsDelta.validate(this, "removed", ElementsDelta.satisfiesRemoval);
+      ElementsDelta.validate(this, "updated", ElementsDelta.satisfiesUpdate);
+    }
+
    return this;
  }

  private static createApplier =
    (
+      prevElements: SceneElementsMap,
      nextElements: SceneElementsMap,
      snapshot: StoreSnapshot["elements"],
-      options: ApplyToOptions,
      flags: ApplyToFlags,
+      options?: ApplyToOptions,
    ) =>
    (deltas: Record<string, Delta<ElementPartial>>) => {
      const getElement = ElementsDelta.createGetter(
@ -1469,15 +1583,26 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
        const element = getElement(id, delta.inserted);

        if (element) {
-          const newElement = ElementsDelta.applyDelta(
+          const nextElement = ElementsDelta.applyDelta(
            element,
            delta,
-            options,
            flags,
+            options,
          );

-          nextElements.set(newElement.id, newElement);
-          acc.set(newElement.id, newElement);
+          nextElements.set(nextElement.id, nextElement);
+          acc.set(nextElement.id, nextElement);
+
+          if (!flags.applyDirection) {
+            const prevElement = prevElements.get(id);
+
+            if (prevElement) {
+              flags.applyDirection =
+                prevElement.version > nextElement.version
+                  ? "backward"
+                  : "forward";
+            }
+          }
        }

        return acc;
@ -1522,8 +1647,8 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
  private static applyDelta(
    element: OrderedExcalidrawElement,
    delta: Delta<ElementPartial>,
-    options: ApplyToOptions,
    flags: ApplyToFlags,
+    options?: ApplyToOptions,
  ) {
    const directlyApplicablePartial: Mutable<ElementPartial> = {};

@ -1537,7 +1662,7 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
        continue;
      }

-      if (options.excludedProperties.has(key)) {
+      if (options?.excludedProperties?.has(key)) {
        continue;
      }

@ -1577,7 +1702,7 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
        delta.deleted.index !== delta.inserted.index;
    }

-    return newElementWith(element, directlyApplicablePartial);
+    return newElementWith(element, directlyApplicablePartial, true);
  }

  /**
@ -1617,6 +1742,7 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
  private resolveConflicts(
    prevElements: SceneElementsMap,
    nextElements: SceneElementsMap,
+    applyDirection: "forward" | "backward" = "forward",
  ) {
    const nextAffectedElements = new Map<string, OrderedExcalidrawElement>();
    const updater = (
@ -1628,21 +1754,36 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
        return;
      }

+      const prevElement = prevElements.get(element.id);
+      const nextVersion =
+        applyDirection === "forward"
+          ? nextElement.version + 1
+          : nextElement.version - 1;
+
+      const elementUpdates = updates as ElementUpdate<OrderedExcalidrawElement>;
+
      let affectedElement: OrderedExcalidrawElement;

-      if (prevElements.get(element.id) === nextElement) {
+      if (prevElement === nextElement) {
        // create the new element instance in case we didn't modify the element yet
        // so that we won't end up in an incosistent state in case we would fail in the middle of mutations
        affectedElement = newElementWith(
          nextElement,
-          updates as ElementUpdate<OrderedExcalidrawElement>,
+          {
+            ...elementUpdates,
+            version: nextVersion,
+          },
+          true,
        );
      } else {
-        affectedElement = mutateElement(
-          nextElement,
-          nextElements,
-          updates as ElementUpdate<OrderedExcalidrawElement>,
-        );
+        affectedElement = mutateElement(nextElement, nextElements, {
+          ...elementUpdates,
+          // don't modify the version further, if it's already different
+          version:
+            prevElement?.version !== nextElement.version
+              ? nextElement.version
+              : nextVersion,
+        });
      }

      nextAffectedElements.set(affectedElement.id, affectedElement);
@ -1747,6 +1888,31 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
    BindableElement.rebindAffected(nextElements, nextElement(), updater);
  }

+  public static redrawElements(
+    nextElements: SceneElementsMap,
+    changedElements: Map<string, OrderedExcalidrawElement>,
+  ) {
+    try {
+      // we don't have an up-to-date scene, as we can be just in the middle of applying history entry
+      // we also don't have a scene on the server
+      // so we are creating a temp scene just to query and mutate elements
+      const tempScene = new Scene(nextElements, { skipValidation: true });
+
+      ElementsDelta.redrawTextBoundingBoxes(tempScene, changedElements);
+
+      // needs ordered nextElements to avoid z-index binding issues
+      ElementsDelta.redrawBoundArrows(tempScene, changedElements);
+    } catch (e) {
+      console.error(`Couldn't redraw elements`, e);
+
+      if (isTestEnv() || isDevEnv()) {
+        throw e;
+      }
+    } finally {
+      return nextElements;
+    }
+  }
+
  private static redrawTextBoundingBoxes(
    scene: Scene,
    changed: Map<string, OrderedExcalidrawElement>,
@ -1801,6 +1967,7 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
  ) {
    for (const element of changed.values()) {
      if (!element.isDeleted && isBindableElement(element)) {
+        // TODO: with precise bindings this is quite expensive, so consider optimisation so it's only triggered when the arrow does not intersect (imprecise) element bounds
        updateBoundElements(element, scene, {
          changedElements: changed,
        });
--- a/packages/element/src/elbowArrow.ts
+++ b/packages/element/src/elbowArrow.ts
@ -359,6 +359,12 @@ const handleSegmentRelease = (
    null,
  );

+  if (!restoredPoints || restoredPoints.length < 2) {
+    throw new Error(
+      "Property 'points' is required in the update returned by normalizeArrowElementUpdate()",
+    );
+  }
+
  const nextPoints: GlobalPoint[] = [];

  // First part of the arrow are the old points
@ -706,7 +712,7 @@ const handleEndpointDrag = (
  endGlobalPoint: GlobalPoint,
  hoveredStartElement: ExcalidrawBindableElement | null,
  hoveredEndElement: ExcalidrawBindableElement | null,
-) => {
+): ElementUpdate<ExcalidrawElbowArrowElement> => {
  let startIsSpecial = arrow.startIsSpecial ?? null;
  let endIsSpecial = arrow.endIsSpecial ?? null;
  const globalUpdatedPoints = updatedPoints.map((p, i) =>
@ -741,8 +747,15 @@ const handleEndpointDrag = (

  // Calculate the moving second point connection and add the start point
  {
-    const secondPoint = globalUpdatedPoints[startIsSpecial ? 2 : 1];
-    const thirdPoint = globalUpdatedPoints[startIsSpecial ? 3 : 2];
+    const secondPoint = globalUpdatedPoints.at(startIsSpecial ? 2 : 1);
+    const thirdPoint = globalUpdatedPoints.at(startIsSpecial ? 3 : 2);
+
+    if (!secondPoint || !thirdPoint) {
+      throw new Error(
+        `Second and third points must exist when handling endpoint drag (${startIsSpecial})`,
+      );
+    }
+
    const startIsHorizontal = headingIsHorizontal(startHeading);
    const secondIsHorizontal = headingIsHorizontal(
      vectorToHeading(vectorFromPoint(secondPoint, thirdPoint)),
@ -801,10 +814,19 @@ const handleEndpointDrag = (

  // Calculate the moving second to last point connection
  {
-    const secondToLastPoint =
-      globalUpdatedPoints[globalUpdatedPoints.length - (endIsSpecial ? 3 : 2)];
-    const thirdToLastPoint =
-      globalUpdatedPoints[globalUpdatedPoints.length - (endIsSpecial ? 4 : 3)];
+    const secondToLastPoint = globalUpdatedPoints.at(
+      globalUpdatedPoints.length - (endIsSpecial ? 3 : 2),
+    );
+    const thirdToLastPoint = globalUpdatedPoints.at(
+      globalUpdatedPoints.length - (endIsSpecial ? 4 : 3),
+    );
+
+    if (!secondToLastPoint || !thirdToLastPoint) {
+      throw new Error(
+        `Second and third to last points must exist when handling endpoint drag (${endIsSpecial})`,
+      );
+    }
+
    const endIsHorizontal = headingIsHorizontal(endHeading);
    const secondIsHorizontal = headingForPointIsHorizontal(
      thirdToLastPoint,
@ -2071,16 +2093,7 @@ const normalizeArrowElementUpdate = (
  nextFixedSegments: readonly FixedSegment[] | null,
  startIsSpecial?: ExcalidrawElbowArrowElement["startIsSpecial"],
  endIsSpecial?: ExcalidrawElbowArrowElement["startIsSpecial"],
-): {
-  points: LocalPoint[];
-  x: number;
-  y: number;
-  width: number;
-  height: number;
-  fixedSegments: readonly FixedSegment[] | null;
-  startIsSpecial?: ExcalidrawElbowArrowElement["startIsSpecial"];
-  endIsSpecial?: ExcalidrawElbowArrowElement["startIsSpecial"];
-} => {
+): ElementUpdate<ExcalidrawElbowArrowElement> => {
  const offsetX = global[0][0];
  const offsetY = global[0][1];
  let points = global.map((p) =>
--- a/packages/element/src/index.ts
+++ b/packages/element/src/index.ts
@ -97,6 +97,7 @@ export * from "./image";
 export * from "./linearElementEditor";
 export * from "./mutateElement";
 export * from "./newElement";
+export * from "./positionElementsOnGrid";
 export * from "./renderElement";
 export * from "./resizeElements";
 export * from "./resizeTest";
--- a/packages/element/src/positionElementsOnGrid.ts
+++ b/packages/element/src/positionElementsOnGrid.ts
@ -0,0 +1,112 @@
+import { getCommonBounds } from "./bounds";
+import { type ElementUpdate, newElementWith } from "./mutateElement";
+
+import type { ExcalidrawElement } from "./types";
+
+// TODO rewrite (mostly vibe-coded)
+export const positionElementsOnGrid = <TElement extends ExcalidrawElement>(
+  elements: TElement[] | TElement[][],
+  centerX: number,
+  centerY: number,
+  padding = 50,
+): TElement[] => {
+  // Ensure there are elements to position
+  if (!elements || elements.length === 0) {
+    return [];
+  }
+
+  const res: TElement[] = [];
+  // Normalize input to work with atomic units (groups of elements)
+  // If elements is a flat array, treat each element as its own atomic unit
+  const atomicUnits: TElement[][] = Array.isArray(elements[0])
+    ? (elements as TElement[][])
+    : (elements as TElement[]).map((element) => [element]);
+
+  // Determine the number of columns for atomic units
+  // A common approach for a "grid-like" layout without specific column constraints
+  // is to aim for a roughly square arrangement.
+  const numUnits = atomicUnits.length;
+  const numColumns = Math.max(1, Math.ceil(Math.sqrt(numUnits)));
+
+  // Group atomic units into rows based on the calculated number of columns
+  const rows: TElement[][][] = [];
+  for (let i = 0; i < numUnits; i += numColumns) {
+    rows.push(atomicUnits.slice(i, i + numColumns));
+  }
+
+  // Calculate properties for each row (total width, max height)
+  // and the total actual height of all row content.
+  let totalGridActualHeight = 0; // Sum of max heights of rows, without inter-row padding
+  const rowProperties = rows.map((rowUnits) => {
+    let rowWidth = 0;
+    let maxUnitHeightInRow = 0;
+
+    const unitBounds = rowUnits.map((unit) => {
+      const [minX, minY, maxX, maxY] = getCommonBounds(unit);
+      return {
+        elements: unit,
+        bounds: [minX, minY, maxX, maxY] as const,
+        width: maxX - minX,
+        height: maxY - minY,
+      };
+    });
+
+    unitBounds.forEach((unitBound, index) => {
+      rowWidth += unitBound.width;
+      // Add padding between units in the same row, but not after the last one
+      if (index < unitBounds.length - 1) {
+        rowWidth += padding;
+      }
+      if (unitBound.height > maxUnitHeightInRow) {
+        maxUnitHeightInRow = unitBound.height;
+      }
+    });
+
+    totalGridActualHeight += maxUnitHeightInRow;
+    return {
+      unitBounds,
+      width: rowWidth,
+      maxHeight: maxUnitHeightInRow,
+    };
+  });
+
+  // Calculate the total height of the grid including padding between rows
+  const totalGridHeightWithPadding =
+    totalGridActualHeight + Math.max(0, rows.length - 1) * padding;
+
+  // Calculate the starting Y position to center the entire grid vertically around centerY
+  let currentY = centerY - totalGridHeightWithPadding / 2;
+
+  // Position atomic units row by row
+  rowProperties.forEach((rowProp) => {
+    const { unitBounds, width: rowWidth, maxHeight: rowMaxHeight } = rowProp;
+
+    // Calculate the starting X for the current row to center it horizontally around centerX
+    let currentX = centerX - rowWidth / 2;
+
+    unitBounds.forEach((unitBound) => {
+      // Calculate the offset needed to position this atomic unit
+      const [originalMinX, originalMinY] = unitBound.bounds;
+      const offsetX = currentX - originalMinX;
+      const offsetY = currentY - originalMinY;
+
+      // Apply the offset to all elements in this atomic unit
+      unitBound.elements.forEach((element) => {
+        res.push(
+          newElementWith(element, {
+            x: element.x + offsetX,
+            y: element.y + offsetY,
+          } as ElementUpdate<TElement>),
+        );
+      });
+
+      // Move X for the next unit in the row
+      currentX += unitBound.width + padding;
+    });
+
+    // Move Y to the starting position for the next row
+    // This accounts for the tallest unit in the current row and the inter-row padding
+    currentY += rowMaxHeight + padding;
+  });
+  return res;
+};
--- a/packages/element/src/renderElement.ts
+++ b/packages/element/src/renderElement.ts
@ -1,7 +1,14 @@
 import rough from "roughjs/bin/rough";
 import { getStroke } from "perfect-freehand";

-import { isRightAngleRads } from "@excalidraw/math";
+import {
+  type GlobalPoint,
+  isRightAngleRads,
+  lineSegment,
+  pointFrom,
+  pointRotateRads,
+  type Radians,
+} from "@excalidraw/math";

 import {
  BOUND_TEXT_PADDING,
@ -14,6 +21,7 @@ import {
  getFontString,
  isRTL,
  getVerticalOffset,
+  invariant,
 } from "@excalidraw/common";

 import type {
@ -32,7 +40,7 @@ import type {
  InteractiveCanvasRenderConfig,
 } from "@excalidraw/excalidraw/scene/types";

-import { getElementAbsoluteCoords } from "./bounds";
+import { getElementAbsoluteCoords, getElementBounds } from "./bounds";
 import { getUncroppedImageElement } from "./cropElement";
 import { LinearElementEditor } from "./linearElementEditor";
 import {
@ -1039,6 +1047,66 @@ export function getFreeDrawPath2D(element: ExcalidrawFreeDrawElement) {
 }

 export function getFreeDrawSvgPath(element: ExcalidrawFreeDrawElement) {
+  return getSvgPathFromStroke(getFreedrawOutlinePoints(element));
+}
+
+export function getFreedrawOutlineAsSegments(
+  element: ExcalidrawFreeDrawElement,
+  points: [number, number][],
+  elementsMap: ElementsMap,
+) {
+  const bounds = getElementBounds(
+    {
+      ...element,
+      angle: 0 as Radians,
+    },
+    elementsMap,
+  );
+  const center = pointFrom<GlobalPoint>(
+    (bounds[0] + bounds[2]) / 2,
+    (bounds[1] + bounds[3]) / 2,
+  );
+
+  invariant(points.length >= 2, "Freepath outline must have at least 2 points");
+
+  return points.slice(2).reduce(
+    (acc, curr) => {
+      acc.push(
+        lineSegment<GlobalPoint>(
+          acc[acc.length - 1][1],
+          pointRotateRads(
+            pointFrom<GlobalPoint>(curr[0] + element.x, curr[1] + element.y),
+            center,
+            element.angle,
+          ),
+        ),
+      );
+      return acc;
+    },
+    [
+      lineSegment<GlobalPoint>(
+        pointRotateRads(
+          pointFrom<GlobalPoint>(
+            points[0][0] + element.x,
+            points[0][1] + element.y,
+          ),
+          center,
+          element.angle,
+        ),
+        pointRotateRads(
+          pointFrom<GlobalPoint>(
+            points[1][0] + element.x,
+            points[1][1] + element.y,
+          ),
+          center,
+          element.angle,
+        ),
+      ),
+    ],
+  );
+}
+
+export function getFreedrawOutlinePoints(element: ExcalidrawFreeDrawElement) {
  // If input points are empty (should they ever be?) return a dot
  const inputPoints = element.simulatePressure
    ? element.points
@ -1057,7 +1125,7 @@ export function getFreeDrawSvgPath(element: ExcalidrawFreeDrawElement) {
    last: !!element.lastCommittedPoint, // LastCommittedPoint is added on pointerup
  };

-  return getSvgPathFromStroke(getStroke(inputPoints as number[][], options));
+  return getStroke(inputPoints as number[][], options) as [number, number][];
 }

 function med(A: number[], B: number[]) {
--- a/packages/element/src/resizeElements.ts
+++ b/packages/element/src/resizeElements.ts
@ -35,6 +35,7 @@ import {
  getContainerElement,
  handleBindTextResize,
  getBoundTextMaxWidth,
+  computeBoundTextPosition,
 } from "./textElement";
 import {
  getMinTextElementWidth,
@ -225,7 +226,16 @@ const rotateSingleElement = (
      scene.getElement<ExcalidrawTextElementWithContainer>(boundTextElementId);

    if (textElement && !isArrowElement(element)) {
-      scene.mutateElement(textElement, { angle });
+      const { x, y } = computeBoundTextPosition(
+        element,
+        textElement,
+        scene.getNonDeletedElementsMap(),
+      );
+      scene.mutateElement(textElement, {
+        angle,
+        x,
+        y,
+      });
    }
  }
 };
@ -416,9 +426,15 @@ const rotateMultipleElements = (

      const boundText = getBoundTextElement(element, elementsMap);
      if (boundText && !isArrowElement(element)) {
+        const { x, y } = computeBoundTextPosition(
+          element,
+          boundText,
+          elementsMap,
+        );
+
        scene.mutateElement(boundText, {
-          x: boundText.x + (rotatedCX - cx),
-          y: boundText.y + (rotatedCY - cy),
+          x,
+          y,
          angle: normalizeRadians((centerAngle + origAngle) as Radians),
        });
      }
--- a/packages/element/src/store.ts
+++ b/packages/element/src/store.ts
@ -552,10 +552,26 @@ export class StoreDelta {
  public static load({
    id,
    elements: { added, removed, updated },
+    appState: { delta: appStateDelta },
  }: DTO<StoreDelta>) {
    const elements = ElementsDelta.create(added, removed, updated);
+    const appState = AppStateDelta.create(appStateDelta);

-    return new this(id, elements, AppStateDelta.empty());
+    return new this(id, elements, appState);
+  }
+
+  /**
+   * Squash the passed deltas into the aggregated delta instance.
+   */
+  public static squash(...deltas: StoreDelta[]) {
+    const aggregatedDelta = StoreDelta.empty();
+
+    for (const delta of deltas) {
+      aggregatedDelta.elements.squash(delta.elements);
+      aggregatedDelta.appState.squash(delta.appState);
+    }
+
+    return aggregatedDelta;
  }

  /**
@ -572,9 +588,7 @@ export class StoreDelta {
    delta: StoreDelta,
    elements: SceneElementsMap,
    appState: AppState,
-    options: ApplyToOptions = {
-      excludedProperties: new Set(),
-    },
+    options?: ApplyToOptions,
  ): [SceneElementsMap, AppState, boolean] {
    const [nextElements, elementsContainVisibleChange] = delta.elements.applyTo(
      elements,
@ -613,6 +627,10 @@ export class StoreDelta {
    );
  }

+  public static empty() {
+    return StoreDelta.create(ElementsDelta.empty(), AppStateDelta.empty());
+  }
+
  public isEmpty() {
    return this.elements.isEmpty() && this.appState.isEmpty();
  }
@ -978,8 +996,7 @@ const getDefaultObservedAppState = (): ObservedAppState => {
    viewBackgroundColor: COLOR_PALETTE.white,
    selectedElementIds: {},
    selectedGroupIds: {},
-    selectedLinearElementId: null,
-    selectedLinearElementIsEditing: null,
+    selectedLinearElement: null,
    croppingElementId: null,
    activeLockedId: null,
    lockedMultiSelections: {},
@ -998,14 +1015,12 @@ export const getObservedAppState = (
    croppingElementId: appState.croppingElementId,
    activeLockedId: appState.activeLockedId,
    lockedMultiSelections: appState.lockedMultiSelections,
-    selectedLinearElementId:
-      (appState as AppState).selectedLinearElement?.elementId ??
-      (appState as ObservedAppState).selectedLinearElementId ??
-      null,
-    selectedLinearElementIsEditing:
-      (appState as AppState).selectedLinearElement?.isEditing ??
-      (appState as ObservedAppState).selectedLinearElementIsEditing ??
-      null,
+    selectedLinearElement: appState.selectedLinearElement
+      ? {
+          elementId: appState.selectedLinearElement.elementId,
+          isEditing: !!appState.selectedLinearElement.isEditing,
+        }
+      : null,
  };

  Reflect.defineProperty(observedAppState, hiddenObservedAppStateProp, {
--- a/packages/element/src/textElement.ts
+++ b/packages/element/src/textElement.ts
@ -10,12 +10,12 @@ import {
  invariant,
 } from "@excalidraw/common";

+import { pointFrom, pointRotateRads, type Radians } from "@excalidraw/math";
+
 import type { AppState } from "@excalidraw/excalidraw/types";

 import type { ExtractSetType } from "@excalidraw/common/utility-types";

-import type { Radians } from "@excalidraw/math";
-
 import {
  resetOriginalContainerCache,
  updateOriginalContainerCache,
@ -254,6 +254,26 @@ export const computeBoundTextPosition = (
    x =
      containerCoords.x + (maxContainerWidth / 2 - boundTextElement.width / 2);
  }
+  const angle = (container.angle ?? 0) as Radians;
+
+  if (angle !== 0) {
+    const contentCenter = pointFrom(
+      containerCoords.x + maxContainerWidth / 2,
+      containerCoords.y + maxContainerHeight / 2,
+    );
+    const textCenter = pointFrom(
+      x + boundTextElement.width / 2,
+      y + boundTextElement.height / 2,
+    );
+
+    const [rx, ry] = pointRotateRads(textCenter, contentCenter, angle);
+
+    return {
+      x: rx - boundTextElement.width / 2,
+      y: ry - boundTextElement.height / 2,
+    };
+  }
+
  return { x, y };
 };

--- a/packages/element/tests/delta.test.tsx
+++ b/packages/element/tests/delta.test.tsx
@ -1,13 +1,345 @@
+import { API } from "@excalidraw/excalidraw/tests/helpers/api";
+
 import type { ObservedAppState } from "@excalidraw/excalidraw/types";
 import type { LinearElementEditor } from "@excalidraw/element";
+import type { SceneElementsMap } from "@excalidraw/element/types";

-import { AppStateDelta } from "../src/delta";
+import { AppStateDelta, Delta, ElementsDelta } from "../src/delta";
+
+describe("ElementsDelta", () => {
+  describe("elements delta calculation", () => {
+    it("should not throw when element gets removed but was already deleted", () => {
+      const element = API.createElement({
+        type: "rectangle",
+        x: 100,
+        y: 100,
+        isDeleted: true,
+      });
+
+      const prevElements = new Map([[element.id, element]]);
+      const nextElements = new Map();
+
+      expect(() =>
+        ElementsDelta.calculate(prevElements, nextElements),
+      ).not.toThrow();
+    });
+
+    it("should not throw when adding element as already deleted", () => {
+      const element = API.createElement({
+        type: "rectangle",
+        x: 100,
+        y: 100,
+        isDeleted: true,
+      });
+
+      const prevElements = new Map();
+      const nextElements = new Map([[element.id, element]]);
+
+      expect(() =>
+        ElementsDelta.calculate(prevElements, nextElements),
+      ).not.toThrow();
+    });
+
+    it("should create updated delta even when there is only version and versionNonce change", () => {
+      const baseElement = API.createElement({
+        type: "rectangle",
+        x: 100,
+        y: 100,
+        strokeColor: "#000000",
+        backgroundColor: "#ffffff",
+      });
+
+      const modifiedElement = {
+        ...baseElement,
+        version: baseElement.version + 1,
+        versionNonce: baseElement.versionNonce + 1,
+      };
+
+      // Create maps for the delta calculation
+      const prevElements = new Map([[baseElement.id, baseElement]]);
+      const nextElements = new Map([[modifiedElement.id, modifiedElement]]);
+
+      // Calculate the delta
+      const delta = ElementsDelta.calculate(
+        prevElements as SceneElementsMap,
+        nextElements as SceneElementsMap,
+      );
+
+      expect(delta).toEqual(
+        ElementsDelta.create(
+          {},
+          {},
+          {
+            [baseElement.id]: Delta.create(
+              {
+                version: baseElement.version,
+                versionNonce: baseElement.versionNonce,
+              },
+              {
+                version: baseElement.version + 1,
+                versionNonce: baseElement.versionNonce + 1,
+              },
+            ),
+          },
+        ),
+      );
+    });
+  });
+
+  describe("squash", () => {
+    it("should not squash when second delta is empty", () => {
+      const updatedDelta = Delta.create(
+        { x: 100, version: 1, versionNonce: 1 },
+        { x: 200, version: 2, versionNonce: 2 },
+      );
+
+      const elementsDelta1 = ElementsDelta.create(
+        {},
+        {},
+        { id1: updatedDelta },
+      );
+      const elementsDelta2 = ElementsDelta.empty();
+      const elementsDelta = elementsDelta1.squash(elementsDelta2);
+
+      expect(elementsDelta.isEmpty()).toBeFalsy();
+      expect(elementsDelta).toBe(elementsDelta1);
+      expect(elementsDelta.updated.id1).toBe(updatedDelta);
+    });
+
+    it("should squash mutually exclusive delta types", () => {
+      const addedDelta = Delta.create(
+        { x: 100, version: 1, versionNonce: 1, isDeleted: true },
+        { x: 200, version: 2, versionNonce: 2, isDeleted: false },
+      );
+
+      const removedDelta = Delta.create(
+        { x: 100, version: 1, versionNonce: 1, isDeleted: false },
+        { x: 200, version: 2, versionNonce: 2, isDeleted: true },
+      );
+
+      const updatedDelta = Delta.create(
+        { x: 100, version: 1, versionNonce: 1 },
+        { x: 200, version: 2, versionNonce: 2 },
+      );
+
+      const elementsDelta1 = ElementsDelta.create(
+        { id1: addedDelta },
+        { id2: removedDelta },
+        {},
+      );
+
+      const elementsDelta2 = ElementsDelta.create(
+        {},
+        {},
+        { id3: updatedDelta },
+      );
+
+      const elementsDelta = elementsDelta1.squash(elementsDelta2);
+
+      expect(elementsDelta.isEmpty()).toBeFalsy();
+      expect(elementsDelta).toBe(elementsDelta1);
+      expect(elementsDelta.added.id1).toBe(addedDelta);
+      expect(elementsDelta.removed.id2).toBe(removedDelta);
+      expect(elementsDelta.updated.id3).toBe(updatedDelta);
+    });
+
+    it("should squash the same delta types", () => {
+      const elementsDelta1 = ElementsDelta.create(
+        {
+          id1: Delta.create(
+            { x: 100, version: 1, versionNonce: 1, isDeleted: true },
+            { x: 200, version: 2, versionNonce: 2, isDeleted: false },
+          ),
+        },
+        {
+          id2: Delta.create(
+            { x: 100, version: 1, versionNonce: 1, isDeleted: false },
+            { x: 200, version: 2, versionNonce: 2, isDeleted: true },
+          ),
+        },
+        {
+          id3: Delta.create(
+            { x: 100, version: 1, versionNonce: 1 },
+            { x: 200, version: 2, versionNonce: 2 },
+          ),
+        },
+      );
+
+      const elementsDelta2 = ElementsDelta.create(
+        {
+          id1: Delta.create(
+            { y: 100, version: 2, versionNonce: 2, isDeleted: true },
+            { y: 200, version: 3, versionNonce: 3, isDeleted: false },
+          ),
+        },
+        {
+          id2: Delta.create(
+            { y: 100, version: 2, versionNonce: 2, isDeleted: false },
+            { y: 200, version: 3, versionNonce: 3, isDeleted: true },
+          ),
+        },
+        {
+          id3: Delta.create(
+            { y: 100, version: 2, versionNonce: 2 },
+            { y: 200, version: 3, versionNonce: 3 },
+          ),
+        },
+      );
+
+      const elementsDelta = elementsDelta1.squash(elementsDelta2);
+
+      expect(elementsDelta.isEmpty()).toBeFalsy();
+      expect(elementsDelta).toBe(elementsDelta1);
+      expect(elementsDelta.added.id1).toEqual(
+        Delta.create(
+          { x: 100, y: 100, version: 2, versionNonce: 2, isDeleted: true },
+          { x: 200, y: 200, version: 3, versionNonce: 3, isDeleted: false },
+        ),
+      );
+      expect(elementsDelta.removed.id2).toEqual(
+        Delta.create(
+          { x: 100, y: 100, version: 2, versionNonce: 2, isDeleted: false },
+          { x: 200, y: 200, version: 3, versionNonce: 3, isDeleted: true },
+        ),
+      );
+      expect(elementsDelta.updated.id3).toEqual(
+        Delta.create(
+          { x: 100, y: 100, version: 2, versionNonce: 2 },
+          { x: 200, y: 200, version: 3, versionNonce: 3 },
+        ),
+      );
+    });
+
+    it("should squash different delta types ", () => {
+      // id1: added   -> updated => added
+      // id2: removed -> added   => added
+      // id3: updated -> removed => removed
+      const elementsDelta1 = ElementsDelta.create(
+        {
+          id1: Delta.create(
+            { x: 100, version: 1, versionNonce: 1, isDeleted: true },
+            { x: 101, version: 2, versionNonce: 2, isDeleted: false },
+          ),
+        },
+        {
+          id2: Delta.create(
+            { x: 200, version: 1, versionNonce: 1, isDeleted: false },
+            { x: 201, version: 2, versionNonce: 2, isDeleted: true },
+          ),
+        },
+        {
+          id3: Delta.create(
+            { x: 300, version: 1, versionNonce: 1 },
+            { x: 301, version: 2, versionNonce: 2 },
+          ),
+        },
+      );
+
+      const elementsDelta2 = ElementsDelta.create(
+        {
+          id2: Delta.create(
+            { y: 200, version: 2, versionNonce: 2, isDeleted: true },
+            { y: 201, version: 3, versionNonce: 3, isDeleted: false },
+          ),
+        },
+        {
+          id3: Delta.create(
+            { y: 300, version: 2, versionNonce: 2, isDeleted: false },
+            { y: 301, version: 3, versionNonce: 3, isDeleted: true },
+          ),
+        },
+        {
+          id1: Delta.create(
+            { y: 100, version: 2, versionNonce: 2 },
+            { y: 101, version: 3, versionNonce: 3 },
+          ),
+        },
+      );
+
+      const elementsDelta = elementsDelta1.squash(elementsDelta2);
+
+      expect(elementsDelta.isEmpty()).toBeFalsy();
+      expect(elementsDelta).toBe(elementsDelta1);
+      expect(elementsDelta.added).toEqual({
+        id1: Delta.create(
+          { x: 100, y: 100, version: 2, versionNonce: 2, isDeleted: true },
+          { x: 101, y: 101, version: 3, versionNonce: 3, isDeleted: false },
+        ),
+        id2: Delta.create(
+          { x: 200, y: 200, version: 2, versionNonce: 2, isDeleted: true },
+          { x: 201, y: 201, version: 3, versionNonce: 3, isDeleted: false },
+        ),
+      });
+      expect(elementsDelta.removed).toEqual({
+        id3: Delta.create(
+          { x: 300, y: 300, version: 2, versionNonce: 2, isDeleted: false },
+          { x: 301, y: 301, version: 3, versionNonce: 3, isDeleted: true },
+        ),
+      });
+      expect(elementsDelta.updated).toEqual({});
+    });
+
+    it("should squash bound elements", () => {
+      const elementsDelta1 = ElementsDelta.create(
+        {},
+        {},
+        {
+          id1: Delta.create(
+            {
+              version: 1,
+              versionNonce: 1,
+              boundElements: [{ id: "t1", type: "text" }],
+            },
+            {
+              version: 2,
+              versionNonce: 2,
+              boundElements: [{ id: "t2", type: "text" }],
+            },
+          ),
+        },
+      );
+
+      const elementsDelta2 = ElementsDelta.create(
+        {},
+        {},
+        {
+          id1: Delta.create(
+            {
+              version: 2,
+              versionNonce: 2,
+              boundElements: [{ id: "a1", type: "arrow" }],
+            },
+            {
+              version: 3,
+              versionNonce: 3,
+              boundElements: [{ id: "a2", type: "arrow" }],
+            },
+          ),
+        },
+      );
+
+      const elementsDelta = elementsDelta1.squash(elementsDelta2);
+
+      expect(elementsDelta.updated.id1.deleted.boundElements).toEqual([
+        { id: "t1", type: "text" },
+        { id: "a1", type: "arrow" },
+      ]);
+      expect(elementsDelta.updated.id1.inserted.boundElements).toEqual([
+        { id: "t2", type: "text" },
+        { id: "a2", type: "arrow" },
+      ]);
+    });
+  });
+});

 describe("AppStateDelta", () => {
  describe("ensure stable delta properties order", () => {
    it("should maintain stable order for root properties", () => {
      const name = "untitled scene";
-      const selectedLinearElementId = "id1" as LinearElementEditor["elementId"];
+      const selectedLinearElement = {
+        elementId: "id1" as LinearElementEditor["elementId"],
+        isEditing: false,
+      };

      const commonAppState = {
        viewBackgroundColor: "#ffffff",
@ -24,23 +356,23 @@ describe("AppStateDelta", () => {
      const prevAppState1: ObservedAppState = {
        ...commonAppState,
        name: "",
-        selectedLinearElementId: null,
+        selectedLinearElement: null,
      };

      const nextAppState1: ObservedAppState = {
        ...commonAppState,
        name,
-        selectedLinearElementId,
+        selectedLinearElement,
      };

      const prevAppState2: ObservedAppState = {
-        selectedLinearElementId: null,
+        selectedLinearElement: null,
        name: "",
        ...commonAppState,
      };

      const nextAppState2: ObservedAppState = {
-        selectedLinearElementId,
+        selectedLinearElement,
        name,
        ...commonAppState,
      };
@ -58,9 +390,7 @@ describe("AppStateDelta", () => {
        selectedGroupIds: {},
        editingGroupId: null,
        croppingElementId: null,
-        selectedLinearElementId: null,
-        selectedLinearElementIsEditing: null,
-        editingLinearElementId: null,
+        selectedLinearElement: null,
        activeLockedId: null,
        lockedMultiSelections: {},
      };
@ -106,9 +436,7 @@ describe("AppStateDelta", () => {
        selectedElementIds: {},
        editingGroupId: null,
        croppingElementId: null,
-        selectedLinearElementId: null,
-        selectedLinearElementIsEditing: null,
-        editingLinearElementId: null,
+        selectedLinearElement: null,
        activeLockedId: null,
        lockedMultiSelections: {},
      };
@ -149,4 +477,97 @@ describe("AppStateDelta", () => {
      expect(JSON.stringify(delta1)).toBe(JSON.stringify(delta2));
    });
  });
+
+  describe("squash", () => {
+    it("should not squash when second delta is empty", () => {
+      const delta = Delta.create(
+        { name: "untitled scene" },
+        { name: "titled scene" },
+      );
+
+      const appStateDelta1 = AppStateDelta.create(delta);
+      const appStateDelta2 = AppStateDelta.empty();
+      const appStateDelta = appStateDelta1.squash(appStateDelta2);
+
+      expect(appStateDelta.isEmpty()).toBeFalsy();
+      expect(appStateDelta).toBe(appStateDelta1);
+      expect(appStateDelta.delta).toBe(delta);
+    });
+
+    it("should squash exclusive properties", () => {
+      const delta1 = Delta.create(
+        { name: "untitled scene" },
+        { name: "titled scene" },
+      );
+      const delta2 = Delta.create(
+        { viewBackgroundColor: "#ffffff" },
+        { viewBackgroundColor: "#000000" },
+      );
+
+      const appStateDelta1 = AppStateDelta.create(delta1);
+      const appStateDelta2 = AppStateDelta.create(delta2);
+      const appStateDelta = appStateDelta1.squash(appStateDelta2);
+
+      expect(appStateDelta.isEmpty()).toBeFalsy();
+      expect(appStateDelta).toBe(appStateDelta1);
+      expect(appStateDelta.delta).toEqual(
+        Delta.create(
+          { name: "untitled scene", viewBackgroundColor: "#ffffff" },
+          { name: "titled scene", viewBackgroundColor: "#000000" },
+        ),
+      );
+    });
+
+    it("should squash selectedElementIds, selectedGroupIds and lockedMultiSelections", () => {
+      const delta1 = Delta.create<Partial<ObservedAppState>>(
+        {
+          name: "untitled scene",
+          selectedElementIds: { id1: true },
+          selectedGroupIds: {},
+          lockedMultiSelections: { g1: true },
+        },
+        {
+          name: "titled scene",
+          selectedElementIds: { id2: true },
+          selectedGroupIds: { g1: true },
+          lockedMultiSelections: {},
+        },
+      );
+      const delta2 = Delta.create<Partial<ObservedAppState>>(
+        {
+          selectedElementIds: { id3: true },
+          selectedGroupIds: { g1: true },
+          lockedMultiSelections: {},
+        },
+        {
+          selectedElementIds: { id2: true },
+          selectedGroupIds: { g2: true, g3: true },
+          lockedMultiSelections: { g3: true },
+        },
+      );
+
+      const appStateDelta1 = AppStateDelta.create(delta1);
+      const appStateDelta2 = AppStateDelta.create(delta2);
+      const appStateDelta = appStateDelta1.squash(appStateDelta2);
+
+      expect(appStateDelta.isEmpty()).toBeFalsy();
+      expect(appStateDelta).toBe(appStateDelta1);
+      expect(appStateDelta.delta).toEqual(
+        Delta.create<Partial<ObservedAppState>>(
+          {
+            name: "untitled scene",
+            selectedElementIds: { id1: true, id3: true },
+            selectedGroupIds: { g1: true },
+            lockedMultiSelections: { g1: true },
+          },
+          {
+            name: "titled scene",
+            selectedElementIds: { id2: true },
+            selectedGroupIds: { g1: true, g2: true, g3: true },
+            lockedMultiSelections: { g3: true },
+          },
+        ),
+      );
+    });
+  });
 });
--- a/packages/element/tests/textElement.test.ts
+++ b/packages/element/tests/textElement.test.ts
@ -1,13 +1,14 @@
 import { getLineHeight } from "@excalidraw/common";
 import { API } from "@excalidraw/excalidraw/tests/helpers/api";

-import { FONT_FAMILY } from "@excalidraw/common";
+import { FONT_FAMILY, TEXT_ALIGN, VERTICAL_ALIGN } from "@excalidraw/common";

 import {
  computeContainerDimensionForBoundText,
  getContainerCoords,
  getBoundTextMaxWidth,
  getBoundTextMaxHeight,
+  computeBoundTextPosition,
 } from "../src/textElement";
 import { detectLineHeight, getLineHeightInPx } from "../src/textMeasurements";

@ -207,3 +208,172 @@ describe("Test getDefaultLineHeight", () => {
    expect(getLineHeight(FONT_FAMILY.Cascadia)).toBe(1.2);
  });
 });
+
+describe("Test computeBoundTextPosition", () => {
+  const createMockElementsMap = () => new Map();
+
+  // Helper function to create rectangle test case with 90-degree rotation
+  const createRotatedRectangleTestCase = (
+    textAlign: string,
+    verticalAlign: string,
+  ) => {
+    const container = API.createElement({
+      type: "rectangle",
+      x: 100,
+      y: 100,
+      width: 200,
+      height: 100,
+      angle: (Math.PI / 2) as any, // 90 degrees
+    });
+
+    const boundTextElement = API.createElement({
+      type: "text",
+      width: 80,
+      height: 40,
+      text: "hello darkness my old friend",
+      textAlign: textAlign as any,
+      verticalAlign: verticalAlign as any,
+      containerId: container.id,
+    }) as ExcalidrawTextElementWithContainer;
+
+    const elementsMap = createMockElementsMap();
+
+    return { container, boundTextElement, elementsMap };
+  };
+
+  describe("90-degree rotation with all alignment combinations", () => {
+    // Test all 9 combinations of horizontal (left, center, right) and vertical (top, middle, bottom) alignment
+
+    it("should position text with LEFT + TOP alignment at 90-degree rotation", () => {
+      const { container, boundTextElement, elementsMap } =
+        createRotatedRectangleTestCase(TEXT_ALIGN.LEFT, VERTICAL_ALIGN.TOP);
+
+      const result = computeBoundTextPosition(
+        container,
+        boundTextElement,
+        elementsMap,
+      );
+
+      expect(result.x).toBeCloseTo(185, 1);
+      expect(result.y).toBeCloseTo(75, 1);
+    });
+
+    it("should position text with LEFT + MIDDLE alignment at 90-degree rotation", () => {
+      const { container, boundTextElement, elementsMap } =
+        createRotatedRectangleTestCase(TEXT_ALIGN.LEFT, VERTICAL_ALIGN.MIDDLE);
+
+      const result = computeBoundTextPosition(
+        container,
+        boundTextElement,
+        elementsMap,
+      );
+
+      expect(result.x).toBeCloseTo(160, 1);
+      expect(result.y).toBeCloseTo(75, 1);
+    });
+
+    it("should position text with LEFT + BOTTOM alignment at 90-degree rotation", () => {
+      const { container, boundTextElement, elementsMap } =
+        createRotatedRectangleTestCase(TEXT_ALIGN.LEFT, VERTICAL_ALIGN.BOTTOM);
+
+      const result = computeBoundTextPosition(
+        container,
+        boundTextElement,
+        elementsMap,
+      );
+
+      expect(result.x).toBeCloseTo(135, 1);
+      expect(result.y).toBeCloseTo(75, 1);
+    });
+
+    it("should position text with CENTER + TOP alignment at 90-degree rotation", () => {
+      const { container, boundTextElement, elementsMap } =
+        createRotatedRectangleTestCase(TEXT_ALIGN.CENTER, VERTICAL_ALIGN.TOP);
+
+      const result = computeBoundTextPosition(
+        container,
+        boundTextElement,
+        elementsMap,
+      );
+
+      expect(result.x).toBeCloseTo(185, 1);
+      expect(result.y).toBeCloseTo(130, 1);
+    });
+
+    it("should position text with CENTER + MIDDLE alignment at 90-degree rotation", () => {
+      const { container, boundTextElement, elementsMap } =
+        createRotatedRectangleTestCase(
+          TEXT_ALIGN.CENTER,
+          VERTICAL_ALIGN.MIDDLE,
+        );
+
+      const result = computeBoundTextPosition(
+        container,
+        boundTextElement,
+        elementsMap,
+      );
+
+      expect(result.x).toBeCloseTo(160, 1);
+      expect(result.y).toBeCloseTo(130, 1);
+    });
+
+    it("should position text with CENTER + BOTTOM alignment at 90-degree rotation", () => {
+      const { container, boundTextElement, elementsMap } =
+        createRotatedRectangleTestCase(
+          TEXT_ALIGN.CENTER,
+          VERTICAL_ALIGN.BOTTOM,
+        );
+
+      const result = computeBoundTextPosition(
+        container,
+        boundTextElement,
+        elementsMap,
+      );
+
+      expect(result.x).toBeCloseTo(135, 1);
+      expect(result.y).toBeCloseTo(130, 1);
+    });
+
+    it("should position text with RIGHT + TOP alignment at 90-degree rotation", () => {
+      const { container, boundTextElement, elementsMap } =
+        createRotatedRectangleTestCase(TEXT_ALIGN.RIGHT, VERTICAL_ALIGN.TOP);
+
+      const result = computeBoundTextPosition(
+        container,
+        boundTextElement,
+        elementsMap,
+      );
+
+      expect(result.x).toBeCloseTo(185, 1);
+      expect(result.y).toBeCloseTo(185, 1);
+    });
+
+    it("should position text with RIGHT + MIDDLE alignment at 90-degree rotation", () => {
+      const { container, boundTextElement, elementsMap } =
+        createRotatedRectangleTestCase(TEXT_ALIGN.RIGHT, VERTICAL_ALIGN.MIDDLE);
+
+      const result = computeBoundTextPosition(
+        container,
+        boundTextElement,
+        elementsMap,
+      );
+
+      expect(result.x).toBeCloseTo(160, 1);
+      expect(result.y).toBeCloseTo(185, 1);
+    });
+
+    it("should position text with RIGHT + BOTTOM alignment at 90-degree rotation", () => {
+      const { container, boundTextElement, elementsMap } =
+        createRotatedRectangleTestCase(TEXT_ALIGN.RIGHT, VERTICAL_ALIGN.BOTTOM);
+
+      const result = computeBoundTextPosition(
+        container,
+        boundTextElement,
+        elementsMap,
+      );
+
+      expect(result.x).toBeCloseTo(135, 1);
+      expect(result.y).toBeCloseTo(185, 1);
+    });
+  });
+});
--- a/packages/excalidraw/actions/actionCanvas.tsx
+++ b/packages/excalidraw/actions/actionCanvas.tsx
@ -69,7 +69,7 @@ export const actionChangeViewBackgroundColor = register({
        : CaptureUpdateAction.EVENTUALLY,
    };
  },
-  PanelComponent: ({ elements, appState, updateData, appProps }) => {
+  PanelComponent: ({ elements, appState, updateData, appProps, data }) => {
    // FIXME move me to src/components/mainMenu/DefaultItems.tsx
    return (
      <ColorPicker
@ -83,6 +83,7 @@ export const actionChangeViewBackgroundColor = register({
        elements={elements}
        appState={appState}
        updateData={updateData}
+        compactMode={appState.stylesPanelMode === "compact"}
      />
    );
  },
@ -121,7 +122,7 @@ export const actionClearCanvas = register({
        pasteDialog: appState.pasteDialog,
        activeTool:
          appState.activeTool.type === "image"
-            ? { ...appState.activeTool, type: "selection" }
+            ? { ...appState.activeTool, type: app.defaultSelectionTool }
            : appState.activeTool,
      },
      captureUpdate: CaptureUpdateAction.IMMEDIATELY,
@ -494,13 +495,13 @@ export const actionToggleEraserTool = register({
  name: "toggleEraserTool",
  label: "toolBar.eraser",
  trackEvent: { category: "toolbar" },
-  perform: (elements, appState) => {
+  perform: (elements, appState, _, app) => {
    let activeTool: AppState["activeTool"];

    if (isEraserActive(appState)) {
      activeTool = updateActiveTool(appState, {
        ...(appState.activeTool.lastActiveTool || {
-          type: "selection",
+          type: app.defaultSelectionTool,
        }),
        lastActiveToolBeforeEraser: null,
      });
@ -530,6 +531,9 @@ export const actionToggleLassoTool = register({
  label: "toolBar.lasso",
  icon: LassoIcon,
  trackEvent: { category: "toolbar" },
+  predicate: (elements, appState, props, app) => {
+    return app.defaultSelectionTool !== "lasso";
+  },
  perform: (elements, appState, _, app) => {
    let activeTool: AppState["activeTool"];

--- a/packages/excalidraw/actions/actionDeleteSelected.tsx
+++ b/packages/excalidraw/actions/actionDeleteSelected.tsx
@ -298,7 +298,9 @@ export const actionDeleteSelected = register({
      elements: nextElements,
      appState: {
        ...nextAppState,
-        activeTool: updateActiveTool(appState, { type: "selection" }),
+        activeTool: updateActiveTool(appState, {
+          type: app.defaultSelectionTool,
+        }),
        multiElement: null,
        activeEmbeddable: null,
        selectedLinearElement: null,
--- a/packages/excalidraw/actions/actionFinalize.tsx
+++ b/packages/excalidraw/actions/actionFinalize.tsx
@ -5,7 +5,11 @@ import {
  bindOrUnbindLinearElement,
  isBindingEnabled,
 } from "@excalidraw/element/binding";
-import { isValidPolygon, LinearElementEditor } from "@excalidraw/element";
+import {
+  isValidPolygon,
+  LinearElementEditor,
+  newElementWith,
+} from "@excalidraw/element";

 import {
  isBindingElement,
@ -78,7 +82,14 @@ export const actionFinalize = register({
        let newElements = elements;
        if (element && isInvisiblySmallElement(element)) {
          // TODO: #7348 in theory this gets recorded by the store, so the invisible elements could be restored by the undo/redo, which might be not what we would want
-          newElements = newElements.filter((el) => el.id !== element!.id);
+          newElements = newElements.map((el) => {
+            if (el.id === element.id) {
+              return newElementWith(el, {
+                isDeleted: true,
+              });
+            }
+            return el;
+          });
        }
        return {
          elements: newElements,
@ -117,7 +128,12 @@ export const actionFinalize = register({
        return {
          elements:
            element.points.length < 2 || isInvisiblySmallElement(element)
-              ? elements.filter((el) => el.id !== element.id)
+              ? elements.map((el) => {
+                  if (el.id === element.id) {
+                    return newElementWith(el, { isDeleted: true });
+                  }
+                  return el;
+                })
              : undefined,
          appState: {
            ...appState,
@ -172,7 +188,12 @@ export const actionFinalize = register({

      if (element && isInvisiblySmallElement(element)) {
        // TODO: #7348 in theory this gets recorded by the store, so the invisible elements could be restored by the undo/redo, which might be not what we would want
-        newElements = newElements.filter((el) => el.id !== element!.id);
+        newElements = newElements.map((el) => {
+          if (el.id === element?.id) {
+            return newElementWith(el, { isDeleted: true });
+          }
+          return el;
+        });
      }

      if (isLinearElement(element) || isFreeDrawElement(element)) {
@ -240,13 +261,13 @@ export const actionFinalize = register({
    if (appState.activeTool.type === "eraser") {
      activeTool = updateActiveTool(appState, {
        ...(appState.activeTool.lastActiveTool || {
-          type: "selection",
+          type: app.defaultSelectionTool,
        }),
        lastActiveToolBeforeEraser: null,
      });
    } else {
      activeTool = updateActiveTool(appState, {
-        type: "selection",
+        type: app.defaultSelectionTool,
      });
    }

--- a/packages/excalidraw/actions/actionLinearEditor.tsx
+++ b/packages/excalidraw/actions/actionLinearEditor.tsx
@ -88,6 +88,10 @@ export const actionToggleLinearEditor = register({
      selectedElementIds: appState.selectedElementIds,
    })[0] as ExcalidrawLinearElement;

+    if (!selectedElement) {
+      return null;
+    }
+
    const label = t(
      selectedElement.type === "arrow"
        ? "labels.lineEditor.editArrow"
--- a/packages/excalidraw/actions/actionProperties.tsx
+++ b/packages/excalidraw/actions/actionProperties.tsx
@ -137,6 +137,11 @@ import {
  isSomeElementSelected,
 } from "../scene";

+import {
+  withCaretPositionPreservation,
+  restoreCaretPosition,
+} from "../hooks/useTextEditorFocus";
+
 import { register } from "./register";

 import type { AppClassProperties, AppState, Primitive } from "../types";
@ -321,9 +326,11 @@ export const actionChangeStrokeColor = register({
        : CaptureUpdateAction.EVENTUALLY,
    };
  },
-  PanelComponent: ({ elements, appState, updateData, app }) => (
+  PanelComponent: ({ elements, appState, updateData, app, data }) => (
    <>
-      <h3 aria-hidden="true">{t("labels.stroke")}</h3>
+      {appState.stylesPanelMode === "full" && (
+        <h3 aria-hidden="true">{t("labels.stroke")}</h3>
+      )}
      <ColorPicker
        topPicks={DEFAULT_ELEMENT_STROKE_PICKS}
        palette={DEFAULT_ELEMENT_STROKE_COLOR_PALETTE}
@ -341,6 +348,7 @@ export const actionChangeStrokeColor = register({
        elements={elements}
        appState={appState}
        updateData={updateData}
+        compactMode={appState.stylesPanelMode === "compact"}
      />
    </>
  ),
@ -398,9 +406,11 @@ export const actionChangeBackgroundColor = register({
      captureUpdate: CaptureUpdateAction.IMMEDIATELY,
    };
  },
-  PanelComponent: ({ elements, appState, updateData, app }) => (
+  PanelComponent: ({ elements, appState, updateData, app, data }) => (
    <>
-      <h3 aria-hidden="true">{t("labels.background")}</h3>
+      {appState.stylesPanelMode === "full" && (
+        <h3 aria-hidden="true">{t("labels.background")}</h3>
+      )}
      <ColorPicker
        topPicks={DEFAULT_ELEMENT_BACKGROUND_PICKS}
        palette={DEFAULT_ELEMENT_BACKGROUND_COLOR_PALETTE}
@ -418,6 +428,7 @@ export const actionChangeBackgroundColor = register({
        elements={elements}
        appState={appState}
        updateData={updateData}
+        compactMode={appState.stylesPanelMode === "compact"}
      />
    </>
  ),
@ -518,9 +529,11 @@ export const actionChangeStrokeWidth = register({
      captureUpdate: CaptureUpdateAction.IMMEDIATELY,
    };
  },
-  PanelComponent: ({ elements, appState, updateData, app }) => (
+  PanelComponent: ({ elements, appState, updateData, app, data }) => (
    <fieldset>
-      <legend>{t("labels.strokeWidth")}</legend>
+      {appState.stylesPanelMode === "full" && (
+        <legend>{t("labels.strokeWidth")}</legend>
+      )}
      <div className="buttonList">
        <RadioSelection
          group="stroke-width"
@ -575,9 +588,11 @@ export const actionChangeSloppiness = register({
      captureUpdate: CaptureUpdateAction.IMMEDIATELY,
    };
  },
-  PanelComponent: ({ elements, appState, updateData, app }) => (
+  PanelComponent: ({ elements, appState, updateData, app, data }) => (
    <fieldset>
-      <legend>{t("labels.sloppiness")}</legend>
+      {appState.stylesPanelMode === "full" && (
+        <legend>{t("labels.sloppiness")}</legend>
+      )}
      <div className="buttonList">
        <RadioSelection
          group="sloppiness"
@ -628,9 +643,11 @@ export const actionChangeStrokeStyle = register({
      captureUpdate: CaptureUpdateAction.IMMEDIATELY,
    };
  },
-  PanelComponent: ({ elements, appState, updateData, app }) => (
+  PanelComponent: ({ elements, appState, updateData, app, data }) => (
    <fieldset>
-      <legend>{t("labels.strokeStyle")}</legend>
+      {appState.stylesPanelMode === "full" && (
+        <legend>{t("labels.strokeStyle")}</legend>
+      )}
      <div className="buttonList">
        <RadioSelection
          group="strokeStyle"
@ -697,7 +714,7 @@ export const actionChangeFontSize = register({
  perform: (elements, appState, value, app) => {
    return changeFontSize(elements, appState, app, () => value, value);
  },
-  PanelComponent: ({ elements, appState, updateData, app }) => (
+  PanelComponent: ({ elements, appState, updateData, app, data }) => (
    <fieldset>
      <legend>{t("labels.fontSize")}</legend>
      <div className="buttonList">
@ -756,7 +773,14 @@ export const actionChangeFontSize = register({
                ? null
                : appState.currentItemFontSize || DEFAULT_FONT_SIZE,
          )}
-          onChange={(value) => updateData(value)}
+          onChange={(value) => {
+            withCaretPositionPreservation(
+              () => updateData(value),
+              appState.stylesPanelMode === "compact",
+              !!appState.editingTextElement,
+              data?.onPreventClose,
+            );
+          }}
        />
      </div>
    </fieldset>
@ -1016,7 +1040,7 @@ export const actionChangeFontFamily = register({

    return result;
  },
-  PanelComponent: ({ elements, appState, app, updateData }) => {
+  PanelComponent: ({ elements, appState, app, updateData, data }) => {
    const cachedElementsRef = useRef<ElementsMap>(new Map());
    const prevSelectedFontFamilyRef = useRef<number | null>(null);
    // relying on state batching as multiple `FontPicker` handlers could be called in rapid succession and we want to combine them
@ -1094,20 +1118,28 @@ export const actionChangeFontFamily = register({

    return (
      <fieldset>
-        <legend>{t("labels.fontFamily")}</legend>
+        {appState.stylesPanelMode === "full" && (
+          <legend>{t("labels.fontFamily")}</legend>
+        )}
        <FontPicker
          isOpened={appState.openPopup === "fontFamily"}
          selectedFontFamily={selectedFontFamily}
          hoveredFontFamily={appState.currentHoveredFontFamily}
+          compactMode={appState.stylesPanelMode === "compact"}
          onSelect={(fontFamily) => {
-            setBatchedData({
-              openPopup: null,
-              currentHoveredFontFamily: null,
-              currentItemFontFamily: fontFamily,
-            });
-
-            // defensive clear so immediate close won't abuse the cached elements
-            cachedElementsRef.current.clear();
+            withCaretPositionPreservation(
+              () => {
+                setBatchedData({
+                  openPopup: null,
+                  currentHoveredFontFamily: null,
+                  currentItemFontFamily: fontFamily,
+                });
+                // defensive clear so immediate close won't abuse the cached elements
+                cachedElementsRef.current.clear();
+              },
+              appState.stylesPanelMode === "compact",
+              !!appState.editingTextElement,
+            );
          }}
          onHover={(fontFamily) => {
            setBatchedData({
@ -1164,25 +1196,28 @@ export const actionChangeFontFamily = register({
              }

              setBatchedData({
+                ...batchedData,
                openPopup: "fontFamily",
              });
            } else {
-              // close, use the cache and clear it afterwards
-              const data = {
-                openPopup: null,
+              const fontFamilyData = {
                currentHoveredFontFamily: null,
                cachedElements: new Map(cachedElementsRef.current),
                resetAll: true,
              } as ChangeFontFamilyData;

-              if (isUnmounted.current) {
-                // in case the component was unmounted by the parent, trigger the update directly
-                updateData({ ...batchedData, ...data });
-              } else {
-                setBatchedData(data);
-              }
-
+              setBatchedData({
+                ...fontFamilyData,
+              });
              cachedElementsRef.current.clear();
+
+              // Refocus text editor when font picker closes if we were editing text
+              if (
+                appState.stylesPanelMode === "compact" &&
+                appState.editingTextElement
+              ) {
+                restoreCaretPosition(null); // Just refocus without saved position
+              }
            }
          }}
        />
@ -1225,8 +1260,9 @@ export const actionChangeTextAlign = register({
      captureUpdate: CaptureUpdateAction.IMMEDIATELY,
    };
  },
-  PanelComponent: ({ elements, appState, updateData, app }) => {
+  PanelComponent: ({ elements, appState, updateData, app, data }) => {
    const elementsMap = app.scene.getNonDeletedElementsMap();
+
    return (
      <fieldset>
        <legend>{t("labels.textAlign")}</legend>
@ -1275,7 +1311,14 @@ export const actionChangeTextAlign = register({
              (hasSelection) =>
                hasSelection ? null : appState.currentItemTextAlign,
            )}
-            onChange={(value) => updateData(value)}
+            onChange={(value) => {
+              withCaretPositionPreservation(
+                () => updateData(value),
+                appState.stylesPanelMode === "compact",
+                !!appState.editingTextElement,
+                data?.onPreventClose,
+              );
+            }}
          />
        </div>
      </fieldset>
@ -1317,7 +1360,7 @@ export const actionChangeVerticalAlign = register({
      captureUpdate: CaptureUpdateAction.IMMEDIATELY,
    };
  },
-  PanelComponent: ({ elements, appState, updateData, app }) => {
+  PanelComponent: ({ elements, appState, updateData, app, data }) => {
    return (
      <fieldset>
        <div className="buttonList">
@ -1367,7 +1410,14 @@ export const actionChangeVerticalAlign = register({
                ) !== null,
              (hasSelection) => (hasSelection ? null : VERTICAL_ALIGN.MIDDLE),
            )}
-            onChange={(value) => updateData(value)}
+            onChange={(value) => {
+              withCaretPositionPreservation(
+                () => updateData(value),
+                appState.stylesPanelMode === "compact",
+                !!appState.editingTextElement,
+                data?.onPreventClose,
+              );
+            }}
          />
        </div>
      </fieldset>
@ -1616,6 +1666,25 @@ export const actionChangeArrowhead = register({
  },
 });

+export const actionChangeArrowProperties = register({
+  name: "changeArrowProperties",
+  label: "Change arrow properties",
+  trackEvent: false,
+  perform: (elements, appState, value, app) => {
+    // This action doesn't perform any changes directly
+    // It's just a container for the arrow type and arrowhead actions
+    return false;
+  },
+  PanelComponent: ({ elements, appState, updateData, app, renderAction }) => {
+    return (
+      <div className="selected-shape-actions">
+        {renderAction("changeArrowType")}
+        {renderAction("changeArrowhead")}
+      </div>
+    );
+  },
+});
+
 export const actionChangeArrowType = register({
  name: "changeArrowType",
  label: "Change arrow types",
--- a/packages/excalidraw/actions/index.ts
+++ b/packages/excalidraw/actions/index.ts
@ -18,6 +18,7 @@ export {
  actionChangeFontFamily,
  actionChangeTextAlign,
  actionChangeVerticalAlign,
+  actionChangeArrowProperties,
 } from "./actionProperties";

 export {
--- a/packages/excalidraw/actions/types.ts
+++ b/packages/excalidraw/actions/types.ts
@ -69,6 +69,7 @@ export type ActionName =
  | "changeStrokeStyle"
  | "changeArrowhead"
  | "changeArrowType"
+  | "changeArrowProperties"
  | "changeOpacity"
  | "changeFontSize"
  | "toggleCanvasMenu"
--- a/packages/excalidraw/appState.ts
+++ b/packages/excalidraw/appState.ts
@ -123,6 +123,7 @@ export const getDefaultAppState = (): Omit<
    searchMatches: null,
    lockedMultiSelections: {},
    activeLockedId: null,
+    stylesPanelMode: "full",
  };
 };

@ -247,6 +248,7 @@ const APP_STATE_STORAGE_CONF = (<
  searchMatches: { browser: false, export: false, server: false },
  lockedMultiSelections: { browser: true, export: true, server: true },
  activeLockedId: { browser: false, export: false, server: false },
+  stylesPanelMode: { browser: true, export: false, server: false },
 });

 const _clearAppStateForStorage = <
--- a/packages/excalidraw/clipboard.test.ts
+++ b/packages/excalidraw/clipboard.test.ts
@ -1,6 +1,7 @@
 import {
  createPasteEvent,
  parseClipboard,
+  parseDataTransferEvent,
  serializeAsClipboardJSON,
 } from "./clipboard";
 import { API } from "./tests/helpers/api";
@ -13,7 +14,9 @@ describe("parseClipboard()", () => {

    text = "123";
    clipboardData = await parseClipboard(
-      createPasteEvent({ types: { "text/plain": text } }),
+      await parseDataTransferEvent(
+        createPasteEvent({ types: { "text/plain": text } }),
+      ),
    );
    expect(clipboardData.text).toBe(text);

@ -21,7 +24,9 @@ describe("parseClipboard()", () => {

    text = "[123]";
    clipboardData = await parseClipboard(
-      createPasteEvent({ types: { "text/plain": text } }),
+      await parseDataTransferEvent(
+        createPasteEvent({ types: { "text/plain": text } }),
+      ),
    );
    expect(clipboardData.text).toBe(text);

@ -29,7 +34,9 @@ describe("parseClipboard()", () => {

    text = JSON.stringify({ val: 42 });
    clipboardData = await parseClipboard(
-      createPasteEvent({ types: { "text/plain": text } }),
+      await parseDataTransferEvent(
+        createPasteEvent({ types: { "text/plain": text } }),
+      ),
    );
    expect(clipboardData.text).toBe(text);
  });
@ -39,11 +46,13 @@ describe("parseClipboard()", () => {

    const json = serializeAsClipboardJSON({ elements: [rect], files: null });
    const clipboardData = await parseClipboard(
-      createPasteEvent({
-        types: {
-          "text/plain": json,
-        },
-      }),
+      await parseDataTransferEvent(
+        createPasteEvent({
+          types: {
+            "text/plain": json,
+          },
+        }),
+      ),
    );
    expect(clipboardData.elements).toEqual([rect]);
  });
@ -56,21 +65,25 @@ describe("parseClipboard()", () => {
    // -------------------------------------------------------------------------
    json = serializeAsClipboardJSON({ elements: [rect], files: null });
    clipboardData = await parseClipboard(
-      createPasteEvent({
-        types: {
-          "text/html": json,
-        },
-      }),
+      await parseDataTransferEvent(
+        createPasteEvent({
+          types: {
+            "text/html": json,
+          },
+        }),
+      ),
    );
    expect(clipboardData.elements).toEqual([rect]);
    // -------------------------------------------------------------------------
    json = serializeAsClipboardJSON({ elements: [rect], files: null });
    clipboardData = await parseClipboard(
-      createPasteEvent({
-        types: {
-          "text/html": `<div> ${json}</div>`,
-        },
-      }),
+      await parseDataTransferEvent(
+        createPasteEvent({
+          types: {
+            "text/html": `<div> ${json}</div>`,
+          },
+        }),
+      ),
    );
    expect(clipboardData.elements).toEqual([rect]);
    // -------------------------------------------------------------------------
@ -80,11 +93,13 @@ describe("parseClipboard()", () => {
    let clipboardData;
    // -------------------------------------------------------------------------
    clipboardData = await parseClipboard(
-      createPasteEvent({
-        types: {
-          "text/html": `<img src="https://example.com/image.png" />`,
-        },
-      }),
+      await parseDataTransferEvent(
+        createPasteEvent({
+          types: {
+            "text/html": `<img src="https://example.com/image.png" />`,
+          },
+        }),
+      ),
    );
    expect(clipboardData.mixedContent).toEqual([
      {
@ -94,11 +109,13 @@ describe("parseClipboard()", () => {
    ]);
    // -------------------------------------------------------------------------
    clipboardData = await parseClipboard(
-      createPasteEvent({
-        types: {
-          "text/html": `<div><img src="https://example.com/image.png" /></div><a><img src="https://example.com/image2.png" /></a>`,
-        },
-      }),
+      await parseDataTransferEvent(
+        createPasteEvent({
+          types: {
+            "text/html": `<div><img src="https://example.com/image.png" /></div><a><img src="https://example.com/image2.png" /></a>`,
+          },
+        }),
+      ),
    );
    expect(clipboardData.mixedContent).toEqual([
      {
@ -114,11 +131,13 @@ describe("parseClipboard()", () => {

  it("should parse text content alongside <image> `src` urls out of text/html", async () => {
    const clipboardData = await parseClipboard(
-      createPasteEvent({
-        types: {
-          "text/html": `<a href="https://example.com">hello </a><div><img src="https://example.com/image.png" /></div><b>my friend!</b>`,
-        },
-      }),
+      await parseDataTransferEvent(
+        createPasteEvent({
+          types: {
+            "text/html": `<a href="https://example.com">hello </a><div><img src="https://example.com/image.png" /></div><b>my friend!</b>`,
+          },
+        }),
+      ),
    );
    expect(clipboardData.mixedContent).toEqual([
      {
@ -141,14 +160,16 @@ describe("parseClipboard()", () => {
    let clipboardData;
    // -------------------------------------------------------------------------
    clipboardData = await parseClipboard(
-      createPasteEvent({
-        types: {
-          "text/plain": `a	b
-        1	2
-        4	5
-        7	10`,
-        },
-      }),
+      await parseDataTransferEvent(
+        createPasteEvent({
+          types: {
+            "text/plain": `a	b
+            1	2
+            4	5
+            7	10`,
+          },
+        }),
+      ),
    );
    expect(clipboardData.spreadsheet).toEqual({
      title: "b",
@ -157,14 +178,16 @@ describe("parseClipboard()", () => {
    });
    // -------------------------------------------------------------------------
    clipboardData = await parseClipboard(
-      createPasteEvent({
-        types: {
-          "text/html": `a	b
-        1	2
-        4	5
-        7	10`,
-        },
-      }),
+      await parseDataTransferEvent(
+        createPasteEvent({
+          types: {
+            "text/html": `a	b
+            1	2
+            4	5
+            7	10`,
+          },
+        }),
+      ),
    );
    expect(clipboardData.spreadsheet).toEqual({
      title: "b",
@ -173,19 +196,21 @@ describe("parseClipboard()", () => {
    });
    // -------------------------------------------------------------------------
    clipboardData = await parseClipboard(
-      createPasteEvent({
-        types: {
-          "text/html": `<html>
-        <body>
-        <!--StartFragment--><google-sheets-html-origin><style type="text/css"><!--td {border: 1px solid #cccccc;}br {mso-data-placement:same-cell;}--></style><table xmlns="http://www.w3.org/1999/xhtml" cellspacing="0" cellpadding="0" dir="ltr" border="1" style="table-layout:fixed;font-size:10pt;font-family:Arial;width:0px;border-collapse:collapse;border:none"><colgroup><col width="100"/><col width="100"/></colgroup><tbody><tr style="height:21px;"><td style="overflow:hidden;padding:2px 3px 2px 3px;vertical-align:bottom;" data-sheets-value="{&quot;1&quot;:2,&quot;2&quot;:&quot;a&quot;}">a</td><td style="overflow:hidden;padding:2px 3px 2px 3px;vertical-align:bottom;" data-sheets-value="{&quot;1&quot;:2,&quot;2&quot;:&quot;b&quot;}">b</td></tr><tr style="height:21px;"><td style="overflow:hidden;padding:2px 3px 2px 3px;vertical-align:bottom;text-align:right;" data-sheets-value="{&quot;1&quot;:3,&quot;3&quot;:1}">1</td><td style="overflow:hidden;padding:2px 3px 2px 3px;vertical-align:bottom;text-align:right;" data-sheets-value="{&quot;1&quot;:3,&quot;3&quot;:2}">2</td></tr><tr style="height:21px;"><td style="overflow:hidden;padding:2px 3px 2px 3px;vertical-align:bottom;text-align:right;" data-sheets-value="{&quot;1&quot;:3,&quot;3&quot;:4}">4</td><td style="overflow:hidden;padding:2px 3px 2px 3px;vertical-align:bottom;text-align:right;" data-sheets-value="{&quot;1&quot;:3,&quot;3&quot;:5}">5</td></tr><tr style="height:21px;"><td style="overflow:hidden;padding:2px 3px 2px 3px;vertical-align:bottom;text-align:right;" data-sheets-value="{&quot;1&quot;:3,&quot;3&quot;:7}">7</td><td style="overflow:hidden;padding:2px 3px 2px 3px;vertical-align:bottom;text-align:right;" data-sheets-value="{&quot;1&quot;:3,&quot;3&quot;:10}">10</td></tr></tbody></table><!--EndFragment-->
-        </body>
-        </html>`,
-          "text/plain": `a	b
-        1	2
-        4	5
-        7	10`,
-        },
-      }),
+      await parseDataTransferEvent(
+        createPasteEvent({
+          types: {
+            "text/html": `<html>
+            <body>
+            <!--StartFragment--><google-sheets-html-origin><style type="text/css"><!--td {border: 1px solid #cccccc;}br {mso-data-placement:same-cell;}--></style><table xmlns="http://www.w3.org/1999/xhtml" cellspacing="0" cellpadding="0" dir="ltr" border="1" style="table-layout:fixed;font-size:10pt;font-family:Arial;width:0px;border-collapse:collapse;border:none"><colgroup><col width="100"/><col width="100"/></colgroup><tbody><tr style="height:21px;"><td style="overflow:hidden;padding:2px 3px 2px 3px;vertical-align:bottom;" data-sheets-value="{&quot;1&quot;:2,&quot;2&quot;:&quot;a&quot;}">a</td><td style="overflow:hidden;padding:2px 3px 2px 3px;vertical-align:bottom;" data-sheets-value="{&quot;1&quot;:2,&quot;2&quot;:&quot;b&quot;}">b</td></tr><tr style="height:21px;"><td style="overflow:hidden;padding:2px 3px 2px 3px;vertical-align:bottom;text-align:right;" data-sheets-value="{&quot;1&quot;:3,&quot;3&quot;:1}">1</td><td style="overflow:hidden;padding:2px 3px 2px 3px;vertical-align:bottom;text-align:right;" data-sheets-value="{&quot;1&quot;:3,&quot;3&quot;:2}">2</td></tr><tr style="height:21px;"><td style="overflow:hidden;padding:2px 3px 2px 3px;vertical-align:bottom;text-align:right;" data-sheets-value="{&quot;1&quot;:3,&quot;3&quot;:4}">4</td><td style="overflow:hidden;padding:2px 3px 2px 3px;vertical-align:bottom;text-align:right;" data-sheets-value="{&quot;1&quot;:3,&quot;3&quot;:5}">5</td></tr><tr style="height:21px;"><td style="overflow:hidden;padding:2px 3px 2px 3px;vertical-align:bottom;text-align:right;" data-sheets-value="{&quot;1&quot;:3,&quot;3&quot;:7}">7</td><td style="overflow:hidden;padding:2px 3px 2px 3px;vertical-align:bottom;text-align:right;" data-sheets-value="{&quot;1&quot;:3,&quot;3&quot;:10}">10</td></tr></tbody></table><!--EndFragment-->
+            </body>
+            </html>`,
+            "text/plain": `a	b
+            1	2
+            4	5
+            7	10`,
+          },
+        }),
+      ),
    );
    expect(clipboardData.spreadsheet).toEqual({
      title: "b",
--- a/packages/excalidraw/clipboard.ts
+++ b/packages/excalidraw/clipboard.ts
@ -5,6 +5,7 @@ import {
  arrayToMap,
  isMemberOf,
  isPromiseLike,
+  EVENT,
 } from "@excalidraw/common";

 import { mutateElement } from "@excalidraw/element";
@ -16,15 +17,26 @@ import {

 import { getContainingFrame } from "@excalidraw/element";

+import type { ValueOf } from "@excalidraw/common/utility-types";
+
+import type { IMAGE_MIME_TYPES, STRING_MIME_TYPES } from "@excalidraw/common";
 import type {
  ExcalidrawElement,
  NonDeletedExcalidrawElement,
 } from "@excalidraw/element/types";

 import { ExcalidrawError } from "./errors";
-import { createFile, isSupportedImageFileType } from "./data/blob";
+import {
+  createFile,
+  getFileHandle,
+  isSupportedImageFileType,
+  normalizeFile,
+} from "./data/blob";
+
 import { tryParseSpreadsheet, VALID_SPREADSHEET } from "./charts";

+import type { FileSystemHandle } from "./data/filesystem";
+
 import type { Spreadsheet } from "./charts";

 import type { BinaryFiles } from "./types";
@ -92,7 +104,7 @@ export const createPasteEvent = ({
    console.warn("createPasteEvent: no types or files provided");
  }

-  const event = new ClipboardEvent("paste", {
+  const event = new ClipboardEvent(EVENT.PASTE, {
    clipboardData: new DataTransfer(),
  });

@ -101,10 +113,11 @@ export const createPasteEvent = ({
      if (typeof value !== "string") {
        files = files || [];
        files.push(value);
+        event.clipboardData?.items.add(value);
        continue;
      }
      try {
-        event.clipboardData?.setData(type, value);
+        event.clipboardData?.items.add(value, type);
        if (event.clipboardData?.getData(type) !== value) {
          throw new Error(`Failed to set "${type}" as clipboardData item`);
        }
@ -229,14 +242,10 @@ function parseHTMLTree(el: ChildNode) {
  return result;
 }

-const maybeParseHTMLPaste = (
-  event: ClipboardEvent,
+const maybeParseHTMLDataItem = (
+  dataItem: ParsedDataTransferItemType<typeof MIME_TYPES["html"]>,
 ): { type: "mixedContent"; value: PastedMixedContent } | null => {
-  const html = event.clipboardData?.getData(MIME_TYPES.html);
-
-  if (!html) {
-    return null;
-  }
+  const html = dataItem.value;

  try {
    const doc = new DOMParser().parseFromString(html, MIME_TYPES.html);
@ -332,18 +341,21 @@ export const readSystemClipboard = async () => {
 * Parses "paste" ClipboardEvent.
 */
 const parseClipboardEventTextData = async (
-  event: ClipboardEvent,
+  dataList: ParsedDataTranferList,
  isPlainPaste = false,
 ): Promise<ParsedClipboardEventTextData> => {
  try {
-    const mixedContent = !isPlainPaste && event && maybeParseHTMLPaste(event);
+    const htmlItem = dataList.findByType(MIME_TYPES.html);
+
+    const mixedContent =
+      !isPlainPaste && htmlItem && maybeParseHTMLDataItem(htmlItem);

    if (mixedContent) {
      if (mixedContent.value.every((item) => item.type === "text")) {
        return {
          type: "text",
          value:
-            event.clipboardData?.getData(MIME_TYPES.text) ||
+            dataList.getData(MIME_TYPES.text) ??
            mixedContent.value
              .map((item) => item.value)
              .join("\n")
@ -354,23 +366,155 @@ const parseClipboardEventTextData = async (
      return mixedContent;
    }

-    const text = event.clipboardData?.getData(MIME_TYPES.text);
-
-    return { type: "text", value: (text || "").trim() };
+    return {
+      type: "text",
+      value: (dataList.getData(MIME_TYPES.text) || "").trim(),
+    };
  } catch {
    return { type: "text", value: "" };
  }
 };

+type AllowedParsedDataTransferItem =
+  | {
+      type: ValueOf<typeof IMAGE_MIME_TYPES>;
+      kind: "file";
+      file: File;
+      fileHandle: FileSystemHandle | null;
+    }
+  | { type: ValueOf<typeof STRING_MIME_TYPES>; kind: "string"; value: string };
+
+type ParsedDataTransferItem =
+  | {
+      type: string;
+      kind: "file";
+      file: File;
+      fileHandle: FileSystemHandle | null;
+    }
+  | { type: string; kind: "string"; value: string };
+
+type ParsedDataTransferItemType<
+  T extends AllowedParsedDataTransferItem["type"],
+> = AllowedParsedDataTransferItem & { type: T };
+
+export type ParsedDataTransferFile = Extract<
+  AllowedParsedDataTransferItem,
+  { kind: "file" }
+>;
+
+type ParsedDataTranferList = ParsedDataTransferItem[] & {
+  /**
+   * Only allows filtering by known `string` data types, since `file`
+   * types can have multiple items of the same type (e.g. multiple image files)
+   * unlike `string` data transfer items.
+   */
+  findByType: typeof findDataTransferItemType;
+  /**
+   * Only allows filtering by known `string` data types, since `file`
+   * types can have multiple items of the same type (e.g. multiple image files)
+   * unlike `string` data transfer items.
+   */
+  getData: typeof getDataTransferItemData;
+  getFiles: typeof getDataTransferFiles;
+};
+
+const findDataTransferItemType = function <
+  T extends ValueOf<typeof STRING_MIME_TYPES>,
+>(this: ParsedDataTranferList, type: T): ParsedDataTransferItemType<T> | null {
+  return (
+    this.find(
+      (item): item is ParsedDataTransferItemType<T> => item.type === type,
+    ) || null
+  );
+};
+const getDataTransferItemData = function <
+  T extends ValueOf<typeof STRING_MIME_TYPES>,
+>(
+  this: ParsedDataTranferList,
+  type: T,
+):
+  | ParsedDataTransferItemType<ValueOf<typeof STRING_MIME_TYPES>>["value"]
+  | null {
+  const item = this.find(
+    (
+      item,
+    ): item is ParsedDataTransferItemType<ValueOf<typeof STRING_MIME_TYPES>> =>
+      item.type === type,
+  );
+
+  return item?.value ?? null;
+};
+
+const getDataTransferFiles = function (
+  this: ParsedDataTranferList,
+): ParsedDataTransferFile[] {
+  return this.filter(
+    (item): item is ParsedDataTransferFile => item.kind === "file",
+  );
+};
+
+export const parseDataTransferEvent = async (
+  event: ClipboardEvent | DragEvent | React.DragEvent<HTMLDivElement>,
+): Promise<ParsedDataTranferList> => {
+  let items: DataTransferItemList | undefined = undefined;
+
+  if (isClipboardEvent(event)) {
+    items = event.clipboardData?.items;
+  } else {
+    const dragEvent = event;
+    items = dragEvent.dataTransfer?.items;
+  }
+
+  const dataItems = (
+    await Promise.all(
+      Array.from(items || []).map(
+        async (item): Promise<ParsedDataTransferItem | null> => {
+          if (item.kind === "file") {
+            const file = item.getAsFile();
+            if (file) {
+              const fileHandle = await getFileHandle(item);
+              return {
+                type: file.type,
+                kind: "file",
+                file: await normalizeFile(file),
+                fileHandle,
+              };
+            }
+          } else if (item.kind === "string") {
+            const { type } = item;
+            let value: string;
+            if ("clipboardData" in event && event.clipboardData) {
+              value = event.clipboardData?.getData(type);
+            } else {
+              value = await new Promise<string>((resolve) => {
+                item.getAsString((str) => resolve(str));
+              });
+            }
+            return { type, kind: "string", value };
+          }
+
+          return null;
+        },
+      ),
+    )
+  ).filter((data): data is ParsedDataTransferItem => data != null);
+
+  return Object.assign(dataItems, {
+    findByType: findDataTransferItemType,
+    getData: getDataTransferItemData,
+    getFiles: getDataTransferFiles,
+  });
+};
+
 /**
 * Attempts to parse clipboard event.
 */
 export const parseClipboard = async (
-  event: ClipboardEvent,
+  dataList: ParsedDataTranferList,
  isPlainPaste = false,
 ): Promise<ClipboardData> => {
  const parsedEventData = await parseClipboardEventTextData(
-    event,
+    dataList,
    isPlainPaste,
  );

@ -519,3 +663,14 @@ const copyTextViaExecCommand = (text: string | null) => {

  return success;
 };
+
+export const isClipboardEvent = (
+  event: React.SyntheticEvent | Event,
+): event is ClipboardEvent => {
+  /** not using instanceof ClipboardEvent due to tests (jsdom) */
+  return (
+    event.type === EVENT.PASTE ||
+    event.type === EVENT.COPY ||
+    event.type === EVENT.CUT
+  );
+};
--- a/packages/excalidraw/components/Actions.scss
+++ b/packages/excalidraw/components/Actions.scss
@ -91,3 +91,120 @@
    }
  }
 }
+
+.compact-shape-actions {
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+  max-height: calc(100vh - 200px);
+  overflow-y: auto;
+  padding: 0.5rem;
+
+  .compact-action-item {
+    position: relative;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    min-height: 2.5rem;
+
+    --default-button-size: 2rem;
+
+    .compact-action-button {
+      width: 2rem;
+      height: 2rem;
+      border: none;
+      border-radius: var(--border-radius-lg);
+      background: transparent;
+      color: var(--color-on-surface);
+      cursor: pointer;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      transition: all 0.2s ease;
+
+      svg {
+        width: 1rem;
+        height: 1rem;
+        flex: 0 0 auto;
+      }
+
+      &:hover {
+        background: var(--button-hover-bg, var(--island-bg-color));
+        border-color: var(
+          --button-hover-border,
+          var(--button-border, var(--default-border-color))
+        );
+      }
+
+      &:active {
+        background: var(--button-active-bg, var(--island-bg-color));
+        border-color: var(--button-active-border, var(--color-primary-darkest));
+      }
+    }
+
+    .compact-popover-content {
+      .popover-section {
+        margin-bottom: 1rem;
+
+        &:last-child {
+          margin-bottom: 0;
+        }
+
+        .popover-section-title {
+          font-size: 0.75rem;
+          font-weight: 600;
+          color: var(--color-text-secondary);
+          margin-bottom: 0.5rem;
+          text-transform: uppercase;
+          letter-spacing: 0.5px;
+        }
+
+        .buttonList {
+          display: flex;
+          flex-wrap: wrap;
+          gap: 0.25rem;
+        }
+      }
+    }
+  }
+}
+
+.compact-shape-actions-island {
+  width: fit-content;
+  overflow-x: hidden;
+}
+
+.compact-popover-content {
+  .popover-section {
+    margin-bottom: 1rem;
+
+    &:last-child {
+      margin-bottom: 0;
+    }
+
+    .popover-section-title {
+      font-size: 0.75rem;
+      font-weight: 600;
+      color: var(--color-text-secondary);
+      margin-bottom: 0.5rem;
+      text-transform: uppercase;
+      letter-spacing: 0.5px;
+    }
+
+    .buttonList {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 0.25rem;
+    }
+  }
+}
+
+.shape-actions-theme-scope {
+  --button-border: transparent;
+  --button-bg: var(--color-surface-mid);
+}
+
+:root.theme--dark .shape-actions-theme-scope {
+  --button-hover-bg: #363541;
+  --button-bg: var(--color-surface-high);
+}
--- a/packages/excalidraw/components/Actions.tsx
+++ b/packages/excalidraw/components/Actions.tsx
@ -1,5 +1,6 @@
 import clsx from "clsx";
 import { useState } from "react";
+import * as Popover from "@radix-ui/react-popover";

 import {
  CLASSES,
@ -19,6 +20,7 @@ import {
  isImageElement,
  isLinearElement,
  isTextElement,
+  isArrowElement,
 } from "@excalidraw/element";

 import { hasStrokeColor, toolIsArrow } from "@excalidraw/element";
@ -46,15 +48,20 @@ import {
  hasStrokeWidth,
 } from "../scene";

-import { SHAPES } from "./shapes";
+import { getFormValue } from "../actions/actionProperties";
+
+import { useTextEditorFocus } from "../hooks/useTextEditorFocus";
+
+import { getToolbarTools } from "./shapes";

 import "./Actions.scss";

-import { useDevice } from "./App";
+import { useDevice, useExcalidrawContainer } from "./App";
 import Stack from "./Stack";
 import { ToolButton } from "./ToolButton";
 import { Tooltip } from "./Tooltip";
 import DropdownMenu from "./dropdownMenu/DropdownMenu";
+import { PropertiesPopover } from "./PropertiesPopover";
 import {
  EmbedIcon,
  extraToolsIcon,
@ -63,11 +70,29 @@ import {
  laserPointerToolIcon,
  MagicIcon,
  LassoIcon,
+  sharpArrowIcon,
+  roundArrowIcon,
+  elbowArrowIcon,
+  TextSizeIcon,
+  adjustmentsIcon,
+  DotsHorizontalIcon,
 } from "./icons";

-import type { AppClassProperties, AppProps, UIAppState, Zoom } from "../types";
+import type {
+  AppClassProperties,
+  AppProps,
+  UIAppState,
+  Zoom,
+  AppState,
+} from "../types";
 import type { ActionManager } from "../actions/manager";

+// Common CSS class combinations
+const PROPERTIES_CLASSES = clsx([
+  CLASSES.SHAPE_ACTIONS_THEME_SCOPE,
+  "properties-content",
+]);
+
 export const canChangeStrokeColor = (
  appState: UIAppState,
  targetElements: ExcalidrawElement[],
@ -280,6 +305,437 @@ export const SelectedShapeActions = ({
  );
 };

+export const CompactShapeActions = ({
+  appState,
+  elementsMap,
+  renderAction,
+  app,
+  setAppState,
+}: {
+  appState: UIAppState;
+  elementsMap: NonDeletedElementsMap | NonDeletedSceneElementsMap;
+  renderAction: ActionManager["renderAction"];
+  app: AppClassProperties;
+  setAppState: React.Component<any, AppState>["setState"];
+}) => {
+  const targetElements = getTargetElements(elementsMap, appState);
+  const { saveCaretPosition, restoreCaretPosition } = useTextEditorFocus();
+  const { container } = useExcalidrawContainer();
+
+  const isEditingTextOrNewElement = Boolean(
+    appState.editingTextElement || appState.newElement,
+  );
+
+  const showFillIcons =
+    (hasBackground(appState.activeTool.type) &&
+      !isTransparent(appState.currentItemBackgroundColor)) ||
+    targetElements.some(
+      (element) =>
+        hasBackground(element.type) && !isTransparent(element.backgroundColor),
+    );
+
+  const showLinkIcon = targetElements.length === 1;
+
+  const showLineEditorAction =
+    !appState.selectedLinearElement?.isEditing &&
+    targetElements.length === 1 &&
+    isLinearElement(targetElements[0]) &&
+    !isElbowArrow(targetElements[0]);
+
+  const showCropEditorAction =
+    !appState.croppingElementId &&
+    targetElements.length === 1 &&
+    isImageElement(targetElements[0]);
+
+  const showAlignActions = alignActionsPredicate(appState, app);
+
+  let isSingleElementBoundContainer = false;
+  if (
+    targetElements.length === 2 &&
+    (hasBoundTextElement(targetElements[0]) ||
+      hasBoundTextElement(targetElements[1]))
+  ) {
+    isSingleElementBoundContainer = true;
+  }
+
+  const isRTL = document.documentElement.getAttribute("dir") === "rtl";
+
+  return (
+    <div className="compact-shape-actions">
+      {/* Stroke Color */}
+      {canChangeStrokeColor(appState, targetElements) && (
+        <div className={clsx("compact-action-item")}>
+          {renderAction("changeStrokeColor")}
+        </div>
+      )}
+
+      {/* Background Color */}
+      {canChangeBackgroundColor(appState, targetElements) && (
+        <div className="compact-action-item">
+          {renderAction("changeBackgroundColor")}
+        </div>
+      )}
+
+      {/* Combined Properties (Fill, Stroke, Opacity) */}
+      {(showFillIcons ||
+        hasStrokeWidth(appState.activeTool.type) ||
+        targetElements.some((element) => hasStrokeWidth(element.type)) ||
+        hasStrokeStyle(appState.activeTool.type) ||
+        targetElements.some((element) => hasStrokeStyle(element.type)) ||
+        canChangeRoundness(appState.activeTool.type) ||
+        targetElements.some((element) => canChangeRoundness(element.type))) && (
+        <div className="compact-action-item">
+          <Popover.Root
+            open={appState.openPopup === "compactStrokeStyles"}
+            onOpenChange={(open) => {
+              if (open) {
+                setAppState({ openPopup: "compactStrokeStyles" });
+              } else {
+                setAppState({ openPopup: null });
+              }
+            }}
+          >
+            <Popover.Trigger asChild>
+              <button
+                type="button"
+                className="compact-action-button properties-trigger"
+                title={t("labels.stroke")}
+                onClick={(e) => {
+                  e.preventDefault();
+                  e.stopPropagation();
+
+                  setAppState({
+                    openPopup:
+                      appState.openPopup === "compactStrokeStyles"
+                        ? null
+                        : "compactStrokeStyles",
+                  });
+                }}
+              >
+                {adjustmentsIcon}
+              </button>
+            </Popover.Trigger>
+            {appState.openPopup === "compactStrokeStyles" && (
+              <PropertiesPopover
+                className={PROPERTIES_CLASSES}
+                container={container}
+                style={{ maxWidth: "13rem" }}
+                onClose={() => {}}
+              >
+                <div className="selected-shape-actions">
+                  {showFillIcons && renderAction("changeFillStyle")}
+                  {(hasStrokeWidth(appState.activeTool.type) ||
+                    targetElements.some((element) =>
+                      hasStrokeWidth(element.type),
+                    )) &&
+                    renderAction("changeStrokeWidth")}
+                  {(hasStrokeStyle(appState.activeTool.type) ||
+                    targetElements.some((element) =>
+                      hasStrokeStyle(element.type),
+                    )) && (
+                    <>
+                      {renderAction("changeStrokeStyle")}
+                      {renderAction("changeSloppiness")}
+                    </>
+                  )}
+                  {(canChangeRoundness(appState.activeTool.type) ||
+                    targetElements.some((element) =>
+                      canChangeRoundness(element.type),
+                    )) &&
+                    renderAction("changeRoundness")}
+                  {renderAction("changeOpacity")}
+                </div>
+              </PropertiesPopover>
+            )}
+          </Popover.Root>
+        </div>
+      )}
+
+      {/* Combined Arrow Properties */}
+      {(toolIsArrow(appState.activeTool.type) ||
+        targetElements.some((element) => toolIsArrow(element.type))) && (
+        <div className="compact-action-item">
+          <Popover.Root
+            open={appState.openPopup === "compactArrowProperties"}
+            onOpenChange={(open) => {
+              if (open) {
+                setAppState({ openPopup: "compactArrowProperties" });
+              } else {
+                setAppState({ openPopup: null });
+              }
+            }}
+          >
+            <Popover.Trigger asChild>
+              <button
+                type="button"
+                className="compact-action-button properties-trigger"
+                title={t("labels.arrowtypes")}
+                onClick={(e) => {
+                  e.preventDefault();
+                  e.stopPropagation();
+
+                  setAppState({
+                    openPopup:
+                      appState.openPopup === "compactArrowProperties"
+                        ? null
+                        : "compactArrowProperties",
+                  });
+                }}
+              >
+                {(() => {
+                  // Show an icon based on the current arrow type
+                  const arrowType = getFormValue(
+                    targetElements,
+                    app,
+                    (element) => {
+                      if (isArrowElement(element)) {
+                        return element.elbowed
+                          ? "elbow"
+                          : element.roundness
+                          ? "round"
+                          : "sharp";
+                      }
+                      return null;
+                    },
+                    (element) => isArrowElement(element),
+                    (hasSelection) =>
+                      hasSelection ? null : appState.currentItemArrowType,
+                  );
+
+                  if (arrowType === "elbow") {
+                    return elbowArrowIcon;
+                  }
+                  if (arrowType === "round") {
+                    return roundArrowIcon;
+                  }
+                  return sharpArrowIcon;
+                })()}
+              </button>
+            </Popover.Trigger>
+            {appState.openPopup === "compactArrowProperties" && (
+              <PropertiesPopover
+                container={container}
+                className="properties-content"
+                style={{ maxWidth: "13rem" }}
+                onClose={() => {}}
+              >
+                {renderAction("changeArrowProperties")}
+              </PropertiesPopover>
+            )}
+          </Popover.Root>
+        </div>
+      )}
+
+      {/* Linear Editor */}
+      {showLineEditorAction && (
+        <div className="compact-action-item">
+          {renderAction("toggleLinearEditor")}
+        </div>
+      )}
+
+      {/* Text Properties */}
+      {(appState.activeTool.type === "text" ||
+        targetElements.some(isTextElement)) && (
+        <>
+          <div className="compact-action-item">
+            {renderAction("changeFontFamily")}
+          </div>
+          <div className="compact-action-item">
+            <Popover.Root
+              open={appState.openPopup === "compactTextProperties"}
+              onOpenChange={(open) => {
+                if (open) {
+                  if (appState.editingTextElement) {
+                    saveCaretPosition();
+                  }
+                  setAppState({ openPopup: "compactTextProperties" });
+                } else {
+                  setAppState({ openPopup: null });
+                  if (appState.editingTextElement) {
+                    restoreCaretPosition();
+                  }
+                }
+              }}
+            >
+              <Popover.Trigger asChild>
+                <button
+                  type="button"
+                  className="compact-action-button properties-trigger"
+                  title={t("labels.textAlign")}
+                  onClick={(e) => {
+                    e.preventDefault();
+                    e.stopPropagation();
+
+                    if (appState.openPopup === "compactTextProperties") {
+                      setAppState({ openPopup: null });
+                    } else {
+                      if (appState.editingTextElement) {
+                        saveCaretPosition();
+                      }
+                      setAppState({ openPopup: "compactTextProperties" });
+                    }
+                  }}
+                >
+                  {TextSizeIcon}
+                </button>
+              </Popover.Trigger>
+              {appState.openPopup === "compactTextProperties" && (
+                <PropertiesPopover
+                  className={PROPERTIES_CLASSES}
+                  container={container}
+                  style={{ maxWidth: "13rem" }}
+                  // Improve focus handling for text editing scenarios
+                  preventAutoFocusOnTouch={!!appState.editingTextElement}
+                  onClose={() => {
+                    // Refocus text editor when popover closes with caret restoration
+                    if (appState.editingTextElement) {
+                      restoreCaretPosition();
+                    }
+                  }}
+                >
+                  <div className="selected-shape-actions">
+                    {(appState.activeTool.type === "text" ||
+                      targetElements.some(isTextElement)) &&
+                      renderAction("changeFontSize")}
+                    {(appState.activeTool.type === "text" ||
+                      suppportsHorizontalAlign(targetElements, elementsMap)) &&
+                      renderAction("changeTextAlign")}
+                    {shouldAllowVerticalAlign(targetElements, elementsMap) &&
+                      renderAction("changeVerticalAlign")}
+                  </div>
+                </PropertiesPopover>
+              )}
+            </Popover.Root>
+          </div>
+        </>
+      )}
+
+      {/* Dedicated Copy Button */}
+      {!isEditingTextOrNewElement && targetElements.length > 0 && (
+        <div className="compact-action-item">
+          {renderAction("duplicateSelection")}
+        </div>
+      )}
+
+      {/* Dedicated Delete Button */}
+      {!isEditingTextOrNewElement && targetElements.length > 0 && (
+        <div className="compact-action-item">
+          {renderAction("deleteSelectedElements")}
+        </div>
+      )}
+
+      {/* Combined Other Actions */}
+      {!isEditingTextOrNewElement && targetElements.length > 0 && (
+        <div className="compact-action-item">
+          <Popover.Root
+            open={appState.openPopup === "compactOtherProperties"}
+            onOpenChange={(open) => {
+              if (open) {
+                setAppState({ openPopup: "compactOtherProperties" });
+              } else {
+                setAppState({ openPopup: null });
+              }
+            }}
+          >
+            <Popover.Trigger asChild>
+              <button
+                type="button"
+                className="compact-action-button properties-trigger"
+                title={t("labels.actions")}
+                onClick={(e) => {
+                  e.preventDefault();
+                  e.stopPropagation();
+                  setAppState({
+                    openPopup:
+                      appState.openPopup === "compactOtherProperties"
+                        ? null
+                        : "compactOtherProperties",
+                  });
+                }}
+              >
+                {DotsHorizontalIcon}
+              </button>
+            </Popover.Trigger>
+            {appState.openPopup === "compactOtherProperties" && (
+              <PropertiesPopover
+                className={PROPERTIES_CLASSES}
+                container={container}
+                style={{
+                  maxWidth: "12rem",
+                  // center the popover content
+                  justifyContent: "center",
+                  alignItems: "center",
+                }}
+                onClose={() => {}}
+              >
+                <div className="selected-shape-actions">
+                  <fieldset>
+                    <legend>{t("labels.layers")}</legend>
+                    <div className="buttonList">
+                      {renderAction("sendToBack")}
+                      {renderAction("sendBackward")}
+                      {renderAction("bringForward")}
+                      {renderAction("bringToFront")}
+                    </div>
+                  </fieldset>
+
+                  {showAlignActions && !isSingleElementBoundContainer && (
+                    <fieldset>
+                      <legend>{t("labels.align")}</legend>
+                      <div className="buttonList">
+                        {isRTL ? (
+                          <>
+                            {renderAction("alignRight")}
+                            {renderAction("alignHorizontallyCentered")}
+                            {renderAction("alignLeft")}
+                          </>
+                        ) : (
+                          <>
+                            {renderAction("alignLeft")}
+                            {renderAction("alignHorizontallyCentered")}
+                            {renderAction("alignRight")}
+                          </>
+                        )}
+                        {targetElements.length > 2 &&
+                          renderAction("distributeHorizontally")}
+                        {/* breaks the row ˇˇ */}
+                        <div style={{ flexBasis: "100%", height: 0 }} />
+                        <div
+                          style={{
+                            display: "flex",
+                            flexWrap: "wrap",
+                            gap: ".5rem",
+                            marginTop: "-0.5rem",
+                          }}
+                        >
+                          {renderAction("alignTop")}
+                          {renderAction("alignVerticallyCentered")}
+                          {renderAction("alignBottom")}
+                          {targetElements.length > 2 &&
+                            renderAction("distributeVertically")}
+                        </div>
+                      </div>
+                    </fieldset>
+                  )}
+                  <fieldset>
+                    <legend>{t("labels.actions")}</legend>
+                    <div className="buttonList">
+                      {renderAction("group")}
+                      {renderAction("ungroup")}
+                      {showLinkIcon && renderAction("hyperlink")}
+                      {showCropEditorAction && renderAction("cropEditor")}
+                    </div>
+                  </fieldset>
+                </div>
+              </PropertiesPopover>
+            )}
+          </Popover.Root>
+        </div>
+      )}
+    </div>
+  );
+};
+
 export const ShapesSwitcher = ({
  activeTool,
  appState,
@ -295,7 +751,8 @@ export const ShapesSwitcher = ({

  const frameToolSelected = activeTool.type === "frame";
  const laserToolSelected = activeTool.type === "laser";
-  const lassoToolSelected = activeTool.type === "lasso";
+  const lassoToolSelected =
+    activeTool.type === "lasso" && app.defaultSelectionTool !== "lasso";

  const embeddableToolSelected = activeTool.type === "embeddable";

@ -303,63 +760,68 @@ export const ShapesSwitcher = ({

  return (
    <>
-      {SHAPES.map(({ value, icon, key, numericKey, fillable }, index) => {
-        if (
-          UIOptions.tools?.[
-            value as Extract<typeof value, keyof AppProps["UIOptions"]["tools"]>
-          ] === false
-        ) {
-          return null;
-        }
+      {getToolbarTools(app).map(
+        ({ value, icon, key, numericKey, fillable }, index) => {
+          if (
+            UIOptions.tools?.[
+              value as Extract<
+                typeof value,
+                keyof AppProps["UIOptions"]["tools"]
+              >
+            ] === false
+          ) {
+            return null;
+          }

-        const label = t(`toolBar.${value}`);
-        const letter =
-          key && capitalizeString(typeof key === "string" ? key : key[0]);
-        const shortcut = letter
-          ? `${letter} ${t("helpDialog.or")} ${numericKey}`
-          : `${numericKey}`;
+          const label = t(`toolBar.${value}`);
+          const letter =
+            key && capitalizeString(typeof key === "string" ? key : key[0]);
+          const shortcut = letter
+            ? `${letter} ${t("helpDialog.or")} ${numericKey}`
+            : `${numericKey}`;

-        return (
-          <ToolButton
-            className={clsx("Shape", { fillable })}
-            key={value}
-            type="radio"
-            icon={icon}
-            checked={activeTool.type === value}
-            name="editor-current-shape"
-            title={`${capitalizeString(label)} — ${shortcut}`}
-            keyBindingLabel={numericKey || letter}
-            aria-label={capitalizeString(label)}
-            aria-keyshortcuts={shortcut}
-            data-testid={`toolbar-${value}`}
-            onPointerDown={({ pointerType }) => {
-              if (!appState.penDetected && pointerType === "pen") {
-                app.togglePenMode(true);
-              }
-
-              if (value === "selection") {
-                if (appState.activeTool.type === "selection") {
-                  app.setActiveTool({ type: "lasso" });
-                } else {
-                  app.setActiveTool({ type: "selection" });
+          return (
+            <ToolButton
+              className={clsx("Shape", { fillable })}
+              key={value}
+              type="radio"
+              icon={icon}
+              checked={activeTool.type === value}
+              name="editor-current-shape"
+              title={`${capitalizeString(label)} — ${shortcut}`}
+              keyBindingLabel={numericKey || letter}
+              aria-label={capitalizeString(label)}
+              aria-keyshortcuts={shortcut}
+              data-testid={`toolbar-${value}`}
+              onPointerDown={({ pointerType }) => {
+                if (!appState.penDetected && pointerType === "pen") {
+                  app.togglePenMode(true);
                }
-              }
-            }}
-            onChange={({ pointerType }) => {
-              if (appState.activeTool.type !== value) {
-                trackEvent("toolbar", value, "ui");
-              }
-              if (value === "image") {
-                app.setActiveTool({
-                  type: value,
-                });
-              } else {
-                app.setActiveTool({ type: value });
-              }
-            }}
-          />
-        );
-      })}
+
+                if (value === "selection") {
+                  if (appState.activeTool.type === "selection") {
+                    app.setActiveTool({ type: "lasso" });
+                  } else {
+                    app.setActiveTool({ type: "selection" });
+                  }
+                }
+              }}
+              onChange={({ pointerType }) => {
+                if (appState.activeTool.type !== value) {
+                  trackEvent("toolbar", value, "ui");
+                }
+                if (value === "image") {
+                  app.setActiveTool({
+                    type: value,
+                  });
+                } else {
+                  app.setActiveTool({ type: value });
+                }
+              }}
+            />
+          );
+        },
+      )}
      <div className="App-toolbar__divider" />

      <DropdownMenu open={isExtraToolsMenuOpen}>
@ -418,14 +880,16 @@ export const ShapesSwitcher = ({
          >
            {t("toolBar.laser")}
          </DropdownMenu.Item>
-          <DropdownMenu.Item
-            onSelect={() => app.setActiveTool({ type: "lasso" })}
-            icon={LassoIcon}
-            data-testid="toolbar-lasso"
-            selected={lassoToolSelected}
-          >
-            {t("toolBar.lasso")}
-          </DropdownMenu.Item>
+          {app.defaultSelectionTool !== "lasso" && (
+            <DropdownMenu.Item
+              onSelect={() => app.setActiveTool({ type: "lasso" })}
+              icon={LassoIcon}
+              data-testid="toolbar-lasso"
+              selected={lassoToolSelected}
+            >
+              {t("toolBar.lasso")}
+            </DropdownMenu.Item>
+          )}
          <div style={{ margin: "6px 0", fontSize: 14, fontWeight: 600 }}>
            Generate
          </div>
--- a/packages/excalidraw/components/App.tsx
+++ b/packages/excalidraw/components/App.tsx
--- a/packages/excalidraw/components/ColorPicker/ColorPicker.scss
+++ b/packages/excalidraw/components/ColorPicker/ColorPicker.scss
@ -22,6 +22,12 @@
    @include isMobile {
      max-width: 11rem;
    }
+
+    &.color-picker-container--no-top-picks {
+      display: flex;
+      justify-content: center;
+      grid-template-columns: unset;
+    }
  }

  .color-picker__top-picks {
@ -80,6 +86,16 @@
      }
    }

+    .color-picker__button-background {
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      svg {
+        width: 100%;
+        height: 100%;
+      }
+    }
+
    &.active {
      .color-picker__button-outline {
        position: absolute;
--- a/packages/excalidraw/components/ColorPicker/ColorPicker.tsx
+++ b/packages/excalidraw/components/ColorPicker/ColorPicker.tsx
@ -1,6 +1,6 @@
 import * as Popover from "@radix-ui/react-popover";
 import clsx from "clsx";
-import { useRef } from "react";
+import { useRef, useEffect } from "react";

 import {
  COLOR_OUTLINE_CONTRAST_THRESHOLD,
@ -18,7 +18,12 @@ import { useExcalidrawContainer } from "../App";
 import { ButtonSeparator } from "../ButtonSeparator";
 import { activeEyeDropperAtom } from "../EyeDropper";
 import { PropertiesPopover } from "../PropertiesPopover";
-import { slashIcon } from "../icons";
+import { backgroundIcon, slashIcon, strokeIcon } from "../icons";
+import {
+  saveCaretPosition,
+  restoreCaretPosition,
+  temporarilyDisableTextEditorBlur,
+} from "../../hooks/useTextEditorFocus";

 import { ColorInput } from "./ColorInput";
 import { Picker } from "./Picker";
@ -67,6 +72,7 @@ interface ColorPickerProps {
  palette?: ColorPaletteCustom | null;
  topPicks?: ColorTuple;
  updateData: (formData?: any) => void;
+  compactMode?: boolean;
 }

 const ColorPickerPopupContent = ({
@ -77,6 +83,8 @@ const ColorPickerPopupContent = ({
  elements,
  palette = COLOR_PALETTE,
  updateData,
+  getOpenPopup,
+  appState,
 }: Pick<
  ColorPickerProps,
  | "type"
@ -86,7 +94,10 @@ const ColorPickerPopupContent = ({
  | "elements"
  | "palette"
  | "updateData"
->) => {
+  | "appState"
+> & {
+  getOpenPopup: () => AppState["openPopup"];
+}) => {
  const { container } = useExcalidrawContainer();
  const [, setActiveColorPickerSection] = useAtom(activeColorPickerSectionAtom);

@ -117,6 +128,8 @@ const ColorPickerPopupContent = ({
    <PropertiesPopover
      container={container}
      style={{ maxWidth: "13rem" }}
+      // Improve focus handling for text editing scenarios
+      preventAutoFocusOnTouch={!!appState.editingTextElement}
      onFocusOutside={(event) => {
        // refocus due to eye dropper
        focusPickerContent();
@ -131,8 +144,23 @@ const ColorPickerPopupContent = ({
        }
      }}
      onClose={() => {
-        updateData({ openPopup: null });
+        // only clear if we're still the active popup (avoid racing with switch)
+        if (getOpenPopup() === type) {
+          updateData({ openPopup: null });
+        }
        setActiveColorPickerSection(null);
+
+        // Refocus text editor when popover closes if we were editing text
+        if (appState.editingTextElement) {
+          setTimeout(() => {
+            const textEditor = document.querySelector(
+              ".excalidraw-wysiwyg",
+            ) as HTMLTextAreaElement;
+            if (textEditor) {
+              textEditor.focus();
+            }
+          }, 0);
+        }
      }}
    >
      {palette ? (
@ -141,7 +169,17 @@ const ColorPickerPopupContent = ({
          palette={palette}
          color={color}
          onChange={(changedColor) => {
+            // Save caret position before color change if editing text
+            const savedSelection = appState.editingTextElement
+              ? saveCaretPosition()
+              : null;
+
            onChange(changedColor);
+
+            // Restore caret position after color change if editing text
+            if (appState.editingTextElement && savedSelection) {
+              restoreCaretPosition(savedSelection);
+            }
          }}
          onEyeDropperToggle={(force) => {
            setEyeDropperState((state) => {
@ -168,6 +206,7 @@ const ColorPickerPopupContent = ({
            if (eyeDropperState) {
              setEyeDropperState(null);
            } else {
+              // close explicitly on Escape
              updateData({ openPopup: null });
            }
          }}
@ -188,11 +227,32 @@ const ColorPickerTrigger = ({
  label,
  color,
  type,
+  compactMode = false,
+  mode = "background",
+  onToggle,
+  editingTextElement,
 }: {
  color: string | null;
  label: string;
  type: ColorPickerType;
+  compactMode?: boolean;
+  mode?: "background" | "stroke";
+  onToggle: () => void;
+  editingTextElement?: boolean;
 }) => {
+  const handleClick = (e: React.MouseEvent) => {
+    // use pointerdown so we run before outside-close logic
+    e.preventDefault();
+    e.stopPropagation();
+
+    // If editing text, temporarily disable the wysiwyg blur event
+    if (editingTextElement) {
+      temporarilyDisableTextEditorBlur();
+    }
+
+    onToggle();
+  };
+
  return (
    <Popover.Trigger
      type="button"
@ -208,8 +268,37 @@ const ColorPickerTrigger = ({
          ? t("labels.showStroke")
          : t("labels.showBackground")
      }
+      data-openpopup={type}
+      onClick={handleClick}
    >
      <div className="color-picker__button-outline">{!color && slashIcon}</div>
+      {compactMode && color && (
+        <div className="color-picker__button-background">
+          {mode === "background" ? (
+            <span
+              style={{
+                color:
+                  color && isColorDark(color, COLOR_OUTLINE_CONTRAST_THRESHOLD)
+                    ? "#fff"
+                    : "#111",
+              }}
+            >
+              {backgroundIcon}
+            </span>
+          ) : (
+            <span
+              style={{
+                color:
+                  color && isColorDark(color, COLOR_OUTLINE_CONTRAST_THRESHOLD)
+                    ? "#fff"
+                    : "#111",
+              }}
+            >
+              {strokeIcon}
+            </span>
+          )}
+        </div>
+      )}
    </Popover.Trigger>
  );
 };
@ -224,25 +313,59 @@ export const ColorPicker = ({
  topPicks,
  updateData,
  appState,
+  compactMode = false,
 }: ColorPickerProps) => {
+  const openRef = useRef(appState.openPopup);
+  useEffect(() => {
+    openRef.current = appState.openPopup;
+  }, [appState.openPopup]);
  return (
    <div>
-      <div role="dialog" aria-modal="true" className="color-picker-container">
-        <TopPicks
-          activeColor={color}
-          onChange={onChange}
-          type={type}
-          topPicks={topPicks}
-        />
-        <ButtonSeparator />
+      <div
+        role="dialog"
+        aria-modal="true"
+        className={clsx("color-picker-container", {
+          "color-picker-container--no-top-picks": compactMode,
+        })}
+      >
+        {!compactMode && (
+          <TopPicks
+            activeColor={color}
+            onChange={onChange}
+            type={type}
+            topPicks={topPicks}
+          />
+        )}
+        {!compactMode && <ButtonSeparator />}
        <Popover.Root
          open={appState.openPopup === type}
          onOpenChange={(open) => {
-            updateData({ openPopup: open ? type : null });
+            if (open) {
+              updateData({ openPopup: type });
+            }
          }}
        >
          {/* serves as an active color indicator as well */}
-          <ColorPickerTrigger color={color} label={label} type={type} />
+          <ColorPickerTrigger
+            color={color}
+            label={label}
+            type={type}
+            compactMode={compactMode}
+            mode={type === "elementStroke" ? "stroke" : "background"}
+            editingTextElement={!!appState.editingTextElement}
+            onToggle={() => {
+              // atomic switch: if another popup is open, close it first, then open this one next tick
+              if (appState.openPopup === type) {
+                // toggle off on same trigger
+                updateData({ openPopup: null });
+              } else if (appState.openPopup) {
+                updateData({ openPopup: type });
+              } else {
+                // open this one
+                updateData({ openPopup: type });
+              }
+            }}
+          />
          {/* popup content */}
          {appState.openPopup === type && (
            <ColorPickerPopupContent
@ -253,6 +376,8 @@ export const ColorPicker = ({
              elements={elements}
              palette={palette}
              updateData={updateData}
+              getOpenPopup={() => openRef.current}
+              appState={appState}
            />
          )}
        </Popover.Root>
--- a/packages/excalidraw/components/FontPicker/FontPicker.scss
+++ b/packages/excalidraw/components/FontPicker/FontPicker.scss
@ -11,5 +11,10 @@
        2rem + 4 * var(--default-button-size)
      ); // 4 gaps + 4 buttons
    }
+
+    &--compact {
+      display: block;
+      grid-template-columns: none;
+    }
  }
 }
--- a/packages/excalidraw/components/FontPicker/FontPicker.tsx
+++ b/packages/excalidraw/components/FontPicker/FontPicker.tsx
@ -1,4 +1,5 @@
 import * as Popover from "@radix-ui/react-popover";
+import clsx from "clsx";
 import React, { useCallback, useMemo } from "react";

 import { FONT_FAMILY } from "@excalidraw/common";
@ -58,6 +59,7 @@ interface FontPickerProps {
  onHover: (fontFamily: FontFamilyValues) => void;
  onLeave: () => void;
  onPopupChange: (open: boolean) => void;
+  compactMode?: boolean;
 }

 export const FontPicker = React.memo(
@ -69,6 +71,7 @@ export const FontPicker = React.memo(
    onHover,
    onLeave,
    onPopupChange,
+    compactMode = false,
  }: FontPickerProps) => {
    const defaultFonts = useMemo(() => DEFAULT_FONTS, []);
    const onSelectCallback = useCallback(
@ -81,18 +84,29 @@ export const FontPicker = React.memo(
    );

    return (
-      <div role="dialog" aria-modal="true" className="FontPicker__container">
-        <div className="buttonList">
-          <RadioSelection<FontFamilyValues | false>
-            type="button"
-            options={defaultFonts}
-            value={selectedFontFamily}
-            onClick={onSelectCallback}
-          />
-        </div>
-        <ButtonSeparator />
+      <div
+        role="dialog"
+        aria-modal="true"
+        className={clsx("FontPicker__container", {
+          "FontPicker__container--compact": compactMode,
+        })}
+      >
+        {!compactMode && (
+          <div className="buttonList">
+            <RadioSelection<FontFamilyValues | false>
+              type="button"
+              options={defaultFonts}
+              value={selectedFontFamily}
+              onClick={onSelectCallback}
+            />
+          </div>
+        )}
+        {!compactMode && <ButtonSeparator />}
        <Popover.Root open={isOpened} onOpenChange={onPopupChange}>
-          <FontPickerTrigger selectedFontFamily={selectedFontFamily} />
+          <FontPickerTrigger
+            selectedFontFamily={selectedFontFamily}
+            isOpened={isOpened}
+          />
          {isOpened && (
            <FontPickerList
              selectedFontFamily={selectedFontFamily}
--- a/packages/excalidraw/components/FontPicker/FontPickerList.tsx
+++ b/packages/excalidraw/components/FontPicker/FontPickerList.tsx
@ -90,7 +90,8 @@ export const FontPickerList = React.memo(
    onClose,
  }: FontPickerListProps) => {
    const { container } = useExcalidrawContainer();
-    const { fonts } = useApp();
+    const app = useApp();
+    const { fonts } = app;
    const { showDeprecatedFonts } = useAppProps();

    const [searchTerm, setSearchTerm] = useState("");
@ -187,6 +188,42 @@ export const FontPickerList = React.memo(
      onLeave,
    ]);

+    // Create a wrapped onSelect function that preserves caret position
+    const wrappedOnSelect = useCallback(
+      (fontFamily: FontFamilyValues) => {
+        // Save caret position before font selection if editing text
+        let savedSelection: { start: number; end: number } | null = null;
+        if (app.state.editingTextElement) {
+          const textEditor = document.querySelector(
+            ".excalidraw-wysiwyg",
+          ) as HTMLTextAreaElement;
+          if (textEditor) {
+            savedSelection = {
+              start: textEditor.selectionStart,
+              end: textEditor.selectionEnd,
+            };
+          }
+        }
+
+        onSelect(fontFamily);
+
+        // Restore caret position after font selection if editing text
+        if (app.state.editingTextElement && savedSelection) {
+          setTimeout(() => {
+            const textEditor = document.querySelector(
+              ".excalidraw-wysiwyg",
+            ) as HTMLTextAreaElement;
+            if (textEditor && savedSelection) {
+              textEditor.focus();
+              textEditor.selectionStart = savedSelection.start;
+              textEditor.selectionEnd = savedSelection.end;
+            }
+          }, 0);
+        }
+      },
+      [onSelect, app.state.editingTextElement],
+    );
+
    const onKeyDown = useCallback<KeyboardEventHandler<HTMLDivElement>>(
      (event) => {
        const handled = fontPickerKeyHandler({
@ -194,7 +231,7 @@ export const FontPickerList = React.memo(
          inputRef,
          hoveredFont,
          filteredFonts,
-          onSelect,
+          onSelect: wrappedOnSelect,
          onHover,
          onClose,
        });
@ -204,7 +241,7 @@ export const FontPickerList = React.memo(
          event.stopPropagation();
        }
      },
-      [hoveredFont, filteredFonts, onSelect, onHover, onClose],
+      [hoveredFont, filteredFonts, wrappedOnSelect, onHover, onClose],
    );

    useEffect(() => {
@ -240,7 +277,7 @@ export const FontPickerList = React.memo(
        // allow to tab between search and selected font
        tabIndex={font.value === selectedFontFamily ? 0 : -1}
        onClick={(e) => {
-          onSelect(Number(e.currentTarget.value));
+          wrappedOnSelect(Number(e.currentTarget.value));
        }}
        onMouseMove={() => {
          if (hoveredFont?.value !== font.value) {
@ -282,9 +319,24 @@ export const FontPickerList = React.memo(
        className="properties-content"
        container={container}
        style={{ width: "15rem" }}
-        onClose={onClose}
+        onClose={() => {
+          onClose();
+
+          // Refocus text editor when font picker closes if we were editing text
+          if (app.state.editingTextElement) {
+            setTimeout(() => {
+              const textEditor = document.querySelector(
+                ".excalidraw-wysiwyg",
+              ) as HTMLTextAreaElement;
+              if (textEditor) {
+                textEditor.focus();
+              }
+            }, 0);
+          }
+        }}
        onPointerLeave={onLeave}
        onKeyDown={onKeyDown}
+        preventAutoFocusOnTouch={!!app.state.editingTextElement}
      >
        <QuickSearch
          ref={inputRef}
--- a/packages/excalidraw/components/FontPicker/FontPickerTrigger.tsx
+++ b/packages/excalidraw/components/FontPicker/FontPickerTrigger.tsx
@ -1,5 +1,4 @@
 import * as Popover from "@radix-ui/react-popover";
-import { useMemo } from "react";

 import type { FontFamilyValues } from "@excalidraw/element/types";

@ -7,33 +6,38 @@ import { t } from "../../i18n";
 import { ButtonIcon } from "../ButtonIcon";
 import { TextIcon } from "../icons";

-import { isDefaultFont } from "./FontPicker";
+import { useExcalidrawSetAppState } from "../App";

 interface FontPickerTriggerProps {
  selectedFontFamily: FontFamilyValues | null;
+  isOpened?: boolean;
 }

 export const FontPickerTrigger = ({
  selectedFontFamily,
+  isOpened = false,
 }: FontPickerTriggerProps) => {
-  const isTriggerActive = useMemo(
-    () => Boolean(selectedFontFamily && !isDefaultFont(selectedFontFamily)),
-    [selectedFontFamily],
-  );
+  const setAppState = useExcalidrawSetAppState();

  return (
    <Popover.Trigger asChild>
-      {/* Empty div as trigger so it's stretched 100% due to different button sizes */}
-      <div>
+      <div data-openpopup="fontFamily" className="properties-trigger">
        <ButtonIcon
          standalone
          icon={TextIcon}
          title={t("labels.showFonts")}
          className="properties-trigger"
          testId={"font-family-show-fonts"}
-          active={isTriggerActive}
-          // no-op
-          onClick={() => {}}
+          active={isOpened}
+          onClick={() => {
+            setAppState((appState) => ({
+              openPopup:
+                appState.openPopup === "fontFamily" ? null : appState.openPopup,
+            }));
+          }}
+          style={{
+            border: "none",
+          }}
        />
      </div>
    </Popover.Trigger>
--- a/packages/excalidraw/components/LayerUI.scss
+++ b/packages/excalidraw/components/LayerUI.scss
@ -24,6 +24,10 @@
      gap: 0.75rem;
      pointer-events: none !important;

+      &--compact {
+        gap: 0.5rem;
+      }
+
      & > * {
        pointer-events: var(--ui-pointerEvents);
      }
--- a/packages/excalidraw/components/LayerUI.tsx
+++ b/packages/excalidraw/components/LayerUI.tsx
@ -4,6 +4,7 @@ import React from "react";
 import {
  CLASSES,
  DEFAULT_SIDEBAR,
+  MQ_MIN_WIDTH_DESKTOP,
  TOOL_TYPE,
  arrayToMap,
  capitalizeString,
@ -28,7 +29,11 @@ import { useAtom, useAtomValue } from "../editor-jotai";
 import { t } from "../i18n";
 import { calculateScrollCenter } from "../scene";

-import { SelectedShapeActions, ShapesSwitcher } from "./Actions";
+import {
+  SelectedShapeActions,
+  ShapesSwitcher,
+  CompactShapeActions,
+} from "./Actions";
 import { LoadingMessage } from "./LoadingMessage";
 import { LockButton } from "./LockButton";
 import { MobileMenu } from "./MobileMenu";
@ -157,6 +162,25 @@ const LayerUI = ({
  const device = useDevice();
  const tunnels = useInitializeTunnels();

+  const spacing =
+    appState.stylesPanelMode === "compact"
+      ? {
+          menuTopGap: 4,
+          toolbarColGap: 4,
+          toolbarRowGap: 1,
+          toolbarInnerRowGap: 0.5,
+          islandPadding: 1,
+          collabMarginLeft: 8,
+        }
+      : {
+          menuTopGap: 6,
+          toolbarColGap: 4,
+          toolbarRowGap: 1,
+          toolbarInnerRowGap: 1,
+          islandPadding: 1,
+          collabMarginLeft: 8,
+        };
+
  const TunnelsJotaiProvider = tunnels.tunnelsJotai.Provider;

  const [eyeDropperState, setEyeDropperState] = useAtom(activeEyeDropperAtom);
@ -209,31 +233,55 @@ const LayerUI = ({
    </div>
  );

-  const renderSelectedShapeActions = () => (
-    <Section
-      heading="selectedShapeActions"
-      className={clsx("selected-shape-actions zen-mode-transition", {
-        "transition-left": appState.zenModeEnabled,
-      })}
-    >
-      <Island
-        className={CLASSES.SHAPE_ACTIONS_MENU}
-        padding={2}
-        style={{
-          // we want to make sure this doesn't overflow so subtracting the
-          // approximate height of hamburgerMenu + footer
-          maxHeight: `${appState.height - 166}px`,
-        }}
+  const renderSelectedShapeActions = () => {
+    const isCompactMode = appState.stylesPanelMode === "compact";
+
+    return (
+      <Section
+        heading="selectedShapeActions"
+        className={clsx("selected-shape-actions zen-mode-transition", {
+          "transition-left": appState.zenModeEnabled,
+        })}
      >
-        <SelectedShapeActions
-          appState={appState}
-          elementsMap={app.scene.getNonDeletedElementsMap()}
-          renderAction={actionManager.renderAction}
-          app={app}
-        />
-      </Island>
-    </Section>
-  );
+        {isCompactMode ? (
+          <Island
+            className={clsx("compact-shape-actions-island")}
+            padding={0}
+            style={{
+              // we want to make sure this doesn't overflow so subtracting the
+              // approximate height of hamburgerMenu + footer
+              maxHeight: `${appState.height - 166}px`,
+            }}
+          >
+            <CompactShapeActions
+              appState={appState}
+              elementsMap={app.scene.getNonDeletedElementsMap()}
+              renderAction={actionManager.renderAction}
+              app={app}
+              setAppState={setAppState}
+            />
+          </Island>
+        ) : (
+          <Island
+            className={CLASSES.SHAPE_ACTIONS_MENU}
+            padding={2}
+            style={{
+              // we want to make sure this doesn't overflow so subtracting the
+              // approximate height of hamburgerMenu + footer
+              maxHeight: `${appState.height - 166}px`,
+            }}
+          >
+            <SelectedShapeActions
+              appState={appState}
+              elementsMap={app.scene.getNonDeletedElementsMap()}
+              renderAction={actionManager.renderAction}
+              app={app}
+            />
+          </Island>
+        )}
+      </Section>
+    );
+  };

  const renderFixedSideContainer = () => {
    const shouldRenderSelectedShapeActions = showSelectedShapeActions(
@ -250,9 +298,19 @@ const LayerUI = ({
    return (
      <FixedSideContainer side="top">
        <div className="App-menu App-menu_top">
-          <Stack.Col gap={6} className={clsx("App-menu_top__left")}>
+          <Stack.Col
+            gap={spacing.menuTopGap}
+            className={clsx("App-menu_top__left")}
+          >
            {renderCanvasActions()}
-            {shouldRenderSelectedShapeActions && renderSelectedShapeActions()}
+            <div
+              className={clsx("selected-shape-actions-container", {
+                "selected-shape-actions-container--compact":
+                  appState.stylesPanelMode === "compact",
+              })}
+            >
+              {shouldRenderSelectedShapeActions && renderSelectedShapeActions()}
+            </div>
          </Stack.Col>
          {!appState.viewModeEnabled &&
            appState.openDialog?.name !== "elementLinkSelector" && (
@ -262,17 +320,19 @@ const LayerUI = ({
                    {renderWelcomeScreen && (
                      <tunnels.WelcomeScreenToolbarHintTunnel.Out />
                    )}
-                    <Stack.Col gap={4} align="start">
+                    <Stack.Col gap={spacing.toolbarColGap} align="start">
                      <Stack.Row
-                        gap={1}
+                        gap={spacing.toolbarRowGap}
                        className={clsx("App-toolbar-container", {
                          "zen-mode": appState.zenModeEnabled,
                        })}
                      >
                        <Island
-                          padding={1}
+                          padding={spacing.islandPadding}
                          className={clsx("App-toolbar", {
                            "zen-mode": appState.zenModeEnabled,
+                            "App-toolbar--compact":
+                              appState.stylesPanelMode === "compact",
                          })}
                        >
                          <HintViewer
@ -282,7 +342,7 @@ const LayerUI = ({
                            app={app}
                          />
                          {heading}
-                          <Stack.Row gap={1}>
+                          <Stack.Row gap={spacing.toolbarInnerRowGap}>
                            <PenModeButton
                              zenModeEnabled={appState.zenModeEnabled}
                              checked={appState.penMode}
@ -316,7 +376,7 @@ const LayerUI = ({
                        {isCollaborating && (
                          <Island
                            style={{
-                              marginLeft: 8,
+                              marginLeft: spacing.collabMarginLeft,
                              alignSelf: "center",
                              height: "fit-content",
                            }}
@ -344,6 +404,8 @@ const LayerUI = ({
              "layer-ui__wrapper__top-right zen-mode-transition",
              {
                "transition-right": appState.zenModeEnabled,
+                "layer-ui__wrapper__top-right--compact":
+                  appState.stylesPanelMode === "compact",
              },
            )}
          >
@ -418,7 +480,9 @@ const LayerUI = ({
        }}
        tab={DEFAULT_SIDEBAR.defaultTab}
      >
-        {t("toolBar.library")}
+        {appState.stylesPanelMode === "full" &&
+          appState.width >= MQ_MIN_WIDTH_DESKTOP &&
+          t("toolBar.library")}
      </DefaultSidebar.Trigger>
      <DefaultOverwriteConfirmDialog />
      {appState.openDialog?.name === "ttd" && <TTDDialog __fallback />}
--- a/packages/excalidraw/components/PropertiesPopover.tsx
+++ b/packages/excalidraw/components/PropertiesPopover.tsx
@ -17,6 +17,7 @@ interface PropertiesPopoverProps {
  onPointerLeave?: React.PointerEventHandler<HTMLDivElement>;
  onFocusOutside?: Popover.PopoverContentProps["onFocusOutside"];
  onPointerDownOutside?: Popover.PopoverContentProps["onPointerDownOutside"];
+  preventAutoFocusOnTouch?: boolean;
 }

 export const PropertiesPopover = React.forwardRef<
@ -34,6 +35,7 @@ export const PropertiesPopover = React.forwardRef<
      onFocusOutside,
      onPointerLeave,
      onPointerDownOutside,
+      preventAutoFocusOnTouch = false,
    },
    ref,
  ) => {
@ -64,6 +66,12 @@ export const PropertiesPopover = React.forwardRef<
          onKeyDown={onKeyDown}
          onFocusOutside={onFocusOutside}
          onPointerDownOutside={onPointerDownOutside}
+          onOpenAutoFocus={(e) => {
+            // prevent auto-focus on touch devices to avoid keyboard popup
+            if (preventAutoFocusOnTouch && device.isTouchScreen) {
+              e.preventDefault();
+            }
+          }}
          onCloseAutoFocus={(e) => {
            e.stopPropagation();
            // prevents focusing the trigger
--- a/packages/excalidraw/components/Toolbar.scss
+++ b/packages/excalidraw/components/Toolbar.scss
@ -10,6 +10,16 @@
      }
    }

+    &--compact {
+      .ToolIcon__keybinding {
+        display: none;
+      }
+
+      .App-toolbar__divider {
+        margin: 0;
+      }
+    }
+
    &__divider {
      width: 1px;
      height: 1.5rem;
--- a/packages/excalidraw/components/icons.tsx
+++ b/packages/excalidraw/components/icons.tsx
@ -118,6 +118,17 @@ export const DotsIcon = createIcon(
  tablerIconProps,
 );

+// tabler-icons: dots-horizontal (horizontal equivalent of dots-vertical)
+export const DotsHorizontalIcon = createIcon(
+  <g strokeWidth="1.5">
+    <path stroke="none" d="M0 0h24v24H0z" fill="none" />
+    <path d="M5 12m-1 0a1 1 0 1 0 2 0a1 1 0 1 0 -2 0" />
+    <path d="M12 12m-1 0a1 1 0 1 0 2 0a1 1 0 1 0 -2 0" />
+    <path d="M19 12m-1 0a1 1 0 1 0 2 0a1 1 0 1 0 -2 0" />
+  </g>,
+  tablerIconProps,
+);
+
 // tabler-icons: pinned
 export const PinIcon = createIcon(
  <svg strokeWidth="1.5">
@ -396,6 +407,19 @@ export const TextIcon = createIcon(
  tablerIconProps,
 );

+export const TextSizeIcon = createIcon(
+  <g stroke="currentColor" strokeWidth="1.5">
+    <path stroke="none" d="M0 0h24v24H0z" fill="none" />
+    <path d="M3 7v-2h13v2" />
+    <path d="M10 5v14" />
+    <path d="M12 19h-4" />
+    <path d="M15 13v-1h6v1" />
+    <path d="M18 12v7" />
+    <path d="M17 19h2" />
+  </g>,
+  tablerIconProps,
+);
+
 // modified tabler-icons: photo
 export const ImageIcon = createIcon(
  <g strokeWidth="1.25">
@ -2269,3 +2293,48 @@ export const elementLinkIcon = createIcon(
  </g>,
  tablerIconProps,
 );
+
+export const resizeIcon = createIcon(
+  <g strokeWidth={1.5}>
+    <path stroke="none" d="M0 0h24v24H0z" fill="none" />
+    <path d="M4 11v8a1 1 0 0 0 1 1h8m-9 -14v-1a1 1 0 0 1 1 -1h1m5 0h2m5 0h1a1 1 0 0 1 1 1v1m0 5v2m0 5v1a1 1 0 0 1 -1 1h-1" />
+    <path d="M4 12h7a1 1 0 0 1 1 1v7" />
+  </g>,
+  tablerIconProps,
+);
+
+export const adjustmentsIcon = createIcon(
+  <g strokeWidth={1.5}>
+    <path stroke="none" d="M0 0h24v24H0z" fill="none" />
+    <path d="M14 6m-2 0a2 2 0 1 0 4 0a2 2 0 1 0 -4 0" />
+    <path d="M4 6l8 0" />
+    <path d="M16 6l4 0" />
+    <path d="M8 12m-2 0a2 2 0 1 0 4 0a2 2 0 1 0 -4 0" />
+    <path d="M4 12l2 0" />
+    <path d="M10 12l10 0" />
+    <path d="M17 18m-2 0a2 2 0 1 0 4 0a2 2 0 1 0 -4 0" />
+    <path d="M4 18l11 0" />
+    <path d="M19 18l1 0" />
+  </g>,
+  tablerIconProps,
+);
+
+export const backgroundIcon = createIcon(
+  <g strokeWidth={1}>
+    <path stroke="none" d="M0 0h24v24H0z" fill="none" />
+    <path d="M6 10l4 -4" />
+    <path d="M6 14l8 -8" />
+    <path d="M6 18l12 -12" />
+    <path d="M10 18l8 -8" />
+    <path d="M14 18l4 -4" />
+  </g>,
+  tablerIconProps,
+);
+
+export const strokeIcon = createIcon(
+  <g strokeWidth={1}>
+    <path stroke="none" d="M0 0h24v24H0z" fill="none" />
+    <rect x="6" y="6" width="12" height="12" fill="none" />
+  </g>,
+  tablerIconProps,
+);
--- a/packages/excalidraw/components/live-collaboration/LiveCollaborationTrigger.tsx
+++ b/packages/excalidraw/components/live-collaboration/LiveCollaborationTrigger.tsx
@ -1,5 +1,7 @@
 import clsx from "clsx";

+import { isMobileOrTablet, MQ_MIN_WIDTH_DESKTOP } from "@excalidraw/common";
+
 import { t } from "../../i18n";
 import { Button } from "../Button";
 import { share } from "../icons";
@ -17,7 +19,8 @@ const LiveCollaborationTrigger = ({
 } & React.ButtonHTMLAttributes<HTMLButtonElement>) => {
  const appState = useUIAppState();

-  const showIconOnly = appState.width < 830;
+  const showIconOnly =
+    isMobileOrTablet() || appState.width < MQ_MIN_WIDTH_DESKTOP;

  return (
    <Button
--- a/packages/excalidraw/components/shapes.tsx
+++ b/packages/excalidraw/components/shapes.tsx
@ -13,6 +13,8 @@ import {
  EraserIcon,
 } from "./icons";

+import type { AppClassProperties } from "../types";
+
 export const SHAPES = [
  {
    icon: SelectionIcon,
@ -86,8 +88,23 @@ export const SHAPES = [
  },
 ] as const;

-export const findShapeByKey = (key: string) => {
-  const shape = SHAPES.find((shape, index) => {
+export const getToolbarTools = (app: AppClassProperties) => {
+  return app.defaultSelectionTool === "lasso"
+    ? ([
+        {
+          value: "lasso",
+          icon: SelectionIcon,
+          key: KEYS.V,
+          numericKey: KEYS["1"],
+          fillable: true,
+        },
+        ...SHAPES.slice(1),
+      ] as const)
+    : SHAPES;
+};
+
+export const findShapeByKey = (key: string, app: AppClassProperties) => {
+  const shape = getToolbarTools(app).find((shape, index) => {
    return (
      (shape.numericKey != null && key === shape.numericKey.toString()) ||
      (shape.key &&
--- a/packages/excalidraw/css/styles.scss
+++ b/packages/excalidraw/css/styles.scss
@ -317,7 +317,7 @@ body.excalidraw-cursor-resize * {

  .App-menu_top {
    grid-template-columns: 1fr 2fr 1fr;
-    grid-gap: 2rem;
+    grid-gap: 1rem;
    align-items: flex-start;
    cursor: default;
    pointer-events: none !important;
@ -336,6 +336,14 @@ body.excalidraw-cursor-resize * {
    justify-self: flex-start;
  }

+  .selected-shape-actions-container {
+    width: fit-content;
+
+    &--compact {
+      min-width: 48px;
+    }
+  }
+
  .App-menu_top > *:last-child {
    justify-self: flex-end;
  }
--- a/packages/excalidraw/data/blob.ts
+++ b/packages/excalidraw/data/blob.ts
@ -96,6 +96,8 @@ export const getMimeType = (blob: Blob | string): string => {
    return MIME_TYPES.jpg;
  } else if (/\.svg$/.test(name)) {
    return MIME_TYPES.svg;
+  } else if (/\.excalidrawlib$/.test(name)) {
+    return MIME_TYPES.excalidrawlib;
  }
  return "";
 };
@ -170,7 +172,11 @@ export const loadSceneOrLibraryFromBlob = async (
          },
          localAppState,
          localElements,
-          { repairBindings: true, refreshDimensions: false },
+          {
+            repairBindings: true,
+            refreshDimensions: false,
+            deleteInvisibleElements: true,
+          },
        ),
      };
    } else if (isValidLibrary(data)) {
@ -385,23 +391,18 @@ export const ImageURLToFile = async (
  throw new Error("Error: unsupported file type", { cause: "UNSUPPORTED" });
 };

-export const getFileFromEvent = async (
-  event: React.DragEvent<HTMLDivElement>,
-) => {
-  const file = event.dataTransfer.files.item(0);
-  const fileHandle = await getFileHandle(event);
-
-  return { file: file ? await normalizeFile(file) : null, fileHandle };
-};
-
 export const getFileHandle = async (
-  event: React.DragEvent<HTMLDivElement>,
+  event: DragEvent | React.DragEvent | DataTransferItem,
 ): Promise<FileSystemHandle | null> => {
  if (nativeFileSystemSupported) {
    try {
-      const item = event.dataTransfer.items[0];
+      const dataTransferItem =
+        event instanceof DataTransferItem
+          ? event
+          : (event as DragEvent).dataTransfer?.items?.[0];
+
      const handle: FileSystemHandle | null =
-        (await (item as any).getAsFileSystemHandle()) || null;
+        (await (dataTransferItem as any).getAsFileSystemHandle()) || null;

      return handle;
    } catch (error: any) {
--- a/packages/excalidraw/data/reconcile.ts
+++ b/packages/excalidraw/data/reconcile.ts
@ -20,7 +20,7 @@ export type ReconciledExcalidrawElement = OrderedExcalidrawElement &
 export type RemoteExcalidrawElement = OrderedExcalidrawElement &
  MakeBrand<"RemoteExcalidrawElement">;

-const shouldDiscardRemoteElement = (
+export const shouldDiscardRemoteElement = (
  localAppState: AppState,
  local: OrderedExcalidrawElement | undefined,
  remote: RemoteExcalidrawElement,
@ -30,7 +30,7 @@ const shouldDiscardRemoteElement = (
    // local element is being edited
    (local.id === localAppState.editingTextElement?.id ||
      local.id === localAppState.resizingElement?.id ||
-      local.id === localAppState.newElement?.id || // TODO: Is this still valid? As newElement is selection element, which is never part of the elements array
+      local.id === localAppState.newElement?.id ||
      // local element is newer
      local.version > remote.version ||
      // resolve conflicting edits deterministically by taking the one with
--- a/packages/excalidraw/data/restore.ts
+++ b/packages/excalidraw/data/restore.ts
@ -241,8 +241,9 @@ const restoreElementWithProperties = <
  return ret;
 };

-const restoreElement = (
+export const restoreElement = (
  element: Exclude<ExcalidrawElement, ExcalidrawSelectionElement>,
+  opts?: { deleteInvisibleElements?: boolean },
 ): typeof element | null => {
  element = { ...element };

@ -290,7 +291,8 @@ const restoreElement = (

      // if empty text, mark as deleted. We keep in array
      // for data integrity purposes (collab etc.)
-      if (!text && !element.isDeleted) {
+      if (opts?.deleteInvisibleElements && !text && !element.isDeleted) {
+        // TODO: we should not do this since it breaks sync / versioning when we exchange / apply just deltas and restore the elements (deletion isn't recorded)
        element = { ...element, originalText: text, isDeleted: true };
        element = bumpVersion(element);
      }
@ -385,7 +387,10 @@ const restoreElement = (
            elbowed: true,
            startBinding: repairBinding(element, element.startBinding),
            endBinding: repairBinding(element, element.endBinding),
-            fixedSegments: element.fixedSegments,
+            fixedSegments:
+              element.fixedSegments?.length && base.points.length >= 4
+                ? element.fixedSegments
+                : null,
            startIsSpecial: element.startIsSpecial,
            endIsSpecial: element.endIsSpecial,
          })
@ -523,7 +528,13 @@ export const restoreElements = (
  elements: ImportedDataState["elements"],
  /** NOTE doesn't serve for reconciliation */
  localElements: readonly ExcalidrawElement[] | null | undefined,
-  opts?: { refreshDimensions?: boolean; repairBindings?: boolean } | undefined,
+  opts?:
+    | {
+        refreshDimensions?: boolean;
+        repairBindings?: boolean;
+        deleteInvisibleElements?: boolean;
+      }
+    | undefined,
 ): OrderedExcalidrawElement[] => {
  // used to detect duplicate top-level element ids
  const existingIds = new Set<string>();
@ -532,24 +543,38 @@ export const restoreElements = (
    (elements || []).reduce((elements, element) => {
      // filtering out selection, which is legacy, no longer kept in elements,
      // and causing issues if retained
-      if (element.type !== "selection" && !isInvisiblySmallElement(element)) {
-        let migratedElement: ExcalidrawElement | null = restoreElement(element);
-        if (migratedElement) {
-          const localElement = localElementsMap?.get(element.id);
-          if (localElement && localElement.version > migratedElement.version) {
-            migratedElement = bumpVersion(
-              migratedElement,
-              localElement.version,
-            );
-          }
-          if (existingIds.has(migratedElement.id)) {
-            migratedElement = { ...migratedElement, id: randomId() };
-          }
-          existingIds.add(migratedElement.id);
-
-          elements.push(migratedElement);
-        }
+      if (element.type === "selection") {
+        return elements;
      }
+
+      let migratedElement: ExcalidrawElement | null = restoreElement(element, {
+        deleteInvisibleElements: opts?.deleteInvisibleElements,
+      });
+      if (migratedElement) {
+        const localElement = localElementsMap?.get(element.id);
+
+        const shouldMarkAsDeleted =
+          opts?.deleteInvisibleElements && isInvisiblySmallElement(element);
+
+        if (
+          shouldMarkAsDeleted ||
+          (localElement && localElement.version > migratedElement.version)
+        ) {
+          migratedElement = bumpVersion(migratedElement, localElement?.version);
+        }
+
+        if (shouldMarkAsDeleted) {
+          migratedElement = { ...migratedElement, isDeleted: true };
+        }
+
+        if (existingIds.has(migratedElement.id)) {
+          migratedElement = { ...migratedElement, id: randomId() };
+        }
+        existingIds.add(migratedElement.id);
+
+        elements.push(migratedElement);
+      }
+
      return elements;
    }, [] as ExcalidrawElement[]),
  );
@ -790,7 +815,11 @@ export const restore = (
   */
  localAppState: Partial<AppState> | null | undefined,
  localElements: readonly ExcalidrawElement[] | null | undefined,
-  elementsConfig?: { refreshDimensions?: boolean; repairBindings?: boolean },
+  elementsConfig?: {
+    refreshDimensions?: boolean;
+    repairBindings?: boolean;
+    deleteInvisibleElements?: boolean;
+  },
 ): RestoredDataState => {
  return {
    elements: restoreElements(data?.elements, localElements, elementsConfig),
--- a/packages/excalidraw/eraser/index.ts
+++ b/packages/excalidraw/eraser/index.ts
@ -1,11 +1,26 @@
 import { arrayToMap, easeOut, THEME } from "@excalidraw/common";
+
 import {
  computeBoundTextPosition,
+  distanceToElement,
+  doBoundsIntersect,
  getBoundTextElement,
+  getElementBounds,
+  getFreedrawOutlineAsSegments,
+  getFreedrawOutlinePoints,
  intersectElementWithLineSegment,
+  isArrowElement,
+  isFreeDrawElement,
+  isLineElement,
  isPointInElement,
 } from "@excalidraw/element";
-import { lineSegment, pointFrom } from "@excalidraw/math";
+import {
+  lineSegment,
+  lineSegmentsDistance,
+  pointFrom,
+  polygon,
+  polygonIncludesPointNonZero,
+} from "@excalidraw/math";

 import { getElementsInGroup } from "@excalidraw/element";

@ -13,6 +28,8 @@ import { shouldTestInside } from "@excalidraw/element";
 import { hasBoundTextElement, isBoundToContainer } from "@excalidraw/element";
 import { getBoundTextElementId } from "@excalidraw/element";

+import type { Bounds } from "@excalidraw/element";
+
 import type { GlobalPoint, LineSegment } from "@excalidraw/math/types";
 import type { ElementsMap, ExcalidrawElement } from "@excalidraw/element/types";

@ -96,6 +113,7 @@ export class EraserTrail extends AnimatedTrail {
          pathSegment,
          element,
          candidateElementsMap,
+          this.app.state.zoom.value,
        );

        if (intersects) {
@ -131,6 +149,7 @@ export class EraserTrail extends AnimatedTrail {
          pathSegment,
          element,
          candidateElementsMap,
+          this.app.state.zoom.value,
        );

        if (intersects) {
@ -180,8 +199,33 @@ const eraserTest = (
  pathSegment: LineSegment<GlobalPoint>,
  element: ExcalidrawElement,
  elementsMap: ElementsMap,
+  zoom: number,
 ): boolean => {
  const lastPoint = pathSegment[1];
+
+  // PERF: Do a quick bounds intersection test first because it's cheap
+  const threshold = isFreeDrawElement(element) ? 15 : element.strokeWidth / 2;
+  const segmentBounds = [
+    Math.min(pathSegment[0][0], pathSegment[1][0]) - threshold,
+    Math.min(pathSegment[0][1], pathSegment[1][1]) - threshold,
+    Math.max(pathSegment[0][0], pathSegment[1][0]) + threshold,
+    Math.max(pathSegment[0][1], pathSegment[1][1]) + threshold,
+  ] as Bounds;
+  const origElementBounds = getElementBounds(element, elementsMap);
+  const elementBounds: Bounds = [
+    origElementBounds[0] - threshold,
+    origElementBounds[1] - threshold,
+    origElementBounds[2] + threshold,
+    origElementBounds[3] + threshold,
+  ];
+
+  if (!doBoundsIntersect(segmentBounds, elementBounds)) {
+    return false;
+  }
+
+  // There are shapes where the inner area should trigger erasing
+  // even though the eraser path segment doesn't intersect with or
+  // get close to the shape's stroke
  if (
    shouldTestInside(element) &&
    isPointInElement(lastPoint, element, elementsMap)
@ -189,6 +233,50 @@ const eraserTest = (
    return true;
  }

+  // Freedraw elements are tested for erasure by measuring the distance
+  // of the eraser path and the freedraw shape outline lines to a tolerance
+  // which offers a good visual precision at various zoom levels
+  if (isFreeDrawElement(element)) {
+    const outlinePoints = getFreedrawOutlinePoints(element);
+    const strokeSegments = getFreedrawOutlineAsSegments(
+      element,
+      outlinePoints,
+      elementsMap,
+    );
+    const tolerance = Math.max(2.25, 5 / zoom); // NOTE: Visually fine-tuned approximation
+
+    for (const seg of strokeSegments) {
+      if (lineSegmentsDistance(seg, pathSegment) <= tolerance) {
+        return true;
+      }
+    }
+
+    const poly = polygon(
+      ...(outlinePoints.map(([x, y]) =>
+        pointFrom<GlobalPoint>(element.x + x, element.y + y),
+      ) as GlobalPoint[]),
+    );
+
+    // PERF: Check only one point of the eraser segment. If the eraser segment
+    // start is inside the closed freedraw shape, the other point is either also
+    // inside or the eraser segment will intersect the shape outline anyway
+    if (polygonIncludesPointNonZero(pathSegment[0], poly)) {
+      return true;
+    }
+
+    return false;
+  } else if (
+    isArrowElement(element) ||
+    (isLineElement(element) && !element.polygon)
+  ) {
+    const tolerance = Math.max(
+      element.strokeWidth,
+      (element.strokeWidth * 2) / zoom,
+    );
+
+    return distanceToElement(element, elementsMap, lastPoint) <= tolerance;
+  }
+
  const boundTextElement = getBoundTextElement(element, elementsMap);

  return (
--- a/packages/excalidraw/history.ts
+++ b/packages/excalidraw/history.ts
@ -175,7 +175,7 @@ export class History {
      let nextAppState = appState;
      let containsVisibleChange = false;

-      // iterate through the history entries in case ;they result in no visible changes
+      // iterate through the history entries in case they result in no visible changes
      while (historyDelta) {
        try {
          [nextElements, nextAppState, containsVisibleChange] =
--- a/packages/excalidraw/hooks/useTextEditorFocus.ts
+++ b/packages/excalidraw/hooks/useTextEditorFocus.ts
@ -0,0 +1,112 @@
+import { useState, useCallback } from "react";
+
+// Utility type for caret position
+export type CaretPosition = {
+  start: number;
+  end: number;
+};
+
+// Utility function to get text editor element
+const getTextEditor = (): HTMLTextAreaElement | null => {
+  return document.querySelector(".excalidraw-wysiwyg") as HTMLTextAreaElement;
+};
+
+// Utility functions for caret position management
+export const saveCaretPosition = (): CaretPosition | null => {
+  const textEditor = getTextEditor();
+  if (textEditor) {
+    return {
+      start: textEditor.selectionStart,
+      end: textEditor.selectionEnd,
+    };
+  }
+  return null;
+};
+
+export const restoreCaretPosition = (position: CaretPosition | null): void => {
+  setTimeout(() => {
+    const textEditor = getTextEditor();
+    if (textEditor) {
+      textEditor.focus();
+      if (position) {
+        textEditor.selectionStart = position.start;
+        textEditor.selectionEnd = position.end;
+      }
+    }
+  }, 0);
+};
+
+export const withCaretPositionPreservation = (
+  callback: () => void,
+  isCompactMode: boolean,
+  isEditingText: boolean,
+  onPreventClose?: () => void,
+): void => {
+  // Prevent popover from closing in compact mode
+  if (isCompactMode && onPreventClose) {
+    onPreventClose();
+  }
+
+  // Save caret position if editing text
+  const savedPosition =
+    isCompactMode && isEditingText ? saveCaretPosition() : null;
+
+  // Execute the callback
+  callback();
+
+  // Restore caret position if needed
+  if (isCompactMode && isEditingText) {
+    restoreCaretPosition(savedPosition);
+  }
+};
+
+// Hook for managing text editor caret position with state
+export const useTextEditorFocus = () => {
+  const [savedCaretPosition, setSavedCaretPosition] =
+    useState<CaretPosition | null>(null);
+
+  const saveCaretPositionToState = useCallback(() => {
+    const position = saveCaretPosition();
+    setSavedCaretPosition(position);
+  }, []);
+
+  const restoreCaretPositionFromState = useCallback(() => {
+    setTimeout(() => {
+      const textEditor = getTextEditor();
+      if (textEditor) {
+        textEditor.focus();
+        if (savedCaretPosition) {
+          textEditor.selectionStart = savedCaretPosition.start;
+          textEditor.selectionEnd = savedCaretPosition.end;
+          setSavedCaretPosition(null);
+        }
+      }
+    }, 0);
+  }, [savedCaretPosition]);
+
+  const clearSavedPosition = useCallback(() => {
+    setSavedCaretPosition(null);
+  }, []);
+
+  return {
+    saveCaretPosition: saveCaretPositionToState,
+    restoreCaretPosition: restoreCaretPositionFromState,
+    clearSavedPosition,
+    hasSavedPosition: !!savedCaretPosition,
+  };
+};
+
+// Utility function to temporarily disable text editor blur
+export const temporarilyDisableTextEditorBlur = (
+  duration: number = 100,
+): void => {
+  const textEditor = getTextEditor();
+  if (textEditor) {
+    const originalOnBlur = textEditor.onblur;
+    textEditor.onblur = null;
+
+    setTimeout(() => {
+      textEditor.onblur = originalOnBlur;
+    }, duration);
+  }
+};
--- a/packages/excalidraw/index.tsx
+++ b/packages/excalidraw/index.tsx
@ -229,6 +229,7 @@ export { defaultLang, useI18n, languages } from "./i18n";
 export {
  restore,
  restoreAppState,
+  restoreElement,
  restoreElements,
  restoreLibraryItems,
 } from "./data/restore";
--- a/packages/excalidraw/package.json
+++ b/packages/excalidraw/package.json
@ -83,7 +83,7 @@
    "@excalidraw/element": "0.18.0",
    "@excalidraw/math": "0.18.0",
    "@excalidraw/laser-pointer": "1.3.1",
-    "@excalidraw/mermaid-to-excalidraw": "1.1.2",
+    "@excalidraw/mermaid-to-excalidraw": "1.1.3",
    "@excalidraw/random-username": "1.1.0",
    "@radix-ui/react-popover": "1.1.6",
    "@radix-ui/react-tabs": "1.1.3",
--- a/packages/excalidraw/snapping.ts
+++ b/packages/excalidraw/snapping.ts
@ -169,8 +169,14 @@ export const isSnappingEnabled = ({
  selectedElements: NonDeletedExcalidrawElement[];
 }) => {
  if (event) {
+    // Allow snapping for lasso tool when dragging selected elements
+    // but not during lasso selection phase
+    const isLassoDragging =
+      app.state.activeTool.type === "lasso" &&
+      app.state.selectedElementsAreBeingDragged;
+
    return (
-      app.state.activeTool.type !== "lasso" &&
+      (app.state.activeTool.type !== "lasso" || isLassoDragging) &&
      ((app.state.objectsSnapModeEnabled && !event[KEYS.CTRL_OR_CMD]) ||
        (!app.state.objectsSnapModeEnabled &&
          event[KEYS.CTRL_OR_CMD] &&
--- a/packages/excalidraw/tests/snapshots/contextmenu.test.tsx.snap
+++ b/packages/excalidraw/tests/snapshots/contextmenu.test.tsx.snap
@ -981,6 +981,7 @@ exports[`contextMenu element > right-clicking on a group should select whole gro
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -1172,6 +1173,7 @@ exports[`contextMenu element > selecting 'Add to library' in context menu adds e
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": {
@ -1384,6 +1386,7 @@ exports[`contextMenu element > selecting 'Bring forward' in context menu brings
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -1713,6 +1716,7 @@ exports[`contextMenu element > selecting 'Bring to front' in context menu brings
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -2042,6 +2046,7 @@ exports[`contextMenu element > selecting 'Copy styles' in context menu copies st
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": {
@ -2252,6 +2257,7 @@ exports[`contextMenu element > selecting 'Delete' in context menu deletes elemen
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -2493,6 +2499,7 @@ exports[`contextMenu element > selecting 'Duplicate' in context menu duplicates
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -2794,6 +2801,7 @@ exports[`contextMenu element > selecting 'Group selection' in context menu group
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -3159,6 +3167,7 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": {
@ -3650,6 +3659,7 @@ exports[`contextMenu element > selecting 'Send backward' in context menu sends e
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -3682,14 +3692,14 @@ exports[`contextMenu element > selecting 'Send backward' in context menu sends e
  "opacity": 100,
  "roughness": 1,
  "roundness": null,
-  "seed": 1116226695,
+  "seed": 400692809,
  "strokeColor": "#1e1e1e",
  "strokeStyle": "solid",
  "strokeWidth": 2,
  "type": "rectangle",
  "updated": 1,
  "version": 4,
-  "versionNonce": 23633383,
+  "versionNonce": 81784553,
  "width": 20,
  "x": 20,
  "y": 30,
@ -3714,14 +3724,14 @@ exports[`contextMenu element > selecting 'Send backward' in context menu sends e
  "opacity": 100,
  "roughness": 1,
  "roundness": null,
-  "seed": 1278240551,
+  "seed": 449462985,
  "strokeColor": "#1e1e1e",
  "strokeStyle": "solid",
  "strokeWidth": 2,
  "type": "rectangle",
  "updated": 1,
  "version": 3,
-  "versionNonce": 401146281,
+  "versionNonce": 1150084233,
  "width": 20,
  "x": -10,
  "y": 0,
@ -3971,6 +3981,7 @@ exports[`contextMenu element > selecting 'Send to back' in context menu sends el
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -4295,6 +4306,7 @@ exports[`contextMenu element > selecting 'Ungroup selection' in context menu ung
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -5578,6 +5590,7 @@ exports[`contextMenu element > shows 'Group selection' in context menu for multi
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -6795,6 +6808,7 @@ exports[`contextMenu element > shows 'Ungroup selection' in context menu for gro
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -7724,6 +7738,7 @@ exports[`contextMenu element > shows context menu for canvas > [end of test] app
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -8721,6 +8736,7 @@ exports[`contextMenu element > shows context menu for element > [end of test] ap
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -9713,6 +9729,7 @@ exports[`contextMenu element > shows context menu for element > [end of test] ap
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
--- a/packages/excalidraw/tests/snapshots/excalidraw.test.tsx.snap
+++ b/packages/excalidraw/tests/snapshots/excalidraw.test.tsx.snap
@ -688,6 +688,7 @@ exports[`<Excalidraw/> > Test UIOptions prop > Test canvasActions > should rende
              aria-haspopup="dialog"
              aria-label="Canvas background"
              class="color-picker__button active-color properties-trigger has-outline"
+              data-openpopup="canvasBackground"
              data-state="closed"
              style="--swatch-color: #ffffff;"
              title="Show background color picker"
--- a/packages/excalidraw/tests/snapshots/history.test.tsx.snap
+++ b/packages/excalidraw/tests/snapshots/history.test.tsx.snap
--- a/packages/excalidraw/tests/snapshots/regressionTests.test.tsx.snap
+++ b/packages/excalidraw/tests/snapshots/regressionTests.test.tsx.snap
@ -108,6 +108,7 @@ exports[`given element A and group of elements B and given both are selected whe
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -534,6 +535,7 @@ exports[`given element A and group of elements B and given both are selected whe
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -939,6 +941,7 @@ exports[`regression tests > Cmd/Ctrl-click exclusively select element under poin
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -1503,6 +1506,7 @@ exports[`regression tests > Drags selected element when hitting only bounding bo
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -1713,6 +1717,7 @@ exports[`regression tests > adjusts z order when grouping > [end of test] appSta
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -2092,6 +2097,7 @@ exports[`regression tests > alt-drag duplicates an element > [end of test] appSt
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -2333,6 +2339,7 @@ exports[`regression tests > arrow keys > [end of test] appState 1`] = `
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -2513,6 +2520,7 @@ exports[`regression tests > can drag element that covers another element, while
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -2834,6 +2842,7 @@ exports[`regression tests > change the properties of a shape > [end of test] app
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -3089,6 +3098,7 @@ exports[`regression tests > click on an element and drag it > [dragged] appState
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -3328,6 +3338,7 @@ exports[`regression tests > click on an element and drag it > [end of test] appS
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -3562,6 +3573,7 @@ exports[`regression tests > click to select a shape > [end of test] appState 1`]
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -3819,6 +3831,7 @@ exports[`regression tests > click-drag to select a group > [end of test] appStat
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -4130,6 +4143,7 @@ exports[`regression tests > deleting last but one element in editing group shoul
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -4591,6 +4605,7 @@ exports[`regression tests > deselects group of selected elements on pointer down
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -4844,6 +4859,7 @@ exports[`regression tests > deselects group of selected elements on pointer up w
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -5145,6 +5161,7 @@ exports[`regression tests > deselects selected element on pointer down when poin
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -5323,6 +5340,7 @@ exports[`regression tests > deselects selected element, on pointer up, when clic
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -5521,6 +5539,7 @@ exports[`regression tests > double click to edit a group > [end of test] appStat
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -5916,6 +5935,7 @@ exports[`regression tests > drags selected elements from point inside common bou
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -6205,6 +6225,7 @@ exports[`regression tests > draw every type of shape > [end of test] appState 1`
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -6394,15 +6415,16 @@ exports[`regression tests > draw every type of shape > [end of test] undo stack
          "selectedElementIds": {
            "id9": true,
          },
-          "selectedLinearElementId": "id9",
-          "selectedLinearElementIsEditing": false,
+          "selectedLinearElement": {
+            "elementId": "id9",
+            "isEditing": false,
+          },
        },
        "inserted": {
          "selectedElementIds": {
            "id6": true,
          },
-          "selectedLinearElementId": null,
-          "selectedLinearElementIsEditing": null,
+          "selectedLinearElement": null,
        },
      },
    },
@ -6470,13 +6492,19 @@ exports[`regression tests > draw every type of shape > [end of test] undo stack
          "selectedElementIds": {
            "id12": true,
          },
-          "selectedLinearElementId": "id12",
+          "selectedLinearElement": {
+            "elementId": "id12",
+            "isEditing": false,
+          },
        },
        "inserted": {
          "selectedElementIds": {
            "id9": true,
          },
-          "selectedLinearElementId": "id9",
+          "selectedLinearElement": {
+            "elementId": "id9",
+            "isEditing": false,
+          },
        },
      },
    },
@ -6542,15 +6570,16 @@ exports[`regression tests > draw every type of shape > [end of test] undo stack
          "selectedElementIds": {
            "id15": true,
          },
-          "selectedLinearElementId": null,
-          "selectedLinearElementIsEditing": null,
+          "selectedLinearElement": null,
        },
        "inserted": {
          "selectedElementIds": {
            "id12": true,
          },
-          "selectedLinearElementId": "id12",
-          "selectedLinearElementIsEditing": false,
+          "selectedLinearElement": {
+            "elementId": "id12",
+            "isEditing": false,
+          },
        },
      },
    },
@ -6677,12 +6706,13 @@ exports[`regression tests > draw every type of shape > [end of test] undo stack
    "appState": AppStateDelta {
      "delta": Delta {
        "deleted": {
-          "selectedLinearElementId": "id15",
-          "selectedLinearElementIsEditing": false,
+          "selectedLinearElement": {
+            "elementId": "id15",
+            "isEditing": false,
+          },
        },
        "inserted": {
-          "selectedLinearElementId": null,
-          "selectedLinearElementIsEditing": null,
+          "selectedLinearElement": null,
        },
      },
    },
@ -6700,15 +6730,16 @@ exports[`regression tests > draw every type of shape > [end of test] undo stack
          "selectedElementIds": {
            "id22": true,
          },
-          "selectedLinearElementId": null,
-          "selectedLinearElementIsEditing": null,
+          "selectedLinearElement": null,
        },
        "inserted": {
          "selectedElementIds": {
            "id15": true,
          },
-          "selectedLinearElementId": "id15",
-          "selectedLinearElementIsEditing": false,
+          "selectedLinearElement": {
+            "elementId": "id15",
+            "isEditing": false,
+          },
        },
      },
    },
@ -6833,12 +6864,13 @@ exports[`regression tests > draw every type of shape > [end of test] undo stack
    "appState": AppStateDelta {
      "delta": Delta {
        "deleted": {
-          "selectedLinearElementId": "id22",
-          "selectedLinearElementIsEditing": false,
+          "selectedLinearElement": {
+            "elementId": "id22",
+            "isEditing": false,
+          },
        },
        "inserted": {
-          "selectedLinearElementId": null,
-          "selectedLinearElementIsEditing": null,
+          "selectedLinearElement": null,
        },
      },
    },
@ -6873,12 +6905,13 @@ exports[`regression tests > draw every type of shape > [end of test] undo stack
    "appState": AppStateDelta {
      "delta": Delta {
        "deleted": {
-          "selectedLinearElementId": null,
-          "selectedLinearElementIsEditing": null,
+          "selectedLinearElement": null,
        },
        "inserted": {
-          "selectedLinearElementId": "id22",
-          "selectedLinearElementIsEditing": false,
+          "selectedLinearElement": {
+            "elementId": "id22",
+            "isEditing": false,
+          },
        },
      },
    },
@ -7052,6 +7085,7 @@ exports[`regression tests > given a group of selected elements with an element t
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -7384,6 +7418,7 @@ exports[`regression tests > given a selected element A and a not selected elemen
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -7660,6 +7695,7 @@ exports[`regression tests > given selected element A with lower z-index than uns
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -7893,6 +7929,7 @@ exports[`regression tests > given selected element A with lower z-index than uns
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -8129,6 +8166,7 @@ exports[`regression tests > key 2 selects rectangle tool > [end of test] appStat
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -8307,6 +8345,7 @@ exports[`regression tests > key 3 selects diamond tool > [end of test] appState
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -8485,6 +8524,7 @@ exports[`regression tests > key 4 selects ellipse tool > [end of test] appState
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -8690,6 +8730,7 @@ exports[`regression tests > key 5 selects arrow tool > [end of test] appState 1`
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -8719,13 +8760,14 @@ exports[`regression tests > key 5 selects arrow tool > [end of test] undo stack
          "selectedElementIds": {
            "id0": true,
          },
-          "selectedLinearElementId": "id0",
-          "selectedLinearElementIsEditing": false,
+          "selectedLinearElement": {
+            "elementId": "id0",
+            "isEditing": false,
+          },
        },
        "inserted": {
          "selectedElementIds": {},
-          "selectedLinearElementId": null,
-          "selectedLinearElementIsEditing": null,
+          "selectedLinearElement": null,
        },
      },
    },
@ -8917,6 +8959,7 @@ exports[`regression tests > key 6 selects line tool > [end of test] appState 1`]
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -8946,13 +8989,14 @@ exports[`regression tests > key 6 selects line tool > [end of test] undo stack 1
          "selectedElementIds": {
            "id0": true,
          },
-          "selectedLinearElementId": "id0",
-          "selectedLinearElementIsEditing": false,
+          "selectedLinearElement": {
+            "elementId": "id0",
+            "isEditing": false,
+          },
        },
        "inserted": {
          "selectedElementIds": {},
-          "selectedLinearElementId": null,
-          "selectedLinearElementIsEditing": null,
+          "selectedLinearElement": null,
        },
      },
    },
@ -9113,6 +9157,7 @@ exports[`regression tests > key 7 selects freedraw tool > [end of test] appState
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -9336,6 +9381,7 @@ exports[`regression tests > key a selects arrow tool > [end of test] appState 1`
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -9365,13 +9411,14 @@ exports[`regression tests > key a selects arrow tool > [end of test] undo stack
          "selectedElementIds": {
            "id0": true,
          },
-          "selectedLinearElementId": "id0",
-          "selectedLinearElementIsEditing": false,
+          "selectedLinearElement": {
+            "elementId": "id0",
+            "isEditing": false,
+          },
        },
        "inserted": {
          "selectedElementIds": {},
-          "selectedLinearElementId": null,
-          "selectedLinearElementIsEditing": null,
+          "selectedLinearElement": null,
        },
      },
    },
@ -9536,6 +9583,7 @@ exports[`regression tests > key d selects diamond tool > [end of test] appState
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -9741,6 +9789,7 @@ exports[`regression tests > key l selects line tool > [end of test] appState 1`]
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -9770,13 +9819,14 @@ exports[`regression tests > key l selects line tool > [end of test] undo stack 1
          "selectedElementIds": {
            "id0": true,
          },
-          "selectedLinearElementId": "id0",
-          "selectedLinearElementIsEditing": false,
+          "selectedLinearElement": {
+            "elementId": "id0",
+            "isEditing": false,
+          },
        },
        "inserted": {
          "selectedElementIds": {},
-          "selectedLinearElementId": null,
-          "selectedLinearElementIsEditing": null,
+          "selectedLinearElement": null,
        },
      },
    },
@ -9939,6 +9989,7 @@ exports[`regression tests > key o selects ellipse tool > [end of test] appState
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -10115,6 +10166,7 @@ exports[`regression tests > key p selects freedraw tool > [end of test] appState
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -10311,6 +10363,7 @@ exports[`regression tests > key r selects rectangle tool > [end of test] appStat
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -10497,6 +10550,7 @@ exports[`regression tests > make a group and duplicate it > [end of test] appSta
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -11020,6 +11074,7 @@ exports[`regression tests > noop interaction after undo shouldn't create history
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -11294,6 +11349,7 @@ exports[`regression tests > pinch-to-zoom works > [end of test] appState 1`] = `
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -11417,6 +11473,7 @@ exports[`regression tests > shift click on selected element should deselect it o
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -11619,6 +11676,7 @@ exports[`regression tests > shift-click to multiselect, then drag > [end of test
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -11938,6 +11996,7 @@ exports[`regression tests > should group elements and ungroup them > [end of tes
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -12369,6 +12428,7 @@ exports[`regression tests > single-clicking on a subgroup of a selected group sh
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -12998,6 +13058,7 @@ exports[`regression tests > spacebar + drag scrolls the canvas > [end of test] a
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -13123,6 +13184,7 @@ exports[`regression tests > supports nested groups > [end of test] appState 1`]
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -13781,6 +13843,7 @@ exports[`regression tests > switches from group of selected elements to another
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -14117,6 +14180,7 @@ exports[`regression tests > switches selected element on pointer down > [end of
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -14347,6 +14411,7 @@ exports[`regression tests > two-finger scroll works > [end of test] appState 1`]
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -14470,6 +14535,7 @@ exports[`regression tests > undo/redo drawing an element > [end of test] appStat
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -14494,12 +14560,13 @@ exports[`regression tests > undo/redo drawing an element > [end of test] redo st
    "appState": AppStateDelta {
      "delta": Delta {
        "deleted": {
-          "selectedLinearElementId": null,
-          "selectedLinearElementIsEditing": null,
+          "selectedLinearElement": null,
        },
        "inserted": {
-          "selectedLinearElementId": "id6",
-          "selectedLinearElementIsEditing": false,
+          "selectedLinearElement": {
+            "elementId": "id6",
+            "isEditing": false,
+          },
        },
      },
    },
@ -14857,6 +14924,7 @@ exports[`regression tests > updates fontSize & fontFamily appState > [end of tes
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
@ -14981,6 +15049,7 @@ exports[`regression tests > zoom hotkeys > [end of test] appState 1`] = `
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
--- a/packages/excalidraw/tests/appState.test.tsx
+++ b/packages/excalidraw/tests/appState.test.tsx
@ -35,20 +35,23 @@ describe("appState", () => {
      expect(h.state.viewBackgroundColor).toBe("#F00");
    });

-    await API.drop(
-      new Blob(
-        [
-          JSON.stringify({
-            type: EXPORT_DATA_TYPES.excalidraw,
-            appState: {
-              viewBackgroundColor: "#000",
-            },
-            elements: [API.createElement({ type: "rectangle", id: "A" })],
-          }),
-        ],
-        { type: MIME_TYPES.json },
-      ),
-    );
+    await API.drop([
+      {
+        kind: "file",
+        file: new Blob(
+          [
+            JSON.stringify({
+              type: EXPORT_DATA_TYPES.excalidraw,
+              appState: {
+                viewBackgroundColor: "#000",
+              },
+              elements: [API.createElement({ type: "rectangle", id: "A" })],
+            }),
+          ],
+          { type: MIME_TYPES.json },
+        ),
+      },
+    ]);

    await waitFor(() => {
      expect(h.elements).toEqual([expect.objectContaining({ id: "A" })]);
--- a/packages/excalidraw/tests/data/restore.test.ts
+++ b/packages/excalidraw/tests/data/restore.test.ts
@ -60,7 +60,11 @@ describe("restoreElements", () => {
    const rectElement = API.createElement({ type: "rectangle" });
    mockSizeHelper.mockImplementation(() => true);

-    expect(restore.restoreElements([rectElement], null).length).toBe(0);
+    expect(
+      restore.restoreElements([rectElement], null, {
+        deleteInvisibleElements: true,
+      }),
+    ).toEqual([expect.objectContaining({ isDeleted: true })]);
  });

  it("should restore text element correctly passing value for each attribute", () => {
@ -85,6 +89,23 @@ describe("restoreElements", () => {
    });
  });

+  it("should not delete empty text element when opts.deleteInvisibleElements is not defined", () => {
+    const textElement = API.createElement({
+      type: "text",
+      text: "",
+      isDeleted: false,
+    });
+
+    const restoredElements = restore.restoreElements([textElement], null);
+
+    expect(restoredElements).toEqual([
+      expect.objectContaining({
+        id: textElement.id,
+        isDeleted: false,
+      }),
+    ]);
+  });
+
  it("should restore text element correctly with unknown font family, null text and undefined alignment", () => {
    const textElement: any = API.createElement({
      type: "text",
@ -97,10 +118,9 @@ describe("restoreElements", () => {
    textElement.font = "10 unknown";

    expect(textElement.isDeleted).toBe(false);
-    const restoredText = restore.restoreElements(
-      [textElement],
-      null,
-    )[0] as ExcalidrawTextElement;
+    const restoredText = restore.restoreElements([textElement], null, {
+      deleteInvisibleElements: true,
+    })[0] as ExcalidrawTextElement;
    expect(restoredText.isDeleted).toBe(true);
    expect(restoredText).toMatchSnapshot({
      seed: expect.any(Number),
@ -177,13 +197,16 @@ describe("restoreElements", () => {
      y: 0,
    });

-    const restoredElements = restore.restoreElements([arrowElement], null);
+    const restoredElements = restore.restoreElements([arrowElement], null, {
+      deleteInvisibleElements: true,
+    });

    const restoredArrow = restoredElements[0] as
      | ExcalidrawArrowElement
      | undefined;

-    expect(restoredArrow).toBeUndefined();
+    expect(restoredArrow).not.toBeUndefined();
+    expect(restoredArrow?.isDeleted).toBe(true);
  });

  it("should keep 'imperceptibly' small freedraw/line elements", () => {
@ -848,6 +871,7 @@ describe("repairing bindings", () => {
    let restoredElements = restore.restoreElements(
      [container, invisibleBoundElement, boundElement],
      null,
+      { deleteInvisibleElements: true },
    );

    expect(restoredElements).toEqual([
@ -855,6 +879,11 @@ describe("repairing bindings", () => {
        id: container.id,
        boundElements: [obsoleteBinding, invisibleBinding, nonExistentBinding],
      }),
+      expect.objectContaining({
+        id: invisibleBoundElement.id,
+        containerId: container.id,
+        isDeleted: true,
+      }),
      expect.objectContaining({
        id: boundElement.id,
        containerId: container.id,
@ -864,7 +893,7 @@ describe("repairing bindings", () => {
    restoredElements = restore.restoreElements(
      [container, invisibleBoundElement, boundElement],
      null,
-      { repairBindings: true },
+      { repairBindings: true, deleteInvisibleElements: true },
    );

    expect(restoredElements).toEqual([
@ -872,6 +901,11 @@ describe("repairing bindings", () => {
        id: container.id,
        boundElements: [],
      }),
+      expect.objectContaining({
+        id: invisibleBoundElement.id,
+        containerId: container.id,
+        isDeleted: true,
+      }),
      expect.objectContaining({
        id: boundElement.id,
        containerId: container.id,
--- a/packages/excalidraw/tests/dragCreate.test.tsx
+++ b/packages/excalidraw/tests/dragCreate.test.tsx
@ -315,7 +315,12 @@ describe("Test dragCreate", () => {
      );
      expect(renderStaticScene.mock.calls.length).toMatchInlineSnapshot(`5`);
      expect(h.state.selectionElement).toBeNull();
-      expect(h.elements.length).toEqual(0);
+      expect(h.elements).toEqual([
+        expect.objectContaining({
+          type: "arrow",
+          isDeleted: true,
+        }),
+      ]);
    });

    it("line", async () => {
@ -344,7 +349,12 @@ describe("Test dragCreate", () => {
      );
      expect(renderStaticScene.mock.calls.length).toMatchInlineSnapshot(`5`);
      expect(h.state.selectionElement).toBeNull();
-      expect(h.elements.length).toEqual(0);
+      expect(h.elements).toEqual([
+        expect.objectContaining({
+          type: "line",
+          isDeleted: true,
+        }),
+      ]);
    });
  });
 });
--- a/packages/excalidraw/tests/export.test.tsx
+++ b/packages/excalidraw/tests/export.test.tsx
@ -57,7 +57,7 @@ describe("export", () => {
      blob: pngBlob,
      metadata: serializeAsJSON(testElements, h.state, {}, "local"),
    });
-    await API.drop(pngBlobEmbedded);
+    await API.drop([{ kind: "file", file: pngBlobEmbedded }]);

    await waitFor(() => {
      expect(h.elements).toEqual([
@ -94,7 +94,12 @@ describe("export", () => {
  });

  it("import embedded png (legacy v1)", async () => {
-    await API.drop(await API.loadFile("./fixtures/test_embedded_v1.png"));
+    await API.drop([
+      {
+        kind: "file",
+        file: await API.loadFile("./fixtures/test_embedded_v1.png"),
+      },
+    ]);
    await waitFor(() => {
      expect(h.elements).toEqual([
        expect.objectContaining({ type: "text", text: "test" }),
@ -103,7 +108,12 @@ describe("export", () => {
  });

  it("import embedded png (v2)", async () => {
-    await API.drop(await API.loadFile("./fixtures/smiley_embedded_v2.png"));
+    await API.drop([
+      {
+        kind: "file",
+        file: await API.loadFile("./fixtures/smiley_embedded_v2.png"),
+      },
+    ]);
    await waitFor(() => {
      expect(h.elements).toEqual([
        expect.objectContaining({ type: "text", text: "😀" }),
@ -112,7 +122,12 @@ describe("export", () => {
  });

  it("import embedded svg (legacy v1)", async () => {
-    await API.drop(await API.loadFile("./fixtures/test_embedded_v1.svg"));
+    await API.drop([
+      {
+        kind: "file",
+        file: await API.loadFile("./fixtures/test_embedded_v1.svg"),
+      },
+    ]);
    await waitFor(() => {
      expect(h.elements).toEqual([
        expect.objectContaining({ type: "text", text: "test" }),
@ -121,7 +136,12 @@ describe("export", () => {
  });

  it("import embedded svg (v2)", async () => {
-    await API.drop(await API.loadFile("./fixtures/smiley_embedded_v2.svg"));
+    await API.drop([
+      {
+        kind: "file",
+        file: await API.loadFile("./fixtures/smiley_embedded_v2.svg"),
+      },
+    ]);
    await waitFor(() => {
      expect(h.elements).toEqual([
        expect.objectContaining({ type: "text", text: "😀" }),
--- a/packages/excalidraw/tests/fixtures/constants.ts
+++ b/packages/excalidraw/tests/fixtures/constants.ts
@ -0,0 +1,9 @@
+export const DEER_IMAGE_DIMENSIONS = {
+  width: 318,
+  height: 335,
+};
+
+export const SMILEY_IMAGE_DIMENSIONS = {
+  width: 56,
+  height: 77,
+};
--- a/packages/excalidraw/tests/flip.test.tsx
+++ b/packages/excalidraw/tests/flip.test.tsx
@ -25,6 +25,7 @@ import { Excalidraw } from "../index";
 // Importing to spy on it and mock the implementation (mocking does not work with simple vi.mock for some reason)
 import * as blobModule from "../data/blob";

+import { SMILEY_IMAGE_DIMENSIONS } from "./fixtures/constants";
 import { API } from "./helpers/api";
 import { UI, Pointer, Keyboard } from "./helpers/ui";
 import {
@ -744,11 +745,6 @@ describe("freedraw", () => {
 //image
 //TODO: currently there is no test for pixel colors at flipped positions.
 describe("image", () => {
-  const smileyImageDimensions = {
-    width: 56,
-    height: 77,
-  };
-
  beforeEach(() => {
    // it's necessary to specify the height in order to calculate natural dimensions of the image
    h.state.height = 1000;
@ -756,8 +752,8 @@ describe("image", () => {

  beforeAll(() => {
    mockHTMLImageElement(
-      smileyImageDimensions.width,
-      smileyImageDimensions.height,
+      SMILEY_IMAGE_DIMENSIONS.width,
+      SMILEY_IMAGE_DIMENSIONS.height,
    );
  });

--- a/packages/excalidraw/tests/helpers/api.ts
+++ b/packages/excalidraw/tests/helpers/api.ts
@ -478,33 +478,43 @@ export class API {
    });
  };

-  static drop = async (blob: Blob) => {
-    const fileDropEvent = createEvent.drop(GlobalTestState.interactiveCanvas);
-    const text = await new Promise<string>((resolve, reject) => {
-      try {
-        const reader = new FileReader();
-        reader.onload = () => {
-          resolve(reader.result as string);
-        };
-        reader.readAsText(blob);
-      } catch (error: any) {
-        reject(error);
-      }
-    });
+  static drop = async (items: ({kind: "string", value: string, type: string} | {kind: "file", file: File | Blob, type?: string })[]) => {

-    const files = [blob] as File[] & { item: (index: number) => File };
+    const fileDropEvent = createEvent.drop(GlobalTestState.interactiveCanvas);
+
+    const dataTransferFileItems = items.filter(i => i.kind === "file") as {kind: "file", file: File | Blob, type: string }[];
+
+    const files = dataTransferFileItems.map(item => item.file) as File[] & { item: (index: number) => File };
+    // https://developer.mozilla.org/en-US/docs/Web/API/FileList/item
    files.item = (index: number) => files[index];

    Object.defineProperty(fileDropEvent, "dataTransfer", {
      value: {
+        // https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer/files
        files,
-        getData: (type: string) => {
-          if (type === blob.type || type === "text") {
-            return text;
+        // https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer/items
+        items: items.map((item, idx) => {
+          if (item.kind === "string")  {
+            return {
+              kind: "string",
+              type: item.type,
+              // https://developer.mozilla.org/en-US/docs/Web/API/DataTransferItem/getAsString
+              getAsString: (cb: (text: string) => any) => cb(item.value),
+            };
          }
-          return "";
+          return {
+            kind: "file",
+            type: item.type || item.file.type,
+            // https://developer.mozilla.org/en-US/docs/Web/API/DataTransferItem/getAsFile
+            getAsFile: () => item.file,
+          };
+        }),
+        // https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer/getData
+        getData: (type: string) => {
+          return items.find((item) => item.type === "string" && item.type === type) || "";
        },
-        types: [blob.type],
+        // https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer/types
+        types: Array.from(new Set(items.map((item) => item.kind === "file" ? "Files" : item.type))),
      },
    });
    Object.defineProperty(fileDropEvent, "clientX", {
@ -513,7 +523,7 @@ export class API {
    Object.defineProperty(fileDropEvent, "clientY", {
      value: 0,
    });
-    
+
    await fireEvent(GlobalTestState.interactiveCanvas, fileDropEvent);
  };

--- a/packages/excalidraw/tests/helpers/constants.ts
+++ b/packages/excalidraw/tests/helpers/constants.ts
@ -0,0 +1,6 @@
+export const INITIALIZED_IMAGE_PROPS = {
+  type: "image",
+  fileId: expect.any(String),
+  x: expect.toBeNonNaNNumber(),
+  y: expect.toBeNonNaNNumber(),
+};
--- a/packages/excalidraw/tests/helpers/mocks.ts
+++ b/packages/excalidraw/tests/helpers/mocks.ts
@ -58,3 +58,35 @@ export const mockHTMLImageElement = (
    },
  );
 };
+
+// Mocks for multiple HTMLImageElements (dimensions are assigned in the order of image initialization)
+export const mockMultipleHTMLImageElements = (
+  sizes: (readonly [number, number])[],
+) => {
+  const _sizes = [...sizes];
+
+  vi.stubGlobal(
+    "Image",
+    class extends Image {
+      constructor() {
+        super();
+
+        const size = _sizes.shift();
+        if (!size) {
+          throw new Error("Insufficient sizes");
+        }
+
+        Object.defineProperty(this, "naturalWidth", {
+          value: size[0],
+        });
+        Object.defineProperty(this, "naturalHeight", {
+          value: size[1],
+        });
+
+        queueMicrotask(() => {
+          this.onload?.({} as Event);
+        });
+      }
+    },
+  );
+};
--- a/packages/excalidraw/tests/helpers/polyfills.ts
+++ b/packages/excalidraw/tests/helpers/polyfills.ts
@ -47,42 +47,43 @@ class DataTransferItem {
  }
 }

-class DataTransferList {
-  items: DataTransferItem[] = [];
-
+class DataTransferItemList extends Array<DataTransferItem> {
  add(data: string | File, type: string = ""): void {
    if (typeof data === "string") {
-      this.items.push(new DataTransferItem("string", type, data));
+      this.push(new DataTransferItem("string", type, data));
    } else if (data instanceof File) {
-      this.items.push(new DataTransferItem("file", type, data));
+      this.push(new DataTransferItem("file", type, data));
    }
  }

  clear(): void {
-    this.items = [];
+    this.clear();
  }
 }

 class DataTransfer {
-  public items: DataTransferList = new DataTransferList();
-  private _types: Record<string, string> = {};
+  public items: DataTransferItemList = new DataTransferItemList();

  get files() {
-    return this.items.items
+    return this.items
      .filter((item) => item.kind === "file")
      .map((item) => item.getAsFile()!);
  }

  add(data: string | File, type: string = ""): void {
-    this.items.add(data, type);
+    if (typeof data === "string") {
+      this.items.add(data, type);
+    } else {
+      this.items.add(data);
+    }
  }

  setData(type: string, value: string) {
-    this._types[type] = value;
+    this.items.add(value, type);
  }

  getData(type: string) {
-    return this._types[type] || "";
+    return this.items.find((item) => item.type === type)?.data || "";
  }
 }

--- a/packages/excalidraw/tests/history.test.tsx
+++ b/packages/excalidraw/tests/history.test.tsx
@ -20,6 +20,7 @@ import {
  DEFAULT_ELEMENT_BACKGROUND_COLOR_INDEX,
  DEFAULT_ELEMENT_STROKE_COLOR_INDEX,
  reseed,
+  randomId,
 } from "@excalidraw/common";

 import "@excalidraw/utils/test-utils";
@ -58,9 +59,13 @@ import { createPasteEvent } from "../clipboard";

 import * as blobModule from "../data/blob";

+import {
+  DEER_IMAGE_DIMENSIONS,
+  SMILEY_IMAGE_DIMENSIONS,
+} from "./fixtures/constants";
 import { API } from "./helpers/api";
 import { Keyboard, Pointer, UI } from "./helpers/ui";
-import { mockHTMLImageElement } from "./helpers/mocks";
+import { INITIALIZED_IMAGE_PROPS } from "./helpers/constants";
 import {
  GlobalTestState,
  act,
@ -71,6 +76,7 @@ import {
  checkpointHistory,
  unmountComponent,
 } from "./test-utils";
+import { setupImageTest as _setupImageTest } from "./image.test";

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

@ -123,7 +129,9 @@ describe("history", () => {
    const generateIdSpy = vi.spyOn(blobModule, "generateIdFromFile");
    const resizeFileSpy = vi.spyOn(blobModule, "resizeImageFile");

-    generateIdSpy.mockImplementation(() => Promise.resolve("fileId" as FileId));
+    generateIdSpy.mockImplementation(() =>
+      Promise.resolve(randomId() as FileId),
+    );
    resizeFileSpy.mockImplementation((file: File) => Promise.resolve(file));

    Object.assign(document, {
@ -560,21 +568,24 @@ describe("history", () => {
        expect(h.elements).toEqual([expect.objectContaining({ id: "A" })]),
      );

-      await API.drop(
-        new Blob(
-          [
-            JSON.stringify({
-              type: EXPORT_DATA_TYPES.excalidraw,
-              appState: {
-                ...getDefaultAppState(),
-                viewBackgroundColor: "#000",
-              },
-              elements: [API.createElement({ type: "rectangle", id: "B" })],
-            }),
-          ],
-          { type: MIME_TYPES.json },
-        ),
-      );
+      await API.drop([
+        {
+          kind: "file",
+          file: new Blob(
+            [
+              JSON.stringify({
+                type: EXPORT_DATA_TYPES.excalidraw,
+                appState: {
+                  ...getDefaultAppState(),
+                  viewBackgroundColor: "#000",
+                },
+                elements: [API.createElement({ type: "rectangle", id: "B" })],
+              }),
+            ],
+            { type: MIME_TYPES.json },
+          ),
+        },
+      ]);

      await waitFor(() => expect(API.getUndoStack().length).toBe(1));
      expect(h.state.viewBackgroundColor).toBe("#000");
@ -612,89 +623,17 @@ describe("history", () => {
      ]);
    });

-    it("should create new history entry on image drag&drop", async () => {
-      await render(<Excalidraw handleKeyboardGlobally={true} />);
-
-      // it's necessary to specify the height in order to calculate natural dimensions of the image
-      h.state.height = 1000;
-
-      const deerImageDimensions = {
-        width: 318,
-        height: 335,
-      };
-
-      mockHTMLImageElement(
-        deerImageDimensions.width,
-        deerImageDimensions.height,
-      );
-
-      await API.drop(await API.loadFile("./fixtures/deer.png"));
-
-      await waitFor(() => {
-        expect(API.getUndoStack().length).toBe(1);
-        expect(API.getRedoStack().length).toBe(0);
-        expect(h.elements).toEqual([
-          expect.objectContaining({
-            type: "image",
-            fileId: expect.any(String),
-            x: expect.toBeNonNaNNumber(),
-            y: expect.toBeNonNaNNumber(),
-            ...deerImageDimensions,
-          }),
-        ]);
-
-        // need to check that delta actually contains initialized image element (with fileId & natural dimensions)
-        expect(
-          Object.values(h.history.undoStack[0].elements.removed)[0].deleted,
-        ).toEqual(
-          expect.objectContaining({
-            type: "image",
-            fileId: expect.any(String),
-            x: expect.toBeNonNaNNumber(),
-            y: expect.toBeNonNaNNumber(),
-            ...deerImageDimensions,
-          }),
-        );
-      });
-
-      Keyboard.undo();
-      expect(API.getUndoStack().length).toBe(0);
-      expect(API.getRedoStack().length).toBe(1);
-      expect(h.elements).toEqual([
-        expect.objectContaining({
-          type: "image",
-          fileId: expect.any(String),
-          x: expect.toBeNonNaNNumber(),
-          y: expect.toBeNonNaNNumber(),
-          isDeleted: true,
-          ...deerImageDimensions,
-        }),
-      ]);
-
-      Keyboard.redo();
-      expect(API.getUndoStack().length).toBe(1);
-      expect(API.getRedoStack().length).toBe(0);
-      expect(h.elements).toEqual([
-        expect.objectContaining({
-          type: "image",
-          fileId: expect.any(String),
-          x: expect.toBeNonNaNNumber(),
-          y: expect.toBeNonNaNNumber(),
-          isDeleted: false,
-          ...deerImageDimensions,
-        }),
-      ]);
-    });
-
    it("should create new history entry on embeddable link drag&drop", async () => {
      await render(<Excalidraw handleKeyboardGlobally={true} />);

      const link = "https://www.youtube.com/watch?v=gkGMXY0wekg";
-      await API.drop(
-        new Blob([link], {
+      await API.drop([
+        {
+          kind: "string",
+          value: link,
          type: MIME_TYPES.text,
-        }),
-      );
+        },
+      ]);

      await waitFor(() => {
        expect(API.getUndoStack().length).toBe(1);
@ -730,54 +669,29 @@ describe("history", () => {
      ]);
    });

-    it("should create new history entry on image paste", async () => {
-      await render(
-        <Excalidraw autoFocus={true} handleKeyboardGlobally={true} />,
-      );
-
-      // it's necessary to specify the height in order to calculate natural dimensions of the image
-      h.state.height = 1000;
-
-      const smileyImageDimensions = {
-        width: 56,
-        height: 77,
-      };
-
-      mockHTMLImageElement(
-        smileyImageDimensions.width,
-        smileyImageDimensions.height,
-      );
-
-      document.dispatchEvent(
-        createPasteEvent({
-          files: [await API.loadFile("./fixtures/smiley_embedded_v2.png")],
-        }),
-      );
+    const setupImageTest = () =>
+      _setupImageTest([DEER_IMAGE_DIMENSIONS, SMILEY_IMAGE_DIMENSIONS]);

+    const assertImageTest = async () => {
      await waitFor(() => {
        expect(API.getUndoStack().length).toBe(1);
        expect(API.getRedoStack().length).toBe(0);
-        expect(h.elements).toEqual([
+
+        // need to check that delta actually contains initialized image elements (with fileId & natural dimensions)
+        expect(
+          Object.values(h.history.undoStack[0].elements.removed).map(
+            (val) => val.deleted,
+          ),
+        ).toEqual([
          expect.objectContaining({
-            type: "image",
-            fileId: expect.any(String),
-            x: expect.toBeNonNaNNumber(),
-            y: expect.toBeNonNaNNumber(),
-            ...smileyImageDimensions,
+            ...INITIALIZED_IMAGE_PROPS,
+            ...DEER_IMAGE_DIMENSIONS,
+          }),
+          expect.objectContaining({
+            ...INITIALIZED_IMAGE_PROPS,
+            ...SMILEY_IMAGE_DIMENSIONS,
          }),
        ]);
-        // need to check that delta actually contains initialized image element (with fileId & natural dimensions)
-        expect(
-          Object.values(h.history.undoStack[0].elements.removed)[0].deleted,
-        ).toEqual(
-          expect.objectContaining({
-            type: "image",
-            fileId: expect.any(String),
-            x: expect.toBeNonNaNNumber(),
-            y: expect.toBeNonNaNNumber(),
-            ...smileyImageDimensions,
-          }),
-        );
      });

      Keyboard.undo();
@ -785,12 +699,14 @@ describe("history", () => {
      expect(API.getRedoStack().length).toBe(1);
      expect(h.elements).toEqual([
        expect.objectContaining({
-          type: "image",
-          fileId: expect.any(String),
-          x: expect.toBeNonNaNNumber(),
-          y: expect.toBeNonNaNNumber(),
+          ...INITIALIZED_IMAGE_PROPS,
          isDeleted: true,
-          ...smileyImageDimensions,
+          ...DEER_IMAGE_DIMENSIONS,
+        }),
+        expect.objectContaining({
+          ...INITIALIZED_IMAGE_PROPS,
+          isDeleted: true,
+          ...SMILEY_IMAGE_DIMENSIONS,
        }),
      ]);

@ -799,14 +715,49 @@ describe("history", () => {
      expect(API.getRedoStack().length).toBe(0);
      expect(h.elements).toEqual([
        expect.objectContaining({
-          type: "image",
-          fileId: expect.any(String),
-          x: expect.toBeNonNaNNumber(),
-          y: expect.toBeNonNaNNumber(),
+          ...INITIALIZED_IMAGE_PROPS,
          isDeleted: false,
-          ...smileyImageDimensions,
+          ...DEER_IMAGE_DIMENSIONS,
+        }),
+        expect.objectContaining({
+          ...INITIALIZED_IMAGE_PROPS,
+          isDeleted: false,
+          ...SMILEY_IMAGE_DIMENSIONS,
        }),
      ]);
+    };
+
+    it("should create new history entry on image drag&drop", async () => {
+      await setupImageTest();
+
+      await API.drop(
+        (
+          await Promise.all([
+            API.loadFile("./fixtures/deer.png"),
+            API.loadFile("./fixtures/smiley.png"),
+          ])
+        ).map((file) => ({
+          kind: "file",
+          file,
+        })),
+      );
+
+      await assertImageTest();
+    });
+
+    it("should create new history entry on image paste", async () => {
+      await setupImageTest();
+
+      document.dispatchEvent(
+        createPasteEvent({
+          files: await Promise.all([
+            API.loadFile("./fixtures/deer.png"),
+            API.loadFile("./fixtures/smiley.png"),
+          ]),
+        }),
+      );
+
+      await assertImageTest();
    });

    it("should create new history entry on embeddable link paste", async () => {
@ -3043,15 +2994,14 @@ describe("history", () => {
      });

      Keyboard.undo();
-      expect(API.getUndoStack().length).toBe(3);
-      expect(API.getRedoStack().length).toBe(1);
-      expect(h.state.selectedLinearElement).not.toBeNull();
-      expect(h.state.selectedLinearElement?.isEditing).toBe(true);
+      expect(API.getUndoStack().length).toBe(0);
+      expect(API.getRedoStack().length).toBe(4);
+      expect(h.state.selectedLinearElement).toBeNull();

      Keyboard.redo();
      expect(API.getUndoStack().length).toBe(4);
      expect(API.getRedoStack().length).toBe(0);
-      expect(h.state.selectedLinearElement).not.toBeNull();
+      expect(h.state.selectedLinearElement).toBeNull();
      expect(h.state.selectedLinearElement?.isEditing ?? false).toBe(false);
    });

@ -4056,7 +4006,7 @@ describe("history", () => {
            expect.objectContaining({
              id: container.id,
              boundElements: [{ id: remoteText.id, type: "text" }],
-              isDeleted: false, // isDeleted got remotely updated to false
+              isDeleted: false,
            }),
            expect.objectContaining({
              id: text.id,
@ -4065,7 +4015,6 @@ describe("history", () => {
            }),
            expect.objectContaining({
              id: remoteText.id,
-              // unbound
              containerId: container.id,
              isDeleted: false,
            }),
@ -4356,8 +4305,8 @@ describe("history", () => {
          expect.objectContaining({
            ...textProps,
            // text element got redrawn!
-            x: 205,
-            y: 205,
+            x: 241.295259647664,
+            y: 247.59240920619527,
            angle: 90,
            id: text.id,
            containerId: container.id,
@ -4400,8 +4349,8 @@ describe("history", () => {
          }),
          expect.objectContaining({
            ...textProps,
-            x: 205,
-            y: 205,
+            x: 241.295259647664,
+            y: 247.59240920619527,
            angle: 90,
            id: text.id,
            containerId: container.id,
--- a/packages/excalidraw/tests/image.test.tsx
+++ b/packages/excalidraw/tests/image.test.tsx
@ -0,0 +1,115 @@
+import { randomId, reseed } from "@excalidraw/common";
+
+import type { FileId } from "@excalidraw/element/types";
+
+import * as blobModule from "../data/blob";
+import * as filesystemModule from "../data/filesystem";
+import { Excalidraw } from "../index";
+import { createPasteEvent } from "../clipboard";
+
+import { API } from "./helpers/api";
+import { mockMultipleHTMLImageElements } from "./helpers/mocks";
+import { UI } from "./helpers/ui";
+import { GlobalTestState, render, waitFor } from "./test-utils";
+import {
+  DEER_IMAGE_DIMENSIONS,
+  SMILEY_IMAGE_DIMENSIONS,
+} from "./fixtures/constants";
+import { INITIALIZED_IMAGE_PROPS } from "./helpers/constants";
+
+const { h } = window;
+
+export const setupImageTest = async (
+  sizes: { width: number; height: number }[],
+) => {
+  await render(<Excalidraw autoFocus={true} handleKeyboardGlobally={true} />);
+
+  h.state.height = 1000;
+
+  mockMultipleHTMLImageElements(sizes.map((size) => [size.width, size.height]));
+};
+
+describe("image insertion", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.unstubAllGlobals();
+
+    reseed(7);
+
+    const generateIdSpy = vi.spyOn(blobModule, "generateIdFromFile");
+    const resizeFileSpy = vi.spyOn(blobModule, "resizeImageFile");
+
+    generateIdSpy.mockImplementation(() =>
+      Promise.resolve(randomId() as FileId),
+    );
+    resizeFileSpy.mockImplementation((file: File) => Promise.resolve(file));
+
+    Object.assign(document, {
+      elementFromPoint: () => GlobalTestState.canvas,
+    });
+  });
+
+  const setup = () =>
+    setupImageTest([DEER_IMAGE_DIMENSIONS, SMILEY_IMAGE_DIMENSIONS]);
+
+  const assert = async () => {
+    await waitFor(() => {
+      expect(h.elements).toEqual([
+        expect.objectContaining({
+          ...INITIALIZED_IMAGE_PROPS,
+          ...DEER_IMAGE_DIMENSIONS,
+        }),
+        expect.objectContaining({
+          ...INITIALIZED_IMAGE_PROPS,
+          ...SMILEY_IMAGE_DIMENSIONS,
+        }),
+      ]);
+    });
+    // Not placed on top of each other
+    const dimensionsSet = new Set(h.elements.map((el) => `${el.x}-${el.y}`));
+    expect(dimensionsSet.size).toEqual(h.elements.length);
+  };
+
+  it("should eventually initialize all dropped images", async () => {
+    await setup();
+
+    const files = await Promise.all([
+      API.loadFile("./fixtures/deer.png"),
+      API.loadFile("./fixtures/smiley.png"),
+    ]);
+    await API.drop(files.map((file) => ({ kind: "file", file })));
+
+    await assert();
+  });
+
+  it("should eventually initialize all pasted images", async () => {
+    await setup();
+
+    document.dispatchEvent(
+      createPasteEvent({
+        files: await Promise.all([
+          API.loadFile("./fixtures/deer.png"),
+          API.loadFile("./fixtures/smiley.png"),
+        ]),
+      }),
+    );
+
+    await assert();
+  });
+
+  it("should eventually initialize all images added through image tool", async () => {
+    await setup();
+
+    const fileOpenSpy = vi.spyOn(filesystemModule, "fileOpen");
+    fileOpenSpy.mockImplementation(
+      async () =>
+        await Promise.all([
+          API.loadFile("./fixtures/deer.png"),
+          API.loadFile("./fixtures/smiley.png"),
+        ]),
+    );
+    UI.clickTool("image");
+
+    await assert();
+  });
+});
--- a/packages/excalidraw/tests/library.test.tsx
+++ b/packages/excalidraw/tests/library.test.tsx
@ -56,9 +56,13 @@ describe("library", () => {

  it("import library via drag&drop", async () => {
    expect(await h.app.library.getLatestLibrary()).toEqual([]);
-    await API.drop(
-      await API.loadFile("./fixtures/fixture_library.excalidrawlib"),
-    );
+    await API.drop([
+      {
+        kind: "file",
+        type: MIME_TYPES.excalidrawlib,
+        file: await API.loadFile("./fixtures/fixture_library.excalidrawlib"),
+      },
+    ]);
    await waitFor(async () => {
      expect(await h.app.library.getLatestLibrary()).toEqual([
        {
@ -75,11 +79,13 @@ describe("library", () => {
  it("drop library item onto canvas", async () => {
    expect(h.elements).toEqual([]);
    const libraryItems = parseLibraryJSON(await libraryJSONPromise);
-    await API.drop(
-      new Blob([serializeLibraryAsJSON(libraryItems)], {
+    await API.drop([
+      {
+        kind: "string",
+        value: serializeLibraryAsJSON(libraryItems),
        type: MIME_TYPES.excalidrawlib,
-      }),
-    );
+      },
+    ]);
    await waitFor(() => {
      expect(h.elements).toEqual([expect.objectContaining({ [ORIG_ID]: "A" })]);
    });
@ -111,23 +117,20 @@ describe("library", () => {
      },
    });

-    await API.drop(
-      new Blob(
-        [
-          serializeLibraryAsJSON([
-            {
-              id: "item1",
-              status: "published",
-              elements: [rectangle, text, arrow],
-              created: 1,
-            },
-          ]),
-        ],
-        {
-          type: MIME_TYPES.excalidrawlib,
-        },
-      ),
-    );
+    await API.drop([
+      {
+        kind: "string",
+        value: serializeLibraryAsJSON([
+          {
+            id: "item1",
+            status: "published",
+            elements: [rectangle, text, arrow],
+            created: 1,
+          },
+        ]),
+        type: MIME_TYPES.excalidrawlib,
+      },
+    ]);

    await waitFor(() => {
      expect(h.elements).toEqual(
@ -170,11 +173,13 @@ describe("library", () => {
      created: 1,
    };

-    await API.drop(
-      new Blob([serializeLibraryAsJSON([item1, item1])], {
+    await API.drop([
+      {
+        kind: "string",
+        value: serializeLibraryAsJSON([item1, item1]),
        type: MIME_TYPES.excalidrawlib,
-      }),
-    );
+      },
+    ]);

    await waitFor(() => {
      expect(h.elements).toEqual([
@ -193,11 +198,13 @@ describe("library", () => {
    UI.clickTool("rectangle");
    expect(h.elements).toEqual([]);
    const libraryItems = parseLibraryJSON(await libraryJSONPromise);
-    await API.drop(
-      new Blob([serializeLibraryAsJSON(libraryItems)], {
+    await API.drop([
+      {
+        kind: "string",
+        value: serializeLibraryAsJSON(libraryItems),
        type: MIME_TYPES.excalidrawlib,
-      }),
-    );
+      },
+    ]);
    await waitFor(() => {
      expect(h.elements).toEqual([expect.objectContaining({ [ORIG_ID]: "A" })]);
    });
--- a/packages/excalidraw/types.ts
+++ b/packages/excalidraw/types.ts
@ -248,8 +248,10 @@ export type ObservedElementsAppState = {
  editingGroupId: AppState["editingGroupId"];
  selectedElementIds: AppState["selectedElementIds"];
  selectedGroupIds: AppState["selectedGroupIds"];
-  selectedLinearElementId: LinearElementEditor["elementId"] | null;
-  selectedLinearElementIsEditing: boolean | null;
+  selectedLinearElement: {
+    elementId: LinearElementEditor["elementId"];
+    isEditing: boolean;
+  } | null;
  croppingElementId: AppState["croppingElementId"];
  lockedMultiSelections: AppState["lockedMultiSelections"];
  activeLockedId: AppState["activeLockedId"];
@ -350,6 +352,10 @@ export interface AppState {
    | "elementBackground"
    | "elementStroke"
    | "fontFamily"
+    | "compactTextProperties"
+    | "compactStrokeStyles"
+    | "compactOtherProperties"
+    | "compactArrowProperties"
    | null;
  openSidebar: { name: SidebarName; tab?: SidebarTabName } | null;
  openDialog:
@ -440,6 +446,9 @@ 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 };
+
+  /** properties sidebar mode - determines whether to show compact or complete sidebar */
+  stylesPanelMode: "compact" | "full";
 }

 export type SearchMatch = {
@ -729,6 +738,8 @@ export type AppClassProperties = {

  onPointerUpEmitter: App["onPointerUpEmitter"];
  updateEditorAtom: App["updateEditorAtom"];
+
+  defaultSelectionTool: "selection" | "lasso";
 };

 export type PointerDownState = Readonly<{
@ -778,6 +789,10 @@ export type PointerDownState = Readonly<{
    // by default same as PointerDownState.origin. On alt-duplication, reset
    // to current pointer position at time of duplication.
    origin: { x: number; y: number };
+    // Whether to block drag after lasso selection
+    // this is meant to be used to block dragging after lasso selection on PCs
+    // until the next pointer down
+    blockDragging: boolean;
  };
  // We need to have these in the state so that we can unsubscribe them
  eventListeners: {
@ -799,6 +814,7 @@ export type UnsubscribeCallback = () => void;

 export interface ExcalidrawImperativeAPI {
  updateScene: InstanceType<typeof App>["updateScene"];
+  applyDeltas: InstanceType<typeof App>["applyDeltas"];
  mutateElement: InstanceType<typeof App>["mutateElement"];
  updateLibrary: InstanceType<typeof Library>["updateLibrary"];
  resetScene: InstanceType<typeof App>["resetScene"];
--- a/packages/excalidraw/wysiwyg/textWysiwyg.test.tsx
+++ b/packages/excalidraw/wysiwyg/textWysiwyg.test.tsx
@ -704,7 +704,7 @@ describe("textWysiwyg", () => {
        rectangle.x + rectangle.width / 2,
        rectangle.y + rectangle.height / 2,
      );
-      expect(h.elements.length).toBe(2);
+      expect(h.elements.length).toBe(3);

      text = h.elements[1] as ExcalidrawTextElementWithContainer;
      expect(text.type).toBe("text");
@ -1198,7 +1198,11 @@ describe("textWysiwyg", () => {
      updateTextEditor(editor, "   ");
      Keyboard.exitTextEditor(editor);
      expect(rectangle.boundElements).toStrictEqual([]);
-      expect(h.elements[1]).toBeUndefined();
+      expect(h.elements[1]).toEqual(
+        expect.objectContaining({
+          isDeleted: true,
+        }),
+      );
    });

    it("should restore original container height and clear cache once text is unbind", async () => {
--- a/packages/excalidraw/wysiwyg/textWysiwyg.tsx
+++ b/packages/excalidraw/wysiwyg/textWysiwyg.tsx
@ -7,6 +7,7 @@ import {
  getFontString,
  getFontFamilyString,
  isTestEnv,
+  MIME_TYPES,
 } from "@excalidraw/common";

 import {
@ -45,7 +46,7 @@ import type {

 import { actionSaveToActiveFile } from "../actions";

-import { parseClipboard } from "../clipboard";
+import { parseDataTransferEvent } from "../clipboard";
 import {
  actionDecreaseFontSize,
  actionIncreaseFontSize,
@ -215,11 +216,12 @@ export const textWysiwyg = ({
          );
          app.scene.mutateElement(container, { height: targetContainerHeight });
        } else {
-          const { y } = computeBoundTextPosition(
+          const { x, y } = computeBoundTextPosition(
            container,
            updatedTextElement as ExcalidrawTextElementWithContainer,
            elementsMap,
          );
+          coordX = x;
          coordY = y;
        }
      }
@ -331,12 +333,14 @@ export const textWysiwyg = ({

  if (onChange) {
    editable.onpaste = async (event) => {
-      const clipboardData = await parseClipboard(event, true);
-      if (!clipboardData.text) {
+      const textItem = (await parseDataTransferEvent(event)).findByType(
+        MIME_TYPES.text,
+      );
+      if (!textItem) {
        return;
      }
-      const data = normalizeText(clipboardData.text);
-      if (!data) {
+      const text = normalizeText(textItem.value);
+      if (!text) {
        return;
      }
      const container = getContainerElement(
@ -354,7 +358,7 @@ export const textWysiwyg = ({
          app.scene.getNonDeletedElementsMap(),
        );
        const wrappedText = wrapText(
-          `${editable.value}${data}`,
+          `${editable.value}${text}`,
          font,
          getBoundTextMaxWidth(container, boundTextElement),
        );
@ -538,6 +542,7 @@ export const textWysiwyg = ({
    if (isDestroyed) {
      return;
    }
+
    isDestroyed = true;
    // cleanup must be run before onSubmit otherwise when app blurs the wysiwyg
    // it'd get stuck in an infinite loop of blur→onSubmit after we re-focus the
@ -621,14 +626,24 @@ export const textWysiwyg = ({
    const isPropertiesTrigger =
      target instanceof HTMLElement &&
      target.classList.contains("properties-trigger");
+    const isPropertiesContent =
+      (target instanceof HTMLElement || target instanceof SVGElement) &&
+      !!(target as Element).closest(".properties-content");
+    const inShapeActionsMenu =
+      (target instanceof HTMLElement || target instanceof SVGElement) &&
+      (!!(target as Element).closest(`.${CLASSES.SHAPE_ACTIONS_MENU}`) ||
+        !!(target as Element).closest(".compact-shape-actions-island"));

    setTimeout(() => {
-      editable.onblur = handleSubmit;
-
-      // case: clicking on the same property → no change → no update → no focus
-      if (!isPropertiesTrigger) {
-        editable.focus();
+      // If we interacted within shape actions menu or its popovers/triggers,
+      // keep submit disabled and don't steal focus back to textarea.
+      if (inShapeActionsMenu || isPropertiesTrigger || isPropertiesContent) {
+        return;
      }
+
+      // Otherwise, re-enable submit on blur and refocus the editor.
+      editable.onblur = handleSubmit;
+      editable.focus();
    });
  };

@ -651,6 +666,7 @@ export const textWysiwyg = ({
        event.preventDefault();
        app.handleCanvasPanUsingWheelOrSpaceDrag(event);
      }
+
      temporarilyDisableSubmit();
      return;
    }
@ -658,15 +674,20 @@ export const textWysiwyg = ({
    const isPropertiesTrigger =
      target instanceof HTMLElement &&
      target.classList.contains("properties-trigger");
+    const isPropertiesContent =
+      (target instanceof HTMLElement || target instanceof SVGElement) &&
+      !!(target as Element).closest(".properties-content");

    if (
      ((event.target instanceof HTMLElement ||
        event.target instanceof SVGElement) &&
-        event.target.closest(
+        (event.target.closest(
          `.${CLASSES.SHAPE_ACTIONS_MENU}, .${CLASSES.ZOOM_ACTIONS}`,
-        ) &&
+        ) ||
+          event.target.closest(".compact-shape-actions-island")) &&
        !isWritableElement(event.target)) ||
-      isPropertiesTrigger
+      isPropertiesTrigger ||
+      isPropertiesContent
    ) {
      temporarilyDisableSubmit();
    } else if (
--- a/packages/math/src/segment.ts
+++ b/packages/math/src/segment.ts
@ -177,3 +177,19 @@ export function lineSegmentIntersectionPoints<

  return candidate;
 }
+
+export function lineSegmentsDistance<Point extends GlobalPoint | LocalPoint>(
+  s1: LineSegment<Point>,
+  s2: LineSegment<Point>,
+): number {
+  if (lineSegmentIntersectionPoints(s1, s2)) {
+    return 0;
+  }
+
+  return Math.min(
+    distanceToLineSegment(s1[0], s2),
+    distanceToLineSegment(s1[1], s2),
+    distanceToLineSegment(s2[0], s1),
+    distanceToLineSegment(s2[1], s1),
+  );
+}
--- a/packages/utils/src/export.ts
+++ b/packages/utils/src/export.ts
@ -49,6 +49,7 @@ export const exportToCanvas = ({
    { elements, appState },
    null,
    null,
+    { deleteInvisibleElements: true },
  );
  const { exportBackground, viewBackgroundColor } = restoredAppState;
  return _exportToCanvas(
@ -179,6 +180,7 @@ export const exportToSvg = async ({
    { elements, appState },
    null,
    null,
+    { deleteInvisibleElements: true },
  );

  const exportAppState = {
--- a/packages/utils/tests/snapshots/export.test.ts.snap
+++ b/packages/utils/tests/snapshots/export.test.ts.snap
@ -100,6 +100,7 @@ exports[`exportToSvg > with default arguments 1`] = `
    "open": false,
    "panels": 3,
  },
+  "stylesPanelMode": "full",
  "suggestedBindings": [],
  "theme": "light",
  "toast": null,
--- a/yarn.lock
+++ b/yarn.lock
@ -1452,14 +1452,15 @@
  resolved "https://registry.yarnpkg.com/@excalidraw/markdown-to-text/-/markdown-to-text-0.1.2.tgz#1703705e7da608cf478f17bfe96fb295f55a23eb"
  integrity sha512-1nDXBNAojfi3oSFwJswKREkFm5wrSjqay81QlyRv2pkITG/XYB5v+oChENVBQLcxQwX4IUATWvXM5BcaNhPiIg==

-"@excalidraw/mermaid-to-excalidraw@1.1.2":
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/@excalidraw/mermaid-to-excalidraw/-/mermaid-to-excalidraw-1.1.2.tgz#74d9507971976a7d3d960a1b2e8fb49a9f1f0d22"
-  integrity sha512-hAFv/TTIsOdoy0dL5v+oBd297SQ+Z88gZ5u99fCIFuEMHfQuPgLhU/ztKhFSTs7fISwVo6fizny/5oQRR3d4tQ==
+"@excalidraw/mermaid-to-excalidraw@1.1.3":
+  version "1.1.3"
+  resolved "https://registry.yarnpkg.com/@excalidraw/mermaid-to-excalidraw/-/mermaid-to-excalidraw-1.1.3.tgz#3204642c99f3d49c2ad41108217a5d493ef7fd09"
+  integrity sha512-/50GUWlGotc+FCMX7nM1P1kWm9vNd3fuq38v7upBp9IHqlw6Zmfyj79eG/0vz1heifuYrSW9yzzv0q9jVALzxg==
  dependencies:
    "@excalidraw/markdown-to-text" "0.1.2"
-    mermaid "10.9.3"
+    mermaid "10.9.4"
    nanoid "4.0.2"
+    react-split "^2.0.14"

 "@excalidraw/prettier-config@1.0.2":
  version "1.0.2"
@ -7057,10 +7058,10 @@ merge2@^1.3.0, merge2@^1.4.1:
  resolved "https://registry.yarnpkg.com/merge2/-/merge2-1.4.1.tgz#4368892f885e907455a6fd7dc55c0c9d404990ae"
  integrity sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==

-mermaid@10.9.3:
-  version "10.9.3"
-  resolved "https://registry.yarnpkg.com/mermaid/-/mermaid-10.9.3.tgz#90bc6f15c33dbe5d9507fed31592cc0d88fee9f7"
-  integrity sha512-V80X1isSEvAewIL3xhmz/rVmc27CVljcsbWxkxlWJWY/1kQa4XOABqpDl2qQLGKzpKm6WbTfUEKImBlUfFYArw==
+mermaid@10.9.4:
+  version "10.9.4"
+  resolved "https://registry.yarnpkg.com/mermaid/-/mermaid-10.9.4.tgz#985fd4b6d73ae795b87f0b32f620a56d3d6bf1f8"
+  integrity sha512-VIG2B0R9ydvkS+wShA8sXqkzfpYglM2Qwj7VyUeqzNVqSGPoP/tcaUr3ub4ESykv8eqQJn3p99bHNvYdg3gCHQ==
  dependencies:
    "@braintree/sanitize-url" "^6.0.1"
    "@types/d3-scale" "^4.0.3"
@ -7963,7 +7964,7 @@ progress@2.0.3, progress@^2.0.0:
  resolved "https://registry.yarnpkg.com/progress/-/progress-2.0.3.tgz#7e8cf8d8f5b8f239c1bc68beb4eb78567d572ef8"
  integrity sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==

-prop-types@^15.8.1:
+prop-types@^15.5.7, prop-types@^15.8.1:
  version "15.8.1"
  resolved "https://registry.yarnpkg.com/prop-types/-/prop-types-15.8.1.tgz#67d87bf1a694f48435cf332c24af10214a3140b5"
  integrity sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==
@ -8108,6 +8109,14 @@ react-remove-scroll@^2.6.3:
    use-callback-ref "^1.3.3"
    use-sidecar "^1.1.3"

+react-split@^2.0.14:
+  version "2.0.14"
+  resolved "https://registry.yarnpkg.com/react-split/-/react-split-2.0.14.tgz#ef198259bf43264d605f792fb3384f15f5b34432"
+  integrity sha512-bKWydgMgaKTg/2JGQnaJPg51T6dmumTWZppFgEbbY0Fbme0F5TuatAScCLaqommbGQQf/ZT1zaejuPDriscISA==
+  dependencies:
+    prop-types "^15.5.7"
+    split.js "^1.6.0"
+
 react-style-singleton@^2.2.2, react-style-singleton@^2.2.3:
  version "2.2.3"
  resolved "https://registry.yarnpkg.com/react-style-singleton/-/react-style-singleton-2.2.3.tgz#4265608be69a4d70cfe3047f2c6c88b2c3ace388"
@ -8747,6 +8756,11 @@ sourcemap-codec@^1.4.8:
  resolved "https://registry.yarnpkg.com/sourcemap-codec/-/sourcemap-codec-1.4.8.tgz#ea804bd94857402e6992d05a38ef1ae35a9ab4c4"
  integrity sha512-9NykojV5Uih4lgo5So5dtw+f0JgJX30KCNI8gwhz2J9A15wD0Ml6tjHKwf6fTSa6fAdVBdZeNOs9eJ71qCk8vA==

+split.js@^1.6.0:
+  version "1.6.5"
+  resolved "https://registry.yarnpkg.com/split.js/-/split.js-1.6.5.tgz#f7f61da1044c9984cb42947df4de4fadb5a3f300"
+  integrity sha512-mPTnGCiS/RiuTNsVhCm9De9cCAUsrNFFviRbADdKiiV+Kk8HKp/0fWu7Kr8pi3/yBmsqLFHuXGT9UUZ+CNLwFw==
+
 sprintf-js@~1.0.2:
  version "1.0.3"
  resolved "https://registry.yarnpkg.com/sprintf-js/-/sprintf-js-1.0.3.tgz#04e6926f662895354f3dd015203633b857297e2c"
Author	SHA1	Message	Date
Márk Tolmács	f55ecb96cc	fix: Mobile arrow point drag broken (#9998 ) * fix: Mobile bound arrow point drag broken * fix:Check real point	2025-09-19 19:41:03 +02:00
David Luzar	a6a32b9b29	fix: align MQ breakpoints and always use editor dimensions (#9991 ) * fix: align MQ breakpoints and always use editor dimensions * naming * update snapshots	2025-09-17 07:57:10 +00:00
Márk Tolmács	ac0d3059dc	fix: Use the right polygon enclosure test (#9979 )	2025-09-15 10:07:37 +02:00
Christopher Tangonan	1161f1b8ba	fix: eraser can handle dots without regressing prior performance improvements (#9946 ) Co-authored-by: Márk Tolmács <mark@lazycat.hu>	2025-09-14 11:33:43 +00:00
Ryan Di	204e06b77b	feat: compact layout for tablets (#9910 ) * feat: allow the hiding of top picks * feat: allow the hiding of default fonts * refactor: rename to compactMode * feat: introduce layout (incomplete) * tweak icons * do not show border * lint * add isTouchMobile to device * add isTouchMobile to device * refactor to use showCompactSidebar instead * hide library label in compact * fix icon color in dark theme * fix library and share btns getting hidden in smaller tablet widths * update tests * use a smaller gap between shapes * proper fix of range * quicker switching between different popovers * to not show properties panel at all when editing text * fix switching between different popovers for texts * fix popover not closable and font search auto focus * change properties for a new or editing text * change icon for more style settings * use bolt icon for extra actions * fix breakpoints * use rem for icon sizes * fix tests * improve switching between triggers (incomplete) * improve trigger switching (complete) * clean up code * put compact into app state * fix button size * remove redundant PanelComponentProps["compactMode"] * move fontSize UI on top * mobile detection (breakpoints incomplete) * tweak compact mode detection * rename appState prop & values * update snapshots --------- Co-authored-by: dwelle <5153846+dwelle@users.noreply.github.com>	2025-09-12 10:18:31 +10:00
David Luzar	414182f599	fix: normalize file on paste/drop (#9959 )	2025-09-10 17:59:02 +02:00
David Luzar	b9d27d308e	fix: pasting not working in firefox (#9947 )	2025-09-06 22:51:23 +02:00
Omar Brikaa	3bdaafe4b5	feat: [cont.] support inserting multiple images (#9875 ) * feat: support inserting multiple images * Initial * handleAppOnDrop, onImageToolbarButtonClick, pasteFromClipboard * Initial get history working * insertMultipleImages -> insertImages * Bug fixes, improvements * Remove redundant branch * Refactor addElementsFromMixedContentPaste * History, drag & drop bug fixes * Update snapshots * Remove redundant try-catch * Refactor pasteFromClipboard * Plain paste check in mermaid paste * Move comment * processClipboardData -> insertClipboardContent * Redundant variable * Redundant variable * Refactor insertImages * createImagePlaceholder -> newImagePlaceholder * Get rid of unneeded NEVER schedule, filter out failed images * Trigger CI * Position placeholders before initializing * Don't mutate scene with positionElementsOnGrid, captureUpdate: CaptureUpdateAction.IMMEDIATELY * Comment * Move positionOnGrid out of file * Rename file * Get rid of generic * Initial tests * More asserts, test paste * Test image tool * De-duplicate * Stricter assert, move rest of logic outside of waitFor * Modify history tests * De-duplicate update snapshots * Trigger CI * Fix package build * Make setupImageTest more explicit * Re-introduce generic to use latest placeholder versions * newElementWith instead of mutateElement to delete failed placeholder * Insert failed images separately with CaptureUpdateAction.NEVER * Refactor * Don't re-order elements * WIP * Get rid of 'never' for failed * refactor type check * align max file size constant * make grid padding scale to zoom --------- Co-authored-by: dwelle <5153846+dwelle@users.noreply.github.com>	2025-09-01 17:31:24 +02:00
Christopher Tangonan	ae89608985	fix: bound text rotation across alignments (#9914 ) Co-authored-by: A-Mundanilkunathil <aaronchackom2002@gmail.com>	2025-08-29 12:31:23 +02:00
Ryan Di	3085f4af81	fix: tighten distance for double tap text creation (#9889 )	2025-08-22 18:12:51 +02:00
David Luzar	531f3e5524	fix: restore from invalid fixedSegments & type-safer point updates (#9899 ) * fix: restore from invalid fixedSegments & type-safer point updates * fix: Type updates and throw for invalid point states --------- Co-authored-by: Mark Tolmacs <mark@lazycat.hu>	2025-08-22 15:45:58 +00:00
David Luzar	90ec2739ae	fix: calling toLowerCase on potentially undefined `navigator.*` values (#9901 )	2025-08-22 17:37:16 +02:00
David Luzar	f29e9df72d	chore: bump mermaid-to-excalidraw to 1.1.3 (#9898 )	2025-08-21 20:58:04 +02:00
Marcel Mraz	b5ad7ae4e3	fix: even deltas with version & version nonce are valid (#9897 )	2025-08-21 16:09:19 +02:00
David Luzar	c78e4aab7f	chore: tweak title & remove timeout (#9883 )	2025-08-20 14:09:20 +02:00
Ryan Di	b4903a7eab	feat: drag, resize, and rotate after selecting in lasso (#9732 ) * feat: drag, resize, and rotate after selecting in lasso * alternative ux: drag with lasso right away * fix: lasso dragging should snap too * fix: alt+cmd getting stuck * test: snapshots * alternatvie: keep lasso drag to only mobile * alternative: drag after selection on PCs * improve mobile dection * add mobile lasso icon * add default selection tool * render according to default selection tool * return to default selection tool after deletion * reset to default tool after clearing out the canvas * return to default tool after eraser toggle * if default lasso, close lasso toggle * finalize to default selection tool * toggle between laser and default selection * return to default selection tool after creation * double click to add text when using default selection tool * set to default selection tool after unlocking tool * paste to center on touch screen * switch to default selection tool after pasting * lint * fix tests * show welcome screen when using default selection tool * fix tests * fix snapshots * fix context menu not opening * prevent potential displacement issue * prevent element jumping during lasso selection * fix dragging on mobile * use same selection icon * fix alt+cmd lasso getting cut off * fix: shortcut handling * lint --------- Co-authored-by: dwelle <5153846+dwelle@users.noreply.github.com>	2025-08-20 00:03:02 +02:00
zsviczian	c6f8ef9ad2	fix: Scene deleted after pica image resize failure (#9879 ) Revert change in private updateImageCache	2025-08-18 11:45:05 +02:00
Marcel Mraz	2535d73054	feat: apply deltas API (#9869 )	2025-08-15 15:25:56 +02:00
David Luzar	dda3affcb0	fix: do not strip invisible elements from array (#9844 )	2025-08-12 11:56:11 +02:00
Marcel Mraz	54c148f390	fix: text restore & deletion issues (#9853 )	2025-08-12 09:27:04 +02:00
zsviczian	cc8e490c75	fix: do not auto-add elements to locked frame (#9851 ) * Do not return locked frames when filtering for top level frame * lint * lint * lint	2025-08-11 11:52:44 +02:00
Marcel Mraz	9036812b6d	fix: editing linear element (#9839 )	2025-08-08 09:30:11 +02:00