fix: extend wait time for file loading on mobile devices

2025-08-01 12:42:20 +10:00
581 changed files with 18772 additions and 63677 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.
@@ -12,7 +12,7 @@ VITE_APP_WS_SERVER_URL=http://localhost:3002
 VITE_APP_PLUS_LP=https://plus.excalidraw.com
 VITE_APP_PLUS_APP=http://localhost:3000

-VITE_APP_AI_BACKEND=http://localhost:3016
+VITE_APP_AI_BACKEND=http://localhost:3015

 VITE_APP_FIREBASE_CONFIG='{"apiKey":"AIzaSyCMkxA60XIW8KbqMYL7edC4qT5l4qHX2h8","authDomain":"excalidraw-oss-dev.firebaseapp.com","projectId":"excalidraw-oss-dev","storageBucket":"excalidraw-oss-dev.appspot.com","messagingSenderId":"664559512677","appId":"1:664559512677:web:a385181f2928d328a7aa8c"}'

@@ -27,7 +27,7 @@ VITE_APP_ENABLE_TRACKING=true
 FAST_REFRESH=false

 # The port the run the dev server
-VITE_APP_PORT=3001
+VITE_APP_PORT=3000

 #Debug flags

@@ -1,7 +0,0 @@
-# VITE_DEBUG_DOM
-#   When "true", testing-library failures (waitFor / getBy*) include the full
-#   serialized DOM in the error message. It's off by default because it's noisy.
-#
-#   Flip it to "true" (or use `VITE_DEBUG_DOM=true yarn test`) when you need to
-#   inspect the DOM of a failing test.
-VITE_DEBUG_DOM=false
@@ -39,26 +39,5 @@
        "allowReferrer": true
      }
    ]
-  },
-  "overrides": [
-    {
-      "files": ["packages/excalidraw/**/*.{ts,tsx}"],
-      "excludedFiles": ["packages/excalidraw/**/*.test.{ts,tsx}", "packages/excalidraw/**/*.test.*.{ts,tsx}"],
-      "rules": {
-        "@typescript-eslint/no-restricted-imports": [
-          "error",
-          {
-            "patterns": [
-              {
-                "group": ["@excalidraw/excalidraw"],
-                "message": "Do not import from the barrel 'index.tsx' files. Use direct relative imports to the specific module instead.",
-                "allowTypeImports": true
-              }
-            ],
-            "paths": [".", "..", "../..", "../../..", "../../../..", "../../../../..", "../index", "../../index", "../../../index", "../../../../index"]
-          }
-        ]
-      }
-    }
-  ]
+  }
 }
@@ -9,13 +9,13 @@ 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
+      - name: Setup Node.js 18.x
+        uses: actions/setup-node@v2
        with:
-          node-version: 20.x
+          node-version: 18.x
      - name: Set up publish access
        run: |
          npm config set //registry.npmjs.org/:_authToken ${NPM_TOKEN}
@@ -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,12 +7,12 @@ 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
+      - name: Setup Node.js 18.x
+        uses: actions/setup-node@v2
        with:
-          node-version: 20.x
+          node-version: 18.x

      - name: Install and lint
        run: |
@@ -10,14 +10,14 @@ 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
+      - name: Setup Node.js 18.x
+        uses: actions/setup-node@v2
        with:
-          node-version: 20.x
+          node-version: 18.x

      - name: Create report file
        run: |
@@ -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,11 +9,11 @@ jobs:
  sentry:
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
-      - name: Setup Node.js
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+      - uses: actions/checkout@v2
+      - name: Setup Node.js 18.x
+        uses: actions/setup-node@v2
        with:
-          node-version: 20.x
+          node-version: 18.x
      - name: Install and build
        run: |
          yarn --frozen-lockfile
@@ -28,7 +28,7 @@ jobs:
          export SENTRY_RELEASE=$(sentry-cli releases propose-version)
          sentry-cli releases new $SENTRY_RELEASE --project $SENTRY_PROJECT
          sentry-cli releases set-commits --auto $SENTRY_RELEASE
-          sentry-cli sourcemaps upload --release $SENTRY_RELEASE --no-rewrite ./build/static/js/ --url-prefix "~/static/js"
+          sentry-cli releases files $SENTRY_RELEASE upload-sourcemaps --no-rewrite ./build/static/js/ --url-prefix "~/static/js"
          sentry-cli releases finalize $SENTRY_RELEASE
          sentry-cli releases deploys $SENTRY_RELEASE new -e production
        env:
@@ -10,17 +10,17 @@ jobs:
      CI_JOB_NUMBER: 1
    steps:
      - name: Checkout repository
-        uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
-      - name: Setup Node.js
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+        uses: actions/checkout@v3
+      - name: Setup Node.js 18.x
+        uses: actions/setup-node@v3
        with:
-          node-version: 20.x
+          node-version: 18.x
      - name: Install in packages/excalidraw
        run: yarn
        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,17 +10,17 @@ 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"
+          node-version: "18.x"
      - name: "Install Deps"
        run: yarn install
      - name: "Test Coverage"
        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,11 +8,11 @@ jobs:
  test:
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
-      - name: Setup Node.js
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+      - uses: actions/checkout@v4
+      - name: Setup Node.js 18.x
+        uses: actions/setup-node@v4
        with:
-          node-version: 20.x
+          node-version: 18.x
      - name: Install and test
        run: |
          yarn install
@@ -0,0 +1 @@
+18
@@ -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

@@ -23,17 +23,23 @@
 <br />
 <p align="center">
  <a href="https://github.com/excalidraw/excalidraw/blob/master/LICENSE">
-    <img alt="Excalidraw is released under the MIT license." src="https://img.shields.io/badge/license-MIT-blue.svg"  /></a>
+    <img alt="Excalidraw is released under the MIT license." src="https://img.shields.io/badge/license-MIT-blue.svg"  />
+  </a>
  <a href="https://www.npmjs.com/package/@excalidraw/excalidraw">
-    <img alt="npm downloads/month" src="https://img.shields.io/npm/dm/@excalidraw/excalidraw"  /></a>
+    <img alt="npm downloads/month" src="https://img.shields.io/npm/dm/@excalidraw/excalidraw"  />
+  </a>
  <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>
+    <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>
+    <img alt="Ask DeepWiki" src="https://deepwiki.com/badge.svg" />
+  </a>
  <a href="https://twitter.com/excalidraw">
-    <img alt="Follow Excalidraw on Twitter" src="https://img.shields.io/twitter/follow/excalidraw.svg?label=follow+@excalidraw&style=social&logo=twitter"/></a>
+    <img alt="Follow Excalidraw on Twitter" src="https://img.shields.io/twitter/follow/excalidraw.svg?label=follow+@excalidraw&style=social&logo=twitter"/>
+  </a>
 </p>

 <div align="center">
