fix ts

Signed-off-by: Mark Tolmacs <mark@lazycat.hu>

.codesandbox/Dockerfile

@@ -1,4 +1,4 @@
-FROM node:24-bullseye
+FROM node:18-bullseye
 
 # Vite wants to open the browser using `open`, so we
 # need to install those utils.

.github/workflows/autorelease-excalidraw.yml

@@ -9,11 +9,11 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
+      - uses: actions/checkout@v2
         with:
           fetch-depth: 2
       - name: Setup Node.js
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+        uses: actions/setup-node@v2
         with:
           node-version: 20.x
       - name: Set up publish access

.github/workflows/build-docker.yml

@@ -9,5 +9,5 @@ jobs:
   build-docker:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
+      - uses: actions/checkout@v2
       - run: docker build -t excalidraw .

.github/workflows/cancel.yml

@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 3
     steps:
-      - uses: styfle/cancel-workflow-action@ce177499ccf9fd2aded3b0426c97e5434c2e8a73 # 0.6.0
+      - uses: styfle/cancel-workflow-action@0.6.0
         with:
           workflow_id: 400555, 400556, 905313, 1451724, 1710116, 3185001, 3438604
           access_token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/lint.yml

@@ -7,10 +7,10 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
+      - uses: actions/checkout@v2
 
       - name: Setup Node.js
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+        uses: actions/setup-node@v2
         with:
           node-version: 20.x
 

.github/workflows/locales-coverage.yml

@@ -10,12 +10,12 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
+      - uses: actions/checkout@v4
         with:
           token: ${{ secrets.PUSH_TRANSLATIONS_COVERAGE_PAT }}
 
       - name: Setup Node.js
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+        uses: actions/setup-node@v2
         with:
           node-version: 20.x
 
@@ -40,7 +40,7 @@ jobs:
           echo ::set-output name=body::$body
 
       - name: Update description with coverage
-        uses: kt3k/update-pr-description@1b35a6dcd84d81aa0bc1889610efdcde7f37b0c0 # v1.0.1
+        uses: kt3k/update-pr-description@v1.0.1
         with:
           pr_body: ${{ steps.getCommentBody.outputs.body }}
           pr_title: "chore: Update translations from Crowdin"

.github/workflows/publish-docker.yml

@@ -11,18 +11,18 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
+        uses: actions/checkout@v3
       - name: Login to DockerHub
-        uses: docker/login-action@465a07811f14bebb1938fbed4728c6a1ff8901fc # v2
+        uses: docker/login-action@v2
         with:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@c7c53464625b32c7a7e944ae62b3e17d2b600130 # v3
+        uses: docker/setup-qemu-action@v3
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f # v3
+        uses: docker/setup-buildx-action@v3
       - name: Build and push
-        uses: docker/build-push-action@ca052bb54ab0790a636c9b5f226502c73d547a25 # v5
+        uses: docker/build-push-action@v5
         with:
           context: .
           push: true

.github/workflows/semantic-pr-title.yml

@@ -6,97 +6,11 @@ on:
       - opened
       - edited
       - synchronize
-      - labeled
-      - unlabeled
 
 jobs:
   semantic:
     runs-on: ubuntu-latest
-    permissions:
-      pull-requests: read
     steps:
-      - uses: amannn/action-semantic-pull-request@e32d7e603df1aa1ba07e981f2a23455dee596825 # v5
-        with:
-          requireScope: true
-          scopes: |
-            app
-            editor
-            packages/excalidraw
-            packages/utils
-            docker
-            repo
-          ignoreLabels: |
-            skip-semantic-title
+      - uses: amannn/action-semantic-pull-request@v5
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-  label-scope:
-    needs: semantic
-    if: github.event.pull_request.head.repo.full_name == github.repository
-    runs-on: ubuntu-latest
-    permissions:
-      issues: write
-      pull-requests: write
-    steps:
-      - name: Label scoped PR
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          PR_NUMBER: ${{ github.event.pull_request.number }}
-          PR_TITLE: ${{ github.event.pull_request.title }}
-          REPOSITORY: ${{ github.repository }}
-        run: |
-          set -euo pipefail
-
-          scope_labels=(s-app s-editor s-package)
-
-          readarray -t desired_labels < <(
-            node <<'NODE'
-          const title = process.env.PR_TITLE;
-          const match = title.match(/^[a-z]+(?:\(([^)]+)\))?!?:/i);
-          const scopes = match?.[1]?.split(",").map((scope) => scope.trim()) ?? [];
-          const labels = new Set();
-
-          for (const scope of scopes) {
-            if (scope === "app") {
-              labels.add("s-app");
-            } else if (scope === "editor") {
-              labels.add("s-editor");
-            } else if (scope.startsWith("packages/")) {
-              labels.add("s-package");
-            }
-          }
-
-          process.stdout.write([...labels].join("\n"));
-          NODE
-          )
-
-          should_apply_label() {
-            local label="$1"
-
-            for desired_label in "${desired_labels[@]}"; do
-              if [[ "$desired_label" == "$label" ]]; then
-                return 0
-              fi
-            done
-
-            return 1
-          }
-
-          for label in "${scope_labels[@]}"; do
-            if ! should_apply_label "$label"; then
-              gh api \
-                --method DELETE \
-                "repos/${REPOSITORY}/issues/${PR_NUMBER}/labels/${label}" \
-                --silent 2>/dev/null || true
-            fi
-          done
-
-          for label in "${desired_labels[@]}"; do
-            if ! gh api \
-              --method POST \
-              "repos/${REPOSITORY}/issues/${PR_NUMBER}/labels" \
-              --field "labels[]=${label}" \
-              --silent; then
-              echo "::warning::Could not apply ${label}. The workflow token likely does not have issues:write permission for this PR."
-            fi
-          done

.github/workflows/sentry-production.yml

@@ -9,9 +9,9 @@ jobs:
   sentry:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
+      - uses: actions/checkout@v2
       - name: Setup Node.js
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+        uses: actions/setup-node@v2
         with:
           node-version: 20.x
       - name: Install and build

.github/workflows/size-limit.yml

@@ -10,9 +10,9 @@ jobs:
       CI_JOB_NUMBER: 1
     steps:
       - name: Checkout repository
-        uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
+        uses: actions/checkout@v3
       - name: Setup Node.js
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+        uses: actions/setup-node@v3
         with:
           node-version: 20.x
       - name: Install in packages/excalidraw
@@ -20,7 +20,7 @@ jobs:
         working-directory: packages/excalidraw
         env:
           CI: true
-      - uses: andresz1/size-limit-action@e7493a72a44b113341c0cf6186ab49c17c4b65c1 # v1
+      - uses: andresz1/size-limit-action@v1
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}
           build_script: build:esm

.github/workflows/test-coverage-pr.yml

@@ -10,9 +10,9 @@ jobs:
       pull-requests: write
 
     steps:
-      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
+      - uses: actions/checkout@v2
       - name: "Install Node"
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+        uses: actions/setup-node@v2
         with:
           node-version: "20.x"
       - name: "Install Deps"
@@ -21,6 +21,6 @@ jobs:
         run: yarn test:coverage
       - name: "Report Coverage"
         if: always() # Also generate the report if tests are failing
-        uses: davelosert/vitest-coverage-report-action@2500dafcee7dd64f85ab689c0b83798a8359770e # v2
+        uses: davelosert/vitest-coverage-report-action@v2
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/test.yml

@@ -8,9 +8,9 @@ jobs:
   test:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
+      - uses: actions/checkout@v4
       - name: Setup Node.js
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+        uses: actions/setup-node@v4
         with:
           node-version: 20.x
       - name: Install and test

Dockerfile

@@ -1,4 +1,4 @@
-FROM --platform=${BUILDPLATFORM} node:24@sha256:8530f76a96d88820d288761f022e318970dda93d01536919fbc16076b7983e63 AS build
+FROM --platform=${BUILDPLATFORM} node:18 AS build
 
 WORKDIR /opt/node_app
 
@@ -7,13 +7,13 @@ COPY . .
 # do not ignore optional dependencies:
 # Error: Cannot find module @rollup/rollup-linux-x64-gnu
 RUN --mount=type=cache,target=/root/.cache/yarn \
-    npm_config_target_arch=${TARGETARCH} yarn --frozen-lockfile --network-timeout 600000
+    npm_config_target_arch=${TARGETARCH} yarn --network-timeout 600000
 
 ARG NODE_ENV=production
 
 RUN npm_config_target_arch=${TARGETARCH} yarn build:app:docker
 
-FROM nginx:stable-alpine-slim@sha256:2c605dbeab79a6b2a63340474fe58119d0ef95bdc4b1f41df0aa689659b3d13b
+FROM --platform=${TARGETPLATFORM} nginx:1.27-alpine
 
 COPY --from=build /opt/node_app/excalidraw-app/build /usr/share/nginx/html
 

README.md

@@ -29,7 +29,7 @@
   <a href="https://docs.excalidraw.com/docs/introduction/contributing">
     <img alt="PRs welcome!" src="https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat"  /></a>
   <a href="https://discord.gg/UexuTaE">
-    <img alt="Chat on Discord" src="https://img.shields.io/discord/723672430744174682?color=738ad6&label=Chat%20on%20Discord&logo=discord&logoColor=ffffff&widget=false"/></a>
+    <img alt="Chat on Discord" src="https://img.shields.io/discord/723672430744174682?color=738ad6&label=Chat%20on%20Discord&logo=discord&logoColor=ffffff&widge=false"/></a>
   <a href="https://deepwiki.com/excalidraw/excalidraw">
     <img alt="Ask DeepWiki" src="https://deepwiki.com/badge.svg" /></a>
   <a href="https://twitter.com/excalidraw">

dev-docs/docusaurus.config.js

