feat(editor): highlight duplicate matches in mermaid editor

feat(editor): highlight TTD assistant responses
2026-03-24 16:16:44 +01:00 · 2026-03-24 16:14:26 +01:00
136 changed files with 1871 additions and 6060 deletions
@@ -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.
@@ -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
@@ -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 .
@@ -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 }}
@@ -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

@@ -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"
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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 }}
@@ -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
@@ -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

@@ -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">
@@ -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",
@@ -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";
@@ -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: {
@@ -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",
@@ -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"?>
@@ -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"
  }
 }
@@ -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) {
@@ -10,6 +10,7 @@ import {
  getBindingGap,
  getGlobalFixedPointForBindableElement,
  isBindingEnabled,
+  maxBindingDistance_simple,
  unbindBindingElement,
  updateBoundPoint,
 } from "../binding";
@@ -19,7 +20,7 @@ import {
  isElbowArrow,
 } from "../typeChecks";
 import { LinearElementEditor } from "../linearElementEditor";
-import { getHoveredElementForBinding, hitElementItself } from "../collision";
+import { getHoveredElementForFocusPoint, hitElementItself } from "../collision";
 import { moveArrowAboveBindable } from "../zindex";

 import type {
@@ -91,7 +92,7 @@ export const isFocusPointVisible = (
      element: bindableElement,
      elementsMap,
      point: focusPoint,
-      threshold: getBindingGap(bindableElement),
+      threshold: getBindingGap(bindableElement, arrow),
      overrideShouldTestInside: true,
    })
  );
@@ -233,12 +234,12 @@ export const handleFocusPointDrag = (
    pointerCoords.y - offsetY,
  );
  const bindingField = isStartBinding ? "startBinding" : "endBinding";
-  const hit = getHoveredElementForBinding(
-    arrow,
+  const hit = getHoveredElementForFocusPoint(
    point,
+    arrow,
    scene.getNonDeletedElements(),
    elementsMap,
-    appState.zoom,
+    maxBindingDistance_simple(appState.zoom),
  );

  // Hovering a bindable element
@@ -269,7 +270,6 @@ export const handleFocusPointDrag = (
        newMode || "orbit",
        linearElementEditor.draggedFocusPointBinding,
        scene,
-        appState.zoom,
        point,
      );
    }
@@ -60,7 +60,6 @@ import { updateElbowArrowPoints } from "./elbowArrow";
 import {
  deconstructDiamondElement,
  deconstructRectanguloidElement,
-  getSnapOutlineMidPoint,
  projectFixedPointOntoDiagonal,
 } from "./utils";

@@ -111,13 +110,18 @@ export type BindingStrategy =
 * IMPORTANT: currently must be > 0 (this also applies to the computed gap)
 */
 export const BASE_BINDING_GAP = 5;