@@ -9,7 +9,7 @@ You will need to import the `Footer` component from the package and wrap your co
 ```jsx live
 function App() {
  return (
-    <div style={{ height: "500px" }}>
+    <div style={{ height: "500px"}}>
      <Excalidraw>
        <Footer>
          <button
@@ -27,19 +27,19 @@ function App() {

 This will only work for `Desktop` devices.

-For `mobile` you will need to render it inside the [MainMenu](#mainmenu). You can use the [`useEditorInterface`](#useEditorInterface) hook to check the type of device, this will be available only inside the `children` of `Excalidraw` component.
+For `mobile` you will need to render it inside the [MainMenu](#mainmenu). You can use the [`useDevice`](#useDevice) hook to check the type of device, this will be available only inside the `children` of `Excalidraw` component.

 Open the `Menu` in the below playground and you will see the `custom footer` rendered.

 ```jsx live noInline
 const MobileFooter = ({}) => {
-  const editorInterface = useEditorInterface();
-  if (editorInterface.formFactor === "phone") {
+  const device = useDevice();
+  if (device.editor.isMobile) {
    return (
      <Footer>
        <button
          className="custom-footer"
-          style={{ marginLeft: "20px", height: "2rem" }}
+          style= {{ marginLeft: '20px', height: '2rem'}}
          onClick={() => alert("This is custom footer in mobile menu")}
        >
          custom footer
@@ -172,7 +172,7 @@ convertToExcalidrawElements([
    type: "arrow",
    x: 450,
    y: 20,
-    startArrowhead: "circle",
+    startArrowhead: "dot",
    endArrowhead: "triangle",
    strokeColor: "#1971c2",
    strokeWidth: 2,
@@ -292,7 +292,7 @@ viewportCoordsToSceneCoords(&#123; clientX: number, clientY: number },<br/>&nbsp
  appState: <a href="https://github.com/excalidraw/excalidraw/blob/master/packages/excalidraw/types.ts#L95">AppState</a><br/>): &#123;x: number, y: number}
 </pre>

-### useEditorInterface
+### useDevice

 This hook can be used to check the type of device which is being used. It can only be used inside the `children` of `Excalidraw` component.

@@ -300,8 +300,8 @@ Open the `main menu` in the below example to view the footer.

 ```jsx live noInline
 const MobileFooter = ({}) => {
-  const editorInterface = useEditorInterface();
-  if (editorInterface.formFactor === "phone") {
+  const device = useDevice();
+  if (device.editor.isMobile) {
    return (
      <Footer>
        <button
@@ -336,20 +336,12 @@ render(<App />);
 The `device` has the following `attributes`, some grouped into `viewport` and `editor` objects, per context.

 | Name | Type | Description |
-| ---- | ---- | ----------- |
-
-The `EditorInterface` object has the following properties:
-
-| Name | Type | Description |
-| --- | --- | --- | --- | --- | --- |
-| `formFactor` | `'phone' | 'tablet' | 'desktop'` | Indicates the device type based on screen size |
-| `desktopUIMode` | `'compact' | 'full'` | UI mode for desktop form factor |
-| `userAgent.raw` | `string` | Raw user agent string |
-| `userAgent.isMobileDevice` | `boolean` | True if device is mobile |
-| `userAgent.platform` | `'ios' | 'android' | 'other' | 'unknown'` | Device platform |
-| `isTouchScreen` | `boolean` | True if touch events are detected |
-| `canFitSidebar` | `boolean` | True if sidebar can fit in the viewport |
-| `isLandscape` | `boolean` | True if viewport is in landscape mode |
+| --- | --- | --- |
+| `viewport.isMobile` | `boolean` | Set to `true` when viewport is in `mobile` breakpoint |
+| `viewport.isLandscape` | `boolean` | Set to `true` when the viewport is in `landscape` mode |
+| `editor.canFitSidebar` | `boolean` | Set to `true` if there's enough space to fit the `sidebar` |
+| `editor.isMobile` | `boolean` | Set to `true` when editor container is in `mobile` breakpoint |
+| `isTouchScreen` | `boolean` | Set to `true` for `touch` when touch event detected |

 ### i18n

@@ -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",
@@ -1,3 +1,5 @@
+version: "3.8"
+
 services:
  excalidraw:
    build:
@@ -12,10 +12,10 @@ const MobileFooter = ({
  excalidrawAPI: ExcalidrawImperativeAPI;
  excalidrawLib: typeof TExcalidraw;
 }) => {
-  const { useEditorInterface, Footer } = excalidrawLib;
+  const { useDevice, Footer } = excalidrawLib;

-  const editorInterface = useEditorInterface();
-  if (editorInterface.formFactor === "phone") {
+  const device = useDevice();
+  if (device.editor.isMobile) {
    return (
      <Footer>
        <CustomFooter
@@ -1,4 +1,4 @@
-import type { ExcalidrawElementSkeleton } from "@excalidraw/excalidraw/element/transform";
+import type { ExcalidrawElementSkeleton } from "@excalidraw/excalidraw/data/transform";
 import type { FileId } from "@excalidraw/excalidraw/element/types";

 const elements: ExcalidrawElementSkeleton[] = [
@@ -3,14 +3,14 @@
  "version": "1.0.0",
  "private": true,
  "dependencies": {
-    "@excalidraw/excalidraw": "*",
-    "browser-fs-access": "0.38.0",
    "react": "19.0.0",
-    "react-dom": "19.0.0"
+    "react-dom": "19.0.0",
+    "@excalidraw/excalidraw": "*",
+    "browser-fs-access": "0.29.1"
  },
  "devDependencies": {
-    "typescript": "^5",
-    "vite": "5.0.12"
+    "vite": "5.0.12",
+    "typescript": "^5"
  },
  "scripts": {
    "start": "vite",
@@ -4,6 +4,8 @@ import { unstable_batchedUpdates } from "react-dom";

 type FILE_EXTENSION = Exclude<keyof typeof MIME_TYPES, "binary">;

+const INPUT_CHANGE_INTERVAL_MS = 500;
+
 export type ResolvablePromise<T> = Promise<T> & {
  resolve: [T] extends [undefined] ? (value?: T) => void : (value: T) => void;
  reject: (error: Error) => void;
@@ -52,6 +54,40 @@ export const fileOpen = <M extends boolean | undefined = false>(opts: {
    extensions,
    mimeTypes,
    multiple: opts.multiple ?? false,
+    legacySetup: (resolve, reject, input) => {
+      const scheduleRejection = debounce(reject, INPUT_CHANGE_INTERVAL_MS);
+      const focusHandler = () => {
+        checkForFile();
+        document.addEventListener("keyup", scheduleRejection);
+        document.addEventListener("pointerup", scheduleRejection);
+        scheduleRejection();
+      };
+      const checkForFile = () => {
+        // this hack might not work when expecting multiple files
+        if (input.files?.length) {
+          const ret = opts.multiple ? [...input.files] : input.files[0];
+          resolve(ret as RetType);
+        }
+      };
+      requestAnimationFrame(() => {
+        window.addEventListener("focus", focusHandler);
+      });
+      const interval = window.setInterval(() => {
+        checkForFile();
+      }, INPUT_CHANGE_INTERVAL_MS);
+      return (rejectPromise) => {
+        clearInterval(interval);
+        scheduleRejection.cancel();
+        window.removeEventListener("focus", focusHandler);
+        document.removeEventListener("keyup", scheduleRejection);
+        document.removeEventListener("pointerup", scheduleRejection);
+        if (rejectPromise) {
+          // so that something is shown in console if we need to debug this
+          console.warn("Opening the file was canceled (legacy-fs).");
+          rejectPromise(new Error("Request Aborted"));
+        }
+      };
+    },
  }) as Promise<RetType>;
 };

@@ -4,9 +4,6 @@ import {
  TTDDialogTrigger,
  CaptureUpdateAction,
  reconcileElements,
-  useEditorInterface,
-  ExcalidrawAPIProvider,
-  useExcalidrawAPI,
 } from "@excalidraw/excalidraw";
 import { trackEvent } from "@excalidraw/excalidraw/analytics";
 import { getDefaultAppState } from "@excalidraw/excalidraw/appState";
@@ -22,6 +19,8 @@ import Trans from "@excalidraw/excalidraw/components/Trans";
 import {
  APP_NAME,
  EVENT,
+  THEME,
+  TITLE_TIMEOUT,
  VERSION_TIMEOUT,
  debounce,
  getVersion,
@@ -35,6 +34,7 @@ import {
 import polyfill from "@excalidraw/excalidraw/polyfill";
 import { useCallback, useEffect, useRef, useState } from "react";
 import { loadFromBlob } from "@excalidraw/excalidraw/data/blob";
+import { useCallbackRefState } from "@excalidraw/excalidraw/hooks/useCallbackRefState";
 import { t } from "@excalidraw/excalidraw/i18n";

 import {
@@ -48,11 +48,7 @@ import {
  youtubeIcon,
 } from "@excalidraw/excalidraw/components/icons";
 import { isElementLink } from "@excalidraw/element";
-import {
-  bumpElementVersions,
-  restoreAppState,
-  restoreElements,
-} from "@excalidraw/excalidraw/data/restore";
+import { restore, restoreAppState } from "@excalidraw/excalidraw/data/restore";
 import { newElementWith } from "@excalidraw/element";
 import { isInitializedImageElement } from "@excalidraw/element";
 import clsx from "clsx";
@@ -74,7 +70,6 @@ import type {
  BinaryFiles,
  ExcalidrawInitialDataState,
  UIAppState,
-  ExcalidrawProps,
 } from "@excalidraw/excalidraw/types";
 import type { ResolutionType } from "@excalidraw/common/utility-types";
 import type { ResolvablePromise } from "@excalidraw/common/utils";
@@ -110,12 +105,11 @@ import { TopErrorBoundary } from "./components/TopErrorBoundary";
 import {
  exportToBackend,
  getCollaborationLinkData,
-  importFromBackend,
  isCollaborationLink,
+  loadScene,
 } from "./data";

 import { updateStaleImageStatuses } from "./data/FileManager";
-import { FileStatusStore } from "./data/fileStatusStore";
 import {
  importFromLocalStorage,
  importUsernameFromLocalStorage,
@@ -126,7 +120,6 @@ import {
  LibraryIndexedDBAdapter,
  LibraryLocalStorageMigrationAdapter,
  LocalData,
-  localStorageQuotaExceededAtom,
 } from "./data/LocalData";
 import { isBrowserStorageStateNewer } from "./data/tabSync";
 import { ShareDialog, shareDialogStateAtom } from "./share/ShareDialog";
@@ -144,9 +137,6 @@ import { ExcalidrawPlusIframeExport } from "./ExcalidrawPlusIframeExport";

 import "./index.scss";

-import { ExcalidrawPlusPromoBanner } from "./components/ExcalidrawPlusPromoBanner";
-import { AppSidebar } from "./components/AppSidebar";
-
 import type { CollabAPI } from "./collab/Collab";

 polyfill();
@@ -230,20 +220,9 @@ const initializeScene = async (opts: {

  const localDataState = importFromLocalStorage();

-  let scene: Omit<
-    RestoredDataState,
-    // we're not storing files in the scene database/localStorage, and instead
-    // fetch them async from a different store
-    "files"
-  > & {
+  let scene: RestoredDataState & {
    scrollToContent?: boolean;
-  } = {
-    elements: restoreElements(localDataState?.elements, null, {
-      repairBindings: true,
-      deleteInvisibleElements: true,
-    }),
-    appState: restoreAppState(localDataState?.appState, null),
-  };
+  } = await loadScene(null, null, localDataState);

  let roomLinkData = getCollaborationLinkData(window.location.href);
  const isExternalScene = !!(id || jsonBackendMatch || roomLinkData);
@@ -257,26 +236,11 @@ const initializeScene = async (opts: {
      (await openConfirmModal(shareableLinkConfirmDialog))
    ) {
      if (jsonBackendMatch) {
-        const imported = await importFromBackend(
+        scene = await loadScene(
          jsonBackendMatch[1],
          jsonBackendMatch[2],
+          localDataState,
        );
-
-        scene = {
-          elements: bumpElementVersions(
-            restoreElements(imported.elements, null, {
-              repairBindings: true,
-              deleteInvisibleElements: true,
-            }),
-            localDataState?.elements,
-          ),
-          appState: restoreAppState(
-            imported.appState,
-            // local appState when importing from backend to ensure we restore
-            // localStorage user settings which we do not persist on server.
-            localDataState?.appState,
-          ),
-        };
      }
      scene.scrollToContent = true;
      if (!roomLinkData) {
@@ -371,8 +335,6 @@ const initializeScene = async (opts: {
 };

 const ExcalidrawWrapper = () => {
-  const excalidrawAPI = useExcalidrawAPI();
-
  const [errorMessage, setErrorMessage] = useState("");
  const isCollabDisabled = isRunningInIframe();

@@ -380,8 +342,6 @@ const ExcalidrawWrapper = () => {

  const [langCode, setLangCode] = useAppLangCode();

-  const editorInterface = useEditorInterface();
-
  // initial state
  // ---------------------------------------------------------------------------

@@ -403,6 +363,9 @@ const ExcalidrawWrapper = () => {
    }, VERSION_TIMEOUT);
  }, []);

+  const [excalidrawAPI, excalidrawRefCallback] =
+    useCallbackRefState<ExcalidrawImperativeAPI>();
+
  const [, setShareDialogState] = useAtom(shareDialogStateAtom);
  const [collabAPI] = useAtom(collabAPIAtom);
  const [isCollaborating] = useAtomWithInitialValue(isCollaboratingAtom, () => {
@@ -434,15 +397,18 @@ const ExcalidrawWrapper = () => {
    }
  }, [excalidrawAPI]);

-  // ---------------------------------------------------------------------------
-  // Hoisted loadImages
-  // ---------------------------------------------------------------------------
-  const loadImages = useCallback(
-    (data: ResolutionType<typeof initializeScene>, isInitialLoad = false) => {
-      if (!data.scene || !excalidrawAPI) {
+  useEffect(() => {
+    if (!excalidrawAPI || (!isCollabDisabled && !collabAPI)) {
+      return;
+    }
+
+    const loadImages = (
+      data: ResolutionType<typeof initializeScene>,
+      isInitialLoad = false,
+    ) => {
+      if (!data.scene) {
        return;
      }
-
      if (collabAPI?.isCollaborating()) {
        if (data.scene.elements) {
          collabAPI
@@ -469,12 +435,6 @@ const ExcalidrawWrapper = () => {
          }, [] as FileId[]) || [];

        if (data.isExternalScene) {
-          if (fileIds.length) {
-            // Direct Firebase call (not through FileManager), so track manually
-            FileStatusStore.updateStatuses(
-              fileIds.map((id) => [id, "loading"]),
-            );
-          }
          loadFilesFromFirebase(
            `${FIREBASE_STORAGE_PREFIXES.shareLinkFiles}/${data.id}`,
            data.key,
@@ -486,18 +446,12 @@ const ExcalidrawWrapper = () => {
              erroredFiles,
              elements: excalidrawAPI.getSceneElementsIncludingDeleted(),
            });
-            FileStatusStore.updateStatuses([
-              ...loadedFiles.map((f) => [f.id, "loaded"] as [FileId, "loaded"]),
-              ...[...erroredFiles.keys()].map(
-                (id) => [id, "error"] as [FileId, "error"],
-              ),
-            ]);
          });
        } else if (isInitialLoad) {
          if (fileIds.length) {
            LocalData.fileStorage
              .getFiles(fileIds)
-              .then(async ({ loadedFiles, erroredFiles }) => {
+              .then(({ loadedFiles, erroredFiles }) => {
                if (loadedFiles.length) {
                  excalidrawAPI.addFiles(loadedFiles);
                }
@@ -510,19 +464,10 @@ const ExcalidrawWrapper = () => {
          }
          // on fresh load, clear unused files from IDB (from previous
          // session)
-          LocalData.fileStorage.clearObsoleteFiles({
-            currentFileIds: fileIds,
-          });
+          LocalData.fileStorage.clearObsoleteFiles({ currentFileIds: fileIds });
        }
      }
-    },
-    [collabAPI, excalidrawAPI],
-  );
-
-  useEffect(() => {
-    if (!excalidrawAPI || (!isCollabDisabled && !collabAPI)) {
-      return;
-    }
+    };

    initializeScene({ collabAPI, excalidrawAPI }).then(async (data) => {
      loadImages(data, /* isInitialLoad */ true);
@@ -545,10 +490,8 @@ const ExcalidrawWrapper = () => {
          loadImages(data);
          if (data.scene) {
            excalidrawAPI.updateScene({
-              elements: restoreElements(data.scene.elements, null, {
-                repairBindings: true,
-              }),
-              appState: restoreAppState(data.scene.appState, null),
+              ...data.scene,
+              ...restore(data.scene, null, null, { repairBindings: true }),
              captureUpdate: CaptureUpdateAction.IMMEDIATELY,
            });
          }
@@ -556,6 +499,11 @@ const ExcalidrawWrapper = () => {
      }
    };

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

  useEffect(() => {
    const unloadHandler = (event: BeforeUnloadEvent) => {
@@ -720,8 +669,8 @@ const ExcalidrawWrapper = () => {
      debugRenderer(
        debugCanvasRef.current,
        appState,
-        elements,
        window.devicePixelRatio,
+        () => forceRefresh((prev) => !prev),
      );
    }
  };
@@ -785,63 +734,11 @@ const ExcalidrawWrapper = () => {

  const isOffline = useAtomValue(isOfflineAtom);

-  const localStorageQuotaExceeded = useAtomValue(localStorageQuotaExceededAtom);
-
  const onCollabDialogOpen = useCallback(
    () => setShareDialogState({ isOpen: true, type: "collaborationOnly" }),
    [setShareDialogState],
  );

-  // ---------------------------------------------------------------------------
-  // onExport — intercepts file save to wait for pending image loads
-  // ---------------------------------------------------------------------------
-  const onExport: Required<ExcalidrawProps>["onExport"] = useCallback(
-    async function* () {
-      let snapshot = FileStatusStore.getSnapshot();
-      const { pending, total } = FileStatusStore.getPendingCount(
-        snapshot.value,
-      );
-      if (pending === 0) {
-        return;
-      }
-
-      // Yield initial progress
-      yield {
-        type: "progress",
-        progress: (total - pending) / total,
-        message: `Loading images (${total - pending}/${total})...`,
-      };
-
-      // Wait for all pending images to finish
-      while (true) {
-        snapshot = await FileStatusStore.pull(snapshot.version);
-        const { pending: nowPending, total: nowTotal } =
-          FileStatusStore.getPendingCount(snapshot.value);
-
-        yield {
-          type: "progress",
-          progress: (nowTotal - nowPending) / nowTotal,
-          message: `Loading images (${nowTotal - nowPending}/${nowTotal})...`,
-        };
-
-        if (nowPending === 0) {
-          await new Promise((r) => setTimeout(r, 500));
-          yield {
-            type: "progress",
-            message: `Preparing export...`,
-          };
-          return;
-        }
-      }
-    },
-    [],
-  );
-
-  // const onExport = () => {
-  //   return new Promise((r) => setTimeout(r, 2500));
-  //   // console.log("onExport");
-  // };
-
  // browsers generally prevent infinite self-embedding, there are
  // cases where it still happens, and while we disallow self-embedding
  // by not whitelisting our own origin, this serves as an additional guard
@@ -908,8 +805,8 @@ const ExcalidrawWrapper = () => {
      })}
    >
      <Excalidraw
+        excalidrawAPI={excalidrawRefCallback}
        onChange={onChange}
-        onExport={onExport}
        initialData={initialStatePromiseRef.current.promise}
        isCollaborating={isCollaborating}
        onPointerUpdate={collabAPI?.onPointerUpdate}
@@ -951,27 +848,18 @@ const ExcalidrawWrapper = () => {
        handleKeyboardGlobally={true}
        autoFocus={true}
        theme={editorTheme}
-        onThemeChange={setAppTheme}
        renderTopRightUI={(isMobile) => {
          if (isMobile || !collabAPI || isCollabDisabled) {
            return null;
          }
-
          return (
-            <div className="excalidraw-ui-top-right">
-              {excalidrawAPI?.getEditorInterface().formFactor === "desktop" && (
-                <ExcalidrawPlusPromoBanner
-                  isSignedIn={isExcalidrawPlusSignedUser}
-                />
-              )}
-
+            <div className="top-right-ui">
              {collabError.message && <CollabError collabError={collabError} />}
              <LiveCollaborationTrigger
                isCollaborating={isCollaborating}
                onSelect={() =>
                  setShareDialogState({ isOpen: true, type: "share" })
                }
-                editorInterface={editorInterface}
              />
            </div>
          );
@@ -988,6 +876,7 @@ const ExcalidrawWrapper = () => {
          isCollaborating={isCollaborating}
          isCollabEnabled={!isCollabDisabled}
          theme={appTheme}
+          setTheme={(theme) => setAppTheme(theme)}
          refresh={() => forceRefresh((prev) => !prev)}
        />
        <AppWelcomeScreen
@@ -1019,15 +908,10 @@ const ExcalidrawWrapper = () => {

        <TTDDialogTrigger />
        {isCollaborating && isOffline && (
-          <div className="alertalert--warning">
+          <div className="collab-offline-warning">
            {t("alerts.collabOfflineWarning")}
          </div>
        )}
-        {localStorageQuotaExceeded && (
-          <div className="alert alert--danger">
-            {t("alerts.localStorageQuotaExceeded")}
-          </div>
-        )}
        {latestShareableLink && (
          <ShareableLinkDialog
            link={latestShareableLink}
@@ -1056,8 +940,6 @@ const ExcalidrawWrapper = () => {
          }}
        />

-        <AppSidebar />
-
        {errorMessage && (
          <ErrorDialog onClose={() => setErrorMessage("")}>
            {errorMessage}
@@ -1228,6 +1110,14 @@ const ExcalidrawWrapper = () => {
                }
              },
            },
+            {
+              ...CommandPalette.defaultItems.toggleTheme,
+              perform: () => {
+                setAppTheme(
+                  editorTheme === THEME.DARK ? THEME.LIGHT : THEME.DARK,
+                );
+              },
+            },
            {
              label: t("labels.installPWA"),
              category: DEFAULT_CATEGORIES.app,
@@ -1267,9 +1157,7 @@ const ExcalidrawApp = () => {
  return (
    <TopErrorBoundary>
      <Provider store={appJotaiStore}>
-        <ExcalidrawAPIProvider>
-          <ExcalidrawWrapper />
-        </ExcalidrawAPIProvider>
+        <ExcalidrawWrapper />
      </Provider>
    </TopErrorBoundary>
  );
@@ -8,8 +8,7 @@ export const SYNC_BROWSER_TABS_TIMEOUT = 50;
 export const CURSOR_SYNC_TIMEOUT = 33; // ~30fps
 export const DELETED_ELEMENT_TIMEOUT = 24 * 60 * 60 * 1000; // 1 day

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

@@ -46,7 +45,6 @@ export const STORAGE_KEYS = {
  VERSION_FILES: "version-files",

  IDB_LIBRARY: "excalidraw-library",
-  IDB_TTD_CHATS: "excalidraw-ttd-chats",

  // do not use apart from migrations
  __LEGACY_LOCAL_STORAGE_LIBRARY: "excalidraw-library",
@@ -6,7 +6,7 @@ import {
  reconcileElements,
 } from "@excalidraw/excalidraw";
 import { ErrorDialog } from "@excalidraw/excalidraw/components/ErrorDialog";
-import { APP_NAME, cloneJSON, EVENT, toBrandedType } from "@excalidraw/common";
+import { APP_NAME, EVENT } from "@excalidraw/common";
 import {
  IDLE_THRESHOLD,
  ACTIVE_THRESHOLD,
@@ -29,8 +29,6 @@ import { withBatchedUpdates } from "@excalidraw/excalidraw/reactUtils";
 import throttle from "lodash.throttle";
 import { PureComponent } from "react";

-import { bumpElementVersions } from "@excalidraw/excalidraw/data/restore";
-
 import type {
  ReconciledExcalidrawElement,
  RemoteExcalidrawElement,
@@ -72,7 +70,6 @@ import {
  FileManager,
  updateStaleImageStatuses,
 } from "../data/FileManager";
-import { FileStatusStore } from "../data/fileStatusStore";
 import { LocalData } from "../data/LocalData";
 import {
  isSavedToFirebase,
@@ -150,7 +147,6 @@ class Collab extends PureComponent<CollabProps, CollabState> {
    };
    this.portal = new Portal(this);
    this.fileManager = new FileManager({
-      onFileStatusChange: FileStatusStore.updateStatuses.bind(FileStatusStore),
      getFiles: async (fileIds) => {
        const { roomId, roomKey } = this.portal;
        if (!roomId || !roomKey) {
@@ -315,7 +311,6 @@ class Collab extends PureComponent<CollabProps, CollabState> {
  saveCollabRoomToFirebase = async (
    syncableElements: readonly SyncableExcalidrawElement[],
  ) => {
-    syncableElements = cloneJSON(syncableElements);
    try {
      const storedElements = await saveToFirebase(
        this.portal,
@@ -446,7 +441,7 @@ class Collab extends PureComponent<CollabProps, CollabState> {
  };

  private decryptPayload = async (
-    iv: Uint8Array<ArrayBuffer>,
+    iv: Uint8Array,
    encryptedData: ArrayBuffer,
    decryptionKey: string,
  ): Promise<ValueOf<SocketUpdateDataSource>> => {
@@ -535,10 +530,7 @@ class Collab extends PureComponent<CollabProps, CollabState> {
      return null;
    }

-    if (existingRoomLinkData) {
-      // when joining existing room, don't merge it with current scene data
-      this.excalidrawAPI.resetScene();
-    } else {
+    if (!existingRoomLinkData) {
      const elements = this.excalidrawAPI.getSceneElements().map((element) => {
        if (isImageElement(element) && element.status === "saved") {
          return newElementWith(element, { status: "pending" });
@@ -567,7 +559,7 @@ class Collab extends PureComponent<CollabProps, CollabState> {
    // All socket listeners are moving to Portal
    this.portal.socket.on(
      "client-broadcast",
-      async (encryptedData: ArrayBuffer, iv: Uint8Array<ArrayBuffer>) => {
+      async (encryptedData: ArrayBuffer, iv: Uint8Array) => {
        if (!this.portal.roomKey) {
          return;
        }
@@ -584,9 +576,7 @@ class Collab extends PureComponent<CollabProps, CollabState> {
          case WS_SUBTYPES.INIT: {
            if (!this.portal.socketInitialized) {
              this.initializeRoom({ fetchScene: false });
-              const remoteElements = toBrandedType<
-                readonly RemoteExcalidrawElement[]
-              >(decryptedData.payload.elements);
+              const remoteElements = decryptedData.payload.elements;
              const reconciledElements =
                this._reconcileElements(remoteElements);
              this.handleRemoteSceneUpdate(reconciledElements);
@@ -600,11 +590,7 @@ class Collab extends PureComponent<CollabProps, CollabState> {
          }
          case WS_SUBTYPES.UPDATE:
            this.handleRemoteSceneUpdate(
-              this._reconcileElements(
-                toBrandedType<readonly RemoteExcalidrawElement[]>(
-                  decryptedData.payload.elements,
-                ),
-              ),
+              this._reconcileElements(decryptedData.payload.elements),
            );
            break;
          case WS_SUBTYPES.MOUSE_LOCATION: {
@@ -753,28 +739,17 @@ class Collab extends PureComponent<CollabProps, CollabState> {
  };

  private _reconcileElements = (
-    remoteElements: readonly RemoteExcalidrawElement[],
+    remoteElements: readonly ExcalidrawElement[],
  ): ReconciledExcalidrawElement[] => {
+    const localElements = this.getSceneElementsIncludingDeleted();
    const appState = this.excalidrawAPI.getAppState();
-
-    const existingElements = this.getSceneElementsIncludingDeleted();
-
-    // NOTE ideally we restore _after_ reconciliation but we can't do that
-    // as we'd regenerate even elements such as appState.newElement which would
-    // break the state
-    remoteElements = restoreElements(remoteElements, existingElements);
-
-    let reconciledElements = reconcileElements(
-      existingElements,
-      remoteElements,
+    const restoredRemoteElements = restoreElements(remoteElements, null);
+    const reconciledElements = reconcileElements(
+      localElements,
+      restoredRemoteElements as RemoteExcalidrawElement[],
      appState,
    );

-    reconciledElements = bumpElementVersions(
-      reconciledElements,
-      existingElements,
-    );
-
    // Avoid broadcasting to the rest of the collaborators the scene
    // we just received!
    // Note: this needs to be set before updating the scene as it
@@ -4,15 +4,12 @@ import {
  getTextFromElements,
  MIME_TYPES,
  TTDDialog,
-  TTDStreamFetch,
 } from "@excalidraw/excalidraw";
 import { getDataURL } from "@excalidraw/excalidraw/data/blob";
 import { safelyParseJSON } from "@excalidraw/common";

 import type { ExcalidrawImperativeAPI } from "@excalidraw/excalidraw/types";

-import { TTDIndexedDBAdapter } from "../data/TTDStorage";
-
 export const AIComponents = ({
  excalidrawAPI,
 }: {
@@ -102,23 +99,61 @@ export const AIComponents = ({
      />

      <TTDDialog
-        onTextSubmit={async (props) => {
-          const { onChunk, onStreamCreated, signal, messages } = props;
+        onTextSubmit={async (input) => {
+          try {
+            const response = await fetch(
+              `${
+                import.meta.env.VITE_APP_AI_BACKEND
+              }/v1/ai/text-to-diagram/generate`,
+              {
+                method: "POST",
+                headers: {
+                  Accept: "application/json",
+                  "Content-Type": "application/json",
+                },
+                body: JSON.stringify({ prompt: input }),
+              },
+            );

-          const result = await TTDStreamFetch({
-            url: `${
-              import.meta.env.VITE_APP_AI_BACKEND
-            }/v1/ai/text-to-diagram/chat-streaming`,
-            messages,
-            onChunk,
-            onStreamCreated,
-            extractRateLimits: true,
-            signal,
-          });
+            const rateLimit = response.headers.has("X-Ratelimit-Limit")
+              ? parseInt(response.headers.get("X-Ratelimit-Limit") || "0", 10)
+              : undefined;

-          return result;
+            const rateLimitRemaining = response.headers.has(
+              "X-Ratelimit-Remaining",
+            )
+              ? parseInt(
+                  response.headers.get("X-Ratelimit-Remaining") || "0",
+                  10,
+                )
+              : undefined;
+
+            const json = await response.json();
+
+            if (!response.ok) {
+              if (response.status === 429) {
+                return {
+                  rateLimit,
+                  rateLimitRemaining,
+                  error: new Error(
+                    "Too many requests today, please try again tomorrow!",
+                  ),
+                };
+              }
+
+              throw new Error(json.message || "Generation failed...");
+            }
+
+            const generatedResponse = json.generatedResponse;
+            if (!generatedResponse) {
+              throw new Error("Generation failed...");
+            }
+
+            return { generatedResponse, rateLimit, rateLimitRemaining };
+          } catch (err: any) {
+            throw new Error("Request failed");
+          }
        }}
-        persistenceAdapter={TTDIndexedDBAdapter}
      />
    </>
  );
@@ -5,6 +5,7 @@ import { isExcalidrawPlusSignedUser } from "../app_constants";

 import { DebugFooter, isVisualDebuggerEnabled } from "./DebugCanvas";
 import { EncryptedIcon } from "./EncryptedIcon";
+import { ExcalidrawPlusAppLink } from "./ExcalidrawPlusAppLink";

 export const AppFooter = React.memo(
  ({ onChange }: { onChange: () => void }) => {
@@ -18,7 +19,11 @@ export const AppFooter = React.memo(
          }}
        >
          {isVisualDebuggerEnabled() && <DebugFooter onChange={onChange} />}
-          {!isExcalidrawPlusSignedUser && <EncryptedIcon />}
+          {isExcalidrawPlusSignedUser ? (
+            <ExcalidrawPlusAppLink />
+          ) : (
+            <EncryptedIcon />
+          )}
        </div>
      </Footer>
    );
@@ -20,6 +20,7 @@ export const AppMainMenu: React.FC<{
  isCollaborating: boolean;
  isCollabEnabled: boolean;
  theme: Theme | "system";
+  setTheme: (theme: Theme | "system") => void;
  refresh: () => void;
 }> = React.memo((props) => {
  return (
@@ -61,7 +62,7 @@ export const AppMainMenu: React.FC<{
      {isDevEnv() && (
        <MainMenu.Item
          icon={eyeIcon}
-          onSelect={() => {
+          onClick={() => {
            if (window.visualDebug) {
              delete window.visualDebug;
              saveDebugState({ enabled: false });
@@ -76,8 +77,11 @@ export const AppMainMenu: React.FC<{
        </MainMenu.Item>
      )}
      <MainMenu.Separator />
-      <MainMenu.DefaultItems.Preferences />
-      <MainMenu.DefaultItems.ToggleTheme allowSystemTheme theme={props.theme} />
+      <MainMenu.DefaultItems.ToggleTheme
+        allowSystemTheme
+        theme={props.theme}
+        onSelect={props.setTheme}
+      />
      <MainMenu.ItemCustom>
        <LanguageList style={{ width: "100%" }} />
      </MainMenu.ItemCustom>
@@ -1,36 +0,0 @@
-.excalidraw {
-  .app-sidebar-promo-container {
-    padding: 0.75rem;
-    display: flex;
-    flex-direction: column;
-    text-align: center;
-    gap: 1rem;
-    flex: 1 1 auto;
-  }
-
-  .app-sidebar-promo-image {
-    margin: 1rem 0;
-
-    height: 16.25rem;
-    background-size: contain;
-    background-position: center;
-    background-repeat: no-repeat;
-
-    background-image: radial-gradient(
-        circle,
-        transparent 60%,
-        var(--sidebar-bg-color) 100%
-      ),
-      var(--image-source);
-
-    display: flex;
-  }
-
-  .app-sidebar-promo-text {
-    padding: 0 2rem;
-  }
-
-  .link-button {
-    margin: 0 auto;
-  }
-}
@@ -1,79 +0,0 @@
-import { DefaultSidebar, Sidebar, THEME } from "@excalidraw/excalidraw";
-import {
-  messageCircleIcon,
-  presentationIcon,
-} from "@excalidraw/excalidraw/components/icons";
-import { LinkButton } from "@excalidraw/excalidraw/components/LinkButton";
-import { useUIAppState } from "@excalidraw/excalidraw/context/ui-appState";
-
-import "./AppSidebar.scss";
-
-export const AppSidebar = () => {
-  const { theme, openSidebar } = useUIAppState();
-
-  return (
-    <DefaultSidebar>
-      <DefaultSidebar.TabTriggers>
-        <Sidebar.TabTrigger
-          tab="comments"
-          style={{ opacity: openSidebar?.tab === "comments" ? 1 : 0.4 }}
-        >
-          {messageCircleIcon}
-        </Sidebar.TabTrigger>
-        <Sidebar.TabTrigger
-          tab="presentation"
-          style={{ opacity: openSidebar?.tab === "presentation" ? 1 : 0.4 }}
-        >
-          {presentationIcon}
-        </Sidebar.TabTrigger>
-      </DefaultSidebar.TabTriggers>
-      <Sidebar.Tab tab="comments">
-        <div className="app-sidebar-promo-container">
-          <div
-            className="app-sidebar-promo-image"
-            style={{
-              ["--image-source" as any]: `url(/oss_promo_comments_${
-                theme === THEME.DARK ? "dark" : "light"
-              }.jpg)`,
-              opacity: 0.7,
-            }}
-          />
-          <div className="app-sidebar-promo-text">
-            Make comments with Excalidraw+
-          </div>
-          <LinkButton
-            href={`${
-              import.meta.env.VITE_APP_PLUS_LP
-            }/plus?utm_source=excalidraw&utm_medium=app&utm_content=comments_promo#excalidraw-redirect`}
-          >
-            Sign up now
-          </LinkButton>
-        </div>
-      </Sidebar.Tab>
-      <Sidebar.Tab tab="presentation" className="px-3">
-        <div className="app-sidebar-promo-container">
-          <div
-            className="app-sidebar-promo-image"
-            style={{
-              ["--image-source" as any]: `url(/oss_promo_presentations_${
-                theme === THEME.DARK ? "dark" : "light"
-              }.svg)`,
-              backgroundSize: "60%",
-              opacity: 0.4,
-            }}
-          />
-          <div className="app-sidebar-promo-text">
-            Create presentations with Excalidraw+
-          </div>
-          <LinkButton
-            href={`${
-              import.meta.env.VITE_APP_PLUS_LP
-            }/plus?utm_source=excalidraw&utm_medium=app&utm_content=presentations_promo#excalidraw-redirect`}
-          >
-            Sign up now
-          </LinkButton>
-        </div>
-      </Sidebar.Tab>
-    </DefaultSidebar>
-  );
-};
@@ -33,15 +33,7 @@ export const AppWelcomeScreen: React.FC<{
        return bit;
      });
  } else {
-    headingContent = (
-      <>
-        {t("welcomeScreen.app.center_heading")}
-        <br />
-        {t("welcomeScreen.app.center_heading_line2")}
-        <br />
-        {t("welcomeScreen.app.center_heading_line3")}
-      </>
-    );
+    headingContent = t("welcomeScreen.app.center_heading");
  }

  return (
@@ -8,15 +8,9 @@ import {
  getNormalizedCanvasDimensions,
 } from "@excalidraw/excalidraw/renderer/helpers";
 import { type AppState } from "@excalidraw/excalidraw/types";
-import { arrayToMap, throttleRAF } from "@excalidraw/common";
+import { throttleRAF } from "@excalidraw/common";
 import { useCallback } from "react";

-import {
-  getGlobalFixedPointForBindableElement,
-  isArrowElement,
-  isBindableElement,
-} from "@excalidraw/element";
-
 import {
  isLineSegment,
  type GlobalPoint,
@@ -27,17 +21,8 @@ import { isCurve } from "@excalidraw/math/curve";
 import React from "react";

 import type { Curve } from "@excalidraw/math";
-import type {
-  DebugElement,
-  DebugPolygon,
-} from "@excalidraw/element/visualdebug";
-import type {
-  ElementsMap,
-  ExcalidrawArrowElement,
-  ExcalidrawBindableElement,
-  FixedPointBinding,
-  OrderedExcalidrawElement,
-} from "@excalidraw/element/types";
+
+import type { DebugElement } from "@excalidraw/utils/visualdebug";

 import { STORAGE_KEYS } from "../app_constants";

@@ -78,44 +63,6 @@ const renderCubicBezier = (
  context.restore();
 };

-const renderPolygon = (
-  context: CanvasRenderingContext2D,
-  zoom: number,
-  polygon: DebugPolygon,
-  color: string,
-) => {
-  const { points, fill, close } = polygon;
-
-  if (points.length < 2) {
-    return;
-  }
-
-  context.save();
-  context.beginPath();
-  context.moveTo(points[0][0] * zoom, points[0][1] * zoom);
-  for (let i = 1; i < points.length; i += 1) {
-    context.lineTo(points[i][0] * zoom, points[i][1] * zoom);
-  }
-  if (close !== false) {
-    context.closePath();
-  }
-
-  if (fill) {
-    context.save();
-    context.globalAlpha = 0.15;
-    context.fillStyle = color;
-    context.fill();
-    context.restore();
-  }
-
-  context.strokeStyle = color;
-  context.stroke();
-  context.restore();
-};
-
-const isDebugPolygon = (data: DebugElement["data"]): data is DebugPolygon =>
-  (data as DebugPolygon).type === "polygon";
-
 const renderOrigin = (context: CanvasRenderingContext2D, zoom: number) => {
  context.strokeStyle = "#888";
  context.save();
@@ -128,176 +75,6 @@ const renderOrigin = (context: CanvasRenderingContext2D, zoom: number) => {
  context.save();
 };

-const _renderBinding = (
-  context: CanvasRenderingContext2D,
-  binding: FixedPointBinding,
-  elementsMap: ElementsMap,
-  zoom: number,
-  width: number,
-  height: number,
-  color: string,
-) => {
-  if (!binding.fixedPoint) {
-    console.warn("Binding must have a fixedPoint");
-    return;
-  }
-
-  const bindable = elementsMap.get(
-    binding.elementId,
-  ) as ExcalidrawBindableElement;
-  const [x, y] = getGlobalFixedPointForBindableElement(
-    binding.fixedPoint,
-    bindable,
-    elementsMap,
-  );
-
-  context.save();
-  context.strokeStyle = color;
-  context.lineWidth = 1;
-  context.beginPath();
-  context.moveTo(x * zoom, y * zoom);
-  context.bezierCurveTo(
-    x * zoom - width,
-    y * zoom - height,
-    x * zoom - width,
-    y * zoom + height,
-    x * zoom,
-    y * zoom,
-  );
-  context.stroke();
-  context.restore();
-};
-
-const _renderBindableBinding = (
-  binding: FixedPointBinding,
-  context: CanvasRenderingContext2D,
-  elementsMap: ElementsMap,
-  zoom: number,
-  width: number,
-  height: number,
-  color: string,
-) => {
-  const bindable = elementsMap.get(
-    binding.elementId,
-  ) as ExcalidrawBindableElement;
-  if (!binding.fixedPoint) {
-    console.warn("Binding must have a fixedPoint");
-    return;
-  }
-
-  const [x, y] = getGlobalFixedPointForBindableElement(
-    binding.fixedPoint,
-    bindable,
-    elementsMap,
-  );
-
-  context.save();
-  context.strokeStyle = color;
-  context.lineWidth = 1;
-  context.beginPath();
-  context.moveTo(x * zoom, y * zoom);
-  context.bezierCurveTo(
-    x * zoom + width,
-    y * zoom + height,
-    x * zoom + width,
-    y * zoom - height,
-    x * zoom,
-    y * zoom,
-  );
-  context.stroke();
-  context.restore();
-};
-
-const renderBindings = (
-  context: CanvasRenderingContext2D,
-  elements: readonly OrderedExcalidrawElement[],
-  zoom: number,
-) => {
-  const elementsMap = arrayToMap(elements);
-  const dim = 16;
-  elements.forEach((element) => {
-    if (element.isDeleted) {
-      return;
-    }
-
-    if (isArrowElement(element)) {
-      if (element.startBinding) {
-        if (
-          !elementsMap
-            .get(element.startBinding.elementId)
-            ?.boundElements?.find((e) => e.id === element.id)
-        ) {
-          return;
-        }
-
-        _renderBinding(
-          context,
-          element.startBinding,
-          elementsMap,
-          zoom,
-          dim,
-          dim,
-          element.startBinding?.mode === "orbit" ? "red" : "black",
-        );
-      }
-
-      if (element.endBinding) {
-        if (
-          !elementsMap
-            .get(element.endBinding.elementId)
-            ?.boundElements?.find((e) => e.id === element.id)
-        ) {
-          return;
-        }
-        _renderBinding(
-          context,
-          element.endBinding,
-          elementsMap,
-          zoom,
-          dim,
-          dim,
-          element.endBinding?.mode === "orbit" ? "red" : "black",
-        );
-      }
-    }
-
-    if (isBindableElement(element) && element.boundElements?.length) {
-      element.boundElements.forEach((boundElement) => {
-        if (boundElement.type !== "arrow") {
-          return;
-        }
-
-        const arrow = elementsMap.get(
-          boundElement.id,
-        ) as ExcalidrawArrowElement;
-
-        if (arrow && arrow.startBinding?.elementId === element.id) {
-          _renderBindableBinding(
-            arrow.startBinding,
-            context,
-            elementsMap,
-            zoom,
-            dim,
-            dim,
-            "green",
-          );
-        }
-        if (arrow && arrow.endBinding?.elementId === element.id) {
-          _renderBindableBinding(
-            arrow.endBinding,
-            context,
-            elementsMap,
-            zoom,
-            dim,
-            dim,
-            "green",
-          );
-        }
-      });
-    }
-  });
-};
-
 const render = (
  frame: DebugElement[],
  context: CanvasRenderingContext2D,
@@ -321,9 +98,6 @@ const render = (
          el.color,
        );
        break;
-      case isDebugPolygon(el.data):
-        renderPolygon(context, appState.zoom.value, el.data, el.color);
-        break;
      default:
        throw new Error(`Unknown element type ${JSON.stringify(el)}`);
    }
@@ -333,8 +107,8 @@ const render = (
 const _debugRenderer = (
  canvas: HTMLCanvasElement,
  appState: AppState,
-  elements: readonly OrderedExcalidrawElement[],
  scale: number,
+  refresh: () => void,
 ) => {
  const [normalizedWidth, normalizedHeight] = getNormalizedCanvasDimensions(
    canvas,
@@ -357,7 +131,6 @@ const _debugRenderer = (
  );

  renderOrigin(context, appState.zoom.value);
-  renderBindings(context, elements, appState.zoom.value);

  if (
    window.visualDebug?.currentFrame &&
@@ -409,11 +182,12 @@ export const debugRenderer = throttleRAF(
  (
    canvas: HTMLCanvasElement,
    appState: AppState,
-    elements: readonly OrderedExcalidrawElement[],
    scale: number,
+    refresh: () => void,
  ) => {
-    _debugRenderer(canvas, appState, elements, scale);
+    _debugRenderer(canvas, appState, scale, refresh);
  },
+  { trailing: true },
 );

 export const loadSavedDebugState = () => {
@@ -0,0 +1,19 @@
+import { isExcalidrawPlusSignedUser } from "../app_constants";
+
+export const ExcalidrawPlusAppLink = () => {
+  if (!isExcalidrawPlusSignedUser) {
+    return null;
+  }
+  return (
+    <a
+      href={`${
+        import.meta.env.VITE_APP_PLUS_APP
+      }?utm_source=excalidraw&utm_medium=app&utm_content=signedInUserRedirectButton#excalidraw-redirect`}
+      target="_blank"
+      rel="noopener"
+      className="plus-button"
+    >
+      Go to Excalidraw+
+    </a>
+  );
+};
@@ -1,22 +0,0 @@
-export const ExcalidrawPlusPromoBanner = ({
-  isSignedIn,
-}: {
-  isSignedIn: boolean;
-}) => {
-  return (
-    <a
-      href={
-        isSignedIn
-          ? import.meta.env.VITE_APP_PLUS_APP
-          : `${
-              import.meta.env.VITE_APP_PLUS_LP
-            }/plus?utm_source=excalidraw&utm_medium=app&utm_content=guestBanner#excalidraw-redirect`
-      }
-      target="_blank"
-      rel="noopener"
-      className="plus-banner"
-    >
-      Excalidraw+
-    </a>
-  );
-};
@@ -0,0 +1,46 @@
+import { THEME } from "@excalidraw/common";
+import oc from "open-color";
+import React from "react";
+
+import type { Theme } from "@excalidraw/element/types";
+
+// https://github.com/tholman/github-corners
+export const GitHubCorner = React.memo(
+  ({ theme, dir }: { theme: Theme; dir: string }) => (
+    <svg
+      xmlns="http://www.w3.org/2000/svg"
+      width="40"
+      height="40"
+      viewBox="0 0 250 250"
+      className="rtl-mirror"
+      style={{
+        marginTop: "calc(var(--space-factor) * -1)",
+        [dir === "rtl" ? "marginLeft" : "marginRight"]:
+          "calc(var(--space-factor) * -1)",
+      }}
+    >
+      <a
+        href="https://github.com/excalidraw/excalidraw"
+        target="_blank"
+        rel="noopener noreferrer"
+        aria-label="GitHub repository"
+      >
+        <path
+          d="M0 0l115 115h15l12 27 108 108V0z"
+          fill={theme === THEME.LIGHT ? oc.gray[6] : oc.gray[7]}
+        />
+        <path
+          className="octo-arm"
+          d="M128 109c-15-9-9-19-9-19 3-7 2-11 2-11-1-7 3-2 3-2 4 5 2 11 2 11-3 10 5 15 9 16"
+          style={{ transformOrigin: "130px 106px" }}
+          fill={theme === THEME.LIGHT ? oc.white : "var(--default-bg-color)"}
+        />
+        <path
+          className="octo-body"
+          d="M115 115s4 2 5 0l14-14c3-2 6-3 8-3-8-11-15-24 2-41 5-5 10-7 16-7 1-2 3-7 12-11 0 0 5 3 7 16 4 2 8 5 12 9s7 8 9 12c14 3 17 7 17 7-4 8-9 11-11 11 0 6-2 11-7 16-16 16-30 10-41 2 0 3-1 7-5 11l-12 11c-1 1 1 5 1 5z"
+          fill={theme === THEME.LIGHT ? oc.white : "var(--default-bg-color)"}
+        />
+      </a>
+    </svg>
+  ),
+);
@@ -40,12 +40,10 @@ export class FileManager {

  private _getFiles;
  private _saveFiles;
-  private _onFileStatusChange;

  constructor({
    getFiles,
    saveFiles,
-    onFileStatusChange,
  }: {
    getFiles: (fileIds: FileId[]) => Promise<{
      loadedFiles: BinaryFileData[];
@@ -55,13 +53,9 @@ export class FileManager {
      savedFiles: Map<FileId, BinaryFileData>;
      erroredFiles: Map<FileId, BinaryFileData>;
    }>;
-    onFileStatusChange?: (
-      updates: Array<[FileId, "loading" | "loaded" | "error"]>,
-    ) => void;
  }) {
    this._getFiles = getFiles;
    this._saveFiles = saveFiles;
-    this._onFileStatusChange = onFileStatusChange;
  }

  /**
@@ -152,8 +146,6 @@ export class FileManager {
      this.fetchingFiles.set(id, true);
    }

-    this._onFileStatusChange?.(ids.map((id) => [id, "loading"]));
-
    try {
      const { loadedFiles, erroredFiles } = await this._getFiles(ids);

@@ -164,13 +156,6 @@ export class FileManager {
        this.erroredFiles_fetch.set(fileId, true);
      }

-      this._onFileStatusChange?.([
-        ...loadedFiles.map((f) => [f.id, "loaded"] as [FileId, "loaded"]),
-        ...[...erroredFiles.keys()].map(
-          (id) => [id, "error"] as [FileId, "error"],
-        ),
-      ]);
-
      return { loadedFiles, erroredFiles };
    } finally {
      for (const id of ids) {
@@ -210,13 +195,6 @@ export class FileManager {
  };

  reset() {
-    if (this._onFileStatusChange && this.fetchingFiles.size) {
-      this._onFileStatusChange(
-        [...this.fetchingFiles.keys()].map(
-          (id) => [id, "error"] as [FileId, "error"],
-        ),
-      );
-    }
    this.fetchingFiles.clear();
    this.savingFiles.clear();
    this.savedFiles.clear();
@@ -16,6 +16,7 @@ import {
  DEFAULT_SIDEBAR,
  debounce,
 } from "@excalidraw/common";
+import { clearElementsForLocalStorage } from "@excalidraw/element";
 import {
  createStore,
  entries,
@@ -26,8 +27,6 @@ import {
  get,
 } from "idb-keyval";

-import { getNonDeletedElements } from "@excalidraw/element";
-
 import type { LibraryPersistedData } from "@excalidraw/excalidraw/data/library";
 import type { ImportedDataState } from "@excalidraw/excalidraw/data/types";
 import type { ExcalidrawElement, FileId } from "@excalidraw/element/types";
@@ -38,18 +37,14 @@ 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";
-import { FileStatusStore } from "./fileStatusStore";
 import { Locker } from "./Locker";
 import { updateBrowserStateVersion } from "./tabSync";

 const filesStore = createStore("files-db", "files-store");

-export const localStorageQuotaExceededAtom = atom(false);
-
 class LocalFileManager extends FileManager {
  clearObsoleteFiles = async (opts: { currentFileIds: FileId[] }) => {
    await entries(filesStore).then((entries) => {
@@ -74,9 +69,6 @@ const saveDataStateToLocalStorage = (
  elements: readonly ExcalidrawElement[],
  appState: AppState,
 ) => {
-  const localStorageQuotaExceeded = appJotaiStore.get(
-    localStorageQuotaExceededAtom,
-  );
  try {
    const _appState = clearAppStateForLocalStorage(appState);

@@ -89,29 +81,19 @@ const saveDataStateToLocalStorage = (

    localStorage.setItem(
      STORAGE_KEYS.LOCAL_STORAGE_ELEMENTS,
-      JSON.stringify(getNonDeletedElements(elements)),
+      JSON.stringify(clearElementsForLocalStorage(elements)),
    );
    localStorage.setItem(
      STORAGE_KEYS.LOCAL_STORAGE_APP_STATE,
      JSON.stringify(_appState),
    );
    updateBrowserStateVersion(STORAGE_KEYS.VERSION_DATA_STATE);
-    if (localStorageQuotaExceeded) {
-      appJotaiStore.set(localStorageQuotaExceededAtom, false);
-    }
  } catch (error: any) {
    // Unable to access window.localStorage
    console.error(error);
-    if (isQuotaExceededError(error) && !localStorageQuotaExceeded) {
-      appJotaiStore.set(localStorageQuotaExceededAtom, true);
-    }
  }
 };

-const isQuotaExceededError = (error: any) => {
-  return error instanceof DOMException && error.name === "QuotaExceededError";
-};
-
 type SavingLockTypes = "collaboration";

 export class LocalData {
@@ -167,7 +149,6 @@ export class LocalData {
  // ---------------------------------------------------------------------------

  static fileStorage = new LocalFileManager({
-    onFileStatusChange: FileStatusStore.updateStatuses.bind(FileStatusStore),
    getFiles(ids) {
      return getMany(ids, filesStore).then(
        async (filesData: (BinaryFileData | undefined)[]) => {
@@ -1,51 +0,0 @@
-import { createStore, get, set } from "idb-keyval";
-
-import type { SavedChats } from "@excalidraw/excalidraw/components/TTDDialog/types";
-
-import { STORAGE_KEYS } from "../app_constants";
-
-/**
- * IndexedDB adapter for TTD chat storage.
- * Implements TTDPersistenceAdapter interface.
- */
-export class TTDIndexedDBAdapter {
-  /** IndexedDB database name */
-  private static idb_name = STORAGE_KEYS.IDB_TTD_CHATS;
-  /** Store key for chat data */
-  private static key = "ttdChats";
-
-  private static store = createStore(
-    `${TTDIndexedDBAdapter.idb_name}-db`,
-    `${TTDIndexedDBAdapter.idb_name}-store`,
-  );
-
-  /**
-   * Load saved chats from IndexedDB.
-   * @returns Promise resolving to saved chats array (empty if none found)
-   */
-  static async loadChats(): Promise<SavedChats> {
-    try {
-      const data = await get<SavedChats>(
-        TTDIndexedDBAdapter.key,
-        TTDIndexedDBAdapter.store,
-      );
-      return data || [];
-    } catch (error) {
-      console.warn("Failed to load TTD chats from IndexedDB:", error);
-      return [];
-    }
-  }
-
-  /**
-   * Save chats to IndexedDB.
-   * @param chats - The chats array to persist
-   */
-  static async saveChats(chats: SavedChats): Promise<void> {
-    try {
-      await set(TTDIndexedDBAdapter.key, chats, TTDIndexedDBAdapter.store);
-    } catch (error) {
-      console.warn("Failed to save TTD chats to IndexedDB:", error);
-      throw error;
-    }
-  }
-}
@@ -1,48 +0,0 @@
-import { VersionedSnapshotStore } from "@excalidraw/common";
-
-import type { FileId } from "@excalidraw/element/types";
-
-export type FileLoadingStatus = "loading" | "loaded" | "error";
-
-export class FileStatusStore {
-  private static store = new VersionedSnapshotStore<
-    Map<FileId, FileLoadingStatus>
-  >(new Map());
-
-  static getSnapshot() {
-    return this.store.getSnapshot();
-  }
-
-  static pull(sinceVersion?: number) {
-    return this.store.pull(sinceVersion);
-  }
-
-  static updateStatuses(updates: Array<[FileId, FileLoadingStatus]>) {
-    if (!updates.length) {
-      return;
-    }
-    this.store.update((prev) => {
-      let changed = false;
-      const next = new Map(prev);
-      for (const [id, status] of updates) {
-        if (next.get(id) !== status) {
-          next.set(id, status);
-          changed = true;
-        }
-      }
-      return changed ? next : prev;
-    });
-  }
-
-  static getPendingCount(statuses: Map<FileId, FileLoadingStatus>) {
-    let pending = 0;
-    let total = 0;
-    for (const status of statuses.values()) {
-      total++;
-      if (status === "loading") {
-        pending++;
-      }
-    }
-    return { pending, total };
-  }
-}
@@ -1,5 +1,5 @@
 import { reconcileElements } from "@excalidraw/excalidraw";
-import { MIME_TYPES, toBrandedType } from "@excalidraw/common";
+import { MIME_TYPES } from "@excalidraw/common";
 import { decompressData } from "@excalidraw/excalidraw/data/encode";
 import {
  encryptData,
@@ -105,8 +105,8 @@ const decryptElements = async (
  data: FirebaseStoredScene,
  roomKey: string,
 ): Promise<readonly ExcalidrawElement[]> => {
-  const ciphertext = data.ciphertext.toUint8Array() as Uint8Array<ArrayBuffer>;
-  const iv = data.iv.toUint8Array() as Uint8Array<ArrayBuffer>;
+  const ciphertext = data.ciphertext.toUint8Array();
+  const iv = data.iv.toUint8Array();

  const decrypted = await decryptData(iv, ciphertext, roomKey);
  const decodedData = new TextDecoder("utf-8").decode(
@@ -243,7 +243,7 @@ export const saveToFirebase = async (

  FirebaseSceneVersionCache.set(socket, storedElements);

-  return toBrandedType<RemoteExcalidrawElement[]>(storedElements);
+  return storedElements;
 };

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

  if (socket) {
@@ -8,6 +8,7 @@ import {
  IV_LENGTH_BYTES,
 } from "@excalidraw/excalidraw/data/encryption";
 import { serializeAsJSON } from "@excalidraw/excalidraw/data/json";
+import { restore } from "@excalidraw/excalidraw/data/restore";
 import { isInvisiblySmallElement } from "@excalidraw/element";
 import { isInitializedImageElement } from "@excalidraw/element";
 import { t } from "@excalidraw/excalidraw/i18n";
@@ -83,13 +84,13 @@ export type SocketUpdateDataSource = {
  SCENE_INIT: {
    type: WS_SUBTYPES.INIT;
    payload: {
-      elements: readonly OrderedExcalidrawElement[];
+      elements: readonly ExcalidrawElement[];
    };
  };
  SCENE_UPDATE: {
    type: WS_SUBTYPES.UPDATE;
    payload: {
-      elements: readonly OrderedExcalidrawElement[];
+      elements: readonly ExcalidrawElement[];
    };
  };
  MOUSE_LOCATION: {
@@ -199,7 +200,7 @@ const legacy_decodeFromBackend = async ({
  };
 };

-export const importFromBackend = async (
+const importFromBackend = async (
  id: string,
  decryptionKey: string,
 ): Promise<ImportedDataState> => {
@@ -241,6 +242,40 @@ export const importFromBackend = async (
  }
 };

+export const loadScene = async (
+  id: string | null,
+  privateKey: string | null,
+  // Supply local state even if importing from backend to ensure we restore
+  // localStorage user settings which we do not persist on server.
+  // Non-optional so we don't forget to pass it even if `undefined`.
+  localDataState: ImportedDataState | undefined | null,
+) => {
+  let data;
+  if (id != null && privateKey != null) {
+    // the private key is used to decrypt the content from the server, take
+    // extra care not to leak it
+    data = restore(
+      await importFromBackend(id, privateKey),
+      localDataState?.appState,
+      localDataState?.elements,
+      { repairBindings: true, refreshDimensions: false },
+    );
+  } else {
+    data = restore(localDataState || null, null, null, {
+      repairBindings: true,
+    });
+  }
+
+  return {
+    elements: data.elements,
+    appState: data.appState,
+    // note: this will always be empty because we're not storing files
+    // in the scene database/localStorage, and instead fetch them async
+    // from a different database
+    files: data.files,
+  };
+};
+
 type ExportToBackendResult =
  | { url: null; errorMessage: string }
  | { url: string; errorMessage: null };
@@ -2,6 +2,7 @@ import {
  clearAppStateForLocalStorage,
  getDefaultAppState,
 } from "@excalidraw/excalidraw/appState";
+import { clearElementsForLocalStorage } from "@excalidraw/element";

 import type { ExcalidrawElement } from "@excalidraw/element/types";
 import type { AppState } from "@excalidraw/excalidraw/types";
@@ -49,7 +50,7 @@ export const importFromLocalStorage = () => {
  let elements: ExcalidrawElement[] = [];
  if (savedElements) {
    try {
-      elements = JSON.parse(savedElements);
+      elements = clearElementsForLocalStorage(JSON.parse(savedElements));
    } catch (error: any) {
      console.error(error);
      // Do nothing because elements array is already empty
@@ -1,9 +1,17 @@
+declare global {
+  interface Window {
+    debug: typeof Debug;
+  }
+}
+
 const lessPrecise = (num: number, precision = 5) =>
  parseFloat(num.toPrecision(precision));

 const getAvgFrameTime = (times: number[]) =>
  lessPrecise(times.reduce((a, b) => a + b) / times.length);

+const getFps = (frametime: number) => lessPrecise(1000 / frametime);
+
 export class Debug {
  public static DEBUG_LOG_TIMES = true;

@@ -16,35 +24,34 @@ export class Debug {
  private static LAST_DEBUG_LOG_CALL = 0;
  private static DEBUG_LOG_INTERVAL_ID: null | number = null;

-  private static LAST_FRAME_TIMESTAMP = 0;
-  private static FRAME_COUNT = 0;
-  private static ANIMATION_FRAME_ID: null | number = null;
-
-  private static scheduleAnimationFrame = () => {
-    if (Debug.DEBUG_LOG_INTERVAL_ID !== null) {
-      Debug.ANIMATION_FRAME_ID = requestAnimationFrame((timestamp) => {
-        if (Debug.LAST_FRAME_TIMESTAMP !== timestamp) {
-          Debug.LAST_FRAME_TIMESTAMP = timestamp;
-          Debug.FRAME_COUNT++;
-        }
-
-        if (Debug.DEBUG_LOG_INTERVAL_ID !== null) {
-          Debug.scheduleAnimationFrame();
-        }
-      });
-    }
-  };
-
  private static setupInterval = () => {
    if (Debug.DEBUG_LOG_INTERVAL_ID === null) {
      console.info("%c(starting perf recording)", "color: lime");
      Debug.DEBUG_LOG_INTERVAL_ID = window.setInterval(Debug.debugLogger, 1000);
-      Debug.scheduleAnimationFrame();
    }
    Debug.LAST_DEBUG_LOG_CALL = Date.now();
  };

  private static debugLogger = () => {
+    if (
+      Date.now() - Debug.LAST_DEBUG_LOG_CALL > 600 &&
+      Debug.DEBUG_LOG_INTERVAL_ID !== null
+    ) {
+      window.clearInterval(Debug.DEBUG_LOG_INTERVAL_ID);
+      Debug.DEBUG_LOG_INTERVAL_ID = null;
+      for (const [name, { avg }] of Object.entries(Debug.TIMES_AVG)) {
+        if (avg != null) {
+          console.info(
+            `%c${name} run avg: ${avg}ms (${getFps(avg)} fps)`,
+            "color: blue",
+          );
+        }
+      }
+      console.info("%c(stopping perf recording)", "color: red");
+      Debug.TIMES_AGGR = {};
+      Debug.TIMES_AVG = {};
+      return;
+    }
    if (Debug.DEBUG_LOG_TIMES) {
      for (const [name, { t, times }] of Object.entries(Debug.TIMES_AGGR)) {
        if (times.length) {
@@ -58,18 +65,8 @@ export class Debug {
      }
      for (const [name, { t, times, avg }] of Object.entries(Debug.TIMES_AVG)) {
        if (times.length) {
-          // const avgFrameTime = getAvgFrameTime(times);
-          const totalTime = times.reduce((a, b) => a + b);
-          const avgFrameTime = lessPrecise(totalTime / Debug.FRAME_COUNT);
-          console.info(
-            name,
-            `- ${times.length} calls - ${avgFrameTime}ms/frame across ${
-              Debug.FRAME_COUNT
-            } frames (${lessPrecise(
-              (avgFrameTime / 16.67) * 100,
-              1,
-            )}% of frame budget)`,
-          );
+          const avgFrameTime = getAvgFrameTime(times);
+          console.info(name, `${avgFrameTime}ms (${getFps(avgFrameTime)} fps)`);
          Debug.TIMES_AVG[name] = {
            t,
            times: [],
@@ -79,24 +76,6 @@ export class Debug {
        }
      }
    }
-    Debug.FRAME_COUNT = 0;
-
-    // Check for stop condition after logging
-    if (
-      Date.now() - Debug.LAST_DEBUG_LOG_CALL > 600 &&
-      Debug.DEBUG_LOG_INTERVAL_ID !== null
-    ) {
-      console.info("%c(stopping perf recording)", "color: red");
-      window.clearInterval(Debug.DEBUG_LOG_INTERVAL_ID);
-      window.cancelAnimationFrame(Debug.ANIMATION_FRAME_ID!);
-      Debug.ANIMATION_FRAME_ID = null;
-      Debug.FRAME_COUNT = 0;
-      Debug.LAST_FRAME_TIMESTAMP = 0;
-
-      Debug.DEBUG_LOG_INTERVAL_ID = null;
-      Debug.TIMES_AGGR = {};
-      Debug.TIMES_AVG = {};
-    }
  };

  public static logTime = (time?: number, name = "default") => {
@@ -130,7 +109,7 @@ export class Debug {
      return (...args: T) => {
        const t0 = performance.now();
        const ret = fn(...args);
-        Debug[type](performance.now() - t0, name);
+        Debug.logTime(performance.now() - t0, name);
        return ret;
      };
    };
@@ -151,70 +130,6 @@ export class Debug {
      return ret;
    };
  };
-
-  private static CHANGED_CACHE: Record<string, Record<string, unknown>> = {};
-
-  public static logChanged(name: string, obj: Record<string, unknown>) {
-    const prev = Debug.CHANGED_CACHE[name];
-
-    Debug.CHANGED_CACHE[name] = obj;
-
-    if (!prev) {
-      return;
-    }
-
-    const allKeys = new Set([...Object.keys(prev), ...Object.keys(obj)]);
-    const changed: Record<string, { prev: unknown; next: unknown }> = {};
-
-    for (const key of allKeys) {
-      const prevVal = prev[key];
-      const nextVal = obj[key];
-      if (!deepEqual(prevVal, nextVal)) {
-        changed[key] = { prev: prevVal, next: nextVal };
-      }
-    }
-
-    if (Object.keys(changed).length > 0) {
-      console.info(`[${name}] changed:`, changed);
-    }
-  }
-}
-
-function deepEqual(a: unknown, b: unknown): boolean {
-  if (Object.is(a, b)) {
-    return true;
-  }
-
-  if (
-    a === null ||
-    b === null ||
-    typeof a !== "object" ||
-    typeof b !== "object"
-  ) {
-    return false;
-  }
-
-  if (Array.isArray(a) !== Array.isArray(b)) {
-    return false;
-  }
-
-  const keysA = Object.keys(a as Record<string, unknown>);
-  const keysB = Object.keys(b as Record<string, unknown>);
-
-  if (keysA.length !== keysB.length) {
-    return false;
-  }
-
-  for (const key of keysA) {
-    if (
-      !deepEqual(
-        (a as Record<string, unknown>)[key],
-        (b as Record<string, unknown>)[key],
-      )
-    ) {
-      return false;
-    }
-  }
-
-  return true;
 }
+//@ts-ignore
+window.debug = Debug;
@@ -2,7 +2,7 @@
 <html lang="en">
  <head>
    <meta charset="utf-8" />
-    <title>Excalidraw Whiteboard</title>
+    <title>Excalidraw | Hand-drawn look & feel • Collaborative • Secure</title>
    <meta
      name="viewport"
      content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no, viewport-fit=cover, shrink-to-fit=no"
@@ -14,7 +14,7 @@
    <!-- Primary Meta Tags -->
    <meta
      name="title"
-      content="Free, collaborative whiteboard • Hand-drawn look & feel | Excalidraw"
+      content="Excalidraw — Collaborative whiteboarding made easy"
    />
    <meta
      name="description"
@@ -1,5 +1,3 @@
-@import "../packages/excalidraw/css/variables.module.scss";
-
 .excalidraw {
  --color-primary-contrast-offset: #625ee0; // to offset Chubb illusion

@@ -7,6 +5,12 @@
    --color-primary-contrast-offset: #726dff; // to offset Chubb illusion
  }

+  .top-right-ui {
+    display: flex;
+    justify-content: center;
+    align-items: flex-start;
+  }
+
  .footer-center {
    justify-content: flex-end;
    margin-top: auto;
@@ -54,7 +58,7 @@
    }
  }

-  .alert {
+  .collab-offline-warning {
    pointer-events: none;
    position: absolute;
    top: 6.5rem;
@@ -65,18 +69,10 @@
    text-align: center;
    line-height: 1.5;
    border-radius: var(--border-radius-md);
+    background-color: var(--color-warning);
+    color: var(--color-text-warning);
    z-index: 6;
    white-space: pre;
-
-    &--warning {
-      background-color: var(--color-warning);
-      color: var(--color-text-warning);
-    }
-
-    &--danger {
-      background-color: var(--color-danger-dark);
-      color: var(--color-danger-text);
-    }
  }
 }

@@ -86,31 +82,22 @@
  }
 }

-.plus-banner {
+.plus-button {
  display: flex;
  justify-content: center;
  cursor: pointer;
  align-items: center;
  border: 1px solid var(--color-primary);
-  padding: 0.5rem 0.875rem;
+  padding: 0.5rem 0.75rem;
  border-radius: var(--border-radius-lg);
  background-color: var(--island-bg-color);
+  color: var(--color-primary) !important;
  text-decoration: none !important;

-  font-family: var(--ui-font);
-  font-size: 0.8333rem;
+  font-size: 0.75rem;
  box-sizing: border-box;
  height: var(--lg-button-size);

-  border: none;
-  box-shadow: 0 0 0 1px var(--color-surface-lowest);
-  background-color: var(--color-surface-low);
-  color: var(--button-color, var(--color-on-surface)) !important;
-
-  &:active {
-    box-shadow: 0 0 0 1px var(--color-brand-active);
-  }
-
  &:hover {
    background-color: var(--color-primary);
    color: white !important;
@@ -122,7 +109,7 @@
 }

 .theme--dark {
-  .plus-banner {
+  .plus-button {
    &:hover {
      color: black !important;
    }
@@ -23,7 +23,7 @@
    ]
  },
  "engines": {
-    "node": ">=18.0.0"
+    "node": "18.0.0 - 22.x.x"
  },
  "dependencies": {
    "@excalidraw/random-username": "1.0.0",
@@ -36,7 +36,6 @@
    "react": "19.0.0",
    "react-dom": "19.0.0",
    "socket.io-client": "4.7.2",
-    "uqr": "0.1.2",
    "vite-plugin-html": "3.2.2"
  },
  "prettier": "@excalidraw/prettier-config",
@@ -1,4 +1,3 @@
-import { getFeatureFlag } from "@excalidraw/common";
 import * as Sentry from "@sentry/browser";
 import callsites from "callsites";

@@ -34,7 +33,6 @@ Sentry.init({
    Sentry.captureConsoleIntegration({
      levels: ["error"],
    }),
-    Sentry.featureFlagsIntegration(),
  ],
  beforeSend(event) {
    if (event.request?.url) {
@@ -81,14 +79,3 @@ Sentry.init({
    return event;
  },
 });
-
-const flagsIntegration =
-  Sentry.getClient()?.getIntegrationByName<Sentry.FeatureFlagsIntegration>(
-    "FeatureFlags",
-  );
-if (flagsIntegration) {
-  flagsIntegration.addFeatureFlag(
-    "COMPLEX_BINDINGS",
-    getFeatureFlag("COMPLEX_BINDINGS"),
-  );
-}
@@ -1,56 +0,0 @@
-import { useEffect, useState } from "react";
-import Spinner from "@excalidraw/excalidraw/components/Spinner";
-
-interface QRCodeProps {
-  value: string;
-}
-
-export const QRCode = ({ value }: QRCodeProps) => {
-  const [svgData, setSvgData] = useState<string | null>(null);
-  const [error, setError] = useState<boolean>(false);
-
-  useEffect(() => {
-    let mounted = true;
-
-    import("./qrcode.chunk")
-      .then(({ generateQRCodeSVG }) => {
-        if (mounted) {
-          try {
-            setSvgData(generateQRCodeSVG(value));
-          } catch {
-            setError(true);
-          }
-        }
-      })
-      .catch(() => {
-        if (mounted) {
-          setError(true);
-        }
-      });
-
-    return () => {
-      mounted = false;
-    };
-  }, [value]);
-
-  if (error) {
-    return null;
-  }
-
-  if (!svgData) {
-    return (
-      <div className="ShareDialog__active__qrcode ShareDialog__active__qrcode--loading">
-        <Spinner />
-      </div>
-    );
-  }
-
-  return (
-    <div
-      className="ShareDialog__active__qrcode"
-      role="img"
-      aria-label="QR code for collaboration link"
-      dangerouslySetInnerHTML={{ __html: svgData }}
-    />
-  );
-};
@@ -140,31 +140,6 @@
        gap: 0.75rem;
      }

-      &__qrcode {
-        display: flex;
-        justify-content: center;
-        align-items: center;
-        align-self: center;
-        padding: 1rem;
-        background: #fff;
-        border-radius: 0.5rem;
-        border: 1px solid #e0e0e0;
-
-        $size: 150px;
-        width: $size;
-        height: $size;
-
-        & svg {
-          width: $size;
-          height: $size;
-        }
-
-        &--loading {
-          background: var(--island-bg-color);
-          border: 1px solid var(--dialog-border-color);
-        }
-      }
-
      &__description {
        border-top: 1px solid var(--color-gray-20);

@@ -22,7 +22,6 @@ import { atom, useAtom, useAtomValue } from "../app-jotai";
 import { activeRoomLinkAtom } from "../collab/Collab";

 import "./ShareDialog.scss";
-import { QRCode } from "./QRCode";

 import type { CollabAPI } from "../collab/Collab";

@@ -143,7 +142,6 @@ const ActiveRoomDialog = ({
          }}
        />
      </div>
-      <QRCode value={activeRoomLink} />
      <div className="ShareDialog__active__description">
        <p>
          <span
@@ -1,5 +0,0 @@
-import { renderSVG } from "uqr";
-
-export const generateQRCodeSVG = (text: string): string => {
-  return renderSVG(text);
-};
@@ -17,15 +17,30 @@ describe("Test MobileMenu", () => {

  beforeEach(async () => {
    await render(<ExcalidrawApp />);
-    h.app.refreshEditorInterface();
+    // @ts-ignore
+    h.app.refreshViewportBreakpoints();
+    // @ts-ignore
+    h.app.refreshEditorBreakpoints();
  });

  afterAll(() => {
    restoreOriginalGetBoundingClientRect();
  });

-  it("should set editor interface correctly", () => {
-    expect(h.app.editorInterface.formFactor).toBe("phone");
+  it("should set device correctly", () => {
+    expect(h.app.device).toMatchInlineSnapshot(`
+      {
+        "editor": {
+          "canFitSidebar": false,
+          "isMobile": true,
+        },
+        "isTouchScreen": false,
+        "viewport": {
+          "isLandscape": false,
+          "isMobile": true,
+        },
+      }
+    `);
  });

  it("should initialize with welcome screen and hide once user interacts", async () => {
@@ -50,11 +50,7 @@ exports[`Test MobileMenu > should initialize with welcome screen and hide once u
  <div
    class="welcome-screen-center__heading welcome-screen-decor excalifont"
  >
-    Your drawings are saved in your browser's storage.
-    <br />
-    Browser storage can be cleared unexpectedly.
-    <br />
-    Save your work to a file regularly to avoid losing it.
+    All your data is saved locally in your browser.
  </div>
  <div
    class="welcome-screen-menu"
@@ -1,4 +1,5 @@
 import { THEME } from "@excalidraw/excalidraw";
+import { EVENT, CODES, KEYS } from "@excalidraw/common";
 import { useEffect, useLayoutEffect, useState } from "react";

 import type { Theme } from "@excalidraw/element/types";
@@ -30,10 +31,28 @@ export const useHandleAppTheme = () => {
      mediaQuery?.addEventListener("change", handleChange);
    }

+    const handleKeydown = (event: KeyboardEvent) => {
+      if (
+        !event[KEYS.CTRL_OR_CMD] &&
+        event.altKey &&
+        event.shiftKey &&
+        event.code === CODES.D
+      ) {
+        event.preventDefault();
+        event.stopImmediatePropagation();
+        setAppTheme(editorTheme === THEME.DARK ? THEME.LIGHT : THEME.DARK);
+      }
+    };
+
+    document.addEventListener(EVENT.KEYDOWN, handleKeydown, { capture: true });
+
    return () => {
      mediaQuery?.removeEventListener("change", handleChange);
+      document.removeEventListener(EVENT.KEYDOWN, handleKeydown, {
+        capture: true,
+      });
    };
-  }, [appTheme]);
+  }, [appTheme, editorTheme, setAppTheme]);

  useLayoutEffect(() => {
    localStorage.setItem(STORAGE_KEYS.LOCAL_STORAGE_THEME, appTheme);
@@ -75,20 +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",
-          ),
-        },
-        {
-          find: /^@excalidraw\/laser-pointer$/,
-          replacement: path.resolve(
-            __dirname,
-            "../packages/laser-pointer/src/index.ts",
-          ),
-        },
      ],
    },
    build: {
@@ -116,14 +102,6 @@ export default defineConfig(({ mode }) => {
              // Taking the substring after "locales/"
              return `locales/${id.substring(index + 8)}`;
            }
-
-            if (id.includes("@excalidraw/mermaid-to-excalidraw")) {
-              return "mermaid-to-excalidraw";
-            }
-
-            if (id.includes("@codemirror/") || id.includes("@lezer/")) {
-              return "codemirror.chunk";
-            }
          },
        },
      },
@@ -168,11 +146,6 @@ export default defineConfig(({ mode }) => {
            "**/locales/**",
            "service-worker.js",
            "**/*.chunk-*.js",
-            // CodeMirrorEditor can't be assigned a `.chunk` name via
-            // manualChunks because Rollup would hoist shared deps (React)
-            // via a static import from the main bundle, defeating lazy
-            // loading. So we exclude it by name instead.
-            "**/CodeMirrorEditor-*.js",
          ],
          runtimeCaching: [
            {
@@ -212,7 +185,7 @@ export default defineConfig(({ mode }) => {
              },
            },
            {
-              urlPattern: new RegExp("(.chunk-.+|CodeMirrorEditor-.+)\\.js"),
+              urlPattern: new RegExp(".chunk-.+.js"),
              handler: "CacheFirst",
              options: {
                cacheName: "chunk",
@@ -223,7 +196,6 @@ export default defineConfig(({ mode }) => {
              },
            },
          ],
-          maximumFileSizeToCacheInBytes: 2.3 * 1024 ** 2, // 2.3MB
        },
        manifest: {
          short_name: "Excalidraw",
@@ -34,7 +34,7 @@
    "prettier": "2.6.2",
    "rewire": "6.0.0",
    "rimraf": "^5.0.0",
-    "typescript": "5.9.3",
+    "typescript": "4.9.4",
    "vite": "5.0.12",
    "vite-plugin-checker": "0.7.2",
    "vite-plugin-ejs": "1.7.0",
@@ -44,7 +44,7 @@
    "vitest-canvas-mock": "0.3.3"
  },
  "engines": {
-    "node": ">=18.0.0"
+    "node": "18.0.0 - 22.x.x"
  },
  "homepage": ".",
  "prettier": "@excalidraw/prettier-config",
@@ -56,9 +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:laser-pointer": "yarn --cwd ./packages/laser-pointer build:esm",
-    "build:packages": "yarn build:common && yarn build:fractional-indexing && yarn build:laser-pointer && 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",
@@ -55,11 +55,5 @@
  "scripts": {
    "gen:types": "rimraf types && tsc",
    "build:esm": "rimraf dist && node ../../scripts/buildBase.js && yarn gen:types"
-  },
-  "dependencies": {
-    "tinycolor2": "1.6.0"
-  },
-  "devDependencies": {
-    "@types/tinycolor2": "1.4.6"
  }
 }
@@ -1,185 +0,0 @@
-// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
-
-exports[`COLOR_PALETTE > color palette doesn't regress 1`] = `
-{
-  "black": "#1e1e1e",
-  "blue": [
-    "#e7f5ff",
-    "#a5d8ff",
-    "#4dabf7",
-    "#228be6",
-    "#1971c2",
-  ],
-  "bronze": [
-    "#f8f1ee",
-    "#eaddd7",
-    "#d2bab0",
-    "#a18072",
-    "#846358",
-  ],
-  "cyan": [
-    "#e3fafc",
-    "#99e9f2",
-    "#3bc9db",
-    "#15aabf",
-    "#0c8599",
-  ],
-  "grape": [
-    "#f8f0fc",
-    "#eebefa",
-    "#da77f2",
-    "#be4bdb",
-    "#9c36b5",
-  ],
-  "gray": [
-    "#f8f9fa",
-    "#e9ecef",
-    "#ced4da",
-    "#868e96",
-    "#343a40",
-  ],
-  "green": [
-    "#ebfbee",
-    "#b2f2bb",
-    "#69db7c",
-    "#40c057",
-    "#2f9e44",
-  ],
-  "orange": [
-    "#fff4e6",
-    "#ffd8a8",
-    "#ffa94d",
-    "#fd7e14",
-    "#e8590c",
-  ],
-  "pink": [
-    "#fff0f6",
-    "#fcc2d7",
-    "#f783ac",
-    "#e64980",
-    "#c2255c",
-  ],
-  "red": [
-    "#fff5f5",
-    "#ffc9c9",
-    "#ff8787",
-    "#fa5252",
-    "#e03131",
-  ],
-  "teal": [
-    "#e6fcf5",
-    "#96f2d7",
-    "#38d9a9",
-    "#12b886",
-    "#099268",
-  ],
-  "transparent": "transparent",
-  "violet": [
-    "#f3f0ff",
-    "#d0bfff",
-    "#9775fa",
-    "#7950f2",
-    "#6741d9",
-  ],
-  "white": "#ffffff",
-  "yellow": [
-    "#fff9db",
-    "#ffec99",
-    "#ffd43b",
-    "#fab005",
-    "#f08c00",
-  ],
-}
-`;
-
-exports[`applyDarkModeFilter > COLOR_PALETTE regression tests > matches snapshot for all palette colors 1`] = `
-{
-  "black": "#d3d3d3",
-  "blue": [
-    "#121e26",
-    "#154162",
-    "#2273b4",
-    "#3791e0",
-    "#56a2e8",
-  ],
-  "bronze": [
-    "#221c1a",
-    "#362b26",
-    "#5a463d",
-    "#917569",
-    "#a98d84",
-  ],
-  "cyan": [
-    "#0a1e20",
-    "#004149",
-    "#007281",
-    "#0f8fa1",
-    "#3da5b6",
-  ],
-  "grape": [
-    "#211a25",
-    "#5b3165",
-    "#a954be",
-    "#d471ed",
-    "#e28af8",
-  ],
-  "gray": [
-    "#161718",
-    "#202325",
-    "#33383d",
-    "#6e757c",
-    "#b7bcc1",
-  ],
-  "green": [
-    "#0f1d12",
-    "#043b0c",
-    "#056715",
-    "#16842a",
-    "#39994b",
-  ],
-  "orange": [
-    "#22190d",
-    "#4c2b01",
-    "#924800",
-    "#cd6005",
-    "#f17634",
-  ],
-  "pink": [
-    "#26191e",
-    "#602e40",
-    "#b04d70",
-    "#f56e9d",
-    "#ff8dbc",
-  ],
-  "red": [
-    "#1f1717",
-    "#5a2c2c",
-    "#b44d4d",
-    "#fa6969",
-    "#ff8383",
-  ],
-  "teal": [
-    "#0a1d17",
-    "#00422b",
-    "#00744b",
-    "#039267",
-    "#32a783",
-  ],
-  "transparent": "#ededed00",
-  "violet": [
-    "#1f1c29",
-    "#4a3b72",
-    "#8a6cdf",
-    "#a885ff",
-    "#b595ff",
-  ],
-  "white": "#121212",
-  "yellow": [
-    "#1e1900",
-    "#362600",
-    "#5f3a00",
-    "#905000",
-    "#b86200",
-  ],
-}
-`;
@@ -1,74 +0,0 @@
-import { AppEventBus } from "./appEventBus";
-
-type TestEvents = {
-  initialize: [api: number];
-  pointerUp: [pointerId: string];
-  viewState: [zoom: number];
-};
-
-const behavior = {
-  initialize: { cardinality: "once", replay: "last" },
-  pointerUp: { cardinality: "many", replay: "none" },
-  viewState: { cardinality: "many", replay: "last" },
-} as const;
-
-const flushMicrotasks = async () => Promise.resolve();
-
-describe("AppEventBus", () => {
-  it("replays once events to late callback and Promise subscribers", async () => {
-    const bus = new AppEventBus<TestEvents, typeof behavior>(behavior);
-    bus.emit("initialize", 42);
-
-    const calls: number[] = [];
-    bus.on("initialize", (value) => {
-      calls.push(value);
-    });
-
-    expect(calls).toEqual([]);
-    await flushMicrotasks();
-    expect(calls).toEqual([42]);
-
-    await expect(bus.on("initialize")).resolves.toBe(42);
-  });
-
-  it("does not replay stream events to late subscribers", async () => {
-    const bus = new AppEventBus<TestEvents, typeof behavior>(behavior);
-    bus.emit("pointerUp", "first");
-
-    const calls: string[] = [];
-    bus.on("pointerUp", (pointerId) => {
-      calls.push(pointerId);
-    });
-
-    await flushMicrotasks();
-    expect(calls).toEqual([]);
-
-    bus.emit("pointerUp", "second");
-    expect(calls).toEqual(["second"]);
-  });
-
-  it("replays replay-last stream events and stays subscribed", async () => {
-    const bus = new AppEventBus<TestEvents, typeof behavior>(behavior);
-    bus.emit("viewState", 1);
-
-    const calls: number[] = [];
-    bus.on("viewState", (zoom) => {
-      calls.push(zoom);
-    });
-
-    await flushMicrotasks();
-    expect(calls).toEqual([1]);
-
-    bus.emit("viewState", 2);
-    expect(calls).toEqual([1, 2]);
-  });
-
-  it("throws when emitting a once event twice", () => {
-    const bus = new AppEventBus<TestEvents, typeof behavior>(behavior);
-    bus.emit("initialize", 1);
-
-    expect(() => {
-      bus.emit("initialize", 2);
-    }).toThrow('Event "initialize" can only be emitted once');
-  });
-});
@@ -1,136 +0,0 @@
-import type { UnsubscribeCallback } from "@excalidraw/excalidraw/types";
-
-import { Emitter } from "./emitter";
-import { isProdEnv } from "./utils";
-
-export type AppEventPayloadMap = Record<string, unknown[]>;
-
-export type AppEventBehavior = {
-  cardinality: "once" | "many";
-  replay: "none" | "last";
-};
-
-export type AppEventBehaviorMap<Events extends AppEventPayloadMap> = {
-  [K in keyof Events]: AppEventBehavior;
-};
-
-type AwaitableAppEventKeys<
-  Events extends AppEventPayloadMap,
-  Behavior extends AppEventBehaviorMap<Events>,
-> = {
-  [K in keyof Events]: Behavior[K]["cardinality"] extends "once"
-    ? Behavior[K]["replay"] extends "last"
-      ? K
-      : never
-    : never;
-}[keyof Events];
-
-type AppEventPromiseValue<Args extends any[]> = Args extends [infer Only]
-  ? Only
-  : Args;
-
-export class AppEventBus<
-  Events extends AppEventPayloadMap,
-  Behavior extends AppEventBehaviorMap<Events>,
-> {
-  private readonly emitters = new Map<keyof Events, Emitter<any>>();
-  private readonly lastPayload = new Map<keyof Events, any[]>();
-  private readonly emittedOnce = new Set<keyof Events>();
-
-  constructor(private readonly behavior: Behavior) {}
-
-  private getEmitter<K extends keyof Events>(name: K): Emitter<Events[K]> {
-    let emitter = this.emitters.get(name);
-    if (!emitter) {
-      emitter = new Emitter<any>();
-      this.emitters.set(name, emitter);
-    }
-    return emitter as Emitter<Events[K]>;
-  }
-
-  private toPromiseValue<Args extends any[]>(
-    args: Args,
-  ): AppEventPromiseValue<Args> {
-    return (args.length === 1 ? args[0] : args) as AppEventPromiseValue<Args>;
-  }
-
-  public on<K extends keyof Events>(
-    name: K,
-    callback: (...args: Events[K]) => void,
-  ): UnsubscribeCallback;
-  public on<K extends AwaitableAppEventKeys<Events, Behavior>>(
-    name: K,
-  ): Promise<AppEventPromiseValue<Events[K]>>;
-  public on<K extends keyof Events>(
-    name: K,
-    callback?: (...args: Events[K]) => void,
-  ): UnsubscribeCallback | Promise<AppEventPromiseValue<Events[K]>> {
-    const eventBehavior = this.behavior[name];
-    const cachedPayload = this.lastPayload.get(name) as Events[K] | undefined;
-
-    if (callback) {
-      if (eventBehavior.replay === "last" && cachedPayload) {
-        queueMicrotask(() => callback(...cachedPayload));
-
-        if (eventBehavior.cardinality === "once") {
-          return () => {};
-        }
-      }
-
-      return this.getEmitter(name).on(callback);
-    }
-
-    if (
-      eventBehavior.cardinality !== "once" ||
-      eventBehavior.replay !== "last"
-    ) {
-      throw new Error(`Event "${String(name)}" requires a callback`);
-    }
-
-    if (cachedPayload) {
-      return Promise.resolve(this.toPromiseValue(cachedPayload));
-    }
-
-    return new Promise<AppEventPromiseValue<Events[K]>>((resolve) => {
-      this.getEmitter(name).once((...args: Events[K]) => {
-        resolve(this.toPromiseValue(args));
-      });
-    });
-  }
-
-  public emit<K extends keyof Events>(name: K, ...args: Events[K]) {
-    const eventBehavior = this.behavior[name];
-
-    if (!isProdEnv()) {
-      if (eventBehavior.cardinality === "once") {
-        if (this.emittedOnce.has(name)) {
-          throw new Error(`Event "${String(name)}" can only be emitted once`);
-        }
-        this.emittedOnce.add(name);
-      }
-    }
-
-    if (eventBehavior.replay === "last") {
-      this.lastPayload.set(name, args);
-    }
-
-    try {
-      this.getEmitter(name).trigger(...args);
-    } finally {
-      if (eventBehavior.cardinality === "once") {
-        this.getEmitter(name).clear();
-      }
-    }
-  }
-
-  public clear() {
-    this.lastPayload.clear();
-    this.emittedOnce.clear();
-
-    for (const emitter of this.emitters.values()) {
-      emitter.clear();
-    }
-
-    this.emitters.clear();
-  }
-}
@@ -5,18 +5,17 @@ export class BinaryHeap<T> {

  sinkDown(idx: number) {
    const node = this.content[idx];
-    const nodeScore = this.scoreFunction(node);
    while (idx > 0) {
      const parentN = ((idx + 1) >> 1) - 1;
      const parent = this.content[parentN];
-      if (nodeScore < this.scoreFunction(parent)) {
+      if (this.scoreFunction(node) < this.scoreFunction(parent)) {
+        this.content[parentN] = node;
        this.content[idx] = parent;
        idx = parentN; // TODO: Optimize
      } else {
        break;
      }
    }
-    this.content[idx] = node;
  }

  bubbleUp(idx: number) {
@@ -25,39 +24,35 @@ export class BinaryHeap<T> {
    const score = this.scoreFunction(node);

    while (true) {
-      const child1N = ((idx + 1) << 1) - 1;
-      const child2N = child1N + 1;
-      let smallestIdx = idx;
-      let smallestScore = score;
+      const child2N = (idx + 1) << 1;
+      const child1N = child2N - 1;
+      let swap = null;
+      let child1Score = 0;

-      // Check left child
      if (child1N < length) {
-        const child1Score = this.scoreFunction(this.content[child1N]);
-        if (child1Score < smallestScore) {
-          smallestIdx = child1N;
-          smallestScore = child1Score;
+        const child1 = this.content[child1N];
+        child1Score = this.scoreFunction(child1);
+        if (child1Score < score) {
+          swap = child1N;
        }
      }

-      // Check right child
      if (child2N < length) {
-        const child2Score = this.scoreFunction(this.content[child2N]);
-        if (child2Score < smallestScore) {
-          smallestIdx = child2N;
+        const child2 = this.content[child2N];
+        const child2Score = this.scoreFunction(child2);
+        if (child2Score < (swap === null ? score : child1Score)) {
+          swap = child2N;
        }
      }

-      if (smallestIdx === idx) {
+      if (swap !== null) {
+        this.content[idx] = this.content[swap];
+        this.content[swap] = node;
+        idx = swap; // TODO: Optimize
+      } else {
        break;
      }
-
-      // Move the smaller child up, continue finding position for node
-      this.content[idx] = this.content[smallestIdx];
-      idx = smallestIdx;
    }
-
-    // Place node in its final position
-    this.content[idx] = node;
  }

  push(node: T) {
@@ -1,17 +0,0 @@
-/**
- * x and y position of top left corner, x and y position of bottom right corner
- */
-export type Bounds = readonly [
-  minX: number,
-  minY: number,
-  maxX: number,
-  maxY: number,
-];
-
-export const isBounds = (box: unknown): box is Bounds =>
-  Array.isArray(box) &&
-  box.length === 4 &&
-  typeof box[0] === "number" &&
-  typeof box[1] === "number" &&
-  typeof box[2] === "number" &&
-  typeof box[3] === "number";
@@ -1,286 +0,0 @@
-import {
-  applyDarkModeFilter,
-  COLOR_PALETTE,
-  rgbToHex,
-} from "@excalidraw/common";
-
-describe("COLOR_PALETTE", () => {
-  it("color palette doesn't regress", () => {
-    expect(COLOR_PALETTE).toMatchSnapshot();
-  });
-});
-
-describe("applyDarkModeFilter", () => {
-  describe("basic transformations", () => {
-    it("transforms black to near-white", () => {
-      const result = applyDarkModeFilter("#000000");
-      // Black inverted 93% + hue rotate should be near white/light gray
-      expect(result).toBe("#ededed");
-    });
-
-    it("transforms white to near-black", () => {
-      const result = applyDarkModeFilter("#ffffff");
-      // White inverted 93% should be near black/dark gray
-      expect(result).toBe("#121212");
-    });
-
-    it("transforms pure red", () => {
-      const result = applyDarkModeFilter("#ff0000");
-      // Invert 93% + hue rotate 180deg produces a cyan-ish tint
-      expect(result).toBe("#ff9090");
-    });
-
-    it("transforms pure green", () => {
-      const result = applyDarkModeFilter("#00ff00");
-      // Invert 93% + hue rotate 180deg
-      expect(result).toBe("#008f00");
-    });
-
-    it("transforms pure blue", () => {
-      const result = applyDarkModeFilter("#0000ff");
-      // Invert 93% + hue rotate 180deg produces a light purple
-      expect(result).toBe("#cdcdff");
-    });
-  });
-
-  describe("color formats", () => {
-    it("handles hex with hash", () => {
-      const result = applyDarkModeFilter("#ff0000");
-      // Fully opaque colors return 6-char hex
-      expect(result).toMatch(/^#[0-9a-f]{6}$/);
-    });
-
-    it("handles named colors", () => {
-      const result = applyDarkModeFilter("red");
-      // "red" = #ff0000, fully opaque
-      expect(result).toBe("#ff9090");
-    });
-
-    it("handles rgb format", () => {
-      const result = applyDarkModeFilter("rgb(255, 0, 0)");
-      expect(result).toBe("#ff9090");
-    });
-
-    it("handles rgba format and preserves alpha", () => {
-      const result = applyDarkModeFilter("rgba(255, 0, 0, 0.5)");
-      expect(result).toMatch(/^#[0-9a-f]{8}$/);
-      // Alpha 0.5 = 128 in hex = 80
-      expect(result).toBe("#ff909080");
-    });
-
-    it("handles transparent", () => {
-      const result = applyDarkModeFilter("transparent");
-      // transparent = rgba(0,0,0,0), inverted should still have 0 alpha
-      expect(result).toBe("#ededed00");
-    });
-
-    it("handles shorthand hex", () => {
-      const result = applyDarkModeFilter("#f00");
-      expect(result).toBe("#ff9090");
-    });
-  });
-
-  describe("alpha preservation", () => {
-    it("omits alpha for full opacity", () => {
-      const result = applyDarkModeFilter("#ff0000ff");
-      // Full opacity returns 6-char hex (no alpha suffix)
-      expect(result).toBe("#ff9090");
-    });
-
-    it("preserves 50% opacity", () => {
-      const result = applyDarkModeFilter("#ff000080");
-      expect(result.slice(-2)).toBe("80");
-    });
-
-    it("preserves 0% opacity", () => {
-      const result = applyDarkModeFilter("#ff000000");
-      expect(result.slice(-2)).toBe("00");
-    });
-  });
-
-  describe("COLOR_PALETTE regression tests", () => {
-    it("transforms black from palette", () => {
-      // COLOR_PALETTE.black is #1e1e1e (not pure black)
-      const result = applyDarkModeFilter(COLOR_PALETTE.black);
-      expect(result).toBe("#d3d3d3");
-    });
-
-    it("transforms white from palette", () => {
-      const result = applyDarkModeFilter(COLOR_PALETTE.white);
-      expect(result).toBe("#121212");
-    });
-
-    it("transforms transparent from palette", () => {
-      const result = applyDarkModeFilter(COLOR_PALETTE.transparent);
-      expect(result).toBe("#ededed00");
-    });
-
-    // Test each color family from the palette (all opaque, so 6-char hex)
-    describe("red shades", () => {
-      const redShades = COLOR_PALETTE.red;
-      it.each(redShades.map((color, i) => [color, i]))(
-        "transforms red shade %s (index %d)",
-        (color) => {
-          const result = applyDarkModeFilter(color as string);
-          expect(result).toMatch(/^#[0-9a-f]{6}$/);
-        },
-      );
-    });
-
-    describe("blue shades", () => {
-      const blueShades = COLOR_PALETTE.blue;
-      it.each(blueShades.map((color, i) => [color, i]))(
-        "transforms blue shade %s (index %d)",
-        (color) => {
-          const result = applyDarkModeFilter(color as string);
-          expect(result).toMatch(/^#[0-9a-f]{6}$/);
-        },
-      );
-    });
-
-    describe("green shades", () => {
-      const greenShades = COLOR_PALETTE.green;
-      it.each(greenShades.map((color, i) => [color, i]))(
-        "transforms green shade %s (index %d)",
-        (color) => {
-          const result = applyDarkModeFilter(color as string);
-          expect(result).toMatch(/^#[0-9a-f]{6}$/);
-        },
-      );
-    });
-
-    describe("gray shades", () => {
-      const grayShades = COLOR_PALETTE.gray;
-      it.each(grayShades.map((color, i) => [color, i]))(
-        "transforms gray shade %s (index %d)",
-        (color) => {
-          const result = applyDarkModeFilter(color as string);
-          expect(result).toMatch(/^#[0-9a-f]{6}$/);
-        },
-      );
-    });
-
-    describe("bronze shades", () => {
-      const bronzeShades = COLOR_PALETTE.bronze;
-      it.each(bronzeShades.map((color, i) => [color, i]))(
-        "transforms bronze shade %s (index %d)",
-        (color) => {
-          const result = applyDarkModeFilter(color as string);
-          expect(result).toMatch(/^#[0-9a-f]{6}$/);
-        },
-      );
-    });
-
-    // Snapshot test for full palette to catch any regressions
-    it("matches snapshot for all palette colors", () => {
-      const transformedPalette: Record<string, string | string[]> = {};
-
-      transformedPalette.black = applyDarkModeFilter(COLOR_PALETTE.black);
-      transformedPalette.white = applyDarkModeFilter(COLOR_PALETTE.white);
-      transformedPalette.transparent = applyDarkModeFilter(
-        COLOR_PALETTE.transparent,
-      );
-
-      // Transform color arrays
-      for (const colorName of [
-        "gray",
-        "red",
-        "pink",
-        "grape",
-        "violet",
-        "blue",
-        "cyan",
-        "teal",
-        "green",
-        "yellow",
-        "orange",
-        "bronze",
-      ] as const) {
-        const shades = COLOR_PALETTE[colorName];
-        transformedPalette[colorName] = shades.map((shade) =>
-          applyDarkModeFilter(shade),
-        );
-      }
-
-      expect(transformedPalette).toMatchSnapshot();
-    });
-  });
-
-  describe("caching", () => {
-    it("returns same result for same input (cached)", () => {
-      const result1 = applyDarkModeFilter("#ff0000");
-      const result2 = applyDarkModeFilter("#ff0000");
-      expect(result1).toBe(result2);
-    });
-  });
-});
-
-describe("rgbToHex", () => {
-  describe("basic RGB conversion", () => {
-    it("converts black (0,0,0)", () => {
-      expect(rgbToHex(0, 0, 0)).toBe("#000000");
-    });
-
-    it("converts white (255,255,255)", () => {
-      expect(rgbToHex(255, 255, 255)).toBe("#ffffff");
-    });
-
-    it("converts red (255,0,0)", () => {
-      expect(rgbToHex(255, 0, 0)).toBe("#ff0000");
-    });
-
-    it("converts green (0,255,0)", () => {
-      expect(rgbToHex(0, 255, 0)).toBe("#00ff00");
-    });
-
-    it("converts blue (0,0,255)", () => {
-      expect(rgbToHex(0, 0, 255)).toBe("#0000ff");
-    });
-
-    it("converts arbitrary color", () => {
-      expect(rgbToHex(30, 30, 30)).toBe("#1e1e1e");
-    });
-  });
-
-  describe("leading zeros preservation", () => {
-    it("preserves leading zeros for low values", () => {
-      expect(rgbToHex(0, 0, 1)).toBe("#000001");
-      expect(rgbToHex(0, 1, 0)).toBe("#000100");
-      expect(rgbToHex(1, 0, 0)).toBe("#010000");
-    });
-
-    it("preserves zeros for single-digit hex values", () => {
-      expect(rgbToHex(15, 15, 15)).toBe("#0f0f0f");
-    });
-  });
-
-  describe("alpha handling", () => {
-    it("omits alpha when undefined", () => {
-      expect(rgbToHex(255, 0, 0)).toBe("#ff0000");
-      expect(rgbToHex(255, 0, 0, undefined)).toBe("#ff0000");
-    });
-
-    it("omits alpha when fully opaque (1)", () => {
-      expect(rgbToHex(255, 0, 0, 1)).toBe("#ff0000");
-    });
-
-    it("includes alpha for semi-transparent (0.5)", () => {
-      // 0.5 * 255 = 127.5 -> rounds to 128 = 0x80
-      expect(rgbToHex(255, 0, 0, 0.5)).toBe("#ff000080");
-    });
-
-    it("includes alpha for fully transparent (0)", () => {
-      expect(rgbToHex(255, 0, 0, 0)).toBe("#ff000000");
-    });
-
-    it("includes alpha for near-opaque (0.99)", () => {
-      // 0.99 * 255 = 252.45 -> rounds to 252 = 0xfc
-      expect(rgbToHex(255, 0, 0, 0.99)).toBe("#ff0000fc");
-    });
-
-    it("pads alpha with leading zero when needed", () => {
-      // 0.05 * 255 = 12.75 -> rounds to 13 = 0x0d
-      expect(rgbToHex(255, 0, 0, 0.05)).toBe("#ff00000d");
-    });
-  });
-});
@@ -1,121 +1,8 @@
-import tinycolor from "tinycolor2";
+import oc from "open-color";

-import { clamp } from "@excalidraw/math";
-import { degreesToRadians } from "@excalidraw/math";
+import type { Merge } from "./utility-types";

-import type { Degrees } from "@excalidraw/math";
-
-// ---------------------------------------------------------------------------
-// Dark mode color transformation
-// ---------------------------------------------------------------------------
-
-// Browser-only cache to avoid memory leaks on server
-const DARK_MODE_COLORS_CACHE: Map<string, string> | null =
-  typeof window !== "undefined" ? new Map() : null;
-
-function cssHueRotate(
-  red: number,
-  green: number,
-  blue: number,
-  degrees: Degrees,
-): { r: number; g: number; b: number } {
-  // normalize
-  const r = red / 255;
-  const g = green / 255;
-  const b = blue / 255;
-
-  // Convert degrees to radians
-  const a = degreesToRadians(degrees);
-
-  const c = Math.cos(a);
-  const s = Math.sin(a);
-
-  // rotation matrix
-  const matrix = [
-    0.213 + c * 0.787 - s * 0.213,
-    0.715 - c * 0.715 - s * 0.715,
-    0.072 - c * 0.072 + s * 0.928,
-    0.213 - c * 0.213 + s * 0.143,
-    0.715 + c * 0.285 + s * 0.14,
-    0.072 - c * 0.072 - s * 0.283,
-    0.213 - c * 0.213 - s * 0.787,
-    0.715 - c * 0.715 + s * 0.715,
-    0.072 + c * 0.928 + s * 0.072,
-  ];
-
-  // transform
-  const newR = r * matrix[0] + g * matrix[1] + b * matrix[2];
-  const newG = r * matrix[3] + g * matrix[4] + b * matrix[5];
-  const newB = r * matrix[6] + g * matrix[7] + b * matrix[8];
-
-  // clamp the values to [0, 1] range and convert back to [0, 255]
-  return {
-    r: Math.round(Math.max(0, Math.min(1, newR)) * 255),
-    g: Math.round(Math.max(0, Math.min(1, newG)) * 255),
-    b: Math.round(Math.max(0, Math.min(1, newB)) * 255),
-  };
-}
-
-const cssInvert = (
-  r: number,
-  g: number,
-  b: number,
-  percent: number,
-): { r: number; g: number; b: number } => {
-  const p = clamp(percent, 0, 100) / 100;
-
-  // Function to invert a single color component
-  const invertComponent = (color: number): number => {
-    // Apply the invert formula
-    const inverted = color * (1 - p) + (255 - color) * p;
-    // Round to the nearest integer and clamp to [0, 255]
-    return Math.round(clamp(inverted, 0, 255));
-  };
-
-  // Calculate the inverted RGB components
-  const invertedR = invertComponent(r);
-  const invertedG = invertComponent(g);
-  const invertedB = invertComponent(b);
-
-  return { r: invertedR, g: invertedG, b: invertedB };
-};
-
-export const applyDarkModeFilter = (color: string, enable = true): string => {
-  if (!enable) {
-    return color;
-  }
-
-  const cached = DARK_MODE_COLORS_CACHE?.get(color);
-  if (cached) {
-    return cached;
-  }
-
-  const tc = tinycolor(color);
-  const alpha = tc.getAlpha();
-
-  // order of operations matters
-  // (corresponds to "filter: invert(invertPercent) hue-rotate(hueDegrees)" in css)
-  const rgb = tc.toRgb();
-  const inverted = cssInvert(rgb.r, rgb.g, rgb.b, 93);
-  const rotated = cssHueRotate(
-    inverted.r,
-    inverted.g,
-    inverted.b,
-    180 as Degrees,
-  );
-
-  const result = rgbToHex(rotated.r, rotated.g, rotated.b, alpha);
-
-  if (DARK_MODE_COLORS_CACHE) {
-    DARK_MODE_COLORS_CACHE.set(color, result);
-  }
-
-  return result;
-};
-
-// ---------------------------------------------------------------------------
-// Color palette
-// ---------------------------------------------------------------------------
+export const COLOR_OUTLINE_CONTRAST_THRESHOLD = 240;

 // FIXME can't put to utils.ts rn because of circular dependency
 const pick = <R extends Record<string, any>, K extends readonly (keyof R)[]>(
@@ -130,7 +17,15 @@ const pick = <R extends Record<string, any>, K extends readonly (keyof R)[]>(
  }, {} as Pick<R, K[number]>) as Pick<R, K[number]>;
 };

+export type ColorPickerColor =
+  | Exclude<keyof oc, "indigo" | "lime">
+  | "transparent"
+  | "bronze";
 export type ColorTuple = readonly [string, string, string, string, string];
+export type ColorPalette = Merge<
+  Record<ColorPickerColor, ColorTuple>,
+  { black: "#1e1e1e"; white: "#ffffff"; transparent: "transparent" }
+>;

 // used general type instead of specific type (ColorPalette) to support custom colors
 export type ColorPaletteCustom = { [key: string]: ColorTuple | string };
@@ -143,30 +38,38 @@ export const DEFAULT_CHART_COLOR_INDEX = 4;

 export const DEFAULT_ELEMENT_STROKE_COLOR_INDEX = 4;
 export const DEFAULT_ELEMENT_BACKGROUND_COLOR_INDEX = 1;
+export const ELEMENTS_PALETTE_SHADE_INDEXES = [0, 2, 4, 6, 8] as const;
+export const CANVAS_PALETTE_SHADE_INDEXES = [0, 1, 2, 3, 4] as const;
+
+export const getSpecificColorShades = (
+  color: Exclude<
+    ColorPickerColor,
+    "transparent" | "white" | "black" | "bronze"
+  >,
+  indexArr: Readonly<ColorShadesIndexes>,
+) => {
+  return indexArr.map((index) => oc[color][index]) as any as ColorTuple;
+};

 export const COLOR_PALETTE = {
  transparent: "transparent",
  black: "#1e1e1e",
  white: "#ffffff",
-  // open-color from https://github.com/yeun/open-color/blob/master/open-color.js
-  // corresponds to indexes [0,2,4,6,8] (weights: 50, 200, 400, 600, 800)
-  gray: ["#f8f9fa", "#e9ecef", "#ced4da", "#868e96", "#343a40"],
-  red: ["#fff5f5", "#ffc9c9", "#ff8787", "#fa5252", "#e03131"],
-  pink: ["#fff0f6", "#fcc2d7", "#f783ac", "#e64980", "#c2255c"],
-  grape: ["#f8f0fc", "#eebefa", "#da77f2", "#be4bdb", "#9c36b5"],
-  violet: ["#f3f0ff", "#d0bfff", "#9775fa", "#7950f2", "#6741d9"],
-  blue: ["#e7f5ff", "#a5d8ff", "#4dabf7", "#228be6", "#1971c2"],
-  cyan: ["#e3fafc", "#99e9f2", "#3bc9db", "#15aabf", "#0c8599"],
-  teal: ["#e6fcf5", "#96f2d7", "#38d9a9", "#12b886", "#099268"],
-  green: ["#ebfbee", "#b2f2bb", "#69db7c", "#40c057", "#2f9e44"],
-  yellow: ["#fff9db", "#ffec99", "#ffd43b", "#fab005", "#f08c00"],
-  orange: ["#fff4e6", "#ffd8a8", "#ffa94d", "#fd7e14", "#e8590c"],
-  // radix bronze shades [3,5,7,9,11]
+  // open-colors
+  gray: getSpecificColorShades("gray", ELEMENTS_PALETTE_SHADE_INDEXES),
+  red: getSpecificColorShades("red", ELEMENTS_PALETTE_SHADE_INDEXES),
+  pink: getSpecificColorShades("pink", ELEMENTS_PALETTE_SHADE_INDEXES),
+  grape: getSpecificColorShades("grape", ELEMENTS_PALETTE_SHADE_INDEXES),
+  violet: getSpecificColorShades("violet", ELEMENTS_PALETTE_SHADE_INDEXES),
+  blue: getSpecificColorShades("blue", ELEMENTS_PALETTE_SHADE_INDEXES),
+  cyan: getSpecificColorShades("cyan", ELEMENTS_PALETTE_SHADE_INDEXES),
+  teal: getSpecificColorShades("teal", ELEMENTS_PALETTE_SHADE_INDEXES),
+  green: getSpecificColorShades("green", ELEMENTS_PALETTE_SHADE_INDEXES),
+  yellow: getSpecificColorShades("yellow", ELEMENTS_PALETTE_SHADE_INDEXES),
+  orange: getSpecificColorShades("orange", ELEMENTS_PALETTE_SHADE_INDEXES),
+  // radix bronze shades 3,5,7,9,11
  bronze: ["#f8f1ee", "#eaddd7", "#d2bab0", "#a18072", "#846358"],
-} as const;
-
-export type ColorPalette = typeof COLOR_PALETTE;
-export type ColorPickerColor = keyof typeof COLOR_PALETTE;
+} as ColorPalette;

 const COMMON_ELEMENT_SHADES = pick(COLOR_PALETTE, [
  "cyan",
@@ -181,6 +84,7 @@ const COMMON_ELEMENT_SHADES = pick(COLOR_PALETTE, [
  "red",
 ]);

+// -----------------------------------------------------------------------------
 // quick picks defaults
 // -----------------------------------------------------------------------------

@@ -215,6 +119,7 @@ export const DEFAULT_CANVAS_BACKGROUND_PICKS = [
  "#fdf8f6",
 ] as ColorTuple;

+// -----------------------------------------------------------------------------
 // palette defaults
 // -----------------------------------------------------------------------------

@@ -240,120 +145,29 @@ export const DEFAULT_ELEMENT_BACKGROUND_COLOR_PALETTE = {
  ...COMMON_ELEMENT_SHADES,
 } as const;

-// color palette helpers
+// -----------------------------------------------------------------------------
+// helpers
 // -----------------------------------------------------------------------------

 // !!!MUST BE WITHOUT GRAY, TRANSPARENT AND BLACK!!!
-export const getAllColorsSpecificShade = (index: 0 | 1 | 2 | 3 | 4) => [
-  // 2nd row
-  COLOR_PALETTE.cyan[index],
-  COLOR_PALETTE.blue[index],
-  COLOR_PALETTE.violet[index],
-  COLOR_PALETTE.grape[index],
-  COLOR_PALETTE.pink[index],
+export const getAllColorsSpecificShade = (index: 0 | 1 | 2 | 3 | 4) =>
+  [
+    // 2nd row
+    COLOR_PALETTE.cyan[index],
+    COLOR_PALETTE.blue[index],
+    COLOR_PALETTE.violet[index],
+    COLOR_PALETTE.grape[index],
+    COLOR_PALETTE.pink[index],

-  // 3rd row
-  COLOR_PALETTE.green[index],
-  COLOR_PALETTE.teal[index],
-  COLOR_PALETTE.yellow[index],
-  COLOR_PALETTE.orange[index],
-  COLOR_PALETTE.red[index],
-];
+    // 3rd row
+    COLOR_PALETTE.green[index],
+    COLOR_PALETTE.teal[index],
+    COLOR_PALETTE.yellow[index],
+    COLOR_PALETTE.orange[index],
+    COLOR_PALETTE.red[index],
+  ] as const;
+
+export const rgbToHex = (r: number, g: number, b: number) =>
+  `#${((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1)}`;

 // -----------------------------------------------------------------------------
-// other helpers
-// -----------------------------------------------------------------------------
-
-export const rgbToHex = (r: number, g: number, b: number, a?: number) => {
-  // (1 << 24) adds 0x1000000 to ensure the hex string is always 7 chars,
-  // then slice(1) removes the leading "1" to get exactly 6 hex digits
-  // e.g. rgb(0,0,0) -> 0x1000000 -> "1000000" -> "000000"
-  const hex6 = `#${((1 << 24) + (r << 16) + (g << 8) + b)
-    .toString(16)
-    .slice(1)}`;
-  if (a !== undefined && a < 1) {
-    // convert alpha from 0-1 float to 0-255 int, then to 2-digit hex
-    // e.g. 0.5 -> 128 -> "80"
-    const alphaHex = Math.round(a * 255)
-      .toString(16)
-      .padStart(2, "0");
-    return `${hex6}${alphaHex}`;
-  }
-  return hex6;
-};
-
-/**
- * @returns #RRGGBB or #RRGGBBAA based on color containing non-opaque alpha,
- *  null if not valid color
- */
-export const colorToHex = (color: string): string | null => {
-  const tc = tinycolor(color);
-  if (!tc.isValid()) {
-    return null;
-  }
-  const { r, g, b, a } = tc.toRgb();
-  return rgbToHex(r, g, b, a);
-};
-
-export const isTransparent = (color: string) => {
-  return tinycolor(color).getAlpha() === 0;
-};
-
-// -----------------------------------------------------------------------------
-// color contract helpers
-// -----------------------------------------------------------------------------
-
-export const COLOR_OUTLINE_CONTRAST_THRESHOLD = 240;
-
-const calculateContrast = (r: number, g: number, b: number): number => {
-  const yiq = (r * 299 + g * 587 + b * 114) / 1000;
-  return yiq;
-};
-
-// YIQ algo, inspiration from https://stackoverflow.com/a/11868398
-export const isColorDark = (color: string, threshold = 160): boolean => {
-  // no color ("") -> assume it default to black
-  if (!color) {
-    return true;
-  }
-
-  if (isTransparent(color)) {
-    return false;
-  }
-
-  const tc = tinycolor(color);
-  if (!tc.isValid()) {
-    // invalid color -> assume it defaults to black
-    return true;
-  }
-
-  const { r, g, b } = tc.toRgb();
-  return calculateContrast(r, g, b) < threshold;
-};
-
-// -----------------------------------------------------------------------------
-// normalization
-// -----------------------------------------------------------------------------
-
-/**
- * tries to keep the input color as-is if it's valid, making minimal adjustments
- * (trimming whitespace or adding `#` to hex colors)
- */
-export const normalizeInputColor = (color: string): string | null => {
-  color = color.trim();
-  if (isTransparent(color)) {
-    return color;
-  }
-
-  const tc = tinycolor(color);
-  if (tc.isValid()) {
-    // testing for `#` first fixes a bug on Electron (more specfically, an
-    // Obsidian popout window), where a hex color without `#` is considered valid
-    if (["hex", "hex8"].includes(tc.getFormat()) && !color.startsWith("#")) {
-      return `#${color}`;
-    }
-    return color;
-  }
-
-  return null;
-};
@@ -6,6 +6,25 @@ import type { AppProps, AppState } from "@excalidraw/excalidraw/types";

 import { COLOR_PALETTE } from "./colors";

+export const isDarwin = /Mac|iPod|iPhone|iPad/.test(navigator.platform);
+export const isWindows = /^Win/.test(navigator.platform);
+export const isAndroid = /\b(android)\b/i.test(navigator.userAgent);
+export const isFirefox =
+  typeof window !== "undefined" &&
+  "netscape" in window &&
+  navigator.userAgent.indexOf("rv:") > 1 &&
+  navigator.userAgent.indexOf("Gecko") > 1;
+export const isChrome = navigator.userAgent.indexOf("Chrome") !== -1;
+export const isSafari =
+  !isChrome && navigator.userAgent.indexOf("Safari") !== -1;
+export const isIOS =
+  /iPad|iPhone/.test(navigator.platform) ||
+  // iPadOS 13+
+  (navigator.userAgent.includes("Mac") && "ontouchend" in document);
+// keeping function so it can be mocked in test
+export const isBrave = () =>
+  (navigator as any).brave?.isBrave?.name === "isBrave";
+
 export const supportsResizeObserver =
  typeof window !== "undefined" && "ResizeObserver" in window;

@@ -99,23 +118,12 @@ export const ENV = {
 };

 export const CLASSES = {
-  SIDEBAR: "sidebar",
  SHAPE_ACTIONS_MENU: "App-menu__left",
  ZOOM_ACTIONS: "zoom-actions",
  SEARCH_MENU_INPUT_WRAPPER: "layer-ui__search-inputWrapper",
  CONVERT_ELEMENT_TYPE_POPUP: "ConvertElementTypePopup",
-  SHAPE_ACTIONS_THEME_SCOPE: "shape-actions-theme-scope",
-  FRAME_NAME: "frame-name",
-  DROPDOWN_MENU_EVENT_WRAPPER: "dropdown-menu-event-wrapper",
 };

-export const FONT_SIZES = {
-  sm: 16,
-  md: 20,
-  lg: 28,
-  xl: 36,
-} as const;
-
 export const CJK_HAND_DRAWN_FALLBACK_FONT = "Xiaolai";
 export const WINDOWS_EMOJI_FALLBACK_FONT = "Segoe UI Emoji";

@@ -191,8 +199,6 @@ export const THEME = {
  DARK: "dark",
 } as const;

-export const DARK_THEME_FILTER = "invert(93%) hue-rotate(180deg)";
-
 export const FRAME_STYLE = {
  strokeColor: "#bbb" as ExcalidrawElement["strokeColor"],
  strokeWidth: 2 as ExcalidrawElement["strokeWidth"],
@@ -246,21 +252,13 @@ export const IMAGE_MIME_TYPES = {
  jfif: "image/jfif",
 } as const;

-export const STRING_MIME_TYPES = {
+export const MIME_TYPES = {
  text: "text/plain",
  html: "text/html",
  json: "application/json",
  // excalidraw data
  excalidraw: "application/vnd.excalidraw+json",
-  excalidrawClipboard: "application/vnd.excalidraw.clipboard+json",
-  // LEGACY: fully-qualified library JSON data
  excalidrawlib: "application/vnd.excalidrawlib+json",
-  // list of excalidraw library item ids
-  excalidrawlibIds: "application/vnd.excalidrawlib.ids+json",
-} as const;
-
-export const MIME_TYPES = {
-  ...STRING_MIME_TYPES,
  // image-encoded excalidraw data
  "excalidraw.svg": "image/svg+xml",
  "excalidraw.png": "image/png",
@@ -309,6 +307,9 @@ export const IDLE_THRESHOLD = 60_000;
 // Report a user active each ACTIVE_THRESHOLD milliseconds
 export const ACTIVE_THRESHOLD = 3_000;

+// duplicates --theme-filter, should be removed soon
+export const THEME_FILTER = "invert(93%) hue-rotate(180deg)";
+
 export const URL_QUERY_KEYS = {
  addLibrary: "addLibrary",
 } as const;
@@ -332,15 +333,24 @@ export const DEFAULT_UI_OPTIONS: AppProps["UIOptions"] = {
  },
 };

+// breakpoints
+// -----------------------------------------------------------------------------
+// md screen
+export const MQ_MAX_WIDTH_PORTRAIT = 730;
+export const MQ_MAX_WIDTH_LANDSCAPE = 1000;
+export const MQ_MAX_HEIGHT_LANDSCAPE = 500;
+// sidebar
+export const MQ_RIGHT_SIDEBAR_MIN_WIDTH = 1229;
+// -----------------------------------------------------------------------------
+
 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"?>
@@ -404,47 +414,11 @@ export const ROUGHNESS = {
  cartoonist: 2,
 } as const;

-export type StrokeWidthKey = "thin" | "medium" | "bold";
-
-export const STROKE_WIDTH_KEYS: readonly StrokeWidthKey[] = [
-  "thin",
-  "medium",
-  "bold",
-];
-
-export const STROKE_WIDTH: Readonly<
-  Record<StrokeWidthKey | "extraBold", ExcalidrawElement["strokeWidth"]>
-> = {
+export const STROKE_WIDTH = {
  thin: 1,
-  medium: 2,
-  bold: 4,
-  extraBold: 8, // unused (may be introduced in the future)
-};
-
-// freedraw schema 2.0 uses thinner stroke, but to maintain backwards and
-// forwards compatibility, instead of changing the shape renderer, we scale
-// the stroke width by 1/2 (previous, thin was 1, medium 2 etc.)
-//
-// note that in the UI, STROKE_WIDTH.thin == FREEDRAW_STROKE_WIDTH.thin still
-export const FREEDRAW_STROKE_WIDTH: Readonly<
-  Record<StrokeWidthKey | "extraBold", ExcalidrawElement["strokeWidth"]>
-> = {
-  thin: 0.5,
-  medium: 1,
  bold: 2,
-  extraBold: 4, // legacy (may be used again in the future)
-};
-
-export const getStrokeWidthByKey = (
-  elementType: ExcalidrawElement["type"],
-  strokeWidthKey: StrokeWidthKey,
-): ExcalidrawElement["strokeWidth"] => {
-  return elementType === "freedraw"
-    ? FREEDRAW_STROKE_WIDTH[strokeWidthKey]
-    : STROKE_WIDTH[strokeWidthKey];
-};
-
-export const DEFAULT_ELEMENT_STROKE_WIDTH_KEY: StrokeWidthKey = "medium";
+  extraBold: 4,
+} as const;

 export const DEFAULT_ELEMENT_PROPS: {
  strokeColor: ExcalidrawElement["strokeColor"];
@@ -459,7 +433,7 @@ export const DEFAULT_ELEMENT_PROPS: {
  strokeColor: COLOR_PALETTE.black,
  backgroundColor: COLOR_PALETTE.transparent,
  fillStyle: "solid",
-  strokeWidth: STROKE_WIDTH[DEFAULT_ELEMENT_STROKE_WIDTH_KEY],
+  strokeWidth: 2,
  strokeStyle: "solid",
  roughness: ROUGHNESS.artist,
  opacity: 100,
@@ -541,15 +515,3 @@ export enum UserIdleState {
 * the start and end points)
 */
 export const LINE_POLYGON_POINT_MERGE_DISTANCE = 20;
-
-export const DOUBLE_TAP_POSITION_THRESHOLD = 35;
-
-export const BIND_MODE_TIMEOUT = 700; // ms
-
-// glass background for mobile action buttons
-export const MOBILE_ACTION_BUTTON_BG = {
-  background: "var(--mobile-action-button-bg)",
-} as const;
-
-export const DEFAULT_STROKE_STREAMLINE = 0.5;
-export const DEFAULT_STROKE_STREAMLINE_PRECISE = 0.2;
@@ -1,222 +0,0 @@
-export type StylesPanelMode = "compact" | "full" | "mobile";
-
-export type EditorInterface = Readonly<{
-  formFactor: "phone" | "tablet" | "desktop";
-  desktopUIMode: "compact" | "full";
-  userAgent: Readonly<{
-    isMobileDevice: boolean;
-    platform: "ios" | "android" | "other" | "unknown";
-  }>;
-  isTouchScreen: boolean;
-  canFitSidebar: boolean;
-  isLandscape: boolean;
-}>;
-
-// storage key
-const DESKTOP_UI_MODE_STORAGE_KEY = "excalidraw.desktopUIMode";
-
-// breakpoints
-export const MQ_MAX_MOBILE = 599;
-
-export const MQ_MAX_WIDTH_LANDSCAPE = 1000;
-export const MQ_MAX_HEIGHT_LANDSCAPE = 500;
-
-// tablets
-export const MQ_MIN_TABLET = MQ_MAX_MOBILE + 1; // lower bound (excludes phones)
-export const MQ_MAX_TABLET = 1180; // ipad air
-
-// desktop/laptop (NOTE: not used for form factor detection)
-export const MQ_MIN_WIDTH_DESKTOP = 1440;
-
-// sidebar
-export const MQ_RIGHT_SIDEBAR_MIN_WIDTH = 1229;
-
-// -----------------------------------------------------------------------------
-
-// user agent detections
-export const isDarwin = /Mac|iPod|iPhone|iPad/.test(navigator.platform);
-export const isWindows = /^Win/.test(navigator.platform);
-export const isAndroid = /\b(android)\b/i.test(navigator.userAgent);
-export const isFirefox =
-  typeof window !== "undefined" &&
-  "netscape" in window &&
-  navigator.userAgent.indexOf("rv:") > 1 &&
-  navigator.userAgent.indexOf("Gecko") > 1;
-export const isChrome = navigator.userAgent.indexOf("Chrome") !== -1;
-export const isSafari =
-  !isChrome && navigator.userAgent.indexOf("Safari") !== -1;
-export const isIOS =
-  /iPad|iPhone/i.test(navigator.platform) ||
-  // iPadOS 13+
-  (navigator.userAgent.includes("Mac") && "ontouchend" in document);
-// keeping function so it can be mocked in test
-export const isBrave = () =>
-  (navigator as any).brave?.isBrave?.name === "isBrave";
-
-// export const isMobile =
-//   isIOS ||
-//   /android|webos|ipod|blackberry|iemobile|opera mini/i.test(
-//     navigator.userAgent,
-//   ) ||
-//   /android|ios|ipod|blackberry|windows phone/i.test(navigator.platform);
-
-// utilities
-export const isMobileBreakpoint = (width: number, height: number) => {
-  return (
-    width <= MQ_MAX_MOBILE ||
-    (height < MQ_MAX_HEIGHT_LANDSCAPE && width < MQ_MAX_WIDTH_LANDSCAPE)
-  );
-};
-
-export const isTabletBreakpoint = (
-  editorWidth: number,
-  editorHeight: number,
-) => {
-  const minSide = Math.min(editorWidth, editorHeight);
-  const maxSide = Math.max(editorWidth, editorHeight);
-
-  return minSide >= MQ_MIN_TABLET && maxSide <= MQ_MAX_TABLET;
-};
-
-const isMobileOrTablet = (): boolean => {
-  const ua = navigator.userAgent || "";
-  const platform = navigator.platform || "";
-  const uaData = (navigator as any).userAgentData as
-    | { mobile?: boolean; platform?: string }
-    | undefined;
-
-  // --- 1) chromium: prefer ua client hints -------------------------------
-  if (uaData) {
-    const plat = (uaData.platform || "").toLowerCase();
-    const isDesktopOS =
-      plat === "windows" ||
-      plat === "macos" ||
-      plat === "linux" ||
-      plat === "chrome os";
-    if (uaData.mobile === true) {
-      return true;
-    }
-    if (uaData.mobile === false && plat === "android") {
-      const looksTouchTablet =
-        matchMedia?.("(hover: none)").matches &&
-        matchMedia?.("(pointer: coarse)").matches;
-      return looksTouchTablet;
-    }
-    if (isDesktopOS) {
-      return false;
-    }
-  }
-
-  // --- 2) ios (includes ipad) --------------------------------------------
-  if (isIOS) {
-    return true;
-  }
-
-  // --- 3) android legacy ua fallback -------------------------------------
-  if (isAndroid) {
-    const isAndroidPhone = /Mobile/i.test(ua);
-    const isAndroidTablet = !isAndroidPhone;
-    if (isAndroidPhone || isAndroidTablet) {
-      const looksTouchTablet =
-        matchMedia?.("(hover: none)").matches &&
-        matchMedia?.("(pointer: coarse)").matches;
-      return looksTouchTablet;
-    }
-  }
-
-  // --- 4) last resort desktop exclusion ----------------------------------
-  const looksDesktopPlatform =
-    /Win|Linux|CrOS|Mac/.test(platform) ||
-    /Windows NT|X11|CrOS|Macintosh/.test(ua);
-  if (looksDesktopPlatform) {
-    return false;
-  }
-  return false;
-};
-
-export const getFormFactor = (
-  editorWidth: number,
-  editorHeight: number,
-): EditorInterface["formFactor"] => {
-  if (isMobileBreakpoint(editorWidth, editorHeight)) {
-    return "phone";
-  }
-
-  if (isTabletBreakpoint(editorWidth, editorHeight)) {
-    return "tablet";
-  }
-
-  return "desktop";
-};
-
-export const deriveStylesPanelMode = (
-  editorInterface: EditorInterface,
-): StylesPanelMode => {
-  if (editorInterface.formFactor === "phone") {
-    return "mobile";
-  }
-
-  if (editorInterface.formFactor === "tablet") {
-    return "compact";
-  }
-
-  return editorInterface.desktopUIMode;
-};
-
-export const createUserAgentDescriptor = (
-  userAgentString: string,
-): EditorInterface["userAgent"] => {
-  const normalizedUA = userAgentString ?? "";
-  let platform: EditorInterface["userAgent"]["platform"] = "unknown";
-
-  if (isIOS) {
-    platform = "ios";
-  } else if (isAndroid) {
-    platform = "android";
-  } else if (normalizedUA) {
-    platform = "other";
-  }
-
-  return {
-    isMobileDevice: isMobileOrTablet(),
-    platform,
-  } as const;
-};
-
-export const loadDesktopUIModePreference = () => {
-  if (typeof window === "undefined") {
-    return null;
-  }
-
-  try {
-    const stored = window.localStorage.getItem(DESKTOP_UI_MODE_STORAGE_KEY);
-    if (stored === "compact" || stored === "full") {
-      return stored as EditorInterface["desktopUIMode"];
-    }
-  } catch (error) {
-    // ignore storage access issues (e.g., Safari private mode)
-  }
-
-  return null;
-};
-
-const persistDesktopUIMode = (mode: EditorInterface["desktopUIMode"]) => {
-  if (typeof window === "undefined") {
-    return;
-  }
-  try {
-    window.localStorage.setItem(DESKTOP_UI_MODE_STORAGE_KEY, mode);
-  } catch (error) {
-    // ignore storage access issues (e.g., Safari private mode)
-  }
-};
-
-export const setDesktopUIMode = (mode: EditorInterface["desktopUIMode"]) => {
-  if (mode !== "compact" && mode !== "full") {
-    return;
-  }
-
-  persistDesktopUIMode(mode);
-
-  return mode;
-};
@@ -1,5 +1,4 @@
 export * from "./binary-heap";
-export * from "./bounds";
 export * from "./colors";
 export * from "./constants";
 export * from "./font-metadata";
@@ -11,7 +10,3 @@ export * from "./random";
 export * from "./url";
 export * from "./utils";
 export * from "./emitter";
-export * from "./appEventBus";
-export * from "./editorInterface";
-export * from "./versionedSnapshotStore";
-export { Debug } from "../debug";
@@ -1,4 +1,4 @@
-import { isDarwin } from "./editorInterface";
+import { isDarwin } from "./constants";

 import type { ValueOf } from "./utility-types";

@@ -3,12 +3,6 @@ import {
  mapFind,
  reduceToCommonValue,
 } from "@excalidraw/common";
-import { vi } from "vitest";
-
-// Import directly to avoid the @excalidraw/common throttleRAF mock from setupTests.ts.
-import { throttleRAF } from "./utils";
-
-type RafCallback = FrameRequestCallback;

 describe("@excalidraw/common/utils", () => {
  describe("isTransparent()", () => {
@@ -85,87 +79,4 @@ describe("@excalidraw/common/utils", () => {
      expect(mapFind([1, 2], () => null)).toBe(undefined);
    });
  });
-
-  describe("throttleRAF()", () => {
-    let frameCallbacks: Map<number, RafCallback>;
-    let nextFrameId: number;
-
-    const runScheduledFrame = (timestamp = 16) => {
-      const callbacks = [...frameCallbacks.values()];
-      frameCallbacks.clear();
-      callbacks.forEach((callback) => callback(timestamp));
-    };
-
-    beforeEach(() => {
-      frameCallbacks = new Map();
-      nextFrameId = 0;
-
-      vi.spyOn(window, "requestAnimationFrame").mockImplementation(
-        (callback) => {
-          const frameId = ++nextFrameId;
-          frameCallbacks.set(frameId, callback);
-          return frameId;
-        },
-      );
-
-      vi.spyOn(window, "cancelAnimationFrame").mockImplementation((frameId) => {
-        frameCallbacks.delete(frameId);
-      });
-    });
-
-    afterEach(() => {
-      vi.restoreAllMocks();
-    });
-
-    it("should invoke the callback with the last args from the same frame", () => {
-      const fn = vi.fn();
-      const throttled = throttleRAF(fn);
-
-      throttled("first", 1);
-      throttled("second", 2);
-      throttled("last", 3);
-
-      expect(fn).not.toHaveBeenCalled();
-      expect(window.requestAnimationFrame).toHaveBeenCalledTimes(1);
-
-      runScheduledFrame();
-
-      expect(fn).toHaveBeenCalledTimes(1);
-      expect(fn).toHaveBeenCalledWith("last", 3);
-    });
-
-    it("should flush the pending callback immediately", () => {
-      const fn = vi.fn();
-      const throttled = throttleRAF(fn);
-
-      throttled("first");
-      throttled("last");
-
-      throttled.flush();
-
-      expect(window.cancelAnimationFrame).toHaveBeenCalledTimes(1);
-      expect(fn).toHaveBeenCalledTimes(1);
-      expect(fn).toHaveBeenCalledWith("last");
-
-      runScheduledFrame();
-
-      expect(fn).toHaveBeenCalledTimes(1);
-    });
-
-    it("should cancel the pending callback", () => {
-      const fn = vi.fn();
-      const throttled = throttleRAF(fn);
-
-      throttled("first");
-      throttled("last");
-
-      throttled.cancel();
-
-      expect(window.cancelAnimationFrame).toHaveBeenCalledTimes(1);
-
-      runScheduledFrame();
-
-      expect(fn).not.toHaveBeenCalled();
-    });
-  });
 });
@@ -1,8 +1,10 @@
 import { average } from "@excalidraw/math";

-import type { GlobalCoord } from "@excalidraw/math";
-
-import type { FontFamilyValues, FontString } from "@excalidraw/element/types";
+import type {
+  ExcalidrawBindableElement,
+  FontFamilyValues,
+  FontString,
+} from "@excalidraw/element/types";

 import type {
  ActiveTool,
@@ -12,11 +14,13 @@ import type {
  Zoom,
 } from "@excalidraw/excalidraw/types";

+import { COLOR_PALETTE } from "./colors";
 import {
  DEFAULT_VERSION,
  ENV,
  FONT_FAMILY,
  getFontFamilyFallbacks,
+  isDarwin,
  WINDOWS_EMOJI_FALLBACK_FONT,
 } from "./constants";

@@ -87,9 +91,7 @@ export const isWritableElement = (
  (target instanceof HTMLInputElement &&
    (target.type === "text" ||
      target.type === "number" ||
-      target.type === "password" ||
-      target.type === "search")) ||
-  (target instanceof HTMLElement && target.closest(".cm-editor") !== null);
+      target.type === "password"));

 export const getFontFamilyString = ({
  fontFamily,
@@ -117,11 +119,6 @@ export const getFontString = ({
  return `${fontSize}px ${getFontFamilyString({ fontFamily })}` as FontString;
 };

-/** executes callback in the frame that's after the current one */
-export const nextAnimationFrame = async (cb: () => any) => {
-  requestAnimationFrame(() => requestAnimationFrame(cb));
-};
-
 export const debounce = <T extends any[]>(
  fn: (...args: T) => void,
  timeout: number,
@@ -151,27 +148,38 @@ export const debounce = <T extends any[]>(
  return ret;
 };

-// throttle callback to execute once per animation frame using the latest args
-export const throttleRAF = <T extends any[]>(fn: (...args: T) => void) => {
+// throttle callback to execute once per animation frame
+export const throttleRAF = <T extends any[]>(
+  fn: (...args: T) => void,
+  opts?: { trailing?: boolean },
+) => {
  let timerId: number | null = null;
  let lastArgs: T | null = null;
+  let lastArgsTrailing: T | null = null;

-  const scheduleFunc = () => {
+  const scheduleFunc = (args: T) => {
    timerId = window.requestAnimationFrame(() => {
      timerId = null;
-      const args = lastArgs;
+      fn(...args);
      lastArgs = null;
-
-      if (args) {
-        fn(...args);
+      if (lastArgsTrailing) {
+        lastArgs = lastArgsTrailing;
+        lastArgsTrailing = null;
+        scheduleFunc(lastArgs);
      }
    });
  };

  const ret = (...args: T) => {
+    if (isTestEnv()) {
+      fn(...args);
+      return;
+    }
    lastArgs = args;
    if (timerId === null) {
-      scheduleFunc();
+      scheduleFunc(lastArgs);
+    } else if (opts?.trailing) {
+      lastArgsTrailing = args;
    }
  };
  ret.flush = () => {
@@ -180,12 +188,12 @@ export const throttleRAF = <T extends any[]>(fn: (...args: T) => void) => {
      timerId = null;
    }
    if (lastArgs) {
-      fn(...lastArgs);
-      lastArgs = null;
+      fn(...(lastArgsTrailing || lastArgs));
+      lastArgs = lastArgsTrailing = null;
    }
  };
  ret.cancel = () => {
-    lastArgs = null;
+    lastArgs = lastArgsTrailing = null;
    if (timerId !== null) {
      cancelAnimationFrame(timerId);
      timerId = null;
@@ -369,10 +377,6 @@ export const removeSelection = () => {

 export const distance = (x: number, y: number) => Math.abs(x - y);

-export const isSelectionLikeTool = (type: ToolType | "custom") => {
-  return type === "selection" || type === "lasso";
-};
-
 export const updateActiveTool = (
  appState: Pick<AppState, "activeTool">,
  data: ((
@@ -414,6 +418,19 @@ export const allowFullScreen = () =>

 export const exitFullScreen = () => document.exitFullscreen();

+export const getShortcutKey = (shortcut: string): string => {
+  shortcut = shortcut
+    .replace(/\bAlt\b/i, "Alt")
+    .replace(/\bShift\b/i, "Shift")
+    .replace(/\b(Enter|Return)\b/i, "Enter");
+  if (isDarwin) {
+    return shortcut
+      .replace(/\bCtrlOrCmd\b/gi, "Cmd")
+      .replace(/\bAlt\b/i, "Option");
+  }
+  return shortcut.replace(/\bCtrlOrCmd\b/gi, "Ctrl");
+};
+
 export const viewportCoordsToSceneCoords = (
  { clientX, clientY }: { clientX: number; clientY: number },
  {
@@ -433,7 +450,7 @@ export const viewportCoordsToSceneCoords = (
  const x = (clientX - offsetLeft) / zoom.value - scrollX;
  const y = (clientY - offsetTop) / zoom.value - scrollY;

-  return { x, y } as GlobalCoord;
+  return { x, y };
 };

 export const sceneCoordsToViewportCoords = (
@@ -539,6 +556,19 @@ export const mapFind = <T, K>(
  return undefined;
 };

+export const isTransparent = (color: string) => {
+  const isRGBTransparent = color.length === 5 && color.substr(4, 1) === "0";
+  const isRRGGBBTransparent = color.length === 9 && color.substr(7, 2) === "00";
+  return (
+    isRGBTransparent ||
+    isRRGGBBTransparent ||
+    color === COLOR_PALETTE.transparent
+  );
+};
+
+export const isBindingFallthroughEnabled = (el: ExcalidrawBindableElement) =>
+  el.fillStyle !== "solid" || isTransparent(el.backgroundColor);
+
 export type ResolvablePromise<T> = Promise<T> & {
  resolve: [T] extends [undefined]
    ? (value?: MaybePromise<Awaited<T>>) => void
@@ -1138,69 +1168,39 @@ export const normalizeEOL = (str: string) => {
 };

 // -----------------------------------------------------------------------------
-export type HasBrand<T> = {
+type HasBrand<T> = {
  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  [K in keyof T]: K extends `~brand${infer _}` | "_brand" ? true : never;
+  [K in keyof T]: K extends `~brand${infer _}` ? true : never;
 }[keyof T];

 type RemoveAllBrands<T> = HasBrand<T> extends true
  ? {
      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      [K in keyof T as K extends `~brand~${infer _}` | "_brand"
-        ? never
-        : K]: T[K];
+      [K in keyof T as K extends `~brand~${infer _}` ? never : K]: T[K];
    }
-  : T;
+  : never;

-// For accepting values - uses loose matching for branded types
-// Preserves readonly modifier: mutable array requires mutable input
-type UnbrandForValue<T> = T extends Map<infer E, infer F>
-  ? Map<UnbrandForValue<E>, UnbrandForValue<F>>
+// adapted from https://github.com/colinhacks/zod/discussions/1994#discussioncomment-6068940
+// currently does not cover all types (e.g. tuples, promises...)
+type Unbrand<T> = T extends Map<infer E, infer F>
+  ? Map<E, F>
  : T extends Set<infer E>
-  ? Set<UnbrandForValue<E>>
-  : T extends readonly any[]
-  ? T extends any[]
-    ? unknown[] // mutable array - require mutable input
-    : readonly unknown[] // readonly array - accept readonly input
+  ? Set<E>
+  : T extends Array<infer E>
+  ? Array<E>
  : RemoveAllBrands<T>;

-// For return types - preserves array element unbranding
-export type Unbrand<T> = T extends Map<infer E, infer F>
-  ? Map<Unbrand<E>, Unbrand<F>>
-  : T extends Set<infer E>
-  ? Set<Unbrand<E>>
-  : T extends readonly (infer E)[]
-  ? Array<Unbrand<E>>
-  : RemoveAllBrands<T>;
-
-export type CombineBrands<BrandedType, CurrentType> =
-  BrandedType extends readonly (infer BE)[]
-    ? CurrentType extends readonly (infer CE)[]
-      ? Array<CE & BE>
-      : CurrentType & BrandedType
-    : CurrentType & BrandedType;
-
-export type CombineBrandsIfNeeded<T, Required> = [T] extends [Required]
-  ? T[]
-  : HasBrand<T> extends true
-  ? CombineBrands<T, Required>[]
-  : Required[];
-
 /**
 * Makes type into a branded type, ensuring that value is assignable to
- * the base unbranded type. Optionally you can explicitly supply current value
+ * the base ubranded type. Optionally you can explicitly supply current value
 * type to combine both (useful for composite branded types. Make sure you
 * compose branded types which are not composite themselves.)
 */
-export function toBrandedType<BrandedType>(
-  value: UnbrandForValue<BrandedType>,
-): BrandedType;
-export function toBrandedType<BrandedType, CurrentType>(
-  value: CurrentType,
-): CombineBrands<BrandedType, CurrentType>;
-export function toBrandedType(value: unknown) {
-  return value;
-}
+export const toBrandedType = <BrandedType, CurrentType = BrandedType>(
+  value: Unbrand<BrandedType>,
+) => {
+  return value as CurrentType & BrandedType;
+};

 // -----------------------------------------------------------------------------

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

  return commonValue;
 };
-
-type FEATURE_FLAGS = {
-  COMPLEX_BINDINGS: boolean;
-};
-
-const FEATURE_FLAGS_STORAGE_KEY = "excalidraw-feature-flags";
-const DEFAULT_FEATURE_FLAGS: FEATURE_FLAGS = {
-  COMPLEX_BINDINGS: false,
-};
-let featureFlags: FEATURE_FLAGS | null = null;
-
-export const getFeatureFlag = <F extends keyof FEATURE_FLAGS>(
-  flag: F,
-): FEATURE_FLAGS[F] => {
-  if (!featureFlags) {
-    try {
-      const serializedFlags = localStorage.getItem(FEATURE_FLAGS_STORAGE_KEY);
-      if (serializedFlags) {
-        const flags = JSON.parse(serializedFlags);
-        featureFlags = flags ?? DEFAULT_FEATURE_FLAGS;
-      }
-    } catch {}
-  }
-
-  return (featureFlags || DEFAULT_FEATURE_FLAGS)[flag];
-};
-
-export const setFeatureFlag = <F extends keyof FEATURE_FLAGS>(
-  flag: F,
-  value: FEATURE_FLAGS[F],
-) => {
-  try {
-    featureFlags = {
-      ...(featureFlags || DEFAULT_FEATURE_FLAGS),
-      [flag]: value,
-    };
-    localStorage.setItem(
-      FEATURE_FLAGS_STORAGE_KEY,
-      JSON.stringify(featureFlags),
-    );
-  } catch (e) {
-    console.error("unable to set feature flag", e);
-  }
-};
-
-export const oneOf = <N extends string | number | symbol | null, H extends N>(
-  needle: N,
-  haystack: readonly H[],
-): needle is H => {
-  return haystack.includes(needle as any);
-};
@@ -1,70 +0,0 @@
-export type VersionedSnapshot<T> = Readonly<{
-  version: number;
-  value: T;
-}>;
-
-export class VersionedSnapshotStore<T> {
-  private version = 0;
-  private value: T;
-  private readonly waiters = new Set<
-    (snapshot: VersionedSnapshot<T>) => void
-  >();
-  private readonly subscribers = new Set<
-    (snapshot: VersionedSnapshot<T>) => void
-  >();
-
-  constructor(
-    initialValue: T,
-    private readonly isEqual: (prev: T, next: T) => boolean = Object.is,
-  ) {
-    this.value = initialValue;
-  }
-
-  public getSnapshot(): VersionedSnapshot<T> {
-    return { version: this.version, value: this.value };
-  }
-
-  public set(nextValue: T): boolean {
-    if (this.isEqual(this.value, nextValue)) {
-      return false;
-    }
-
-    this.value = nextValue;
-    this.version += 1;
-
-    const snapshot = this.getSnapshot();
-
-    for (const subscriber of this.subscribers) {
-      subscriber(snapshot);
-    }
-    for (const waiter of this.waiters) {
-      waiter(snapshot);
-    }
-    this.waiters.clear();
-
-    return true;
-  }
-
-  public update(updater: (prev: T) => T): boolean {
-    return this.set(updater(this.value));
-  }
-
-  public subscribe(
-    subscriber: (snapshot: VersionedSnapshot<T>) => void,
-  ): () => void {
-    this.subscribers.add(subscriber);
-    return () => {
-      this.subscribers.delete(subscriber);
-    };
-  }
-
-  public pull(sinceVersion = -1): Promise<VersionedSnapshot<T>> {
-    if (this.version !== sinceVersion) {
-      return Promise.resolve(this.getSnapshot());
-    }
-
-    return new Promise((resolve) => {
-      this.waiters.add(resolve);
-    });
-  }
-}
@@ -1,109 +0,0 @@
-import { BinaryHeap } from "../src/binary-heap";
-
-describe("BinaryHeap", () => {
-  const numberHeap = () => new BinaryHeap<number>((n) => n);
-
-  const drain = (heap: BinaryHeap<number>) => {
-    const out: number[] = [];
-    while (heap.size() > 0) {
-      out.push(heap.pop()!);
-    }
-    return out;
-  };
-
-  describe("empty heap", () => {
-    it("has size 0", () => {
-      expect(numberHeap().size()).toBe(0);
-    });
-
-    it("pop() returns null", () => {
-      expect(numberHeap().pop()).toBe(null);
-    });
-
-    it("remove() is a no-op and does not throw", () => {
-      const heap = numberHeap();
-      expect(() => heap.remove(1)).not.toThrow();
-      expect(heap.size()).toBe(0);
-    });
-  });
-
-  describe("push / pop", () => {
-    it("tracks size as items are added and removed", () => {
-      const heap = numberHeap();
-      [3, 1, 2].forEach((n) => heap.push(n));
-      expect(heap.size()).toBe(3);
-
-      heap.pop();
-      expect(heap.size()).toBe(2);
-    });
-
-    it("pops a single pushed element back out", () => {
-      const heap = numberHeap();
-      heap.push(42);
-      expect(heap.pop()).toBe(42);
-      expect(heap.pop()).toBe(null);
-    });
-
-    it("always pops the smallest score first", () => {
-      const heap = numberHeap();
-      [5, 3, 8, 1, 9, 2, 7].forEach((n) => heap.push(n));
-      expect(drain(heap)).toEqual([1, 2, 3, 5, 7, 8, 9]);
-    });
-
-    it("handles duplicate scores", () => {
-      const heap = numberHeap();
-      [4, 1, 4, 1, 2].forEach((n) => heap.push(n));
-      expect(drain(heap)).toEqual([1, 1, 2, 4, 4]);
-    });
-
-    it("maintains the heap invariant for a large adversarial (reverse-sorted) input", () => {
-      const heap = numberHeap();
-      // pushing in descending order forces a sift-up on every insert
-      const input = Array.from({ length: 1000 }, (_, i) => 1000 - i);
-      input.forEach((n) => heap.push(n));
-      expect(drain(heap)).toEqual([...input].sort((a, b) => a - b));
-    });
-  });
-
-  describe("remove", () => {
-    it("removes an interior element and keeps the rest ordered", () => {
-      const heap = numberHeap();
-      [5, 3, 8, 1, 9].forEach((n) => heap.push(n));
-
-      heap.remove(8);
-
-      expect(heap.size()).toBe(4);
-      expect(drain(heap)).toEqual([1, 3, 5, 9]);
-    });
-
-    it("can remove the current minimum", () => {
-      const heap = numberHeap();
-      [5, 3, 8, 1, 9].forEach((n) => heap.push(n));
-
-      heap.remove(1);
-
-      expect(heap.size()).toBe(4);
-      expect(heap.pop()).toBe(3);
-    });
-  });
-
-  describe("rescoreElement", () => {
-    type Node = { id: string; f: number };
-
-    it("re-sorts a node after its score is lowered", () => {
-      const heap = new BinaryHeap<Node>((node) => node.f);
-
-      const a = { id: "a", f: 10 };
-      const b = { id: "b", f: 20 };
-      const c = { id: "c", f: 30 };
-      [a, b, c].forEach((node) => heap.push(node));
-
-      c.f = 5;
-      heap.rescoreElement(c);
-
-      expect(heap.pop()).toBe(c);
-      expect(heap.pop()).toBe(a);
-      expect(heap.pop()).toBe(b);
-    });
-  });
-});
@@ -1,8 +1,7 @@
 {
  "extends": "../tsconfig.base.json",
  "compilerOptions": {
-    "outDir": "./dist/types",
-    "rootDir": "../"
+    "outDir": "./dist/types"
  },
  "include": ["src/**/*", "global.d.ts"],
  "exclude": ["**/*.test.*", "tests", "types", "examples", "dist"]
@@ -17,12 +17,6 @@
      "development": "./dist/dev/index.js",
      "production": "./dist/prod/index.js",
      "default": "./dist/prod/index.js"
-    },
-    "./visualdebug": {
-      "types": "./dist/types/element/src/visualdebug.d.ts",
-      "development": "./dist/dev/visualdebug.js",
-      "production": "./dist/prod/visualdebug.js",
-      "default": "./dist/prod/visualdebug.js"
    }
  },
  "files": [
@@ -64,7 +58,6 @@
  },
  "dependencies": {
    "@excalidraw/common": "0.18.0",
-    "@excalidraw/math": "0.18.0",
-    "@excalidraw/fractional-indexing": "3.3.0"
+    "@excalidraw/math": "0.18.0"
  }
 }
@@ -164,14 +164,9 @@ export class Scene {
    return this.frames;
  }

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

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

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

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

    this.elements = syncInvalidIndices(_nextElements);
    this.elementsMap.clear();
@@ -338,18 +326,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 +366,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) {
@@ -414,8 +426,6 @@ export class Scene {
    options: {
      informMutation: boolean;
      isDragging: boolean;
-      isBindingEnabled?: boolean;
-      isMidpointSnappingEnabled?: boolean;
    } = {
      informMutation: true,
      isDragging: false,
@@ -1,32 +0,0 @@
-import type { Arrowhead, AnyArrowhead } from "./types";
-
-export const normalizeArrowhead = (
-  arrowhead: AnyArrowhead | null | undefined,
-): Arrowhead | null => {
-  switch (arrowhead) {
-    case undefined:
-    case null:
-      return null;
-    case "dot":
-      return "circle";
-    case "crowfoot_one":
-      return "cardinality_one";
-    case "crowfoot_many":
-      return "cardinality_many";
-    case "crowfoot_one_or_many":
-      return "cardinality_one_or_many";
-    default:
-      return arrowhead;
-  }
-};
-
-export const getArrowheadForPicker = (
-  arrowhead: AnyArrowhead | null | undefined,
-): Arrowhead | null => {
-  const normalizedArrowhead = normalizeArrowhead(arrowhead);
-  if (normalizedArrowhead === null) {
-    return null;
-  }
-
-  return normalizedArrowhead;
-};
@@ -1,558 +0,0 @@
-import { pointDistance, pointFrom, type GlobalPoint } from "@excalidraw/math";
-import { invariant } from "@excalidraw/common";
-
-import type { AppState, NullableGridSize } from "@excalidraw/excalidraw/types";
-
-import {
-  bindBindingElement,
-  calculateFixedPointForNonElbowArrowBinding,
-  FOCUS_POINT_SIZE,
-  getBindingGap,
-  getGlobalFixedPointForBindableElement,
-  isBindingEnabled,
-  maxBindingDistance_simple,
-  unbindBindingElement,
-  updateBoundPoint,
-} from "../binding";
-import {
-  isBindableElement,
-  isBindingElement,
-  isElbowArrow,
-} from "../typeChecks";
-import { LinearElementEditor } from "../linearElementEditor";
-import { getHoveredElementForFocusPoint, hitElementItself } from "../collision";
-import { moveArrowAboveBindable } from "../zindex";
-
-import type {
-  ElementsMap,
-  ExcalidrawArrowElement,
-  ExcalidrawBindableElement,
-  NonDeletedSceneElementsMap,
-  PointsPositionUpdates,
-} from "../types";
-
-import type { Scene } from "../Scene";
-
-export const isFocusPointVisible = (
-  focusPoint: GlobalPoint,
-  arrow: ExcalidrawArrowElement,
-  bindableElement: ExcalidrawBindableElement,
-  elementsMap: ElementsMap,
-  appState: {
-    isBindingEnabled: AppState["isBindingEnabled"];
-    zoom: AppState["zoom"];
-  },
-  startOrEnd: "start" | "end",
-  ignoreOverlap = false,
-): boolean => {
-  // No focus point management for elbow arrows, because elbow arrows
-  // always have their focus point at the arrow point itself
-  if (
-    isElbowArrow(arrow) ||
-    !isBindingEnabled(appState) ||
-    arrow.points.length !== 2
-  ) {
-    return false;
-  }
-
-  // Avoid showing the focus point indicator if the focus point is essentially
-  // on top of the arrow point it belongs to itself, if not ignoring specifically
-  if (!ignoreOverlap) {
-    const associatedPointIdx =
-      arrow.startBinding?.elementId === bindableElement.id
-        ? 0
-        : arrow.points.length - 1;
-    const associatedArrowPoint =
-      LinearElementEditor.getPointAtIndexGlobalCoordinates(
-        arrow,
-        associatedPointIdx,
-        elementsMap,
-      );
-
-    if (
-      pointDistance(focusPoint, associatedArrowPoint) <
-      (FOCUS_POINT_SIZE * 1.5) / appState.zoom.value
-    ) {
-      return false;
-    }
-  }
-
-  const arrowPoint = LinearElementEditor.getPointAtIndexGlobalCoordinates(
-    arrow,
-    startOrEnd === "end" ? arrow.points.length - 1 : 0,
-    elementsMap,
-  );
-
-  // Check if the focus point is within the element's shape bounds
-  // Endpoint dragging takes precedence
-  return (
-    pointDistance(focusPoint, arrowPoint) >=
-      (FOCUS_POINT_SIZE * 1.5) / appState.zoom.value &&
-    hitElementItself({
-      element: bindableElement,
-      elementsMap,
-      point: focusPoint,
-      threshold: getBindingGap(bindableElement, arrow),
-      overrideShouldTestInside: true,
-    })
-  );
-};
-
-// Updates the arrow endpoints in "orbit" configuration
-const focusPointUpdate = (
-  arrow: ExcalidrawArrowElement,
-  bindableElement: ExcalidrawBindableElement | null,
-  isStartBinding: boolean,
-  elementsMap: NonDeletedSceneElementsMap,
-  scene: Scene,
-  appState: AppState,
-  switchToInsideBinding: boolean,
-) => {
-  const pointUpdates = new Map();
-
-  const bindingField = isStartBinding ? "startBinding" : "endBinding";
-  const adjacentBindingField = isStartBinding ? "endBinding" : "startBinding";
-  let currentBinding = arrow[bindingField];
-  let adjacentBinding = arrow[adjacentBindingField];
-
-  // Update the dragged focus point related end
-  if (currentBinding && bindableElement) {
-    // Update the targeted bindings
-    const boundToSameElement =
-      bindableElement &&
-      adjacentBinding &&
-      currentBinding.elementId === adjacentBinding.elementId;
-    if (switchToInsideBinding || boundToSameElement) {
-      currentBinding = {
-        ...currentBinding,
-        mode: "inside",
-      };
-    } else {
-      currentBinding = {
-        ...currentBinding,
-        mode: "orbit",
-      };
-    }
-
-    const pointIndex = isStartBinding ? 0 : arrow.points.length - 1;
-    const newPoint = updateBoundPoint(
-      arrow,
-      bindingField as "startBinding" | "endBinding",
-      currentBinding,
-      bindableElement,
-      elementsMap,
-      true,
-    );
-
-    if (newPoint) {
-      pointUpdates.set(pointIndex, { point: newPoint });
-    }
-  }
-
-  // Also update the adjacent end if it has a binding
-  if (adjacentBinding && adjacentBinding.mode === "orbit") {
-    const adjacentBindableElement = elementsMap.get(
-      adjacentBinding.elementId,
-    ) as ExcalidrawBindableElement;
-
-    if (
-      adjacentBindableElement &&
-      isBindableElement(adjacentBindableElement) &&
-      isBindingEnabled(appState)
-    ) {
-      // Same shape bound on both ends
-      const boundToSameElementAfterUpdate =
-        bindableElement && adjacentBinding.elementId === bindableElement.id;
-      if (switchToInsideBinding || boundToSameElementAfterUpdate) {
-        adjacentBinding = {
-          ...adjacentBinding,
-          mode: "inside",
-        };
-      } else {
-        adjacentBinding = {
-          ...adjacentBinding,
-          mode: "orbit",
-        };
-      }
-
-      const adjacentPointIndex = isStartBinding ? arrow.points.length - 1 : 0;
-      const adjacentNewPoint = updateBoundPoint(
-        arrow,
-        adjacentBindingField,
-        adjacentBinding,
-        adjacentBindableElement,
-        elementsMap,
-      );
-
-      if (adjacentNewPoint) {
-        pointUpdates.set(adjacentPointIndex, {
-          point: adjacentNewPoint,
-        });
-      }
-    }
-  }
-
-  if (pointUpdates.size > 0) {
-    LinearElementEditor.movePoints(arrow, scene, pointUpdates, {
-      [bindingField]: currentBinding,
-      [adjacentBindingField]: adjacentBinding,
-    });
-  }
-};
-
-export const handleFocusPointDrag = (
-  linearElementEditor: LinearElementEditor,
-  elementsMap: NonDeletedSceneElementsMap,
-  pointerCoords: { x: number; y: number },
-  scene: Scene,
-  appState: AppState,
-  gridSize: NullableGridSize,
-  switchToInsideBinding: boolean,
-) => {
-  const arrow = LinearElementEditor.getElement(
-    linearElementEditor.elementId,
-    elementsMap,
-  ) as any;
-
-  // Sanity checks
-  if (
-    !arrow ||
-    !isBindingElement(arrow) ||
-    isElbowArrow(arrow) ||
-    !linearElementEditor.hoveredFocusPointBinding ||
-    !linearElementEditor.draggedFocusPointBinding
-  ) {
-    return;
-  }
-
-  const isStartBinding =
-    linearElementEditor.draggedFocusPointBinding === "start";
-  const binding = isStartBinding ? arrow.startBinding : arrow.endBinding;
-  const { x: offsetX, y: offsetY } = linearElementEditor.pointerOffset;
-  const point = pointFrom<GlobalPoint>(
-    pointerCoords.x - offsetX,
-    pointerCoords.y - offsetY,
-  );
-  const bindingField = isStartBinding ? "startBinding" : "endBinding";
-  const hit = getHoveredElementForFocusPoint(
-    point,
-    arrow,
-    scene.getNonDeletedElements(),
-    elementsMap,
-    maxBindingDistance_simple(appState.zoom),
-  );
-
-  // Hovering a bindable element
-  if (hit && isBindingEnabled(appState)) {
-    // Break existing binding if bound to another shape or if binding is disabled
-    if (arrow[bindingField] && hit.id !== binding?.elementId) {
-      unbindBindingElement(
-        arrow,
-        linearElementEditor.draggedFocusPointBinding,
-        scene,
-      );
-    }
-
-    // Handle binding mode switch
-    const newMode =
-      switchToInsideBinding && arrow[bindingField]?.mode === "orbit"
-        ? "inside"
-        : !switchToInsideBinding && arrow[bindingField]?.mode === "inside"
-        ? "orbit"
-        : null;
-
-    // If no existing binding, create it
-    if (!arrow[bindingField] || newMode) {
-      // Create a new binding if none exists
-      bindBindingElement(
-        arrow,
-        hit,
-        newMode || "orbit",
-        linearElementEditor.draggedFocusPointBinding,
-        scene,
-        point,
-      );
-    }
-
-    // Update the binding's fixed point
-    scene.mutateElement(arrow, {
-      [bindingField]: {
-        ...arrow[bindingField],
-        elementId: hit.id,
-        mode: newMode || arrow[bindingField]?.mode || "orbit",
-        ...calculateFixedPointForNonElbowArrowBinding(
-          arrow,
-          hit,
-          linearElementEditor.draggedFocusPointBinding,
-          elementsMap,
-          point,
-        ),
-      },
-    });
-  } else {
-    // Not hovering any bindable element, move the arrow endpoint
-    const pointUpdates: PointsPositionUpdates = new Map();
-    const pointIndex = isStartBinding ? 0 : arrow.points.length - 1;
-    pointUpdates.set(pointIndex, {
-      point: LinearElementEditor.createPointAt(
-        arrow,
-        elementsMap,
-        point[0],
-        point[1],
-        gridSize,
-      ),
-    });
-    LinearElementEditor.movePoints(arrow, scene, pointUpdates);
-    if (arrow[bindingField]) {
-      unbindBindingElement(arrow, isStartBinding ? "start" : "end", scene);
-    }
-  }
-
-  // Update the arrow endpoints
-  focusPointUpdate(
-    arrow,
-    hit,
-    isStartBinding,
-    elementsMap,
-    scene,
-    appState,
-    switchToInsideBinding,
-  );
-
-  if (hit && isBindingEnabled(appState)) {
-    moveArrowAboveBindable(
-      point,
-      arrow,
-      scene.getElementsIncludingDeleted(),
-      elementsMap,
-      scene,
-      hit,
-    );
-  }
-};
-
-export const handleFocusPointPointerDown = (
-  arrow: ExcalidrawArrowElement,
-  pointerDownState: { origin: { x: number; y: number } },
-  elementsMap: NonDeletedSceneElementsMap,
-  appState: AppState,
-): {
-  hitFocusPoint: "start" | "end" | null;
-  pointerOffset: { x: number; y: number };
-} => {
-  const pointerPos = pointFrom(
-    pointerDownState.origin.x,
-    pointerDownState.origin.y,
-  );
-  const hitThreshold = (FOCUS_POINT_SIZE * 1.5) / appState.zoom.value;
-
-  // Check start binding focus point
-  if (arrow.startBinding?.elementId) {
-    const bindableElement = elementsMap.get(arrow.startBinding.elementId);
-    if (
-      bindableElement &&
-      isBindableElement(bindableElement) &&
-      !bindableElement.isDeleted
-    ) {
-      const focusPoint = getGlobalFixedPointForBindableElement(
-        arrow.startBinding.fixedPoint,
-        bindableElement,
-        elementsMap,
-      );
-      if (
-        isFocusPointVisible(
-          focusPoint,
-          arrow,
-          bindableElement,
-          elementsMap,
-          appState,
-          "start",
-        ) &&
-        pointDistance(pointerPos, focusPoint) <= hitThreshold
-      ) {
-        return {
-          hitFocusPoint: "start",
-          pointerOffset: {
-            x: pointerPos[0] - focusPoint[0],
-            y: pointerPos[1] - focusPoint[1],
-          },
-        };
-      }
-    }
-  }
-
-  // Check end binding focus point (only if start not already hit)
-  if (arrow.endBinding?.elementId) {
-    const bindableElement = elementsMap.get(arrow.endBinding.elementId);
-    if (
-      bindableElement &&
-      isBindableElement(bindableElement) &&
-      !bindableElement.isDeleted
-    ) {
-      const focusPoint = getGlobalFixedPointForBindableElement(
-        arrow.endBinding.fixedPoint,
-        bindableElement,
-        elementsMap,
-      );
-      if (
-        isFocusPointVisible(
-          focusPoint,
-          arrow,
-          bindableElement,
-          elementsMap,
-          appState,
-          "end",
-        ) &&
-        pointDistance(pointerPos, focusPoint) <= hitThreshold
-      ) {
-        return {
-          hitFocusPoint: "end",
-          pointerOffset: {
-            x: pointerPos[0] - focusPoint[0],
-            y: pointerPos[1] - focusPoint[1],
-          },
-        };
-      }
-    }
-  }
-
-  return {
-    hitFocusPoint: null,
-    pointerOffset: { x: 0, y: 0 },
-  };
-};
-
-export const handleFocusPointPointerUp = (
-  linearElementEditor: LinearElementEditor,
-  scene: Scene,
-) => {
-  invariant(
-    linearElementEditor.draggedFocusPointBinding,
-    "Must have a dragged focus point at pointer release",
-  );
-
-  const arrow = LinearElementEditor.getElement<ExcalidrawArrowElement>(
-    linearElementEditor.elementId,
-    scene.getNonDeletedElementsMap(),
-  );
-  invariant(arrow, "Arrow must be in the scene");
-
-  // Clean up
-  const bindingKey =
-    linearElementEditor.draggedFocusPointBinding === "start"
-      ? "startBinding"
-      : "endBinding";
-  const otherBindingKey =
-    linearElementEditor.draggedFocusPointBinding === "start"
-      ? "endBinding"
-      : "startBinding";
-  const boundElementId = arrow[bindingKey]?.elementId;
-  const otherBoundElementId = arrow[otherBindingKey]?.elementId;
-  const oldBoundElement =
-    boundElementId &&
-    scene
-      .getNonDeletedElements()
-      .find(
-        (element) =>
-          element.id !== boundElementId &&
-          element.id !== otherBoundElementId &&
-          isBindableElement(element) &&
-          element.boundElements?.find(({ id }) => id === arrow.id),
-      );
-  if (oldBoundElement) {
-    scene.mutateElement(oldBoundElement, {
-      boundElements: oldBoundElement.boundElements?.filter(
-        ({ id }) => id !== arrow.id,
-      ),
-    });
-  }
-
-  // Record the new bound element
-  const boundElement =
-    boundElementId && scene.getNonDeletedElementsMap().get(boundElementId);
-  if (boundElement) {
-    scene.mutateElement(boundElement, {
-      boundElements: [
-        ...(boundElement.boundElements || [])?.filter(
-          ({ id }) => id !== arrow.id,
-        ),
-        {
-          id: arrow.id,
-          type: "arrow",
-        },
-      ],
-    });
-  }
-};
-
-export const handleFocusPointHover = (
-  arrow: ExcalidrawArrowElement,
-  scenePointerX: number,
-  scenePointerY: number,
-  scene: Scene,
-  appState: AppState,
-): "start" | "end" | null => {
-  const elementsMap = scene.getNonDeletedElementsMap();
-  const pointerPos = pointFrom(scenePointerX, scenePointerY);
-  const hitThreshold = (FOCUS_POINT_SIZE * 1.5) / appState.zoom.value;
-
-  // Check start binding focus point
-  if (arrow.startBinding?.elementId) {
-    const bindableElement = elementsMap.get(arrow.startBinding.elementId);
-    if (
-      bindableElement &&
-      isBindableElement(bindableElement) &&
-      !bindableElement.isDeleted
-    ) {
-      const focusPoint = getGlobalFixedPointForBindableElement(
-        arrow.startBinding.fixedPoint,
-        bindableElement,
-        elementsMap,
-      );
-      if (
-        isFocusPointVisible(
-          focusPoint,
-          arrow,
-          bindableElement,
-          elementsMap,
-          appState,
-          "start",
-        ) &&
-        pointDistance(pointerPos, focusPoint) <= hitThreshold
-      ) {
-        return "start";
-      }
-    }
-  }
-
-  // Check end binding focus point (only if start not already hovered)
-  if (arrow.endBinding?.elementId) {
-    const bindableElement = elementsMap.get(arrow.endBinding.elementId);
-    if (
-      bindableElement &&
-      isBindableElement(bindableElement) &&
-      !bindableElement.isDeleted
-    ) {
-      const focusPoint = getGlobalFixedPointForBindableElement(
-        arrow.endBinding.fixedPoint,
-        bindableElement,
-        elementsMap,
-      );
-      if (
-        isFocusPointVisible(
-          focusPoint,
-          arrow,
-          bindableElement,
-          elementsMap,
-          appState,
-          "end",
-        ) &&
-        pointDistance(pointerPos, focusPoint) <= hitThreshold
-      ) {
-        return "end";
-      }
-    }
-  }
-
-  return null;
-};
@@ -1,45 +0,0 @@
-import type { App } from "@excalidraw/excalidraw/types";
-
-import { LinearElementEditor } from "../linearElementEditor";
-
-import { handleFocusPointDrag } from "./focus";
-
-export const maybeHandleArrowPointlikeDrag = ({
-  app,
-  event,
-}: {
-  app: App;
-  event: KeyboardEvent | React.KeyboardEvent<Element> | PointerEvent;
-}): boolean => {
-  const appState = app.state;
-  if (appState.selectedLinearElement && app.lastPointerMoveCoords) {
-    // Update focus point status if the binding mode is changing
-    if (appState.selectedLinearElement.draggedFocusPointBinding) {
-      handleFocusPointDrag(
-        appState.selectedLinearElement,
-        app.scene.getNonDeletedElementsMap(),
-        app.lastPointerMoveCoords,
-        app.scene,
-        appState,
-        app.getEffectiveGridSize(),
-        event.altKey,
-      );
-      return true;
-    } else if (
-      appState.selectedLinearElement.hoverPointIndex !== null &&
-      app.lastPointerMoveEvent &&
-      appState.selectedLinearElement.initialState.lastClickedPoint >= 0 &&
-      appState.selectedLinearElement.isDragging
-    ) {
-      LinearElementEditor.handlePointDragging(
-        app.lastPointerMoveEvent,
-        app,
-        app.lastPointerMoveCoords.x,
-        app.lastPointerMoveCoords.y,
-        appState.selectedLinearElement,
-      );
-      return true;
-    }
-  }
-  return false;
-};
@@ -1,11 +1,12 @@
 import rough from "roughjs/bin/rough";
+
 import {
  arrayToMap,
-  type Bounds,
  invariant,
  rescalePoints,
  sizeOf,
 } from "@excalidraw/common";
+
 import {
  degreesToRadians,
  lineSegment,
@@ -14,7 +15,9 @@ import {
  pointFromArray,
  pointRotateRads,
 } from "@excalidraw/math";
+
 import { getCurvePathOps } from "@excalidraw/utils/shape";
+
 import { pointsOnBezierCurves } from "points-on-curve";

 import type {
@@ -25,7 +28,9 @@ import type {
  LocalPoint,
  Radians,
 } from "@excalidraw/math";
+
 import type { AppState } from "@excalidraw/excalidraw/types";
+
 import type { Mutable } from "@excalidraw/common/utility-types";

 import { generateRoughOptions } from "./shape";
@@ -35,20 +40,17 @@ import { getBoundTextElement, getContainerElement } from "./textElement";
 import {
  isArrowElement,
  isBoundToContainer,
-  isFrameLikeElement,
  isFreeDrawElement,
  isLinearElement,
-  isLineElement,
  isTextElement,
-  isExcalidrawElement,
 } from "./typeChecks";
+
 import { getElementShape } from "./shape";
+
 import {
  deconstructDiamondElement,
  deconstructRectanguloidElement,
 } from "./utils";
-import { intersectElementWithLineSegment } from "./collision";
-import { elementOverlapsWithFrame, getContainingFrame } from "./frame";

 import type { Drawable, Op } from "roughjs/bin/core";
 import type { Point as RoughPoint } from "roughjs/bin/geometry";
@@ -63,7 +65,6 @@ import type {
  ExcalidrawRectanguloidElement,
  ExcalidrawTextElementWithContainer,
  NonDeleted,
-  NonDeletedExcalidrawElement,
 } from "./types";

 export type RectangleBox = {
@@ -76,6 +77,16 @@ export type RectangleBox = {

 type MaybeQuadraticSolution = [number | null, number | null] | false;

+/**
+ * x and y position of top left corner, x and y position of bottom right corner
+ */
+export type Bounds = readonly [
+  minX: number,
+  minY: number,
+  maxX: number,
+  maxY: number,
+];
+
 export type SceneBounds = readonly [
  sceneX: number,
  sceneY: number,
@@ -310,42 +321,19 @@ export const getElementLineSegments = (

  if (shape.type === "polycurve") {
    const curves = shape.data;
-    const pointsOnCurves = curves.map((curve) =>
-      pointsOnBezierCurves(curve, 10),
-    );
-
+    const points = curves
+      .map((curve) => pointsOnBezierCurves(curve, 10))
+      .flat();
+    let i = 0;
    const segments: LineSegment<GlobalPoint>[] = [];
-
-    if (
-      (isLineElement(element) && !element.polygon) ||
-      isArrowElement(element)
-    ) {
-      for (const points of pointsOnCurves) {
-        let i = 0;
-
-        while (i < points.length - 1) {
-          segments.push(
-            lineSegment(
-              pointFrom(points[i][0], points[i][1]),
-              pointFrom(points[i + 1][0], points[i + 1][1]),
-            ),
-          );
-          i++;
-        }
-      }
-    } else {
-      const points = pointsOnCurves.flat();
-      let i = 0;
-
-      while (i < points.length - 1) {
-        segments.push(
-          lineSegment(
-            pointFrom(points[i][0], points[i][1]),
-            pointFrom(points[i + 1][0], points[i + 1][1]),
-          ),
-        );
-        i++;
-      }
+    while (i < points.length - 1) {
+      segments.push(
+        lineSegment(
+          pointFrom(points[i][0], points[i][1]),
+          pointFrom(points[i + 1][0], points[i + 1][1]),
+        ),
+      );
+      i++;
    }

    return segments;
@@ -677,9 +665,8 @@ export const getMinMaxXYFromCurvePathOps = (
  return [minX, minY, maxX, maxY];
 };

-export const getBoundsFromPoints = <P extends GlobalPoint | LocalPoint>(
-  points: readonly P[],
-  padding: number = 0,
+export const getBoundsFromPoints = (
+  points: ExcalidrawFreeDrawElement["points"],
 ): Bounds => {
  let minX = Infinity;
  let minY = Infinity;
@@ -693,7 +680,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 = (
@@ -707,9 +694,6 @@ const getFreeDrawElementAbsoluteCoords = (
  return [x1, y1, x2, y2, (x1 + x2) / 2, (y1 + y2) / 2];
 };

-const CARDINALITY_MARKER_SIZE = 20;
-const CROWFOOT_ARROWHEAD_SIZE = 15;
-
 /** @returns number in pixels */
 export const getArrowheadSize = (arrowhead: Arrowhead): number => {
  switch (arrowhead) {
@@ -718,14 +702,10 @@ export const getArrowheadSize = (arrowhead: Arrowhead): number => {
    case "diamond":
    case "diamond_outline":
      return 12;
-    case "cardinality_many":
-    case "cardinality_one_or_many":
-    case "cardinality_zero_or_many":
-      return CROWFOOT_ARROWHEAD_SIZE;
-    case "cardinality_one":
-    case "cardinality_exactly_one":
-    case "cardinality_zero_or_one":
-      return CARDINALITY_MARKER_SIZE;
+    case "crowfoot_many":
+    case "crowfoot_one":
+    case "crowfoot_one_or_many":
+      return 20;
    default:
      return 15;
  }
@@ -748,12 +728,7 @@ export const getArrowheadPoints = (
  shape: Drawable[],
  position: "start" | "end",
  arrowhead: Arrowhead,
-  offsetMultiplier = 0,
 ) => {
-  if (arrowhead === null) {
-    return null;
-  }
-
  if (shape.length < 1) {
    return null;
  }
@@ -834,30 +809,29 @@ export const getArrowheadPoints = (
  const lengthMultiplier =
    arrowhead === "diamond" || arrowhead === "diamond_outline" ? 0.25 : 0.5;
  const minSize = Math.min(size, length * lengthMultiplier);
-  const tx = x2 - nx * minSize * offsetMultiplier;
-  const ty = y2 - ny * minSize * offsetMultiplier;
-  const xs = tx - nx * minSize;
-  const ys = ty - ny * minSize;
+  const xs = x2 - nx * minSize;
+  const ys = y2 - ny * minSize;

-  if (arrowhead === "circle" || arrowhead === "circle_outline") {
-    const diameter = Math.hypot(ys - ty, xs - tx) + element.strokeWidth - 2;
-    return [tx, ty, diameter];
+  if (
+    arrowhead === "dot" ||
+    arrowhead === "circle" ||
+    arrowhead === "circle_outline"
+  ) {
+    const diameter = Math.hypot(ys - y2, xs - x2) + element.strokeWidth - 2;
+    return [x2, y2, diameter];
  }

  const angle = getArrowheadAngle(arrowhead);

-  if (
-    arrowhead === "cardinality_many" ||
-    arrowhead === "cardinality_one_or_many"
-  ) {
+  if (arrowhead === "crowfoot_many" || arrowhead === "crowfoot_one_or_many") {
    // swap (xs, ys) with (x2, y2)
    const [x3, y3] = pointRotateRads(
-      pointFrom(tx, ty),
+      pointFrom(x2, y2),
      pointFrom(xs, ys),
      degreesToRadians(-angle as Degrees),
    );
    const [x4, y4] = pointRotateRads(
-      pointFrom(tx, ty),
+      pointFrom(x2, y2),
      pointFrom(xs, ys),
      degreesToRadians(angle),
    );
@@ -867,12 +841,12 @@ export const getArrowheadPoints = (
  // Return points
  const [x3, y3] = pointRotateRads(
    pointFrom(xs, ys),
-    pointFrom(tx, ty),
+    pointFrom(x2, y2),
    ((-angle * Math.PI) / 180) as Radians,
  );
  const [x4, y4] = pointRotateRads(
    pointFrom(xs, ys),
-    pointFrom(tx, ty),
+    pointFrom(x2, y2),
    degreesToRadians(angle),
  );

@@ -885,9 +859,9 @@ export const getArrowheadPoints = (
      const [px, py] = element.points.length > 1 ? element.points[1] : [0, 0];

      [ox, oy] = pointRotateRads(
-        pointFrom(tx + minSize * 2, ty),
-        pointFrom(tx, ty),
-        Math.atan2(py - ty, px - tx) as Radians,
+        pointFrom(x2 + minSize * 2, y2),
+        pointFrom(x2, y2),
+        Math.atan2(py - y2, px - x2) as Radians,
      );
    } else {
      const [px, py] =
@@ -896,19 +870,18 @@ export const getArrowheadPoints = (
          : [0, 0];

      [ox, oy] = pointRotateRads(
-        pointFrom(tx - minSize * 2, ty),
-        pointFrom(tx, ty),
-        Math.atan2(ty - py, tx - px) as Radians,
+        pointFrom(x2 - minSize * 2, y2),
+        pointFrom(x2, y2),
+        Math.atan2(y2 - py, x2 - px) as Radians,
      );
    }

-    return [tx, ty, x3, y3, ox, oy, x4, y4];
+    return [x2, y2, x3, y3, ox, oy, x4, y4];
  }

-  return [tx, ty, x3, y3, x4, y4];
+  return [x2, y2, x3, y3, x4, y4];
 };

-// TODO reuse shape.ts
 const generateLinearElementShape = (
  element: ExcalidrawLinearElement,
 ): Drawable => {
@@ -966,7 +939,7 @@ const getLinearElementRotatedBounds = (
  }

  // first element is always the curve
-  const cachedShape = ShapeCache.get(element, null)?.[0];
+  const cachedShape = ShapeCache.get(element)?.[0];
  const shape = cachedShape ?? generateLinearElementShape(element);
  const ops = getCurvePathOps(shape);
  const transformXY = ([x, y]: GlobalPoint) =>
@@ -1153,9 +1126,7 @@ export interface BoundingBox {
 }

 export const getCommonBoundingBox = (
-  elements:
-    | readonly ExcalidrawElement[]
-    | readonly NonDeleted<ExcalidrawElement>[],
+  elements: ExcalidrawElement[] | readonly NonDeleted<ExcalidrawElement>[],
 ): BoundingBox => {
  const [minX, minY, maxX, maxY] = getCommonBounds(elements);
  return {
@@ -1259,17 +1230,6 @@ export const pointInsideBounds = <P extends GlobalPoint | LocalPoint>(
 ): boolean =>
  p[0] > bounds[0] && p[0] < bounds[2] && p[1] > bounds[1] && p[1] < bounds[3];

-// TODO make pointInsideBounds inclusive and remove this function once we
-// test nothing is breaking
-export const pointInsideBoundsInclusive = <P extends GlobalPoint | LocalPoint>(
-  p: P,
-  bounds: Bounds,
-): boolean =>
-  p[0] >= bounds[0] &&
-  p[0] <= bounds[2] &&
-  p[1] >= bounds[1] &&
-  p[1] <= bounds[3];
-
 export const doBoundsIntersect = (
  bounds1: Bounds | null,
  bounds2: Bounds | null,
@@ -1284,316 +1244,12 @@ export const doBoundsIntersect = (
  return minX1 < maxX2 && maxX1 > minX2 && minY1 < maxY2 && maxY1 > minY2;
 };

-export const boundsContainBounds = (outerBounds: Bounds, innerBounds: Bounds) =>
-  [
-    pointFrom<GlobalPoint>(innerBounds[0], innerBounds[1]),
-    pointFrom<GlobalPoint>(innerBounds[0], innerBounds[3]),
-    pointFrom<GlobalPoint>(innerBounds[2], innerBounds[1]),
-    pointFrom<GlobalPoint>(innerBounds[2], innerBounds[3]),
-  ].every((point) => pointInsideBoundsInclusive(point, outerBounds));
-
-/**
- * High level helper to get elements overlapping a bounding box.
- * It can be used to get elements overlapping a selection box, for example.
- *
- */
-export const elementsOverlappingBBox = ({
-  elements,
-  elementsMap,
-  bounds,
-  type,
-  excludeElementsInFrames,
-  shouldIgnoreElementFromSelection,
-}: {
-  elements: readonly NonDeletedExcalidrawElement[];
-  elementsMap?: ElementsMap;
-  bounds: Bounds | ExcalidrawElement;
-  /**
-   * - overlap: elements overlapping or inside bounds
-   * - contain: elements inside bounds
-   **/
-  type: "contain" | "overlap";
-  excludeElementsInFrames?: boolean;
-  shouldIgnoreElementFromSelection?: (
-    element: NonDeletedExcalidrawElement,
-  ) => boolean;
-}) => {
-  if (!elementsMap) {
-    elementsMap = arrayToMap(elements) as ElementsMap;
-  }
-  const selectionBounds = isExcalidrawElement(bounds)
-    ? getElementBounds(bounds, elementsMap)
-    : bounds;
-  const [selectionX1, selectionY1, selectionX2, selectionY2] = selectionBounds;
-  const selectionEdges = [
-    lineSegment<GlobalPoint>(
-      pointFrom(selectionX1, selectionY1),
-      pointFrom(selectionX2, selectionY1),
-    ),
-    lineSegment<GlobalPoint>(
-      pointFrom(selectionX2, selectionY1),
-      pointFrom(selectionX2, selectionY2),
-    ),
-    lineSegment<GlobalPoint>(
-      pointFrom(selectionX2, selectionY2),
-      pointFrom(selectionX1, selectionY2),
-    ),
-    lineSegment<GlobalPoint>(
-      pointFrom(selectionX1, selectionY2),
-      pointFrom(selectionX1, selectionY1),
-    ),
-  ];
-
-  const framesInSelection = excludeElementsInFrames
-    ? new Set<NonDeletedExcalidrawElement["id"]>()
-    : null;
-  const groups: Record<string, NonDeletedExcalidrawElement[]> = {};
-  const elementsInSelection: Set<NonDeletedExcalidrawElement> = new Set();
-
-  for (const element of elements) {
-    if (shouldIgnoreElementFromSelection?.(element)) {
-      continue;
-    }
-
-    // Track only selectable top-level group members, so ignored elements such
-    // as bound text and locked elements don't affect group selection.
-    const groupId = element.groupIds.at(-1);
-    if (groupId) {
-      if (!groups[groupId]) {
-        groups[groupId] = [];
-      }
-      groups[groupId].push(element);
-    }
-
-    const strokeWidth = element.strokeWidth;
-    let labelAABB: Bounds | null = null;
-    let elementAABB = getElementBounds(element, elementsMap);
-
-    elementAABB = [
-      elementAABB[0] - strokeWidth / 2,
-      elementAABB[1] - strokeWidth / 2,
-      elementAABB[2] + strokeWidth / 2,
-      elementAABB[3] + strokeWidth / 2,
-    ] as Bounds;
-
-    // Whether the element bounds should include the bound text element bounds
-    const boundTextElement =
-      isArrowElement(element) && getBoundTextElement(element, elementsMap);
-    if (boundTextElement) {
-      const { x, y } = LinearElementEditor.getBoundTextElementPosition(
-        element,
-        boundTextElement,
-        elementsMap,
-      );
-      labelAABB = [
-        x,
-        y,
-        x + boundTextElement.width,
-        y + boundTextElement.height,
-      ] as Bounds;
-    }
-
-    // Clip element bounds by its containing frame (if any), since only the
-    // visible (frame-clipped) portion of the element is relevant for selection.
-    const associatedFrame = getContainingFrame(element, elementsMap);
-    if (
-      associatedFrame &&
-      elementOverlapsWithFrame(element, associatedFrame, elementsMap)
-    ) {
-      const frameAABB = getElementBounds(associatedFrame, elementsMap);
-      elementAABB = [
-        Math.max(elementAABB[0], frameAABB[0]),
-        Math.max(elementAABB[1], frameAABB[1]),
-        Math.min(elementAABB[2], frameAABB[2]),
-        Math.min(elementAABB[3], frameAABB[3]),
-      ] as Bounds;
-
-      labelAABB = labelAABB
-        ? ([
-            Math.max(labelAABB[0], frameAABB[0]),
-            Math.max(labelAABB[1], frameAABB[1]),
-            Math.min(labelAABB[2], frameAABB[2]),
-            Math.min(labelAABB[3], frameAABB[3]),
-          ] as Bounds)
-        : null;
-    }
-
-    const commonAABB = labelAABB
-      ? ([
-          Math.min(labelAABB[0], elementAABB[0]),
-          Math.min(labelAABB[1], elementAABB[1]),
-          Math.max(labelAABB[2], elementAABB[2]),
-          Math.max(labelAABB[3], elementAABB[3]),
-        ] as Bounds)
-      : elementAABB;
-
-    // ============== Evaluation ==============
-
-    // 1. If the selection box WRAPs the element's AABB, then add it to the
-    //    selection and move on, regardless of the selection mode.
-    //
-    //    PERF: This trick only works with axis-aligned box selection and the
-    //          current convex element shapes!
-    if (boundsContainBounds(selectionBounds, commonAABB)) {
-      if (framesInSelection && isFrameLikeElement(element)) {
-        framesInSelection.add(element.id);
-      }
-      elementsInSelection.add(element);
-      continue;
-    }
-
-    // 2. Handle the case where the label is overlapped by the selection box
-    if (
-      type === "overlap" &&
-      labelAABB &&
-      doBoundsIntersect(selectionBounds, labelAABB)
-    ) {
-      elementsInSelection.add(element);
-      continue;
-    }
-
-    // 3. Handle the case where the selection is not wrapping the element, but
-    //    it does intersect the element's outline (non-AABB).
-    if (type === "overlap" && doBoundsIntersect(selectionBounds, elementAABB)) {
-      let hasIntersection = false;
-
-      // Preliminary check potential intersection imprecision
-      if (isLinearElement(element) || isFreeDrawElement(element)) {
-        const center = elementCenterPoint(element, elementsMap);
-        hasIntersection = element.points.some((point) => {
-          const rotatedPoint = pointRotateRads(
-            pointFrom<GlobalPoint>(element.x + point[0], element.y + point[1]),
-            center,
-            element.angle,
-          );
-
-          return pointInsideBounds(rotatedPoint, selectionBounds);
-        });
-      } else {
-        const nonRotatedElementBounds = getElementBounds(
-          element,
-          elementsMap,
-          true,
-        );
-        const center = elementCenterPoint(element, elementsMap);
-        hasIntersection = [
-          pointRotateRads(
-            pointFrom<GlobalPoint>(
-              (nonRotatedElementBounds[0] + nonRotatedElementBounds[2]) / 2,
-              nonRotatedElementBounds[1],
-            ),
-            center,
-            element.angle,
-          ),
-          pointRotateRads(
-            pointFrom<GlobalPoint>(
-              nonRotatedElementBounds[2],
-              (nonRotatedElementBounds[1] + nonRotatedElementBounds[3]) / 2,
-            ),
-            center,
-            element.angle,
-          ),
-          pointRotateRads(
-            pointFrom<GlobalPoint>(
-              (nonRotatedElementBounds[0] + nonRotatedElementBounds[2]) / 2,
-              nonRotatedElementBounds[3],
-            ),
-            center,
-            element.angle,
-          ),
-          pointRotateRads(
-            pointFrom<GlobalPoint>(
-              nonRotatedElementBounds[0],
-              (nonRotatedElementBounds[1] + nonRotatedElementBounds[3]) / 2,
-            ),
-            center,
-            element.angle,
-          ),
-        ].some((point) => {
-          return pointInsideBounds(
-            pointRotateRads(point, center, element.angle),
-            selectionBounds,
-          );
-        });
-      }
-
-      if (!hasIntersection) {
-        hasIntersection = selectionEdges.some(
-          (selectionEdge) =>
-            intersectElementWithLineSegment(
-              element,
-              elementsMap,
-              selectionEdge,
-              strokeWidth / 2,
-              true, // Stop at first hit for better performance
-            ).length > 0,
-        );
-      }
-
-      if (hasIntersection) {
-        if (framesInSelection && isFrameLikeElement(element)) {
-          framesInSelection.add(element.id);
-        }
-
-        elementsInSelection.add(element);
-        continue;
-      }
-    }
-
-    // 4. We don't need to handle when the selection is inside the element
-    //    as it is separately handled in App.
-  }
-
-  if (framesInSelection) {
-    elementsInSelection.forEach((element) => {
-      if (element.frameId && framesInSelection.has(element.frameId)) {
-        elementsInSelection.delete(element);
-      }
-    });
-  }
-
-  if (type === "overlap") {
-    Array.from(elementsInSelection).forEach((element) => {
-      const groupId = element.groupIds.at(-1);
-      const group = groupId ? groups[groupId] : null;
-
-      group?.forEach((groupElement) => elementsInSelection.add(groupElement));
-    });
-  } else if (type === "contain") {
-    elementsInSelection.forEach((element) => {
-      // note: currently we only support top-level group handling since
-      // we don't support box selecting while editing the group/subgroup
-      // see https://github.com/excalidraw/excalidraw/pull/11234#issuecomment-4387654451
-      const groupId = element.groupIds.at(-1);
-
-      const group = groupId ? groups[groupId] : null;
-
-      if (
-        group &&
-        !group.every((groupElement) => elementsInSelection.has(groupElement))
-      ) {
-        elementsInSelection.delete(element);
-      }
-    });
-  }
-
-  // to maintain original order elements (namely for group selection)
-  return elements.filter((element) => elementsInSelection.has(element));
-};
-
 export const elementCenterPoint = (
  element: ExcalidrawElement,
  elementsMap: ElementsMap,
  xOffset: number = 0,
  yOffset: number = 0,
 ) => {
-  if (isLinearElement(element) || isFreeDrawElement(element)) {
-    const [x1, y1, x2, y2] = getElementAbsoluteCoords(element, elementsMap);
-    const [x, y] = pointFrom<GlobalPoint>((x1 + x2) / 2, (y1 + y2) / 2);
-
-    return pointFrom<GlobalPoint>(x + xOffset, y + yOffset);
-  }
-
  const [x, y] = getCenterForBounds(getElementBounds(element, elementsMap));

  return pointFrom<GlobalPoint>(x + xOffset, y + yOffset);
@@ -1,4 +1,4 @@
-import { invariant, isTransparent, type Bounds } from "@excalidraw/common";
+import { isTransparent } from "@excalidraw/common";
 import {
  curveIntersectLineSegment,
  isPointWithinBounds,
@@ -29,18 +29,15 @@ import type { FrameNameBounds } from "@excalidraw/excalidraw/types";

 import { isPathALoop } from "./utils";
 import {
+  type Bounds,
  doBoundsIntersect,
  elementCenterPoint,
  getCenterForBounds,
  getCubicBezierCurveBound,
-  getDiamondPoints,
  getElementBounds,
-  pointInsideBounds,
 } from "./bounds";
 import {
  hasBoundTextElement,
-  isBindableElement,
-  isFrameLikeElement,
  isFreeDrawElement,
  isIframeLikeElement,
  isImageElement,
@@ -59,24 +56,14 @@ import { LinearElementEditor } from "./linearElementEditor";

 import { distanceToElement } from "./distance";

-import { getBindingGap } from "./binding";
-
-import { hasBackground } from "./comparisons";
-
 import type {
  ElementsMap,
-  ExcalidrawArrowElement,
-  ExcalidrawBindableElement,
  ExcalidrawDiamondElement,
  ExcalidrawElement,
  ExcalidrawEllipseElement,
  ExcalidrawFreeDrawElement,
  ExcalidrawLinearElement,
  ExcalidrawRectanguloidElement,
-  NonDeleted,
-  NonDeletedExcalidrawElement,
-  NonDeletedSceneElementsMap,
-  Ordered,
 } from "./types";

 export const shouldTestInside = (element: ExcalidrawElement) => {
@@ -85,7 +72,7 @@ export const shouldTestInside = (element: ExcalidrawElement) => {
  }

  const isDraggableFromInside =
-    (hasBackground(element.type) && !isTransparent(element.backgroundColor)) ||
+    !isTransparent(element.backgroundColor) ||
    hasBoundTextElement(element) ||
    isIframeLikeElement(element) ||
    isTextElement(element);
@@ -107,41 +94,15 @@ export type HitTestArgs = {
  threshold: number;
  elementsMap: ElementsMap;
  frameNameBound?: FrameNameBounds | null;
-  overrideShouldTestInside?: boolean;
 };

-let cachedPoint: GlobalPoint | null = null;
-let cachedElement: WeakRef<ExcalidrawElement> | null = null;
-let cachedThreshold: number = Infinity;
-let cachedHit: boolean = false;
-let cachedOverrideShouldTestInside = false;
-
 export const hitElementItself = ({
  point,
  element,
  threshold,
  elementsMap,
  frameNameBound = null,
-  overrideShouldTestInside = false,
 }: HitTestArgs) => {
-  // Return cached result if the same point and element version is tested again
-  if (
-    cachedPoint &&
-    pointsEqual(point, cachedPoint) &&
-    cachedThreshold <= threshold &&
-    overrideShouldTestInside === cachedOverrideShouldTestInside
-  ) {
-    const derefElement = cachedElement?.deref();
-    if (
-      derefElement &&
-      derefElement.id === element.id &&
-      derefElement.version === element.version &&
-      derefElement.versionNonce === element.versionNonce
-    ) {
-      return cachedHit;
-    }
-  }
-
  // Hit test against a frame's name
  const hitFrameName = frameNameBound
    ? isPointWithinBounds(
@@ -156,11 +117,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
@@ -170,43 +134,14 @@ export const hitElementItself = ({
  }

  // Do the precise (and relatively costly) hit test
-  const hitElement = (
-    overrideShouldTestInside ? true : shouldTestInside(element)
-  )
+  const hitElement = shouldTestInside(element)
    ? // Since `inShape` tests STRICTLY againt the insides of a shape
      // we would need `onShape` as well to include the "borders"
      isPointInElement(point, element, elementsMap) ||
      isPointOnElementOutline(point, element, elementsMap, threshold)
    : isPointOnElementOutline(point, element, elementsMap, threshold);

-  const result = hitElement || hitFrameName;
-
-  // Cache end result
-  cachedPoint = point;
-  cachedElement = new WeakRef(element);
-  cachedThreshold = threshold;
-  cachedOverrideShouldTestInside = overrideShouldTestInside;
-  cachedHit = result;
-
-  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),
-  );
+  return hitElement || hitFrameName;
 };

 export const hitElementBoundingBox = (
@@ -215,8 +150,12 @@ export const hitElementBoundingBox = (
  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 = (
@@ -254,169 +193,6 @@ export const hitElementBoundText = (
  return isPointInElement(point, boundTextElement, elementsMap);
 };

-const bindingBorderTest = (
-  element: NonDeleted<ExcalidrawBindableElement>,
-  [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 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 false;
-  }
-
-  // If the element is inside a frame, we should clip the element
-  if (element.frameId) {
-    const enclosingFrame = elementsMap.get(element.frameId);
-    if (enclosingFrame && isFrameLikeElement(enclosingFrame)) {
-      const enclosingFrameBounds = getElementBounds(
-        enclosingFrame,
-        elementsMap,
-      );
-      if (!pointInsideBounds(p, enclosingFrameBounds)) {
-        return false;
-      }
-    }
-  }
-
-  // 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 shouldTestInside
-    ? intersections.length === 0 || distance <= tolerance
-    : intersections.length > 0 && distance <= t;
-};
-
-export const getAllHoveredElementAtPoint = (
-  point: Readonly<GlobalPoint>,
-  elements: readonly Ordered<NonDeletedExcalidrawElement>[],
-  elementsMap: NonDeletedSceneElementsMap,
-  tolerance?: number,
-): NonDeleted<ExcalidrawBindableElement>[] => {
-  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];
-
-    invariant(
-      !element.isDeleted,
-      "Elements in the function parameter for getAllElementsAtPositionForBinding() should not contain deleted elements",
-    );
-
-    if (
-      isBindableElement(element, false) &&
-      bindingBorderTest(element, point, elementsMap, tolerance)
-    ) {
-      candidateElements.push(element);
-
-      if (
-        hasBackground(element.type) &&
-        !isTransparent(element.backgroundColor)
-      ) {
-        break;
-      }
-    }
-  }
-
-  return candidateElements;
-};
-
-export const getHoveredElementForBinding = (
-  point: Readonly<GlobalPoint>,
-  elements: readonly Ordered<NonDeletedExcalidrawElement>[],
-  elementsMap: NonDeletedSceneElementsMap,
-  tolerance?: number,
-): NonDeleted<ExcalidrawBindableElement> | null => {
-  const candidateElements = getAllHoveredElementAtPoint(
-    point,
-    elements,
-    elementsMap,
-    tolerance,
-  );
-
-  if (!candidateElements || candidateElements.length === 0) {
-    return null;
-  }
-
-  if (candidateElements.length === 1) {
-    return candidateElements[0];
-  }
-
-  // Prefer smaller shapes
-  return candidateElements
-    .sort(
-      (a, b) => b.width ** 2 + b.height ** 2 - (a.width ** 2 + a.height ** 2),
-    )
-    .pop() as NonDeleted<ExcalidrawBindableElement>;
-};
-
-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];
-
-    invariant(
-      !element.isDeleted,
-      "Elements in the function parameter for getAllElementsAtPositionForBinding() should not contain deleted elements",
-    );
-
-    if (
-      isBindableElement(element, false) &&
-      bindingBorderTest(element, point, elementsMap, tolerance)
-    ) {
-      candidateElements.push(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>;
-};
-
 /**
 * Intersect a line with an element for binding test
 *
@@ -481,12 +257,7 @@ export const intersectElementWithLineSegment = (
    case "line":
    case "freedraw":
    case "arrow":
-      return intersectLinearOrFreeDrawWithLineSegment(
-        element,
-        line,
-        elementsMap,
-        onlyFirst,
-      );
+      return intersectLinearOrFreeDrawWithLineSegment(element, line, onlyFirst);
  }
 };

@@ -553,15 +324,11 @@ const lineIntersections = (
 const intersectLinearOrFreeDrawWithLineSegment = (
  element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement,
  segment: LineSegment<GlobalPoint>,
-  elementsMap: ElementsMap,
  onlyFirst = false,
 ): GlobalPoint[] => {
  // NOTE: This is the only one which return the decomposed elements
  // rotated! This is due to taking advantage of roughjs definitions.
-  const [lines, curves] = deconstructLinearOrFreeDrawElement(
-    element,
-    elementsMap,
-  );
+  const [lines, curves] = deconstructLinearOrFreeDrawElement(element);
  const intersections: GlobalPoint[] = [];

  for (const l of lines) {
@@ -589,9 +356,7 @@ const intersectLinearOrFreeDrawWithLineSegment = (
      continue;
    }

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

    if (hits.length > 0) {
      intersections.push(...hits);
@@ -789,61 +554,3 @@ export const isPointInElement = (

  return intersections.length % 2 === 1;
 };
-
-export const isBindableElementInsideOtherBindable = (
-  innerElement: ExcalidrawBindableElement,
-  outerElement: ExcalidrawBindableElement,
-  elementsMap: ElementsMap,
-): boolean => {
-  // Get corner points of the inner element based on its type
-  const getCornerPoints = (
-    element: ExcalidrawElement,
-    offset: number,
-  ): GlobalPoint[] => {
-    const { x, y, width, height, angle } = element;
-    const center = elementCenterPoint(element, elementsMap);
-
-    if (element.type === "diamond") {
-      // Diamond has 4 corner points at the middle of each side
-      const [topX, topY, rightX, rightY, bottomX, bottomY, leftX, leftY] =
-        getDiamondPoints(element);
-      const corners: GlobalPoint[] = [
-        pointFrom(x + topX, y + topY - offset), // top
-        pointFrom(x + rightX + offset, y + rightY), // right
-        pointFrom(x + bottomX, y + bottomY + offset), // bottom
-        pointFrom(x + leftX - offset, y + leftY), // left
-      ];
-      return corners.map((corner) => pointRotateRads(corner, center, angle));
-    }
-    if (element.type === "ellipse") {
-      // For ellipse, test points at the extremes (top, right, bottom, left)
-      const cx = x + width / 2;
-      const cy = y + height / 2;
-      const rx = width / 2;
-      const ry = height / 2;
-      const corners: GlobalPoint[] = [
-        pointFrom(cx, cy - ry - offset), // top
-        pointFrom(cx + rx + offset, cy), // right
-        pointFrom(cx, cy + ry + offset), // bottom
-        pointFrom(cx - rx - offset, cy), // left
-      ];
-      return corners.map((corner) => pointRotateRads(corner, center, angle));
-    }
-    // Rectangle and other rectangular shapes (image, text, etc.)
-    const corners: GlobalPoint[] = [
-      pointFrom(x - offset, y - offset), // top-left
-      pointFrom(x + width + offset, y - offset), // top-right
-      pointFrom(x + width + offset, y + height + offset), // bottom-right
-      pointFrom(x - offset, y + height + offset), // bottom-left
-    ];
-    return corners.map((corner) => pointRotateRads(corner, center, angle));
-  };
-
-  const offset = (-1 * Math.max(innerElement.width, innerElement.height)) / 20; // 5% offset
-  const innerCorners = getCornerPoints(innerElement, offset);
-
-  // Check if all corner points of the inner element are inside the outer element
-  return innerCorners.every((corner) =>
-    isPointInElement(corner, outerElement, elementsMap),
-  );
-};
@@ -10,14 +10,7 @@ export const hasBackground = (type: ElementOrToolType) =>
  type === "freedraw";

 export const hasStrokeColor = (type: ElementOrToolType) =>
-  type === "rectangle" ||
-  type === "ellipse" ||
-  type === "diamond" ||
-  type === "freedraw" ||
-  type === "arrow" ||
-  type === "line" ||
-  type === "text" ||
-  type === "embeddable";
+  type !== "image" && type !== "frame" && type !== "magicframe";

 export const hasStrokeWidth = (type: ElementOrToolType) =>
  type === "rectangle" ||
@@ -38,8 +31,6 @@ export const hasStrokeStyle = (type: ElementOrToolType) =>
  type === "arrow" ||
  type === "line";

-export const hasFreedrawMode = (type: ElementOrToolType) => type === "freedraw";
-
 export const canChangeRoundness = (type: ElementOrToolType) =>
  type === "rectangle" ||
  type === "iframe" ||
@@ -2,6 +2,7 @@ import {
  arrayToMap,
  arrayToObject,
  assertNever,
+  invariant,
  isDevEnv,
  isShallowEqual,
  isTestEnv,
@@ -55,10 +56,10 @@ import { getNonDeletedGroupIds } from "./groups";

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

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

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

 import type { ElementUpdate } from "./mutateElement";
@@ -150,27 +151,13 @@ export class Delta<T> {
    );
  }

-  /**
-   * Merges two deltas into a new one.
-   */
-  public static merge<T>(
-    delta1: Delta<T>,
-    delta2: Delta<T>,
-    delta3: Delta<T> = Delta.empty(),
-  ) {
-    return Delta.create(
-      { ...delta1.deleted, ...delta2.deleted, ...delta3.deleted },
-      { ...delta1.inserted, ...delta2.inserted, ...delta3.inserted },
-    );
-  }
-
  /**
   * Merges deleted and inserted object partials.
   */
  public static mergeObjects<T extends { [key: string]: unknown }>(
    prev: T,
    added: T,
-    removed: T = {} as T,
+    removed: T,
  ) {
    const cloned = { ...prev };

@@ -510,11 +497,6 @@ export interface DeltaContainer<T> {
   */
  applyTo(previous: T, ...options: unknown[]): [T, boolean];

-  /**
-   * Squashes the current delta with the given one.
-   */
-  squash(delta: DeltaContainer<T>): this;
-
  /**
   * Checks whether all `Delta`s are empty.
   */
@@ -522,11 +504,7 @@ export interface DeltaContainer<T> {
 }

 export class AppStateDelta implements DeltaContainer<AppState> {
-  private constructor(public delta: Delta<ObservedAppState>) {}
-
-  public static create(delta: Delta<ObservedAppState>): AppStateDelta {
-    return new AppStateDelta(delta);
-  }
+  private constructor(public readonly delta: Delta<ObservedAppState>) {}

  public static calculate<T extends ObservedAppState>(
    prevAppState: T,
@@ -557,137 +535,76 @@ export class AppStateDelta implements DeltaContainer<AppState> {
    return new AppStateDelta(inversedDelta);
  }

-  public squash(delta: AppStateDelta): this {
-    if (delta.isEmpty()) {
-      return this;
-    }
-
-    const mergedDeletedSelectedElementIds = Delta.mergeObjects(
-      this.delta.deleted.selectedElementIds ?? {},
-      delta.delta.deleted.selectedElementIds ?? {},
-    );
-
-    const mergedInsertedSelectedElementIds = Delta.mergeObjects(
-      this.delta.inserted.selectedElementIds ?? {},
-      delta.delta.inserted.selectedElementIds ?? {},
-    );
-
-    const mergedDeletedSelectedGroupIds = Delta.mergeObjects(
-      this.delta.deleted.selectedGroupIds ?? {},
-      delta.delta.deleted.selectedGroupIds ?? {},
-    );
-
-    const mergedInsertedSelectedGroupIds = Delta.mergeObjects(
-      this.delta.inserted.selectedGroupIds ?? {},
-      delta.delta.inserted.selectedGroupIds ?? {},
-    );
-
-    const mergedDeletedLockedMultiSelections = Delta.mergeObjects(
-      this.delta.deleted.lockedMultiSelections ?? {},
-      delta.delta.deleted.lockedMultiSelections ?? {},
-    );
-
-    const mergedInsertedLockedMultiSelections = Delta.mergeObjects(
-      this.delta.inserted.lockedMultiSelections ?? {},
-      delta.delta.inserted.lockedMultiSelections ?? {},
-    );
-
-    const mergedInserted: Partial<ObservedAppState> = {};
-    const mergedDeleted: Partial<ObservedAppState> = {};
-
-    if (
-      Object.keys(mergedDeletedSelectedElementIds).length ||
-      Object.keys(mergedInsertedSelectedElementIds).length
-    ) {
-      mergedDeleted.selectedElementIds = mergedDeletedSelectedElementIds;
-      mergedInserted.selectedElementIds = mergedInsertedSelectedElementIds;
-    }
-
-    if (
-      Object.keys(mergedDeletedSelectedGroupIds).length ||
-      Object.keys(mergedInsertedSelectedGroupIds).length
-    ) {
-      mergedDeleted.selectedGroupIds = mergedDeletedSelectedGroupIds;
-      mergedInserted.selectedGroupIds = mergedInsertedSelectedGroupIds;
-    }
-
-    if (
-      Object.keys(mergedDeletedLockedMultiSelections).length ||
-      Object.keys(mergedInsertedLockedMultiSelections).length
-    ) {
-      mergedDeleted.lockedMultiSelections = mergedDeletedLockedMultiSelections;
-      mergedInserted.lockedMultiSelections =
-        mergedInsertedLockedMultiSelections;
-    }
-
-    this.delta = Delta.merge(
-      this.delta,
-      delta.delta,
-      Delta.create(mergedDeleted, mergedInserted),
-    );
-
-    return this;
-  }
-
  public applyTo(
    appState: AppState,
    nextElements: SceneElementsMap,
  ): [AppState, boolean] {
    try {
      const {
-        selectedElementIds: deletedSelectedElementIds = {},
-        selectedGroupIds: deletedSelectedGroupIds = {},
-        lockedMultiSelections: deletedLockedMultiSelections = {},
+        selectedElementIds: removedSelectedElementIds = {},
+        selectedGroupIds: removedSelectedGroupIds = {},
      } = this.delta.deleted;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1268,8 +1196,8 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
    const inverseInternal = (deltas: Record<string, Delta<ElementPartial>>) => {
      const inversedDeltas: Record<string, Delta<ElementPartial>> = {};

-      for (const [id, { inserted, deleted }] of Object.entries(deltas)) {
-        inversedDeltas[id] = Delta.create({ ...inserted }, { ...deleted });
+      for (const [id, delta] of Object.entries(deltas)) {
+        inversedDeltas[id] = Delta.create(delta.inserted, delta.deleted);
      }

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

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

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

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

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

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

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

-  public squash(delta: ElementsDelta): this {
-    if (delta.isEmpty()) {
-      return this;
-    }
-
-    const { added, removed, updated } = delta;
-
-    const mergeBoundElements = (
-      prevDelta: Delta<ElementPartial>,
-      nextDelta: Delta<ElementPartial>,
-    ) => {
-      const mergedDeletedBoundElements =
-        Delta.mergeArrays(
-          prevDelta.deleted.boundElements ?? [],
-          nextDelta.deleted.boundElements ?? [],
-          undefined,
-          (x) => x.id,
-        ) ?? [];
-
-      const mergedInsertedBoundElements =
-        Delta.mergeArrays(
-          prevDelta.inserted.boundElements ?? [],
-          nextDelta.inserted.boundElements ?? [],
-          undefined,
-          (x) => x.id,
-        ) ?? [];
-
-      if (
-        !mergedDeletedBoundElements.length &&
-        !mergedInsertedBoundElements.length
-      ) {
-        return;
-      }
-
-      return Delta.create(
-        {
-          boundElements: mergedDeletedBoundElements,
-        },
-        {
-          boundElements: mergedInsertedBoundElements,
-        },
-      );
-    };
-
-    for (const [id, nextDelta] of Object.entries(added)) {
-      const prevDelta = this.added[id] ?? this.removed[id] ?? this.updated[id];
-
-      if (!prevDelta) {
-        this.added[id] = nextDelta;
-      } else {
-        const mergedDelta = mergeBoundElements(prevDelta, nextDelta);
-        delete this.removed[id];
-        delete this.updated[id];
-
-        this.added[id] = Delta.merge(prevDelta, nextDelta, mergedDelta);
-      }
-    }
-
-    for (const [id, nextDelta] of Object.entries(removed)) {
-      const prevDelta = this.added[id] ?? this.removed[id] ?? this.updated[id];
-
-      if (!prevDelta) {
-        this.removed[id] = nextDelta;
-      } else {
-        const mergedDelta = mergeBoundElements(prevDelta, nextDelta);
-        delete this.added[id];
-        delete this.updated[id];
-
-        this.removed[id] = Delta.merge(prevDelta, nextDelta, mergedDelta);
-      }
-    }
-
-    for (const [id, nextDelta] of Object.entries(updated)) {
-      const prevDelta = this.added[id] ?? this.removed[id] ?? this.updated[id];
-
-      if (!prevDelta) {
-        this.updated[id] = nextDelta;
-      } else {
-        const mergedDelta = mergeBoundElements(prevDelta, nextDelta);
-        const updatedDelta = Delta.merge(prevDelta, nextDelta, mergedDelta);
-
-        if (prevDelta === this.added[id]) {
-          this.added[id] = updatedDelta;
-        } else if (prevDelta === this.removed[id]) {
-          this.removed[id] = updatedDelta;
-        } else {
-          this.updated[id] = updatedDelta;
-        }
-      }
-    }
-
-    if (isTestEnv() || isDevEnv()) {
-      ElementsDelta.validate(this, "added", ElementsDelta.satisfiesAddition);
-      ElementsDelta.validate(this, "removed", ElementsDelta.satisfiesRemoval);
-      ElementsDelta.validate(this, "updated", ElementsDelta.satisfiesUpdate);
-    }
-
-    return this;
-  }
-
  private static createApplier =
    (
-      prevElements: SceneElementsMap,
      nextElements: SceneElementsMap,
      snapshot: StoreSnapshot["elements"],
+      options: ApplyToOptions,
      flags: ApplyToFlags,
-      options?: ApplyToOptions,
    ) =>
    (deltas: Record<string, Delta<ElementPartial>>) => {
      const getElement = ElementsDelta.createGetter(
@@ -1583,26 +1413,15 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
        const element = getElement(id, delta.inserted);

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

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

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

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

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

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

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

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

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

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

      nextAffectedElements.set(affectedElement.id, affectedElement);
@@ -1821,12 +1624,25 @@ export class ElementsDelta implements DeltaContainer<SceneElementsMap> {
      Array.from(prevElements).filter(([id]) => nextAffectedElements.has(id)),
    );

-    // calculate complete deltas for affected elements, and squash them back to the current deltas
-    this.squash(
-      // technically we could do better here if perf. would become an issue
-      ElementsDelta.calculate(prevAffectedElements, nextAffectedElements),
+    // calculate complete deltas for affected elements, and assign them back to all the deltas
+    // technically we could do better here if perf. would become an issue
+    const { added, removed, updated } = ElementsDelta.calculate(
+      prevAffectedElements,
+      nextAffectedElements,
    );

+    for (const [id, delta] of Object.entries(added)) {
+      this.added[id] = delta;
+    }
+
+    for (const [id, delta] of Object.entries(removed)) {
+      this.removed[id] = delta;
+    }
+
+    for (const [id, delta] of Object.entries(updated)) {
+      this.updated[id] = delta;
+    }
+
    return nextAffectedElements;
  }

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

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

@@ -133,13 +133,9 @@ const distanceToEllipseElement = (

 const distanceToLinearOrFreeDraElement = (
  element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement,
-  elementsMap: ElementsMap,
  p: GlobalPoint,
 ) => {
-  const [lines, curves] = deconstructLinearOrFreeDrawElement(
-    element,
-    elementsMap,
-  );
+  const [lines, curves] = deconstructLinearOrFreeDrawElement(element);
  return Math.min(
    ...lines.map((s) => distanceToLineSegment(p, s)),
    ...curves.map((a) => curvePointDistance(a, p)),
@@ -1,12 +1,10 @@
 import type { AppState } from "@excalidraw/excalidraw/types";

-import { updateBoundElements } from "./binding";
 import { getCommonBoundingBox } from "./bounds";
+import { newElementWith } from "./mutateElement";

 import { getSelectedElementsByGroup } from "./groups";

-import type { Scene } from "./Scene";
-
 import type { ElementsMap, ExcalidrawElement } from "./types";

 export interface Distribution {
@@ -19,7 +17,6 @@ export const distributeElements = (
  elementsMap: ElementsMap,
  distribution: Distribution,
  appState: Readonly<AppState>,
-  scene: Scene,
 ): ExcalidrawElement[] => {
  const [start, mid, end, extent] =
    distribution.axis === "x"
@@ -69,16 +66,12 @@ export const distributeElements = (
        translation[distribution.axis] = pos - box[mid];
      }

-      return group.map((element) => {
-        const updatedElement = scene.mutateElement(element, {
+      return group.map((element) =>
+        newElementWith(element, {
          x: element.x + translation.x,
          y: element.y + translation.y,
-        });
-        updateBoundElements(element, scene, {
-          simultaneouslyUpdated: group,
-        });
-        return updatedElement;
-      });
+        }),
+      );
    });
  }

@@ -97,15 +90,11 @@ export const distributeElements = (
    pos += step;
    pos += box[extent];

-    return group.map((element) => {
-      const updatedElement = scene.mutateElement(element, {
+    return group.map((element) =>
+      newElementWith(element, {
        x: element.x + translation.x,
        y: element.y + translation.y,
-      });
-      updateBoundElements(element, scene, {
-        simultaneouslyUpdated: group,
-      });
-      return updatedElement;
-    });
+      }),
+    );
  });
 };
@@ -1,9 +1,7 @@
 import {
-  type Bounds,
  TEXT_AUTOWRAP_THRESHOLD,
  getGridPoint,
  getFontString,
-  DRAGGING_THRESHOLD,
 } from "@excalidraw/common";

 import type {
@@ -15,7 +13,7 @@ import type {

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

-import { unbindBindingElement, updateBoundElements } from "./binding";
+import { updateBoundElements } from "./binding";
 import { getCommonBounds } from "./bounds";
 import { getPerfectElementSize } from "./sizeHelpers";
 import { getBoundTextElement } from "./textElement";
@@ -30,6 +28,7 @@ import {

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

+import type { Bounds } from "./bounds";
 import type { ExcalidrawElement } from "./types";

 export const dragSelectedElements = (
@@ -103,26 +102,9 @@ export const dragSelectedElements = (
    gridSize,
  );

-  const elementsToUpdateIds = new Set(
-    Array.from(elementsToUpdate, (el) => el.id),
-  );
-
  elementsToUpdate.forEach((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);
-
+    updateElementCoords(pointerDownState, element, scene, adjustedOffset);
    if (!isArrowElement(element)) {
-      updateElementCoords(pointerDownState, element, scene, adjustedOffset);
-
      // skip arrow labels since we calculate its position during render
      const textElement = getBoundTextElement(
        element,
@@ -139,33 +121,6 @@ export const dragSelectedElements = (
      updateBoundElements(element, scene, {
        simultaneouslyUpdated: Array.from(elementsToUpdate),
      });
-    } else if (
-      // 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 ||
-      (!element.startBinding && !element.endBinding)
-    ) {
-      updateElementCoords(pointerDownState, element, scene, adjustedOffset);
-
-      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
-        // the arrow outside a filled shape suddenly forcing the arrow start
-        // and end point to jump "outside" the shape.
-        if (shouldUnbindStart) {
-          unbindBindingElement(element, "start", scene);
-        }
-        if (shouldUnbindEnd) {
-          unbindBindingElement(element, "end", scene);
-        }
-      }
    }
  });
 };
@@ -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) => {
@@ -14,10 +14,10 @@ import {
 } from "@excalidraw/math";

 import {
-  type Bounds,
  BinaryHeap,
  invariant,
  isAnyTrue,
+  tupleToCoors,
  getSizeFromPoints,
  isDevEnv,
  arrayToMap,
@@ -27,11 +27,10 @@ import type { AppState } from "@excalidraw/excalidraw/types";

 import {
  bindPointToSnapToElementOutline,
+  FIXED_BINDING_DISTANCE,
  getHeadingForElbowArrowSnap,
  getGlobalFixedPointForBindableElement,
-  getBindingGap,
-  maxBindingDistance_simple,
-  BASE_BINDING_GAP_ELBOW,
+  getHoveredElementForBinding,
 } from "./binding";
 import { distanceToElement } from "./distance";
 import {
@@ -52,9 +51,10 @@ import {
  type ExcalidrawElbowArrowElement,
  type NonDeletedSceneElementsMap,
 } from "./types";
-import { aabbForElement, pointInsideBounds } from "./bounds";
-import { getHoveredElementForBinding } from "./collision";

+import { aabbForElement, pointInsideBounds } from "./bounds";
+
+import type { Bounds } from "./bounds";
 import type { Heading } from "./heading";
 import type {
  Arrowhead,
@@ -63,7 +63,6 @@ import type {
  FixedPointBinding,
  FixedSegment,
  NonDeletedExcalidrawElement,
-  Ordered,
 } from "./types";

 type GridAddress = [number, number] & { _brand: "gridaddress" };
@@ -360,12 +359,6 @@ const handleSegmentRelease = (
    null,
  );

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

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

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

  // Calculate the moving second to last point connection
  {
-    const secondToLastPoint = globalUpdatedPoints.at(
-      globalUpdatedPoints.length - (endIsSpecial ? 3 : 2),
-    );
-    const thirdToLastPoint = globalUpdatedPoints.at(
-      globalUpdatedPoints.length - (endIsSpecial ? 4 : 3),
-    );
-
-    if (!secondToLastPoint || !thirdToLastPoint) {
-      throw new Error(
-        `Second and third to last points must exist when handling endpoint drag (${endIsSpecial})`,
-      );
-    }
-
+    const secondToLastPoint =
+      globalUpdatedPoints[globalUpdatedPoints.length - (endIsSpecial ? 3 : 2)];
+    const thirdToLastPoint =
+      globalUpdatedPoints[globalUpdatedPoints.length - (endIsSpecial ? 4 : 3)];
    const endIsHorizontal = headingIsHorizontal(endHeading);
    const secondIsHorizontal = headingForPointIsHorizontal(
      thirdToLastPoint,
@@ -915,8 +892,6 @@ export const updateElbowArrowPoints = (
  },
  options?: {
    isDragging?: boolean;
-    isBindingEnabled?: boolean;
-    isMidpointSnappingEnabled?: boolean;
  },
 ): ElementUpdate<ExcalidrawElbowArrowElement> => {
  if (arrow.points.length < 2) {
@@ -1204,8 +1179,6 @@ const getElbowArrowData = (
  options?: {
    isDragging?: boolean;
    zoom?: AppState["zoom"];
-    isBindingEnabled?: boolean;
-    isMidpointSnappingEnabled?: boolean;
  },
 ) => {
  const origStartGlobalPoint: GlobalPoint = pointTranslate<
@@ -1219,7 +1192,7 @@ const getElbowArrowData = (

  let hoveredStartElement = null;
  let hoveredEndElement = null;
-  if (options?.isDragging && options?.isBindingEnabled !== false) {
+  if (options?.isDragging) {
    const elements = Array.from(elementsMap.values());
    hoveredStartElement =
      getHoveredElement(
@@ -1248,7 +1221,6 @@ const getElbowArrowData = (
  const startGlobalPoint = getGlobalPoint(
    {
      ...arrow,
-      angle: 0,
      type: "arrow",
      elbowed: true,
      points: nextPoints,
@@ -1259,13 +1231,10 @@ const getElbowArrowData = (
    hoveredStartElement,
    elementsMap,
    options?.isDragging,
-    options?.isBindingEnabled,
-    options?.isMidpointSnappingEnabled,
  );
  const endGlobalPoint = getGlobalPoint(
    {
      ...arrow,
-      angle: 0,
      type: "arrow",
      elbowed: true,
      points: nextPoints,
@@ -1276,8 +1245,6 @@ const getElbowArrowData = (
    hoveredEndElement,
    elementsMap,
    options?.isDragging,
-    options?.isBindingEnabled,
-    options?.isMidpointSnappingEnabled,
  );
  const startHeading = getBindPointHeading(
    startGlobalPoint,
@@ -1285,7 +1252,6 @@ const getElbowArrowData = (
    hoveredStartElement,
    origStartGlobalPoint,
    elementsMap,
-    options?.zoom,
  );
  const endHeading = getBindPointHeading(
    endGlobalPoint,
@@ -1293,7 +1259,6 @@ const getElbowArrowData = (
    hoveredEndElement,
    origEndGlobalPoint,
    elementsMap,
-    options?.zoom,
  );
  const startPointBounds = [
    startGlobalPoint[0] - 2,
@@ -1314,8 +1279,8 @@ const getElbowArrowData = (
        offsetFromHeading(
          startHeading,
          arrow.startArrowhead
-            ? getBindingGap(hoveredStartElement, { elbowed: true }) * 6
-            : getBindingGap(hoveredStartElement, { elbowed: true }) * 2,
+            ? FIXED_BINDING_DISTANCE * 6
+            : FIXED_BINDING_DISTANCE * 2,
          1,
        ),
      )
@@ -1327,8 +1292,8 @@ const getElbowArrowData = (
        offsetFromHeading(
          endHeading,
          arrow.endArrowhead
-            ? getBindingGap(hoveredEndElement, { elbowed: true }) * 6
-            : getBindingGap(hoveredEndElement, { elbowed: true }) * 2,
+            ? FIXED_BINDING_DISTANCE * 6
+            : FIXED_BINDING_DISTANCE * 2,
          1,
        ),
      )
@@ -1375,8 +1340,8 @@ const getElbowArrowData = (
            ? 0
            : BASE_PADDING -
                (arrow.startArrowhead
-                  ? BASE_BINDING_GAP_ELBOW * 6
-                  : BASE_BINDING_GAP_ELBOW * 2),
+                  ? FIXED_BINDING_DISTANCE * 6
+                  : FIXED_BINDING_DISTANCE * 2),
          BASE_PADDING,
        ),
    boundsOverlap
@@ -1391,8 +1356,8 @@ const getElbowArrowData = (
            ? 0
            : BASE_PADDING -
                (arrow.endArrowhead
-                  ? BASE_BINDING_GAP_ELBOW * 6
-                  : BASE_BINDING_GAP_ELBOW * 2),
+                  ? FIXED_BINDING_DISTANCE * 6
+                  : FIXED_BINDING_DISTANCE * 2),
          BASE_PADDING,
        ),
    boundsOverlap,
@@ -2106,7 +2071,16 @@ const normalizeArrowElementUpdate = (
  nextFixedSegments: readonly FixedSegment[] | null,
  startIsSpecial?: ExcalidrawElbowArrowElement["startIsSpecial"],
  endIsSpecial?: ExcalidrawElbowArrowElement["startIsSpecial"],
-): ElementUpdate<ExcalidrawElbowArrowElement> => {
+): {
+  points: LocalPoint[];
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  fixedSegments: readonly FixedSegment[] | null;
+  startIsSpecial?: ExcalidrawElbowArrowElement["startIsSpecial"];
+  endIsSpecial?: ExcalidrawElbowArrowElement["startIsSpecial"];
+} => {
  const offsetX = global[0][0];
  const offsetY = global[0][1];
  let points = global.map((p) =>
@@ -2124,8 +2098,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(
@@ -2221,18 +2195,14 @@ const getGlobalPoint = (
  element?: ExcalidrawBindableElement | null,
  elementsMap?: ElementsMap,
  isDragging?: boolean,
-  isBindingEnabled = true,
-  isMidpointSnappingEnabled = true,
 ): GlobalPoint => {
  if (isDragging) {
-    if (isBindingEnabled && element && elementsMap) {
+    if (element && elementsMap) {
      return bindPointToSnapToElementOutline(
        arrow,
        element,
        startOrEnd,
        elementsMap,
-        undefined,
-        isMidpointSnappingEnabled,
      );
    }

@@ -2256,7 +2226,6 @@ const getBindPointHeading = (
  hoveredElement: ExcalidrawBindableElement | null | undefined,
  origPoint: GlobalPoint,
  elementsMap: ElementsMap,
-  zoom?: AppState["zoom"],
 ): Heading =>
  getHeadingForElbowArrowSnap(
    p,
@@ -2275,20 +2244,21 @@ const getBindPointHeading = (
      ),
    origPoint,
    elementsMap,
-    zoom,
  );

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

@@ -56,7 +56,7 @@ const RE_REDDIT =
 const RE_REDDIT_EMBED =
  /^<blockquote[\s\S]*?\shref=["'](https?:\/\/(?:www\.)?reddit\.com\/[^"']*)/i;

-const parseYouTubeLikeTimestamp = (url: string): number => {
+const parseYouTubeTimestamp = (url: string): number => {
  let timeParam: string | null | undefined;

  try {
@@ -85,57 +85,11 @@ const parseYouTubeLikeTimestamp = (url: string): number => {
  return parseInt(hours) * 3600 + parseInt(minutes) * 60 + parseInt(seconds);
 };

-const parseGoogleDriveVideoLink = (
-  url: string,
-): { fileId: string; resourceKey?: string; timestamp?: number } | null => {
-  try {
-    const urlObj = new URL(url.startsWith("http") ? url : `https://${url}`);
-    const hostname = urlObj.hostname.replace(/^www\./, "");
-    if (hostname !== "drive.google.com") {
-      return null;
-    }
-
-    let fileId: string | null = null;
-    const pathMatch = urlObj.pathname.match(/^\/file\/d\/([^/]+)(?:\/|$)/);
-    if (pathMatch?.[1]) {
-      fileId = pathMatch[1];
-    } else if (urlObj.pathname === "/open" || urlObj.pathname === "/uc") {
-      // Shared Drive links can be emitted as:
-      // - /open?id=<fileId> (common "open in Drive" format)
-      // - /uc?...&id=<fileId> (download/export endpoint often seen in copied links)
-      fileId = urlObj.searchParams.get("id");
-    }
-
-    if (!fileId || !/^[a-zA-Z0-9_-]+$/.test(fileId)) {
-      return null;
-    }
-
-    // Some Drive share links include `resourcekey` for access to link-shared
-    // files; preserve it in the preview URL so embeds keep working.
-    const resourceKey = urlObj.searchParams.get("resourcekey");
-    const timestamp = parseYouTubeLikeTimestamp(urlObj.toString());
-
-    return {
-      fileId,
-      resourceKey:
-        resourceKey && /^[a-zA-Z0-9_-]+$/.test(resourceKey)
-          ? resourceKey
-          : undefined,
-      // Drive accepts YouTube-like `t` formats (e.g. `t=90`, `t=1m30s`);
-      // normalize to seconds for a stable preview URL.
-      timestamp: timestamp > 0 ? timestamp : undefined,
-    };
-  } catch (error) {
-    return null;
-  }
-};
-
 const ALLOWED_DOMAINS = new Set([
  "youtube.com",
  "youtu.be",
  "vimeo.com",
  "player.vimeo.com",
-  "drive.google.com",
  "figma.com",
  "link.excalidraw.com",
  "gist.github.com",
@@ -154,7 +108,6 @@ const ALLOW_SAME_ORIGIN = new Set([
  "youtu.be",
  "vimeo.com",
  "player.vimeo.com",
-  "drive.google.com",
  "figma.com",
  "twitter.com",
  "x.com",
@@ -189,7 +142,7 @@ export const getEmbedLink = (
  let aspectRatio = { w: 560, h: 840 };
  const ytLink = link.match(RE_YOUTUBE);
  if (ytLink?.[2]) {
-    const startTime = parseYouTubeLikeTimestamp(originalLink);
+    const startTime = parseYouTubeTimestamp(originalLink);
    const time = startTime > 0 ? `&start=${startTime}` : ``;
    const isPortrait = link.includes("shorts");
    type = "video";
@@ -248,36 +201,6 @@ export const getEmbedLink = (
    };
  }

-  const googleDriveVideo = parseGoogleDriveVideoLink(link);
-  if (googleDriveVideo) {
-    type = "video";
-    const searchParams = new URLSearchParams();
-    if (googleDriveVideo.resourceKey) {
-      searchParams.set("resourcekey", googleDriveVideo.resourceKey);
-    }
-    if (googleDriveVideo.timestamp) {
-      searchParams.set("t", `${googleDriveVideo.timestamp}`);
-    }
-
-    const search = searchParams.toString();
-    link = `https://drive.google.com/file/d/${googleDriveVideo.fileId}/preview${
-      search ? `?${search}` : ""
-    }`;
-    aspectRatio = { w: 560, h: 315 };
-    embeddedLinkCache.set(originalLink, {
-      link,
-      intrinsicSize: aspectRatio,
-      type,
-      sandbox: { allowSameOrigin },
-    });
-    return {
-      link,
-      intrinsicSize: aspectRatio,
-      type,
-      sandbox: { allowSameOrigin },
-    };
-  }
-
  const figmaLink = link.match(RE_FIGMA);
  if (figmaLink) {
    type = "generic";
@@ -7,7 +7,7 @@ import type {
  PendingExcalidrawElements,
 } from "@excalidraw/excalidraw/types";

-import { bindBindingElement } from "./binding";
+import { bindLinearElement } from "./binding";
 import { updateElbowArrowPoints } from "./elbowArrow";
 import {
  HEADING_DOWN,
@@ -446,14 +446,8 @@ const createBindingArrow = (

  const elementsMap = scene.getNonDeletedElementsMap();

-  bindBindingElement(
-    bindingArrow,
-    startBindingElement,
-    "orbit",
-    "start",
-    scene,
-  );
-  bindBindingElement(bindingArrow, endBindingElement, "orbit", "end", scene);
+  bindLinearElement(bindingArrow, startBindingElement, "start", scene);
+  bindLinearElement(bindingArrow, endBindingElement, "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,9 +1,7 @@
 import { arrayToMap } from "@excalidraw/common";
-import {
-  isPointWithinBounds,
-  pointFrom,
-  segmentsIntersectAt,
-} from "@excalidraw/math";
+import { isPointWithinBounds, pointFrom } from "@excalidraw/math";
+import { doLineSegmentsIntersect } from "@excalidraw/utils/bbox";
+import { elementsOverlappingBBox } from "@excalidraw/utils/withinBounds";

 import type {
  AppClassProperties,
@@ -20,13 +18,9 @@ import {
  getElementLineSegments,
  getCommonBounds,
  getElementAbsoluteCoords,
-  doBoundsIntersect,
-  getElementBounds,
-  boundsContainBounds,
 } from "./bounds";
 import { mutateElement } from "./mutateElement";
 import { getBoundTextElement, getContainerElement } from "./textElement";
-import { syncMovedIndices } from "./fractionalIndex";
 import {
  isFrameElement,
  isFrameLikeElement,
@@ -81,7 +75,7 @@ export function isElementIntersectingFrame(

  const intersecting = frameLineSegments.some((frameLineSegment) =>
    elementLineSegments.some((elementLineSegment) =>
-      segmentsIntersectAt(frameLineSegment, elementLineSegment),
+      doLineSegmentsIntersect(frameLineSegment, elementLineSegment),
    ),
  );

@@ -106,9 +100,8 @@ export const isElementContainingFrame = (
  frame: ExcalidrawFrameLikeElement,
  elementsMap: ElementsMap,
 ) => {
-  return boundsContainBounds(
-    getElementBounds(element, elementsMap),
-    getElementBounds(frame, elementsMap),
+  return getElementsWithinSelection([frame], element, elementsMap).some(
+    (e) => e.id === frame.id,
  );
 };

@@ -495,44 +488,10 @@ export const filterElementsEligibleAsFrameChildren = (
  return eligibleElements;
 };

-export const getCommonFrameId = (elements: readonly ExcalidrawElement[]) => {
-  let commonFrameId: ExcalidrawElement["frameId"] | undefined;
-
-  for (const element of elements) {
-    if (isFrameLikeElement(element) || !element.frameId) {
-      return null;
-    }
-
-    if (commonFrameId === undefined) {
-      commonFrameId = element.frameId;
-    } else if (commonFrameId !== element.frameId) {
-      return null;
-    }
-  }
-
-  return commonFrameId ?? null;
-};
-
-export const getFrameChildrenInsertionIndex = (
-  elements: readonly ExcalidrawElement[],
-  frameId: ExcalidrawFrameLikeElement["id"],
-): number | null => {
-  for (let index = elements.length - 1; index >= 0; index--) {
-    const element = elements[index];
-
-    if (element.id === frameId) {
-      return index;
-    } else if (element.frameId === frameId) {
-      return index + 1;
-    }
-  }
-
-  return null;
-};
-
 /**
- * Adds elements and their bound elements to frame. Reorders added elements to
- * be just below frame, or just above its highest child (whichever is higher).
+ * Retains (or repairs for target frame) the ordering invriant where children
+ * elements come right before the parent frame:
+ * [el, el, child, child, frame, el]
 *
 * @returns mutated allElements (same data structure)
 */
@@ -540,11 +499,19 @@ export const addElementsToFrame = <T extends ElementsMapOrArray>(
  allElements: T,
  elementsToAdd: NonDeletedExcalidrawElement[],
  frame: ExcalidrawFrameLikeElement,
+  appState: AppState,
 ): T => {
  const elementsMap = arrayToMap(allElements);
-  const commonFrameId = getCommonFrameId(elementsToAdd);
+  const currTargetFrameChildrenMap = new Map<ExcalidrawElement["id"], true>();
+  for (const element of allElements.values()) {
+    if (element.frameId === frame.id) {
+      currTargetFrameChildrenMap.set(element.id, true);
+    }
+  }

-  const finalElementsToAdd = new Set<ExcalidrawElement>();
+  const suppliedElementsToAddSet = new Set(elementsToAdd.map((el) => el.id));
+
+  const finalElementsToAdd: ExcalidrawElement[] = [];

  const otherFrames = new Set<ExcalidrawFrameLikeElement["id"]>();

@@ -555,8 +522,7 @@ export const addElementsToFrame = <T extends ElementsMapOrArray>(
  }

  // - add bound text elements if not already in the array
-  // - keep elements already in the frame so mixed selections can be reordered
-  //   together
+  // - filter out elements that are already in the frame
  for (const element of omitGroupsContainingFrameLikes(
    allElements,
    elementsToAdd,
@@ -569,64 +535,38 @@ export const addElementsToFrame = <T extends ElementsMapOrArray>(
      continue;
    }

-    finalElementsToAdd.add(element);
+    // if the element is already in another frame (which is also in elementsToAdd),
+    // it means that frame and children are selected at the same time
+    // => keep original frame membership, do not add to the target frame
+    if (
+      element.frameId &&
+      appState.selectedElementIds[element.id] &&
+      appState.selectedElementIds[element.frameId]
+    ) {
+      continue;
+    }
+
+    if (!currTargetFrameChildrenMap.has(element.id)) {
+      finalElementsToAdd.push(element);
+    }

    const boundTextElement = getBoundTextElement(element, elementsMap);
-    if (boundTextElement && !finalElementsToAdd.has(boundTextElement)) {
-      finalElementsToAdd.add(boundTextElement);
+    if (
+      boundTextElement &&
+      !suppliedElementsToAddSet.has(boundTextElement.id) &&
+      !currTargetFrameChildrenMap.has(boundTextElement.id)
+    ) {
+      finalElementsToAdd.push(boundTextElement);
    }
  }

  for (const element of finalElementsToAdd) {
-    // we don't always need to update the element if it's already in the frame,
-    // but we still need to accumulate in finalElementsToAdd so we potentially
-    // reorder them if added together
-    if (element.frameId !== frame.id) {
-      mutateElement(element, elementsMap, {
-        frameId: frame.id,
-      });
-    }
+    mutateElement(element, elementsMap, {
+      frameId: frame.id,
+    });
  }

-  // (re)order elements to be just below the frame,
-  // or just above the highest child if that is higher
-  // (latter case is denormalized order until we migrate)
-  // ---------------------------------------------------------------------------
-
-  if (
-    !finalElementsToAdd.size ||
-    // if all elements to add already belong to the frame, then we don't want to
-    // reorder (case: we're dragging element children within the frame)
-    commonFrameId === frame.id
-  ) {
-    return allElements;
-  }
-
-  const otherElements = Array.from(allElements.values()).filter(
-    (element) => !finalElementsToAdd.has(element),
-  );
-  const insertionIndex = getFrameChildrenInsertionIndex(
-    otherElements,
-    frame.id,
-  );
-
-  if (insertionIndex === null) {
-    return allElements;
-  }
-
-  const reorderedElements = [
-    ...otherElements.slice(0, insertionIndex),
-    ...finalElementsToAdd,
-    ...otherElements.slice(insertionIndex),
-  ];
-
-  syncMovedIndices(reorderedElements, arrayToMap([...finalElementsToAdd]));
-
-  return (
-    Array.isArray(allElements)
-      ? reorderedElements
-      : new Map(reorderedElements.map((element) => [element.id, element]))
-  ) as T;
+  return allElements;
 };

 export const removeElementsFromFrame = (
@@ -680,11 +620,13 @@ export const replaceAllElementsInFrame = <T extends ExcalidrawElement>(
  allElements: readonly T[],
  nextElementsInFrame: ExcalidrawElement[],
  frame: ExcalidrawFrameLikeElement,
+  app: AppClassProperties,
 ): T[] => {
  return addElementsToFrame(
    removeAllElementsFromFrame(allElements, frame),
    nextElementsInFrame,
    frame,
+    app.state,
  ).slice();
 };

@@ -978,17 +920,16 @@ export const getFrameLikeTitle = (element: ExcalidrawFrameLikeElement) => {
 export const getElementsOverlappingFrame = (
  elements: readonly ExcalidrawElement[],
  frame: ExcalidrawFrameLikeElement,
-  elementsMap: ElementsMap,
 ) => {
-  return elements.filter(
-    (el) =>
-      // exclude elements which are overlapping, but are in a different frame,
+  return (
+    elementsOverlappingBBox({
+      elements,
+      bounds: frame,
+      type: "overlap",
+    })
+      // removes elements who are overlapping, but are in a different frame,
      // and thus invisible in target frame
-      (!el.frameId || el.frameId === frame.id) &&
-      doBoundsIntersect(
-        getElementBounds(el, elementsMap),
-        getElementBounds(frame, elementsMap),
-      ),
+      .filter((el) => !el.frameId || el.frameId === frame.id)
  );
 };

@@ -1,9 +1,4 @@
-import {
-  invariant,
-  isDevEnv,
-  isTestEnv,
-  type Bounds,
-} from "@excalidraw/common";
+import { invariant, isDevEnv, isTestEnv } from "@excalidraw/common";

 import {
  pointFrom,
@@ -24,7 +19,7 @@ import type {
  Vector,
 } from "@excalidraw/math";

-import { getCenterForBounds } from "./bounds";
+import { getCenterForBounds, type Bounds } from "./bounds";

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

@@ -1,6 +1,7 @@
 import { toIterable } from "@excalidraw/common";

 import { isInvisiblySmallElement } from "./sizeHelpers";
+import { isLinearElementType } from "./typeChecks";

 import type {
  ExcalidrawElement,
@@ -28,9 +29,6 @@ export const hashElementsVersion = (elements: ElementsMapOrArray): number => {

 // string hash function (using djb2). Not cryptographically secure, use only
 // for versioning and such.
-// note: hashes individual code units (not code points),
-// but for hashing purposes this is fine as it iterates through every code unit
-// (as such, no need to encode to byte string first)
 export const hashString = (s: string): number => {
  let hash: number = 5381;
  for (let i = 0; i < s.length; i++) {
@@ -54,6 +52,27 @@ export const isNonDeletedElement = <T extends ExcalidrawElement>(
  element: T,
 ): element is NonDeleted<T> => !element.isDeleted;

+const _clearElements = (
+  elements: readonly ExcalidrawElement[],
+): ExcalidrawElement[] =>
+  getNonDeletedElements(elements).map((element) =>
+    isLinearElementType(element.type)
+      ? { ...element, lastCommittedPoint: null }
+      : element,
+  );
+
+export const clearElementsForDatabase = (
+  elements: readonly ExcalidrawElement[],
+) => _clearElements(elements);
+
+export const clearElementsForExport = (
+  elements: readonly ExcalidrawElement[],
+) => _clearElements(elements);
+
+export const clearElementsForLocalStorage = (
+  elements: readonly ExcalidrawElement[],
+) => _clearElements(elements);
+
 export * from "./align";
 export * from "./binding";
 export * from "./bounds";
@@ -70,7 +89,6 @@ export * from "./elbowArrow";
 export * from "./elementLink";
 export * from "./embeddable";
 export * from "./flowchart";
-export * from "./arrows/focus";
 export * from "./fractionalIndex";
 export * from "./frame";
 export * from "./groups";
@@ -79,7 +97,6 @@ export * from "./image";
 export * from "./linearElementEditor";
 export * from "./mutateElement";
 export * from "./newElement";
-export * from "./positionElementsOnGrid";
 export * from "./renderElement";
 export * from "./resizeElements";
 export * from "./resizeTest";
@@ -93,10 +110,7 @@ export * from "./store";
 export * from "./textElement";
 export * from "./textMeasurements";
 export * from "./textWrapping";
-export * from "./transform";
 export * from "./transformHandles";
 export * from "./typeChecks";
 export * from "./utils";
 export * from "./zindex";
-export * from "./arrows/helpers";
-export * from "./arrowheads";
--- a/Show More
+++ b/Show More