@@ -97,8 +97,8 @@ const config = {
                 href: "https://discord.gg/UexuTaE",
               },
               {
-                label: "𝕏",
-                href: "https://x.com/excalidraw",
+                label: "Twitter",
+                href: "https://twitter.com/excalidraw",
               },
               {
                 label: "Linkedin",

excalidraw-app/App.tsx

@@ -22,6 +22,7 @@ import Trans from "@excalidraw/excalidraw/components/Trans";
 import {
   APP_NAME,
   EVENT,
+  THEME,
   VERSION_TIMEOUT,
   debounce,
   getVersion,
@@ -951,7 +952,6 @@ const ExcalidrawWrapper = () => {
         handleKeyboardGlobally={true}
         autoFocus={true}
         theme={editorTheme}
-        onThemeChange={setAppTheme}
         renderTopRightUI={(isMobile) => {
           if (isMobile || !collabAPI || isCollabDisabled) {
             return null;
@@ -988,6 +988,7 @@ const ExcalidrawWrapper = () => {
           isCollaborating={isCollaborating}
           isCollabEnabled={!isCollabDisabled}
           theme={appTheme}
+          setTheme={(theme) => setAppTheme(theme)}
           refresh={() => forceRefresh((prev) => !prev)}
         />
         <AppWelcomeScreen
@@ -1228,6 +1229,14 @@ const ExcalidrawWrapper = () => {
                 }
               },
             },
+            {
+              ...CommandPalette.defaultItems.toggleTheme,
+              perform: () => {
+                setAppTheme(
+                  editorTheme === THEME.DARK ? THEME.LIGHT : THEME.DARK,
+                );
+              },
+            },
             {
               label: t("labels.installPWA"),
               category: DEFAULT_CATEGORIES.app,

excalidraw-app/components/AppMainMenu.tsx

@@ -20,6 +20,7 @@ export const AppMainMenu: React.FC<{
   isCollaborating: boolean;
   isCollabEnabled: boolean;
   theme: Theme | "system";
+  setTheme: (theme: Theme | "system") => void;
   refresh: () => void;
 }> = React.memo((props) => {
   return (
@@ -77,7 +78,11 @@ export const AppMainMenu: React.FC<{
       )}
       <MainMenu.Separator />
       <MainMenu.DefaultItems.Preferences />
-      <MainMenu.DefaultItems.ToggleTheme allowSystemTheme theme={props.theme} />
+      <MainMenu.DefaultItems.ToggleTheme
+        allowSystemTheme
+        theme={props.theme}
+        onSelect={props.setTheme}
+      />
       <MainMenu.ItemCustom>
         <LanguageList style={{ width: "100%" }} />
       </MainMenu.ItemCustom>

excalidraw-app/components/DebugCanvas.tsx

@@ -3,24 +3,41 @@ import {
   CloseIcon,
   TrashIcon,
 } from "@excalidraw/excalidraw/components/icons";
+import { useExcalidrawAPI } from "@excalidraw/excalidraw/index";
 import {
   bootstrapCanvas,
+  fillCircle,
   getNormalizedCanvasDimensions,
 } from "@excalidraw/excalidraw/renderer/helpers";
 import { type AppState } from "@excalidraw/excalidraw/types";
-import { arrayToMap, throttleRAF } from "@excalidraw/common";
-import { useCallback } from "react";
+import {
+  arrayToMap,
+  sceneCoordsToViewportCoords,
+  throttleRAF,
+  viewportCoordsToSceneCoords,
+} from "@excalidraw/common";
+import { useCallback, useEffect, useRef, useState } from "react";
 
 import {
+  CaptureUpdateAction,
+  clearSimpleArrowTangentOverride,
   getGlobalFixedPointForBindableElement,
+  getElementAbsoluteCoords,
+  getSimpleArrowCurveDebugData,
   isArrowElement,
   isBindableElement,
+  setSimpleArrowTangentOverride,
+  ShapeCache,
 } from "@excalidraw/element";
 
 import {
   isLineSegment,
+  pointFrom,
+  pointRotateRads,
   type GlobalPoint,
+  type LocalPoint,
   type LineSegment,
+  type Radians,
 } from "@excalidraw/math";
 import { isCurve } from "@excalidraw/math/curve";
 
@@ -36,11 +53,260 @@ import type {
   ExcalidrawArrowElement,
   ExcalidrawBindableElement,
   FixedPointBinding,
+  Ordered,
   OrderedExcalidrawElement,
 } from "@excalidraw/element/types";
+import type { SimpleArrowCurveDebugData } from "@excalidraw/element";
 
 import { STORAGE_KEYS } from "../app_constants";
 
+type DebugCanvasOverlayState = Pick<
+  AppState,
+  | "width"
+  | "height"
+  | "zoom"
+  | "scrollX"
+  | "scrollY"
+  | "offsetLeft"
+  | "offsetTop"
+  | "selectedElementIds"
+>;
+
+type SimpleArrowHandleDirection = "incoming" | "outgoing";
+
+type SimpleArrowHandleDescriptor = {
+  key: string;
+  elementId: string;
+  pointIndex: number;
+  direction: SimpleArrowHandleDirection;
+  point: GlobalPoint;
+  handle: GlobalPoint;
+  isOverridden: boolean;
+  title: string;
+};
+
+type SelectedSimpleArrowDebugState = {
+  element: ExcalidrawArrowElement;
+  debugData: SimpleArrowCurveDebugData<GlobalPoint>;
+  handles: SimpleArrowHandleDescriptor[];
+};
+
+const areSimpleArrowTangentHandlesEnabled = () =>
+  window.EXCALIDRAW_DEBUG_LINEAR_ARROW_TANGENTS !== false;
+
+const pickOverlayState = (appState: AppState): DebugCanvasOverlayState => ({
+  width: appState.width,
+  height: appState.height,
+  zoom: appState.zoom,
+  scrollX: appState.scrollX,
+  scrollY: appState.scrollY,
+  offsetLeft: appState.offsetLeft,
+  offsetTop: appState.offsetTop,
+  selectedElementIds: appState.selectedElementIds,
+});
+
+const getSimpleArrowTransform = (
+  element: ExcalidrawArrowElement,
+  elementsMap: ElementsMap,
+) => {
+  const [, , , , cx, cy] = getElementAbsoluteCoords(element, elementsMap);
+  const center = pointFrom<GlobalPoint>(cx, cy);
+
+  return {
+    pointToGlobal: (point: LocalPoint): GlobalPoint => {
+      const rotated = pointRotateRads(
+        pointFrom<GlobalPoint>(element.x + point[0], element.y + point[1]),
+        center,
+        element.angle,
+      );
+
+      return pointFrom<GlobalPoint>(rotated[0], rotated[1]);
+    },
+    vectorToGlobal: (vector: [number, number]): [number, number] => {
+      const rotated = pointRotateRads(
+        pointFrom<GlobalPoint>(vector[0], vector[1]),
+        pointFrom<GlobalPoint>(0, 0),
+        element.angle,
+      );
+
+      return [rotated[0], rotated[1]];
+    },
+    vectorToLocal: (vector: [number, number]): [number, number] => {
+      const rotated = pointRotateRads(
+        pointFrom<GlobalPoint>(vector[0], vector[1]),
+        pointFrom<GlobalPoint>(0, 0),
+        -element.angle as Radians,
+      );
+
+      return [rotated[0], rotated[1]];
+    },
+  };
+};
+
+const getSimpleArrowDebugStateForElement = (
+  elements: readonly OrderedExcalidrawElement[],
+  elementId: string,
+): SelectedSimpleArrowDebugState | null => {
+  const element = elements.find(
+    (candidate): candidate is Ordered<ExcalidrawArrowElement> =>
+      candidate.id === elementId &&
+      !candidate.isDeleted &&
+      isArrowElement(candidate) &&
+      !!candidate.roundness &&
+      !candidate.elbowed,
+  );
+
+  if (!element) {
+    return null;
+  }
+
+  const elementsMap = arrayToMap(elements);
+  const transform = getSimpleArrowTransform(element, elementsMap);
+  const localDebugData = getSimpleArrowCurveDebugData(element.points, 0.5, {
+    elementId: element.id,
+  });
+  const debugData: SimpleArrowCurveDebugData<GlobalPoint> = {
+    ...localDebugData,
+    tangents: localDebugData.tangents.map((tangent) => ({
+      ...tangent,
+      point: transform.pointToGlobal(tangent.point as LocalPoint),
+      base: transform.vectorToGlobal(tangent.base),
+      autoScaled: transform.vectorToGlobal(tangent.autoScaled),
+      scaled: transform.vectorToGlobal(tangent.scaled),
+    })),
+    segments: localDebugData.segments.map((segment) => ({
+      ...segment,
+      start: transform.pointToGlobal(segment.start as LocalPoint),
+      end: transform.pointToGlobal(segment.end as LocalPoint),
+      baseCp1: transform.pointToGlobal(segment.baseCp1 as LocalPoint),
+      baseCp2: transform.pointToGlobal(segment.baseCp2 as LocalPoint),
+      cp1: transform.pointToGlobal(segment.cp1 as LocalPoint),
+      cp2: transform.pointToGlobal(segment.cp2 as LocalPoint),
+    })),
+  };
+  const handles = debugData.tangents.flatMap((tangent, pointIndex) => {
+    const descriptors: SimpleArrowHandleDescriptor[] = [];
+    const lengthRatio =
+      tangent.normalized.finalLengthVsMinNeighbor === null
+        ? "n/a"
+        : tangent.normalized.finalLengthVsMinNeighbor.toFixed(3);
+    const angleDelta = tangent.normalized.angleDelta.toFixed(3);
+    const title = `point ${pointIndex} · len/min ${lengthRatio} · dAngle ${angleDelta} · dblclick resets`;
+
+    if (pointIndex < debugData.tangents.length - 1) {
+      descriptors.push({
+        key: `${element.id}:${pointIndex}:out`,
+        elementId: element.id,
+        pointIndex,
+        direction: "outgoing",
+        point: tangent.point,
+        handle: pointFrom<GlobalPoint>(
+          tangent.point[0] + tangent.scaled[0] / 3,
+          tangent.point[1] + tangent.scaled[1] / 3,
+        ),
+        isOverridden: tangent.isOverridden,
+        title,
+      });
+    }
+
+    if (pointIndex > 0) {
+      descriptors.push({
+        key: `${element.id}:${pointIndex}:in`,
+        elementId: element.id,
+        pointIndex,
+        direction: "incoming",
+        point: tangent.point,
+        handle: pointFrom<GlobalPoint>(
+          tangent.point[0] - tangent.scaled[0] / 3,
+          tangent.point[1] - tangent.scaled[1] / 3,
+        ),
+        isOverridden: tangent.isOverridden,
+        title,
+      });
+    }
+
+    return descriptors;
+  });
+
+  return {
+    element,
+    debugData,
+    handles,
+  };
+};
+
+const getSelectedSimpleArrowDebugState = (
+  elements: readonly OrderedExcalidrawElement[],
+  appState: Pick<AppState, "selectedElementIds">,
+) => {
+  const selectedIds = Object.keys(appState.selectedElementIds);
+
+  if (selectedIds.length !== 1) {
+    return null;
+  }
+
+  return getSimpleArrowDebugStateForElement(elements, selectedIds[0]);
+};
+
+const renderSelectedSimpleArrowTangentOverlay = (
+  context: CanvasRenderingContext2D,
+  zoom: number,
+  debugState: SelectedSimpleArrowDebugState,
+) => {
+  context.save();
+  context.lineWidth = 1;
+
+  context.setLineDash([6, 4]);
+  context.strokeStyle = "rgba(134, 142, 150, 0.75)";
+
+  for (const segment of debugState.debugData.segments) {
+    context.beginPath();
+    context.moveTo(segment.start[0] * zoom, segment.start[1] * zoom);
+    context.lineTo(segment.baseCp1[0] * zoom, segment.baseCp1[1] * zoom);
+    context.lineTo(segment.baseCp2[0] * zoom, segment.baseCp2[1] * zoom);
+    context.lineTo(segment.end[0] * zoom, segment.end[1] * zoom);
+    context.stroke();
+  }
+
+  context.setLineDash([]);
+
+  for (const segment of debugState.debugData.segments) {
+    context.strokeStyle = segment.overshootsBaseline
+      ? "rgba(245, 159, 0, 0.9)"
+      : "rgba(94, 90, 216, 0.85)";
+
+    context.beginPath();
+    context.moveTo(segment.start[0] * zoom, segment.start[1] * zoom);
+    context.lineTo(segment.cp1[0] * zoom, segment.cp1[1] * zoom);
+    context.lineTo(segment.cp2[0] * zoom, segment.cp2[1] * zoom);
+    context.lineTo(segment.end[0] * zoom, segment.end[1] * zoom);
+    context.stroke();
+  }
+
+  for (const tangent of debugState.debugData.tangents) {
+    if (!tangent.isAdjusted) {
+      continue;
+    }
+
+    context.strokeStyle = tangent.isOverridden
+      ? "rgba(230, 73, 128, 0.95)"
+      : "rgba(201, 42, 42, 0.85)";
+    context.fillStyle = tangent.isOverridden
+      ? "rgba(230, 73, 128, 0.95)"
+      : "rgba(201, 42, 42, 0.95)";
+
+    fillCircle(
+      context,
+      tangent.point[0] * zoom,
+      tangent.point[1] * zoom,
+      3,
+      true,
+    );
+  }
+
+  context.restore();
+};
+
 const renderLine = (
   context: CanvasRenderingContext2D,
   zoom: number,
@@ -359,6 +625,13 @@ const _debugRenderer = (
   renderOrigin(context, appState.zoom.value);
   renderBindings(context, elements, appState.zoom.value);
 
+  const selectedSimpleArrowDebugState = areSimpleArrowTangentHandlesEnabled()
+    ? getSelectedSimpleArrowDebugState(elements, appState)
+    : null;
+
+  window.EXCALIDRAW_DEBUG_SELECTED_LINEAR_ARROW =
+    selectedSimpleArrowDebugState?.debugData;
+
   if (
     window.visualDebug?.currentFrame &&
     window.visualDebug?.data &&
@@ -375,6 +648,14 @@ const _debugRenderer = (
     });
   }
 
+  if (selectedSimpleArrowDebugState) {
+    renderSelectedSimpleArrowTangentOverlay(
+      context,
+      appState.zoom.value,
+      selectedSimpleArrowDebugState,
+    );
+  }
+
   if (window.visualDebug) {
     window.visualDebug!.data =
       window.visualDebug?.data.map((frame) =>
@@ -542,23 +823,324 @@ interface DebugCanvasProps {
 
 const DebugCanvas = React.forwardRef<HTMLCanvasElement, DebugCanvasProps>(
   ({ appState, scale }, ref) => {
-    const { width, height } = appState;
+    const excalidrawAPI = useExcalidrawAPI();
+    const [overlayState, setOverlayState] = useState<DebugCanvasOverlayState>(
+      () => pickOverlayState(appState),
+    );
+    const [selectedSimpleArrowDebugState, setSelectedSimpleArrowDebugState] =
+      useState<SelectedSimpleArrowDebugState | null>(null);
+    const dragStateRef = useRef<{
+      elementId: string;
+      pointIndex: number;
+      direction: SimpleArrowHandleDirection;
+    } | null>(null);
+
+    const syncSelectedSimpleArrowDebugState = useCallback(
+      (
+        nextAppState: AppState,
+        nextElements?: readonly OrderedExcalidrawElement[],
+      ) => {
+        if (!excalidrawAPI || excalidrawAPI.isDestroyed) {
+          return;
+        }
+
+        const elements =
+          nextElements ??
+          (excalidrawAPI.getSceneElements() as OrderedExcalidrawElement[]);
+
+        setOverlayState(pickOverlayState(nextAppState));
+
+        const nextDebugState = areSimpleArrowTangentHandlesEnabled()
+          ? getSelectedSimpleArrowDebugState(elements, nextAppState)
+          : null;
+
+        window.EXCALIDRAW_DEBUG_SELECTED_LINEAR_ARROW =
+          nextDebugState?.debugData;
+        setSelectedSimpleArrowDebugState(nextDebugState);
+      },
+      [excalidrawAPI],
+    );
+
+    useEffect(() => {
+      if (!excalidrawAPI || excalidrawAPI.isDestroyed) {
+        return;
+      }
+
+      syncSelectedSimpleArrowDebugState(excalidrawAPI.getAppState());
+
+      const unsubscribeChange = excalidrawAPI.onChange(
+        (elements, nextAppState) =>
+          syncSelectedSimpleArrowDebugState(
+            nextAppState,
+            elements as readonly OrderedExcalidrawElement[],
+          ),
+      );
+      const unsubscribeState = excalidrawAPI.onStateChange(
+        [
+          "selectedElementIds",
+          "zoom",
+          "scrollX",
+          "scrollY",
+          "offsetLeft",
+          "offsetTop",
+          "width",
+          "height",
+        ],
+        (_value, nextAppState) =>
+          syncSelectedSimpleArrowDebugState(nextAppState),
+      );
+
+      return () => {
+        unsubscribeChange();
+        unsubscribeState();
+      };
+    }, [excalidrawAPI, syncSelectedSimpleArrowDebugState]);
+
+    const rerenderSceneForSimpleArrowOverride = useCallback(() => {
+      if (!excalidrawAPI || excalidrawAPI.isDestroyed) {
+        return;
+      }
+
+      excalidrawAPI.updateScene({
+        elements: excalidrawAPI.getSceneElementsIncludingDeleted(),
+        captureUpdate: CaptureUpdateAction.NEVER,
+      });
+    }, [excalidrawAPI]);
+
+    const commitOverrideForHandle = useCallback(
+      (
+        handle: Pick<
+          SimpleArrowHandleDescriptor,
+          "elementId" | "pointIndex" | "direction"
+        >,
+        clientX: number,
+        clientY: number,
+      ) => {
+        if (!excalidrawAPI || excalidrawAPI.isDestroyed) {
+          return;
+        }
+
+        const nextAppState = excalidrawAPI.getAppState();
+        const nextElements =
+          excalidrawAPI.getSceneElements() as OrderedExcalidrawElement[];
+        const debugState = getSimpleArrowDebugStateForElement(
+          nextElements,
+          handle.elementId,
+        );
+
+        if (!debugState) {
+          return;
+        }
+
+        const scenePoint = viewportCoordsToSceneCoords(
+          { clientX, clientY },
+          nextAppState,
+        );
+        const tangent =
+          handle.direction === "outgoing"
+            ? ([
+                (scenePoint.x -
+                  debugState.debugData.tangents[handle.pointIndex].point[0]) *
+                  3,
+                (scenePoint.y -
+                  debugState.debugData.tangents[handle.pointIndex].point[1]) *
+                  3,
+              ] as [number, number])
+            : ([
+                (debugState.debugData.tangents[handle.pointIndex].point[0] -
+                  scenePoint.x) *
+                  3,
+                (debugState.debugData.tangents[handle.pointIndex].point[1] -
+                  scenePoint.y) *
+                  3,
+              ] as [number, number]);
+        const localTangent = getSimpleArrowTransform(
+          debugState.element,
+          arrayToMap(nextElements),
+        ).vectorToLocal(tangent);
+
+        setSimpleArrowTangentOverride(
+          debugState.element.id,
+          handle.pointIndex,
+          localTangent,
+        );
+        ShapeCache.delete(debugState.element);
+        rerenderSceneForSimpleArrowOverride();
+        syncSelectedSimpleArrowDebugState(nextAppState, nextElements);
+      },
+      [
+        excalidrawAPI,
+        rerenderSceneForSimpleArrowOverride,
+        syncSelectedSimpleArrowDebugState,
+      ],
+    );
+
+    const onPointerMove = useCallback(
+      (event: PointerEvent) => {
+        if (!dragStateRef.current) {
+          return;
+        }
+
+        event.preventDefault();
+        commitOverrideForHandle(
+          dragStateRef.current,
+          event.clientX,
+          event.clientY,
+        );
+      },
+      [commitOverrideForHandle],
+    );
+
+    const onPointerUp = useCallback(
+      (event: PointerEvent) => {
+        if (!dragStateRef.current) {
+          return;
+        }
+
+        event.preventDefault();
+        dragStateRef.current = null;
+        window.removeEventListener("pointermove", onPointerMove);
+        window.removeEventListener("pointerup", onPointerUp);
+        window.removeEventListener("pointercancel", onPointerUp);
+      },
+      [onPointerMove],
+    );
+
+    useEffect(() => {
+      return () => {
+        dragStateRef.current = null;
+        window.removeEventListener("pointermove", onPointerMove);
+        window.removeEventListener("pointerup", onPointerUp);
+        window.removeEventListener("pointercancel", onPointerUp);
+      };
+    }, [onPointerMove, onPointerUp]);
+
+    const handlePointerDown = useCallback(
+      (
+        handle: SimpleArrowHandleDescriptor,
+        event: React.PointerEvent<HTMLDivElement>,
+      ) => {
+        event.preventDefault();
+        event.stopPropagation();
+
+        dragStateRef.current = {
+          elementId: handle.elementId,
+          pointIndex: handle.pointIndex,
+          direction: handle.direction,
+        };
+
+        window.addEventListener("pointermove", onPointerMove, {
+          passive: false,
+        });
+        window.addEventListener("pointerup", onPointerUp, {
+          passive: false,
+        });
+        window.addEventListener("pointercancel", onPointerUp, {
+          passive: false,
+        });
+
+        commitOverrideForHandle(handle, event.clientX, event.clientY);
+      },
+      [commitOverrideForHandle, onPointerMove, onPointerUp],
+    );
+
+    const resetHandleOverride = useCallback(
+      (
+        handle: SimpleArrowHandleDescriptor,
+        event: React.MouseEvent<HTMLDivElement>,
+      ) => {
+        event.preventDefault();
+        event.stopPropagation();
+
+        if (!excalidrawAPI || excalidrawAPI.isDestroyed) {
+          return;
+        }
+
+        clearSimpleArrowTangentOverride(handle.elementId, handle.pointIndex);
+
+        const nextElements =
+          excalidrawAPI.getSceneElements() as OrderedExcalidrawElement[];
+        const element = nextElements.find(
+          (candidate): candidate is Ordered<ExcalidrawArrowElement> =>
+            candidate.id === handle.elementId &&
+            !candidate.isDeleted &&
+            isArrowElement(candidate),
+        );
+
+        if (element) {
+          ShapeCache.delete(element);
+          rerenderSceneForSimpleArrowOverride();
+        }
+
+        syncSelectedSimpleArrowDebugState(
+          excalidrawAPI.getAppState(),
+          nextElements,
+        );
+      },
+      [
+        excalidrawAPI,
+        rerenderSceneForSimpleArrowOverride,
+        syncSelectedSimpleArrowDebugState,
+      ],
+    );
+
+    const { width, height } = overlayState;
 
     return (
-      <canvas
-        style={{
-          width,
-          height,
-          position: "absolute",
-          zIndex: 2,
-          pointerEvents: "none",
-        }}
-        width={width * scale}
-        height={height * scale}
-        ref={ref}
-      >
-        Debug Canvas
-      </canvas>
+      <>
+        <canvas
+          style={{
+            width,
+            height,
+            position: "absolute",
+            inset: 0,
+            zIndex: 2,
+            pointerEvents: "none",
+          }}
+          width={width * scale}
+          height={height * scale}
+          ref={ref}
+        >
+          Debug Canvas
+        </canvas>
+        {selectedSimpleArrowDebugState?.handles.map((handle) => {
+          const { x, y } = sceneCoordsToViewportCoords(
+            {
+              sceneX: handle.handle[0],
+              sceneY: handle.handle[1],
+            },
+            overlayState,
+          );
+
+          return (
+            <div
+              key={handle.key}
+              title={handle.title}
+              onPointerDown={(event) => handlePointerDown(handle, event)}
+              onDoubleClick={(event) => resetHandleOverride(handle, event)}
+              style={{
+                position: "absolute",
+                left: x - overlayState.offsetLeft,
+                top: y - overlayState.offsetTop,
+                width: 12,
+                height: 12,
+                zIndex: 3,
+                borderRadius: handle.direction === "outgoing" ? "999px" : 3,
+                transform: "translate(-50%, -50%)",
+                background: handle.isOverridden
+                  ? "rgba(230, 73, 128, 0.95)"
+                  : handle.direction === "outgoing"
+                  ? "rgba(94, 90, 216, 0.95)"
+                  : "rgba(245, 159, 0, 0.95)",
+                border: "2px solid rgba(255,255,255,0.95)",
+                boxShadow: "0 0 0 1px rgba(0, 0, 0, 0.18)",
+                pointerEvents: "auto",
+                cursor: "grab",
+              }}
+            />
+          );
+        })}
+      </>
     );
   },
 );

excalidraw-app/data/LocalData.ts

@@ -26,6 +26,7 @@ import {
   get,
 } from "idb-keyval";
 
+import { appJotaiStore, atom } from "excalidraw-app/app-jotai";
 import { getNonDeletedElements } from "@excalidraw/element";
 
 import type { LibraryPersistedData } from "@excalidraw/excalidraw/data/library";
@@ -38,7 +39,6 @@ import type {
 } from "@excalidraw/excalidraw/types";
 import type { MaybePromise } from "@excalidraw/common/utility-types";
 
-import { appJotaiStore, atom } from "../app-jotai";
 import { SAVE_TO_LOCAL_STORAGE_TIMEOUT, STORAGE_KEYS } from "../app_constants";
 
 import { FileManager } from "./FileManager";

excalidraw-app/useHandleAppTheme.ts

@@ -1,4 +1,5 @@
 import { THEME } from "@excalidraw/excalidraw";
+import { EVENT, CODES, KEYS } from "@excalidraw/common";
 import { useEffect, useLayoutEffect, useState } from "react";
 
 import type { Theme } from "@excalidraw/element/types";
@@ -30,10 +31,28 @@ export const useHandleAppTheme = () => {
       mediaQuery?.addEventListener("change", handleChange);
     }
 
+    const handleKeydown = (event: KeyboardEvent) => {
+      if (
+        !event[KEYS.CTRL_OR_CMD] &&
+        event.altKey &&
+        event.shiftKey &&
+        event.code === CODES.D
+      ) {
+        event.preventDefault();
+        event.stopImmediatePropagation();
+        setAppTheme(editorTheme === THEME.DARK ? THEME.LIGHT : THEME.DARK);
+      }
+    };
+
+    document.addEventListener(EVENT.KEYDOWN, handleKeydown, { capture: true });
+
     return () => {
       mediaQuery?.removeEventListener("change", handleChange);
+      document.removeEventListener(EVENT.KEYDOWN, handleKeydown, {
+        capture: true,
+      });
     };
-  }, [appTheme]);
+  }, [appTheme, editorTheme, setAppTheme]);
 
   useLayoutEffect(() => {
     localStorage.setItem(STORAGE_KEYS.LOCAL_STORAGE_THEME, appTheme);

excalidraw-app/vite.config.mts

@@ -75,13 +75,6 @@ export default defineConfig(({ mode }) => {
           find: /^@excalidraw\/utils\/(.*?)/,
           replacement: path.resolve(__dirname, "../packages/utils/src/$1"),
         },
-        {
-          find: /^@excalidraw\/fractional-indexing$/,
-          replacement: path.resolve(
-            __dirname,
-            "../packages/fractional-indexing/src/index.ts",
-          ),
-        },
       ],
     },
     build: {

package.json

@@ -56,8 +56,7 @@
     "build:element": "yarn --cwd ./packages/element build:esm",
     "build:excalidraw": "yarn --cwd ./packages/excalidraw build:esm",
     "build:math": "yarn --cwd ./packages/math build:esm",
-    "build:fractional-indexing": "yarn --cwd ./packages/fractional-indexing build:esm",
-    "build:packages": "yarn build:common && yarn build:fractional-indexing && yarn build:math && yarn build:element && yarn build:excalidraw",
+    "build:packages": "yarn build:common && yarn build:math && yarn build:element && yarn build:excalidraw",
     "build:version": "yarn --cwd ./excalidraw-app build:version",
     "build": "yarn --cwd ./excalidraw-app build",
     "build:preview": "yarn --cwd ./excalidraw-app build:preview",

packages/common/src/colors.ts

@@ -80,11 +80,7 @@ const cssInvert = (
   return { r: invertedR, g: invertedG, b: invertedB };
 };
 
-export const applyDarkModeFilter = (color: string, enable = true): string => {
-  if (!enable) {
-    return color;
-  }
-
+export const applyDarkModeFilter = (color: string): string => {
   const cached = DARK_MODE_COLORS_CACHE?.get(color);
   if (cached) {
     return cached;

packages/common/src/constants.ts

@@ -337,10 +337,9 @@ export const MAX_DECIMALS_FOR_SVG_EXPORT = 2;
 export const EXPORT_SCALES = [1, 2, 3];
 export const DEFAULT_EXPORT_PADDING = 10; // px
 
-export const DEFAULT_IMAGE_OPTIONS: AppProps["imageOptions"] = {
-  maxWidthOrHeight: 1440,
-  maxFileSizeBytes: 4 * 1024 * 1024,
-};
+export const DEFAULT_MAX_IMAGE_WIDTH_OR_HEIGHT = 1440;
+
+export const MAX_ALLOWED_FILE_BYTES = 4 * 1024 * 1024;
 
 export const SVG_NS = "http://www.w3.org/2000/svg";
 export const SVG_DOCUMENT_PREAMBLE = `<?xml version="1.0" standalone="no"?>

packages/common/tests/binary-heap.test.ts

@@ -1,109 +0,0 @@
-import { BinaryHeap } from "../src/binary-heap";
-
-describe("BinaryHeap", () => {
-  const numberHeap = () => new BinaryHeap<number>((n) => n);
-
-  const drain = (heap: BinaryHeap<number>) => {
-    const out: number[] = [];
-    while (heap.size() > 0) {
-      out.push(heap.pop()!);
-    }
-    return out;
-  };
-
-  describe("empty heap", () => {
-    it("has size 0", () => {
-      expect(numberHeap().size()).toBe(0);
-    });
-
-    it("pop() returns null", () => {
-      expect(numberHeap().pop()).toBe(null);
-    });
-
-    it("remove() is a no-op and does not throw", () => {
-      const heap = numberHeap();
-      expect(() => heap.remove(1)).not.toThrow();
-      expect(heap.size()).toBe(0);
-    });
-  });
-
-  describe("push / pop", () => {
-    it("tracks size as items are added and removed", () => {
-      const heap = numberHeap();
-      [3, 1, 2].forEach((n) => heap.push(n));
-      expect(heap.size()).toBe(3);
-
-      heap.pop();
-      expect(heap.size()).toBe(2);
-    });
-
-    it("pops a single pushed element back out", () => {
-      const heap = numberHeap();
-      heap.push(42);
-      expect(heap.pop()).toBe(42);
-      expect(heap.pop()).toBe(null);
-    });
-
-    it("always pops the smallest score first", () => {
-      const heap = numberHeap();
-      [5, 3, 8, 1, 9, 2, 7].forEach((n) => heap.push(n));
-      expect(drain(heap)).toEqual([1, 2, 3, 5, 7, 8, 9]);
-    });
-
-    it("handles duplicate scores", () => {
-      const heap = numberHeap();
-      [4, 1, 4, 1, 2].forEach((n) => heap.push(n));
-      expect(drain(heap)).toEqual([1, 1, 2, 4, 4]);
-    });
-
-    it("maintains the heap invariant for a large adversarial (reverse-sorted) input", () => {
-      const heap = numberHeap();
-      // pushing in descending order forces a sift-up on every insert
-      const input = Array.from({ length: 1000 }, (_, i) => 1000 - i);
-      input.forEach((n) => heap.push(n));
-      expect(drain(heap)).toEqual([...input].sort((a, b) => a - b));
-    });
-  });
-
-  describe("remove", () => {
-    it("removes an interior element and keeps the rest ordered", () => {
-      const heap = numberHeap();
-      [5, 3, 8, 1, 9].forEach((n) => heap.push(n));
-
-      heap.remove(8);
-
-      expect(heap.size()).toBe(4);
-      expect(drain(heap)).toEqual([1, 3, 5, 9]);
-    });
-
-    it("can remove the current minimum", () => {
-      const heap = numberHeap();
-      [5, 3, 8, 1, 9].forEach((n) => heap.push(n));
-
-      heap.remove(1);
-
-      expect(heap.size()).toBe(4);
-      expect(heap.pop()).toBe(3);
-    });
-  });
-
-  describe("rescoreElement", () => {
-    type Node = { id: string; f: number };
-
-    it("re-sorts a node after its score is lowered", () => {
-      const heap = new BinaryHeap<Node>((node) => node.f);
-
-      const a = { id: "a", f: 10 };
-      const b = { id: "b", f: 20 };
-      const c = { id: "c", f: 30 };
-      [a, b, c].forEach((node) => heap.push(node));
-
-      c.f = 5;
-      heap.rescoreElement(c);
-
-      expect(heap.pop()).toBe(c);
-      expect(heap.pop()).toBe(a);
-      expect(heap.pop()).toBe(b);
-    });
-  });
-});

packages/element/package.json

@@ -64,7 +64,6 @@
   },
   "dependencies": {
     "@excalidraw/common": "0.18.0",
-    "@excalidraw/math": "0.18.0",
-    "@excalidraw/fractional-indexing": "3.3.0"
+    "@excalidraw/math": "0.18.0"
   }
 }

packages/element/src/Scene.ts

@@ -338,18 +338,27 @@ export class Scene {
     this.callbacks.clear();
   }
 
-  /** low-level - generally use app.insertNewElements() */
-  insertElementsAtIndex(
-    elements: ExcalidrawElement[],
-    /** null indicates end of the array */
-    index: number | null,
-  ) {
-    if (!elements.length) {
-      return;
+  insertElementAtIndex(element: ExcalidrawElement, index: number) {
+    if (!Number.isFinite(index) || index < 0) {
+      throw new Error(
+        "insertElementAtIndex can only be called with index >= 0",
+      );
     }
 
-    if (index === null) {
-      index = this.elements.length;
+    const nextElements = [
+      ...this.elements.slice(0, index),
+      element,
+      ...this.elements.slice(index),
+    ];
+
+    syncMovedIndices(nextElements, arrayToMap([element]));
+
+    this.replaceAllElements(nextElements);
+  }
+
+  insertElementsAtIndex(elements: ExcalidrawElement[], index: number) {
+    if (!elements.length) {
+      return;
     }
 
     if (!Number.isFinite(index) || index < 0) {
@@ -369,9 +378,24 @@ export class Scene {
     this.replaceAllElements(nextElements);
   }
 
-  /** low-level - generally use app.insertNewElement() */
   insertElement = (element: ExcalidrawElement) => {
-    this.insertElementsAtIndex([element], null);
+    const index = element.frameId
+      ? this.getElementIndex(element.frameId)
+      : this.elements.length;
+
+    this.insertElementAtIndex(element, index);
+  };
+
+  insertElements = (elements: ExcalidrawElement[]) => {
+    if (!elements.length) {
+      return;
+    }
+
+    const index = elements[0]?.frameId
+      ? this.getElementIndex(elements[0].frameId)
+      : this.elements.length;
+
+    this.insertElementsAtIndex(elements, index);
   };
 
   getElementIndex(elementId: string) {

packages/element/src/__tests__/__snapshots__/transform.test.ts.snap

@@ -1822,7 +1822,7 @@ exports[`Test Transform > should transform the elements correctly when linear el
   "versionNonce": Any<Number>,
   "verticalAlign": "middle",
   "width": 120,
-  "x": 187.75450000000004,
+  "x": 187.7545,
   "y": 44.5,
 }
 `;

packages/element/src/binding.ts

@@ -734,11 +734,12 @@ const getBindingStrategyForDraggingBindingElementEndpoints_simple = (
     });
 
   // Handle outside-outside binding to the same element
-  if (
-    otherBinding &&
-    otherBinding.elementId === hit?.id &&
-    (!opts?.newArrow || appState.selectedLinearElement?.initialState.origin)
-  ) {
+  if (otherBinding && otherBinding.elementId === hit?.id) {
+    invariant(
+      !opts?.newArrow || appState.selectedLinearElement?.initialState.origin,
+      "appState.selectedLinearElement.initialState.origin must be defined for new arrows",
+    );
+
     return {
       start: {
         mode: "inside",
@@ -1942,9 +1943,9 @@ export const calculateFixedPointForElbowArrowBinding = (
   return {
     fixedPoint: normalizeFixedPoint([
       (nonRotatedSnappedGlobalPoint[0] - hoveredElement.x) /
-        Math.max(hoveredElement.width, PRECISION),
+        hoveredElement.width,
       (nonRotatedSnappedGlobalPoint[1] - hoveredElement.y) /
-        Math.max(hoveredElement.height, PRECISION),
+        hoveredElement.height,
     ]),
   };
 };
@@ -1975,11 +1976,9 @@ export const calculateFixedPointForNonElbowArrowBinding = (
 
   // Calculate the ratio relative to the element's bounds
   const fixedPointX =
-    (nonRotatedPoint[0] - hoveredElement.x) /
-    Math.max(hoveredElement.width, PRECISION);
+    (nonRotatedPoint[0] - hoveredElement.x) / hoveredElement.width;
   const fixedPointY =
-    (nonRotatedPoint[1] - hoveredElement.y) /
-    Math.max(hoveredElement.height, PRECISION);
+    (nonRotatedPoint[1] - hoveredElement.y) / hoveredElement.height;
 
   return {
     fixedPoint: normalizeFixedPoint([fixedPointX, fixedPointY]),

packages/element/src/bounds.ts

@@ -1,4 +1,5 @@
 import rough from "roughjs/bin/rough";
+
 import {
   arrayToMap,
   type Bounds,
@@ -6,6 +7,7 @@ import {
   rescalePoints,
   sizeOf,
 } from "@excalidraw/common";
+
 import {
   degreesToRadians,
   lineSegment,
@@ -14,7 +16,9 @@ import {
   pointFromArray,
   pointRotateRads,
 } from "@excalidraw/math";
+
 import { getCurvePathOps } from "@excalidraw/utils/shape";
+
 import { pointsOnBezierCurves } from "points-on-curve";
 
 import type {
@@ -25,7 +29,9 @@ import type {
   LocalPoint,
   Radians,
 } from "@excalidraw/math";
+
 import type { AppState } from "@excalidraw/excalidraw/types";
+
 import type { Mutable } from "@excalidraw/common/utility-types";
 
 import { generateRoughOptions } from "./shape";
@@ -35,20 +41,18 @@ import { getBoundTextElement, getContainerElement } from "./textElement";
 import {
   isArrowElement,
   isBoundToContainer,
-  isFrameLikeElement,
   isFreeDrawElement,
   isLinearElement,
   isLineElement,
   isTextElement,
-  isExcalidrawElement,
 } from "./typeChecks";
+
 import { getElementShape } from "./shape";
+
 import {
   deconstructDiamondElement,
   deconstructRectanguloidElement,
 } from "./utils";
-import { intersectElementWithLineSegment } from "./collision";
-import { elementOverlapsWithFrame, getContainingFrame } from "./frame";
 
 import type { Drawable, Op } from "roughjs/bin/core";
 import type { Point as RoughPoint } from "roughjs/bin/geometry";
@@ -63,7 +67,6 @@ import type {
   ExcalidrawRectanguloidElement,
   ExcalidrawTextElementWithContainer,
   NonDeleted,
-  NonDeletedExcalidrawElement,
 } from "./types";
 
 export type RectangleBox = {
@@ -677,9 +680,8 @@ export const getMinMaxXYFromCurvePathOps = (
   return [minX, minY, maxX, maxY];
 };
 
-export const getBoundsFromPoints = <P extends GlobalPoint | LocalPoint>(
-  points: readonly P[],
-  padding: number = 0,
+export const getBoundsFromPoints = (
+  points: ExcalidrawFreeDrawElement["points"],
 ): Bounds => {
   let minX = Infinity;
   let minY = Infinity;
@@ -693,7 +695,7 @@ export const getBoundsFromPoints = <P extends GlobalPoint | LocalPoint>(
     maxY = Math.max(maxY, y);
   }
 
-  return [minX - padding, minY - padding, maxX + padding, maxY + padding];
+  return [minX, minY, maxX, maxY];
 };
 
 const getFreeDrawElementAbsoluteCoords = (
@@ -787,27 +789,41 @@ export const getArrowheadPoints = (
     p0 = pointFrom(prevOp.data[4], prevOp.data[5]);
   }
 
-  // B(t) = p0 * (1-t)^3 + 3p1 * t * (1-t)^2 + 3p2 * t^2 * (1-t) + p3 * t^3
-  const equation = (t: number, idx: number) =>
-    Math.pow(1 - t, 3) * p3[idx] +
-    3 * t * Math.pow(1 - t, 2) * p2[idx] +
-    3 * Math.pow(t, 2) * (1 - t) * p1[idx] +
-    p0[idx] * Math.pow(t, 3);
-
-  // Ee know the last point of the arrow (or the first, if start arrowhead).
+  // We know the last point of the arrow (or the first, if start arrowhead).
   const [x2, y2] = position === "start" ? p0 : p3;
 
-  // By using cubic bezier equation (B(t)) and the given parameters,
-  // we calculate a point that is closer to the last point.
-  // The value 0.3 is chosen arbitrarily and it works best for all
-  // the tested cases.
-  const [x1, y1] = [equation(0.3, 0), equation(0.3, 1)];
-
-  // Find the normalized direction vector based on the
-  // previously calculated points.
-  const distance = Math.hypot(x2 - x1, y2 - y1);
-  const nx = (x2 - x1) / distance;
-  const ny = (y2 - y1) / distance;
+  // Use the analytic tangent at the Bézier endpoint for a precise arrowhead
+  // direction. For a cubic Bézier B(t) with control points p0p3:
+  //   B'(1): (p3 − p2) tangent at the end
+  //   B'(0): (p1 − p0) for start arrowhead, arrow points away: (p0 − p1)
+  let dx: number;
+  let dy: number;
+  if (position === "end") {
+    dx = p3[0] - p2[0];
+    dy = p3[1] - p2[1];
+    if (Math.hypot(dx, dy) < 1e-6) {
+      dx = p3[0] - p1[0];
+      dy = p3[1] - p1[1];
+    }
+    if (Math.hypot(dx, dy) < 1e-6) {
+      dx = p3[0] - p0[0];
+      dy = p3[1] - p0[1];
+    }
+  } else {
+    dx = p0[0] - p1[0];
+    dy = p0[1] - p1[1];
+    if (Math.hypot(dx, dy) < 1e-6) {
+      dx = p0[0] - p2[0];
+      dy = p0[1] - p2[1];
+    }
+    if (Math.hypot(dx, dy) < 1e-6) {
+      dx = p0[0] - p3[0];
+      dy = p0[1] - p3[1];
+    }
+  }
+  const distance = Math.hypot(dx, dy);
+  const nx = dx / distance;
+  const ny = dy / distance;
 
   const size = getArrowheadSize(arrowhead);
 
@@ -1259,17 +1275,6 @@ export const pointInsideBounds = <P extends GlobalPoint | LocalPoint>(
 ): boolean =>
   p[0] > bounds[0] && p[0] < bounds[2] && p[1] > bounds[1] && p[1] < bounds[3];
 
-// TODO make pointInsideBounds inclusive and remove this function once we
-// test nothing is breaking
-export const pointInsideBoundsInclusive = <P extends GlobalPoint | LocalPoint>(
-  p: P,
-  bounds: Bounds,
-): boolean =>
-  p[0] >= bounds[0] &&
-  p[0] <= bounds[2] &&
-  p[1] >= bounds[1] &&
-  p[1] <= bounds[3];
-
 export const doBoundsIntersect = (
   bounds1: Bounds | null,
   bounds2: Bounds | null,
@@ -1284,310 +1289,13 @@ export const doBoundsIntersect = (
   return minX1 < maxX2 && maxX1 > minX2 && minY1 < maxY2 && maxY1 > minY2;
 };
 
-export const boundsContainBounds = (outerBounds: Bounds, innerBounds: Bounds) =>
-  [
-    pointFrom<GlobalPoint>(innerBounds[0], innerBounds[1]),
-    pointFrom<GlobalPoint>(innerBounds[0], innerBounds[3]),
-    pointFrom<GlobalPoint>(innerBounds[2], innerBounds[1]),
-    pointFrom<GlobalPoint>(innerBounds[2], innerBounds[3]),
-  ].every((point) => pointInsideBoundsInclusive(point, outerBounds));
-
-/**
- * High level helper to get elements overlapping a bounding box.
- * It can be used to get elements overlapping a selection box, for example.
- *
- */
-export const elementsOverlappingBBox = ({
-  elements,
-  elementsMap,
-  bounds,
-  type,
-  excludeElementsInFrames,
-  shouldIgnoreElementFromSelection,
-}: {
-  elements: readonly NonDeletedExcalidrawElement[];
-  elementsMap?: ElementsMap;
-  bounds: Bounds | ExcalidrawElement;
-  /**
-   * - overlap: elements overlapping or inside bounds
-   * - contain: elements inside bounds
-   **/
-  type: "contain" | "overlap";
-  excludeElementsInFrames?: boolean;
-  shouldIgnoreElementFromSelection?: (
-    element: NonDeletedExcalidrawElement,
-  ) => boolean;
-}) => {
-  if (!elementsMap) {
-    elementsMap = arrayToMap(elements) as ElementsMap;
-  }
-  const selectionBounds = isExcalidrawElement(bounds)
-    ? getElementBounds(bounds, elementsMap)
-    : bounds;
-  const [selectionX1, selectionY1, selectionX2, selectionY2] = selectionBounds;
-  const selectionEdges = [
-    lineSegment<GlobalPoint>(
-      pointFrom(selectionX1, selectionY1),
-      pointFrom(selectionX2, selectionY1),
-    ),
-    lineSegment<GlobalPoint>(
-      pointFrom(selectionX2, selectionY1),
-      pointFrom(selectionX2, selectionY2),
-    ),
-    lineSegment<GlobalPoint>(
-      pointFrom(selectionX2, selectionY2),
-      pointFrom(selectionX1, selectionY2),
-    ),
-    lineSegment<GlobalPoint>(
-      pointFrom(selectionX1, selectionY2),
-      pointFrom(selectionX1, selectionY1),
-    ),
-  ];
-
-  const framesInSelection = excludeElementsInFrames
-    ? new Set<NonDeletedExcalidrawElement["id"]>()
-    : null;
-  const groups: Record<string, NonDeletedExcalidrawElement[]> = {};
-  const elementsInSelection: Set<NonDeletedExcalidrawElement> = new Set();
-
-  for (const element of elements) {
-    if (shouldIgnoreElementFromSelection?.(element)) {
-      continue;
-    }
-
-    // Track only selectable top-level group members, so ignored elements such
-    // as bound text and locked elements don't affect group selection.
-    const groupId = element.groupIds.at(-1);
-    if (groupId) {
-      if (!groups[groupId]) {
-        groups[groupId] = [];
-      }
-      groups[groupId].push(element);
-    }
-
-    const strokeWidth = element.strokeWidth;
-    let labelAABB: Bounds | null = null;
-    let elementAABB = getElementBounds(element, elementsMap);
-
-    elementAABB = [
-      elementAABB[0] - strokeWidth / 2,
-      elementAABB[1] - strokeWidth / 2,
-      elementAABB[2] + strokeWidth / 2,
-      elementAABB[3] + strokeWidth / 2,
-    ] as Bounds;
-
-    // Whether the element bounds should include the bound text element bounds
-    const boundTextElement =
-      isArrowElement(element) && getBoundTextElement(element, elementsMap);
-    if (boundTextElement) {
-      const { x, y } = LinearElementEditor.getBoundTextElementPosition(
-        element,
-        boundTextElement,
-        elementsMap,
-      );
-      labelAABB = [
-        x,
-        y,
-        x + boundTextElement.width,
-        y + boundTextElement.height,
-      ] as Bounds;
-    }
-
-    // Clip element bounds by its containing frame (if any), since only the
-    // visible (frame-clipped) portion of the element is relevant for selection.
-    const associatedFrame = getContainingFrame(element, elementsMap);
-    if (
-      associatedFrame &&
-      elementOverlapsWithFrame(element, associatedFrame, elementsMap)
-    ) {
-      const frameAABB = getElementBounds(associatedFrame, elementsMap);
-      elementAABB = [
-        Math.max(elementAABB[0], frameAABB[0]),
-        Math.max(elementAABB[1], frameAABB[1]),
-        Math.min(elementAABB[2], frameAABB[2]),
-        Math.min(elementAABB[3], frameAABB[3]),
-      ] as Bounds;
-
-      labelAABB = labelAABB
-        ? ([
-            Math.max(labelAABB[0], frameAABB[0]),
-            Math.max(labelAABB[1], frameAABB[1]),
-            Math.min(labelAABB[2], frameAABB[2]),
-            Math.min(labelAABB[3], frameAABB[3]),
-          ] as Bounds)
-        : null;
-    }
-
-    const commonAABB = labelAABB
-      ? ([
-          Math.min(labelAABB[0], elementAABB[0]),
-          Math.min(labelAABB[1], elementAABB[1]),
-          Math.max(labelAABB[2], elementAABB[2]),
-          Math.max(labelAABB[3], elementAABB[3]),
-        ] as Bounds)
-      : elementAABB;
-
-    // ============== Evaluation ==============
-
-    // 1. If the selection box WRAPs the element's AABB, then add it to the
-    //    selection and move on, regardless of the selection mode.
-    //
-    //    PERF: This trick only works with axis-aligned box selection and the
-    //          current convex element shapes!
-    if (boundsContainBounds(selectionBounds, commonAABB)) {
-      if (framesInSelection && isFrameLikeElement(element)) {
-        framesInSelection.add(element.id);
-      }
-      elementsInSelection.add(element);
-      continue;
-    }
-
-    // 2. Handle the case where the label is overlapped by the selection box
-    if (
-      type === "overlap" &&
-      labelAABB &&
-      doBoundsIntersect(selectionBounds, labelAABB)
-    ) {
-      elementsInSelection.add(element);
-      continue;
-    }
-
-    // 3. Handle the case where the selection is not wrapping the element, but
-    //    it does intersect the element's outline (non-AABB).
-    if (type === "overlap" && doBoundsIntersect(selectionBounds, elementAABB)) {
-      let hasIntersection = false;
-
-      // Preliminary check potential intersection imprecision
-      if (isLinearElement(element) || isFreeDrawElement(element)) {
-        const center = elementCenterPoint(element, elementsMap);
-        hasIntersection = element.points.some((point) => {
-          const rotatedPoint = pointRotateRads(
-            pointFrom<GlobalPoint>(element.x + point[0], element.y + point[1]),
-            center,
-            element.angle,
-          );
-
-          return pointInsideBounds(rotatedPoint, selectionBounds);
-        });
-      } else {
-        const nonRotatedElementBounds = getElementBounds(
-          element,
-          elementsMap,
-          true,
-        );
-        const center = elementCenterPoint(element, elementsMap);
-        hasIntersection = [
-          pointRotateRads(
-            pointFrom<GlobalPoint>(
-              (nonRotatedElementBounds[0] + nonRotatedElementBounds[2]) / 2,
-              nonRotatedElementBounds[1],
-            ),
-            center,
-            element.angle,
-          ),
-          pointRotateRads(
-            pointFrom<GlobalPoint>(
-              nonRotatedElementBounds[2],
-              (nonRotatedElementBounds[1] + nonRotatedElementBounds[3]) / 2,
-            ),
-            center,
-            element.angle,
-          ),
-          pointRotateRads(
-            pointFrom<GlobalPoint>(
-              (nonRotatedElementBounds[0] + nonRotatedElementBounds[2]) / 2,
-              nonRotatedElementBounds[3],
-            ),
-            center,
-            element.angle,
-          ),
-          pointRotateRads(
-            pointFrom<GlobalPoint>(
-              nonRotatedElementBounds[0],
-              (nonRotatedElementBounds[1] + nonRotatedElementBounds[3]) / 2,
-            ),
-            center,
-            element.angle,
-          ),
-        ].some((point) => {
-          return pointInsideBounds(
-            pointRotateRads(point, center, element.angle),
-            selectionBounds,
-          );
-        });
-      }
-
-      if (!hasIntersection) {
-        hasIntersection = selectionEdges.some(
-          (selectionEdge) =>
-            intersectElementWithLineSegment(
-              element,
-              elementsMap,
-              selectionEdge,
-              strokeWidth / 2,
-              true, // Stop at first hit for better performance
-            ).length > 0,
-        );
-      }
-
-      if (hasIntersection) {
-        if (framesInSelection && isFrameLikeElement(element)) {
-          framesInSelection.add(element.id);
-        }
-
-        elementsInSelection.add(element);
-        continue;
-      }
-    }
-
-    // 4. We don't need to handle when the selection is inside the element
-    //    as it is separately handled in App.
-  }
-
-  if (framesInSelection) {
-    elementsInSelection.forEach((element) => {
-      if (element.frameId && framesInSelection.has(element.frameId)) {
-        elementsInSelection.delete(element);
-      }
-    });
-  }
-
-  if (type === "overlap") {
-    Array.from(elementsInSelection).forEach((element) => {
-      const groupId = element.groupIds.at(-1);
-      const group = groupId ? groups[groupId] : null;
-
-      group?.forEach((groupElement) => elementsInSelection.add(groupElement));
-    });
-  } else if (type === "contain") {
-    elementsInSelection.forEach((element) => {
-      // note: currently we only support top-level group handling since
-      // we don't support box selecting while editing the group/subgroup
-      // see https://github.com/excalidraw/excalidraw/pull/11234#issuecomment-4387654451
-      const groupId = element.groupIds.at(-1);
-
-      const group = groupId ? groups[groupId] : null;
-
-      if (
-        group &&
-        !group.every((groupElement) => elementsInSelection.has(groupElement))
-      ) {
-        elementsInSelection.delete(element);
-      }
-    });
-  }
-
-  // to maintain original order elements (namely for group selection)
-  return elements.filter((element) => elementsInSelection.has(element));
-};
-
 export const elementCenterPoint = (
   element: ExcalidrawElement,
   elementsMap: ElementsMap,
   xOffset: number = 0,
   yOffset: number = 0,
 ) => {
-  if (isLinearElement(element) || isFreeDrawElement(element)) {
+  if (isLinearElement(element)) {
     const [x1, y1, x2, y2] = getElementAbsoluteCoords(element, elementsMap);
     const [x, y] = pointFrom<GlobalPoint>((x1 + x2) / 2, (y1 + y2) / 2);
 

packages/element/src/collision.ts

@@ -61,8 +61,6 @@ import { distanceToElement } from "./distance";
 
 import { getBindingGap } from "./binding";
 
-import { hasBackground } from "./comparisons";
-
 import type {
   ElementsMap,
   ExcalidrawArrowElement,
@@ -85,7 +83,7 @@ export const shouldTestInside = (element: ExcalidrawElement) => {
   }
 
   const isDraggableFromInside =
-    (hasBackground(element.type) && !isTransparent(element.backgroundColor)) ||
+    !isTransparent(element.backgroundColor) ||
     hasBoundTextElement(element) ||
     isIframeLikeElement(element) ||
     isTextElement(element);
@@ -156,11 +154,14 @@ export const hitElementItself = ({
 
   // Hit test against the extended, rotated bounding box of the element first
   const bounds = getElementBounds(element, elementsMap, true);
-  const hitBounds = isPointInRotatedBounds(
-    point,
-    bounds,
-    element.angle,
-    threshold,
+  const hitBounds = isPointWithinBounds(
+    pointFrom(bounds[0] - threshold, bounds[1] - threshold),
+    pointRotateRads(
+      point,
+      getCenterForBounds(bounds),
+      -element.angle as Radians,
+    ),
+    pointFrom(bounds[2] + threshold, bounds[3] + threshold),
   );
 
   // PERF: Bail out early if the point is not even in the
@@ -191,32 +192,18 @@ export const hitElementItself = ({
   return result;
 };
 
-const isPointInRotatedBounds = (
-  point: GlobalPoint,
-  bounds: Bounds,
-  angle: Radians,
-  tolerance = 0,
-) => {
-  const adjustedPoint =
-    angle === 0
-      ? point
-      : pointRotateRads(point, getCenterForBounds(bounds), -angle as Radians);
-
-  return isPointWithinBounds(
-    pointFrom(bounds[0] - tolerance, bounds[1] - tolerance),
-    adjustedPoint,
-    pointFrom(bounds[2] + tolerance, bounds[3] + tolerance),
-  );
-};
-
 export const hitElementBoundingBox = (
   point: GlobalPoint,
   element: ExcalidrawElement,
   elementsMap: ElementsMap,
   tolerance = 0,
 ) => {
-  const bounds = getElementBounds(element, elementsMap, true);
-  return isPointInRotatedBounds(point, bounds, element.angle, tolerance);
+  let [x1, y1, x2, y2] = getElementBounds(element, elementsMap);
+  x1 -= tolerance;
+  y1 -= tolerance;
+  x2 += tolerance;
+  y2 += tolerance;
+  return isPointWithinBounds(pointFrom(x1, y1), point, pointFrom(x2, y2));
 };
 
 export const hitElementBoundingBoxOnly = (
@@ -326,10 +313,7 @@ export const getAllHoveredElementAtPoint = (
     ) {
       candidateElements.push(element);
 
-      if (
-        hasBackground(element.type) &&
-        !isTransparent(element.backgroundColor)
-      ) {
+      if (!isTransparent(element.backgroundColor)) {
         break;
       }
     }
@@ -481,12 +465,7 @@ export const intersectElementWithLineSegment = (
     case "line":
     case "freedraw":
     case "arrow":
-      return intersectLinearOrFreeDrawWithLineSegment(
-        element,
-        line,
-        elementsMap,
-        onlyFirst,
-      );
+      return intersectLinearOrFreeDrawWithLineSegment(element, line, onlyFirst);
   }
 };
 
@@ -553,15 +532,11 @@ const lineIntersections = (
 const intersectLinearOrFreeDrawWithLineSegment = (
   element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement,
   segment: LineSegment<GlobalPoint>,
-  elementsMap: ElementsMap,
   onlyFirst = false,
 ): GlobalPoint[] => {
   // NOTE: This is the only one which return the decomposed elements
   // rotated! This is due to taking advantage of roughjs definitions.
-  const [lines, curves] = deconstructLinearOrFreeDrawElement(
-    element,
-    elementsMap,
-  );
+  const [lines, curves] = deconstructLinearOrFreeDrawElement(element);
   const intersections: GlobalPoint[] = [];
 
   for (const l of lines) {
@@ -589,9 +564,7 @@ const intersectLinearOrFreeDrawWithLineSegment = (
       continue;
     }
 
-    const hits = curveIntersectLineSegment(c, segment, {
-      iterLimit: 10,
-    });
+    const hits = curveIntersectLineSegment(c, segment);
 
     if (hits.length > 0) {
       intersections.push(...hits);

packages/element/src/distance.ts

@@ -48,7 +48,7 @@ export const distanceToElement = (
     case "line":
     case "arrow":
     case "freedraw":
-      return distanceToLinearOrFreeDraElement(element, elementsMap, p);
+      return distanceToLinearOrFreeDraElement(element, p);
   }
 };
 
@@ -133,13 +133,9 @@ const distanceToEllipseElement = (
 
 const distanceToLinearOrFreeDraElement = (
   element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement,
-  elementsMap: ElementsMap,
   p: GlobalPoint,
 ) => {
-  const [lines, curves] = deconstructLinearOrFreeDrawElement(
-    element,
-    elementsMap,
-  );
+  const [lines, curves] = deconstructLinearOrFreeDrawElement(element);
   return Math.min(
     ...lines.map((s) => distanceToLineSegment(p, s)),
     ...curves.map((a) => curvePointDistance(a, p)),

packages/element/src/duplicate.ts

@@ -111,9 +111,6 @@ export const duplicateElements = (
          * user interaction.
          */
         type: "everything";
-        // TODO remove/review this once we add frame children order migration
-        // and invariant checks
-        preserveFrameChildrenOrder?: boolean;
       }
     | {
         /**
@@ -173,8 +170,6 @@ export const duplicateElements = (
     opts.type === "in-place"
       ? opts.idsOfElementsToDuplicate
       : new Map(elements.map((el) => [el.id, el]));
-  const preserveFrameChildrenOrder =
-    opts.type === "everything" && opts.preserveFrameChildrenOrder;
 
   // For sanity
   if (opts.type === "in-place") {
@@ -255,9 +250,6 @@ export const duplicateElements = (
     elementsWithDuplicates.splice(index + 1, 0, ...castArray(elements));
   };
 
-  // main
-  // ---------------------------------------------------------------------------
-
   const frameIdsToDuplicate = new Set(
     elements
       .filter(
@@ -282,7 +274,7 @@ export const duplicateElements = (
     if (groupId) {
       const groupElements = getElementsInGroup(elements, groupId).flatMap(
         (element) =>
-          isFrameLikeElement(element) && !preserveFrameChildrenOrder
+          isFrameLikeElement(element)
             ? [...getFrameChildren(elements, element.id), element]
             : [element],
       );
@@ -298,25 +290,13 @@ export const duplicateElements = (
     // frame duplication
     // -------------------------------------------------------------------------
 
-    if (
-      !preserveFrameChildrenOrder &&
-      element.frameId &&
-      frameIdsToDuplicate.has(element.frameId)
-    ) {
+    if (element.frameId && frameIdsToDuplicate.has(element.frameId)) {
       continue;
     }
 
     if (isFrameLikeElement(element)) {
       const frameId = element.id;
 
-      if (preserveFrameChildrenOrder) {
-        insertBeforeOrAfterIndex(
-          findLastIndex(elementsWithDuplicates, (el) => el.id === frameId),
-          copyElements(element),
-        );
-        continue;
-      }
-
       const frameChildren = getFrameChildren(elements, frameId);
 
       const targetIndex = findLastIndex(elementsWithDuplicates, (el) => {

packages/element/src/elbowArrow.ts

@@ -2124,8 +2124,8 @@ const normalizeArrowElementUpdate = (
     offsetY < -MAX_POS ||
     offsetY > MAX_POS ||
     offsetX + points[points.length - 1][0] < -MAX_POS ||
-    offsetX + points[points.length - 1][0] > MAX_POS ||
-    offsetY + points[points.length - 1][1] < -MAX_POS ||
+    offsetY + points[points.length - 1][0] > MAX_POS ||
+    offsetX + points[points.length - 1][1] < -MAX_POS ||
     offsetY + points[points.length - 1][1] > MAX_POS
   ) {
     console.error(

packages/element/src/fractionalIndex.ts

@@ -1,9 +1,6 @@
-import { arrayToMap } from "@excalidraw/common";
+import { generateNKeysBetween } from "fractional-indexing";
 
-import {
-  validateOrderKey,
-  generateNKeysBetween,
-} from "@excalidraw/fractional-indexing";
+import { arrayToMap } from "@excalidraw/common";
 
 import { mutateElement, newElementWith } from "./mutateElement";
 import { getBoundTextElement } from "./textElement";
@@ -385,13 +382,6 @@ const isValidFractionalIndex = (
     return false;
   }
 
-  try {
-    // Format validation
-    validateOrderKey(index);
-  } catch {
-    return false;
-  }
-
   if (predecessor && successor) {
     return predecessor < index && index < successor;
   }

packages/element/src/frame.ts

@@ -1,9 +1,7 @@
 import { arrayToMap } from "@excalidraw/common";
-import {
-  isPointWithinBounds,
-  pointFrom,
-  segmentsIntersectAt,
-} from "@excalidraw/math";
+import { isPointWithinBounds, pointFrom } from "@excalidraw/math";
+import { doLineSegmentsIntersect } from "@excalidraw/utils/bbox";
+import { elementsOverlappingBBox } from "@excalidraw/utils/withinBounds";
 
 import type {
   AppClassProperties,
@@ -20,13 +18,9 @@ import {
   getElementLineSegments,
   getCommonBounds,
   getElementAbsoluteCoords,
-  doBoundsIntersect,
-  getElementBounds,
-  boundsContainBounds,
 } from "./bounds";
 import { mutateElement } from "./mutateElement";
 import { getBoundTextElement, getContainerElement } from "./textElement";
-import { syncMovedIndices } from "./fractionalIndex";
 import {
   isFrameElement,
   isFrameLikeElement,
@@ -81,7 +75,7 @@ export function isElementIntersectingFrame(
 
   const intersecting = frameLineSegments.some((frameLineSegment) =>
     elementLineSegments.some((elementLineSegment) =>
-      segmentsIntersectAt(frameLineSegment, elementLineSegment),
+      doLineSegmentsIntersect(frameLineSegment, elementLineSegment),
     ),
   );
 
@@ -106,9 +100,8 @@ export const isElementContainingFrame = (
   frame: ExcalidrawFrameLikeElement,
   elementsMap: ElementsMap,
 ) => {
-  return boundsContainBounds(
-    getElementBounds(element, elementsMap),
-    getElementBounds(frame, elementsMap),
+  return getElementsWithinSelection([frame], element, elementsMap).some(
+    (e) => e.id === frame.id,
   );
 };
 
@@ -495,44 +488,10 @@ export const filterElementsEligibleAsFrameChildren = (
   return eligibleElements;
 };
 
-export const getCommonFrameId = (elements: readonly ExcalidrawElement[]) => {
-  let commonFrameId: ExcalidrawElement["frameId"] | undefined;
-
-  for (const element of elements) {
-    if (isFrameLikeElement(element) || !element.frameId) {
-      return null;
-    }
-
-    if (commonFrameId === undefined) {
-      commonFrameId = element.frameId;
-    } else if (commonFrameId !== element.frameId) {
-      return null;
-    }
-  }
-
-  return commonFrameId ?? null;
-};
-
-export const getFrameChildrenInsertionIndex = (
-  elements: readonly ExcalidrawElement[],
-  frameId: ExcalidrawFrameLikeElement["id"],
-): number | null => {
-  for (let index = elements.length - 1; index >= 0; index--) {
-    const element = elements[index];
-
-    if (element.id === frameId) {
-      return index;
-    } else if (element.frameId === frameId) {
-      return index + 1;
-    }
-  }
-
-  return null;
-};
-
 /**
- * Adds elements and their bound elements to frame. Reorders added elements to
- * be just below frame, or just above its highest child (whichever is higher).
+ * Retains (or repairs for target frame) the ordering invriant where children
+ * elements come right before the parent frame:
+ * [el, el, child, child, frame, el]
  *
  * @returns mutated allElements (same data structure)
  */
@@ -540,11 +499,19 @@ export const addElementsToFrame = <T extends ElementsMapOrArray>(
   allElements: T,
   elementsToAdd: NonDeletedExcalidrawElement[],
   frame: ExcalidrawFrameLikeElement,
+  appState: AppState,
 ): T => {
   const elementsMap = arrayToMap(allElements);
-  const commonFrameId = getCommonFrameId(elementsToAdd);
+  const currTargetFrameChildrenMap = new Map<ExcalidrawElement["id"], true>();
+  for (const element of allElements.values()) {
+    if (element.frameId === frame.id) {
+      currTargetFrameChildrenMap.set(element.id, true);
+    }
+  }
 
-  const finalElementsToAdd = new Set<ExcalidrawElement>();
+  const suppliedElementsToAddSet = new Set(elementsToAdd.map((el) => el.id));
+
+  const finalElementsToAdd: ExcalidrawElement[] = [];
 
   const otherFrames = new Set<ExcalidrawFrameLikeElement["id"]>();
 
@@ -555,8 +522,7 @@ export const addElementsToFrame = <T extends ElementsMapOrArray>(
   }
 
   // - add bound text elements if not already in the array
-  // - keep elements already in the frame so mixed selections can be reordered
-  //   together
+  // - filter out elements that are already in the frame
   for (const element of omitGroupsContainingFrameLikes(
     allElements,
     elementsToAdd,
@@ -569,64 +535,38 @@ export const addElementsToFrame = <T extends ElementsMapOrArray>(
       continue;
     }
 
-    finalElementsToAdd.add(element);
+    // if the element is already in another frame (which is also in elementsToAdd),
+    // it means that frame and children are selected at the same time
+    // => keep original frame membership, do not add to the target frame
+    if (
+      element.frameId &&
+      appState.selectedElementIds[element.id] &&
+      appState.selectedElementIds[element.frameId]
+    ) {
+      continue;
+    }
+
+    if (!currTargetFrameChildrenMap.has(element.id)) {
+      finalElementsToAdd.push(element);
+    }
 
     const boundTextElement = getBoundTextElement(element, elementsMap);
-    if (boundTextElement && !finalElementsToAdd.has(boundTextElement)) {
-      finalElementsToAdd.add(boundTextElement);
+    if (
+      boundTextElement &&
+      !suppliedElementsToAddSet.has(boundTextElement.id) &&
+      !currTargetFrameChildrenMap.has(boundTextElement.id)
+    ) {
+      finalElementsToAdd.push(boundTextElement);
     }
   }
 
   for (const element of finalElementsToAdd) {
-    // we don't always need to update the element if it's already in the frame,
-    // but we still need to accumulate in finalElementsToAdd so we potentially
-    // reorder them if added together
-    if (element.frameId !== frame.id) {
-      mutateElement(element, elementsMap, {
-        frameId: frame.id,
-      });
-    }
+    mutateElement(element, elementsMap, {
+      frameId: frame.id,
+    });
   }
 
-  // (re)order elements to be just below the frame,
-  // or just above the highest child if that is higher
-  // (latter case is denormalized order until we migrate)
-  // ---------------------------------------------------------------------------
-
-  if (
-    !finalElementsToAdd.size ||
-    // if all elements to add already belong to the frame, then we don't want to
-    // reorder (case: we're dragging element children within the frame)
-    commonFrameId === frame.id
-  ) {
-    return allElements;
-  }
-
-  const otherElements = Array.from(allElements.values()).filter(
-    (element) => !finalElementsToAdd.has(element),
-  );
-  const insertionIndex = getFrameChildrenInsertionIndex(
-    otherElements,
-    frame.id,
-  );
-
-  if (insertionIndex === null) {
-    return allElements;
-  }
-
-  const reorderedElements = [
-    ...otherElements.slice(0, insertionIndex),
-    ...finalElementsToAdd,
-    ...otherElements.slice(insertionIndex),
-  ];
-
-  syncMovedIndices(reorderedElements, arrayToMap([...finalElementsToAdd]));
-
-  return (
-    Array.isArray(allElements)
-      ? reorderedElements
-      : new Map(reorderedElements.map((element) => [element.id, element]))
-  ) as T;
+  return allElements;
 };
 
 export const removeElementsFromFrame = (
@@ -680,11 +620,13 @@ export const replaceAllElementsInFrame = <T extends ExcalidrawElement>(
   allElements: readonly T[],
   nextElementsInFrame: ExcalidrawElement[],
   frame: ExcalidrawFrameLikeElement,
+  app: AppClassProperties,
 ): T[] => {
   return addElementsToFrame(
     removeAllElementsFromFrame(allElements, frame),
     nextElementsInFrame,
     frame,
+    app.state,
   ).slice();
 };
 
@@ -978,17 +920,16 @@ export const getFrameLikeTitle = (element: ExcalidrawFrameLikeElement) => {
 export const getElementsOverlappingFrame = (
   elements: readonly ExcalidrawElement[],
   frame: ExcalidrawFrameLikeElement,
-  elementsMap: ElementsMap,
 ) => {
-  return elements.filter(
-    (el) =>
-      // exclude elements which are overlapping, but are in a different frame,
+  return (
+    elementsOverlappingBBox({
+      elements,
+      bounds: frame,
+      type: "overlap",
+    })
+      // removes elements who are overlapping, but are in a different frame,
       // and thus invisible in target frame
-      (!el.frameId || el.frameId === frame.id) &&
-      doBoundsIntersect(
-        getElementBounds(el, elementsMap),
-        getElementBounds(frame, elementsMap),
-      ),
+      .filter((el) => !el.frameId || el.frameId === frame.id)
   );
 };
 

packages/element/src/linearElementEditor.ts

@@ -476,22 +476,16 @@ export class LinearElementEditor {
       });
     }
 
-    if (
-      lastClickedPoint < 0 ||
-      !selectedPointsIndices.includes(lastClickedPoint) ||
-      !element.points[lastClickedPoint]
-    ) {
-      console.error(
-        `There must be a valid lastClickedPoint in order to drag it. selectedPointsIndices(${JSON.stringify(
-          selectedPointsIndices,
-        )}) points(0..${
-          element.points.length - 1
-        }) lastClickedPoint(${lastClickedPoint}) isElbowArrow: ${elbowed}`,
-      );
-
-      // Fall back to the actual last point as a last resort.
-      lastClickedPoint = element.points.length - 1;
-    }
+    invariant(
+      lastClickedPoint > -1 &&
+        selectedPointsIndices.includes(lastClickedPoint) &&
+        element.points[lastClickedPoint],
+      `There must be a valid lastClickedPoint in order to drag it. selectedPointsIndices(${JSON.stringify(
+        selectedPointsIndices,
+      )}) points(0..${
+        element.points.length - 1
+      }) lastClickedPoint(${lastClickedPoint})`,
+    );
 
     // point that's being dragged (out of all selected points)
     const draggingPoint = element.points[lastClickedPoint];
@@ -790,9 +784,20 @@ export class LinearElementEditor {
       elementsMap,
     );
 
+    // For curved (non-elbow) arrows the quadratic spline produces N-2 arcs
+    // for N anchor points. Cap the loop to the actual segment count so we
+    // don't request a midpoint for a segment that doesn't exist.
+    const [lines, segCurves] = deconstructLinearOrFreeDrawElement(element);
+    const segmentCount = lines.length + segCurves.length;
+
     let index = 0;
     const midpoints: (GlobalPoint | null)[] = [];
     while (index < points.length - 1) {
+      if (segmentCount > 0 && index >= segmentCount) {
+        midpoints.push(null);
+        index++;
+        continue;
+      }
       if (
         LinearElementEditor.isSegmentTooShort(
           element,
@@ -800,7 +805,6 @@ export class LinearElementEditor {
           element.points[index + 1],
           index,
           appState.zoom,
-          elementsMap,
         )
       ) {
         midpoints.push(null);
@@ -810,7 +814,6 @@ export class LinearElementEditor {
       const segmentMidPoint = LinearElementEditor.getSegmentMidPoint(
         element,
         index + 1,
-        elementsMap,
       );
       midpoints.push(segmentMidPoint);
       index++;
@@ -898,7 +901,6 @@ export class LinearElementEditor {
     endPoint: P,
     index: number,
     zoom: Zoom,
-    elementsMap: ElementsMap,
   ) {
     if (isElbowArrow(element)) {
       if (index >= 0 && index < element.points.length) {
@@ -913,10 +915,7 @@ export class LinearElementEditor {
 
     let distance = pointDistance(startPoint, endPoint);
     if (element.points.length > 2 && element.roundness) {
-      const [lines, curves] = deconstructLinearOrFreeDrawElement(
-        element,
-        elementsMap,
-      );
+      const [lines, curves] = deconstructLinearOrFreeDrawElement(element);
 
       invariant(
         lines.length === 0 && curves.length > 0,
@@ -936,7 +935,6 @@ export class LinearElementEditor {
   static getSegmentMidPoint(
     element: NonDeleted<ExcalidrawLinearElement>,
     index: number,
-    elementsMap: ElementsMap,
   ): GlobalPoint {
     if (isElbowArrow(element)) {
       invariant(
@@ -949,10 +947,7 @@ export class LinearElementEditor {
       return pointFrom<GlobalPoint>(element.x + p[0], element.y + p[1]);
     }
 
-    const [lines, curves] = deconstructLinearOrFreeDrawElement(
-      element,
-      elementsMap,
-    );
+    const [lines, curves] = deconstructLinearOrFreeDrawElement(element);
 
     invariant(
       (lines.length === 0 && curves.length > 0) ||
@@ -1867,7 +1862,6 @@ export class LinearElementEditor {
       const midSegmentMidpoint = LinearElementEditor.getSegmentMidPoint(
         element,
         index + 1,
-        elementsMap,
       );
 
       x = midSegmentMidpoint[0] - boundTextElement.width / 2;
@@ -2139,13 +2133,13 @@ const pointDraggingUpdates = (
 } => {
   const naiveDraggingPoints = new Map(
     selectedPointsIndices.map((pointIndex) => {
-      // NOTE: Avoid stale point index issue potentially caused by elbow
-      // arrows unpredictably changing the number of points during dragging
-      const point = element.points[pointIndex] ?? element.points.at(-1);
       return [
         pointIndex,
         {
-          point: pointFrom<LocalPoint>(point[0] + deltaX, point[1] + deltaY),
+          point: pointFrom<LocalPoint>(
+            element.points[pointIndex][0] + deltaX,
+            element.points[pointIndex][1] + deltaY,
+          ),
           isDragging: true,
         },
       ];
@@ -2417,7 +2411,7 @@ const pointDraggingUpdates = (
     ? nextArrow.points[0]
     : endBindable
     ? updateBoundPoint(
-        nextArrow,
+        element,
         "endBinding",
         nextArrow.endBinding,
         endBindable,
@@ -2448,7 +2442,7 @@ const pointDraggingUpdates = (
       ? endLocalPoint
       : startBindable
       ? updateBoundPoint(
-          nextArrow,
+          element,
           "startBinding",
           nextArrow.startBinding,
           startBindable,

packages/element/src/renderElement.ts

@@ -422,10 +422,10 @@ const drawElementOnCanvas = (
 
       for (const shape of shapes) {
         if (typeof shape === "string") {
-          context.fillStyle = applyDarkModeFilter(
-            element.strokeColor,
-            renderConfig.theme === THEME.DARK,
-          );
+          context.fillStyle =
+            renderConfig.theme === THEME.DARK
+              ? applyDarkModeFilter(element.strokeColor)
+              : element.strokeColor;
           context.fill(new Path2D(shape));
         } else {
           rc.draw(shape);
@@ -555,10 +555,10 @@ const drawElementOnCanvas = (
         context.canvas.setAttribute("dir", rtl ? "rtl" : "ltr");
         context.save();
         context.font = getFontString(element);
-        context.fillStyle = applyDarkModeFilter(
-          element.strokeColor,
-          renderConfig.theme === THEME.DARK,
-        );
+        context.fillStyle =
+          renderConfig.theme === THEME.DARK
+            ? applyDarkModeFilter(element.strokeColor)
+            : element.strokeColor;
         context.textAlign = element.textAlign as CanvasTextAlign;
 
         // Canvas does not support multiline text by default
@@ -811,10 +811,10 @@ export const renderElement = (
         context.fillStyle = "rgba(0, 0, 200, 0.04)";
 
         context.lineWidth = FRAME_STYLE.strokeWidth / appState.zoom.value;
-        context.strokeStyle = applyDarkModeFilter(
-          FRAME_STYLE.strokeColor,
-          appState.theme === THEME.DARK,
-        );
+        context.strokeStyle =
+          appState.theme === THEME.DARK
+            ? applyDarkModeFilter(FRAME_STYLE.strokeColor)
+            : FRAME_STYLE.strokeColor;
 
         // TODO change later to only affect AI frames
         if (isMagicFrameElement(element)) {

packages/element/src/selection.ts

@@ -1,12 +1,11 @@
-import { arrayToMap, isShallowEqual, type Bounds } from "@excalidraw/common";
+import { arrayToMap, isShallowEqual } from "@excalidraw/common";
 
 import type {
   AppState,
-  BoxSelectionMode,
   InteractiveCanvasAppState,
 } from "@excalidraw/excalidraw/types";
 
-import { elementsOverlappingBBox, getElementAbsoluteCoords } from "./bounds";
+import { getElementAbsoluteCoords, getElementBounds } from "./bounds";
 import { isElementInViewport } from "./sizeHelpers";
 import {
   isBoundToContainer,
@@ -14,7 +13,11 @@ import {
   isLinearElement,
   isTextElement,
 } from "./typeChecks";
-import { getFrameChildren } from "./frame";
+import {
+  elementOverlapsWithFrame,
+  getContainingFrame,
+  getFrameChildren,
+} from "./frame";
 
 import { LinearElementEditor } from "./linearElementEditor";
 import { selectGroupsForSelectedElements } from "./groups";
@@ -23,27 +26,10 @@ import type {
   ElementsMap,
   ElementsMapOrArray,
   ExcalidrawElement,
-  ExcalidrawFrameLikeElement,
   NonDeleted,
   NonDeletedExcalidrawElement,
 } from "./types";
 
-const shouldIgnoreElementFromSelection = (
-  element: NonDeletedExcalidrawElement,
-) => element.locked || isBoundToContainer(element);
-
-const excludeElementsFromFrames = <T extends ExcalidrawElement>(
-  selectedElements: readonly T[],
-  framesInSelection: Set<ExcalidrawFrameLikeElement["id"]>,
-) => {
-  return selectedElements.filter((element) => {
-    if (element.frameId && framesInSelection.has(element.frameId)) {
-      return false;
-    }
-    return true;
-  });
-};
-
 /**
  * Frames and their containing elements are not to be selected at the same time.
  * Given an array of selected elements, if there are frames and their containing elements
@@ -63,38 +49,68 @@ export const excludeElementsInFramesFromSelection = <
     }
   });
 
-  return excludeElementsFromFrames(selectedElements, framesInSelection);
+  return selectedElements.filter((element) => {
+    if (element.frameId && framesInSelection.has(element.frameId)) {
+      return false;
+    }
+    return true;
+  });
 };
 
 export const getElementsWithinSelection = (
   elements: readonly NonDeletedExcalidrawElement[],
   selection: NonDeletedExcalidrawElement,
   elementsMap: ElementsMap,
-  // TODO remove (this flag is effectively unused AFAIK)
   excludeElementsInFrames: boolean = true,
-  boxSelectionMode: BoxSelectionMode = "contain",
-): NonDeletedExcalidrawElement[] => {
-  const [selectionStartX, selectionStartY, selectionEndX, selectionEndY] =
+) => {
+  const [selectionX1, selectionY1, selectionX2, selectionY2] =
     getElementAbsoluteCoords(selection, elementsMap);
-  const selectionX1 = Math.min(selectionStartX, selectionEndX);
-  const selectionY1 = Math.min(selectionStartY, selectionEndY);
-  const selectionX2 = Math.max(selectionStartX, selectionEndX);
-  const selectionY2 = Math.max(selectionStartY, selectionEndY);
-  const selectionBounds = [
-    selectionX1,
-    selectionY1,
-    selectionX2,
-    selectionY2,
-  ] as Bounds;
 
-  return elementsOverlappingBBox({
-    elements,
-    bounds: selectionBounds,
-    elementsMap,
-    type: boxSelectionMode,
-    shouldIgnoreElementFromSelection,
-    excludeElementsInFrames,
+  let elementsInSelection = elements.filter((element) => {
+    let [elementX1, elementY1, elementX2, elementY2] = getElementBounds(
+      element,
+      elementsMap,
+    );
+
+    const containingFrame = getContainingFrame(element, elementsMap);
+    if (containingFrame) {
+      const [fx1, fy1, fx2, fy2] = getElementBounds(
+        containingFrame,
+        elementsMap,
+      );
+
+      elementX1 = Math.max(fx1, elementX1);
+      elementY1 = Math.max(fy1, elementY1);
+      elementX2 = Math.min(fx2, elementX2);
+      elementY2 = Math.min(fy2, elementY2);
+    }
+
+    return (
+      element.locked === false &&
+      element.type !== "selection" &&
+      !isBoundToContainer(element) &&
+      selectionX1 <= elementX1 &&
+      selectionY1 <= elementY1 &&
+      selectionX2 >= elementX2 &&
+      selectionY2 >= elementY2
+    );
   });
+
+  elementsInSelection = excludeElementsInFrames
+    ? excludeElementsInFramesFromSelection(elementsInSelection)
+    : elementsInSelection;
+
+  elementsInSelection = elementsInSelection.filter((element) => {
+    const containingFrame = getContainingFrame(element, elementsMap);
+
+    if (containingFrame) {
+      return elementOverlapsWithFrame(element, containingFrame, elementsMap);
+    }
+
+    return true;
+  });
+
+  return elementsInSelection;
 };
 
 export const getVisibleAndNonSelectedElements = (

packages/element/src/shape.ts

@@ -57,8 +57,8 @@ import { headingForPointIsHorizontal } from "./heading";
 
 import { canChangeRoundness } from "./comparisons";
 import {
-  elementCenterPoint,
   getArrowheadPoints,
+  getCenterForBounds,
   getDiamondPoints,
   getElementAbsoluteCoords,
 } from "./bounds";
@@ -218,7 +218,9 @@ export const generateRoughOptions = (
     fillWeight: element.strokeWidth / 2,
     hachureGap: element.strokeWidth * 4,
     roughness: adjustRoughness(element),
-    stroke: applyDarkModeFilter(element.strokeColor, isDarkMode),
+    stroke: isDarkMode
+      ? applyDarkModeFilter(element.strokeColor)
+      : element.strokeColor,
     preserveVertices:
       continuousPath || element.roughness < ROUGHNESS.cartoonist,
   };
@@ -232,7 +234,9 @@ export const generateRoughOptions = (
       options.fillStyle = element.fillStyle;
       options.fill = isTransparent(element.backgroundColor)
         ? undefined
-        : applyDarkModeFilter(element.backgroundColor, isDarkMode);
+        : isDarkMode
+        ? applyDarkModeFilter(element.backgroundColor)
+        : element.backgroundColor;
       if (element.type === "ellipse") {
         options.curveFitting = 1;
       }
@@ -245,7 +249,9 @@ export const generateRoughOptions = (
         options.fill =
           element.backgroundColor === "transparent"
             ? undefined
-            : applyDarkModeFilter(element.backgroundColor, isDarkMode);
+            : isDarkMode
+            ? applyDarkModeFilter(element.backgroundColor)
+            : element.backgroundColor;
       }
       return options;
     }
@@ -380,11 +386,12 @@ const getArrowheadShapes = (
     return [];
   }
 
-  const strokeColor = applyDarkModeFilter(element.strokeColor, isDarkMode);
-  const backgroundFillColor = applyDarkModeFilter(
-    canvasBackgroundColor,
-    isDarkMode,
-  );
+  const strokeColor = isDarkMode
+    ? applyDarkModeFilter(element.strokeColor)
+    : element.strokeColor;
+  const backgroundFillColor = isDarkMode
+    ? applyDarkModeFilter(canvasBackgroundColor)
+    : canvasBackgroundColor;
   const cardinalityOneOrManyOffset = -0.25;
   const cardinalityZeroCircleScale = 0.8;
 
@@ -576,11 +583,7 @@ const getArrowheadShapes = (
 
 export const generateLinearCollisionShape = (
   element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement,
-  elementsMap: ElementsMap,
-): {
-  op: string;
-  data: number[];
-}[] => {
+) => {
   const generator = new RoughGenerator();
   const options: Options = {
     seed: element.seed,
@@ -589,7 +592,20 @@ export const generateLinearCollisionShape = (
     roughness: 0,
     preserveVertices: true,
   };
-  const center = elementCenterPoint(element, elementsMap);
+  const center = getCenterForBounds(
+    // Need a non-rotated center point
+    element.points.reduce(
+      (acc, point) => {
+        return [
+          Math.min(element.x + point[0], acc[0]),
+          Math.min(element.y + point[1], acc[1]),
+          Math.max(element.x + point[0], acc[2]),
+          Math.max(element.y + point[1], acc[3]),
+        ];
+      },
+      [Infinity, Infinity, -Infinity, -Infinity],
+    ),
+  );
 
   switch (element.type) {
     case "line":
@@ -618,60 +634,34 @@ export const generateLinearCollisionShape = (
         });
       }
 
-      return generator
-        .curve(points as unknown as RoughPoint[], options)
-        .sets[0].ops.slice(0, element.points.length)
-        .map((op, i) => {
-          if (i === 0) {
-            const p = pointRotateRads<GlobalPoint>(
-              pointFrom<GlobalPoint>(
-                element.x + op.data[0],
-                element.y + op.data[1],
-              ),
-              center,
-              element.angle,
-            );
+      // Rotate the same cubic ops used for rendering so hit-testing matches the
+      // visible arrow path.
+      const rotateLocal = (lx: number, ly: number): LocalPoint => {
+        const g = pointRotateRads<GlobalPoint>(
+          pointFrom<GlobalPoint>(element.x + lx, element.y + ly),
+          center,
+          element.angle,
+        );
+        return pointFrom<LocalPoint>(g[0] - element.x, g[1] - element.y);
+      };
 
-            return {
-              op: "move",
-              data: pointFrom<LocalPoint>(p[0] - element.x, p[1] - element.y),
-            };
-          }
+      return generateSimpleArrowPathOps(points, 0.5, element.id).map((op) => {
+        if (op.op === "bcurveTo") {
+          const rcp1 = rotateLocal(op.data[0], op.data[1]);
+          const rcp2 = rotateLocal(op.data[2], op.data[3]);
+          const rend = rotateLocal(op.data[4], op.data[5]);
 
           return {
             op: "bcurveTo",
-            data: [
-              pointRotateRads(
-                pointFrom<GlobalPoint>(
-                  element.x + op.data[0],
-                  element.y + op.data[1],
-                ),
-                center,
-                element.angle,
-              ),
-              pointRotateRads(
-                pointFrom<GlobalPoint>(
-                  element.x + op.data[2],
-                  element.y + op.data[3],
-                ),
-                center,
-                element.angle,
-              ),
-              pointRotateRads(
-                pointFrom<GlobalPoint>(
-                  element.x + op.data[4],
-                  element.y + op.data[5],
-                ),
-                center,
-                element.angle,
-              ),
-            ]
-              .map((p) =>
-                pointFrom<LocalPoint>(p[0] - element.x, p[1] - element.y),
-              )
-              .flat(),
+            data: [rcp1[0], rcp1[1], rcp2[0], rcp2[1], rend[0], rend[1]],
           };
-        });
+        }
+
+        return {
+          op: op.op,
+          data: rotateLocal(op.data[0], op.data[1]),
+        };
+      });
     }
     case "freedraw": {
       if (element.points.length < 2) {
@@ -913,7 +903,12 @@ const _generateElementShape = (
           ];
         }
       } else {
-        shape = [generator.curve(points as unknown as RoughPoint[], options)];
+        shape = [
+          generator.path(
+            generateSimpleArrowShape(points, 0.5, element.id),
+            generateRoughOptions(element, true, isDarkMode),
+          ),
+        ];
       }
 
       // add lines only in arrow
@@ -997,10 +992,754 @@ const _generateElementShape = (
   }
 };
 
+type SimpleArrowPathOp =
+  | { op: "move" | "lineTo"; data: LocalPoint }
+  | { op: "bcurveTo"; data: [number, number, number, number, number, number] };
+
+const SIMPLE_ARROW_OVERSHOOT_EPSILON = 0.5;
+const SIMPLE_ARROW_SCALE_EPSILON = 1e-4;
+const SIMPLE_ARROW_SCALE_SEARCH_STEPS = 24;
+const SIMPLE_ARROW_SCALE_PASSES = 8;
+
+type SimpleArrowVector = [number, number];
+
+type SimpleArrowTangentOverrides = Record<
+  string,
+  Record<number, SimpleArrowVector>
+>;
+
+declare global {
+  interface Window {
+    EXCALIDRAW_DEBUG_LINEAR_ARROW_TANGENT_OVERRIDES?:
+      | SimpleArrowTangentOverrides
+      | undefined;
+  }
+}
+
+type SimpleArrowCurveDebugDataOptions = {
+  elementId?: string;
+};
+
+export type SimpleArrowCurveDebugData<
+  Point extends GlobalPoint | LocalPoint = LocalPoint,
+> = {
+  elementId?: string;
+  tangents: Array<{
+    point: Point;
+    base: SimpleArrowVector;
+    autoScaled: SimpleArrowVector;
+    scale: number;
+    autoScale: number;
+    scaled: SimpleArrowVector;
+    isAdjusted: boolean;
+    isOverridden: boolean;
+    normalized: {
+      baseLength: number;
+      autoLength: number;
+      finalLength: number;
+      prevSegmentLength: number | null;
+      nextSegmentLength: number | null;
+      minNeighborLength: number | null;
+      finalLengthVsMinNeighbor: number | null;
+      autoLengthVsMinNeighbor: number | null;
+      angleDelta: number;
+      turnAngle: number | null;
+    };
+  }>;
+  segments: Array<{
+    start: Point;
+    end: Point;
+    baseCp1: Point;
+    baseCp2: Point;
+    cp1: Point;
+    cp2: Point;
+    overshootsBaseline: boolean;
+    overshootsResolved: boolean;
+    metrics: {
+      chordLength: number;
+      baseStartProjection: number;
+      baseEndProjection: number;
+      finalStartProjection: number;
+      finalEndProjection: number;
+    };
+  }>;
+  inference: {
+    overriddenPointIndices: number[];
+  };
+};
+
+const SIMPLE_ARROW_ADJUSTMENT_EPSILON = 1e-3;
+
+const getSimpleArrowTangentOverrideStore = () => {
+  if (typeof window === "undefined") {
+    return null;
+  }
+
+  window.EXCALIDRAW_DEBUG_LINEAR_ARROW_TANGENT_OVERRIDES ??= {};
+  return window.EXCALIDRAW_DEBUG_LINEAR_ARROW_TANGENT_OVERRIDES;
+};
+
+export const setSimpleArrowTangentOverride = (
+  elementId: string,
+  pointIndex: number,
+  tangent: SimpleArrowVector,
+) => {
+  const store = getSimpleArrowTangentOverrideStore();
+
+  if (!store) {
+    return;
+  }
+
+  store[elementId] = {
+    ...(store[elementId] ?? {}),
+    [pointIndex]: [tangent[0], tangent[1]],
+  };
+};
+
+export const clearSimpleArrowTangentOverride = (
+  elementId: string,
+  pointIndex?: number,
+) => {
+  const store = getSimpleArrowTangentOverrideStore();
+
+  if (!store?.[elementId]) {
+    return;
+  }
+
+  if (typeof pointIndex === "number") {
+    delete store[elementId][pointIndex];
+
+    if (Object.keys(store[elementId]).length === 0) {
+      delete store[elementId];
+    }
+    return;
+  }
+
+  delete store[elementId];
+};
+
+const getSimpleArrowTangentOverrides = (elementId?: string) => {
+  if (!elementId) {
+    return null;
+  }
+
+  return getSimpleArrowTangentOverrideStore()?.[elementId] ?? null;
+};
+
+const getSimpleArrowVectorLength = ([x, y]: SimpleArrowVector) =>
+  Math.hypot(x, y);
+
+const normalizeSimpleArrowAngle = (angle: number) => {
+  let normalized = angle;
+
+  while (normalized <= -Math.PI) {
+    normalized += Math.PI * 2;
+  }
+  while (normalized > Math.PI) {
+    normalized -= Math.PI * 2;
+  }
+
+  return normalized;
+};
+
+const getSimpleArrowBezierValue = (
+  p0: number,
+  p1: number,
+  p2: number,
+  p3: number,
+  t: number,
+) => {
+  const mt = 1 - t;
+
+  return (
+    mt * mt * mt * p0 +
+    3 * mt * mt * t * p1 +
+    3 * mt * t * t * p2 +
+    t * t * t * p3
+  );
+};
+
+const doesSimpleArrowSegmentOvershoot = (
+  startProjection: number,
+  endProjection: number,
+  segmentLength: number,
+) => {
+  const a = -3 * startProjection + 3 * endProjection + segmentLength;
+  const b = 2 * (segmentLength - 2 * endProjection + startProjection);
+  const c = startProjection;
+  const candidateTs = [0, 1];
+
+  if (Math.abs(a) < 1e-8) {
+    if (Math.abs(b) >= 1e-8) {
+      candidateTs.push(-c / b);
+    }
+  } else {
+    const discriminant = b * b - 4 * a * c;
+
+    if (discriminant >= 0) {
+      const discriminantRoot = Math.sqrt(discriminant);
+      candidateTs.push((-b + discriminantRoot) / (2 * a));
+      candidateTs.push((-b - discriminantRoot) / (2 * a));
+    }
+  }
+
+  let minProjection = Infinity;
+  let maxProjection = -Infinity;
+
+  for (const t of candidateTs) {
+    if (t < 0 || t > 1) {
+      continue;
+    }
+
+    const projection = getSimpleArrowBezierValue(
+      0,
+      startProjection,
+      endProjection,
+      segmentLength,
+      t,
+    );
+
+    minProjection = Math.min(minProjection, projection);
+    maxProjection = Math.max(maxProjection, projection);
+  }
+
+  return (
+    minProjection < -SIMPLE_ARROW_OVERSHOOT_EPSILON ||
+    maxProjection > segmentLength + SIMPLE_ARROW_OVERSHOOT_EPSILON
+  );
+};
+
+const getSimpleArrowBaseTangents = <Point extends GlobalPoint | LocalPoint>(
+  points: readonly Point[],
+  tension: number,
+): [Float64Array, Float64Array] => {
+  const tx = new Float64Array(points.length);
+  const ty = new Float64Array(points.length);
+
+  for (let i = 0; i < points.length; i++) {
+    if (i === 0) {
+      const pbx = 3 * points[0][0] - 3 * points[1][0] + points[2][0];
+      const pby = 3 * points[0][1] - 3 * points[1][1] + points[2][1];
+      tx[i] = tension * (points[1][0] - pbx);
+      ty[i] = tension * (points[1][1] - pby);
+    } else if (i === points.length - 1) {
+      const pax =
+        3 * points[points.length - 1][0] -
+        3 * points[points.length - 2][0] +
+        points[points.length - 3][0];
+      const pay =
+        3 * points[points.length - 1][1] -
+        3 * points[points.length - 2][1] +
+        points[points.length - 3][1];
+      tx[i] = tension * (pax - points[points.length - 2][0]);
+      ty[i] = tension * (pay - points[points.length - 2][1]);
+    } else {
+      tx[i] = tension * (points[i + 1][0] - points[i - 1][0]);
+      ty[i] = tension * (points[i + 1][1] - points[i - 1][1]);
+    }
+  }
+
+  return [tx, ty];
+};
+
+const getSimpleArrowSegmentProjections = <
+  Point extends GlobalPoint | LocalPoint,
+>(
+  points: readonly Point[],
+  tangentX: Float64Array,
+  tangentY: Float64Array,
+  scales: Float64Array | undefined,
+  segmentIndex: number,
+  segmentScale = 1,
+) => {
+  const start = points[segmentIndex];
+  const end = points[segmentIndex + 1];
+  const segmentDx = end[0] - start[0];
+  const segmentDy = end[1] - start[1];
+  const segmentLength = Math.hypot(segmentDx, segmentDy);
+
+  if (!segmentLength) {
+    return {
+      segmentLength,
+      startProjection: 0,
+      endProjection: 0,
+    };
+  }
+
+  const segmentUx = segmentDx / segmentLength;
+  const segmentUy = segmentDy / segmentLength;
+  const startScale = scales?.[segmentIndex] ?? 1;
+  const endScale = scales?.[segmentIndex + 1] ?? 1;
+  const startProjection =
+    startScale *
+    segmentScale *
+    ((tangentX[segmentIndex] * segmentUx + tangentY[segmentIndex] * segmentUy) /
+      3);
+  const endProjection =
+    segmentLength -
+    endScale *
+      segmentScale *
+      ((tangentX[segmentIndex + 1] * segmentUx +
+        tangentY[segmentIndex + 1] * segmentUy) /
+        3);
+
+  return {
+    segmentLength,
+    startProjection,
+    endProjection,
+  };
+};
+
+const isSimpleArrowSegmentOvershooting = <
+  Point extends GlobalPoint | LocalPoint,
+>(
+  points: readonly Point[],
+  tangentX: Float64Array,
+  tangentY: Float64Array,
+  scales: Float64Array | undefined,
+  segmentIndex: number,
+  segmentScale = 1,
+) => {
+  const { segmentLength, startProjection, endProjection } =
+    getSimpleArrowSegmentProjections(
+      points,
+      tangentX,
+      tangentY,
+      scales,
+      segmentIndex,
+      segmentScale,
+    );
+
+  if (!segmentLength) {
+    return false;
+  }
+
+  return doesSimpleArrowSegmentOvershoot(
+    startProjection,
+    endProjection,
+    segmentLength,
+  );
+};
+
+const getSimpleArrowSegmentScale = <Point extends GlobalPoint | LocalPoint>(
+  points: readonly Point[],
+  tx: Float64Array,
+  ty: Float64Array,
+  scales: Float64Array,
+  segmentIndex: number,
+) => {
+  if (
+    !isSimpleArrowSegmentOvershooting(points, tx, ty, scales, segmentIndex, 1)
+  ) {
+    return 1;
+  }
+
+  let low = 0;
+  let high = 1;
+
+  for (let i = 0; i < SIMPLE_ARROW_SCALE_SEARCH_STEPS; i++) {
+    const mid = (low + high) / 2;
+    if (
+      isSimpleArrowSegmentOvershooting(
+        points,
+        tx,
+        ty,
+        scales,
+        segmentIndex,
+        mid,
+      )
+    ) {
+      high = mid;
+    } else {
+      low = mid;
+    }
+  }
+
+  return low;
+};
+
+const getSimpleArrowTangentScales = <Point extends GlobalPoint | LocalPoint>(
+  points: readonly Point[],
+  tx: Float64Array,
+  ty: Float64Array,
+) => {
+  const scales = new Float64Array(points.length);
+  scales.fill(1);
+
+  for (let pass = 0; pass < SIMPLE_ARROW_SCALE_PASSES; pass++) {
+    const nextScales = new Float64Array(scales);
+    let didChange = false;
+
+    for (
+      let segmentIndex = 0;
+      segmentIndex < points.length - 1;
+      segmentIndex++
+    ) {
+      if (
+        !isSimpleArrowSegmentOvershooting(points, tx, ty, scales, segmentIndex)
+      ) {
+        continue;
+      }
+
+      const segmentScale = getSimpleArrowSegmentScale(
+        points,
+        tx,
+        ty,
+        scales,
+        segmentIndex,
+      );
+
+      const nextStartScale = scales[segmentIndex] * segmentScale;
+      const nextEndScale = scales[segmentIndex + 1] * segmentScale;
+
+      if (
+        nextStartScale <
+        nextScales[segmentIndex] - SIMPLE_ARROW_SCALE_EPSILON
+      ) {
+        nextScales[segmentIndex] = nextStartScale;
+        didChange = true;
+      }
+
+      if (
+        nextEndScale <
+        nextScales[segmentIndex + 1] - SIMPLE_ARROW_SCALE_EPSILON
+      ) {
+        nextScales[segmentIndex + 1] = nextEndScale;
+        didChange = true;
+      }
+    }
+
+    if (!didChange) {
+      return scales;
+    }
+
+    scales.set(nextScales);
+  }
+
+  return scales;
+};
+
+const getSimpleArrowFinalTangents = (
+  tx: Float64Array,
+  ty: Float64Array,
+  scales: Float64Array,
+  elementId?: string,
+) => {
+  const finalX = new Float64Array(tx.length);
+  const finalY = new Float64Array(ty.length);
+
+  for (let i = 0; i < tx.length; i++) {
+    finalX[i] = tx[i] * scales[i];
+    finalY[i] = ty[i] * scales[i];
+  }
+
+  const overrides = getSimpleArrowTangentOverrides(elementId);
+
+  if (!overrides) {
+    return {
+      finalX,
+      finalY,
+      overriddenPointIndices: [] as number[],
+    };
+  }
+
+  const overriddenPointIndices: number[] = [];
+
+  for (const [indexKey, tangent] of Object.entries(overrides)) {
+    const index = Number(indexKey);
+
+    if (!Number.isInteger(index) || index < 0 || index >= finalX.length) {
+      continue;
+    }
+
+    finalX[index] = tangent[0];
+    finalY[index] = tangent[1];
+    overriddenPointIndices.push(index);
+  }
+
+  overriddenPointIndices.sort((a, b) => a - b);
+
+  return {
+    finalX,
+    finalY,
+    overriddenPointIndices,
+  };
+};
+
+export const getSimpleArrowCurveDebugData = <
+  Point extends GlobalPoint | LocalPoint,
+>(
+  points: readonly Point[],
+  tension = 0.5,
+  options?: SimpleArrowCurveDebugDataOptions,
+): SimpleArrowCurveDebugData<Point> => {
+  if (points.length < 2) {
+    return {
+      elementId: options?.elementId,
+      tangents: [],
+      segments: [],
+      inference: {
+        overriddenPointIndices: [],
+      },
+    };
+  }
+
+  if (points.length === 2) {
+    return {
+      elementId: options?.elementId,
+      tangents: points.map((point) => ({
+        point,
+        base: [0, 0],
+        autoScaled: [0, 0],
+        scale: 1,
+        autoScale: 1,
+        scaled: [0, 0],
+        isAdjusted: false,
+        isOverridden: false,
+        normalized: {
+          baseLength: 0,
+          autoLength: 0,
+          finalLength: 0,
+          prevSegmentLength: null,
+          nextSegmentLength: null,
+          minNeighborLength: null,
+          finalLengthVsMinNeighbor: null,
+          autoLengthVsMinNeighbor: null,
+          angleDelta: 0,
+          turnAngle: null,
+        },
+      })),
+      segments: [],
+      inference: {
+        overriddenPointIndices: [],
+      },
+    };
+  }
+
+  const [tx, ty] = getSimpleArrowBaseTangents(points, tension);
+  const scales = getSimpleArrowTangentScales(points, tx, ty);
+  const baselineScales = new Float64Array(points.length);
+  baselineScales.fill(1);
+  const { finalX, finalY, overriddenPointIndices } =
+    getSimpleArrowFinalTangents(tx, ty, scales, options?.elementId);
+
+  return {
+    elementId: options?.elementId,
+    tangents: points.map((point, index) => ({
+      point,
+      base: [tx[index], ty[index]],
+      autoScaled: [tx[index] * scales[index], ty[index] * scales[index]],
+      scale:
+        getSimpleArrowVectorLength([tx[index], ty[index]]) > 0
+          ? getSimpleArrowVectorLength([finalX[index], finalY[index]]) /
+            getSimpleArrowVectorLength([tx[index], ty[index]])
+          : 1,
+      autoScale: scales[index],
+      scaled: [finalX[index], finalY[index]],
+      isAdjusted:
+        Math.abs(scales[index] - 1) > SIMPLE_ARROW_ADJUSTMENT_EPSILON ||
+        Math.abs(
+          normalizeSimpleArrowAngle(
+            Math.atan2(finalY[index], finalX[index]) -
+              Math.atan2(ty[index], tx[index]),
+          ),
+        ) > SIMPLE_ARROW_ADJUSTMENT_EPSILON,
+      isOverridden: overriddenPointIndices.includes(index),
+      normalized: (() => {
+        const base = [tx[index], ty[index]] as SimpleArrowVector;
+        const autoScaled = [
+          tx[index] * scales[index],
+          ty[index] * scales[index],
+        ] as SimpleArrowVector;
+        const scaled = [finalX[index], finalY[index]] as SimpleArrowVector;
+        const baseLength = getSimpleArrowVectorLength(base);
+        const autoLength = getSimpleArrowVectorLength(autoScaled);
+        const finalLength = getSimpleArrowVectorLength(scaled);
+        const prevSegmentLength =
+          index > 0 ? pointDistance(points[index - 1], point) : null;
+        const nextSegmentLength =
+          index < points.length - 1
+            ? pointDistance(point, points[index + 1])
+            : null;
+        const minNeighborLength =
+          prevSegmentLength === null
+            ? nextSegmentLength
+            : nextSegmentLength === null
+            ? prevSegmentLength
+            : Math.min(prevSegmentLength, nextSegmentLength);
+        const turnAngle =
+          prevSegmentLength !== null && nextSegmentLength !== null
+            ? normalizeSimpleArrowAngle(
+                Math.atan2(
+                  points[index + 1][1] - point[1],
+                  points[index + 1][0] - point[0],
+                ) -
+                  Math.atan2(
+                    point[1] - points[index - 1][1],
+                    point[0] - points[index - 1][0],
+                  ),
+              )
+            : null;
+
+        return {
+          baseLength,
+          autoLength,
+          finalLength,
+          prevSegmentLength,
+          nextSegmentLength,
+          minNeighborLength,
+          finalLengthVsMinNeighbor:
+            minNeighborLength && minNeighborLength > 0
+              ? finalLength / minNeighborLength
+              : null,
+          autoLengthVsMinNeighbor:
+            minNeighborLength && minNeighborLength > 0
+              ? autoLength / minNeighborLength
+              : null,
+          angleDelta: normalizeSimpleArrowAngle(
+            Math.atan2(finalY[index], finalX[index]) -
+              Math.atan2(ty[index], tx[index]),
+          ),
+          turnAngle,
+        };
+      })(),
+    })),
+    segments: points.slice(0, -1).map((start, index) => {
+      const end = points[index + 1];
+      const {
+        segmentLength: chordLength,
+        startProjection: baseStartProjection,
+        endProjection: baseEndProjection,
+      } = getSimpleArrowSegmentProjections(
+        points,
+        tx,
+        ty,
+        baselineScales,
+        index,
+      );
+      const {
+        startProjection: finalStartProjection,
+        endProjection: finalEndProjection,
+      } = getSimpleArrowSegmentProjections(
+        points,
+        finalX,
+        finalY,
+        undefined,
+        index,
+      );
+      const baseCp1 = pointFrom<Point>(
+        start[0] + tx[index] / 3,
+        start[1] + ty[index] / 3,
+      );
+      const baseCp2 = pointFrom<Point>(
+        end[0] - tx[index + 1] / 3,
+        end[1] - ty[index + 1] / 3,
+      );
+      const cp1 = pointFrom<Point>(
+        start[0] + finalX[index] / 3,
+        start[1] + finalY[index] / 3,
+      );
+      const cp2 = pointFrom<Point>(
+        end[0] - finalX[index + 1] / 3,
+        end[1] - finalY[index + 1] / 3,
+      );
+
+      return {
+        start,
+        end,
+        baseCp1,
+        baseCp2,
+        cp1,
+        cp2,
+        overshootsBaseline: isSimpleArrowSegmentOvershooting(
+          points,
+          tx,
+          ty,
+          baselineScales,
+          index,
+        ),
+        overshootsResolved: isSimpleArrowSegmentOvershooting(
+          points,
+          finalX,
+          finalY,
+          undefined,
+          index,
+        ),
+        metrics: {
+          chordLength,
+          baseStartProjection,
+          baseEndProjection,
+          finalStartProjection,
+          finalEndProjection,
+        },
+      };
+    }),
+    inference: {
+      overriddenPointIndices,
+    },
+  };
+};
+
+const generateSimpleArrowPathOps = (
+  points: readonly LocalPoint[],
+  tension = 0.5,
+  elementId?: string,
+): SimpleArrowPathOp[] => {
+  if (points.length < 2) {
+    return [];
+  }
+
+  const ops: SimpleArrowPathOp[] = [
+    {
+      op: "move",
+      data: pointFrom<LocalPoint>(points[0][0], points[0][1]),
+    },
+  ];
+
+  if (points.length === 2) {
+    ops.push({
+      op: "lineTo",
+      data: pointFrom<LocalPoint>(points[1][0], points[1][1]),
+    });
+
+    return ops;
+  }
+  const debugData = getSimpleArrowCurveDebugData(points, tension, {
+    elementId,
+  });
+
+  for (const segment of debugData.segments) {
+    const { cp1, cp2, end } = segment;
+
+    ops.push({
+      op: "bcurveTo",
+      data: [cp1[0], cp1[1], cp2[0], cp2[1], end[0], end[1]],
+    });
+  }
+
+  return ops;
+};
+
+const generateSimpleArrowShape = (
+  points: readonly LocalPoint[],
+  tension = 0.5,
+  elementId?: string,
+): string => {
+  return generateSimpleArrowPathOps(points, tension, elementId)
+    .map((op) => {
+      if (op.op === "bcurveTo") {
+        return `C ${op.data[0]} ${op.data[1]} ${op.data[2]} ${op.data[3]} ${op.data[4]} ${op.data[5]}`;
+      }
+
+      return `${op.op === "move" ? "M" : "L"} ${op.data[0]} ${op.data[1]}`;
+    })
+    .join(" ");
+};
+
 const generateElbowArrowShape = (
   points: readonly LocalPoint[],
   radius: number,
-) => {
+): string => {
   const subpoints = [] as [number, number][];
   for (let i = 1; i < points.length - 1; i += 1) {
     const prev = points[i - 1];

packages/element/src/sortElements.ts

@@ -1,56 +1,59 @@
-import { arrayToMap } from "@excalidraw/common";
+import { arrayToMapWithIndex } from "@excalidraw/common";
 
 import type { ExcalidrawElement } from "./types";
 
-const defragmentGroups = (elements: readonly ExcalidrawElement[]) => {
-  const groupIdAtLevel = (element: ExcalidrawElement, level: number) => {
-    return element.groupIds[element.groupIds.length - level - 1];
-  };
+const normalizeGroupElementOrder = (elements: readonly ExcalidrawElement[]) => {
+  const origElements: ExcalidrawElement[] = elements.slice();
+  const sortedElements = new Set<ExcalidrawElement>();
 
-  const orderLevel = (
-    levelElements: readonly ExcalidrawElement[],
-    level: number,
+  const orderInnerGroups = (
+    elements: readonly ExcalidrawElement[],
   ): ExcalidrawElement[] => {
-    const buckets = new Map<string, ExcalidrawElement[]>();
-    // Slots preserve first-occurrence order: a groupId reserves its slot
-    // the first time one of its members is seen; loose elements occupy
-    // their own slot. Groups are then expanded (and recursed into) in place.
-    const slots: (ExcalidrawElement | string)[] = [];
-
-    for (const element of levelElements) {
-      const groupId = groupIdAtLevel(element, level);
-      if (groupId === undefined) {
-        slots.push(element);
-        continue;
+    const firstGroupSig = elements[0]?.groupIds?.join("");
+    const aGroup: ExcalidrawElement[] = [elements[0]];
+    const bGroup: ExcalidrawElement[] = [];
+    for (const element of elements.slice(1)) {
+      if (element.groupIds?.join("") === firstGroupSig) {
+        aGroup.push(element);
+      } else {
+        bGroup.push(element);
       }
-      let bucket = buckets.get(groupId);
-      if (!bucket) {
-        bucket = [];
-        buckets.set(groupId, bucket);
-        slots.push(groupId);
-      }
-      bucket.push(element);
     }
-
-    return slots.flatMap((slot) =>
-      typeof slot === "string"
-        ? orderLevel(buckets.get(slot)!, level + 1)
-        : [slot],
-    );
+    return bGroup.length ? [...aGroup, ...orderInnerGroups(bGroup)] : aGroup;
   };
 
-  // `groupIds` is stored innermost-first, so the outermost group is the
-  // last entry. We recurse from level 0 (outermost) inward.
-  const sortedElements = orderLevel(elements, 0);
+  const groupHandledElements = new Map<string, true>();
+
+  origElements.forEach((element, idx) => {
+    if (groupHandledElements.has(element.id)) {
+      return;
+    }
+    if (element.groupIds?.length) {
+      const topGroup = element.groupIds[element.groupIds.length - 1];
+      const groupElements = origElements.slice(idx).filter((element) => {
+        const ret = element?.groupIds?.some((id) => id === topGroup);
+        if (ret) {
+          groupHandledElements.set(element!.id, true);
+        }
+        return ret;
+      });
+
+      for (const elem of orderInnerGroups(groupElements)) {
+        sortedElements.add(elem);
+      }
+    } else {
+      sortedElements.add(element);
+    }
+  });
 
   // if there's a bug which resulted in losing some of the elements, return
   // original instead as that's better than losing data
-  if (sortedElements.length !== elements.length) {
-    console.error("defragmentGroups: lost some elements... bailing!");
+  if (sortedElements.size !== elements.length) {
+    console.error("normalizeGroupElementOrder: lost some elements... bailing!");
     return elements;
   }
 
-  return sortedElements;
+  return [...sortedElements];
 };
 
 /**
@@ -65,40 +68,39 @@ const defragmentGroups = (elements: readonly ExcalidrawElement[]) => {
 const normalizeBoundElementsOrder = (
   elements: readonly ExcalidrawElement[],
 ) => {
-  const elementsMap = arrayToMap(elements);
+  const elementsMap = arrayToMapWithIndex(elements);
 
+  const origElements: (ExcalidrawElement | null)[] = elements.slice();
   const sortedElements = new Set<ExcalidrawElement>();
 
-  for (const element of elements) {
-    if (sortedElements.has(element)) {
-      continue;
+  origElements.forEach((element, idx) => {
+    if (!element) {
+      return;
     }
-
     if (element.boundElements?.length) {
       sortedElements.add(element);
-      for (const boundElement of element.boundElements) {
+      origElements[idx] = null;
+      element.boundElements.forEach((boundElement) => {
         const child = elementsMap.get(boundElement.id);
         if (child && boundElement.type === "text") {
-          sortedElements.add(child);
+          sortedElements.add(child[0]);
+          origElements[child[1]] = null;
         }
+      });
+    } else if (element.type === "text" && element.containerId) {
+      const parent = elementsMap.get(element.containerId);
+      if (!parent?.[0].boundElements?.find((x) => x.id === element.id)) {
+        sortedElements.add(element);
+        origElements[idx] = null;
+
+        // if element has a container and container lists it, skip this element
+        // as it'll be taken care of by the container
       }
-      continue;
+    } else {
+      sortedElements.add(element);
+      origElements[idx] = null;
     }
-
-    // if element has a container and container lists it, skip this element
-    // as it'll be taken care of by the container
-    if (
-      element.type === "text" &&
-      element.containerId &&
-      elementsMap
-        .get(element.containerId)
-        ?.boundElements?.some((el) => el.id === element.id)
-    ) {
-      continue;
-    }
-
-    sortedElements.add(element);
-  }
+  });
 
   // if there's a bug which resulted in losing some of the elements, return
   // original instead as that's better than losing data
@@ -115,5 +117,5 @@ const normalizeBoundElementsOrder = (
 export const normalizeElementOrder = (
   elements: readonly ExcalidrawElement[],
 ) => {
-  return normalizeBoundElementsOrder(defragmentGroups(elements));
+  return normalizeBoundElementsOrder(normalizeGroupElementOrder(elements));
 };

packages/element/src/textElement.ts

@@ -347,7 +347,6 @@ export const getContainerCenter = (
     midSegmentMidpoint = LinearElementEditor.getSegmentMidPoint(
       container,
       index + 1,
-      elementsMap,
     );
   }
   return { x: midSegmentMidpoint[0], y: midSegmentMidpoint[1] };

packages/element/src/typeChecks.ts

@@ -392,23 +392,3 @@ export const canBecomePolygon = (
     (points.length === 3 && !pointsEqual(points[0], points[points.length - 1]))
   );
 };
-
-export const isEligibleFrameChildType = (type: ElementOrToolType) => {
-  switch (type) {
-    case "rectangle":
-    case "diamond":
-    case "ellipse":
-    case "arrow":
-    case "line":
-    case "freedraw":
-    case "text":
-    case "image":
-    case "frame":
-    case "embeddable": {
-      return true;
-    }
-    default: {
-      return false;
-    }
-  }
-};

packages/element/src/utils.ts

@@ -124,7 +124,6 @@ const setElementShapesCacheEntry = <T extends ExcalidrawElement>(
  */
 export function deconstructLinearOrFreeDrawElement(
   element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement,
-  elementsMap: ElementsMap,
 ): [LineSegment<GlobalPoint>[], Curve<GlobalPoint>[]] {
   const cachedShape = getElementShapesCacheEntry(element, 0);
 
@@ -132,7 +131,10 @@ export function deconstructLinearOrFreeDrawElement(
     return cachedShape;
   }
 
-  const ops = generateLinearCollisionShape(element, elementsMap);
+  const ops = generateLinearCollisionShape(element) as {
+    op: string;
+    data: number[];
+  }[];
   const lines = [];
   const curves = [];
 

packages/element/src/visualdebug.ts

@@ -5,7 +5,6 @@ import {
   pointFrom,
   type GlobalPoint,
   type LocalPoint,
-  type LineSegment,
 } from "@excalidraw/math";
 import { type Bounds, isBounds } from "@excalidraw/common";
 import {
@@ -18,6 +17,7 @@ import {
 
 import type { ElementsMap, ExcalidrawElement } from "@excalidraw/element/types";
 import type { Curve } from "@excalidraw/math";
+import type { LineSegment } from "@excalidraw/utils";
 
 // The global data holder to collect the debug operations
 declare global {

packages/element/src/zindex.ts

@@ -1,7 +1,5 @@
 import { arrayToMap, findIndex, findLastIndex } from "@excalidraw/common";
 
-import { isFiniteNumber } from "@excalidraw/math";
-
 import type { AppState } from "@excalidraw/excalidraw/types";
 import type { GlobalPoint } from "@excalidraw/math";
 
@@ -315,46 +313,12 @@ const getTargetElementsMap = <T extends ExcalidrawElement>(
   }, new Map<string, ExcalidrawElement>());
 };
 
-const hasSameElementIds = (
-  prevElements: readonly ExcalidrawElement[],
-  nextElements: readonly ExcalidrawElement[],
-) => {
-  if (prevElements.length !== nextElements.length) {
-    console.error(
-      "z-index reordering failed: resulting array have different lengths",
-    );
-    return false;
-  }
-
-  const prevElementIdCounts = new Map<ExcalidrawElement["id"], number>();
-  for (const element of prevElements) {
-    prevElementIdCounts.set(
-      element.id,
-      (prevElementIdCounts.get(element.id) || 0) + 1,
-    );
-  }
-
-  for (const element of nextElements) {
-    const count = prevElementIdCounts.get(element.id);
-    if (!count) {
-      console.error(
-        "z-index reordering failed: element id mismatch / duplicate ids",
-      );
-      return false;
-    }
-    prevElementIdCounts.set(element.id, count - 1);
-  }
-
-  return true;
-};
-
 const shiftElementsByOne = (
   elements: readonly ExcalidrawElement[],
   appState: AppState,
   direction: "left" | "right",
   scene: Scene,
 ) => {
-  const originalElements = elements;
   const indicesToMove = getIndicesToMove(elements, appState);
   const targetElementsMap = getTargetElementsMap(elements, indicesToMove);
 
@@ -425,10 +389,6 @@ const shiftElementsByOne = (
           ];
   });
 
-  if (!hasSameElementIds(originalElements, elements)) {
-    return originalElements;
-  }
-
   syncMovedIndices(elements, targetElementsMap);
 
   return elements;
@@ -442,20 +402,11 @@ const shiftElementsToEnd = (
   elementsToBeMoved?: readonly ExcalidrawElement[],
 ) => {
   const indicesToMove = getIndicesToMove(elements, appState, elementsToBeMoved);
-
-  // Nothing to move (e.g. `elementsToBeMoved` is empty because all selected
-  // elements were frame children handled in a prior pass). Bail out early —
-  // otherwise `leadingIndex`/`trailingIndex` below resolve to `undefined` and
-  // the resulting `slice()` calls overlap, duplicating elements.
-  if (indicesToMove.length === 0) {
-    return elements;
-  }
-
   const targetElementsMap = getTargetElementsMap(elements, indicesToMove);
   const displacedElements: ExcalidrawElement[] = [];
 
-  let leadingIndex: number | undefined;
-  let trailingIndex: number | undefined;
+  let leadingIndex: number;
+  let trailingIndex: number;
   if (direction === "left") {
     if (containingFrame) {
       leadingIndex = findIndex(elements, (el) =>
@@ -500,19 +451,6 @@ const shiftElementsToEnd = (
     leadingIndex = 0;
   }
 
-  const isValidIndex = (index: number | undefined): index is number => {
-    return isFiniteNumber(index) && index >= 0;
-  };
-
-  if (
-    !isValidIndex(leadingIndex) ||
-    !isValidIndex(trailingIndex) ||
-    leadingIndex > trailingIndex ||
-    indicesToMove.some((index) => index < leadingIndex || index > trailingIndex)
-  ) {
-    return elements;
-  }
-
   for (let index = leadingIndex; index < trailingIndex + 1; index++) {
     if (!indicesToMove.includes(index)) {
       displacedElements.push(elements[index]);
@@ -537,10 +475,6 @@ const shiftElementsToEnd = (
           ...trailingElements,
         ];
 
-  if (!hasSameElementIds(elements, nextElements)) {
-    return elements;
-  }
-
   syncMovedIndices(nextElements, targetElementsMap);
 
   return nextElements;
@@ -609,7 +543,7 @@ function shiftElementsAccountingForFrames(
 
   for (const [frameId, children] of frameChildrenSets) {
     nextElements = shiftFunction(
-      nextElements,
+      allElements,
       appState,
       direction,
       frameId,

packages/element/tests/bounds.test.ts

@@ -1,14 +1,10 @@
 import { pointFrom } from "@excalidraw/math";
-import { arrayToMap, type Bounds, ROUNDNESS } from "@excalidraw/common";
-import { API } from "@excalidraw/excalidraw/tests/helpers/api";
+
+import { arrayToMap, ROUNDNESS } from "@excalidraw/common";
 
 import type { LocalPoint } from "@excalidraw/math";
 
-import {
-  elementsOverlappingBBox,
-  getElementAbsoluteCoords,
-  getElementBounds,
-} from "../src/bounds";
+import { getElementAbsoluteCoords, getElementBounds } from "../src/bounds";
 
 import type { ExcalidrawElement, ExcalidrawLinearElement } from "../src/types";
 
@@ -139,71 +135,9 @@ describe("getElementBounds", () => {
     } as ExcalidrawLinearElement;
 
     const [x1, y1, x2, y2] = getElementBounds(element, arrayToMap([element]));
-    expect(x1).toEqual(360.9291017525165);
-    expect(y1).toEqual(185.24770129343722);
-    expect(x2).toEqual(481.4815539037601);
-    expect(y2).toEqual(319.8162855827246);
-  });
-});
-
-const makeElement = (x: number, y: number, width: number, height: number) =>
-  API.createElement({
-    type: "rectangle",
-    x,
-    y,
-    width,
-    height,
-  });
-
-const makeBBox = (
-  minX: number,
-  minY: number,
-  maxX: number,
-  maxY: number,
-): Bounds => [minX, minY, maxX, maxY];
-
-describe("elementsOverlappingBBox()", () => {
-  it("should return elements that overlap bbox", () => {
-    const bbox = makeBBox(0, 0, 100, 100);
-
-    const rectOutside = makeElement(110, 110, 100, 100);
-    const rectInside = makeElement(10, 10, 85, 85);
-    const rectContainingBBox = makeElement(-10, -10, 110, 110);
-    const rectOverlappingTopLeft = makeElement(-10, -10, 50, 50);
-
-    expect(
-      elementsOverlappingBBox({
-        bounds: bbox,
-        type: "overlap",
-        elements: [
-          rectOutside,
-          rectInside,
-          rectContainingBBox,
-          rectOverlappingTopLeft,
-        ],
-      }),
-    ).toEqual([rectInside, rectOverlappingTopLeft]);
-  });
-
-  it("should return elements inside/containing bbox", () => {
-    const bbox = makeBBox(0, 0, 100, 100);
-
-    const rectOutside = makeElement(110, 110, 100, 100);
-    const rectInside = makeElement(10, 10, 85, 85);
-    const rectContainingBBox = makeElement(-10, -10, 110, 110);
-    const rectOverlappingTopLeft = makeElement(-10, -10, 50, 50);
-
-    expect(
-      elementsOverlappingBBox({
-        bounds: bbox,
-        type: "contain",
-        elements: [
-          rectOutside,
-          rectInside,
-          rectContainingBBox,
-          rectOverlappingTopLeft,
-        ],
-      }),
-    ).toEqual([rectInside]);
+    expect(x1).toEqual(360.3176068760539);
+    expect(y1).toEqual(185.90654264413516);
+    expect(x2).toEqual(486.6924560404731);
+    expect(y2).toEqual(320.391865303557);
   });
 });

packages/element/tests/collision.test.tsx

@@ -1,4 +1,4 @@
-import { arrayToMap, reseed } from "@excalidraw/common";
+import { arrayToMap } from "@excalidraw/common";
 import { type GlobalPoint, type LocalPoint, pointFrom } from "@excalidraw/math";
 import { Excalidraw } from "@excalidraw/excalidraw";
 import { API } from "@excalidraw/excalidraw/tests/helpers/api";
@@ -12,7 +12,6 @@ import { hitElementItself } from "../src/collision";
 describe("check rotated elements can be hit:", () => {
   beforeEach(async () => {
     localStorage.clear();
-    reseed(7);
     await render(<Excalidraw handleKeyboardGlobally={true} />);
   });
 
@@ -57,7 +56,6 @@ describe("hitElementItself cache", () => {
     });
 
     localStorage.clear();
-    reseed(7);
     await render(<Excalidraw handleKeyboardGlobally={true} />);
   });
 

packages/element/tests/fractionalIndex.test.ts

@@ -1,8 +1,9 @@
 /* eslint-disable no-lone-blocks */
+import { generateKeyBetween } from "fractional-indexing";
+
 import { arrayToMap } from "@excalidraw/common";
 
 import {
-  InvalidFractionalIndexError,
   syncInvalidIndices,
   syncMovedIndices,
   validateFractionalIndices,
@@ -12,34 +13,13 @@ import { deepCopyElement } from "@excalidraw/element";
 
 import { API } from "@excalidraw/excalidraw/tests/helpers/api";
 
-import {
-  generateKeyBetween,
-  validateOrderKey,
-} from "@excalidraw/fractional-indexing";
-
 import type {
   ElementsMap,
   ExcalidrawElement,
   FractionalIndex,
 } from "@excalidraw/element/types";
 
-describe("fractional index format validation", () => {
-  it("should reject malformed base62 order keys", () => {
-    expect(() => validateOrderKey("a!")).toThrow();
-    expect(() => validateOrderKey("a_")).toThrow();
-    expect(() => validateOrderKey("a1!")).toThrow();
-    expect(() => validateOrderKey("a1_")).toThrow();
-    expect(() => validateOrderKey("zd0032")).toThrow();
-  });
-
-  it("should accept valid base62 order keys", () => {
-    expect(() => validateOrderKey("Zz")).not.toThrow();
-    expect(() => validateOrderKey("a0")).not.toThrow();
-    expect(() => validateOrderKey("a1")).not.toThrow();
-    expect(() => validateOrderKey("a1V")).not.toThrow();
-    expect(() => validateOrderKey("z".padEnd(28, "z"))).not.toThrow();
-  });
-});
+import { InvalidFractionalIndexError } from "../src/fractionalIndex";
 
 describe("sync invalid indices with array order", () => {
   describe("should NOT sync empty array", () => {
@@ -124,46 +104,6 @@ describe("sync invalid indices with array order", () => {
     });
   });
 
-  describe("should sync when fractional index is malformed", () => {
-    // "zd0032" has head "z" which requires length 28 per getIntegerLength,
-    // but the string is far too short, so validateOrderKey throws for it
-    testInvalidIndicesSync({
-      elements: [{ id: "A", index: "zd0032" }],
-      expect: {
-        unchangedElements: [],
-      },
-    });
-
-    testInvalidIndicesSync({
-      elements: [
-        { id: "A", index: "a1" },
-        { id: "B", index: "zd0032" },
-        { id: "C", index: "a3" },
-      ],
-      expect: {
-        unchangedElements: ["A", "C"],
-      },
-    });
-
-    testInvalidIndicesSync({
-      elements: [{ id: "A", index: "a!" }],
-      expect: {
-        unchangedElements: [],
-      },
-    });
-
-    testInvalidIndicesSync({
-      elements: [
-        { id: "A", index: "a1" },
-        { id: "B", index: "a!" },
-        { id: "C", index: "a2" },
-      ],
-      expect: {
-        unchangedElements: ["A", "C"],
-      },
-    });
-  });
-
   describe("should sync when fractional indices are duplicated", () => {
     testInvalidIndicesSync({
       elements: [

packages/element/tests/frame.test.tsx

@@ -2,27 +2,15 @@ import {
   convertToExcalidrawElements,
   Excalidraw,
 } from "@excalidraw/excalidraw";
-import { arrayToMap } from "@excalidraw/common";
-import { degreesToRadians, pointFrom } from "@excalidraw/math";
 
 import { API } from "@excalidraw/excalidraw/tests/helpers/api";
-import { Keyboard, Pointer, UI } from "@excalidraw/excalidraw/tests/helpers/ui";
-import { getTextEditor } from "@excalidraw/excalidraw/tests/queries/dom";
+import { Keyboard, Pointer } from "@excalidraw/excalidraw/tests/helpers/ui";
 import {
   getCloneByOrigId,
   render,
 } from "@excalidraw/excalidraw/tests/test-utils";
 
-import { getSelectedElements } from "@excalidraw/excalidraw/scene";
-
-import type { Degrees } from "@excalidraw/math";
-
-import { elementOverlapsWithFrame } from "../src/frame";
-
-import type {
-  ExcalidrawElement,
-  ExcalidrawFrameLikeElement,
-} from "../src/types";
+import type { ExcalidrawElement } from "../src/types";
 
 const { h } = window;
 const mouse = new Pointer("mouse");
@@ -137,352 +125,6 @@ describe("adding elements to frames", () => {
     });
   });
 
-  it("should treat an element fully containing a frame as overlapping the frame", () => {
-    const containingRect = API.createElement({
-      type: "rectangle",
-      x: -50,
-      y: -50,
-      width: 250,
-      height: 250,
-    });
-
-    API.setElements([containingRect, frame]);
-
-    expect(
-      elementOverlapsWithFrame(
-        containingRect,
-        frame as ExcalidrawFrameLikeElement,
-        arrayToMap(h.elements),
-      ),
-    ).toBe(true);
-  });
-
-  it("uses precise geometry (not the bounding box) to detect frame overlap", () => {
-    // a 300x200 frame at the origin, with shapes positioned just outside each
-    // corner so that their bounding box clips the frame but their actual
-    // outline does not. The precise `isElementIntersectingFrame` must report
-    // no overlap.
-    const overlapFrame = API.createElement({
-      type: "frame",
-      x: 0,
-      y: 0,
-      width: 300,
-      height: 200,
-    });
-    // clips the bottom-right corner; the rhombus tip stays out
-    const diamond = API.createElement({
-      type: "diamond",
-      x: 290,
-      y: 175,
-      width: 100,
-      height: 100,
-    });
-    // clips the bottom-left corner; rotated (NOT 45°, which would degenerate
-    // into an axis-aligned square whose shape fills its AABB)
-    const diamondRotated = API.createElement({
-      type: "diamond",
-      x: -50,
-      y: 195,
-      width: 100,
-      height: 100,
-      angle: degreesToRadians(45 as Degrees),
-    });
-    // clips the top-left corner; the curve doesn't reach the corner
-    const ellipse = API.createElement({
-      type: "ellipse",
-      x: -90,
-      y: -90,
-      width: 100,
-      height: 100,
-    });
-    // clips the top edge; the polyline weaves outside the frame
-    const line = API.createElement({
-      type: "line",
-      x: 130,
-      y: -20,
-      width: 293,
-      height: 183,
-      points: [
-        pointFrom(0, 0),
-        pointFrom(-165, -96),
-        pointFrom(-293, -16),
-        pointFrom(-162, 87),
-      ],
-    });
-    // clips the bottom-left corner; the stroke stays outside
-    const freedraw = API.createElement({
-      type: "freedraw",
-      x: -15,
-      y: 180,
-      width: 207,
-      height: 209,
-      points: [
-        pointFrom(0, 0),
-        pointFrom(-69, 99),
-        pointFrom(-33, 183),
-        pointFrom(48, 209),
-        pointFrom(124, 195),
-        pointFrom(138, 145),
-        pointFrom(123, 85),
-      ],
-    });
-    // clips the top-right corner, but its rounded corner is cut away from
-    // exactly that corner — so its actual outline stays outside
-    const roundedRect = API.createElement({
-      type: "rectangle",
-      x: 295,
-      y: -100,
-      width: 160,
-      height: 110,
-      roundness: { type: 3 },
-    });
-
-    API.setElements([
-      overlapFrame,
-      diamond,
-      diamondRotated,
-      ellipse,
-      line,
-      freedraw,
-      roundedRect,
-    ]);
-    const elementsMap = arrayToMap(h.elements);
-    const f = overlapFrame as ExcalidrawFrameLikeElement;
-
-    expect(elementOverlapsWithFrame(diamond, f, elementsMap)).toBe(false);
-    expect(elementOverlapsWithFrame(diamondRotated, f, elementsMap)).toBe(
-      false,
-    );
-    expect(elementOverlapsWithFrame(ellipse, f, elementsMap)).toBe(false);
-    expect(elementOverlapsWithFrame(line, f, elementsMap)).toBe(false);
-    expect(elementOverlapsWithFrame(freedraw, f, elementsMap)).toBe(false);
-    expect(elementOverlapsWithFrame(roundedRect, f, elementsMap)).toBe(false);
-  });
-
-  it("should not add a newly created element to a frame behind a non-frame element", () => {
-    const cover = API.createElement({
-      id: "cover",
-      type: "rectangle",
-      x: 10,
-      y: 10,
-      width: 80,
-      height: 80,
-      backgroundColor: "#ffc9c9",
-    });
-
-    API.setElements([frame, cover]);
-
-    UI.clickTool("rectangle");
-    mouse.downAt(20, 20);
-    mouse.moveTo(40, 40);
-    mouse.upAt(40, 40);
-
-    const createdElement = h.elements.find(
-      (element) => element.id !== frame.id && element.id !== cover.id,
-    );
-
-    expect(createdElement?.frameId).toBe(null);
-    expect(h.elements.map((element) => element.id)).toEqual([
-      frame.id,
-      cover.id,
-      createdElement?.id,
-    ]);
-  });
-
-  it("should add a newly created element to a frame over a non-frame element", () => {
-    const cover = API.createElement({
-      id: "cover",
-      type: "rectangle",
-      x: 10,
-      y: 10,
-      width: 80,
-      height: 80,
-      backgroundColor: "#ffc9c9",
-    });
-
-    API.setElements([cover, frame]);
-
-    UI.clickTool("rectangle");
-    mouse.downAt(20, 20);
-    mouse.moveTo(40, 40);
-    mouse.upAt(40, 40);
-
-    const createdElement = h.elements.find(
-      (element) => element.id !== frame.id && element.id !== cover.id,
-    );
-
-    expect(createdElement?.frameId).toBe(frame.id);
-  });
-
-  it("should highlight the target frame while creating a new element", () => {
-    API.setElements([frame]);
-
-    UI.clickTool("rectangle");
-    mouse.downAt(20, 20);
-    mouse.moveTo(40, 40);
-
-    expect(h.state.frameToHighlight?.id).toBe(frame.id);
-
-    mouse.upAt(40, 40);
-
-    expect(h.state.frameToHighlight).toBe(null);
-  });
-
-  it("should highlight the target frame while hovering with a creation tool", () => {
-    API.setElements([frame]);
-
-    UI.clickTool("rectangle");
-    mouse.moveTo(20, 20);
-
-    expect(h.state.frameToHighlight?.id).toBe(frame.id);
-
-    mouse.moveTo(200, 200);
-
-    expect(h.state.frameToHighlight).toBe(null);
-  });
-
-  it("should not add grid-snapped text outside the frame to the clicked frame", async () => {
-    const offsetFrame = API.createElement({
-      id: "offsetFrame",
-      type: "frame",
-      x: 10,
-      y: 0,
-      width: 150,
-      height: 150,
-    });
-
-    API.setElements([offsetFrame]);
-    API.setAppState({
-      gridModeEnabled: true,
-    });
-
-    UI.clickTool("text");
-    mouse.clickAt(12, 0);
-
-    await getTextEditor();
-
-    const createdText = h.elements.find(
-      (element) => element.id !== offsetFrame.id,
-    );
-
-    expect(createdText?.x).toBe(0);
-    expect(createdText?.y).toBe(0);
-    expect(createdText?.frameId).toBe(null);
-  });
-
-  it("should add a newly created element to a frame behind another frame", () => {
-    const lockedFrame = API.createElement({
-      id: "lockedFrame",
-      type: "frame",
-      x: 10,
-      y: 10,
-      width: 80,
-      height: 80,
-      locked: true,
-    });
-
-    API.setElements([frame, lockedFrame]);
-
-    UI.clickTool("rectangle");
-    mouse.downAt(20, 20);
-    mouse.moveTo(40, 40);
-    mouse.upAt(40, 40);
-
-    const createdElement = h.elements.find(
-      (element) => element.id !== frame.id && element.id !== lockedFrame.id,
-    );
-
-    expect(createdElement?.frameId).toBe(frame.id);
-  });
-
-  it("should insert a newly created frame child just below its frame", () => {
-    const frameChildUnderCursor = API.createElement({
-      id: "frameChildUnderCursor",
-      type: "rectangle",
-      x: 10,
-      y: 10,
-      width: 80,
-      height: 80,
-      backgroundColor: "#ffc9c9",
-      frameId: frame.id,
-    });
-    const otherFrameChild = API.createElement({
-      id: "otherFrameChild",
-      type: "rectangle",
-      x: 100,
-      y: 20,
-      width: 20,
-      height: 20,
-      frameId: frame.id,
-    });
-
-    API.setElements([frameChildUnderCursor, otherFrameChild, frame]);
-
-    UI.clickTool("rectangle");
-    mouse.downAt(20, 20);
-    mouse.moveTo(40, 40);
-    mouse.upAt(40, 40);
-
-    const createdElement = h.elements.find(
-      (element) =>
-        element.id !== frame.id &&
-        element.id !== frameChildUnderCursor.id &&
-        element.id !== otherFrameChild.id,
-    );
-
-    expect(createdElement?.frameId).toBe(frame.id);
-    expect(h.elements.map((element) => element.id)).toEqual([
-      frameChildUnderCursor.id,
-      otherFrameChild.id,
-      createdElement?.id,
-      frame.id,
-    ]);
-  });
-
-  it("should insert a newly created frame child above the highest frame child", () => {
-    const frameChildUnderCursor = API.createElement({
-      id: "frameChildUnderCursor",
-      type: "rectangle",
-      x: 10,
-      y: 10,
-      width: 80,
-      height: 80,
-      backgroundColor: "#ffc9c9",
-      frameId: frame.id,
-    });
-    const otherFrameChild = API.createElement({
-      id: "otherFrameChild",
-      type: "rectangle",
-      x: 100,
-      y: 20,
-      width: 20,
-      height: 20,
-      frameId: frame.id,
-    });
-
-    API.setElements([frame, frameChildUnderCursor, otherFrameChild]);
-
-    UI.clickTool("rectangle");
-    mouse.downAt(20, 20);
-    mouse.moveTo(40, 40);
-    mouse.upAt(40, 40);
-
-    const createdElement = h.elements.find(
-      (element) =>
-        element.id !== frame.id &&
-        element.id !== frameChildUnderCursor.id &&
-        element.id !== otherFrameChild.id,
-    );
-
-    expect(createdElement?.frameId).toBe(frame.id);
-    expect(h.elements.map((element) => element.id)).toEqual([
-      frame.id,
-      frameChildUnderCursor.id,
-      otherFrameChild.id,
-      createdElement?.id,
-    ]);
-  });
-
   const commonTestCases = async (
     func: typeof resizeFrameOverElement | typeof dragElementIntoFrame,
   ) => {
@@ -773,373 +415,6 @@ describe("adding elements to frames", () => {
   describe("dragging elements into the frame", async () => {
     await commonTestCases(dragElementIntoFrame);
 
-    it("should add a dragged element fully containing the frame", () => {
-      const containingRect = API.createElement({
-        type: "rectangle",
-        x: 220,
-        y: 20,
-        width: 300,
-        height: 300,
-      });
-
-      API.setElements([frame, containingRect]);
-
-      dragElementIntoFrame(frame, containingRect);
-
-      expect(API.getElement(containingRect).frameId).toBe(frame.id);
-    });
-
-    it("should drag an element into a frame", () => {
-      API.setElements([rect2, frame]);
-
-      dragElementIntoFrame(frame, rect2);
-
-      expect(rect2.frameId).toBe(frame.id);
-    });
-
-    it("should move an element dragged from one frame into another", () => {
-      const otherFrame = API.createElement({
-        id: "otherFrame",
-        type: "frame",
-        x: 300,
-        y: 0,
-        width: 150,
-        height: 150,
-      });
-      const frameChild = API.createElement({
-        id: "frameChild",
-        type: "rectangle",
-        x: 50,
-        y: 50,
-        width: 20,
-        height: 20,
-        frameId: frame.id,
-      });
-
-      API.setElements([frame, frameChild, otherFrame]);
-
-      expect(frameChild.frameId).toBe(frame.id);
-
-      dragElementIntoFrame(otherFrame, frameChild);
-
-      expect(frameChild.frameId).toBe(otherFrame.id);
-    });
-
-    it("should layer a dragged element above the highest frame child", () => {
-      const frameChild = API.createElement({
-        id: "frameChild",
-        type: "rectangle",
-        x: 10,
-        y: 10,
-        width: 20,
-        height: 20,
-        frameId: frame.id,
-      });
-
-      API.setElements([frame, frameChild, rect2]);
-
-      dragElementIntoFrame(frame, rect2);
-
-      expect(rect2.frameId).toBe(frame.id);
-      expect(h.elements.map((element) => element.id)).toEqual([
-        frame.id,
-        frameChild.id,
-        rect2.id,
-      ]);
-      expect(rect2.index! > frameChild.index!).toBe(true);
-      expect(rect2.index! > frame.index!).toBe(true);
-    });
-
-    it("should preview a dragged element above the highest frame child before pointerup", () => {
-      const frameChild = API.createElement({
-        id: "frameChild",
-        type: "rectangle",
-        x: 10,
-        y: 10,
-        width: 20,
-        height: 20,
-        frameId: frame.id,
-      });
-
-      API.setElements([rect2, frame, frameChild]);
-      API.setSelectedElements([rect2]);
-      API.updateElement(rect2, {
-        x: 10,
-        y: 10,
-      });
-
-      const getRenderableElementIds = (
-        selectedElementsAreBeingDragged: boolean,
-      ) => {
-        return h.app.renderer
-          .getRenderableElements({
-            zoom: h.state.zoom,
-            offsetLeft: 0,
-            offsetTop: 0,
-            scrollX: 0,
-            scrollY: 0,
-            height: 1000,
-            width: 1000,
-            editingTextElement: h.state.editingTextElement,
-            newElement: h.state.newElement,
-            selectedElements: getSelectedElements(h.elements, h.state),
-            selectedElementsAreBeingDragged,
-            frameToHighlight: frame as ExcalidrawFrameLikeElement,
-          })
-          .visibleElements.map((element) => element.id);
-      };
-
-      expect(h.elements.map((element) => element.id)).toEqual([
-        rect2.id,
-        frame.id,
-        frameChild.id,
-      ]);
-      expect(getRenderableElementIds(false)).toEqual([
-        rect2.id,
-        frame.id,
-        frameChild.id,
-      ]);
-      expect(getRenderableElementIds(true)).toEqual([
-        frame.id,
-        frameChild.id,
-        rect2.id,
-      ]);
-      expect(h.elements.map((element) => element.id)).toEqual([
-        rect2.id,
-        frame.id,
-        frameChild.id,
-      ]);
-      expect(rect2.frameId).toBe(null);
-    });
-
-    it("should not preview reorder dragged elements already in the highlighted frame", () => {
-      const frameChild = API.createElement({
-        id: "frameChild",
-        type: "rectangle",
-        x: 10,
-        y: 10,
-        width: 20,
-        height: 20,
-        frameId: frame.id,
-      });
-      const otherFrameChild = API.createElement({
-        id: "otherFrameChild",
-        type: "rectangle",
-        x: 40,
-        y: 10,
-        width: 20,
-        height: 20,
-        frameId: frame.id,
-      });
-
-      API.setElements([frameChild, frame, otherFrameChild]);
-      API.setSelectedElements([frameChild]);
-
-      const renderableElementIds = h.app.renderer
-        .getRenderableElements({
-          zoom: h.state.zoom,
-          offsetLeft: 0,
-          offsetTop: 0,
-          scrollX: 0,
-          scrollY: 0,
-          height: 1000,
-          width: 1000,
-          editingTextElement: h.state.editingTextElement,
-          newElement: h.state.newElement,
-          selectedElements: getSelectedElements(h.elements, h.state),
-          selectedElementsAreBeingDragged: true,
-          frameToHighlight: frame as ExcalidrawFrameLikeElement,
-        })
-        .visibleElements.map((element) => element.id);
-
-      expect(renderableElementIds).toEqual([
-        frameChild.id,
-        frame.id,
-        otherFrameChild.id,
-      ]);
-    });
-
-    it("should put a dragged mixed selection above the highest frame child", () => {
-      const frameChild = API.createElement({
-        id: "frameChild",
-        type: "rectangle",
-        x: 50,
-        y: 10,
-        width: 20,
-        height: 20,
-        frameId: frame.id,
-        boundElements: [{ id: "boundText", type: "text" }],
-      });
-      const boundText = API.createElement({
-        id: "boundText",
-        type: "text",
-        x: 50,
-        y: 10,
-        width: 20,
-        height: 20,
-        containerId: frameChild.id,
-        frameId: frame.id,
-      });
-      const otherFrameChild = API.createElement({
-        id: "otherFrameChild",
-        type: "rectangle",
-        x: 80,
-        y: 10,
-        width: 20,
-        height: 20,
-        frameId: frame.id,
-      });
-      const nonFrameElement = API.createElement({
-        id: "nonFrameElement",
-        type: "rectangle",
-        x: 155,
-        y: 10,
-        width: 20,
-        height: 20,
-      });
-
-      API.setElements([
-        frame,
-        frameChild,
-        boundText,
-        otherFrameChild,
-        nonFrameElement,
-      ]);
-      API.setSelectedElements([frameChild, nonFrameElement]);
-
-      mouse.downAt(
-        nonFrameElement.x + nonFrameElement.width / 2,
-        nonFrameElement.y + nonFrameElement.height / 2,
-      );
-      mouse.moveTo(frame.x + frame.width - 5, nonFrameElement.y + 10);
-      mouse.up();
-
-      expect(frameChild.frameId).toBe(frame.id);
-      expect(boundText.frameId).toBe(frame.id);
-      expect(nonFrameElement.frameId).toBe(frame.id);
-      expect(h.elements.map((element) => element.id)).toEqual([
-        frame.id,
-        otherFrameChild.id,
-        frameChild.id,
-        boundText.id,
-        nonFrameElement.id,
-      ]);
-    });
-
-    it("should not reorder dragged elements already in the highlighted frame", () => {
-      const frameChild = API.createElement({
-        id: "frameChild",
-        type: "rectangle",
-        x: 50,
-        y: 10,
-        width: 20,
-        height: 20,
-        frameId: frame.id,
-      });
-      const otherFrameChild = API.createElement({
-        id: "otherFrameChild",
-        type: "rectangle",
-        x: 80,
-        y: 10,
-        width: 20,
-        height: 20,
-        frameId: frame.id,
-      });
-
-      API.setElements([frame, frameChild, otherFrameChild]);
-      API.setSelectedElements([frameChild]);
-
-      mouse.downAt(
-        frameChild.x + frameChild.width / 2,
-        frameChild.y + frameChild.height / 2,
-      );
-      mouse.moveTo(frameChild.x + frameChild.width / 2 + 5, frameChild.y + 10);
-      mouse.up();
-
-      expect(frameChild.frameId).toBe(frame.id);
-      expect(h.elements.map((element) => element.id)).toEqual([
-        frame.id,
-        frameChild.id,
-        otherFrameChild.id,
-      ]);
-    });
-
-    it("should not drag an element into a frame behind a non-frame element", () => {
-      const cover = API.createElement({
-        id: "cover",
-        type: "rectangle",
-        x: 10,
-        y: 10,
-        width: 80,
-        height: 80,
-        backgroundColor: "#ffc9c9",
-      });
-      API.setElements([frame, cover, rect2]);
-
-      mouse.clickAt(rect2.x, rect2.y);
-      mouse.downAt(rect2.x + rect2.width / 2, rect2.y + rect2.height / 2);
-      mouse.moveTo(20, 20);
-      mouse.upAt(20, 20);
-
-      expect(rect2.frameId).toBe(null);
-    });
-
-    it("should drag an element into a frame over a non-frame element", () => {
-      const cover = API.createElement({
-        id: "cover",
-        type: "rectangle",
-        x: 10,
-        y: 10,
-        width: 80,
-        height: 80,
-        backgroundColor: "#ffc9c9",
-      });
-      API.setElements([cover, rect2, frame]);
-
-      mouse.clickAt(rect2.x, rect2.y);
-      mouse.downAt(rect2.x + rect2.width / 2, rect2.y + rect2.height / 2);
-      mouse.moveTo(20, 20);
-      mouse.upAt(20, 20);
-
-      expect(rect2.frameId).toBe(frame.id);
-    });
-
-    it("should keep dragging a frame child over a non-frame element above its frame", () => {
-      const cover = API.createElement({
-        id: "cover",
-        type: "rectangle",
-        x: 10,
-        y: 10,
-        width: 80,
-        height: 80,
-        backgroundColor: "#ffc9c9",
-      });
-      const frameChild = API.createElement({
-        id: "frameChild",
-        type: "rectangle",
-        x: 100,
-        y: 20,
-        width: 20,
-        height: 20,
-        frameId: frame.id,
-      });
-
-      API.setElements([frameChild, frame, cover]);
-      API.setSelectedElements([frameChild]);
-
-      mouse.downAt(
-        frameChild.x + frameChild.width / 2,
-        frameChild.y + frameChild.height / 2,
-      );
-      mouse.moveTo(20, 20);
-
-      expect(h.state.frameToHighlight?.id).toBe(frame.id);
-
-      mouse.upAt(20, 20);
-
-      expect(frameChild.frameId).toBe(frame.id);
-    });
-
     it.skip("should drag element inside, duplicate it and keep it in frame", () => {
       API.setElements([frame, rect2]);
 

packages/element/tests/linearElementEditor.test.tsx

@@ -434,12 +434,12 @@ describe("Test Linear Elements", () => {
       expect(midPointsWithRoundEdge).toMatchInlineSnapshot(`
         [
           [
-            "54.27552",
-            "46.16120",
+            "53.63967",
+            "47.15774",
           ],
           [
-            "76.95494",
-            "44.56052",
+            "78.65236",
+            "44.31886",
           ],
         ]
       `);
@@ -499,12 +499,12 @@ describe("Test Linear Elements", () => {
       expect(newMidPoints).toMatchInlineSnapshot(`
         [
           [
-            "104.27552",
-            "66.16120",
+            "103.63967",
+            "67.15774",
           ],
           [
-            "126.95494",
-            "64.56052",
+            "128.65236",
+            "64.31886",
           ],
         ]
       `);
@@ -815,12 +815,12 @@ describe("Test Linear Elements", () => {
         expect(newMidPoints).toMatchInlineSnapshot(`
           [
             [
-              "29.28349",
-              "20.91105",
+              "28.64089",
+              "21.69997",
             ],
             [
-              "78.86048",
-              "46.12277",
+              "82.34322",
+              "47.57759",
             ],
           ]
         `);
@@ -904,12 +904,12 @@ describe("Test Linear Elements", () => {
         expect(newMidPoints).toMatchInlineSnapshot(`
           [
             [
-              "54.27552",
-              "46.16120",
+              "53.63967",
+              "47.15774",
             ],
             [
-              "76.95494",
-              "44.56052",
+              "78.65236",
+              "44.31886",
             ],
           ]
         `);
@@ -1191,7 +1191,7 @@ describe("Test Linear Elements", () => {
           20,
           105,
           80,
-          "55.45894",
+          "56.00000",
           45,
         ]
       `);
@@ -1202,7 +1202,7 @@ describe("Test Linear Elements", () => {
         .toMatchInlineSnapshot(`
           {
             "height": 130,
-            "width": "366.11716",
+            "width": "367.18528",
           }
         `);
 
@@ -1214,7 +1214,7 @@ describe("Test Linear Elements", () => {
         ),
       ).toMatchInlineSnapshot(`
         {
-          "x": "271.11716",
+          "x": "272.18528",
           "y": 45,
         }
       `);
@@ -1231,9 +1231,9 @@ describe("Test Linear Elements", () => {
         [
           20,
           35,
-          "501.11716",
+          "502.18528",
           95,
-          "205.45894",
+          "208.69244",
           "52.50000",
         ]
       `);

packages/element/tests/sortElements.test.ts

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

packages/element/tests/zindex.test.tsx

@@ -1509,190 +1509,4 @@ describe("z-indexing with frames", () => {
       ],
     });
   });
-
-  it("bringing to front / sending to back children of MULTIPLE frames at once moves all of them", () => {
-    assertZindex({
-      elements: [
-        { id: "F1_1", frameId: "F1", isSelected: true },
-        { id: "F1_2", frameId: "F1" },
-        { id: "F1", type: "frame" },
-        { id: "F2_1", frameId: "F2", isSelected: true },
-        { id: "F2_2", frameId: "F2" },
-        { id: "F2", type: "frame" },
-      ],
-      operations: [
-        // +∞: each selected child moves to the front of its own frame
-        [actionBringToFront, ["F1_2", "F1", "F1_1", "F2_2", "F2", "F2_1"]],
-        // -∞: each selected child moves to the back of its own frame
-        [actionSendToBack, ["F1_1", "F1_2", "F1", "F2_1", "F2_2", "F2"]],
-      ],
-    });
-  });
-
-  it("send to back / bring to front of a grouped frame child (in group-editing mode) must not duplicate elements", () => {
-    assertZindex({
-      elements: [
-        { id: "F1_1", frameId: "F1", groupIds: ["g1"] },
-        { id: "F1_2", frameId: "F1", groupIds: ["g1"], isSelected: true },
-        { id: "F1", type: "frame" },
-        { id: "F2_1", frameId: "F2", groupIds: ["g2"] },
-        { id: "F2_2", frameId: "F2", groupIds: ["g2"] },
-        { id: "F2", type: "frame" },
-      ],
-      appState: { editingGroupId: "g1" },
-      operations: [
-        // -∞ (send to back, within the frame)
-        [actionSendToBack, ["F1_2", "F1_1", "F1", "F2_1", "F2_2", "F2"]],
-        // +∞ (bring to front, within the frame)
-        [actionBringToFront, ["F1_1", "F1", "F1_2", "F2_1", "F2_2", "F2"]],
-      ],
-    });
-  });
-});
-
-/**
- * The inputs in this block intentionally VIOLATE the (soft) invariant that a
- * frame's children — and a group's members — are contiguous in the elements
- * array. Such states shouldn't occur in normal use, but they CAN arise from
- * bugs or broken input, because nothing re-defragments element order during
- * a reorder (`normalizeElementOrder` only runs on duplication). We keep these
- * tests so the reordering ops stay exercised against malformed order.
- *
- * HARD CONTRACT (a failure here is a real bug): a reorder must never throw,
- * duplicate, or drop elements. `assertReorderPreservesElements` checks this.
- *
- * SOFT SNAPSHOT (read before "fixing"): the exact resulting ORDER is NOT a
- * contract for invalid input — it's whatever the slice math happens to
- * produce. If a future change alters an `expected` order below, that is NOT
- * necessarily a functional regression. First confirm from the diff that the
- * hard contract still holds (nothing duplicated/lost), then update the
- * expected order to match, provided it's deemed an improvement over the
- * previous order, or it's an acceptable change given the underlying logic
- * change.
- */
-describe("z-index reordering with broken contiguity (invariant-violating input)", () => {
-  beforeEach(async () => {
-    await render(<Excalidraw />);
-  });
-
-  const assertReorderPreservesElements = (
-    elements: Parameters<typeof populateElements>[0],
-    appState: Parameters<typeof populateElements>[1],
-    // each op is applied to a freshly-populated (broken) state
-    cases: [Actions, string[]][],
-  ) => {
-    for (const [action, expected] of cases) {
-      populateElements(elements, appState);
-      const before = h.elements.map((el) => el.id);
-
-      expect(() => API.executeAction(action)).not.toThrow();
-
-      const after = h.elements.map((el) => el.id);
-      // hard contract:
-      expect(after.length).toBe(before.length); // no loss
-      expect(new Set(after).size).toBe(after.length); // no duplication
-      // soft snapshot (see block comment before changing):
-      expect(after).toEqual(expected);
-    }
-  };
-
-  it("discontiguous frame children (foreign frame's child interleaved in span)", () => {
-    // F2_1 (a child of frame F2) sits INSIDE frame F1's z-span. Reordering F1's
-    // child sweeps F2_1 along (span-based frame handling) — wrong ordering, but
-    // never a duplication/loss, and the op does not throw.
-    const elements: Parameters<typeof populateElements>[0] = [
-      { id: "F1_1", frameId: "F1", isSelected: true },
-      { id: "F2_1", frameId: "F2" },
-      { id: "F1_2", frameId: "F1" },
-      { id: "F1", type: "frame" },
-      { id: "F2", type: "frame" },
-    ];
-    assertReorderPreservesElements(elements, undefined, [
-      [actionBringForward, ["F2_1", "F1_2", "F1_1", "F1", "F2"]],
-      [actionSendBackward, ["F1_1", "F2_1", "F1_2", "F1", "F2"]],
-      [actionBringToFront, ["F2_1", "F1_2", "F1", "F1_1", "F2"]],
-      [actionSendToBack, ["F1_1", "F2_1", "F1_2", "F1", "F2"]],
-    ]);
-  });
-
-  it("discontiguous group, whole group selected", () => {
-    // g1 = {A, C}, scattered by the loose elements B and D.
-    const elements: Parameters<typeof populateElements>[0] = [
-      { id: "A", groupIds: ["g1"], isSelected: true },
-      { id: "B" },
-      { id: "C", groupIds: ["g1"], isSelected: true },
-      { id: "D" },
-    ];
-    assertReorderPreservesElements(elements, undefined, [
-      // move-by-one leaves the group scattered (each run moves independently)
-      [actionBringForward, ["B", "A", "D", "C"]],
-      [actionSendBackward, ["A", "C", "B", "D"]],
-      // to-front / to-back gather the scattered members back into one block
-      [actionBringToFront, ["B", "D", "A", "C"]],
-      [actionSendToBack, ["A", "C", "B", "D"]],
-    ]);
-  });
-
-  it("discontiguous group, single member selected in group-editing mode", () => {
-    const elements: Parameters<typeof populateElements>[0] = [
-      { id: "A", groupIds: ["g1"] },
-      { id: "B" },
-      { id: "C", groupIds: ["g1"], isSelected: true },
-      { id: "D" },
-    ];
-    assertReorderPreservesElements(elements, { editingGroupId: "g1" }, [
-      [actionBringForward, ["A", "B", "C", "D"]],
-      [actionSendBackward, ["C", "A", "B", "D"]],
-      [actionBringToFront, ["A", "B", "C", "D"]],
-      [actionSendToBack, ["C", "A", "B", "D"]],
-    ]);
-  });
-
-  it("two interleaved groups, both fully selected", () => {
-    const elements: Parameters<typeof populateElements>[0] = [
-      { id: "A", groupIds: ["g1"], isSelected: true },
-      { id: "X", groupIds: ["g2"], isSelected: true },
-      { id: "C", groupIds: ["g1"], isSelected: true },
-      { id: "Y", groupIds: ["g2"], isSelected: true },
-      { id: "Z" },
-    ];
-    assertReorderPreservesElements(elements, undefined, [
-      [actionBringForward, ["Z", "A", "X", "C", "Y"]],
-      [actionSendBackward, ["A", "X", "C", "Y", "Z"]],
-      [actionBringToFront, ["Z", "A", "X", "C", "Y"]],
-      [actionSendToBack, ["A", "X", "C", "Y", "Z"]],
-    ]);
-  });
-});
-
-describe("z-index reordering with inconsistent group-editing state", () => {
-  beforeEach(async () => {
-    await render(<Excalidraw />);
-  });
-
-  it("does not duplicate or drop elements when selected elements fall outside the edited group scope", () => {
-    assertZindex({
-      elements: [
-        { id: "A", groupIds: ["g1"], isSelected: true },
-        { id: "C", groupIds: ["g1"] },
-        { id: "X", groupIds: ["g2"] },
-        { id: "Y", groupIds: ["g2"] },
-        { id: "R" },
-      ],
-      appState: { editingGroupId: "g2" },
-      operations: [[actionSendToBack, ["A", "C", "X", "Y", "R"]]],
-    });
-
-    assertZindex({
-      elements: [
-        { id: "A", groupIds: ["g1"] },
-        { id: "C", groupIds: ["g1"] },
-        { id: "X", groupIds: ["g2"], isSelected: true },
-        { id: "Y", groupIds: ["g2"] },
-        { id: "R" },
-      ],
-      appState: { editingGroupId: "g1" },
-      operations: [[actionBringToFront, ["A", "C", "X", "Y", "R"]]],
-    });
-  });
 });

packages/excalidraw/CHANGELOG.md

@@ -17,13 +17,6 @@ Please add the latest change on the top under the correct section.
 
 ### Breaking changes
 
-- Theme changes initiated by the default UI are now delegated to `<Excalidraw onThemeChange={(theme) => ...} />` when supplied. If `onThemeChange` is not supplied, light/dark theme toggling still falls back to updating the internal editor state.
-
-  - `MainMenu.DefaultItems.ToggleTheme` no longer accepts the item-level `onSelect` callback. Host apps that need to control light/dark/system theme should pass `onThemeChange` to `<Excalidraw />` instead.
-  - `MainMenu.DefaultItems.ToggleTheme` with system theme support now uses `allowSystemTheme` together with `theme={Theme | "system"}` only to render the selected value. For the regular light/dark item, pass `allowSystemTheme={false}`.
-  - `CommandPalette.defaultItems.toggleTheme` was removed. The default theme command is now rendered by the command palette itself when `UIOptions.canvasActions.toggleTheme` enables the action (see below).
-  - `UIOptions.canvasActions.toggleTheme` still controls default theme UI availability. When it is `null`, it defaults to `true` if `props.theme` is omitted or `props.onThemeChange` is supplied, and otherwise defaults to disabled.
-
 - Renamed the `excalidrawAPI` prop to `onExcalidrawAPI`.
   - `onExcalidrawAPI` is now called on mount (instead of during constructor), and later on unmount (with `null` value). The API may be removed altogether in the future (you can use `onMount` & `onUmount` to manage the `ExcalidrawAPI` object (e.g. to cache it to a global state), already).
 

packages/excalidraw/actions/actionCanvas.tsx

@@ -477,28 +477,17 @@ export const actionToggleTheme = register<AppState["theme"]>({
     appState.theme === THEME.LIGHT ? MoonIcon : SunIcon,
   viewMode: true,
   trackEvent: { category: "canvas" },
-  perform: (_, appState, value, app) => {
-    const nextTheme =
-      value || (appState.theme === THEME.LIGHT ? THEME.DARK : THEME.LIGHT);
-
-    if (app.props.onThemeChange) {
-      app.props.onThemeChange(nextTheme);
-      return false;
-    }
-
+  perform: (_, appState, value) => {
     return {
       appState: {
         ...appState,
-        theme: nextTheme,
+        theme:
+          value || (appState.theme === THEME.LIGHT ? THEME.DARK : THEME.LIGHT),
       },
       captureUpdate: CaptureUpdateAction.EVENTUALLY,
     };
   },
-  keyTest: (event) =>
-    !event[KEYS.CTRL_OR_CMD] &&
-    event.altKey &&
-    event.shiftKey &&
-    event.code === CODES.D,
+  keyTest: (event) => event.altKey && event.shiftKey && event.code === CODES.D,
   predicate: (elements, appState, props, app) => {
     return !!app.props.UIOptions.canvasActions.toggleTheme;
   },

packages/excalidraw/actions/actionDeselect.ts

@@ -1,147 +0,0 @@
-import {
-  getElementsInGroup,
-  isSomeElementSelected,
-  makeNextSelectedElementIds,
-  selectGroupsForSelectedElements,
-} from "@excalidraw/element";
-import { CaptureUpdateAction } from "@excalidraw/element";
-import { KEYS, isWritableElement, updateActiveTool } from "@excalidraw/common";
-
-import type { GroupId } from "@excalidraw/element/types";
-
-import { register } from "./register";
-
-import type { AppClassProperties, AppState } from "../types";
-
-const getNextActiveTool = (
-  appState: Readonly<AppState>,
-  app: AppClassProperties,
-) => {
-  if (appState.activeTool.type === "eraser") {
-    return updateActiveTool(appState, {
-      ...(appState.activeTool.lastActiveTool || {
-        type: app.state.preferredSelectionTool.type,
-      }),
-      lastActiveToolBeforeEraser: null,
-    });
-  }
-
-  return updateActiveTool(appState, {
-    type: app.state.preferredSelectionTool.type,
-  });
-};
-
-const getParentEditingGroupId = (
-  appState: Readonly<AppState>,
-  app: AppClassProperties,
-  selectedElementIds: AppState["selectedElementIds"],
-): GroupId | null => {
-  if (!appState.editingGroupId) {
-    return null;
-  }
-
-  const nonDeletedElements = app.scene.getNonDeletedElements();
-  const selectedElements = app.scene.getSelectedElements({
-    selectedElementIds,
-    elements: nonDeletedElements,
-  });
-  const candidateElements = selectedElements.length
-    ? selectedElements
-    : getElementsInGroup(nonDeletedElements, appState.editingGroupId);
-
-  for (const element of candidateElements) {
-    const editingGroupIndex = element.groupIds.indexOf(appState.editingGroupId);
-    if (editingGroupIndex !== -1 && element.groupIds[editingGroupIndex + 1]) {
-      return element.groupIds[editingGroupIndex + 1] as GroupId;
-    }
-  }
-
-  return null;
-};
-
-export const actionDeselect = register({
-  name: "deselect",
-  label: "",
-  trackEvent: false,
-  perform: (_elements, appState, _, app) => {
-    const activeTool = getNextActiveTool(appState, app);
-
-    if (appState.editingGroupId) {
-      const nonDeletedElements = app.scene.getNonDeletedElements();
-      const selectedElementIds =
-        Object.keys(appState.selectedElementIds).length > 0
-          ? appState.selectedElementIds
-          : getElementsInGroup(
-              nonDeletedElements,
-              appState.editingGroupId,
-            ).reduce((acc, element) => {
-              acc[element.id] = true;
-              return acc;
-            }, {} as Record<string, true>);
-
-      return {
-        appState: {
-          ...appState,
-          ...selectGroupsForSelectedElements(
-            {
-              editingGroupId: getParentEditingGroupId(
-                appState,
-                app,
-                selectedElementIds,
-              ),
-              selectedElementIds,
-            },
-            nonDeletedElements,
-            appState,
-            app,
-          ),
-          activeEmbeddable: null,
-          activeTool,
-          selectedLinearElement: null,
-          selectionElement: null,
-          showHyperlinkPopup: false,
-          suggestedBinding: null,
-          frameToHighlight: null,
-        },
-        captureUpdate: CaptureUpdateAction.IMMEDIATELY,
-      };
-    }
-
-    return {
-      appState: {
-        ...appState,
-        activeEmbeddable: null,
-        activeTool,
-        editingGroupId: null,
-        selectedElementIds: makeNextSelectedElementIds({}, appState),
-        selectedGroupIds: {},
-        selectedLinearElement: null,
-        selectionElement: null,
-        showHyperlinkPopup: false,
-        suggestedBinding: null,
-        frameToHighlight: null,
-      },
-      captureUpdate: CaptureUpdateAction.IMMEDIATELY,
-    };
-  },
-  keyTest: (event, appState, _, app) => {
-    if (event.key !== KEYS.ESCAPE) {
-      return false;
-    }
-
-    if (isWritableElement(event.target)) {
-      return false;
-    }
-
-    return (
-      !appState.newElement &&
-      appState.multiElement === null &&
-      !appState.selectedLinearElement?.isEditing &&
-      (appState.activeEmbeddable !== null ||
-        appState.activeTool.type !== app.state.preferredSelectionTool.type ||
-        !!appState.editingGroupId ||
-        !!appState.selectedLinearElement ||
-        isSomeElementSelected(app.scene.getNonDeletedElements(), appState))
-    );
-  },
-});

packages/excalidraw/actions/actionFinalize.tsx

@@ -329,8 +329,8 @@ export const actionFinalize = register<FormData>({
         selectionElement: null,
         multiElement: null,
         editingTextElement: null,
+        startBoundElement: null,
         suggestedBinding: null,
-        frameToHighlight: null,
         selectedElementIds:
           element &&
           !appState.activeTool.locked &&
@@ -348,7 +348,9 @@ export const actionFinalize = register<FormData>({
     };
   },
   keyTest: (event, appState) =>
-    (event.key === KEYS.ESCAPE && appState.selectedLinearElement?.isEditing) ||
+    (event.key === KEYS.ESCAPE &&
+      (appState.selectedLinearElement?.isEditing ||
+        (!appState.newElement && appState.multiElement === null))) ||
     ((event.key === KEYS.ESCAPE || event.key === KEYS.ENTER) &&
       appState.multiElement !== null),
   PanelComponent: ({ appState, updateData, data }) => (

packages/excalidraw/actions/actionFrame.ts

@@ -205,6 +205,7 @@ export const actionWrapSelectionInFrame = register({
       [...app.scene.getElementsIncludingDeleted(), frame],
       selectedElements,
       frame,
+      appState,
     );
 
     return {

packages/excalidraw/actions/actionGroup.tsx

@@ -277,6 +277,7 @@ export const actionUngroup = register({
             elementsMap,
           ),
           frame,
+          app,
         );
       }
     });

packages/excalidraw/actions/actionHistory.tsx

@@ -1,4 +1,5 @@
 import {
+  isWindows,
   KEYS,
   matchKey,
   arrayToMap,
@@ -113,7 +114,7 @@ export const createRedoAction: ActionCreator = (history) => ({
     ),
   keyTest: (event) =>
     (event[KEYS.CTRL_OR_CMD] && event.shiftKey && matchKey(event, KEYS.Z)) ||
-    (event[KEYS.CTRL_OR_CMD] && !event.shiftKey && matchKey(event, KEYS.Y)),
+    (isWindows && event.ctrlKey && !event.shiftKey && matchKey(event, KEYS.Y)),
   PanelComponent: ({ appState, updateData, data, app }) => {
     const { isRedoStackEmpty } = useEmitter(
       history.onHistoryChangedEmitter,

packages/excalidraw/actions/index.ts

@@ -34,7 +34,6 @@ export {
 export { actionSetEmbeddableAsActiveTool } from "./actionEmbeddable";
 
 export { actionFinalize } from "./actionFinalize";
-export { actionDeselect } from "./actionDeselect";
 
 export {
   actionChangeProjectName,

packages/excalidraw/actions/types.ts

@@ -114,7 +114,6 @@ export type ActionName =
   | "distributeVertically"
   | "flipHorizontal"
   | "flipVertical"
-  | "deselect"
   | "viewMode"
   | "exportWithDarkMode"
   | "toggleTheme"

packages/excalidraw/animated-trail.ts

@@ -1,4 +1,5 @@
 import { LaserPointer } from "@excalidraw/laser-pointer";
+
 import {
   SVG_NS,
   getSvgPathFromStroke,
@@ -7,8 +8,7 @@ import {
 
 import type { LaserPointerOptions } from "@excalidraw/laser-pointer";
 
-import { AnimationController } from "./renderer/animation";
-
+import type { AnimationFrameHandler } from "./animation-frame-handler";
 import type App from "./components/App";
 import type { AppState } from "./types";
 
@@ -34,16 +34,15 @@ export class AnimatedTrail implements Trail {
   private container?: SVGSVGElement;
   private trailElement: SVGPathElement;
   private trailAnimation?: SVGAnimateElement;
-  private key: string;
-
-  private static counter = 0;
 
   constructor(
+    private animationFrameHandler: AnimationFrameHandler,
     protected app: App,
     private options: Partial<LaserPointerOptions> &
       Partial<AnimatedTrailOptions>,
   ) {
-    this.key = `animated-trail-${AnimatedTrail.counter++}`;
+    this.animationFrameHandler.register(this, this.onFrame.bind(this));
+
     this.trailElement = document.createElementNS(SVG_NS, "path");
     if (this.options.animateTrail) {
       this.trailAnimation = document.createElementNS(SVG_NS, "animate");
@@ -74,15 +73,6 @@ export class AnimatedTrail implements Trail {
     return false;
   }
 
-  private cleanup() {
-    this.pastTrails = [];
-    this.currentTrail = undefined;
-
-    if (this.trailElement.parentNode === this.container) {
-      this.container?.removeChild(this.trailElement);
-    }
-  }
-
   start(container?: SVGSVGElement) {
     if (container) {
       this.container = container;
@@ -92,23 +82,15 @@ export class AnimatedTrail implements Trail {
       this.container.appendChild(this.trailElement);
     }
 
-    if (!AnimationController.running(this.key)) {
-      AnimationController.start(this.key, () => {
-        const needsNext = this.onFrame();
-        if (needsNext) {
-          return { keep: true };
-        }
-
-        this.cleanup();
-
-        return null;
-      });
-    }
+    this.animationFrameHandler.start(this);
   }
 
   stop() {
-    AnimationController.cancel(this.key);
-    this.cleanup();
+    this.animationFrameHandler.stop(this);
+
+    if (this.trailElement.parentNode === this.container) {
+      this.container?.removeChild(this.trailElement);
+    }
   }
 
   startPath(x: number, y: number) {
@@ -163,25 +145,21 @@ export class AnimatedTrail implements Trail {
 
     if (this.currentTrail) {
       const currentPath = this.drawTrail(this.currentTrail, this.app.state);
+
       paths.push(currentPath);
     }
 
-    this.pastTrails = this.pastTrails.filter(
-      (t) =>
-        t.getStrokeOutline(t.options.size / this.app.state.zoom.value)
-          .length !== 0,
-    );
+    this.pastTrails = this.pastTrails.filter((trail) => {
+      return trail.getStrokeOutline().length !== 0;
+    });
 
     if (paths.length === 0) {
-      // Clean up the SVG path if there are no trails to render
-      this.trailElement.setAttribute("d", "");
-
-      return false;
+      this.stop();
     }
 
     const svgPaths = paths.join(" ").trim();
-    this.trailElement.setAttribute("d", svgPaths);
 
+    this.trailElement.setAttribute("d", svgPaths);
     if (this.trailAnimation) {
       this.trailElement.setAttribute(
         "fill",
@@ -197,8 +175,6 @@ export class AnimatedTrail implements Trail {
         (this.options.fill ?? (() => "black"))(this),
       );
     }
-
-    return true;
   }
 
   private drawTrail(trail: LaserPointer, state: AppState): string {

packages/excalidraw/animation-frame-handler.ts

@@ -0,0 +1,79 @@
+export type AnimationCallback = (timestamp: number) => void | boolean;
+
+export type AnimationTarget = {
+  callback: AnimationCallback;
+  stopped: boolean;
+};
+
+export class AnimationFrameHandler {
+  private targets = new WeakMap<object, AnimationTarget>();
+  private rafIds = new WeakMap<object, number>();
+
+  register(key: object, callback: AnimationCallback) {
+    this.targets.set(key, { callback, stopped: true });
+  }
+
+  start(key: object) {
+    const target = this.targets.get(key);
+
+    if (!target) {
+      return;
+    }
+
+    if (this.rafIds.has(key)) {
+      return;
+    }
+
+    this.targets.set(key, { ...target, stopped: false });
+    this.scheduleFrame(key);
+  }
+
+  stop(key: object) {
+    const target = this.targets.get(key);
+    if (target && !target.stopped) {
+      this.targets.set(key, { ...target, stopped: true });
+    }
+
+    this.cancelFrame(key);
+  }
+
+  private constructFrame(key: object): FrameRequestCallback {
+    return (timestamp: number) => {
+      const target = this.targets.get(key);
+
+      if (!target) {
+        return;
+      }
+
+      const shouldAbort = this.onFrame(target, timestamp);
+
+      if (!target.stopped && !shouldAbort) {
+        this.scheduleFrame(key);
+      } else {
+        this.cancelFrame(key);
+      }
+    };
+  }
+
+  private scheduleFrame(key: object) {
+    const rafId = requestAnimationFrame(this.constructFrame(key));
+
+    this.rafIds.set(key, rafId);
+  }
+
+  private cancelFrame(key: object) {
+    if (this.rafIds.has(key)) {
+      const rafId = this.rafIds.get(key)!;
+
+      cancelAnimationFrame(rafId);
+    }
+
+    this.rafIds.delete(key);
+  }
+
+  private onFrame(target: AnimationTarget, timestamp: number): boolean {
+    const shouldAbort = target.callback(timestamp);
+
+    return shouldAbort ?? false;
+  }
+}

packages/excalidraw/appState.ts

@@ -99,6 +99,7 @@ export const getDefaultAppState = (): Omit<
       open: false,
       panels: STATS_PANELS.generalStats | STATS_PANELS.elementProperties,
     },
+    startBoundElement: null,
     suggestedBinding: null,
     frameRendering: { enabled: true, clip: true, name: true, outline: true },
     frameToHighlight: null,
@@ -127,7 +128,6 @@ export const getDefaultAppState = (): Omit<
     lockedMultiSelections: {},
     activeLockedId: null,
     bindMode: "orbit",
-    boxSelectionMode: "contain",
   };
 };
 
@@ -193,7 +193,6 @@ const APP_STATE_STORAGE_CONF = (<
   gridModeEnabled: { browser: true, export: true, server: true },
   height: { browser: false, export: false, server: false },
   isBindingEnabled: { browser: true, export: false, server: false },
-  boxSelectionMode: { browser: true, export: false, server: false },
   bindingPreference: { browser: true, export: false, server: false },
   isMidpointSnappingEnabled: { browser: true, export: false, server: false },
   defaultSidebarDockedPreference: {
@@ -230,6 +229,7 @@ const APP_STATE_STORAGE_CONF = (<
   selectionElement: { browser: false, export: false, server: false },
   shouldCacheIgnoreZoom: { browser: true, export: false, server: false },
   stats: { browser: true, export: false, server: false },
+  startBoundElement: { browser: false, export: false, server: false },
   suggestedBinding: { browser: false, export: false, server: false },
   frameRendering: { browser: false, export: false, server: false },
   frameToHighlight: { browser: false, export: false, server: false },

packages/excalidraw/components/App.tsx

@@ -27,7 +27,7 @@ import {
   KEYS,
   APP_NAME,
   CURSOR_TYPE,
-  DEFAULT_TRANSFORM_HANDLE_SPACING,
+  DEFAULT_MAX_IMAGE_WIDTH_OR_HEIGHT,
   DEFAULT_VERTICAL_ALIGN,
   DRAGGING_THRESHOLD,
   ELEMENT_SHIFT_TRANSLATE_AMOUNT,
@@ -37,6 +37,7 @@ import {
   IMAGE_MIME_TYPES,
   IMAGE_RENDER_TIMEOUT,
   LINE_CONFIRM_THRESHOLD,
+  MAX_ALLOWED_FILE_BYTES,
   MIME_TYPES,
   MQ_RIGHT_SIDEBAR_MIN_WIDTH,
   POINTER_BUTTON,
@@ -174,9 +175,7 @@ import {
   isValidTextContainer,
   redrawTextBoundingBox,
   hasBoundingBox,
-  getCommonFrameId,
   getFrameChildren,
-  getFrameChildrenInsertionIndex,
   isCursorInFrame,
   addElementsToFrame,
   replaceAllElementsInFrame,
@@ -259,7 +258,6 @@ import {
   maybeHandleArrowPointlikeDrag,
   getUncroppedWidthAndHeight,
   getActiveTextElement,
-  isEligibleFrameChildType,
 } from "@excalidraw/element";
 
 import type { GlobalPoint, LocalPoint, Radians } from "@excalidraw/math";
@@ -343,6 +341,7 @@ import { ActionManager } from "../actions/manager";
 import { actions } from "../actions/register";
 import { getShortcutFromShortcutName } from "../actions/shortcuts";
 import { trackEvent } from "../analytics";
+import { AnimationFrameHandler } from "../animation-frame-handler";
 import {
   getDefaultAppState,
   isEraserActive,
@@ -416,7 +415,7 @@ import {
   setCursorForShape,
 } from "../cursor";
 import { ElementCanvasButtons } from "../components/ElementCanvasButtons";
-import { LaserTrails } from "../laserTrails";
+import { LaserTrails } from "../laser-trails";
 import { withBatchedUpdates, withBatchedUpdatesThrottled } from "../reactUtils";
 import { isPointHittingTextAutoResizeHandle } from "../textAutoResizeHandle";
 import { textWysiwyg } from "../wysiwyg/textWysiwyg";
@@ -603,8 +602,6 @@ const YOUTUBE_VIDEO_STATES = new Map<
   ValueOf<typeof YOUTUBE_STATES>
 >();
 
-const MAX_EMBEDDABLE_VIEWPORT_SCALE = 4;
-
 let IS_PLAIN_PASTE = false;
 let IS_PLAIN_PASTE_TIMER = 0;
 let PLAIN_PASTE_TOAST_SHOWN = false;
@@ -702,9 +699,11 @@ class App extends React.Component<AppProps, AppState> {
   previousPointerMoveCoords: { x: number; y: number } | null = null;
   lastViewportPosition = { x: 0, y: 0 };
 
-  laserTrails = new LaserTrails(this);
-  eraserTrail = new EraserTrail(this);
-  lassoTrail = new LassoTrail(this);
+  animationFrameHandler = new AnimationFrameHandler();
+
+  laserTrails = new LaserTrails(this.animationFrameHandler, this);
+  eraserTrail = new EraserTrail(this.animationFrameHandler, this);
+  lassoTrail = new LassoTrail(this.animationFrameHandler, this);
 
   onChangeEmitter = new Emitter<
     [
@@ -1735,18 +1734,6 @@ class App extends React.Component<AppProps, AppState> {
             this.state.activeEmbeddable?.element === el &&
             this.state.activeEmbeddable?.state === "hover";
 
-          // scale video embeds based on zoom (capped) so that smaller embeds
-          // on canvas when zoomed are still of legible quality
-          // (note: for some embed types like gdrive, the quality is poor when
-          // scaling mid playback and works only when you initially start the
-          // playback at the higher zoom level)
-          const shouldScaleEmbeddableViewport = src?.type === "video";
-          const embeddableViewportScale = clamp(
-            shouldScaleEmbeddableViewport ? scale : 1,
-            0.75,
-            MAX_EMBEDDABLE_VIEWPORT_SCALE,
-          );
-
           return (
             <div
               key={el.id}
@@ -1813,42 +1800,31 @@ class App extends React.Component<AppProps, AppState> {
                     padding: `${el.strokeWidth}px`,
                   }}
                 >
-                  <div
-                    className="excalidraw__embeddable__content"
-                    style={{
-                      width: `${embeddableViewportScale * 100}%`,
-                      height: `${embeddableViewportScale * 100}%`,
-                      transform: `scale(${1 / embeddableViewportScale})`,
-                    }}
-                  >
-                    {(isEmbeddableElement(el)
-                      ? this.props.renderEmbeddable?.(el, this.state)
-                      : null) ?? (
-                      <iframe
-                        ref={(ref) => this.cacheEmbeddableRef(el, ref)}
-                        className="excalidraw__embeddable"
-                        srcDoc={
-                          src?.type === "document"
-                            ? src.srcdoc(this.state.theme)
-                            : undefined
-                        }
-                        src={
-                          src?.type !== "document" ? src?.link ?? "" : undefined
-                        }
-                        // https://stackoverflow.com/q/18470015
-                        scrolling="no"
-                        referrerPolicy="no-referrer-when-downgrade"
-                        title="Excalidraw Embedded Content"
-                        allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
-                        allowFullScreen={true}
-                        sandbox={`${
-                          src?.sandbox?.allowSameOrigin
-                            ? "allow-same-origin"
-                            : ""
-                        } allow-scripts allow-forms allow-popups allow-popups-to-escape-sandbox allow-presentation allow-downloads`}
-                      />
-                    )}
-                  </div>
+                  {(isEmbeddableElement(el)
+                    ? this.props.renderEmbeddable?.(el, this.state)
+                    : null) ?? (
+                    <iframe
+                      ref={(ref) => this.cacheEmbeddableRef(el, ref)}
+                      className="excalidraw__embeddable"
+                      srcDoc={
+                        src?.type === "document"
+                          ? src.srcdoc(this.state.theme)
+                          : undefined
+                      }
+                      src={
+                        src?.type !== "document" ? src?.link ?? "" : undefined
+                      }
+                      // https://stackoverflow.com/q/18470015
+                      scrolling="no"
+                      referrerPolicy="no-referrer-when-downgrade"
+                      title="Excalidraw Embedded Content"
+                      allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
+                      allowFullScreen={true}
+                      sandbox={`${
+                        src?.sandbox?.allowSameOrigin ? "allow-same-origin" : ""
+                      } allow-scripts allow-forms allow-popups allow-popups-to-escape-sandbox allow-presentation allow-downloads`}
+                    />
+                  )}
                 </div>
               </div>
             </div>
@@ -1995,10 +1971,9 @@ class App extends React.Component<AppProps, AppState> {
               }
             }}
             style={{
-              background: applyDarkModeFilter(
-                this.state.viewBackgroundColor,
-                isDarkTheme,
-              ),
+              background: isDarkTheme
+                ? applyDarkModeFilter(this.state.viewBackgroundColor)
+                : this.state.viewBackgroundColor,
               zIndex: 2,
               border: "none",
               display: "block",
@@ -2091,30 +2066,20 @@ class App extends React.Component<AppProps, AppState> {
     const selectedElements = this.scene.getSelectedElements(this.state);
     const { renderTopRightUI, renderTopLeftUI, renderCustomStats } = this.props;
 
-    const {
-      elementsMap,
-      visibleElements,
-      canvasNonce,
-      /**
-       * element to draw on the <NewElementCanvas> for optimization purposes.
-       * Can be null even if this.state.newElement defined
-       * (e.g. when its zIndex isn't on top) */
-      newElementCanvasElement,
-    } = this.renderer.getRenderableElements({
-      zoom: this.state.zoom,
-      offsetLeft: this.state.offsetLeft,
-      offsetTop: this.state.offsetTop,
-      scrollX: this.state.scrollX,
-      scrollY: this.state.scrollY,
-      height: this.state.height,
-      width: this.state.width,
-      editingTextElement: this.state.editingTextElement,
-      newElement: this.state.newElement,
-      selectedElements,
-      selectedElementsAreBeingDragged:
-        this.state.selectedElementsAreBeingDragged,
-      frameToHighlight: this.state.frameToHighlight,
-    });
+    const sceneNonce = this.scene.getSceneNonce();
+    const { elementsMap, visibleElements } =
+      this.renderer.getRenderableElements({
+        sceneNonce,
+        zoom: this.state.zoom,
+        offsetLeft: this.state.offsetLeft,
+        offsetTop: this.state.offsetTop,
+        scrollX: this.state.scrollX,
+        scrollY: this.state.scrollY,
+        height: this.state.height,
+        width: this.state.width,
+        editingTextElement: this.state.editingTextElement,
+        newElementId: this.state.newElement?.id,
+      });
     this.visibleElements = visibleElements;
 
     const allElementsMap = this.scene.getNonDeletedElementsMap();
@@ -2333,7 +2298,7 @@ class App extends React.Component<AppProps, AppState> {
                             elementsMap={elementsMap}
                             allElementsMap={allElementsMap}
                             visibleElements={visibleElements}
-                            canvasNonce={canvasNonce}
+                            sceneNonce={sceneNonce}
                             selectionNonce={
                               this.state.selectionElement?.versionNonce
                             }
@@ -2354,10 +2319,9 @@ class App extends React.Component<AppProps, AppState> {
                               theme: this.state.theme,
                             }}
                           />
-                          {newElementCanvasElement && (
+                          {this.state.newElement && (
                             <NewElementCanvas
                               appState={this.state}
-                              newElement={newElementCanvasElement}
                               scale={window.devicePixelRatio}
                               rc={this.rc}
                               elementsMap={elementsMap}
@@ -2385,7 +2349,7 @@ class App extends React.Component<AppProps, AppState> {
                             visibleElements={visibleElements}
                             allElementsMap={allElementsMap}
                             selectedElements={selectedElements}
-                            canvasNonce={canvasNonce}
+                            sceneNonce={sceneNonce}
                             selectionNonce={
                               this.state.selectionElement?.versionNonce
                             }
@@ -2560,7 +2524,6 @@ class App extends React.Component<AppProps, AppState> {
     const magicFrameChildren = getElementsOverlappingFrame(
       this.scene.getNonDeletedElements(),
       magicFrame,
-      this.scene.getNonDeletedElementsMap(),
     ).filter((el) => !isMagicFrameElement(el));
 
     if (!magicFrameChildren.length) {
@@ -2697,7 +2660,7 @@ class App extends React.Component<AppProps, AppState> {
           locked: false,
         });
 
-        this.insertNewElement(frame);
+        this.scene.insertElement(frame);
 
         for (const child of selectedElements) {
           this.scene.mutateElement(child, { frameId: frame.id });
@@ -3775,7 +3738,6 @@ class App extends React.Component<AppProps, AppState> {
         position:
           this.editorInterface.formFactor === "desktop" ? "cursor" : "center",
         retainSeed: isPlainPaste,
-        preserveFrameChildrenOrder: true,
       });
       return;
     }
@@ -3919,7 +3881,6 @@ class App extends React.Component<AppProps, AppState> {
     position: { clientX: number; clientY: number } | "cursor" | "center";
     retainSeed?: boolean;
     fitToContent?: boolean;
-    preserveFrameChildrenOrder?: boolean;
   }) => {
     const elements = restoreElements(opts.elements, null, {
       deleteInvisibleElements: true,
@@ -3961,7 +3922,6 @@ class App extends React.Component<AppProps, AppState> {
         });
       }),
       randomizeSeed: !opts.retainSeed,
-      preserveFrameChildrenOrder: opts.preserveFrameChildrenOrder,
     });
 
     const prevElements = this.scene.getElementsIncludingDeleted();
@@ -3983,10 +3943,11 @@ class App extends React.Component<AppProps, AppState> {
         duplicatedElements,
         topLayerFrame,
       );
-      nextElements = addElementsToFrame(
+      addElementsToFrame(
         nextElements,
         eligibleElements,
         topLayerFrame,
+        this.state,
       );
     }
 
@@ -4212,7 +4173,7 @@ class App extends React.Component<AppProps, AppState> {
       return;
     }
 
-    this.insertNewElements(textElements);
+    this.scene.insertElements(textElements);
     this.store.scheduleCapture();
     this.setState({
       selectedElementIds: makeNextSelectedElementIds(
@@ -4613,7 +4574,6 @@ class App extends React.Component<AppProps, AppState> {
       }
 
       if (collaborators) {
-        this.laserTrails.updateCollabTrails(collaborators);
         this.setState({ collaborators });
       }
     },
@@ -5469,7 +5429,7 @@ class App extends React.Component<AppProps, AppState> {
     if (!event[KEYS.CTRL_OR_CMD]) {
       if (this.flowChartCreator.isCreatingChart) {
         if (this.flowChartCreator.pendingNodes?.length) {
-          this.insertNewElements(this.flowChartCreator.pendingNodes);
+          this.scene.insertElements(this.flowChartCreator.pendingNodes);
         }
 
         const firstNode = this.flowChartCreator.pendingNodes?.[0];
@@ -5567,7 +5527,6 @@ class App extends React.Component<AppProps, AppState> {
         selectedLinearElement: isSelectionLikeTool(nextActiveTool.type)
           ? prevState.selectedLinearElement
           : null,
-        frameToHighlight: null,
       } as const;
 
       if (nextActiveTool.type === "freedraw") {
@@ -5766,13 +5725,13 @@ class App extends React.Component<AppProps, AppState> {
         const isDeleted = !nextOriginalText.trim();
         updateElement(nextOriginalText, isDeleted);
 
-        // keyboard-submit keeps focus on the edited object. For bound text, keep
-        // the container selected even if the text becomes empty and is deleted.
-        const elementIdToSelect = viaKeyboard
-          ? element.containerId || (!isDeleted ? element.id : null)
-          : null;
+        // select the created text element only if submitting via keyboard
+        // (when submitting via click it should act as signal to deselect)
+        if (!isDeleted && viaKeyboard) {
+          const elementIdToSelect = element.containerId
+            ? element.containerId
+            : element.id;
 
-        if (elementIdToSelect) {
           // needed to ensure state is updated before "finalize" action
           // that's invoked on keyboard-submit as well
           // TODO either move this into finalize as well, or handle all state
@@ -6165,12 +6124,6 @@ class App extends React.Component<AppProps, AppState> {
         hitElement = elements[index];
         break;
       } else if (x1 < x && x < x2 && y1 < y && y < y2) {
-        // to allow binding to containers within frames,
-        // ignore frames in hit testing
-        if (isFrameLikeElement(elements[index])) {
-          continue;
-        }
-
         hitElement = elements[index];
         break;
       }
@@ -6260,6 +6213,11 @@ class App extends React.Component<AppProps, AppState> {
       }
     }
 
+    const topLayerFrame = this.getTopLayerFrameAtSceneCoords({
+      x: sceneX,
+      y: sceneY,
+    });
+
     const textCreationGridPoint = this.getTextCreationGridPoint(sceneX, sceneY);
 
     const newTextElementPosition = parentCenterPosition
@@ -6281,20 +6239,6 @@ class App extends React.Component<AppProps, AppState> {
           y: sceneY,
         };
 
-    const topLayerFrame = this.getTopLayerFrameAtSceneCoords({
-      x: newTextElementPosition.x,
-      y: newTextElementPosition.y,
-    });
-
-    // container has higher priority. Only add to frame if container is in the same frame.
-    const frameId =
-      topLayerFrame &&
-      (!shouldBindToContainer ||
-        !container ||
-        container.frameId === topLayerFrame.id)
-        ? topLayerFrame.id
-        : null;
-
     const element =
       existingTextElement ||
       newTextElement({
@@ -6324,7 +6268,7 @@ class App extends React.Component<AppProps, AppState> {
             ? (0 as Radians)
             : container.angle
           : (0 as Radians),
-        frameId,
+        frameId: topLayerFrame ? topLayerFrame.id : null,
       });
 
     if (!existingTextElement && shouldBindToContainer && container) {
@@ -6340,12 +6284,9 @@ class App extends React.Component<AppProps, AppState> {
     if (!existingTextElement) {
       if (container && shouldBindToContainer) {
         const containerIndex = this.scene.getElementIndex(container.id);
-        // TODO should use insertNewElement, after we update it to handle
-        // elements with containerId + frameId at the same time (containerId
-        // should take precedence when it comes to z-index)
-        this.scene.insertElementsAtIndex([element], containerIndex + 1);
+        this.scene.insertElementAtIndex(element, containerIndex + 1);
       } else {
-        this.insertNewElement(element);
+        this.scene.insertElement(element);
       }
     }
 
@@ -6727,161 +6668,19 @@ class App extends React.Component<AppProps, AppState> {
     }
   };
 
-  /**
-   * finds candidate frame under cursor (when dragging frame children/elements
-   * inside frames)
-   */
-  private getTopLayerFrameAtSceneCoords = (
-    /**
-     * should be already grid aligned (basically should be what the call site
-     * sets the element's coords to, if applicable)
-     */
-    sceneCoords: {
-      x: number;
-      y: number;
-    },
-    opts?: {
-      /** to exclude selected elements when dragging, etc. */
-      excludeElementIds?: AppState["selectedElementIds"];
-      currentFrameId?: ExcalidrawElement["frameId"];
-    },
-  ) => {
+  private getTopLayerFrameAtSceneCoords = (sceneCoords: {
+    x: number;
+    y: number;
+  }) => {
     const elementsMap = this.scene.getNonDeletedElementsMap();
-    const framesUnderCursor = this.scene
+    const frames = this.scene
       .getNonDeletedFramesLikes()
       .filter(
         (frame): frame is ExcalidrawFrameLikeElement =>
           !frame.locked && isCursorInFrame(sceneCoords, frame, elementsMap),
       );
 
-    if (!framesUnderCursor.length) {
-      return null;
-    }
-
-    const topLayerFrame = framesUnderCursor.at(-1)!;
-
-    const hitElement = this.getElementsAtPosition(
-      sceneCoords.x,
-      sceneCoords.y,
-      {
-        includeLockedElements: true,
-      },
-    ).findLast((element) => !opts?.excludeElementIds?.[element.id]);
-
-    if (hitElement) {
-      if (
-        isFrameLikeElement(hitElement) &&
-        // case: we're hitting a locked frame itself (frame's outline
-        // or later its bg once implemented)
-        !hitElement.locked
-      ) {
-        return topLayerFrame;
-      }
-
-      const hitElementIndex = this.scene.getElementIndex(hitElement.id);
-      const topLayerFrameIndex = this.scene.getElementIndex(topLayerFrame.id);
-
-      if (
-        hitElementIndex !== -1 &&
-        topLayerFrameIndex !== -1 &&
-        hitElementIndex <= topLayerFrameIndex
-      ) {
-        return topLayerFrame;
-      }
-
-      // to support a case of dragging a pre-existing frame child underneath
-      // a non-frame element covering the cursor
-      const currentFrame = opts?.currentFrameId
-        ? framesUnderCursor.find((frame) => frame.id === opts.currentFrameId) ??
-          null
-        : null;
-
-      if (currentFrame) {
-        return currentFrame;
-      }
-
-      return hitElement.frameId
-        ? framesUnderCursor.find((frame) => frame.id === hitElement.frameId) ??
-            null
-        : null;
-    }
-
-    return topLayerFrame;
-  };
-
-  private updateFrameToHighlight = (
-    frameToHighlight: AppState["frameToHighlight"],
-  ) => {
-    if (this.state.frameToHighlight !== frameToHighlight) {
-      this.setState({ frameToHighlight });
-    }
-  };
-
-  private maybeUpdateFrameToHighlightOnPointerMove = (
-    sceneCoords: { x: number; y: number },
-    isOverScrollBar: boolean,
-  ) => {
-    // currently this function is being called even during pointerdown so we
-    // need to make sure we don't re-set the state when dragging and similar
-    //
-    // But, we still want to reset on pointermove in case the state is stale
-    // so we updte even for non-eligible tool types
-    if (
-      this.state.newElement ||
-      this.state.multiElement ||
-      this.state.selectionElement ||
-      this.state.selectedElementsAreBeingDragged
-    ) {
-      return;
-    }
-
-    this.updateFrameToHighlight(
-      !isOverScrollBar && isEligibleFrameChildType(this.state.activeTool.type)
-        ? this.getTopLayerFrameAtSceneCoords(sceneCoords)
-        : null,
-    );
-  };
-
-  private insertNewElements = (elements: readonly ExcalidrawElement[]) => {
-    if (!elements.length) {
-      return;
-    }
-
-    const chunkedElements: ExcalidrawElement[][] = [];
-
-    for (const element of elements) {
-      const currentChunk = chunkedElements[chunkedElements.length - 1];
-
-      if (currentChunk?.[0].frameId === element.frameId) {
-        currentChunk.push(element);
-      } else {
-        chunkedElements.push([element]);
-      }
-    }
-
-    for (const chunk of chunkedElements) {
-      const frameId = chunk[0].frameId;
-
-      const insertionIndex = frameId
-        ? getFrameChildrenInsertionIndex(
-            this.scene.getElementsIncludingDeleted(),
-            frameId,
-          )
-        : null;
-      this.scene.insertElementsAtIndex(chunk, insertionIndex);
-    }
-  };
-
-  private insertNewElement = (element: ExcalidrawElement) => {
-    this.insertNewElements([element]);
-
-    const frame = element.frameId
-      ? this.scene.getNonDeletedElement(element.frameId)
-      : null;
-
-    this.updateFrameToHighlight(
-      frame && isFrameLikeElement(frame) ? frame : null,
-    );
+    return frames.length ? frames[frames.length - 1] : null;
   };
 
   private handleCanvasPointerMove = (
@@ -6983,14 +6782,6 @@ class App extends React.Component<AppProps, AppState> {
       }
     }
 
-    this.maybeUpdateFrameToHighlightOnPointerMove(
-      {
-        x: scenePointerX,
-        y: scenePointerY,
-      },
-      isOverScrollBar,
-    );
-
     if (
       !this.state.newElement &&
       isActiveToolNonLinearSnappable(this.state.activeTool.type)
@@ -7129,7 +6920,7 @@ class App extends React.Component<AppProps, AppState> {
               y: scenePointerY,
             },
           });
-          this.setState({ suggestedBinding: null });
+          this.setState({ suggestedBinding: null, startBoundElement: null });
           if (!this.state.activeTool.locked) {
             resetCursor(this.interactiveCanvas);
             this.setState((prevState) => ({
@@ -7204,23 +6995,27 @@ class App extends React.Component<AppProps, AppState> {
           },
           { informMutation: false, isDragging: false },
         );
-        const newLastIdx = multiElement.points.length - 1;
         this.setState({
           selectedLinearElement: {
             ...selectedLinearElement,
-            selectedPointsIndices: selectedLinearElement.selectedPointsIndices
-              ? [
-                  ...new Set(
-                    selectedLinearElement.selectedPointsIndices.map((idx) =>
-                      Math.min(idx, newLastIdx),
+            selectedPointsIndices:
+              selectedLinearElement.selectedPointsIndices?.includes(
+                multiElement.points.length,
+              )
+                ? [
+                    ...selectedLinearElement.selectedPointsIndices.filter(
+                      (idx) =>
+                        idx !== multiElement.points.length &&
+                        idx !== multiElement.points.length - 1,
                     ),
-                  ),
-                ]
-              : selectedLinearElement.selectedPointsIndices,
-            lastCommittedPoint: multiElement.points[newLastIdx],
+                    multiElement.points.length - 1,
+                  ]
+                : selectedLinearElement.selectedPointsIndices,
+            lastCommittedPoint:
+              multiElement.points[multiElement.points.length - 1],
             initialState: {
               ...selectedLinearElement.initialState,
-              lastClickedPoint: newLastIdx,
+              lastClickedPoint: multiElement.points.length - 1,
             },
           },
         });
@@ -7448,14 +7243,6 @@ class App extends React.Component<AppProps, AppState> {
           this.interactiveCanvas,
           isTextElement(hitElement) ? CURSOR_TYPE.TEXT : CURSOR_TYPE.CROSSHAIR,
         );
-      } else if (
-        !event[KEYS.CTRL_OR_CMD] &&
-        this.isHittingCommonBoundingBoxOfSelectedElements(
-          scenePointer,
-          selectedElements,
-        )
-      ) {
-        setCursor(this.interactiveCanvas, CURSOR_TYPE.MOVE);
       } else if (this.state.viewModeEnabled) {
         setCursor(this.interactiveCanvas, CURSOR_TYPE.GRAB);
       } else if (this.state.openDialog?.name === "elementLinkSelector") {
@@ -7773,6 +7560,7 @@ class App extends React.Component<AppProps, AppState> {
         appState: {
           newElement: null,
           editingTextElement: null,
+          startBoundElement: null,
           suggestedBinding: null,
           selectedElementIds: makeNextSelectedElementIds(
             Object.keys(this.state.selectedElementIds)
@@ -7946,24 +7734,17 @@ class App extends React.Component<AppProps, AppState> {
       const hitSelectedElement =
         pointerDownState.hit.element &&
         this.isASelectedElement(pointerDownState.hit.element);
-      const shouldForceLassoReselect =
-        event.altKey &&
-        event[KEYS.CTRL_OR_CMD] &&
-        !pointerDownState.resize.handleType;
-      const shouldStartLassoSelection =
-        shouldForceLassoReselect ||
-        (!pointerDownState.hit.hasHitCommonBoundingBoxOfSelectedElements &&
-          !pointerDownState.resize.handleType &&
-          !hitSelectedElement);
 
-      if (shouldStartLassoSelection) {
-        if (!this.lassoTrail.hasCurrentTrail) {
-          this.lassoTrail.startPath(
-            pointerDownState.origin.x,
-            pointerDownState.origin.y,
-            event.shiftKey,
-          );
-        }
+      if (
+        !pointerDownState.hit.hasHitCommonBoundingBoxOfSelectedElements &&
+        !pointerDownState.resize.handleType &&
+        !hitSelectedElement
+      ) {
+        this.lassoTrail.startPath(
+          pointerDownState.origin.x,
+          pointerDownState.origin.y,
+          event.shiftKey,
+        );
 
         // block dragging after lasso selection on PCs until the next pointer down
         // (on mobile or tablet, we want to allow user to drag immediately)
@@ -8952,14 +8733,12 @@ class App extends React.Component<AppProps, AppState> {
       DEFAULT_COLLISION_THRESHOLD / this.state.zoom.value,
       1,
     );
-    const boundsPadding =
-      (DEFAULT_TRANSFORM_HANDLE_SPACING * 2) / this.state.zoom.value;
     const [x1, y1, x2, y2] = getCommonBounds(selectedElements);
     return (
-      point.x > x1 - boundsPadding - threshold &&
-      point.x < x2 + boundsPadding + threshold &&
-      point.y > y1 - boundsPadding - threshold &&
-      point.y < y2 + boundsPadding + threshold
+      point.x > x1 - threshold &&
+      point.x < x2 + threshold &&
+      point.y > y1 - threshold &&
+      point.y < y2 + threshold
     );
   }
 
@@ -9045,7 +8824,7 @@ class App extends React.Component<AppProps, AppState> {
       pressures: simulatePressure ? [] : [event.pressure],
     });
 
-    this.insertNewElement(element);
+    this.scene.insertElement(element);
 
     this.setState((prevState) => {
       const nextSelectedElementIds = {
@@ -9060,8 +8839,18 @@ class App extends React.Component<AppProps, AppState> {
       };
     });
 
+    const boundElement = getHoveredElementForBinding(
+      pointFrom<GlobalPoint>(
+        pointerDownState.origin.x,
+        pointerDownState.origin.y,
+      ),
+      this.scene.getNonDeletedElements(),
+      this.scene.getNonDeletedElementsMap(),
+    );
+
     this.setState({
       newElement: element,
+      startBoundElement: boundElement,
       suggestedBinding: null,
     });
   };
@@ -9102,7 +8891,7 @@ class App extends React.Component<AppProps, AppState> {
       height,
     });
 
-    this.insertNewElement(element);
+    this.scene.insertElement(element);
 
     return element;
   };
@@ -9156,7 +8945,7 @@ class App extends React.Component<AppProps, AppState> {
       link,
     });
 
-    this.insertNewElement(element);
+    this.scene.insertElement(element);
 
     return element;
   };
@@ -9400,7 +9189,7 @@ class App extends React.Component<AppProps, AppState> {
         points: [pointFrom<LocalPoint>(0, 0), pointFrom<LocalPoint>(0, 0)],
       });
 
-      this.insertNewElement(element);
+      this.scene.insertElement(element);
 
       if (isBindingElement(element)) {
         // Do the initial binding so the binding strategy has the initial state
@@ -9558,7 +9347,7 @@ class App extends React.Component<AppProps, AppState> {
         selectionElement: element,
       });
     } else {
-      this.insertNewElement(element);
+      this.scene.insertElement(element);
       this.setState({
         multiElement: null,
         newElement: element,
@@ -9591,7 +9380,7 @@ class App extends React.Component<AppProps, AppState> {
         ? newMagicFrameElement(constructorOpts)
         : newFrameElement(constructorOpts);
 
-    this.insertNewElement(frame);
+    this.scene.insertElement(frame);
 
     this.setState({
       multiElement: null,
@@ -9959,17 +9748,18 @@ class App extends React.Component<AppProps, AppState> {
           return;
         }
 
-        const selectedElementsHasAFrame = selectedElements.some((e) =>
+        const selectedElementsHasAFrame = selectedElements.find((e) =>
           isFrameLikeElement(e),
         );
-        const frameToHighlight = selectedElementsHasAFrame
-          ? null
-          : this.getTopLayerFrameAtSceneCoords(pointerCoords, {
-              currentFrameId: getCommonFrameId(selectedElements),
-              excludeElementIds: this.state.selectedElementIds,
-            });
+        const topLayerFrame = this.getTopLayerFrameAtSceneCoords(pointerCoords);
+        const frameToHighlight =
+          topLayerFrame && !selectedElementsHasAFrame ? topLayerFrame : null;
         // Only update the state if there is a difference
-        this.updateFrameToHighlight(frameToHighlight);
+        if (this.state.frameToHighlight !== frameToHighlight) {
+          flushSync(() => {
+            this.setState({ frameToHighlight });
+          });
+        }
 
         // Marking that click was used for dragging to check
         // if elements should be deselected on pointerup
@@ -10405,38 +10195,20 @@ class App extends React.Component<AppProps, AppState> {
           );
 
           let linearElementEditor = this.state.selectedLinearElement;
-
-          if (
-            !linearElementEditor ||
-            linearElementEditor.elementId !== newElement.id
-          ) {
+          if (!linearElementEditor) {
             linearElementEditor = new LinearElementEditor(
               newElement,
               this.scene.getNonDeletedElementsMap(),
             );
-          }
-
-          const lastClickedPointOutOfBounds =
-            linearElementEditor &&
-            (linearElementEditor.initialState.lastClickedPoint < 0 ||
-              linearElementEditor.initialState.lastClickedPoint >=
-                points.length);
-          if (lastClickedPointOutOfBounds) {
-            console.warn(
-              "Last clicked point is out of bounds. Attempting to fix it.",
-            );
             linearElementEditor = {
               ...linearElementEditor,
-              selectedPointsIndices: [points.length - 1],
+              selectedPointsIndices: [1],
               initialState: {
                 ...linearElementEditor.initialState,
-                prevSelectedPointsIndices: null,
-                lastClickedPoint: points.length - 1,
+                lastClickedPoint: 1,
               },
-              hoverPointIndex: points.length - 1,
             };
           }
-
           this.setState({
             newElement,
             ...LinearElementEditor.handlePointDragging(
@@ -10499,7 +10271,6 @@ class App extends React.Component<AppProps, AppState> {
                 this.state.selectionElement,
                 this.scene.getNonDeletedElementsMap(),
                 false,
-                this.state.boxSelectionMode,
               )
             : [];
 
@@ -10931,7 +10702,7 @@ class App extends React.Component<AppProps, AppState> {
               sceneCoords,
             });
           }
-          this.setState({ suggestedBinding: null });
+          this.setState({ suggestedBinding: null, startBoundElement: null });
           if (!activeTool.locked) {
             resetCursor(this.interactiveCanvas);
             this.setState((prevState) => ({
@@ -10952,9 +10723,9 @@ class App extends React.Component<AppProps, AppState> {
               ),
             }));
           } else {
-            this.setState({
+            this.setState((prevState) => ({
               newElement: null,
-            });
+            }));
           }
           // so that the scene gets rendered again to display the newly drawn linear as well
           this.scene.triggerUpdate();
@@ -11016,6 +10787,7 @@ class App extends React.Component<AppProps, AppState> {
             this.scene.getElementsMapIncludingDeleted(),
             elementsInsideFrame,
             newElement,
+            this.state,
           ),
         );
       }
@@ -11075,14 +10847,9 @@ class App extends React.Component<AppProps, AppState> {
           }
         } else {
           // update the relationships between selected elements and frames
+          const topLayerFrame = this.getTopLayerFrameAtSceneCoords(sceneCoords);
+
           const selectedElements = this.scene.getSelectedElements(this.state);
-          const topLayerFrame = this.getTopLayerFrameAtSceneCoords(
-            sceneCoords,
-            {
-              currentFrameId: getCommonFrameId(selectedElements),
-              excludeElementIds: this.state.selectedElementIds,
-            },
-          );
           let nextElements = this.scene.getElementsMapIncludingDeleted();
 
           const updateGroupIdsAfterEditingGroup = (
@@ -11131,8 +10898,10 @@ class App extends React.Component<AppProps, AppState> {
             topLayerFrame &&
             !this.state.selectedElementIds[topLayerFrame.id]
           ) {
-            const elementsToAdd = selectedElements.filter((element) =>
-              isElementInFrame(element, nextElements, this.state),
+            const elementsToAdd = selectedElements.filter(
+              (element) =>
+                element.frameId !== topLayerFrame.id &&
+                isElementInFrame(element, nextElements, this.state),
             );
 
             if (this.state.editingGroupId) {
@@ -11143,6 +10912,7 @@ class App extends React.Component<AppProps, AppState> {
               nextElements,
               elementsToAdd,
               topLayerFrame,
+              this.state,
             );
           } else if (!topLayerFrame) {
             if (this.state.editingGroupId) {
@@ -11204,6 +10974,7 @@ class App extends React.Component<AppProps, AppState> {
               elementsMap,
             ),
             frame,
+            this,
           );
         }
 
@@ -11718,11 +11489,9 @@ class App extends React.Component<AppProps, AppState> {
 
     const existingFileData = this.files[fileId];
     if (!existingFileData?.dataURL) {
-      const { maxWidthOrHeight, maxFileSizeBytes } = this.props.imageOptions;
-
       try {
         imageFile = await resizeImageFile(imageFile, {
-          maxWidthOrHeight,
+          maxWidthOrHeight: DEFAULT_MAX_IMAGE_WIDTH_OR_HEIGHT,
         });
       } catch (error: any) {
         console.error(
@@ -11731,10 +11500,10 @@ class App extends React.Component<AppProps, AppState> {
         );
       }
 
-      if (imageFile.size > maxFileSizeBytes) {
+      if (imageFile.size > MAX_ALLOWED_FILE_BYTES) {
         throw new Error(
           t("errors.fileTooBig", {
-            maxSize: `${Math.trunc(maxFileSizeBytes / 1024 / 1024)}MB`,
+            maxSize: `${Math.trunc(MAX_ALLOWED_FILE_BYTES / 1024 / 1024)}MB`,
           }),
         );
       }
@@ -12021,7 +11790,7 @@ class App extends React.Component<AppProps, AppState> {
       sceneY,
       gridPadding,
     );
-    this.insertNewElements(placeholders);
+    placeholders.forEach((el) => this.scene.insertElement(el));
 
     // Create, position, insert and select initialized (replacing placeholders)
     const initialized = await Promise.all(
@@ -12149,7 +11918,6 @@ class App extends React.Component<AppProps, AppState> {
               type: "everything",
               elements: item.elements,
               randomizeSeed: true,
-              preserveFrameChildrenOrder: true,
             }).duplicatedElements,
           }));
 

packages/excalidraw/components/CommandPalette/CommandPalette.tsx

@@ -19,7 +19,6 @@ import {
   actionClearCanvas,
   actionLink,
   actionToggleSearchMenu,
-  actionToggleTheme,
 } from "../../actions";
 import {
   actionCopyElementLink,
@@ -425,7 +424,6 @@ function CommandPaletteInner({
       ];
 
       const additionalCommands: CommandPaletteItem[] = [
-        actionToCommand(actionToggleTheme, DEFAULT_CATEGORIES.app),
         {
           label: t("toolBar.library"),
           category: DEFAULT_CATEGORIES.app,

packages/excalidraw/components/CommandPalette/defaultCommandPaletteItems.ts

@@ -1 +1,12 @@
-export {};
+import { actionToggleTheme } from "../../actions";
+
+import type { CommandPaletteItem } from "./types";
+
+export const toggleTheme: CommandPaletteItem = {
+  ...actionToggleTheme,
+  category: "App",
+  label: "Toggle theme",
+  perform: ({ actionManager }) => {
+    actionManager.executeAction(actionToggleTheme, "commandPalette");
+  },
+};

packages/excalidraw/components/ConvertElementTypePopup.tsx

@@ -831,13 +831,14 @@ const convertElementType = <
       newElement({
         ...element,
         type: targetType,
-        roundness: element.roundness
-          ? {
-              type: isUsingAdaptiveRadius(targetType)
-                ? ROUNDNESS.ADAPTIVE_RADIUS
-                : ROUNDNESS.PROPORTIONAL_RADIUS,
-            }
-          : element.roundness,
+        roundness:
+          targetType === "diamond" && element.roundness
+            ? {
+                type: isUsingAdaptiveRadius(targetType)
+                  ? ROUNDNESS.ADAPTIVE_RADIUS
+                  : ROUNDNESS.PROPORTIONAL_RADIUS,
+              }
+            : element.roundness,
       }),
     ) as typeof element;
 

packages/excalidraw/components/FontPicker/FontPickerList.tsx

@@ -46,7 +46,6 @@ import {
 import { fontPickerKeyHandler } from "./keyboardNavHandlers";
 
 import type { JSX } from "react";
-import type { ExcalidrawFontFace } from "../../fonts/ExcalidrawFontFace";
 
 export interface FontDescriptor {
   value: number;
@@ -87,15 +86,6 @@ const getFontFamilyIcon = (fontFamily: FontFamilyValues): JSX.Element => {
   }
 };
 
-const getFontFamilyLabel = (
-  fontFamily: FontFamilyValues,
-  fontFaces: ExcalidrawFontFace[],
-) =>
-  // prefer our config as the browser resolved names may be wrapped in quotes and such
-  Object.entries(FONT_FAMILY).find(([, id]) => id === fontFamily)?.[0] ??
-  fontFaces[0]?.fontFace?.family ??
-  "Unknown";
-
 export const FontPickerList = React.memo(
   ({
     selectedFontFamily,
@@ -124,7 +114,7 @@ export const FontPickerList = React.memo(
             const fontDescriptor = {
               value: familyId,
               icon: getFontFamilyIcon(familyId),
-              text: getFontFamilyLabel(familyId, fontFaces),
+              text: fontFaces[0]?.fontFace?.family ?? "Unknown",
             };
 
             if (metadata.deprecated) {

packages/excalidraw/components/HelpDialog.tsx

@@ -4,13 +4,11 @@ import { isDarwin, isFirefox, isWindows } from "@excalidraw/common";
 
 import { KEYS } from "@excalidraw/common";
 
-import { actionToggleTheme } from "../actions";
 import { getShortcutFromShortcutName } from "../actions/shortcuts";
 import { probablySupportsClipboardBlob } from "../clipboard";
 import { t } from "../i18n";
 import { getShortcutKey } from "../shortcut";
 
-import { useExcalidrawActionManager } from "./App";
 import { Dialog } from "./Dialog";
 import { ExternalLinkIcon, GithubIcon, youtubeIcon } from "./icons";
 
@@ -126,7 +124,6 @@ const ShortcutKey = (props: { children: React.ReactNode }) => (
 );
 
 export const HelpDialog = ({ onClose }: { onClose?: () => void }) => {
-  const actionManager = useExcalidrawActionManager();
   const handleClose = React.useCallback(() => {
     if (onClose) {
       onClose();
@@ -305,12 +302,10 @@ export const HelpDialog = ({ onClose }: { onClose?: () => void }) => {
               label={t("labels.viewMode")}
               shortcuts={[getShortcutKey("Alt+R")]}
             />
-            {actionManager.isActionEnabled(actionToggleTheme) && (
-              <Shortcut
-                label={t("labels.toggleTheme")}
-                shortcuts={[getShortcutKey("Alt+Shift+D")]}
-              />
-            )}
+            <Shortcut
+              label={t("labels.toggleTheme")}
+              shortcuts={[getShortcutKey("Alt+Shift+D")]}
+            />
             <Shortcut
               label={t("stats.fullTitle")}
               shortcuts={[getShortcutKey("Alt+/")]}

packages/excalidraw/components/Island.scss

@@ -7,6 +7,7 @@
     border-radius: var(--border-radius-lg);
     padding: calc(var(--padding) * var(--space-factor));
     position: relative;
+    transition: box-shadow 0.5s ease-in-out;
 
     &.zen-mode {
       box-shadow: none;

packages/excalidraw/components/LayerUI.tsx

@@ -122,7 +122,7 @@ const DefaultMainMenu: React.FC<{
         <MainMenu.DefaultItems.Socials />
       </MainMenu.Group>
       <MainMenu.Separator />
-      <MainMenu.DefaultItems.ToggleTheme allowSystemTheme={false} />
+      <MainMenu.DefaultItems.ToggleTheme />
       <MainMenu.DefaultItems.ChangeCanvasBackground />
     </MainMenu>
   );
@@ -650,7 +650,8 @@ const LayerUI = ({
 };
 
 const stripIrrelevantAppStateProps = (appState: AppState): UIAppState => {
-  const { cursorButton, scrollX, scrollY, ...ret } = appState;
+  const { startBoundElement, cursorButton, scrollX, scrollY, ...ret } =
+    appState;
   return ret;
 };
 

packages/excalidraw/components/LibraryMenuItems.tsx

@@ -199,7 +199,6 @@ export default function LibraryMenuItems({
             type: "everything",
             elements: item.elements,
             randomizeSeed: true,
-            preserveFrameChildrenOrder: true,
           }).duplicatedElements,
         };
       });

packages/excalidraw/components/RadioGroup.scss

@@ -26,17 +26,13 @@
     background: var(--RadioGroup-background);
     border: 1px solid var(--RadioGroup-border);
 
-    gap: 2px;
-
     &__choice {
-      box-sizing: content-box;
       position: relative;
       display: flex;
       align-items: center;
       justify-content: center;
-      min-width: 20px;
+      width: 32px;
       height: 24px;
-      padding: 0 0.375rem;
 
       color: var(--RadioGroup-choice-color-off);
       background: var(--RadioGroup-choice-background-off);
@@ -51,11 +47,13 @@
       user-select: none;
       letter-spacing: 0.4px;
 
+      transition: all 75ms ease-out;
+
       &:hover {
         color: var(--RadioGroup-choice-color-off-hover);
       }
 
-      &:not(.active):active {
+      &:active {
         background: var(--RadioGroup-choice-background-off-active);
       }
 

packages/excalidraw/components/SVGLayer.tsx

@@ -2,7 +2,7 @@ import { useEffect, useRef } from "react";
 
 import "./SVGLayer.scss";
 
-import type { Trail } from "../animatedTrail";
+import type { Trail } from "../animated-trail";
 
 type SVGLayerProps = {
   trails: Trail[];

packages/excalidraw/components/Stats/Dimension.tsx

@@ -206,6 +206,7 @@ const handleDimensionChange: DragInputCallbackType<
           scene.getElementsIncludingDeleted(),
           nextElementsInFrame,
           latestElement,
+          app,
         );
 
         scene.replaceAllElements(updatedElements);
@@ -301,6 +302,7 @@ const handleDragFinished: DragFinishedCallbackType = ({
       app.scene.getElementsIncludingDeleted(),
       nextElementsInFrame,
       latestElement,
+      app,
     );
 
     app.scene.replaceAllElements(updatedElements);

packages/excalidraw/components/Stats/MultiDimension.tsx

@@ -261,6 +261,7 @@ const handleDimensionChange: DragInputCallbackType<
               scene.getElementsIncludingDeleted(),
               nextElementsInFrame,
               latestElement,
+              app,
             );
 
             scene.replaceAllElements(updatedElements);
@@ -415,6 +416,7 @@ const handleDragFinished: DragFinishedCallbackType = ({
       app.scene.getElementsIncludingDeleted(),
       nextElementsInFrame,
       latestElement,
+      app,
     );
 
     app.scene.replaceAllElements(updatedElements);

packages/excalidraw/components/Stats/stats.test.tsx

@@ -750,7 +750,7 @@ describe("frame resizing behavior", () => {
       x: 0,
       y: 0,
       width: 100,
-      height: 103,
+      height: 100,
     });
 
     // Create a rectangle outside the frame

packages/excalidraw/components/canvases/InteractiveCanvas.tsx

@@ -39,7 +39,7 @@ type InteractiveCanvasProps = {
   visibleElements: readonly NonDeletedExcalidrawElement[];
   selectedElements: readonly NonDeletedExcalidrawElement[];
   allElementsMap: NonDeletedSceneElementsMap;
-  canvasNonce: string;
+  sceneNonce: number | undefined;
   selectionNonce: number | undefined;
   scale: number;
   appState: InteractiveCanvasAppState;
@@ -279,10 +279,10 @@ const areEqual = (
   // This could be further optimised if needed, as we don't have to render interactive canvas on each scene mutation
   if (
     prevProps.selectionNonce !== nextProps.selectionNonce ||
-    prevProps.canvasNonce !== nextProps.canvasNonce ||
+    prevProps.sceneNonce !== nextProps.sceneNonce ||
     prevProps.scale !== nextProps.scale ||
     // we need to memoize on elementsMap because they may have renewed
-    // even if canvasNonce didn't change (e.g. we filter elements out based
+    // even if sceneNonce didn't change (e.g. we filter elements out based
     // on appState)
     prevProps.elementsMap !== nextProps.elementsMap ||
     prevProps.visibleElements !== nextProps.visibleElements ||

packages/excalidraw/components/canvases/NewElementCanvas.tsx

@@ -14,7 +14,6 @@ import type { RoughCanvas } from "roughjs/bin/canvas";
 
 interface NewElementCanvasProps {
   appState: AppState;
-  newElement: NonNullable<AppState["newElement"]>;
   elementsMap: RenderableElementsMap;
   allElementsMap: NonDeletedSceneElementsMap;
   scale: number;
@@ -32,7 +31,7 @@ const NewElementCanvas = (props: NewElementCanvasProps) => {
       {
         canvas: canvasRef.current,
         scale: props.scale,
-        newElement: props.newElement,
+        newElement: props.appState.newElement,
         elementsMap: props.elementsMap,
         allElementsMap: props.allElementsMap,
         rc: props.rc,

packages/excalidraw/components/canvases/StaticCanvas.tsx

@@ -23,7 +23,7 @@ type StaticCanvasProps = {
   elementsMap: RenderableElementsMap;
   allElementsMap: NonDeletedSceneElementsMap;
   visibleElements: readonly NonDeletedExcalidrawElement[];
-  canvasNonce: string;
+  sceneNonce: number | undefined;
   selectionNonce: number | undefined;
   scale: number;
   appState: StaticCanvasAppState;
@@ -110,10 +110,10 @@ const areEqual = (
   nextProps: StaticCanvasProps,
 ) => {
   if (
-    prevProps.canvasNonce !== nextProps.canvasNonce ||
+    prevProps.sceneNonce !== nextProps.sceneNonce ||
     prevProps.scale !== nextProps.scale ||
     // we need to memoize on elementsMap because they may have renewed
-    // even if canvasNonce didn't change (e.g. we filter elements out based
+    // even if sceneNonce didn't change (e.g. we filter elements out based
     // on appState)
     prevProps.elementsMap !== nextProps.elementsMap ||
     prevProps.visibleElements !== nextProps.visibleElements

packages/excalidraw/components/dropdownMenu/DropdownMenu.scss

@@ -2,7 +2,7 @@
 
 .excalidraw {
   .dropdown-menu {
-    max-width: 20rem;
+    max-width: 16rem;
     z-index: 1;
 
     &--placement-top {

packages/excalidraw/components/dropdownMenu/DropdownMenuItemContentRadio.tsx

@@ -1,5 +1,4 @@
 import { useEditorInterface } from "../App";
-import { Ellipsify } from "../Ellipsify";
 import { RadioGroup } from "../RadioGroup";
 
 type Props<T> = {
@@ -13,7 +12,6 @@ type Props<T> = {
   onChange: (value: T) => void;
   children: React.ReactNode;
   name: string;
-  icon?: React.ReactNode;
 };
 
 const DropdownMenuItemContentRadio = <T,>({
@@ -23,17 +21,13 @@ const DropdownMenuItemContentRadio = <T,>({
   choices,
   children,
   name,
-  icon,
 }: Props<T>) => {
   const editorInterface = useEditorInterface();
 
   return (
     <>
       <div className="dropdown-menu-item-base dropdown-menu-item-bare">
-        {icon && <div className="dropdown-menu-item__icon">{icon}</div>}
-        <label className="dropdown-menu-item__text">
-          <Ellipsify>{children}</Ellipsify>
-        </label>
+        <label className="dropdown-menu-item__text">{children}</label>
         <RadioGroup
           name={name}
           value={value}

packages/excalidraw/components/main-menu/DefaultItems.tsx

@@ -39,13 +39,7 @@ import DropdownMenuItemCheckbox from "../dropdownMenu/DropdownMenuItemCheckbox";
 import DropdownMenuItemContentRadio from "../dropdownMenu/DropdownMenuItemContentRadio";
 import DropdownMenuItemLink from "../dropdownMenu/DropdownMenuItemLink";
 import DropdownMenuSub from "../dropdownMenu/DropdownMenuSub";
-import {
-  GithubIcon,
-  DiscordIcon,
-  XBrandIcon,
-  settingsIcon,
-  emptyIcon,
-} from "../icons";
+import { GithubIcon, DiscordIcon, XBrandIcon, settingsIcon } from "../icons";
 import {
   boltIcon,
   DeviceDesktopIcon,
@@ -232,22 +226,18 @@ export const ToggleTheme = (
   props:
     | {
         allowSystemTheme: true;
-        /**
-         * Controls the theme of this UI component only.
-         * You should subscribe to `props.onThemeChange` and control the theme
-         * upstream.
-         */
         theme: Theme | "system";
+        onSelect: (theme: Theme | "system") => void;
       }
     | {
-        allowSystemTheme: false;
+        allowSystemTheme?: false;
+        onSelect?: (theme: Theme) => void;
       },
 ) => {
   const { t } = useI18n();
   const appState = useUIAppState();
   const actionManager = useExcalidrawActionManager();
   const shortcut = getShortcutFromShortcutName("toggleTheme");
-  const appProps = useAppProps();
 
   if (!actionManager.isActionEnabled(actionToggleTheme)) {
     return null;
@@ -258,16 +248,7 @@ export const ToggleTheme = (
       <DropdownMenuItemContentRadio
         name="theme"
         value={props.theme}
-        onChange={(value: Theme | "system") => {
-          if (appProps.onThemeChange) {
-            appProps.onThemeChange(value);
-            return;
-          }
-
-          console.warn(
-            "MainMenu.DefaultItems.ToggleTheme: `<Excalidraw/> props.onThemeChange` must be defined to use system theme selection.",
-          );
-        }}
+        onChange={(value: Theme | "system") => props.onSelect(value)}
         choices={[
           {
             value: THEME.LIGHT,
@@ -297,7 +278,13 @@ export const ToggleTheme = (
         // do not close the menu when changing theme
         event.preventDefault();
 
-        actionManager.executeAction(actionToggleTheme);
+        if (props?.onSelect) {
+          props.onSelect(
+            appState.theme === THEME.DARK ? THEME.LIGHT : THEME.DARK,
+          );
+        } else {
+          return actionManager.executeAction(actionToggleTheme);
+        }
       }}
       icon={appState.theme === THEME.DARK ? SunIcon : MoonIcon}
       data-testid="toggle-dark-mode"
@@ -440,39 +427,6 @@ const PreferencesToggleToolLockItem = () => {
   );
 };
 
-const PreferencesBoxSelectionModeItem = () => {
-  const { t } = useI18n();
-  const appState = useUIAppState();
-  const setAppState = useExcalidrawSetAppState();
-
-  return (
-    <DropdownMenuItemContentRadio<"contain" | "overlap">
-      name="boxSelectionMode"
-      icon={emptyIcon}
-      value={appState.boxSelectionMode}
-      onChange={(value) => {
-        setAppState({
-          boxSelectionMode: value,
-        });
-      }}
-      choices={[
-        {
-          value: "contain",
-          label: t("labels.boxSelectionContain"),
-          ariaLabel: t("labels.boxSelectionContain"),
-        },
-        {
-          value: "overlap",
-          label: t("labels.boxSelectionOverlap"),
-          ariaLabel: t("labels.boxSelectionOverlap"),
-        },
-      ]}
-    >
-      {t("labels.boxSelectionMode")}
-    </DropdownMenuItemContentRadio>
-  );
-};
-
 const PreferencesToggleSnapModeItem = () => {
   const { t } = useI18n();
   const actionManager = useExcalidrawActionManager();
@@ -614,7 +568,6 @@ export const Preferences = ({
       <DropdownMenuSub.Content className="excalidraw-main-menu-preferences-submenu">
         {children || (
           <>
-            <PreferencesBoxSelectionModeItem />
             <PreferencesToggleToolLockItem />
             <PreferencesToggleSnapModeItem />
             <PreferencesToggleGridModeItem />
@@ -632,7 +585,6 @@ export const Preferences = ({
 };
 
 Preferences.ToggleToolLock = PreferencesToggleToolLockItem;
-Preferences.BoxSelectionMode = PreferencesBoxSelectionModeItem;
 Preferences.ToggleSnapMode = PreferencesToggleSnapModeItem;
 Preferences.ToggleArrowBinding = PreferencesToggleArrowBindingItem;
 Preferences.ToggleMidpointSnapping = PreferencesToggleMidpointSnappingItem;

packages/excalidraw/components/shapes.tsx

@@ -119,12 +119,15 @@ export const SHAPES = [
 export const getToolbarTools = (app: AppClassProperties) => {
   return app.state.preferredSelectionTool.type === "lasso"
     ? ([
-        SHAPES[0],
         {
-          ...SHAPES[1],
           value: "lasso",
+          icon: SelectionIcon,
+          key: KEYS.V,
+          numericKey: KEYS["1"],
+          fillable: true,
+          toolbar: true,
         },
-        ...SHAPES.slice(2),
+        ...SHAPES.slice(1),
       ] as const)
     : SHAPES;
 };

packages/excalidraw/css/styles.scss

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

packages/excalidraw/data/blob.ts

@@ -311,48 +311,6 @@ export const dataURLToString = (dataURL: DataURL) => {
   return base64ToString(dataURL.slice(dataURL.indexOf(",") + 1));
 };
 
-const getImageFileDimensions = async (file: File) => {
-  const browserURL = typeof window !== "undefined" ? window.URL : undefined;
-  let objectURL: string | null = null;
-  let imageSource: string;
-
-  try {
-    imageSource = browserURL?.createObjectURL
-      ? (objectURL = browserURL.createObjectURL(file))
-      : await getDataURL(file);
-  } catch {
-    objectURL = null;
-    imageSource = await getDataURL(file);
-  }
-
-  return new Promise<{ width: number; height: number }>((resolve, reject) => {
-    const image = new Image();
-
-    const cleanup = () => {
-      image.onload = null;
-      image.onerror = null;
-
-      if (objectURL && browserURL?.revokeObjectURL) {
-        browserURL.revokeObjectURL(objectURL);
-      }
-    };
-
-    image.onload = () => {
-      cleanup();
-      resolve({
-        width: image.naturalWidth || image.width,
-        height: image.naturalHeight || image.height,
-      });
-    };
-    image.onerror = (error) => {
-      cleanup();
-      reject(error);
-    };
-
-    image.src = imageSource;
-  });
-};
-
 export const resizeImageFile = async (
   file: File,
   opts: {
@@ -366,20 +324,6 @@ export const resizeImageFile = async (
     return file;
   }
 
-  if (!isSupportedImageFile(file)) {
-    throw new Error("Error: unsupported file type", { cause: "UNSUPPORTED" });
-  }
-
-  if (!opts.outputType || opts.outputType === file.type) {
-    const dimensions = await getImageFileDimensions(file);
-
-    if (
-      Math.max(dimensions.width, dimensions.height) <= opts.maxWidthOrHeight
-    ) {
-      return file;
-    }
-  }
-
   const [pica, imageBlobReduce] = await Promise.all([
     import("pica").then((res) => res.default),
     // a wrapper for pica for better API
@@ -403,6 +347,10 @@ export const resizeImageFile = async (
     };
   }
 
+  if (!isSupportedImageFile(file)) {
+    throw new Error("Error: unsupported file type", { cause: "UNSUPPORTED" });
+  }
+
   return new File(
     [await reduce.toBlob(file, { max: opts.maxWidthOrHeight, alpha: true })],
     file.name,

packages/excalidraw/data/index.ts

@@ -6,7 +6,6 @@ import {
   MIME_TYPES,
   cloneJSON,
   SVG_DOCUMENT_PREAMBLE,
-  arrayToMap,
 } from "@excalidraw/common";
 
 import { getNonDeletedElements } from "@excalidraw/element";
@@ -50,7 +49,6 @@ export const prepareElementsForExport = (
   exportSelectionOnly: boolean,
 ) => {
   elements = getNonDeletedElements(elements);
-  const elementsMap = arrayToMap(elements);
 
   const isExportingSelection =
     exportSelectionOnly &&
@@ -73,11 +71,7 @@ export const prepareElementsForExport = (
       isFrameLikeElement(exportedElements[0])
     ) {
       exportingFrame = exportedElements[0];
-      exportedElements = getElementsOverlappingFrame(
-        elements,
-        exportingFrame,
-        elementsMap,
-      );
+      exportedElements = getElementsOverlappingFrame(elements, exportingFrame);
     } else if (exportedElements.length > 1) {
       exportedElements = getSelectedElements(
         elements,

packages/excalidraw/data/restore.ts

@@ -1,4 +1,4 @@
-import { isFiniteNumber, isValidPoint, pointFrom } from "@excalidraw/math";
+import { isFiniteNumber, pointFrom } from "@excalidraw/math";
 
 import {
   type CombineBrandsIfNeeded,
@@ -54,11 +54,6 @@ import { getNormalizedDimensions } from "@excalidraw/element";
 
 import { isInvisiblySmallElement } from "@excalidraw/element";
 
-import {
-  elementOverlapsWithFrame,
-  isFrameLikeElement,
-} from "@excalidraw/element";
-
 import type { LocalPoint, Radians } from "@excalidraw/math";
 
 import type {
@@ -101,69 +96,6 @@ type RestoredAppState = Omit<
   "offsetTop" | "offsetLeft" | "width" | "height"
 >;
 
-const MAX_ARROW_PX = 75_000;
-
-const restoreLinearElementPoints = (
-  points: unknown,
-  width: unknown,
-  height: unknown,
-): LocalPoint[] => {
-  const restoredPoints = Array.isArray(points)
-    ? points.reduce<LocalPoint[]>((acc, point) => {
-        if (isValidPoint(point)) {
-          acc.push(pointFrom<LocalPoint>(point[0], point[1]));
-        }
-        return acc;
-      }, [])
-    : [];
-
-  return restoredPoints.length < 2
-    ? [
-        pointFrom<LocalPoint>(0, 0),
-        pointFrom<LocalPoint>(
-          isFiniteNumber(width) ? width : 0,
-          isFiniteNumber(height) ? height : 0,
-        ),
-      ]
-    : restoredPoints;
-};
-
-const restoreFreedrawPoints = (
-  points: unknown,
-  pressures: unknown,
-): {
-  points: LocalPoint[];
-  pressures: number[];
-} => {
-  if (!Array.isArray(points)) {
-    return {
-      points: [],
-      pressures: [],
-    };
-  }
-
-  const pressureValues: readonly unknown[] = Array.isArray(pressures)
-    ? pressures
-    : [];
-  const restoredPoints: LocalPoint[] = [];
-  const restoredPressures: number[] = [];
-
-  points.forEach((point, index) => {
-    if (isValidPoint(point)) {
-      restoredPoints.push(pointFrom<LocalPoint>(point[0], point[1]));
-      if (index in pressureValues) {
-        const pressure = pressureValues[index];
-        restoredPressures.push(isFiniteNumber(pressure) ? pressure : 0.5);
-      }
-    }
-  });
-
-  return {
-    points: restoredPoints,
-    pressures: restoredPressures,
-  };
-};
-
 export const AllowedExcalidrawActiveTools: Record<
   AppState["activeTool"]["type"],
   boolean
@@ -319,9 +251,7 @@ const repairBinding = <T extends ExcalidrawArrowElement>(
       };
     }
 
-    console.error(
-      `Could not repair binding for element "${boundElement?.id}" out of (${elementsMap?.size}) elements`,
-    );
+    console.error(`could not repair binding for element`);
   } catch (error) {
     console.error("Error repairing binding:", error);
   }
@@ -480,15 +410,10 @@ export const restoreElement = (
 
       return element;
     case "freedraw": {
-      const { points, pressures } = restoreFreedrawPoints(
-        element.points,
-        element.pressures,
-      );
-
       return restoreElementWithProperties(element, {
-        points,
+        points: element.points,
         simulatePressure: element.simulatePressure,
-        pressures,
+        pressures: element.pressures,
       });
     }
     case "image":
@@ -506,20 +431,14 @@ export const restoreElement = (
       const endArrowhead = normalizeArrowhead(element.endArrowhead);
       let x = element.x;
       let y = element.y;
-      let points = restoreLinearElementPoints(
-        element.points,
-        element.width,
-        element.height,
-      );
+      let points = // migrate old arrow model to new one
+        !Array.isArray(element.points) || element.points.length < 2
+          ? [pointFrom(0, 0), pointFrom(element.width, element.height)]
+          : element.points;
 
       if (points[0][0] !== 0 || points[0][1] !== 0) {
         ({ points, x, y } =
-          LinearElementEditor.getNormalizeElementPointsAndCoords({
-            ...element,
-            points,
-            x: x ?? 0,
-            y: y ?? 0,
-          } as ExcalidrawLinearElement));
+          LinearElementEditor.getNormalizeElementPointsAndCoords(element));
       }
 
       return restoreElementWithProperties(element, {
@@ -533,7 +452,7 @@ export const restoreElement = (
         y,
         ...(isLineElement(element)
           ? {
-              polygon: isValidPolygon(points)
+              polygon: isValidPolygon(element.points)
                 ? element.polygon ?? false
                 : false,
             }
@@ -546,31 +465,24 @@ export const restoreElement = (
         element.endArrowhead === undefined
           ? "arrow"
           : normalizeArrowhead(element.endArrowhead);
-      const x = element.x as number | undefined;
-      const y = element.y as number | undefined;
-      const points = restoreLinearElementPoints(
-        element.points,
-        element.width,
-        element.height,
-      );
-      const elementWithRestoredPoints = {
-        ...element,
-        points,
-        x: x ?? 0,
-        y: y ?? 0,
-      } as ExcalidrawArrowElement;
+      const x: number | undefined = element.x;
+      const y: number | undefined = element.y;
+      const points: readonly LocalPoint[] | undefined = // migrate old arrow model to new one
+        !Array.isArray(element.points) || element.points.length < 2
+          ? [pointFrom(0, 0), pointFrom(element.width, element.height)]
+          : element.points;
 
       const base = {
         type: element.type,
         startBinding: repairBinding(
-          elementWithRestoredPoints,
+          element as ExcalidrawArrowElement,
           element.startBinding,
           targetElementsMap,
           existingElementsMap,
           "start",
         ),
         endBinding: repairBinding(
-          elementWithRestoredPoints,
+          element as ExcalidrawArrowElement,
           element.endBinding,
           targetElementsMap,
           existingElementsMap,
@@ -579,8 +491,8 @@ export const restoreElement = (
         startArrowhead,
         endArrowhead,
         points,
-        x: x ?? 0,
-        y: y ?? 0,
+        x,
+        y,
         elbowed: (element as ExcalidrawArrowElement).elbowed,
         ...getSizeFromPoints(points),
       };
@@ -599,44 +511,12 @@ export const restoreElement = (
           })
         : restoreElementWithProperties(element as ExcalidrawArrowElement, base);
 
-      const normalizedRestoredElement = {
+      return {
         ...restoredElement,
         ...LinearElementEditor.getNormalizeElementPointsAndCoords(
           restoredElement,
         ),
       };
-
-      // Last resort fix for extremely large arrows
-      if (
-        normalizedRestoredElement.width > MAX_ARROW_PX ||
-        normalizedRestoredElement.height > MAX_ARROW_PX
-      ) {
-        console.error(
-          `Removing extremely large arrow ${
-            normalizedRestoredElement.id
-          } (type: ${
-            isElbowArrow(normalizedRestoredElement) ? "elbow" : "simple"
-          }, width: ${normalizedRestoredElement.width}, height: ${
-            normalizedRestoredElement.height
-          }, x: ${normalizedRestoredElement.x}, y: ${
-            normalizedRestoredElement.y
-          })`,
-        );
-        return {
-          ...normalizedRestoredElement,
-          x: 0,
-          y: 0,
-          width: 100,
-          height: 100,
-          points: [
-            pointFrom<LocalPoint>(0, 0),
-            pointFrom<LocalPoint>(100, 100),
-          ],
-          isDeleted: true,
-        };
-      }
-
-      return normalizedRestoredElement;
     }
 
     // generic elements
@@ -749,78 +629,20 @@ const repairBoundElement = (
 };
 
 /**
- * Remove an element's frameId if:
- *  - its containing frame is non-existent (or isn't actually a frame), or
- *  - the element no longer (precisely) overlaps its containing frame.
- *
- * Frame membership is treated atomically per group: a grouped element keeps its
- * frameId as long as ANY element of its (outermost) group still overlaps the
- * frame, so we never split a group across frame membership. Bound text inherits
- * its container's geometry/membership.
+ * Remove an element's frameId if its containing frame is non-existent
  *
  * NOTE mutates elements.
  */
 const repairFrameMembership = (
   element: Mutable<ExcalidrawElement>,
   elementsMap: Map<string, Mutable<ExcalidrawElement>>,
-  /** elements bucketed by outermost groupId (see `restoreElements`) */
-  elementsByGroup: Map<string, Mutable<ExcalidrawElement>[]>,
-  /** memoizes the overlap decision per `${frameId}:${groupId}` */
-  checkedFrameGroups: Map<string, boolean>,
 ) => {
-  if (!element.frameId) {
-    return;
-  }
+  if (element.frameId) {
+    const containingFrame = elementsMap.get(element.frameId);
 
-  const containingFrame = elementsMap.get(element.frameId);
-
-  // frame no longer exists (or the frameId doesn't point to a frame)
-  if (!containingFrame || !isFrameLikeElement(containingFrame)) {
-    element.frameId = null;
-    return;
-  }
-
-  // don't recompute geometry for deleted elements
-  if (element.isDeleted) {
-    return;
-  }
-
-  // a bound text follows its container's geometry / membership
-  const geometryElement =
-    isTextElement(element) && element.containerId
-      ? elementsMap.get(element.containerId) ?? element
-      : element;
-
-  const outerGroupId =
-    geometryElement.groupIds[geometryElement.groupIds.length - 1];
-
-  let overlapsFrame: boolean;
-  if (outerGroupId) {
-    const cacheKey = `${containingFrame.id}:${outerGroupId}`;
-    const cached = checkedFrameGroups.get(cacheKey);
-    if (cached !== undefined) {
-      overlapsFrame = cached;
-    } else {
-      // group membership is atomic — keep the element as long as ANY element
-      // of its group still overlaps the frame, so we never split a group.
-      const groupElements = elementsByGroup.get(outerGroupId) ?? [
-        geometryElement,
-      ];
-      overlapsFrame = groupElements.some((groupElement) =>
-        elementOverlapsWithFrame(groupElement, containingFrame, elementsMap),
-      );
-      checkedFrameGroups.set(cacheKey, overlapsFrame);
+    if (!containingFrame) {
+      element.frameId = null;
     }
-  } else {
-    overlapsFrame = elementOverlapsWithFrame(
-      geometryElement,
-      containingFrame,
-      elementsMap,
-    );
-  }
-
-  if (!overlapsFrame) {
-    element.frameId = null;
   }
 };
 
@@ -842,7 +664,6 @@ export const restoreElements = <T extends ExcalidrawElement>(
   const existingElementsMap = existingElements
     ? arrayToMap(existingElements)
     : null;
-
   const restoredElements = syncInvalidIndices(
     (targetElements || []).reduce((elements, element) => {
       // filtering out selection, which is legacy, no longer kept in elements,
@@ -899,32 +720,9 @@ export const restoreElements = <T extends ExcalidrawElement>(
 
   // repair binding. Mutates elements.
   const restoredElementsMap = arrayToMap(restoredElements);
-
-  // index elements by their outermost groupId once, so frame-membership repair
-  // can resolve a group's members in O(1) instead of scanning all elements per
-  // group (getElementsInGroup) — a big win on large, heavily-grouped scenes.
-  const elementsByGroup = new Map<string, Mutable<ExcalidrawElement>[]>();
-  for (const element of restoredElements) {
-    const outerGroupId = element.groupIds[element.groupIds.length - 1];
-    if (outerGroupId) {
-      const members = elementsByGroup.get(outerGroupId);
-      if (members) {
-        members.push(element);
-      } else {
-        elementsByGroup.set(outerGroupId, [element]);
-      }
-    }
-  }
-
-  const checkedFrameGroups = new Map<string, boolean>();
   for (const element of restoredElements) {
     if (element.frameId) {
-      repairFrameMembership(
-        element,
-        restoredElementsMap,
-        elementsByGroup,
-        checkedFrameGroups,
-      );
+      repairFrameMembership(element, restoredElementsMap);
     }
 
     if (isTextElement(element) && element.containerId) {
@@ -962,7 +760,7 @@ export const restoreElements = <T extends ExcalidrawElement>(
     }
   }
 
-  // NOTE (mtolmacs): Temporary fix for invalid/self-bound elbow arrows
+  // NOTE (mtolmacs): Temporary fix for extremely large arrows
   // Need to iterate again so we have attached text nodes in elementsMap
   return restoredElements.map((element) => {
     if (
@@ -1136,12 +934,6 @@ export const restoreAppState = (
         : defaultValue;
   }
 
-  const boxSelectionMode =
-    appState.boxSelectionMode ?? localAppState?.boxSelectionMode;
-  if (boxSelectionMode !== undefined) {
-    nextAppState.boxSelectionMode = boxSelectionMode;
-  }
-
   return {
     ...nextAppState,
     cursorButton: localAppState?.cursorButton || "up",

packages/excalidraw/eraser/index.ts

@@ -33,7 +33,9 @@ import type { Bounds } from "@excalidraw/common";
 import type { GlobalPoint, LineSegment } from "@excalidraw/math/types";
 import type { ElementsMap, ExcalidrawElement } from "@excalidraw/element/types";
 
-import { AnimatedTrail } from "../animatedTrail";
+import { AnimatedTrail } from "../animated-trail";
+
+import type { AnimationFrameHandler } from "../animation-frame-handler";
 
 import type App from "../components/App";
 
@@ -41,8 +43,8 @@ export class EraserTrail extends AnimatedTrail {
   private elementsToErase: Set<ExcalidrawElement["id"]> = new Set();
   private groupsToErase: Set<ExcalidrawElement["id"]> = new Set();
 
-  constructor(app: App) {
-    super(app, {
+  constructor(animationFrameHandler: AnimationFrameHandler, app: App) {
+    super(animationFrameHandler, app, {
       streamline: 0.2,
       size: 5,
       keepHead: true,

packages/excalidraw/global.d.ts

@@ -4,6 +4,8 @@ interface Window {
   EXCALIDRAW_ASSET_PATH: string | string[] | undefined;
   EXCALIDRAW_THROTTLE_RENDER: boolean | undefined;
   DEBUG_FRACTIONAL_INDICES: boolean | undefined;
+  EXCALIDRAW_DEBUG_LINEAR_ARROW_TANGENTS: boolean | undefined;
+  EXCALIDRAW_DEBUG_SELECTED_LINEAR_ARROW: unknown;
   EXCALIDRAW_EXPORT_SOURCE: string;
   gtag: Function;
   sa_event: Function;

packages/excalidraw/index.tsx

@@ -6,12 +6,7 @@ import React, {
   useState,
 } from "react";
 
-import {
-  applyDarkModeFilter,
-  DEFAULT_IMAGE_OPTIONS,
-  DEFAULT_UI_OPTIONS,
-  isShallowEqual,
-} from "@excalidraw/common";
+import { DEFAULT_UI_OPTIONS, isShallowEqual } from "@excalidraw/common";
 
 import App, {
   ExcalidrawAPIContext,
@@ -67,7 +62,6 @@ const ExcalidrawBase = (props: ExcalidrawProps) => {
   const {
     onExport,
     onChange,
-    onThemeChange,
     onIncrement,
     initialData,
     onExcalidrawAPI,
@@ -104,7 +98,6 @@ const ExcalidrawBase = (props: ExcalidrawProps) => {
     aiEnabled,
     showDeprecatedFonts,
     renderScrollbars,
-    imageOptions,
   } = props;
 
   const canvasActions = props.UIOptions?.canvasActions;
@@ -130,18 +123,11 @@ const ExcalidrawBase = (props: ExcalidrawProps) => {
 
   if (
     UIOptions.canvasActions.toggleTheme === null &&
-    (theme == null || onThemeChange)
+    typeof theme === "undefined"
   ) {
     UIOptions.canvasActions.toggleTheme = true;
   }
 
-  const normalizedImageOptions: AppProps["imageOptions"] = {
-    maxFileSizeBytes:
-      imageOptions?.maxFileSizeBytes ?? DEFAULT_IMAGE_OPTIONS.maxFileSizeBytes,
-    maxWidthOrHeight:
-      imageOptions?.maxWidthOrHeight ?? DEFAULT_IMAGE_OPTIONS.maxWidthOrHeight,
-  };
-
   const setExcalidrawAPI = useContext(ExcalidrawAPISetContext);
 
   const onExcalidrawAPIRef = useRef(onExcalidrawAPI);
@@ -186,7 +172,6 @@ const ExcalidrawBase = (props: ExcalidrawProps) => {
         <App
           onExport={onExport}
           onChange={onChange}
-          onThemeChange={onThemeChange}
           onIncrement={onIncrement}
           initialData={initialData}
           onExcalidrawAPI={handleExcalidrawAPI}
@@ -223,7 +208,6 @@ const ExcalidrawBase = (props: ExcalidrawProps) => {
           aiEnabled={aiEnabled !== false}
           showDeprecatedFonts={showDeprecatedFonts}
           renderScrollbars={renderScrollbars}
-          imageOptions={normalizedImageOptions}
         >
           {children}
         </App>
@@ -241,13 +225,11 @@ const areEqual = (prevProps: ExcalidrawProps, nextProps: ExcalidrawProps) => {
   const {
     initialData: prevInitialData,
     UIOptions: prevUIOptions = {},
-    imageOptions: prevImageOptions,
     ...prev
   } = prevProps;
   const {
     initialData: nextInitialData,
     UIOptions: nextUIOptions = {},
-    imageOptions: nextImageOptions,
     ...next
   } = nextProps;
 
@@ -291,17 +273,7 @@ const areEqual = (prevProps: ExcalidrawProps, nextProps: ExcalidrawProps) => {
     return prevUIOptions[key] === nextUIOptions[key];
   });
 
-  const isImageOptionsSame =
-    (prevImageOptions?.maxWidthOrHeight ??
-      DEFAULT_IMAGE_OPTIONS.maxWidthOrHeight) ===
-      (nextImageOptions?.maxWidthOrHeight ??
-        DEFAULT_IMAGE_OPTIONS.maxWidthOrHeight) &&
-    (prevImageOptions?.maxFileSizeBytes ??
-      DEFAULT_IMAGE_OPTIONS.maxFileSizeBytes) ===
-      (nextImageOptions?.maxFileSizeBytes ??
-        DEFAULT_IMAGE_OPTIONS.maxFileSizeBytes);
-
-  return isUIOptionsSame && isImageOptionsSame && isShallowEqual(prev, next);
+  return isUIOptionsSame && isShallowEqual(prev, next);
 };
 
 export const Excalidraw = React.memo(ExcalidrawBase, areEqual);
@@ -400,14 +372,16 @@ export {
   convertToExcalidrawElements,
 } from "@excalidraw/element";
 
-export { elementsOverlappingBBox } from "@excalidraw/element";
+export {
+  elementsOverlappingBBox,
+  isElementInsideBBox,
+  elementPartiallyOverlapsWithOrContainsBBox,
+} from "@excalidraw/utils/withinBounds";
 
 export { DiagramToCodePlugin } from "./components/DiagramToCodePlugin/DiagramToCodePlugin";
 export { getDataURL } from "./data/blob";
 export { isElementLink } from "@excalidraw/element";
 
-export { Fonts } from "./fonts/Fonts";
-
 export { setCustomTextMetricsProvider } from "@excalidraw/element";
 
 export { CommandPalette } from "./components/CommandPalette/CommandPalette";
@@ -449,5 +423,3 @@ export function useExcalidrawStateValue(
 // -----------------------------------------------------------------------------
 
 export { _useOnAppStateChange as useOnExcalidrawStateChange };
-
-export { applyDarkModeFilter };

packages/excalidraw/laser-trails.ts

@@ -2,20 +2,27 @@ import { DEFAULT_LASER_COLOR, easeOut } from "@excalidraw/common";
 
 import type { LaserPointerOptions } from "@excalidraw/laser-pointer";
 
-import { AnimatedTrail } from "./animatedTrail";
+import { AnimatedTrail } from "./animated-trail";
 import { getClientColor } from "./clients";
 
-import type { Trail } from "./animatedTrail";
+import type { Trail } from "./animated-trail";
+import type { AnimationFrameHandler } from "./animation-frame-handler";
 import type App from "./components/App";
 import type { SocketId } from "./types";
 
 export class LaserTrails implements Trail {
   public localTrail: AnimatedTrail;
   private collabTrails = new Map<SocketId, AnimatedTrail>();
+
   private container?: SVGSVGElement;
 
-  constructor(private app: App) {
-    this.localTrail = new AnimatedTrail(app, {
+  constructor(
+    private animationFrameHandler: AnimationFrameHandler,
+    private app: App,
+  ) {
+    this.animationFrameHandler.register(this, this.onFrame.bind(this));
+
+    this.localTrail = new AnimatedTrail(animationFrameHandler, app, {
       ...this.getTrailOptions(),
       fill: () => DEFAULT_LASER_COLOR,
     });
@@ -56,45 +63,30 @@ export class LaserTrails implements Trail {
 
   start(container: SVGSVGElement) {
     this.container = container;
+
+    this.animationFrameHandler.start(this);
     this.localTrail.start(container);
   }
 
   stop() {
+    this.animationFrameHandler.stop(this);
     this.localTrail.stop();
-    this.stopCollabTrails();
-    this.container = undefined;
   }
 
-  private stopCollabTrails(collaborators?: App["state"]["collaborators"]) {
-    for (const [key, trail] of this.collabTrails) {
-      const collaborator = collaborators?.get(key);
-
-      if (!collaborator) {
-        trail.stop();
-        this.collabTrails.delete(key);
-      }
-    }
+  onFrame() {
+    this.updateCollabTrails();
   }
 
-  updateCollabTrails(collaborators: App["state"]["collaborators"]) {
-    this.stopCollabTrails(collaborators);
-
-    if (!this.container || collaborators.size === 0) {
+  private updateCollabTrails() {
+    if (!this.container || this.app.state.collaborators.size === 0) {
       return;
     }
 
-    for (const [key, collaborator] of collaborators.entries()) {
-      // Current user has their own trail drawn via localTrail
-      if (collaborator.isCurrentUser) {
-        continue;
-      }
+    for (const [key, collaborator] of this.app.state.collaborators.entries()) {
+      let trail!: AnimatedTrail;
 
-      // IDEA: Use the collaborator pointer coordinates to trace out the
-      // laser pointer trail when 1) the selected collab tool is the laser
-      // pointer and 2) the collab pointer button is in the "down" state.
-      let trail = this.collabTrails.get(key);
-      if (!trail) {
-        trail = new AnimatedTrail(this.app, {
+      if (!this.collabTrails.has(key)) {
+        trail = new AnimatedTrail(this.animationFrameHandler, this.app, {
           ...this.getTrailOptions(),
           fill: () =>
             collaborator.pointer?.laserColor ||
@@ -103,33 +95,36 @@ export class LaserTrails implements Trail {
         trail.start(this.container);
 
         this.collabTrails.set(key, trail);
+      } else {
+        trail = this.collabTrails.get(key)!;
       }
 
       if (collaborator.pointer && collaborator.pointer.tool === "laser") {
-        const buttonDown = collaborator.button === "down";
-        const buttonUp = collaborator.button === "up";
-        const hasTrail = trail.hasCurrentTrail;
-
-        // Initialize a new trail
-        if (buttonDown && !hasTrail) {
+        if (collaborator.button === "down" && !trail.hasCurrentTrail) {
           trail.startPath(collaborator.pointer.x, collaborator.pointer.y);
         }
 
-        // Add only original points
-        const lastPointOriginal = !trail.hasLastPoint(
-          collaborator.pointer.x,
-          collaborator.pointer.y,
-        );
-        if (buttonDown && lastPointOriginal) {
+        if (
+          collaborator.button === "down" &&
+          trail.hasCurrentTrail &&
+          !trail.hasLastPoint(collaborator.pointer.x, collaborator.pointer.y)
+        ) {
           trail.addPointToPath(collaborator.pointer.x, collaborator.pointer.y);
         }
 
-        // End the trail on button up
-        if (buttonUp && hasTrail) {
+        if (collaborator.button === "up" && trail.hasCurrentTrail) {
           trail.addPointToPath(collaborator.pointer.x, collaborator.pointer.y);
           trail.endPath();
         }
       }
     }
+
+    for (const key of this.collabTrails.keys()) {
+      if (!this.app.state.collaborators.has(key)) {
+        const trail = this.collabTrails.get(key)!;
+        trail.stop();
+        this.collabTrails.delete(key);
+      }
+    }
   }
 }

packages/excalidraw/lasso/index.ts

@@ -25,7 +25,9 @@ import type {
   NonDeleted,
 } from "@excalidraw/element/types";
 
-import { AnimatedTrail } from "../animatedTrail";
+import { type AnimationFrameHandler } from "../animation-frame-handler";
+
+import { AnimatedTrail } from "../animated-trail";
 
 import { getLassoSelectedElementIds } from "./utils";
 
@@ -45,8 +47,8 @@ export class LassoTrail extends AnimatedTrail {
   private canvasTranslate: CanvasTranslate | null = null;
   private keepPreviousSelection: boolean = false;
 
-  constructor(app: App) {
-    super(app, {
+  constructor(animationFrameHandler: AnimationFrameHandler, app: App) {
+    super(animationFrameHandler, app, {
       animateTrail: true,
       streamline: 0.4,
       sizeMapping: (c) => {

packages/excalidraw/locales/en.json

@@ -185,9 +185,6 @@
     "shapeSwitch": "Switch shape",
     "preferences": "Preferences",
     "preferences_toolLock": "Tool lock",
-    "boxSelectionMode": "Select on",
-    "boxSelectionContain": "Wrap",
-    "boxSelectionOverlap": "Overlap",
     "arrowBinding": "Arrow binding",
     "midpointSnapping": "Snap to midpoints"
   },
@@ -664,7 +661,7 @@
     "placeholder": {
       "title": "Let's design your diagram",
       "description": "Describe the diagram you want to create, and we'll generate it for you.",
-      "hint": "At the moment we know Flowchart, Sequence, Class, State, and Entity Relationship diagrams."
+      "hint": "At the moment we know Flowchart, Sequence, Class, and Entity Relationship diagrams."
     },
     "preview": "Preview",
     "insert": "Insert",

packages/excalidraw/package.json

@@ -88,13 +88,14 @@
     "@excalidraw/element": "0.18.0",
     "@excalidraw/laser-pointer": "1.3.1",
     "@excalidraw/math": "0.18.0",
-    "@excalidraw/mermaid-to-excalidraw": "2.2.2",
+    "@excalidraw/mermaid-to-excalidraw": "2.1.1",
     "@excalidraw/random-username": "1.1.0",
     "browser-fs-access": "0.38.0",
     "canvas-roundrect-polyfill": "0.0.1",
     "clsx": "1.1.1",
     "cross-env": "7.0.3",
     "es6-promise-pool": "2.5.0",
+    "fractional-indexing": "3.2.0",
     "fuzzy": "0.1.3",
     "image-blob-reduce": "3.0.1",
     "jotai": "2.11.0",

packages/excalidraw/polyfill.ts

@@ -23,94 +23,6 @@ const polyfill = () => {
     });
   }
 
-  if (!Array.prototype.findLast) {
-    Object.defineProperty(Array.prototype, "findLast", {
-      value: function <T>(
-        this: T[],
-        predicate: (value: T, index: number, array: T[]) => unknown,
-        thisArg?: unknown,
-      ) {
-        return this
-          .slice()
-          .reverse()
-          .find((value, index) =>
-            predicate.call(thisArg, value, this.length - index - 1, this),
-          );
-      },
-      writable: true,
-      enumerable: false,
-      configurable: true,
-    });
-  }
-
-  if (!Array.prototype.findIndex) {
-    Object.defineProperty(Array.prototype, "findIndex", {
-      value: function <T>(
-        this: T[],
-        predicate: (value: T, index: number, array: T[]) => unknown,
-        thisArg?: unknown,
-      ) {
-        for (let index = 0; index < this.length; index++) {
-          if (predicate.call(thisArg, this[index], index, this)) {
-            return index;
-          }
-        }
-
-        return -1;
-      },
-      writable: true,
-      enumerable: false,
-      configurable: true,
-    });
-  }
-
-  if (!Array.prototype.findLastIndex) {
-    Object.defineProperty(Array.prototype, "findLastIndex", {
-      value: function <T>(
-        this: T[],
-        predicate: (value: T, index: number, array: T[]) => unknown,
-        thisArg?: unknown,
-      ) {
-        const index = this
-          .slice()
-          .reverse()
-          .findIndex((value, index) =>
-            predicate.call(thisArg, value, this.length - index - 1, this),
-          );
-
-        return index === -1 ? -1 : this.length - index - 1;
-      },
-      writable: true,
-      enumerable: false,
-      configurable: true,
-    });
-  }
-
-  if (!Array.prototype.toReversed) {
-    Object.defineProperty(Array.prototype, "toReversed", {
-      value: function <T>(this: T[]) {
-        return this.slice().reverse();
-      },
-      writable: true,
-      enumerable: false,
-      configurable: true,
-    });
-  }
-
-  if (!Array.prototype.toSorted) {
-    Object.defineProperty(Array.prototype, "toSorted", {
-      value: function <T>(
-        this: T[],
-        compareFn?: (a: T, b: T) => number,
-      ) {
-        return this.slice().sort(compareFn);
-      },
-      writable: true,
-      enumerable: false,
-      configurable: true,
-    });
-  }
-
   if (!Element.prototype.replaceChildren) {
     Element.prototype.replaceChildren = function (...nodes) {
       this.innerHTML = "";

packages/excalidraw/renderer/animation.ts

@@ -6,10 +6,7 @@ export type Animation<R extends object> = (params: {
 }) => R | null | undefined;
 
 export class AnimationController {
-  private static scheduledFrame:
-    | { id: ReturnType<typeof requestAnimationFrame>; type: "raf" }
-    | { id: ReturnType<typeof setTimeout>; type: "timeout" }
-    | null = null;
+  private static isRunning = false;
   private static animations = new Map<
     string,
     {
@@ -20,10 +17,6 @@ export class AnimationController {
   >();
 
   static start<R extends object>(key: string, animation: Animation<R>) {
-    if (AnimationController.animations.has(key)) {
-      return;
-    }
-
     const initialState = animation({
       deltaTime: 0,
       state: undefined,
@@ -36,54 +29,19 @@ export class AnimationController {
         state: initialState,
       });
 
-      AnimationController.scheduleNextFrame();
+      if (!AnimationController.isRunning) {
+        AnimationController.isRunning = true;
+
+        if (isRenderThrottlingEnabled()) {
+          requestAnimationFrame(AnimationController.tick);
+        } else {
+          setTimeout(AnimationController.tick, 0);
+        }
+      }
     }
   }
 
-  private static scheduleNextFrame() {
-    if (AnimationController.scheduledFrame) {
-      return;
-    }
-
-    if (isRenderThrottlingEnabled()) {
-      AnimationController.scheduledFrame = {
-        id: requestAnimationFrame(AnimationController.tick),
-        type: "raf",
-      };
-    } else {
-      AnimationController.scheduledFrame = {
-        id: setTimeout(AnimationController.tick, 0),
-        type: "timeout",
-      };
-    }
-  }
-
-  private static cancelScheduledFrame() {
-    if (!AnimationController.scheduledFrame) {
-      return;
-    }
-
-    if (AnimationController.scheduledFrame.type === "raf") {
-      cancelAnimationFrame(AnimationController.scheduledFrame.id);
-    } else {
-      clearTimeout(AnimationController.scheduledFrame.id);
-    }
-
-    AnimationController.scheduledFrame = null;
-  }
-
-  private static cancelScheduledFrameIfIdle() {
-    if (AnimationController.animations.size > 0) {
-      return false;
-    }
-
-    AnimationController.cancelScheduledFrame();
-    return true;
-  }
-
   private static tick() {
-    AnimationController.scheduledFrame = null;
-
     if (AnimationController.animations.size > 0) {
       for (const [key, animation] of AnimationController.animations) {
         const now = performance.now();
@@ -98,7 +56,8 @@ export class AnimationController {
         if (!state) {
           AnimationController.animations.delete(key);
 
-          if (AnimationController.cancelScheduledFrameIfIdle()) {
+          if (AnimationController.animations.size === 0) {
+            AnimationController.isRunning = false;
             return;
           }
         } else {
@@ -107,11 +66,11 @@ export class AnimationController {
         }
       }
 
-      if (AnimationController.cancelScheduledFrameIfIdle()) {
-        return;
+      if (isRenderThrottlingEnabled()) {
+        requestAnimationFrame(AnimationController.tick);
+      } else {
+        setTimeout(AnimationController.tick, 0);
       }
-
-      AnimationController.scheduleNextFrame();
     }
   }
 
@@ -121,6 +80,5 @@ export class AnimationController {
 
   static cancel(key: string) {
     AnimationController.animations.delete(key);
-    AnimationController.cancelScheduledFrameIfIdle();
   }
 }

packages/excalidraw/renderer/helpers.ts

@@ -62,10 +62,10 @@ export const bootstrapCanvas = ({
       context.clearRect(0, 0, normalizedWidth, normalizedHeight);
     }
     context.save();
-    context.fillStyle = applyDarkModeFilter(
-      viewBackgroundColor,
-      theme === THEME.DARK,
-    );
+    context.fillStyle =
+      theme === THEME.DARK
+        ? applyDarkModeFilter(viewBackgroundColor)
+        : viewBackgroundColor;
     context.fillRect(0, 0, normalizedWidth, normalizedHeight);
     context.restore();
   } else {