+export const BASE_BINDING_GAP_ELBOW = 5;
 export const BASE_ARROW_MIN_LENGTH = 10;
 export const FOCUS_POINT_SIZE = 10 / 1.5;

 export const getBindingGap = (
  bindTarget: ExcalidrawBindableElement,
+  opts: Pick<ExcalidrawArrowElement, "elbowed">,
 ): number => {
-  return BASE_BINDING_GAP + bindTarget.strokeWidth / 2;
+  return (
+    (opts.elbowed ? BASE_BINDING_GAP_ELBOW : BASE_BINDING_GAP) +
+    bindTarget.strokeWidth / 2
+  );
 };

 export const maxBindingDistance_simple = (zoom?: AppState["zoom"]): number => {
@@ -171,7 +175,6 @@ export const bindOrUnbindBindingElement = (
    start,
    "start",
    scene,
-    appState.zoom,
    appState.isBindingEnabled,
  );
  bindOrUnbindBindingElementEdge(
@@ -179,7 +182,6 @@ export const bindOrUnbindBindingElement = (
    end,
    "end",
    scene,
-    appState.zoom,
    appState.isBindingEnabled,
  );
  if (start.focusPoint || end.focusPoint) {
@@ -224,7 +226,6 @@ const bindOrUnbindBindingElementEdge = (
  { mode, element, focusPoint }: BindingStrategy,
  startOrEnd: "start" | "end",
  scene: Scene,
-  zoom: AppState["zoom"],
  shouldSnapToOutline = true,
 ): void => {
  if (mode === null) {
@@ -237,7 +238,6 @@ const bindOrUnbindBindingElementEdge = (
      mode,
      startOrEnd,
      scene,
-      zoom,
      focusPoint,
      shouldSnapToOutline,
    );
@@ -270,11 +270,10 @@ const bindingStrategyForElbowArrowEndpointDragging = (
    elementsMap,
  );
  const hit = getHoveredElementForBinding(
-    arrow,
    globalPoint,
    elements,
    elementsMap,
-    zoom,
+    maxBindingDistance_simple(zoom),
  );

  const current = hit
@@ -322,7 +321,7 @@ const bindingStrategyForNewSimpleArrowEndpointDragging = (
    draggingPoints.get(startDragged ? startIdx : endIdx)!.point,
    elementsMap,
  );
-  const hit = getHoveredElementForBinding(arrow, point, elements, elementsMap);
+  const hit = getHoveredElementForBinding(point, elements, elementsMap);

  // With new arrows this handles the binding at arrow creation
  if (startDragged) {
@@ -367,12 +366,7 @@ const bindingStrategyForNewSimpleArrowEndpointDragging = (
    // Check and handle nested shapes
    if (hit && arrow.startBinding) {
      const startBinding = arrow.startBinding;
-      const allHits = getAllHoveredElementAtPoint(
-        arrow,
-        point,
-        elements,
-        elementsMap,
-      );
+      const allHits = getAllHoveredElementAtPoint(point, elements, elementsMap);

      if (allHits.find((el) => el.id === startBinding.elementId)) {
        const otherElement = elementsMap.get(
@@ -474,9 +468,9 @@ const bindingStrategyForSimpleArrowEndpointDragging_complex = (
  let other: BindingStrategy = { mode: undefined };

  const isMultiPoint = arrow.points.length > 2;
-  const hit = getHoveredElementForBinding(arrow, point, elements, elementsMap);
+  const hit = getHoveredElementForBinding(point, elements, elementsMap);
  const isOverlapping = oppositeBinding
-    ? getAllHoveredElementAtPoint(arrow, point, elements, elementsMap).some(
+    ? getAllHoveredElementAtPoint(point, elements, elementsMap).some(
        (el) => el.id === oppositeBinding.elementId,
      )
    : false;
@@ -701,11 +695,10 @@ const getBindingStrategyForDraggingBindingElementEndpoints_simple = (
    elementsMap,
  );
  const hit = getHoveredElementForBinding(
-    arrow,
    globalPoint,
    elements,
    elementsMap,
-    appState.zoom,
+    maxBindingDistance_simple(appState.zoom),
  );
  const pointInElement =
    hit &&
@@ -741,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",
@@ -1026,7 +1020,6 @@ export const bindBindingElement = (
  mode: BindMode,
  startOrEnd: "start" | "end",
  scene: Scene,
-  zoom: AppState["zoom"],
  focusPoint?: GlobalPoint,
  shouldSnapToOutline = true,
 ): void => {
@@ -1043,7 +1036,6 @@ export const bindBindingElement = (
        hoveredElement,
        startOrEnd,
        elementsMap,
-        zoom,
        shouldSnapToOutline,
      ),
    };
@@ -1268,7 +1260,6 @@ const updateArrowBindings = (
        strategy[strategyName].mode,
        strategyName,
        scene,
-        appState.zoom,
        strategy[strategyName].focusPoint,
      );
    }
@@ -1378,7 +1369,6 @@ export const bindPointToSnapToElementOutline = (
  bindableElement: ExcalidrawBindableElement,
  startOrEnd: "start" | "end",
  elementsMap: ElementsMap,
-  zoom: AppState["zoom"],
  customIntersector?: LineSegment<GlobalPoint>,
  isMidpointSnappingEnabled = true,
 ): GlobalPoint => {
@@ -1411,7 +1401,7 @@ export const bindPointToSnapToElementOutline = (
          startOrEnd === "start" ? 1 : -2,
          elementsMap,
        );
-  const bindingGap = getBindingGap(bindableElement);
+  const bindingGap = getBindingGap(bindableElement, arrowElement);
  const aabb = aabbForElement(bindableElement, elementsMap);
  const bindableCenter = getCenterForBounds(aabb);

@@ -1421,13 +1411,7 @@ export const bindPointToSnapToElementOutline = (
      headingForPointFromElement(bindableElement, aabb, point),
    );
    const snapPoint = isMidpointSnappingEnabled
-      ? getSnapOutlineMidPoint(
-          edgePoint,
-          bindableElement,
-          elementsMap,
-          zoom,
-          arrowElement,
-        )
+      ? snapToMid(bindableElement, elementsMap, edgePoint, 0.05, arrowElement)
      : undefined;
    const resolved = snapPoint || point;
    const otherPoint = pointFrom<GlobalPoint>(
@@ -1472,7 +1456,7 @@ export const bindPointToSnapToElementOutline = (
        bindableElement,
        elementsMap,
        anotherIntersector,
-        BASE_BINDING_GAP,
+        BASE_BINDING_GAP_ELBOW,
      ).sort(pointDistanceSq)[0];
    }
  } else {
@@ -1531,7 +1515,7 @@ export const avoidRectangularCorner = (
    -bindTarget.angle as Radians,
  );

-  const bindingGap = getBindingGap(bindTarget);
+  const bindingGap = getBindingGap(bindTarget, arrowElement);

  if (nonRotatedPoint[0] < bindTarget.x && nonRotatedPoint[1] < bindTarget.y) {
    // Top left
@@ -1609,6 +1593,121 @@ export const avoidRectangularCorner = (
  return p;
 };

+export const snapToMid = (
+  bindTarget: ExcalidrawBindableElement,
+  elementsMap: ElementsMap,
+  p: GlobalPoint,
+  tolerance: number = 0.05,
+  arrowElement?: ExcalidrawArrowElement,
+): GlobalPoint | undefined => {
+  const { x, y, width, height, angle } = bindTarget;
+  const center = elementCenterPoint(bindTarget, elementsMap, -0.1, -0.1);
+  const nonRotated = pointRotateRads(p, center, -angle as Radians);
+
+  const bindingGap = arrowElement ? getBindingGap(bindTarget, arrowElement) : 0;
+
+  // snap-to-center point is adaptive to element size, but we don't want to go
+  // above and below certain px distance
+  const verticalThreshold = clamp(tolerance * height, 5, 80);
+  const horizontalThreshold = clamp(tolerance * width, 5, 80);
+
+  // Too close to the center makes it hard to resolve direction precisely
+  if (pointDistance(center, nonRotated) < bindingGap) {
+    return undefined;
+  }
+
+  if (
+    nonRotated[0] <= x + width / 2 &&
+    nonRotated[1] > center[1] - verticalThreshold &&
+    nonRotated[1] < center[1] + verticalThreshold
+  ) {
+    // LEFT
+    return pointRotateRads(
+      pointFrom<GlobalPoint>(x - bindingGap, center[1]),
+      center,
+      angle,
+    );
+  } else if (
+    nonRotated[1] <= y + height / 2 &&
+    nonRotated[0] > center[0] - horizontalThreshold &&
+    nonRotated[0] < center[0] + horizontalThreshold
+  ) {
+    // TOP
+    return pointRotateRads(
+      pointFrom<GlobalPoint>(center[0], y - bindingGap),
+      center,
+      angle,
+    );
+  } else if (
+    nonRotated[0] >= x + width / 2 &&
+    nonRotated[1] > center[1] - verticalThreshold &&
+    nonRotated[1] < center[1] + verticalThreshold
+  ) {
+    // RIGHT
+    return pointRotateRads(
+      pointFrom<GlobalPoint>(x + width + bindingGap, center[1]),
+      center,
+      angle,
+    );
+  } else if (
+    nonRotated[1] >= y + height / 2 &&
+    nonRotated[0] > center[0] - horizontalThreshold &&
+    nonRotated[0] < center[0] + horizontalThreshold
+  ) {
+    // DOWN
+    return pointRotateRads(
+      pointFrom<GlobalPoint>(center[0], y + height + bindingGap),
+      center,
+      angle,
+    );
+  } else if (bindTarget.type === "diamond") {
+    const distance = bindingGap;
+    const topLeft = pointFrom<GlobalPoint>(
+      x + width / 4 - distance,
+      y + height / 4 - distance,
+    );
+    const topRight = pointFrom<GlobalPoint>(
+      x + (3 * width) / 4 + distance,
+      y + height / 4 - distance,
+    );
+    const bottomLeft = pointFrom<GlobalPoint>(
+      x + width / 4 - distance,
+      y + (3 * height) / 4 + distance,
+    );
+    const bottomRight = pointFrom<GlobalPoint>(
+      x + (3 * width) / 4 + distance,
+      y + (3 * height) / 4 + distance,
+    );
+
+    if (
+      pointDistance(topLeft, nonRotated) <
+      Math.max(horizontalThreshold, verticalThreshold)
+    ) {
+      return pointRotateRads(topLeft, center, angle);
+    }
+    if (
+      pointDistance(topRight, nonRotated) <
+      Math.max(horizontalThreshold, verticalThreshold)
+    ) {
+      return pointRotateRads(topRight, center, angle);
+    }
+    if (
+      pointDistance(bottomLeft, nonRotated) <
+      Math.max(horizontalThreshold, verticalThreshold)
+    ) {
+      return pointRotateRads(bottomLeft, center, angle);
+    }
+    if (
+      pointDistance(bottomRight, nonRotated) <
+      Math.max(horizontalThreshold, verticalThreshold)
+    ) {
+      return pointRotateRads(bottomRight, center, angle);
+    }
+  }
+
+  return undefined;
+};
+
 const extractBinding = (
  arrow: ExcalidrawArrowElement,
  startOrEnd: "startBinding" | "endBinding",
@@ -1709,7 +1808,7 @@ export const updateBoundPoint = (
      otherBindable,
      elementsMap,
      intersector,
-      getBindingGap(otherBindable),
+      getBindingGap(otherBindable, arrow),
    ).sort(
      (a, b) => pointDistanceSq(a, focusPoint) - pointDistanceSq(b, focusPoint),
    )[0];
@@ -1719,7 +1818,7 @@ export const updateBoundPoint = (
      bindableElement,
      elementsMap,
      intersector,
-      getBindingGap(bindableElement),
+      getBindingGap(bindableElement, arrow),
    ).sort(
      (a, b) =>
        pointDistanceSq(a, otherFocusPointOrArrowPoint) -
@@ -1747,7 +1846,7 @@ export const updateBoundPoint = (
      element: otherBindable,
      point: outlinePoint,
      elementsMap,
-      threshold: getBindingGap(otherBindable),
+      threshold: getBindingGap(otherBindable, arrow),
      overrideShouldTestInside: true,
    })
  ) {
@@ -1808,7 +1907,6 @@ export const calculateFixedPointForElbowArrowBinding = (
  hoveredElement: ExcalidrawBindableElement,
  startOrEnd: "start" | "end",
  elementsMap: ElementsMap,
-  zoom: AppState["zoom"],
  shouldSnapToOutline = true,
  isMidpointSnappingEnabled = true,
 ): { fixedPoint: FixedPoint } => {
@@ -1824,7 +1922,6 @@ export const calculateFixedPointForElbowArrowBinding = (
        hoveredElement,
        startOrEnd,
        elementsMap,
-        zoom,
        undefined,
        isMidpointSnappingEnabled,
      )
@@ -1846,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,
    ]),
  };
 };
@@ -1879,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]),
@@ -680,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;
@@ -696,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 = (
@@ -1262,17 +1261,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,
@@ -1287,21 +1275,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));
-
 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);

@@ -25,7 +25,7 @@ import type {
  Radians,
 } from "@excalidraw/math";

-import type { AppState, FrameNameBounds } from "@excalidraw/excalidraw/types";
+import type { FrameNameBounds } from "@excalidraw/excalidraw/types";

 import { isPathALoop } from "./utils";
 import {
@@ -59,12 +59,11 @@ import { LinearElementEditor } from "./linearElementEditor";

 import { distanceToElement } from "./distance";

-import { getBindingGap, maxBindingDistance_simple } from "./binding";
-
-import { hasBackground } from "./comparisons";
+import { getBindingGap } from "./binding";

 import type {
  ElementsMap,
+  ExcalidrawArrowElement,
  ExcalidrawBindableElement,
  ExcalidrawDiamondElement,
  ExcalidrawElement,
@@ -84,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);
@@ -155,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
@@ -190,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 = (
@@ -253,20 +241,25 @@ export const hitElementBoundText = (
  return isPointInElement(point, boundTextElement, elementsMap);
 };

-const bindableElementBorderDistanceIfClose = (
+const bindingBorderTest = (
  element: NonDeleted<ExcalidrawBindableElement>,
-  point: GlobalPoint,
-  elementsMap: ElementsMap,
+  [x, y]: Readonly<GlobalPoint>,
+  elementsMap: NonDeletedSceneElementsMap,
  tolerance: number = 0,
-) => {
+): boolean => {
+  const p = pointFrom<GlobalPoint>(x, y);
+  const shouldTestInside =
+    // disable fullshape snapping for frame elements so we
+    // can bind to frame children
+    !isFrameLikeElement(element);
+
  // PERF: Run a cheap test to see if the binding element
  // is even close to the element
-  const [x, y] = point;
  const t = Math.max(1, tolerance);
  const bounds = [x - t, y - t, x + t, y + t] as Bounds;
  const elementBounds = getElementBounds(element, elementsMap);
  if (!doBoundsIntersect(bounds, elementBounds)) {
-    return -Infinity;
+    return false;
  }

  // If the element is inside a frame, we should clip the element
@@ -277,29 +270,33 @@ const bindableElementBorderDistanceIfClose = (
        enclosingFrame,
        elementsMap,
      );
-      if (!pointInsideBounds(point, enclosingFrameBounds)) {
-        return -Infinity;
+      if (!pointInsideBounds(p, enclosingFrameBounds)) {
+        return false;
      }
    }
  }

-  const distance = distanceToElement(element, elementsMap, point);
-  if (isPointInElement(point, element, elementsMap)) {
-    return distance;
-  }
+  // Do the intersection test against the element since it's close enough
+  const intersections = intersectElementWithLineSegment(
+    element,
+    elementsMap,
+    lineSegment(elementCenterPoint(element, elementsMap), p),
+  );
+  const distance = distanceToElement(element, elementsMap, p);

-  return distance > tolerance ? -Infinity : -distance;
+  return shouldTestInside
+    ? intersections.length === 0 || distance <= tolerance
+    : intersections.length > 0 && distance <= t;
 };

 export const getAllHoveredElementAtPoint = (
-  arrow: { elbowed: boolean },
  point: Readonly<GlobalPoint>,
  elements: readonly Ordered<NonDeletedExcalidrawElement>[],
  elementsMap: NonDeletedSceneElementsMap,
  tolerance?: number,
 ): NonDeleted<ExcalidrawBindableElement>[] => {
  const candidateElements: NonDeleted<ExcalidrawBindableElement>[] = [];
-  // We need to do hit testing from front (end of the array) to back (beginning of the array)
+  // We need to to hit testing from front (end of the array) to back (beginning of the array)
  // because array is ordered from lower z-index to highest and we want element z-index
  // with higher z-index
  for (let index = elements.length - 1; index >= 0; --index) {
@@ -312,20 +309,11 @@ export const getAllHoveredElementAtPoint = (

    if (
      isBindableElement(element, false) &&
-      hitElementItself({
-        element,
-        point,
-        elementsMap,
-        threshold: tolerance ?? getBindingGap(element),
-        overrideShouldTestInside: true,
-      })
+      bindingBorderTest(element, point, elementsMap, tolerance)
    ) {
      candidateElements.push(element);

-      if (
-        hasBackground(element.type) &&
-        !isTransparent(element.backgroundColor)
-      ) {
+      if (!isTransparent(element.backgroundColor)) {
        break;
      }
    }
@@ -335,92 +323,82 @@ export const getAllHoveredElementAtPoint = (
 };

 export const getHoveredElementForBinding = (
-  arrow: { elbowed: boolean },
  point: Readonly<GlobalPoint>,
  elements: readonly Ordered<NonDeletedExcalidrawElement>[],
  elementsMap: NonDeletedSceneElementsMap,
-  zoom?: AppState["zoom"],
+  tolerance?: number,
 ): NonDeleted<ExcalidrawBindableElement> | null => {
-  type Candidate = {
-    element: NonDeleted<ExcalidrawBindableElement>;
-    distance: number;
-    overlapPercent?: number;
-    relativeArea?: number;
-  };
+  const candidateElements = getAllHoveredElementAtPoint(
+    point,
+    elements,
+    elementsMap,
+    tolerance,
+  );

-  const candidates: Candidate[] = [];
-  for (let index = elements.length - 1; index >= 0; --index) {
-    const element = elements[index];
-
-    if (!isBindableElement(element, false)) {
-      continue;
-    }
-
-    const maxDistance = maxBindingDistance_simple(zoom);
-    const distance = bindableElementBorderDistanceIfClose(
-      element,
-      point,
-      elementsMap,
-      maxDistance,
-    );
-
-    if (distance > -maxDistance) {
-      candidates.push({ element, distance });
-
-      if (!isTransparent(element.backgroundColor) && distance >= 0) {
-        break;
-      }
-    }
-  }
-
-  if (candidates.length === 0) {
+  if (!candidateElements || candidateElements.length === 0) {
    return null;
  }

-  if (candidates.length === 1) {
-    return candidates[0].element;
+  if (candidateElements.length === 1) {
+    return candidateElements[0];
  }

-  const closestElements = candidates.sort(
-    (a, b) => Math.abs(a.distance) - Math.abs(b.distance),
-  );
+  // Prefer smaller shapes
+  return candidateElements
+    .sort(
+      (a, b) => b.width ** 2 + b.height ** 2 - (a.width ** 2 + a.height ** 2),
+    )
+    .pop() as NonDeleted<ExcalidrawBindableElement>;
+};

-  const candidate = closestElements[0];
-  const [cx1, cy1, cx2, cy2] = getElementBounds(candidate.element, elementsMap);
-  const candidateArea = Math.max(
-    0.00001,
-    Math.abs(cx2 - cx1) * Math.abs(cy2 - cy1),
-  );
-  const overlaps = closestElements
-    .map((c) => {
-      if (c.element === candidate.element) {
-        return { ...c, overlapPercent: 0, relativeArea: 1 };
-      }
+export const getHoveredElementForFocusPoint = (
+  point: GlobalPoint,
+  arrow: ExcalidrawArrowElement,
+  elements: readonly Ordered<NonDeletedExcalidrawElement>[],
+  elementsMap: NonDeletedSceneElementsMap,
+  tolerance?: number,
+): ExcalidrawBindableElement | null => {
+  const candidateElements: NonDeleted<ExcalidrawBindableElement>[] = [];
+  // We need to to hit testing from front (end of the array) to back (beginning of the array)
+  // because array is ordered from lower z-index to highest and we want element z-index
+  // with higher z-index
+  for (let index = elements.length - 1; index >= 0; --index) {
+    const element = elements[index];

-      const [x1, y1, x2, y2] = getElementBounds(c.element, elementsMap);
-      const overlapX1 = x1 > cx1 && x1 < cx2 ? x1 : cx1;
-      const overlapY1 = y1 > cy1 && y1 < cy2 ? y1 : cy1;
-      const overlapX2 = x2 < cx2 && x2 > cx1 ? x2 : cx2;
-      const overlapY2 = y2 < cy2 && y2 > cy1 ? y2 : cy2;
-      const overlapWdith =
-        overlapX1 !== cx1 || overlapX2 !== cx2 ? overlapX2 - overlapX1 : 0;
-      const overlapHeight =
-        overlapY1 !== cy1 || overlapY2 !== cy2 ? overlapY2 - overlapY1 : 0;
-      const area = Math.max(0.00001, Math.abs(x2 - x1) * Math.abs(y2 - y1));
-      const overlapPercent = Math.abs(overlapHeight * overlapWdith) / area;
+    invariant(
+      !element.isDeleted,
+      "Elements in the function parameter for getAllElementsAtPositionForBinding() should not contain deleted elements",
+    );

-      return {
-        ...c,
-        overlapPercent,
-        relativeArea:
-          overlapPercent === 0 ? 1 : Math.min(area / candidateArea, 1),
-      };
-    })
-    .filter((c) => c.overlapPercent > 0.25 && c.relativeArea < 0.75);
+    if (
+      isBindableElement(element, false) &&
+      bindingBorderTest(element, point, elementsMap, tolerance)
+    ) {
+      candidateElements.push(element);
+    }
+  }

-  return candidate.distance >= 0 && overlaps.length > 0
-    ? overlaps[0].element
-    : candidate.element;
+  if (!candidateElements || candidateElements.length === 0) {
+    return null;
+  }
+
+  if (candidateElements.length === 1) {
+    return candidateElements[0];
+  }
+
+  const distanceFilteredCandidateElements = candidateElements
+    // Resolve by distance
+    .filter(
+      (el) =>
+        distanceToElement(el, elementsMap, point) <= getBindingGap(el, arrow) ||
+        isPointInElement(point, el, elementsMap),
+    );
+
+  if (distanceFilteredCandidateElements.length === 0) {
+    return null;
+  }
+
+  return distanceFilteredCandidateElements[0] as NonDeleted<ExcalidrawBindableElement>;
 };

 /**
@@ -595,9 +573,7 @@ const intersectLinearOrFreeDrawWithLineSegment = (
      continue;
    }

-    const hits = curveIntersectLineSegment(c, segment, {
-      iterLimit: 10,
-    });
+    const hits = curveIntersectLineSegment(c, segment);

    if (hits.length > 0) {
      intersections.push(...hits);
@@ -21,7 +21,7 @@ import { getPerfectElementSize } from "./sizeHelpers";
 import { getBoundTextElement } from "./textElement";
 import { getMinTextElementWidth } from "./textMeasurements";
 import {
-  isArrowElement as isBindingElement,
+  isArrowElement,
  isElbowArrow,
  isFrameLikeElement,
  isImageElement,
@@ -108,7 +108,19 @@ export const dragSelectedElements = (
  );

  elementsToUpdate.forEach((element) => {
-    if (!isBindingElement(element)) {
+    const isArrow = !isArrowElement(element);
+    const isStartBoundElementSelected =
+      isArrow ||
+      (element.startBinding
+        ? elementsToUpdateIds.has(element.startBinding.elementId)
+        : false);
+    const isEndBoundElementSelected =
+      isArrow ||
+      (element.endBinding
+        ? elementsToUpdateIds.has(element.endBinding.elementId)
+        : false);
+
+    if (!isArrowElement(element)) {
      updateElementCoords(pointerDownState, element, scene, adjustedOffset);

      // skip arrow labels since we calculate its position during render
@@ -131,6 +143,7 @@ export const dragSelectedElements = (
      // NOTE: Add a little initial drag to the arrow dragging when the arrow
      // is the single element being dragged to avoid accidentally unbinding
      // the arrow when the user just wants to select it.
+
      elementsToUpdate.size > 1 ||
      Math.max(Math.abs(adjustedOffset.x), Math.abs(adjustedOffset.y)) >
        DRAGGING_THRESHOLD ||
@@ -138,12 +151,9 @@ export const dragSelectedElements = (
    ) {
      updateElementCoords(pointerDownState, element, scene, adjustedOffset);

-      const shouldUnbindStart = element.startBinding
-        ? !elementsToUpdateIds.has(element.startBinding.elementId)
-        : true;
-      const shouldUnbindEnd = element.endBinding
-        ? !elementsToUpdateIds.has(element.endBinding.elementId)
-        : true;
+      const shouldUnbindStart =
+        element.startBinding && !isStartBoundElementSelected;
+      const shouldUnbindEnd = element.endBinding && !isEndBoundElementSelected;
      if (shouldUnbindStart || shouldUnbindEnd) {
        // NOTE: Moving the bound arrow should unbind it, otherwise we would
        // have weird situations, like 0 lenght arrow when the user moves
@@ -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) => {
@@ -30,7 +30,8 @@ import {
  getHeadingForElbowArrowSnap,
  getGlobalFixedPointForBindableElement,
  getBindingGap,
-  BASE_BINDING_GAP,
+  maxBindingDistance_simple,
+  BASE_BINDING_GAP_ELBOW,
 } from "./binding";
 import { distanceToElement } from "./distance";
 import {
@@ -317,7 +318,6 @@ const handleSegmentRelease = (
    ...rest
  } = getElbowArrowData(
    {
-      ...arrow,
      x,
      y,
      startBinding,
@@ -1041,7 +1041,6 @@ export const updateElbowArrowPoints = (
    ...rest
  } = getElbowArrowData(
    {
-      ...arrow,
      x: arrow.x,
      y: arrow.y,
      startBinding,
@@ -1191,7 +1190,15 @@ export const updateElbowArrowPoints = (
 * - hoveredEndElement: The element being hovered over at the end point.
 */
 const getElbowArrowData = (
-  arrow: ExcalidrawElbowArrowElement,
+  arrow: {
+    x: number;
+    y: number;
+    startBinding: FixedPointBinding | null;
+    endBinding: FixedPointBinding | null;
+    startArrowhead: Arrowhead | null;
+    endArrowhead: Arrowhead | null;
+    points: readonly LocalPoint[];
+  },
  elementsMap: NonDeletedSceneElementsMap,
  nextPoints: readonly LocalPoint[],
  options?: {
@@ -1216,7 +1223,6 @@ const getElbowArrowData = (
    const elements = Array.from(elementsMap.values());
    hoveredStartElement =
      getHoveredElement(
-        arrow,
        origStartGlobalPoint,
        elementsMap,
        elements,
@@ -1224,7 +1230,6 @@ const getElbowArrowData = (
      ) || null;
    hoveredEndElement =
      getHoveredElement(
-        arrow,
        origEndGlobalPoint,
        elementsMap,
        elements,
@@ -1251,7 +1256,6 @@ const getElbowArrowData = (
    "start",
    arrow.startBinding?.fixedPoint,
    origStartGlobalPoint,
-    options?.zoom || ({ value: 1 } as AppState["zoom"]),
    hoveredStartElement,
    elementsMap,
    options?.isDragging,
@@ -1269,7 +1273,6 @@ const getElbowArrowData = (
    "end",
    arrow.endBinding?.fixedPoint,
    origEndGlobalPoint,
-    options?.zoom || ({ value: 1 } as AppState["zoom"]),
    hoveredEndElement,
    elementsMap,
    options?.isDragging,
@@ -1311,8 +1314,8 @@ const getElbowArrowData = (
        offsetFromHeading(
          startHeading,
          arrow.startArrowhead
-            ? getBindingGap(hoveredStartElement) * 6
-            : getBindingGap(hoveredStartElement) * 2,
+            ? getBindingGap(hoveredStartElement, { elbowed: true }) * 6
+            : getBindingGap(hoveredStartElement, { elbowed: true }) * 2,
          1,
        ),
      )
@@ -1324,8 +1327,8 @@ const getElbowArrowData = (
        offsetFromHeading(
          endHeading,
          arrow.endArrowhead
-            ? getBindingGap(hoveredEndElement) * 6
-            : getBindingGap(hoveredEndElement) * 2,
+            ? getBindingGap(hoveredEndElement, { elbowed: true }) * 6
+            : getBindingGap(hoveredEndElement, { elbowed: true }) * 2,
          1,
        ),
      )
@@ -1372,8 +1375,8 @@ const getElbowArrowData = (
            ? 0
            : BASE_PADDING -
                (arrow.startArrowhead
-                  ? BASE_BINDING_GAP * 6
-                  : BASE_BINDING_GAP * 2),
+                  ? BASE_BINDING_GAP_ELBOW * 6
+                  : BASE_BINDING_GAP_ELBOW * 2),
          BASE_PADDING,
        ),
    boundsOverlap
@@ -1388,8 +1391,8 @@ const getElbowArrowData = (
            ? 0
            : BASE_PADDING -
                (arrow.endArrowhead
-                  ? BASE_BINDING_GAP * 6
-                  : BASE_BINDING_GAP * 2),
+                  ? BASE_BINDING_GAP_ELBOW * 6
+                  : BASE_BINDING_GAP_ELBOW * 2),
          BASE_PADDING,
        ),
    boundsOverlap,
@@ -2121,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(
@@ -2215,7 +2218,6 @@ const getGlobalPoint = (
  startOrEnd: "start" | "end",
  fixedPointRatio: [number, number] | undefined | null,
  initialPoint: GlobalPoint,
-  zoom: AppState["zoom"],
  element?: ExcalidrawBindableElement | null,
  elementsMap?: ElementsMap,
  isDragging?: boolean,
@@ -2229,7 +2231,6 @@ const getGlobalPoint = (
        element,
        startOrEnd,
        elementsMap,
-        zoom,
        undefined,
        isMidpointSnappingEnabled,
      );
@@ -2278,18 +2279,16 @@ const getBindPointHeading = (
  );

 const getHoveredElement = (
-  arrow: ExcalidrawElbowArrowElement,
  origPoint: GlobalPoint,
  elementsMap: NonDeletedSceneElementsMap,
  elements: readonly Ordered<NonDeletedExcalidrawElement>[],
  zoom?: AppState["zoom"],
 ) => {
  return getHoveredElementForBinding(
-    arrow,
    origPoint,
    elements,
    elementsMap,
-    zoom,
+    maxBindingDistance_simple(zoom),
  );
 };

@@ -452,16 +452,8 @@ const createBindingArrow = (
    "orbit",
    "start",
    scene,
-    appState.zoom,
-  );
-  bindBindingElement(
-    bindingArrow,
-    endBindingElement,
-    "orbit",
-    "end",
-    scene,
-    appState.zoom,
  );
+  bindBindingElement(bindingArrow, endBindingElement, "orbit", "end", scene);

  const changedElements = new Map<string, OrderedExcalidrawElement>();
  changedElements.set(
@@ -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;
  }
@@ -1,6 +1,7 @@
 import { arrayToMap } from "@excalidraw/common";
 import { isPointWithinBounds, pointFrom } from "@excalidraw/math";
 import { doLineSegmentsIntersect } from "@excalidraw/utils/bbox";
+import { elementsOverlappingBBox } from "@excalidraw/utils/withinBounds";

 import type {
  AppClassProperties,
@@ -17,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,
@@ -103,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,
  );
 };

@@ -492,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)
 */
@@ -537,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"]>();

@@ -552,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,
@@ -566,68 +535,38 @@ export const addElementsToFrame = <T extends ElementsMapOrArray>(
      continue;
    }

-    if (element.frameId && element.frameId !== frame.id) {
+    // 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;
    }

-    finalElementsToAdd.add(element);
+    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 = (
@@ -681,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();
 };

@@ -979,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)
  );
 };

@@ -48,6 +48,7 @@ import {
  calculateFixedPointForNonElbowArrowBinding,
  getBindingStrategyForDraggingBindingElementEndpoints,
  isBindingEnabled,
+  snapToMid,
  updateBoundPoint,
 } from "./binding";
 import {
@@ -343,7 +344,7 @@ export class LinearElementEditor {

    // Apply the point movement if needed
    let suggestedBinding: AppState["suggestedBinding"] = null;
-    const { positions, updates, hit } = pointDraggingUpdates(
+    const { positions, updates } = pointDraggingUpdates(
      [idx],
      deltaX,
      deltaY,
@@ -381,20 +382,17 @@ export class LinearElementEditor {

    // Move the arrow over the bindable object in terms of z-index
    if (isBindingElement(element)) {
-      if (hit) {
-        moveArrowAboveBindable(
-          LinearElementEditor.getPointGlobalCoordinates(
-            element,
-            element.points[element.points.length - 1],
-            elementsMap,
-          ),
+      moveArrowAboveBindable(
+        LinearElementEditor.getPointGlobalCoordinates(
          element,
-          elements,
+          element.points[element.points.length - 1],
          elementsMap,
-          app.scene,
-          hit,
-        );
-      }
+        ),
+        element,
+        elements,
+        elementsMap,
+        app.scene,
+      );
    }

    // PERF: Avoid state updates if not absolutely necessary
@@ -488,7 +486,7 @@ export class LinearElementEditor {
          selectedPointsIndices,
        )}) points(0..${
          element.points.length - 1
-        }) lastClickedPoint(${lastClickedPoint}) isElbowArrow: ${elbowed}`,
+        }) lastClickedPoint(${lastClickedPoint})`,
      );

      // Fall back to the actual last point as a last resort.
@@ -541,7 +539,7 @@ export class LinearElementEditor {

    // Apply the point movement if needed
    let suggestedBinding: AppState["suggestedBinding"] = null;
-    const { positions, updates, hit } = pointDraggingUpdates(
+    const { positions, updates } = pointDraggingUpdates(
      selectedPointsIndices,
      deltaX,
      deltaY,
@@ -580,22 +578,19 @@ export class LinearElementEditor {

    // Move the arrow over the bindable object in terms of z-index
    if (isBindingElement(element) && startIsSelected !== endIsSelected) {
-      if (hit) {
-        moveArrowAboveBindable(
-          LinearElementEditor.getPointGlobalCoordinates(
-            element,
-            startIsSelected
-              ? element.points[0]
-              : element.points[element.points.length - 1],
-            elementsMap,
-          ),
+      moveArrowAboveBindable(
+        LinearElementEditor.getPointGlobalCoordinates(
          element,
-          elements,
+          startIsSelected
+            ? element.points[0]
+            : element.points[element.points.length - 1],
          elementsMap,
-          app.scene,
-          hit,
-        );
-      }
+        ),
+        element,
+        elements,
+        elementsMap,
+        app.scene,
+      );
    }

    // Attached text might need to update if arrow dimensions change
@@ -2141,17 +2136,16 @@ const pointDraggingUpdates = (
 ): {
  positions: PointsPositionUpdates;
  updates?: PointMoveOtherUpdates;
-  hit?: ExcalidrawBindableElement | null;
 } => {
  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,
        },
      ];
@@ -2199,15 +2193,13 @@ const pointDraggingUpdates = (
          ? {
              element: suggestedBindingElement,
              midPoint: app.state.isMidpointSnappingEnabled
-                ? getSnapOutlineMidPoint(
+                ? snapToMid(
+                    suggestedBindingElement,
+                    elementsMap,
                    pointFrom<GlobalPoint>(
                      scenePointerX - linearElementEditor.pointerOffset.x,
                      scenePointerY - linearElementEditor.pointerOffset.y,
                    ),
-                    suggestedBindingElement,
-                    elementsMap,
-                    app.state.zoom,
-                    element,
                  )
                : undefined,
            }
@@ -2314,7 +2306,6 @@ const pointDraggingUpdates = (
              start.element,
              elementsMap,
              app.state.zoom,
-              element,
            ),
          }
        : null;
@@ -2354,7 +2345,6 @@ const pointDraggingUpdates = (
              end.element,
              elementsMap,
              app.state.zoom,
-              element,
            ),
          }
        : null;
@@ -2507,7 +2497,6 @@ const pointDraggingUpdates = (
        ];
      }),
    ),
-    hit: startIsDragged ? start.element : end.element,
  };
 };

@@ -1,32 +1,15 @@
-import { arrayToMap, isShallowEqual, type Bounds } from "@excalidraw/common";
-import {
-  lineSegment,
-  pointFrom,
-  pointRotateRads,
-  type GlobalPoint,
-} from "@excalidraw/math";
+import { arrayToMap, isShallowEqual } from "@excalidraw/common";

 import type {
  AppState,
-  BoxSelectionMode,
  InteractiveCanvasAppState,
 } from "@excalidraw/excalidraw/types";

-import {
-  boundsContainBounds,
-  doBoundsIntersect,
-  elementCenterPoint,
-  getElementAbsoluteCoords,
-  getElementBounds,
-  pointInsideBounds,
-} from "./bounds";
-import { intersectElementWithLineSegment } from "./collision";
+import { getElementAbsoluteCoords, getElementBounds } from "./bounds";
 import { isElementInViewport } from "./sizeHelpers";
 import {
-  isArrowElement,
  isBoundToContainer,
  isFrameLikeElement,
-  isFreeDrawElement,
  isLinearElement,
  isTextElement,
 } from "./typeChecks";
@@ -38,33 +21,15 @@ import {

 import { LinearElementEditor } from "./linearElementEditor";
 import { selectGroupsForSelectedElements } from "./groups";
-import { getBoundTextElement } from "./textElement";

 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
@@ -84,286 +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;
-  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();
+  let elementsInSelection = elements.filter((element) => {
+    let [elementX1, elementY1, elementX2, elementY2] = getElementBounds(
+      element,
+      elementsMap,
+    );

-  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,
+    const containingFrame = getContainingFrame(element, elementsMap);
+    if (containingFrame) {
+      const [fx1, fy1, fx2, fy2] = getElementBounds(
+        containingFrame,
        elementsMap,
      );
-      labelAABB = [
-        x,
-        y,
-        x + boundTextElement.width,
-        y + boundTextElement.height,
-      ] as Bounds;
+
+      elementX1 = Math.max(fx1, elementX1);
+      elementY1 = Math.max(fy1, elementY1);
+      elementX2 = Math.min(fx2, elementX2);
+      elementY2 = Math.min(fy2, elementY2);
    }

-    // 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;
+    return (
+      element.locked === false &&
+      element.type !== "selection" &&
+      !isBoundToContainer(element) &&
+      selectionX1 <= elementX1 &&
+      selectionY1 <= elementY1 &&
+      selectionX2 >= elementX2 &&
+      selectionY2 >= elementY2
+    );
+  });

-      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;
+  elementsInSelection = excludeElementsInFrames
+    ? excludeElementsInFramesFromSelection(elementsInSelection)
+    : elementsInSelection;
+
+  elementsInSelection = elementsInSelection.filter((element) => {
+    const containingFrame = getContainingFrame(element, elementsMap);
+
+    if (containingFrame) {
+      return elementOverlapsWithFrame(element, containingFrame, elementsMap);
    }

-    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;
+    return true;
+  });

-    // ============== 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 (
-      boxSelectionMode === "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 (
-      boxSelectionMode === "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 (boxSelectionMode === "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 (boxSelectionMode === "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));
+  return elementsInSelection;
 };

 export const getVisibleAndNonSelectedElements = (
@@ -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));
 };
@@ -17,7 +17,6 @@ import {
 } from "@excalidraw/common";

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

 import { bindBindingElement } from "./binding";
 import {
@@ -249,7 +248,6 @@ const bindLinearElementToElement = (
  end: ValidLinearElement["end"],
  elementStore: ElementStore,
  scene: Scene,
-  zoom: Zoom,
 ): {
  linearElement: ExcalidrawLinearElement;
  startBoundElement?: ExcalidrawElement;
@@ -337,7 +335,6 @@ const bindLinearElementToElement = (
        "orbit",
        "start",
        scene,
-        zoom,
      );
    }
  }
@@ -414,7 +411,6 @@ const bindLinearElementToElement = (
        "orbit",
        "end",
        scene,
-        zoom,
      );
    }
  }
@@ -700,7 +696,6 @@ export const convertToExcalidrawElements = (
                originalEnd,
                elementStore,
                scene,
-                { value: 1 } as Zoom,
              );
            container = linearElement;
            elementStore.add(linearElement);
@@ -726,7 +721,6 @@ export const convertToExcalidrawElements = (
                  end,
                  elementStore,
                  scene,
-                  { value: 1 } as Zoom,
                );

              elementStore.add(linearElement);
@@ -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;
-    }
-  }
-};
@@ -8,7 +8,6 @@ import {

 import {
  bezierEquation,
-  clamp,
  curve,
  curveCatmullRomCubicApproxPoints,
  curveOffsetPoints,
@@ -27,7 +26,7 @@ import {
  type GlobalPoint,
 } from "@excalidraw/math";

-import type { Curve, LineSegment, LocalPoint, Radians } from "@excalidraw/math";
+import type { Curve, LineSegment, LocalPoint } from "@excalidraw/math";

 import type {
  AppState,
@@ -42,7 +41,7 @@ import { generateLinearCollisionShape } from "./shape";
 import { hitElementItself, isPointInElement } from "./collision";
 import { LinearElementEditor } from "./linearElementEditor";
 import { isRectangularElement } from "./typeChecks";
-import { getBindingGap, maxBindingDistance_simple } from "./binding";
+import { maxBindingDistance_simple } from "./binding";

 import {
  getGlobalFixedPointForBindableElement,
@@ -588,193 +587,67 @@ const getDiagonalsForBindableElement = (
  return [diagonalOne, diagonalTwo];
 };

-const getSnappedMidpointIndexForElbowArrow = (
-  element: ExcalidrawBindableElement,
+export const getSnapOutlineMidPoint = (
  point: GlobalPoint,
-  center: GlobalPoint,
-  horizontalThreshold: number,
-  verticalThreshold: number,
-) => {
-  const { x, y, width, height, angle } = element;
-  const nonRotated = pointRotateRads(point, center, -angle as Radians);
-
-  const bindingGap = getBindingGap(element);
-
-  if (pointDistance(center, nonRotated) < bindingGap) {
-    return -1;
-  }
-
-  if (
-    nonRotated[0] <= x + width / 2 &&
-    nonRotated[1] > center[1] - verticalThreshold &&
-    nonRotated[1] < center[1] + verticalThreshold
-  ) {
-    return 2;
-  } else if (
-    nonRotated[1] <= y + height / 2 &&
-    nonRotated[0] > center[0] - horizontalThreshold &&
-    nonRotated[0] < center[0] + horizontalThreshold
-  ) {
-    return 3;
-  } else if (
-    nonRotated[0] >= x + width / 2 &&
-    nonRotated[1] > center[1] - verticalThreshold &&
-    nonRotated[1] < center[1] + verticalThreshold
-  ) {
-    return 0;
-  } else if (
-    nonRotated[1] >= y + height / 2 &&
-    nonRotated[0] > center[0] - horizontalThreshold &&
-    nonRotated[0] < center[0] + horizontalThreshold
-  ) {
-    return 1;
-  } else if (element.type === "diamond") {
-    const distance = bindingGap;
-    const topLeft = pointFrom<GlobalPoint>(
-      x + width / 4 - distance,
-      y + height / 4 - distance,
-    );
-    const topRight = pointFrom<GlobalPoint>(
-      x + (3 * width) / 4 + distance,
-      y + height / 4 - distance,
-    );
-    const bottomLeft = pointFrom<GlobalPoint>(
-      x + width / 4 - distance,
-      y + (3 * height) / 4 + distance,
-    );
-    const bottomRight = pointFrom<GlobalPoint>(
-      x + (3 * width) / 4 + distance,
-      y + (3 * height) / 4 + distance,
-    );
-
-    if (
-      pointDistance(bottomLeft, nonRotated) <
-      Math.max(horizontalThreshold, verticalThreshold)
-    ) {
-      return 1;
-    }
-    if (
-      pointDistance(bottomRight, nonRotated) <
-      Math.max(horizontalThreshold, verticalThreshold)
-    ) {
-      return 0;
-    }
-    if (
-      pointDistance(topLeft, nonRotated) <
-      Math.max(horizontalThreshold, verticalThreshold)
-    ) {
-      return 2;
-    }
-    if (
-      pointDistance(topRight, nonRotated) <
-      Math.max(horizontalThreshold, verticalThreshold)
-    ) {
-      return 3;
-    }
-  }
-
-  return -1;
-};
-
-const getSnappedMidpointIndexForSimpleArrow = (
  element: ExcalidrawBindableElement,
-  point: GlobalPoint,
  elementsMap: ElementsMap,
-  horizontalThreshold: number,
-  verticalThreshold: number,
+  zoom: AppState["zoom"],
 ) => {
-  const baseMidpoints = getAllMidpoints(element, elementsMap);
+  const center = elementCenterPoint(element, elementsMap);
+  const sideMidpoints =
+    element.type === "diamond"
+      ? getDiamondBaseCorners(element).map((curve) => {
+          const point = bezierEquation(curve, 0.5);
+          const rotatedPoint = pointRotateRads(point, center, element.angle);

-  for (let i = 0; i < baseMidpoints.length; i++) {
-    const threshold = i % 2 === 0 ? horizontalThreshold : verticalThreshold;
-
-    if (
-      pointDistance(baseMidpoints[i], point) <= threshold &&
+          return pointFrom<GlobalPoint>(rotatedPoint[0], rotatedPoint[1]);
+        })
+      : [
+          // RIGHT midpoint
+          pointRotateRads(
+            pointFrom<GlobalPoint>(
+              element.x + element.width,
+              element.y + element.height / 2,
+            ),
+            center,
+            element.angle,
+          ),
+          // BOTTOM midpoint
+          pointRotateRads(
+            pointFrom<GlobalPoint>(
+              element.x + element.width / 2,
+              element.y + element.height,
+            ),
+            center,
+            element.angle,
+          ),
+          // LEFT midpoint
+          pointRotateRads(
+            pointFrom<GlobalPoint>(element.x, element.y + element.height / 2),
+            center,
+            element.angle,
+          ),
+          // TOP midpoint
+          pointRotateRads(
+            pointFrom<GlobalPoint>(element.x + element.width / 2, element.y),
+            center,
+            element.angle,
+          ),
+        ];
+  const candidate = sideMidpoints.find(
+    (midpoint) =>
+      pointDistance(point, midpoint) <=
+        maxBindingDistance_simple(zoom) + element.strokeWidth / 2 &&
      !hitElementItself({
        point,
        element,
        threshold: 0,
        elementsMap,
        overrideShouldTestInside: true,
-      })
-    ) {
-      return i;
-    }
-  }
-
-  return -1;
-};
-
-export const getAllMidpoints = (
-  element: ExcalidrawBindableElement,
-  elementsMap: ElementsMap,
-): GlobalPoint[] => {
-  const center = elementCenterPoint(element, elementsMap);
-
-  if (element.type === "diamond") {
-    return getDiamondBaseCorners(element).map((curve) =>
-      pointRotateRads(bezierEquation(curve, 0.5), center, element.angle),
-    );
-  }
-
-  return [
-    pointFrom(element.width, element.height / 2),
-    pointFrom(element.width / 2, element.height),
-    pointFrom(0, element.height / 2),
-    pointFrom(element.width / 2, 0),
-  ].map(([x, y]) =>
-    pointRotateRads(
-      pointFrom<GlobalPoint>(element.x + x, element.y + y),
-      center,
-      element.angle,
-    ),
+      }),
  );
-};

-export const getSnapOutlineMidPoint = (
-  point: GlobalPoint,
-  element: ExcalidrawBindableElement,
-  elementsMap: ElementsMap,
-  zoom: AppState["zoom"],
-  arrow: { elbowed: boolean },
-): GlobalPoint | undefined => {
-  const center = elementCenterPoint(element, elementsMap);
-  const baseMidpoints = getAllMidpoints(element, elementsMap);
-  const sideMidpoints =
-    element.type === "diamond"
-      ? baseMidpoints.map((midpoint) => {
-          return pointFrom<GlobalPoint>(
-            midpoint[0] + (midpoint[0] - center[0]) * 0.1,
-            midpoint[1] + (midpoint[1] - center[1]) * 0.1,
-          );
-        })
-      : baseMidpoints;
-
-  const TOLERANCE = 0.05;
-  const maxDistance = maxBindingDistance_simple(zoom) + element.strokeWidth / 2;
-  const verticalThreshold = clamp(TOLERANCE * element.height, 5, maxDistance);
-  const horizontalThreshold = clamp(TOLERANCE * element.width, 5, maxDistance);
-  const idx = arrow.elbowed
-    ? getSnappedMidpointIndexForElbowArrow(
-        element,
-        point,
-        center,
-        horizontalThreshold,
-        verticalThreshold,
-      )
-    : getSnappedMidpointIndexForSimpleArrow(
-        element,
-        point,
-        elementsMap,
-        horizontalThreshold,
-        verticalThreshold,
-      );
-
-  if (idx === -1) {
-    return undefined;
-  }
-
-  return sideMidpoints[idx];
+  return candidate;
 };

 export const projectFixedPointOntoDiagonal = (
@@ -787,6 +660,9 @@ export const projectFixedPointOntoDiagonal = (
  isMidpointSnappingEnabled: boolean = true,
 ): GlobalPoint | null => {
  invariant(arrow.points.length >= 2, "Arrow must have at least two points");
+  if (arrow.width < 3 && arrow.height < 3) {
+    return null;
+  }

  if (isMidpointSnappingEnabled) {
    const sideMidPoint = getSnapOutlineMidPoint(
@@ -794,7 +670,6 @@ export const projectFixedPointOntoDiagonal = (
      element,
      elementsMap,
      zoom,
-      arrow,
    );
    if (sideMidPoint) {
      return sideMidPoint;
@@ -8,6 +8,7 @@ import { getElementsInGroup } from "./groups";
 import { syncMovedIndices } from "./fractionalIndex";
 import { getSelectedElements } from "./selection";
 import { getBoundTextElement, getContainerElement } from "./textElement";
+import { getHoveredElementForBinding } from "./collision";

 import type { Scene } from "./Scene";
 import type {
@@ -155,8 +156,12 @@ export const moveArrowAboveBindable = (
  elements: readonly Ordered<NonDeletedExcalidrawElement>[],
  elementsMap: NonDeletedSceneElementsMap,
  scene: Scene,
-  hoveredElement: NonDeletedExcalidrawElement,
+  hit?: NonDeletedExcalidrawElement,
 ): readonly OrderedExcalidrawElement[] => {
+  const hoveredElement = hit
+    ? hit
+    : getHoveredElementForBinding(point, elements, elementsMap);
+
  if (!hoveredElement) {
    return elements;
  }
@@ -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} />);
  });

@@ -16,7 +16,6 @@ import "@excalidraw/utils/test-utils";
 import { bindBindingElement } from "@excalidraw/element";

 import type { LocalPoint } from "@excalidraw/math";
-import type { Zoom } from "@excalidraw/excalidraw/types";

 import { Scene } from "../src/Scene";

@@ -188,12 +187,8 @@ describe("elbow arrow routing", () => {
    }) as ExcalidrawElbowArrowElement;
    API.setElements([rectangle1, rectangle2, arrow]);

-    bindBindingElement(arrow, rectangle1, "orbit", "start", h.scene, {
-      value: 1,
-    } as Zoom);
-    bindBindingElement(arrow, rectangle2, "orbit", "end", h.scene, {
-      value: 1,
-    } as Zoom);
+    bindBindingElement(arrow, rectangle1, "orbit", "start", h.scene);
+    bindBindingElement(arrow, rectangle2, "orbit", "end", h.scene);

    expect(arrow.startBinding).not.toBe(null);
    expect(arrow.endBinding).not.toBe(null);
@@ -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: [
@@ -2,24 +2,15 @@ import {
  convertToExcalidrawElements,
  Excalidraw,
 } from "@excalidraw/excalidraw";
-import { arrayToMap } from "@excalidraw/common";

 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 { 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");
@@ -134,250 +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("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,
  ) => {
@@ -668,345 +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 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]);

@@ -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
@@ -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))
-    );
-  },
-});
@@ -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 }) => (
@@ -205,6 +205,7 @@ export const actionWrapSelectionInFrame = register({
      [...app.scene.getElementsIncludingDeleted(), frame],
      selectedElements,
      frame,
+      appState,
    );

    return {
@@ -277,6 +277,7 @@ export const actionUngroup = register({
            elementsMap,
          ),
          frame,
+          app,
        );
      }
    });
@@ -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,
@@ -1897,7 +1897,6 @@ export const actionChangeArrowType = register<keyof typeof ARROW_TYPE>({
                  startElement,
                  "start",
                  elementsMap,
-                  appState.zoom,
                  appState.isBindingEnabled,
                ),
              }
@@ -1912,7 +1911,6 @@ export const actionChangeArrowType = register<keyof typeof ARROW_TYPE>({
                  endElement,
                  "end",
                  elementsMap,
-                  appState.zoom,
                  appState.isBindingEnabled,
                ),
              }
@@ -1945,7 +1943,6 @@ export const actionChangeArrowType = register<keyof typeof ARROW_TYPE>({
              appState.bindMode === "inside" ? "inside" : "orbit",
              "start",
              app.scene,
-              appState.zoom,
            );
          }
        }
@@ -1960,7 +1957,6 @@ export const actionChangeArrowType = register<keyof typeof ARROW_TYPE>({
              appState.bindMode === "inside" ? "inside" : "orbit",
              "end",
              app.scene,
-              appState.zoom,
            );
          }
        }
@@ -34,7 +34,6 @@ export {
 export { actionSetEmbeddableAsActiveTool } from "./actionEmbeddable";

 export { actionFinalize } from "./actionFinalize";
-export { actionDeselect } from "./actionDeselect";

 export {
  actionChangeProjectName,
@@ -114,7 +114,6 @@ export type ActionName =
  | "distributeVertically"
  | "flipHorizontal"
  | "flipVertical"
-  | "deselect"
  | "viewMode"
  | "exportWithDarkMode"
  | "toggleTheme"
@@ -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 {
@@ -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;
+  }
+}
@@ -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 },
@@ -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) {
@@ -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;
 };

@@ -199,7 +199,6 @@ export default function LibraryMenuItems({
            type: "everything",
            elements: item.elements,
            randomizeSeed: true,
-            preserveFrameChildrenOrder: true,
          }).duplicatedElements,
        };
      });
@@ -26,16 +26,13 @@
    background: var(--RadioGroup-background);
    border: 1px solid var(--RadioGroup-border);

-    gap: 2px;
-
    &__choice {
      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);
@@ -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[];
@@ -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);
@@ -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);
@@ -750,7 +750,7 @@ describe("frame resizing behavior", () => {
      x: 0,
      y: 0,
      width: 100,
-      height: 103,
+      height: 100,
    });

    // Create a rectangle outside the frame
@@ -3,7 +3,25 @@
 $verticalBreakpoint: 861px;

 .excalidraw {
+  --ttd-mermaid-token-keyword: #0000ff;
+  --ttd-mermaid-token-string: #a31515;
+  --ttd-mermaid-token-comment: #008000;
+  --ttd-mermaid-token-number: #098658;
+  --ttd-mermaid-token-operator: #1e1e1e;
+  --ttd-mermaid-token-punctuation: #1e1e1e;
+  --ttd-mermaid-token-variable-name: #001080;
+  --ttd-mermaid-token-bracket: #af00db;
+
  &.theme--dark {
+    --ttd-mermaid-token-keyword: #569cd6;
+    --ttd-mermaid-token-string: #ce9178;
+    --ttd-mermaid-token-comment: #6a9955;
+    --ttd-mermaid-token-number: #b5cea8;
+    --ttd-mermaid-token-operator: #d4d4d4;
+    --ttd-mermaid-token-punctuation: #d4d4d4;
+    --ttd-mermaid-token-variable-name: #9cdcfe;
+    --ttd-mermaid-token-bracket: #ffd700;
+
    .chat-message {
      &--assistant {
        .chat-message__content {
@@ -194,7 +212,7 @@ $verticalBreakpoint: 861px;
      align-items: flex-start;

      .chat-message__content {
-        background: var(--color-surface-low);
+        background: #f7f7f7;
        color: var(--color-on-surface);
        border-radius: var(--border-radius-md);
        min-width: 6rem;
@@ -292,6 +310,51 @@ $verticalBreakpoint: 861px;
      word-wrap: break-word;
    }

+    &__text--error {
+      color: inherit;
+    }
+
+    &__text--mermaid {
+      overflow-x: auto;
+      font-weight: 400;
+    }
+
+    &__token {
+      white-space: inherit;
+    }
+
+    &__token--keyword {
+      color: var(--ttd-mermaid-token-keyword);
+    }
+
+    &__token--string {
+      color: var(--ttd-mermaid-token-string);
+    }
+
+    &__token--comment {
+      color: var(--ttd-mermaid-token-comment);
+    }
+
+    &__token--number {
+      color: var(--ttd-mermaid-token-number);
+    }
+
+    &__token--operator {
+      color: var(--ttd-mermaid-token-operator);
+    }
+
+    &__token--punctuation {
+      color: var(--ttd-mermaid-token-punctuation);
+    }
+
+    &__token--variableName {
+      color: var(--ttd-mermaid-token-variable-name);
+    }
+
+    &__token--bracket {
+      color: var(--ttd-mermaid-token-bracket);
+    }
+
    &__cursor {
      display: inline-block;
      margin-left: 2px;
@@ -332,11 +395,13 @@ $verticalBreakpoint: 861px;
    &__error {
      color: var(--color-danger);
      font-weight: 500;
-      white-space: pre-wrap;
-      word-wrap: break-word;
      display: flex;
      flex-direction: column;
      gap: 0.5rem;
+
+      .chat-message__text--mermaid {
+        color: var(--color-on-surface);
+      }
    }

    &__error_message {
@@ -5,8 +5,49 @@ import { t } from "../../../i18n";
 import { FilledButton } from "../../FilledButton";
 import { TrashIcon, codeIcon, stackPushIcon, RetryIcon } from "../../icons";

+import { tokenizeMermaid } from "../mermaid-highlighting";
+
 import type { TChat, TTTDDialog } from "../types";

+const isMermaidMessage = (message: TChat.ChatMessage) =>
+  message.contentFormat === "mermaid";
+
+const renderMessageContent = (
+  message: TChat.ChatMessage,
+  className: string,
+) => {
+  const content = message.content ?? "";
+
+  console.log("@", message);
+
+  if (!isMermaidMessage(message)) {
+    return (
+      <div className={className}>
+        {content}
+        {message.isGenerating && (
+          <span className="chat-message__cursor">▋</span>
+        )}
+      </div>
+    );
+  }
+
+  return (
+    <div className={clsx(className, "chat-message__text--mermaid")}>
+      {tokenizeMermaid(content).map((token, index) => (
+        <span
+          key={`${index}-${token.type ?? "text"}-${token.value}`}
+          className={clsx("chat-message__token", {
+            [`chat-message__token--${token.type}`]: token.type,
+          })}
+        >
+          {token.value}
+        </span>
+      ))}
+      {message.isGenerating && <span className="chat-message__cursor">▋</span>}
+    </div>
+  );
+};
+
 export const ChatMessage: React.FC<{
  message: TChat.ChatMessage;
  onMermaidTabClick?: (message: TChat.ChatMessage) => void;
@@ -122,7 +163,14 @@ export const ChatMessage: React.FC<{
        <div className="chat-message__body">
          {message.error ? (
            <>
-              <div className="chat-message__error">{message.content}</div>
+              <div className="chat-message__error">
+                {renderMessageContent(
+                  message,
+                  clsx("chat-message__text", {
+                    "chat-message__text--error": !isMermaidMessage(message),
+                  }),
+                )}
+              </div>
              {message.errorType !== "parse" && (
                <div className="chat-message__error_message">
                  Error: {message.error || t("chat.errors.generationFailed")}
@@ -132,7 +180,7 @@ export const ChatMessage: React.FC<{
                <div className="chat-message__error_message">
                  <p>{t("chat.errors.invalidDiagram")}</p>
                  <div className="chat-message__error-actions">
-                    {onMermaidTabClick && (
+                    {onMermaidTabClick && isMermaidMessage(message) && (
                      <button
                        className="chat-message__error-link"
                        onClick={() => onMermaidTabClick(message)}
@@ -156,18 +204,13 @@ export const ChatMessage: React.FC<{
              )}
            </>
          ) : (
-            <div className="chat-message__text">
-              {message.content}
-              {message.isGenerating && (
-                <span className="chat-message__cursor">▋</span>
-              )}
-            </div>
+            renderMessageContent(message, "chat-message__text")
          )}
        </div>
      </div>
      {message.type === "assistant" && !message.isGenerating && (
        <div className="chat-message__actions">
-          {!message.error && onInsertMessage && (
+          {!message.error && onInsertMessage && isMermaidMessage(message) && (
            <button
              className="chat-message__action"
              onClick={() => onInsertMessage(message)}
@@ -178,7 +221,7 @@ export const ChatMessage: React.FC<{
              {stackPushIcon}
            </button>
          )}
-          {onMermaidTabClick && message.content && (
+          {onMermaidTabClick && isMermaidMessage(message) && message.content && (
            <button
              className="chat-message__action"
              onClick={() => onMermaidTabClick(message)}
@@ -25,6 +25,7 @@ export const TTDChatPanel = ({
  onGenerate,
  isGenerating,
  generatedResponse,
+  generatedResponseFormat,
  isMenuOpen,
  onMenuToggle,
  onMenuClose,
@@ -50,6 +51,7 @@ export const TTDChatPanel = ({
  onGenerate: TTTDDialog.OnGenerate;
  isGenerating: boolean;
  generatedResponse: string | null | undefined;
+  generatedResponseFormat?: TChat.ChatMessage["contentFormat"];

  isMenuOpen: boolean;
  onMenuToggle: () => void;
@@ -89,7 +91,7 @@ export const TTDChatPanel = ({
      });
    }

-    if (generatedResponse) {
+    if (generatedResponse && generatedResponseFormat === "mermaid") {
      actions.push({
        action: onViewAsMermaid,
        label: t("chat.viewAsMermaid"),
@@ -25,6 +25,7 @@ export const useChatAgent = () => {
        {
          type: "assistant",
          content: "",
+          contentFormat: "mermaid",
          isGenerating: true,
        },
      ]),
@@ -1,13 +1,21 @@
 import { useEffect, useRef } from "react";
 import {
  Decoration,
+  type DecorationSet,
  EditorView,
+  ViewPlugin,
+  type ViewUpdate,
  keymap,
  lineNumbers,
  placeholder as cmPlaceholder,
  drawSelection,
 } from "@codemirror/view";
-import { Compartment, EditorState, type Extension } from "@codemirror/state";
+import {
+  Compartment,
+  EditorState,
+  type Extension,
+  type Range,
+} from "@codemirror/state";
 import {
  defaultKeymap,
  history,
@@ -40,6 +48,13 @@ const darkTheme = EditorView.theme(
    },
    ".cm-content": { caretColor: "#fff" },
    ".cm-cursor": { borderLeftColor: "#fff" },
+    ".cm-selectionBackground": {
+      backgroundColor: "rgba(86, 156, 214, 0.3)",
+    },
+    "&.cm-focused > .cm-scroller > .cm-selectionLayer .cm-selectionBackground":
+      {
+        backgroundColor: "rgba(86, 156, 214, 0.42)",
+      },
    ".cm-gutters": {
      backgroundColor: "#1e1e1e",
      color: "#858585",
@@ -48,6 +63,10 @@ const darkTheme = EditorView.theme(
    ".cm-activeLineGutter": { backgroundColor: "#2a2a2a" },
    ".cm-activeLine": { backgroundColor: "#2a2a2a" },
    ".cm-errorLine": { backgroundColor: "rgba(255, 0, 0, 0.15)" },
+    ".cm-selectedWordMatch": {
+      backgroundColor: "rgba(255, 209, 102, 0.22)",
+      borderRadius: "2px",
+    },
  },
  { dark: true },
 );
@@ -80,6 +99,10 @@ const lightTheme = EditorView.theme({
  ".cm-activeLineGutter": { backgroundColor: "#e8e8e8" },
  ".cm-activeLine": { backgroundColor: "#e8e8e8" },
  ".cm-errorLine": { backgroundColor: "rgba(255, 0, 0, 0.1)" },
+  ".cm-selectedWordMatch": {
+    backgroundColor: "rgba(255, 209, 102, 0.35)",
+    borderRadius: "2px",
+  },
 });

 const lightHighlight = HighlightStyle.define([
@@ -96,6 +119,79 @@ const lightHighlight = HighlightStyle.define([
 // ---- Error line decoration ----

 const errorLineDeco = Decoration.line({ class: "cm-errorLine" });
+const selectedWordMatchDeco = Decoration.mark({
+  class: "cm-selectedWordMatch",
+});
+
+const getSelectedWordMatchText = (state: EditorState) => {
+  const mainSelection = state.selection.main;
+  if (state.selection.ranges.length !== 1 || mainSelection.empty) {
+    return null;
+  }
+
+  const selectedWord = state.wordAt(mainSelection.from);
+  if (
+    !selectedWord ||
+    selectedWord.from !== mainSelection.from ||
+    selectedWord.to !== mainSelection.to
+  ) {
+    return null;
+  }
+
+  return state.sliceDoc(mainSelection.from, mainSelection.to);
+};
+
+const getSelectedWordMatchDecorations = (view: EditorView): DecorationSet => {
+  const selectedWord = getSelectedWordMatchText(view.state);
+  if (!selectedWord) {
+    return Decoration.none;
+  }
+
+  const selection = view.state.selection.main;
+  const ranges: Range<Decoration>[] = [];
+  const doc = view.state.doc.toString();
+  let searchFrom = 0;
+
+  while (searchFrom <= doc.length - selectedWord.length) {
+    const matchFrom = doc.indexOf(selectedWord, searchFrom);
+    if (matchFrom === -1) {
+      break;
+    }
+
+    const matchTo = matchFrom + selectedWord.length;
+    const matchWord = view.state.wordAt(matchFrom);
+    if (
+      matchWord?.from === matchFrom &&
+      matchWord.to === matchTo &&
+      (matchFrom !== selection.from || matchTo !== selection.to)
+    ) {
+      ranges.push(selectedWordMatchDeco.range(matchFrom, matchTo));
+    }
+
+    searchFrom = matchTo;
+  }
+
+  return ranges.length ? Decoration.set(ranges) : Decoration.none;
+};
+
+const selectedWordMatchExtension = ViewPlugin.fromClass(
+  class {
+    decorations: DecorationSet;
+
+    constructor(view: EditorView) {
+      this.decorations = getSelectedWordMatchDecorations(view);
+    }
+
+    update(update: ViewUpdate) {
+      if (update.docChanged || update.selectionSet) {
+        this.decorations = getSelectedWordMatchDecorations(update.view);
+      }
+    }
+  },
+  {
+    decorations: (value) => value.decorations,
+  },
+);

 const getErrorLineExtension = (
  errorLine: number | null | undefined,
@@ -172,6 +268,7 @@ const CodeMirrorEditor = ({
          errorLineCompartmentRef.current.of([]),
          mermaidLite(),
          drawSelection({ drawRangeCursor: true }),
+          selectedWordMatchExtension,
          ...(placeholder ? [cmPlaceholder(placeholder)] : []),
        ],
      }),
@@ -80,7 +80,10 @@ const TextToDiagramContent = ({
  } = useChatManagement({ persistenceAdapter });

  const onViewAsMermaid = () => {
-    if (typeof lastAssistantMessage?.content === "string") {
+    if (
+      lastAssistantMessage?.contentFormat === "mermaid" &&
+      typeof lastAssistantMessage.content === "string"
+    ) {
      saveMermaidDataToStorage(lastAssistantMessage.content);
      setAppState({
        openDialog: { name: "ttd", tab: "mermaid" },
@@ -206,6 +209,7 @@ const TextToDiagramContent = ({
        onGenerate={onGenerate}
        isGenerating={lastAssistantMessage?.isGenerating ?? false}
        generatedResponse={lastAssistantMessage?.content}
+        generatedResponseFormat={lastAssistantMessage?.contentFormat}
        isMenuOpen={isMenuOpen}
        onMenuToggle={handleMenuToggle}
        onMenuClose={handleMenuClose}
@@ -88,6 +88,7 @@ export const useTextGeneration = ({
        updateAssistantContent(prev, {
          isGenerating: true,
          content: "",
+          contentFormat: "mermaid",
          error: undefined,
          errorType: undefined,
          errorDetails: undefined,
@@ -0,0 +1,40 @@
+import {
+  getMermaidHighlightToken,
+  tokenizeMermaid,
+} from "./mermaid-highlighting";
+
+describe("mermaid highlighting", () => {
+  it("tokenizes mermaid syntax with shared token types", () => {
+    const tokens = tokenizeMermaid('flowchart LR\nA["Hello"] --> B');
+
+    expect(tokens).toEqual([
+      { type: "keyword", value: "flowchart" },
+      { type: null, value: " " },
+      { type: "keyword", value: "LR" },
+      { type: null, value: "\n" },
+      { type: "variableName", value: "A" },
+      { type: "bracket", value: "[" },
+      { type: "string", value: '"Hello"' },
+      { type: "bracket", value: "]" },
+      { type: null, value: " " },
+      { type: "operator", value: "-->" },
+      { type: null, value: " " },
+      { type: "variableName", value: "B" },
+    ]);
+  });
+
+  it("limits comment tokens to a single line", () => {
+    const tokens = tokenizeMermaid("%% comment\nflowchart TD");
+
+    expect(tokens[0]).toEqual({ type: "comment", value: "%% comment" });
+    expect(tokens[1]).toEqual({ type: null, value: "\n" });
+    expect(tokens[2]).toEqual({ type: "keyword", value: "flowchart" });
+  });
+
+  it("falls back to plain text for unsupported characters", () => {
+    expect(getMermaidHighlightToken("@node")).toEqual({
+      type: null,
+      value: "@",
+    });
+  });
+});
@@ -0,0 +1,79 @@
+export type MermaidHighlightTokenType =
+  | "bracket"
+  | "comment"
+  | "keyword"
+  | "number"
+  | "operator"
+  | "punctuation"
+  | "string"
+  | "variableName";
+
+export type MermaidHighlightToken = {
+  type: MermaidHighlightTokenType | null;
+  value: string;
+};
+
+const DIAGRAM_TYPE_PATTERN =
+  /^(flowchart|graph|sequenceDiagram|classDiagram|stateDiagram|erDiagram|gantt|pie|mindmap|journey|gitGraph|timeline|quadrantChart|sankey|xychart)\b/i;
+const DIRECTION_PATTERN = /^(TB|TD|BT|RL|LR)\b/;
+const KEYWORD_PATTERN =
+  /^(subgraph|end|participant|actor|loop|alt|else|opt|par|critical|break|rect|note|over|activate|deactivate|title|section|class|style|linkStyle|classDef|click)\b/i;
+
+const MERMAID_TOKEN_RULES: ReadonlyArray<{
+  pattern: RegExp;
+  type: MermaidHighlightTokenType | null;
+}> = [
+  { pattern: /^%%[^\n]*/, type: "comment" },
+  { pattern: /^"(?:[^"\\]|\\.)*"/, type: "string" },
+  { pattern: DIAGRAM_TYPE_PATTERN, type: "keyword" },
+  { pattern: DIRECTION_PATTERN, type: "keyword" },
+  { pattern: KEYWORD_PATTERN, type: "keyword" },
+  { pattern: /^[-.=<>|ox]+>/, type: "operator" },
+  { pattern: /^<[-.=<>|ox]+/, type: "operator" },
+  { pattern: /^(--+|\.\.+|==+)/, type: "operator" },
+  { pattern: /^[[\](){}|<>]/, type: "bracket" },
+  { pattern: /^[A-Za-z_][A-Za-z0-9_]*/, type: "variableName" },
+  { pattern: /^\d+(\.\d+)?/, type: "number" },
+  { pattern: /^[,:;]/, type: "punctuation" },
+  { pattern: /^\s+/, type: null },
+];
+
+export const getMermaidHighlightToken = (
+  input: string,
+): MermaidHighlightToken | null => {
+  if (!input) {
+    return null;
+  }
+
+  for (const rule of MERMAID_TOKEN_RULES) {
+    const match = input.match(rule.pattern);
+    if (match) {
+      return {
+        type: rule.type,
+        value: match[0],
+      };
+    }
+  }
+
+  return {
+    type: null,
+    value: input[0],
+  };
+};
+
+export const tokenizeMermaid = (input: string): MermaidHighlightToken[] => {
+  const tokens: MermaidHighlightToken[] = [];
+  let remaining = input;
+
+  while (remaining) {
+    const token = getMermaidHighlightToken(remaining);
+    if (!token) {
+      break;
+    }
+
+    tokens.push(token);
+    remaining = remaining.slice(token.value.length);
+  }
+
+  return tokens;
+};
@@ -1,79 +1,17 @@
 import { StreamLanguage } from "@codemirror/language";

+import { getMermaidHighlightToken } from "./mermaid-highlighting";
+
 const mermaidStreamParser = StreamLanguage.define({
  token(stream) {
-    // Comments: %%...
-    if (stream.match(/^%%.*$/)) {
-      return "comment";
-    }
-
-    // Strings
-    if (stream.match(/^"(?:[^"\\]|\\.)*"/)) {
-      return "string";
-    }
-
-    // Diagram type keywords (at start of line or after whitespace)
-    if (
-      stream.match(
-        /^(flowchart|graph|sequenceDiagram|classDiagram|stateDiagram|erDiagram|gantt|pie|mindmap|journey|gitGraph|timeline|quadrantChart|sankey|xychart)\b/i,
-      )
-    ) {
-      return "keyword";
-    }
-
-    // Direction keywords
-    if (stream.match(/^(TB|TD|BT|RL|LR)\b/)) {
-      return "keyword";
-    }
-
-    // Keywords
-    if (
-      stream.match(
-        /^(subgraph|end|participant|actor|loop|alt|else|opt|par|critical|break|rect|note|over|activate|deactivate|title|section|class|style|linkStyle|classDef|click)\b/i,
-      )
-    ) {
-      return "keyword";
-    }
-
-    // Arrows: -->, ---, -.->, ===>, etc.
-    if (stream.match(/^[-.=<>|ox]+>/)) {
-      return "operator";
-    }
-    if (stream.match(/^<[-.=<>|ox]+/)) {
-      return "operator";
-    }
-    if (stream.match(/^--+|\.\.+|==+/)) {
-      return "operator";
-    }
-
-    // Labels in brackets/parens: [text], (text), {text}, ((text)), etc.
-    if (stream.match(/^[[\](){}|<>]/)) {
-      return "bracket";
-    }
-
-    // Node IDs (alphanumeric)
-    if (stream.match(/^[A-Za-z_][A-Za-z0-9_]*/)) {
-      return "variableName";
-    }
-
-    // Numbers
-    if (stream.match(/^\d+(\.\d+)?/)) {
-      return "number";
-    }
-
-    // Punctuation
-    if (stream.match(/^[,:;]/)) {
-      return "punctuation";
-    }
-
-    // Skip whitespace
-    if (stream.eatSpace()) {
+    const token = getMermaidHighlightToken(stream.string.slice(stream.pos));
+    if (!token) {
+      stream.skipToEnd();
      return null;
    }

-    // Skip any other character
-    stream.next();
-    return null;
+    stream.pos += token.value.length;
+    return token.type;
  },
 });

@@ -18,6 +18,8 @@ export type MermaidData = {
  files: BinaryFiles | null;
 };

+export type ChatMessageContentFormat = "text" | "mermaid";
+
 export interface RateLimits {
  rateLimit: number;
  rateLimitRemaining: number;
@@ -33,6 +35,7 @@ export namespace TChat {
    errorType?: "parse" | "network" | "other";
    lastAttemptAt?: number;
    type: "user" | "assistant" | "warning";
+    contentFormat?: ChatMessageContentFormat;
    warningType?: /* daily rate limit */
    "messageLimitExceeded" | /* general 429 */ "rateLimitExceeded";
    content?: string;
@@ -7,6 +7,17 @@ import { chatHistoryAtom } from "./TTDContext";

 import type { SavedChat, SavedChats, TTDPersistenceAdapter } from "./types";

+const normalizePersistedChat = (chat: SavedChat): SavedChat => ({
+  ...chat,
+  messages: chat.messages.map((message) => ({
+    ...message,
+    // Legacy TTD chats predate explicit content format metadata.
+    contentFormat:
+      message.contentFormat ??
+      (message.type === "assistant" ? "mermaid" : undefined),
+  })),
+});
+
 interface UseTTDChatStorageProps {
  persistenceAdapter: TTDPersistenceAdapter;
 }
@@ -56,7 +67,7 @@ export const useTTDChatStorage = ({
    setIsLoading(true);
    try {
      const chats = await persistenceAdapter.loadChats();
-      setSavedChats(chats);
+      setSavedChats(chats.map(normalizePersistedChat));
      setChatsLoaded(true);
    } catch (error) {
      console.warn("Failed to load chats:", error);
@@ -117,6 +117,28 @@ describe("chat utils", () => {
      expect(result.messages[0].errorType).toBe("network");
    });

+    it("should update content format when provided", () => {
+      const chatHistory: TChat.ChatHistory = {
+        id: "chat-1",
+        currentPrompt: "",
+        messages: [
+          {
+            id: "1",
+            type: "assistant",
+            content: "graph TD",
+            timestamp: new Date("2024-01-01"),
+            contentFormat: "text",
+          },
+        ],
+      };
+
+      const result = updateAssistantContent(chatHistory, {
+        contentFormat: "mermaid",
+      });
+
+      expect(result.messages[0].contentFormat).toBe("mermaid");
+    });
+
    it("should return unchanged chatHistory if no assistant message exists", () => {
      const chatHistory: TChat.ChatHistory = {
        id: "chat-1",
@@ -357,6 +379,7 @@ describe("chat utils", () => {
        {
          type: "assistant",
          content: "Message",
+          contentFormat: "mermaid",
          isGenerating: true,
          error: "Error text",
          errorType: "parse",
@@ -364,6 +387,7 @@ describe("chat utils", () => {
      ]);

      expect(result.messages[0].isGenerating).toBe(true);
+      expect(result.messages[0].contentFormat).toBe("mermaid");
      expect(result.messages[0].error).toBe("Error text");
      expect(result.messages[0].errorType).toBe("parse");
    });
@@ -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 ||
@@ -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,
@@ -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
@@ -2,7 +2,7 @@

 .excalidraw {
  .dropdown-menu {
-    max-width: 20rem;
+    max-width: 16rem;
    z-index: 1;

    &--placement-top {
@@ -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}
@@ -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,
@@ -433,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();
@@ -607,7 +568,6 @@ export const Preferences = ({
      <DropdownMenuSub.Content className="excalidraw-main-menu-preferences-submenu">
        {children || (
          <>
-            <PreferencesBoxSelectionModeItem />
            <PreferencesToggleToolLockItem />
            <PreferencesToggleSnapModeItem />
            <PreferencesToggleGridModeItem />
@@ -625,7 +585,6 @@ export const Preferences = ({
 };

 Preferences.ToggleToolLock = PreferencesToggleToolLockItem;
-Preferences.BoxSelectionMode = PreferencesBoxSelectionModeItem;
 Preferences.ToggleSnapMode = PreferencesToggleSnapModeItem;
 Preferences.ToggleArrowBinding = PreferencesToggleArrowBindingItem;
 Preferences.ToggleMidpointSnapping = PreferencesToggleMidpointSnappingItem;
@@ -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;
 };
@@ -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);
    }
@@ -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,
@@ -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,
@@ -1,4 +1,4 @@
-import { isFiniteNumber, isValidPoint, pointFrom } from "@excalidraw/math";
+import { isFiniteNumber, pointFrom } from "@excalidraw/math";

 import {
  type CombineBrandsIfNeeded,
@@ -96,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
@@ -475,15 +412,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":
@@ -501,20 +433,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, {
@@ -528,7 +454,7 @@ export const restoreElement = (
        y,
        ...(isLineElement(element)
          ? {
-              polygon: isValidPolygon(points)
+              polygon: isValidPolygon(element.points)
                ? element.polygon ?? false
                : false,
            }
@@ -541,31 +467,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,
@@ -574,8 +493,8 @@ export const restoreElement = (
        startArrowhead,
        endArrowhead,
        points,
-        x: x ?? 0,
-        y: y ?? 0,
+        x,
+        y,
        elbowed: (element as ExcalidrawArrowElement).elbowed,
        ...getSizeFromPoints(points),
      };
@@ -594,44 +513,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
@@ -779,7 +666,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,
@@ -876,7 +762,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 (
@@ -1050,12 +936,6 @@ export const restoreAppState = (
        : defaultValue;
  }

-  const boxSelectionMode =
-    appState.boxSelectionMode ?? localAppState?.boxSelectionMode;
-  if (boxSelectionMode !== undefined) {
-    nextAppState.boxSelectionMode = boxSelectionMode;
-  }
-
  return {
    ...nextAppState,
    cursorButton: localAppState?.cursorButton || "up",
@@ -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,
@@ -6,11 +6,7 @@ import React, {
  useState,
 } from "react";

-import {
-  DEFAULT_IMAGE_OPTIONS,
-  DEFAULT_UI_OPTIONS,
-  isShallowEqual,
-} from "@excalidraw/common";
+import { DEFAULT_UI_OPTIONS, isShallowEqual } from "@excalidraw/common";

 import App, {
  ExcalidrawAPIContext,
@@ -102,7 +98,6 @@ const ExcalidrawBase = (props: ExcalidrawProps) => {
    aiEnabled,
    showDeprecatedFonts,
    renderScrollbars,
-    imageOptions,
  } = props;

  const canvasActions = props.UIOptions?.canvasActions;
@@ -133,13 +128,6 @@ const ExcalidrawBase = (props: ExcalidrawProps) => {
    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);
@@ -220,7 +208,6 @@ const ExcalidrawBase = (props: ExcalidrawProps) => {
          aiEnabled={aiEnabled !== false}
          showDeprecatedFonts={showDeprecatedFonts}
          renderScrollbars={renderScrollbars}
-          imageOptions={normalizedImageOptions}
        >
          {children}
        </App>
@@ -238,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;

@@ -288,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);
@@ -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);
+      }
+    }
  }
 }
@@ -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) => {
@@ -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",
@@ -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",
@@ -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 = "";
@@ -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();
  }
 }
@@ -7,6 +7,7 @@ import {
  type Radians,
  bezierEquation,
  pointRotateRads,
+  pointDistance,
 } from "@excalidraw/math";

 import {
@@ -23,12 +24,13 @@ import {
  deconstructDiamondElement,
  deconstructRectanguloidElement,
  elementCenterPoint,
-  getAllMidpoints,
+  getDiamondBaseCorners,
  FOCUS_POINT_SIZE,
  getOmitSidesForEditorInterface,
  getTransformHandles,
  getTransformHandlesFromCoords,
  hasBoundingBox,
+  hitElementItself,
  isArrowElement,
  isBindableElement,
  isElbowArrow,
@@ -36,6 +38,7 @@ import {
  isImageElement,
  isLinearElement,
  isLineElement,
+  maxBindingDistance_simple,
  isTextElement,
  LinearElementEditor,
  getActiveTextElement,
@@ -410,42 +413,145 @@ const renderBindingHighlightForBindableElement_simple = (
      break;
  }

-  // Draw midpoint indicators
  if (
    appState.isMidpointSnappingEnabled &&
    (isFrameLikeElement(suggestedBinding.element) ||
      isBindableElement(suggestedBinding.element))
  ) {
-    context.save();
+    // Draw midpoint indicators
+    const linearElement = appState.selectedLinearElement;
+    const arrow =
+      linearElement?.elementId &&
+      LinearElementEditor.getElement(linearElement?.elementId, elementsMap);
+    const cursorIsInsideBindable =
+      pointerCoords &&
+      hitElementItself({
+        point: pointerCoords,
+        element: suggestedBinding.element,
+        elementsMap,
+        threshold: 0,
+        overrideShouldTestInside: true,
+      });

-    const midpointRadius = 4 / appState.zoom.value;
+    const isElbow =
+      (arrow && isElbowArrow(arrow)) ||
+      (appState.activeTool.type === "arrow" &&
+        appState.currentItemArrowType === "elbow");

-    // Render base midpoints
-    const midpoints = getAllMidpoints(suggestedBinding.element, elementsMap);
-    for (const midpoint of midpoints) {
-      context.fillStyle =
-        appState.theme === THEME.DARK
-          ? `rgba(0, 0, 0, 0.8)`
-          : `rgba(65, 65, 65, 0.5)`;
-      context.beginPath();
-      context.arc(midpoint[0], midpoint[1], midpointRadius, 0, 2 * Math.PI);
-      context.fill();
+    if (!cursorIsInsideBindable || isElbow) {
+      context.save();
+
+      const center = elementCenterPoint(suggestedBinding.element, elementsMap);
+
+      let midpoints: GlobalPoint[];
+      if (suggestedBinding.element.type === "diamond") {
+        const center = elementCenterPoint(
+          suggestedBinding.element,
+          elementsMap,
+        );
+        midpoints = getDiamondBaseCorners(suggestedBinding.element).map(
+          (curve) => {
+            const point = bezierEquation(curve, 0.5);
+            const rotatedPoint = pointRotateRads(
+              point,
+              center,
+              suggestedBinding.element.angle,
+            );
+
+            return pointFrom<GlobalPoint>(rotatedPoint[0], rotatedPoint[1]);
+          },
+        );
+      } else {
+        const basePoints = [
+          {
+            x: suggestedBinding.element.width,
+            y: suggestedBinding.element.height / 2,
+          }, // RIGHT
+          {
+            x: suggestedBinding.element.width / 2,
+            y: suggestedBinding.element.height,
+          }, // BOTTOM
+          { x: 0, y: suggestedBinding.element.height / 2 }, // LEFT
+          { x: suggestedBinding.element.width / 2, y: 0 }, // TOP
+        ];
+        midpoints = basePoints.map((point) => {
+          const globalPoint = pointFrom<GlobalPoint>(
+            point.x + suggestedBinding.element.x,
+            point.y + suggestedBinding.element.y,
+          );
+          const rotatedPoint = pointRotateRads(
+            globalPoint,
+            center,
+            suggestedBinding.element.angle,
+          );
+          return pointFrom<GlobalPoint>(rotatedPoint[0], rotatedPoint[1]);
+        });
+      }
+
+      const hoveredMidpoint =
+        pointerCoords &&
+        midpoints.reduce(
+          (
+            closestIdx: {
+              idx: number;
+              distance: number;
+            },
+            point,
+            idx,
+          ) => {
+            const distance = pointDistance(point, pointerCoords);
+            if (idx === -1 || distance < closestIdx.distance) {
+              return { idx, distance };
+            }
+            return closestIdx;
+          },
+          {
+            idx: -1,
+            distance: Infinity,
+          },
+        );
+
+      const midpointRadius = 4 / appState.zoom.value;
+      const highlightThreshold =
+        maxBindingDistance_simple(appState.zoom) +
+        suggestedBinding.element.strokeWidth / 2;
+
+      midpoints.forEach((midpoint, idx) => {
+        const isHighlighted =
+          (!cursorIsInsideBindable || isElbow) &&
+          hoveredMidpoint?.idx === idx &&
+          hoveredMidpoint.distance <= highlightThreshold;
+
+        // also render midpoint if cursor close but not highlighted
+        // (for elbows, always show all points)
+        const isShown =
+          !isHighlighted &&
+          (isElbow ||
+            (idx === hoveredMidpoint?.idx &&
+              hoveredMidpoint.distance <= highlightThreshold * 2));
+
+        if (isHighlighted) {
+          context.fillStyle =
+            appState.theme === THEME.DARK
+              ? `rgba(3, 93, 161, 1)`
+              : `rgba(106, 189, 252, 1)`;
+
+          context.beginPath();
+          context.arc(midpoint[0], midpoint[1], midpointRadius, 0, 2 * Math.PI);
+          context.fill();
+        } else if (isShown) {
+          context.fillStyle =
+            appState.theme === THEME.DARK
+              ? `rgba(0, 0, 0, 0.8)`
+              : `rgba(65, 65, 65, 0.5)`;
+          context.beginPath();
+          context.arc(midpoint[0], midpoint[1], midpointRadius, 0, 2 * Math.PI);
+          context.fill();
+        }
+      });
+
+      context.restore();
    }
-
-    // Render the highlighted midpoint if any
-    const midpoint = appState.suggestedBinding?.midPoint;
-    if (midpoint) {
-      context.fillStyle =
-        appState.theme === THEME.DARK
-          ? `rgba(3, 93, 161, 1)`
-          : `rgba(106, 189, 252, 1)`;
-
-      context.beginPath();
-      context.arc(midpoint[0], midpoint[1], midpointRadius, 0, 2 * Math.PI);
-      context.fill();
-    }
-
-    context.restore();
  }
 };

@@ -1,15 +1,9 @@
-import {
-  getCommonFrameId,
-  getFrameChildrenInsertionIndex,
-  isElementInViewport,
-} from "@excalidraw/element";
+import { isElementInViewport } from "@excalidraw/element";

-import { arrayToMap, memoize, toBrandedType } from "@excalidraw/common";
+import { memoize, toBrandedType } from "@excalidraw/common";

 import type {
  ExcalidrawElement,
-  ExcalidrawFrameLikeElement,
-  NonDeleted,
  NonDeletedElementsMap,
  NonDeletedExcalidrawElement,
 } from "@excalidraw/element/types";
@@ -22,21 +16,6 @@ import type { RenderableElementsMap } from "./types";

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

-type GetRenderableElementsOpts = {
-  zoom: AppState["zoom"];
-  offsetLeft: AppState["offsetLeft"];
-  offsetTop: AppState["offsetTop"];
-  scrollX: AppState["scrollX"];
-  scrollY: AppState["scrollY"];
-  height: AppState["height"];
-  width: AppState["width"];
-  editingTextElement: AppState["editingTextElement"];
-  newElement: AppState["newElement"];
-  selectedElements: readonly NonDeletedExcalidrawElement[];
-  selectedElementsAreBeingDragged: AppState["selectedElementsAreBeingDragged"];
-  frameToHighlight: AppState["frameToHighlight"];
-};
-
 export class Renderer {
  private scene: Scene;

@@ -44,121 +23,9 @@ export class Renderer {
    this.scene = scene;
  }

-  private getVisibleCanvasElements({
-    elementsMap,
-    zoom,
-    offsetLeft,
-    offsetTop,
-    scrollX,
-    scrollY,
-    height,
-    width,
-  }: {
-    elementsMap: NonDeletedElementsMap;
-    zoom: AppState["zoom"];
-    offsetLeft: AppState["offsetLeft"];
-    offsetTop: AppState["offsetTop"];
-    scrollX: AppState["scrollX"];
-    scrollY: AppState["scrollY"];
-    height: AppState["height"];
-    width: AppState["width"];
-  }): readonly NonDeletedExcalidrawElement[] {
-    const visibleElements: NonDeletedExcalidrawElement[] = [];
-    for (const element of elementsMap.values()) {
-      if (
-        isElementInViewport(
-          element,
-          width,
-          height,
-          {
-            zoom,
-            offsetLeft,
-            offsetTop,
-            scrollX,
-            scrollY,
-          },
-          elementsMap,
-        )
-      ) {
-        visibleElements.push(element);
-      }
-    }
-    return visibleElements;
-  }
-
-  private getRenderableElementsMap({
-    elements,
-    editingTextElement,
-    newElement,
-  }: {
-    elements: readonly NonDeletedExcalidrawElement[];
-    editingTextElement: AppState["editingTextElement"];
-    newElement: AppState["newElement"];
-  }) {
-    const elementsMap = toBrandedType<RenderableElementsMap>(new Map());
-    const newElementCanvasElement = newElement?.frameId ? null : newElement;
-
-    for (const element of elements) {
-      if (newElementCanvasElement?.id === element.id) {
-        continue;
-      }
-
-      // we don't want to render text element that's being currently edited
-      // (it's rendered on remote only)
-      if (
-        !editingTextElement ||
-        editingTextElement.type !== "text" ||
-        element.id !== editingTextElement.id
-      ) {
-        elementsMap.set(element.id, element);
-      }
-    }
-    return { elementsMap, newElementCanvasElement };
-  }
-
-  private sortSelectedElementsIntoHighlightedFrame<
-    T extends ExcalidrawElement,
-  >({
-    visibleElements,
-    selectedElements,
-    frameToHighlight,
-  }: {
-    selectedElements: readonly NonDeletedExcalidrawElement[];
-    visibleElements: readonly T[];
-    frameToHighlight: NonDeleted<ExcalidrawFrameLikeElement>;
-  }): readonly T[] {
-    if (!selectedElements.length) {
-      return visibleElements;
-    }
-
-    // we assume all selected elements are eligible frame children if
-    // frameToHighlight is defined
-    const selectedElementsMap = arrayToMap(selectedElements);
-
-    // thus, all deselected elements are the ones we won't reorder
-    const deselectedElements = visibleElements.filter(
-      (element) => !selectedElementsMap.has(element.id),
-    );
-
-    const insertionIndex = getFrameChildrenInsertionIndex(
-      deselectedElements,
-      frameToHighlight.id,
-    );
-
-    if (insertionIndex === null) {
-      return visibleElements;
-    }
-
-    return [
-      ...deselectedElements.slice(0, insertionIndex),
-      ...selectedElements,
-      ...deselectedElements.slice(insertionIndex),
-    ] as readonly T[];
-  }
-
-  private _getRenderableElements = memoize(
-    ({
-      canvasNonce,
+  public getRenderableElements = (() => {
+    const getVisibleCanvasElements = ({
+      elementsMap,
      zoom,
      offsetLeft,
      offsetTop,
@@ -166,27 +33,70 @@ export class Renderer {
      scrollY,
      height,
      width,
+    }: {
+      elementsMap: NonDeletedElementsMap;
+      zoom: AppState["zoom"];
+      offsetLeft: AppState["offsetLeft"];
+      offsetTop: AppState["offsetTop"];
+      scrollX: AppState["scrollX"];
+      scrollY: AppState["scrollY"];
+      height: AppState["height"];
+      width: AppState["width"];
+    }): readonly NonDeletedExcalidrawElement[] => {
+      const visibleElements: NonDeletedExcalidrawElement[] = [];
+      for (const element of elementsMap.values()) {
+        if (
+          isElementInViewport(
+            element,
+            width,
+            height,
+            {
+              zoom,
+              offsetLeft,
+              offsetTop,
+              scrollX,
+              scrollY,
+            },
+            elementsMap,
+          )
+        ) {
+          visibleElements.push(element);
+        }
+      }
+      return visibleElements;
+    };
+
+    const getRenderableElements = ({
+      elements,
      editingTextElement,
-      newElement,
-    }: Omit<
-      GetRenderableElementsOpts,
-      | "selectedElements"
-      | "selectedElementsAreBeingDragged"
-      | "frameToHighlight"
-    > & {
-      canvasNonce: string;
+      newElementId,
+    }: {
+      elements: readonly NonDeletedExcalidrawElement[];
+      editingTextElement: AppState["editingTextElement"];
+      newElementId: ExcalidrawElement["id"] | undefined;
    }) => {
-      const elements = this.scene.getNonDeletedElements();
+      const elementsMap = toBrandedType<RenderableElementsMap>(new Map());

-      const { elementsMap, newElementCanvasElement } =
-        this.getRenderableElementsMap({
-          elements,
-          editingTextElement,
-          newElement,
-        });
+      for (const element of elements) {
+        if (newElementId === element.id) {
+          continue;
+        }

-      const visibleElements = this.getVisibleCanvasElements({
-        elementsMap,
+        // we don't want to render text element that's being currently edited
+        // (it's rendered on remote only)
+        if (
+          !editingTextElement ||
+          editingTextElement.type !== "text" ||
+          element.id !== editingTextElement.id
+        ) {
+          elementsMap.set(element.id, element);
+        }
+      }
+      return elementsMap;
+    };
+
+    return memoize(
+      ({
        zoom,
        offsetLeft,
        offsetTop,
@@ -194,69 +104,52 @@ export class Renderer {
        scrollY,
        height,
        width,
-      });
+        editingTextElement,
+        newElementId,
+        // cache-invalidation nonce
+        sceneNonce: _sceneNonce,
+      }: {
+        zoom: AppState["zoom"];
+        offsetLeft: AppState["offsetLeft"];
+        offsetTop: AppState["offsetTop"];
+        scrollX: AppState["scrollX"];
+        scrollY: AppState["scrollY"];
+        height: AppState["height"];
+        width: AppState["width"];
+        editingTextElement: AppState["editingTextElement"];
+        /** note: first render of newElement will always bust the cache
+         * (we'd have to prefilter elements outside of this function) */
+        newElementId: ExcalidrawElement["id"] | undefined;
+        sceneNonce: ReturnType<InstanceType<typeof Scene>["getSceneNonce"]>;
+      }) => {
+        const elements = this.scene.getNonDeletedElements();

-      return {
-        elementsMap,
-        visibleElements,
-        newElementCanvasElement,
-        canvasNonce,
-      };
-    },
-  );
-
-  public getRenderableElements = (opts: GetRenderableElementsOpts) => {
-    const { newElement } = opts;
-    const canvasNonce = `${this.scene.getSceneNonce()}${
-      newElement?.frameId ? `:${newElement.versionNonce}` : ""
-    }`;
-
-    const ret = this._getRenderableElements({
-      canvasNonce,
-
-      // don't spread `opts` because we don't want to memoize on some props
-
-      zoom: opts.zoom,
-      offsetLeft: opts.offsetLeft,
-      offsetTop: opts.offsetTop,
-      scrollX: opts.scrollX,
-      scrollY: opts.scrollY,
-      height: opts.height,
-      width: opts.width,
-      editingTextElement: opts.editingTextElement,
-      newElement: opts.newElement,
-    });
-
-    // if we're dragging elements over a frame, reorder the selected elements
-    // inside the frame during render (we don't set the `element.frameId` until
-    // pointerup else we'd have to painstainly restore the orig index if user
-    // didn't end up adding elements to the frame)
-    if (
-      opts.frameToHighlight &&
-      opts.selectedElementsAreBeingDragged &&
-      // if all dragged elements are already in the frame, don't reorder
-      getCommonFrameId(opts.selectedElements) !== opts.frameToHighlight.id
-    ) {
-      const reorderedVisibleElements =
-        this.sortSelectedElementsIntoHighlightedFrame({
-          visibleElements: ret.visibleElements,
-          selectedElements: opts.selectedElements,
-          frameToHighlight: opts.frameToHighlight,
+        const elementsMap = getRenderableElements({
+          elements,
+          editingTextElement,
+          newElementId,
        });

-      return {
-        ...ret,
-        visibleElements: reorderedVisibleElements,
-      };
-    }
+        const visibleElements = getVisibleCanvasElements({
+          elementsMap,
+          zoom,
+          offsetLeft,
+          offsetTop,
+          scrollX,
+          scrollY,
+          height,
+          width,
+        });

-    return ret;
-  };
+        return { elementsMap, visibleElements };
+      },
+    );
+  })();

  // NOTE Doesn't destroy everything (scene, rc, etc.) because it may not be
  // safe to break TS contract here (for upstream cases)
  public destroy() {
    renderStaticSceneThrottled.cancel();
-    this._getRenderableElements.clear();
+    this.getRenderableElements.clear();
  }
 }
@@ -157,11 +157,7 @@ const prepareElementsForRender = ({
  let nextElements: readonly ExcalidrawElement[];

  if (exportingFrame) {
-    nextElements = getElementsOverlappingFrame(
-      elements,
-      exportingFrame,
-      arrayToMap(elements),
-    );
+    nextElements = getElementsOverlappingFrame(elements, exportingFrame);
  } else if (frameRendering.enabled && frameRendering.name) {
    nextElements = addFrameLabelsAsTextElements(elements, {
      exportWithDarkMode,
@@ -83,26 +83,6 @@ mockMermaidToExcalidraw({
  },
 });

-const normalizeDialogSnapshot = (dialog: Element) => {
-  const dialogClone = dialog.cloneNode(true) as HTMLElement;
-
-  dialogClone
-    .querySelectorAll<HTMLElement>(".ttd-dialog-content")
-    .forEach((element) => {
-      // Radix Tabs injects this during initial mount animation prevention.
-      // Its presence depends on render timing and is unrelated to this test.
-      if (element.style.animationDuration === "0s") {
-        element.style.removeProperty("animation-duration");
-      }
-
-      if (!element.getAttribute("style")) {
-        element.removeAttribute("style");
-      }
-    });
-
-  return dialogClone.outerHTML;
-};
-
 describe("Test <MermaidToExcalidraw/>", () => {
  beforeEach(async () => {
    await render(
@@ -119,7 +99,7 @@ describe("Test <MermaidToExcalidraw/>", () => {
  it("should open mermaid popup when active tool is mermaid", async () => {
    const dialog = document.querySelector(".ttd-dialog")!;
    await waitFor(() => expect(dialog.querySelector("canvas")).not.toBeNull());
-    expect(normalizeDialogSnapshot(dialog)).toMatchSnapshot();
+    expect(dialog.outerHTML).toMatchSnapshot();
  });

  it("should show error in preview when mermaid library throws error", async () => {
@@ -1,6 +1,6 @@
 // Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html

-exports[`Test <MermaidToExcalidraw/> > should open mermaid popup when active tool is mermaid 1`] = `"<div class="Modal Dialog ttd-dialog" role="dialog" aria-modal="true" aria-labelledby="dialog-title"><div class="Modal__background"></div><div class="Modal__content" style="--max-width: 1520px;" tabindex="0"><div class="Island"><div class="Dialog__content"><div dir="ltr" data-orientation="horizontal" class="ttd-dialog-tabs-root"><p class="dialog-mermaid-title">Mermaid to Excalidraw</p><div data-state="active" data-orientation="horizontal" role="tabpanel" aria-labelledby="radix-:r4:-trigger-mermaid" id="radix-:r4:-content-mermaid" tabindex="0" class="ttd-dialog-content"><div class="ttd-dialog-desc">Currently only <a href="https://mermaid.js.org/syntax/flowchart.html" target="_blank" rel="noreferrer">Flowchart</a>, <a href="https://mermaid.js.org/syntax/sequenceDiagram.html" target="_blank" rel="noreferrer">Sequence</a>, <a href="https://mermaid.js.org/syntax/classDiagram.html" target="_blank" rel="noreferrer">Class</a>, and <a href="https://mermaid.js.org/syntax/entityRelationshipDiagram.html" target="_blank" rel="noreferrer">Entity Relationship</a> Diagrams are supported. The other types will be rendered as image in Excalidraw.</div><div class="ttd-dialog-panels"><div class="ttd-dialog-panel"><div class="ttd-dialog-panel-button-container invisible" style="justify-content: flex-start;"></div></div><div class="ttd-dialog-panel"><div class="ttd-dialog-output-wrapper "><div class="ttd-dialog-output-canvas-container"><div class="ttd-dialog-output-canvas-content"><canvas width="89" height="158" dir="ltr"></canvas></div></div></div><div class="ttd-dialog-panel-button-container" style="justify-content: flex-start;"><button type="button" class="excalidraw-button ttd-dialog-panel-button"><div class="">Insert<span><svg aria-hidden="true" focusable="false" role="img" viewBox="0 0 20 20" class="" fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round"><g stroke-width="1.25"><path d="M4.16602 10H15.8327"></path><path d="M12.5 13.3333L15.8333 10"></path><path d="M12.5 6.66666L15.8333 9.99999"></path></g></svg></span></div></button><div class="ttd-dialog-submit-shortcut"><div class="ttd-dialog-submit-shortcut__key">Ctrl</div><div class="ttd-dialog-submit-shortcut__key">Enter</div></div></div></div></div></div></div></div></div></div></div>"`;
+exports[`Test <MermaidToExcalidraw/> > should open mermaid popup when active tool is mermaid 1`] = `"<div class="Modal Dialog ttd-dialog" role="dialog" aria-modal="true" aria-labelledby="dialog-title"><div class="Modal__background"></div><div class="Modal__content" style="--max-width: 1520px;" tabindex="0"><div class="Island"><div class="Dialog__content"><div dir="ltr" data-orientation="horizontal" class="ttd-dialog-tabs-root"><p class="dialog-mermaid-title">Mermaid to Excalidraw</p><div data-state="active" data-orientation="horizontal" role="tabpanel" aria-labelledby="radix-:r4:-trigger-mermaid" id="radix-:r4:-content-mermaid" tabindex="0" class="ttd-dialog-content" style=""><div class="ttd-dialog-desc">Currently only <a href="https://mermaid.js.org/syntax/flowchart.html" target="_blank" rel="noreferrer">Flowchart</a>, <a href="https://mermaid.js.org/syntax/sequenceDiagram.html" target="_blank" rel="noreferrer">Sequence</a>, <a href="https://mermaid.js.org/syntax/classDiagram.html" target="_blank" rel="noreferrer">Class</a>, and <a href="https://mermaid.js.org/syntax/entityRelationshipDiagram.html" target="_blank" rel="noreferrer">Entity Relationship</a> Diagrams are supported. The other types will be rendered as image in Excalidraw.</div><div class="ttd-dialog-panels"><div class="ttd-dialog-panel"><div class="ttd-dialog-panel-button-container invisible" style="justify-content: flex-start;"></div></div><div class="ttd-dialog-panel"><div class="ttd-dialog-output-wrapper "><div class="ttd-dialog-output-canvas-container"><div class="ttd-dialog-output-canvas-content"><canvas width="89" height="158" dir="ltr"></canvas></div></div></div><div class="ttd-dialog-panel-button-container" style="justify-content: flex-start;"><button type="button" class="excalidraw-button ttd-dialog-panel-button"><div class="">Insert<span><svg aria-hidden="true" focusable="false" role="img" viewBox="0 0 20 20" class="" fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round"><g stroke-width="1.25"><path d="M4.16602 10H15.8327"></path><path d="M12.5 13.3333L15.8333 10"></path><path d="M12.5 6.66666L15.8333 9.99999"></path></g></svg></span></div></button><div class="ttd-dialog-submit-shortcut"><div class="ttd-dialog-submit-shortcut__key">Ctrl</div><div class="ttd-dialog-submit-shortcut__key">Enter</div></div></div></div></div></div></div></div></div></div></div>"`;

 exports[`Test <MermaidToExcalidraw/> > should show error in preview when mermaid library throws error 1`] = `
 "flowchart TD
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
dwelle	9448cca81d	feat(editor): highlight duplicate matches in mermaid editor	2026-03-24 16:16:44 +01:00
dwelle	217c59a13a	feat(editor): highlight TTD assistant responses	2026-03-24 16:14:26 +01:00